blob: d86ca2b79b494e35c69314128f5ef597e777a77f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
/*
* Copyright (C) 2005-2018 Team Kodi
* This file is part of Kodi - https://kodi.tv
*
* SPDX-License-Identifier: GPL-2.0-or-later
* See LICENSES/README.md for more information.
*/
#pragma once
#include <string>
#include <vector>
#include "system_gl.h"
namespace Shaders {
//////////////////////////////////////////////////////////////////////
// CShader - base class
//////////////////////////////////////////////////////////////////////
class CShader
{
public:
CShader() = default;
virtual ~CShader() = default;
virtual bool Compile() = 0;
virtual void Free() = 0;
virtual GLuint Handle() = 0;
virtual void SetSource(const std::string& src) { m_source = src; }
virtual bool LoadSource(const std::string& filename, const std::string& prefix = "");
virtual bool AppendSource(const std::string& filename);
virtual bool InsertSource(const std::string& filename, const std::string& loc);
bool OK() const { return m_compiled; }
std::string GetName() const { return m_filenames; }
std::string GetSourceWithLineNumbers() const;
protected:
std::string m_source;
std::string m_lastLog;
std::vector<std::string> m_attr;
bool m_compiled = false;
private:
std::string m_filenames;
};
//////////////////////////////////////////////////////////////////////
// CVertexShader - vertex shader class
//////////////////////////////////////////////////////////////////////
class CVertexShader : public CShader
{
public:
CVertexShader() = default;
~CVertexShader() override { Free(); }
void Free() override {}
GLuint Handle() override { return m_vertexShader; }
protected:
GLuint m_vertexShader = 0;
};
class CGLSLVertexShader : public CVertexShader
{
public:
void Free() override;
bool Compile() override;
};
//////////////////////////////////////////////////////////////////////
// CPixelShader - abstract pixel shader class
//////////////////////////////////////////////////////////////////////
class CPixelShader : public CShader
{
public:
CPixelShader() = default;
~CPixelShader() override { Free(); }
void Free() override {}
GLuint Handle() override { return m_pixelShader; }
protected:
GLuint m_pixelShader = 0;
};
class CGLSLPixelShader : public CPixelShader
{
public:
void Free() override;
bool Compile() override;
};
//////////////////////////////////////////////////////////////////////
// CShaderProgram - the complete shader consisting of both the vertex
// and pixel programs. (abstract)
//////////////////////////////////////////////////////////////////////
class CShaderProgram
{
public:
CShaderProgram() = default;
virtual ~CShaderProgram()
{
delete m_pFP;
delete m_pVP;
}
// enable the shader
virtual bool Enable() = 0;
// disable the shader
virtual void Disable() = 0;
// returns true if shader is compiled and linked
bool OK() const { return m_ok; }
// return the vertex shader object
CVertexShader* VertexShader() { return m_pVP; }
// return the pixel shader object
CPixelShader* PixelShader() { return m_pFP; }
// compile and link the shaders
virtual bool CompileAndLink() = 0;
// override to perform custom tasks on successful compilation
// and linkage. E.g. obtaining handles to shader attributes.
virtual void OnCompiledAndLinked() {}
// override to perform custom tasks before shader is enabled
// and after it is disabled. Return false in OnDisabled() to
// disable shader.
// E.g. setting attributes, disabling texture unites, etc
virtual bool OnEnabled() { return true; }
virtual void OnDisabled() { }
virtual GLuint ProgramHandle() { return m_shaderProgram; }
protected:
CVertexShader* m_pVP = nullptr;
CPixelShader* m_pFP = nullptr;
GLuint m_shaderProgram = 0;
bool m_ok = false;
};
class CGLSLShaderProgram : virtual public CShaderProgram
{
public:
CGLSLShaderProgram();
CGLSLShaderProgram(const std::string& vert
, const std::string& frag);
~CGLSLShaderProgram() override;
// enable the shader
bool Enable() override;
// disable the shader
void Disable() override;
// compile and link the shaders
bool CompileAndLink() override;
protected:
void Free();
GLint m_lastProgram;
bool m_validated = false;
};
} // close namespace
|
