← Back to branch summary

~ubuntu-branches/debian/wheezy/gource/wheezy

« back to all changes in this revision

Viewing changes to src/core/shader.h

  • Committer: Package Import Robot
  • Author(s): Andrew Caudwell
  • Date: 2012-04-24 11:25:45 UTC
  • mfrom: (1.2.13)
  • Revision ID: package-import@ubuntu.com-20120424112545-18fbnycu9xrsl4s5
Tags: 0.38-1
http://bugs.debian.org/667189
* New upstream release (closes: #667189)
* New build dependencies on libglm-dev and libboost-filesystem-dev. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/shader.h
34
34
#include "display.h"
35
35
#include "sdlapp.h"
36
36
#include "regex.h"
 
37
#include "util.h"
37
38
 
 
39
#include <boost/format.hpp>
 
40
#include <list>
38
41
#include <map>
39
42
#include <string>
40
43
#include <fstream>
 
44
#include <sstream>
 
45
 
 
46
enum { SHADER_UNIFORM_FLOAT,
 
47
       SHADER_UNIFORM_BOOL,
 
48
       SHADER_UNIFORM_SAMPLER_1D,
 
49
       SHADER_UNIFORM_SAMPLER_2D,
 
50
       SHADER_UNIFORM_INT,
 
51
       SHADER_UNIFORM_VEC2,
 
52
       SHADER_UNIFORM_VEC3,
 
53
       SHADER_UNIFORM_VEC4,
 
54
       SHADER_UNIFORM_MAT3,
 
55
       SHADER_UNIFORM_MAT4,
 
56
       SHADER_UNIFORM_VEC2_ARRAY,
 
57
       SHADER_UNIFORM_VEC3_ARRAY,
 
58
       SHADER_UNIFORM_VEC4_ARRAY
 
59
};
 
60
 
 
61
class Shader;
 
62
 
 
63
class ShaderUniform {
 
64
protected:
 
65
    std::string name;
 
66
    GLint location;
 
67
    Shader* shader;
 
68
    int uniform_type;
 
69
    std::string type_name;
 
70
    bool modified;
 
71
    bool initialized;
 
72
    bool baked;
 
73
public:
 
74
 
 
75
    ShaderUniform(Shader* shader, const std::string& name, int uniform_type, const std::string& type_name);
 
76
 
 
77
    virtual void unload();
 
78
 
 
79
    int getType() { return uniform_type; };
 
80
 
 
81
    virtual void write(std::string& content) const {};
 
82
 
 
83
    const std::string& getName() const;
 
84
    bool  isInitialized() const { return initialized; };
 
85
    GLint getLocation();
 
86
 
 
87
    bool isBaked() const    { return baked; };
 
88
    bool isModified() const { return modified; };
 
89
 
 
90
    void setInitialized(bool initialized) { this->initialized = initialized; };
 
91
 
 
92
    virtual void apply() {};
 
93
 
 
94
    virtual void setBaked(bool baked);
 
95
    virtual void setModified(bool modified) { this->modified = modified; };
 
96
};
 
97
 
 
98
class FloatShaderUniform : public ShaderUniform {
 
99
    float value;
 
100
public:
 
101
    FloatShaderUniform(Shader* shader, const std::string& name, float value = 0.0f);
 
102
 
 
103
    void write(std::string& content) const;
 
104
 
 
105
    void apply();
 
106
    void setValue(float value);
 
107
    float getValue() const;
 
108
};
 
109
 
 
110
class IntShaderUniform : public ShaderUniform {
 
111
    int value;
 
112
public:
 
113
    IntShaderUniform(Shader* shader, const std::string& name, int value = 0);
 
114
 
 
115
    void write(std::string& content) const;
 
116
 
 
117
    void apply();
 
118
    void setValue(int value);
 
119
    float getValue() const;
 
120
};
 
121
 
 
122
class BoolShaderUniform : public ShaderUniform {
 
123
    bool value;
 
124
public:
 
125
    BoolShaderUniform(Shader* shader, const std::string& name, bool value = false);
 
126
 
 
127
    void write(std::string& content) const;
 
128
 
 
129
    void apply();
 
130
    void setValue(bool value);
 
131
    float getValue() const;
 
132
};
 
133
 
 
134
class Sampler1DShaderUniform : public ShaderUniform {
 
135
    int value;
 
136
public:
 
137
    Sampler1DShaderUniform(Shader* shader, const std::string& name, int value = 0);
 
138
 
 
139
    void write(std::string& content) const;
 
140
 
 
141
    void setBaked(bool baked);
 
142
 
 
143
    void apply();
 
144
    void setValue(int value);
 
145
    float getValue() const;
 
146
};
 
147
 
 
148
class Sampler2DShaderUniform : public ShaderUniform {
 
149
    int value;
 
150
public:
 
151
    Sampler2DShaderUniform(Shader* shader, const std::string& name, int value = 0);
 
152
 
 
153
    void write(std::string& content) const;
 
154
 
 
155
    void setBaked(bool baked);
 
156
 
 
157
    void apply();
 
158
    void setValue(int value);
 
159
    float getValue() const;
 
160
};
 
161
 
 
162
class Vec2ShaderUniform : public ShaderUniform {
 
163
    vec2 value;
 
164
public:
 
165
    Vec2ShaderUniform(Shader* shader, const std::string& name, const vec2& value = vec2(0.0f)) ;
 
166
 
 
167
    void write(std::string& content) const;
 
168
 
 
169
    void apply();
 
170
    void setValue(const vec2& value);
 
171
    const vec2& getValue() const;
 
172
};
 
173
 
 
174
class Vec3ShaderUniform : public ShaderUniform {
 
175
    vec3 value;
 
176
public:
 
177
    Vec3ShaderUniform(Shader* shader, const std::string& name, const vec3& value = vec3(0.0f));
 
178
 
 
179
    void write(std::string& content) const;
 
180
 
 
181
    void apply();
 
182
    void setValue(const vec3& value);
 
183
    const vec3& getValue() const;
 
184
};
 
185
 
 
186
class Vec4ShaderUniform : public ShaderUniform {
 
187
    vec4 value;
 
188
public:
 
189
    Vec4ShaderUniform(Shader* shader, const std::string& name, const vec4& value = vec4(0.0f));
 
190
 
 
191
    void write(std::string& content) const;
 
192
 
 
193
    void apply();
 
194
    void setValue(const vec4& value);
 
195
    const vec4& getValue() const;
 
196
};
 
197
 
 
198
class Mat3ShaderUniform : public ShaderUniform {
 
199
    mat3 value;
 
200
public:
 
201
    Mat3ShaderUniform(Shader* shader, const std::string& name, const mat3& value = mat3(1.0f));
 
202
 
 
203
    void write(std::string& content) const;
 
204
 
 
205
    void apply();
 
206
    void setValue(const mat3& value);
 
207
    const mat3& getValue() const;
 
208
};
 
209
 
 
210
class Mat4ShaderUniform : public ShaderUniform {
 
211
    mat4 value;
 
212
public:
 
213
    Mat4ShaderUniform(Shader* shader, const std::string& name, const mat4& value = mat4(1.0f));
 
214
 
 
215
    void write(std::string& content) const;
 
216
 
 
217
    void apply();
 
218
    void setValue(const mat4& value);
 
219
    const mat4& getValue() const;
 
220
};
 
221
 
 
222
class Vec2ArrayShaderUniform : public ShaderUniform {
 
223
    vec2* value;
 
224
    size_t length;
 
225
 
 
226
    void copyValue(const vec2* value);
 
227
    void copyValue(const std::vector<vec2>& value);
 
228
public:
 
229
    Vec2ArrayShaderUniform(Shader* shader, const std::string& name, size_t length, const vec2* value = 0);
 
230
    ~Vec2ArrayShaderUniform();
 
231
 
 
232
    void write(std::string& content) const;
 
233
 
 
234
    void apply();
 
235
 
 
236
    void setValue(const vec2* value);
 
237
    void setValue(const std::vector<vec2>& value);
 
238
 
 
239
    const vec2* getValue() const;
 
240
};
 
241
 
 
242
class Vec3ArrayShaderUniform : public ShaderUniform {
 
243
    vec3* value;
 
244
    size_t length;
 
245
 
 
246
    void copyValue(const vec3* value);
 
247
    void copyValue(const std::vector<vec3>& value);
 
248
public:
 
249
    Vec3ArrayShaderUniform(Shader* shader, const std::string& name, size_t length, const vec3* value = 0);
 
250
    ~Vec3ArrayShaderUniform();
 
251
 
 
252
    void write(std::string& content) const;
 
253
 
 
254
    void apply();
 
255
 
 
256
    void setValue(const vec3* value);
 
257
    void setValue(const std::vector<vec3>& value);
 
258
 
 
259
    const vec3* getValue() const;
 
260
};
 
261
 
 
262
class Vec4ArrayShaderUniform : public ShaderUniform {
 
263
    vec4* value;
 
264
    size_t length;
 
265
 
 
266
    void copyValue(const vec4* value);
 
267
    void copyValue(const std::vector<vec4>& value);
 
268
public:
 
269
    Vec4ArrayShaderUniform(Shader* shader, const std::string& name, size_t length, const vec4* value = 0);
 
270
    ~Vec4ArrayShaderUniform();
 
271
 
 
272
    void write(std::string& content) const;
 
273
 
 
274
    void apply();
 
275
 
 
276
    void setValue(const vec4* value);
 
277
    void setValue(const std::vector<vec4>& value);
 
278
 
 
279
    const vec4* getValue() const;
 
280
};
 
281
 
 
282
class ShaderPass {
 
283
    GLint       shader_object_type;
 
284
    std::string shader_object_desc;
 
285
    GLenum      shader_object;
 
286
 
 
287
    int version;
 
288
    std::map<std::string,std::string> extensions;
 
289
 
 
290
    Shader* parent;
 
291
 
 
292
    std::string source;
 
293
    std::string shader_object_source;
 
294
 
 
295
    std::list<ShaderUniform*> uniforms;
 
296
 
 
297
    bool errorContext(const char* log_message, std::string& context);
 
298
 
 
299
    bool preprocess(const std::string& line);
 
300
public:
 
301
    ShaderPass(Shader* parent, GLint shader_object_type, const std::string& shader_object_desc);
 
302
    virtual ~ShaderPass();
 
303
 
 
304
    GLint getType() { return shader_object_type; };
 
305
 
 
306
    void toString(std::string& out);
 
307
 
 
308
    void unload();
 
309
    void compile();
 
310
 
 
311
    void checkError();
 
312
 
 
313
    ShaderUniform* addArrayUniform(const std::string& name, const std::string& type, size_t length);
 
314
    ShaderUniform* addUniform(const std::string& name, const std::string& type);
 
315
 
 
316
    virtual void attachTo(GLenum program);
 
317
 
 
318
    void includeSource(const std::string& source);
 
319
    void includeFile(const std::string& filename);
 
320
};
 
321
 
 
322
class VertexShader : public ShaderPass {
 
323
public:
 
324
    VertexShader(Shader* parent);
 
325
};
 
326
 
 
327
class FragmentShader : public ShaderPass {
 
328
public:
 
329
    FragmentShader(Shader* parent);
 
330
};
 
331
 
 
332
class GeometryShader : public ShaderPass {
 
333
public:
 
334
    GeometryShader(Shader* parent);
 
335
 
 
336
    void attachTo(GLenum program);
 
337
};
41
338
 
42
339
class Shader : public Resource {
43
340
 
44
 
    std::map<std::string, GLint> varMap;
45
 
 
46
 
    GLenum shaderProg;
47
 
    GLenum vertexShader;
48
 
    GLenum fragmentShader;
49
 
    
50
 
    GLint getVarLocation(const std::string& name);
51
 
 
52
 
    bool preprocess(const std::string& line, std::string& output);
53
 
    bool readSource(const std::string& filename, std::string& output);
54
 
    GLenum load(const std::string& filename, GLenum shaderType);
55
 
    void makeProgram();
56
 
 
57
 
    void checkError(const std::string& filename, GLenum shaderRef);
 
341
    std::map<std::string, ShaderUniform*>  uniforms;
 
342
    std::map<std::string,std::string> substitutions;
 
343
 
 
344
    GLenum program;
 
345
    bool dynamic_compile;
 
346
 
 
347
    void checkProgramError();
 
348
 
 
349
    void setDefaults();
58
350
public:
 
351
    VertexShader*   vertex_shader;
 
352
    GeometryShader* geometry_shader;
 
353
    FragmentShader* fragment_shader;
 
354
 
 
355
    Shader();
59
356
    Shader(const std::string& prefix);
60
357
    ~Shader();
61
358
 
62
359
    GLenum getProgram();
63
 
    GLenum getVertexShader();
64
 
    GLenum getFragmentShader();
65
 
 
 
360
 
 
361
    void clear();
 
362
 
 
363
    void load();
 
364
    void unload();
 
365
 
 
366
    ShaderPass* grabShaderPass(GLenum shader_object_type);
 
367
 
 
368
    void includeSource(GLenum shader_object_type, const std::string& source);
 
369
    void includeFile(GLenum shader_object_type,   const std::string& filename);
 
370
 
 
371
    static void substitute(std::string& source, const std::string& name, const std::string& value);
 
372
 
 
373
    void addSubstitute(const std::string& name, const char *value, ...);
 
374
    void applySubstitutions(std::string& source);
 
375
 
 
376
    void addUniform(ShaderUniform* uniform);
 
377
    ShaderUniform* getUniform(const std::string& name);
 
378
 
 
379
    void setDynamicCompile(bool dynamic_compile);
 
380
    bool needsCompile();
 
381
 
 
382
    void applyUniforms();
 
383
 
 
384
    void setBool(const std::string& name, bool value);
66
385
    void setInteger (const std::string& name, int value);
 
386
    void setSampler1D(const std::string& name, int value);
 
387
    void setSampler2D(const std::string& name, int value);
67
388
    void setFloat(const std::string& name, float value);
68
 
    void setVec2 (const std::string& name, const vec2f& value);
69
 
    void setVec3 (const std::string& name, const vec3f& value);
70
 
    void setVec4 (const std::string& name, const vec4f& value);
 
389
    void setVec2 (const std::string& name, const vec2& value);
 
390
    void setVec3 (const std::string& name, const vec3& value);
 
391
    void setVec4 (const std::string& name, const vec4& value);
 
392
    void setMat3 (const std::string& name, const mat3& value);
 
393
    void setMat4 (const std::string& name, const mat4& value);
 
394
 
 
395
    void setVec2Array(const std::string& name, vec2* value);
 
396
    void setVec2Array(const std::string& name, std::vector<vec2>& value);
 
397
 
 
398
    void setVec3Array(const std::string& name, vec3* value);
 
399
    void setVec3Array(const std::string& name, std::vector<vec3>& value);
 
400
 
 
401
    void setVec4Array(const std::string& name, vec4* value);
 
402
    void setVec4Array(const std::string& name, std::vector<vec4>& value);
 
403
 
 
404
    void setBaked(const std::string& name, bool baked);
 
405
    void setBakedUniforms(bool baked);
 
406
 
 
407
    void bind();
 
408
    void unbind();
71
409
 
72
410
    void use();
73
411
};
74
412
 
75
413
class ShaderManager : public ResourceManager {
76
414
public:
77
 
    bool debug;
78
 
    ShaderManager() {
79
 
        debug = false;
80
 
    }
 
415
    bool warnings;
 
416
 
 
417
    ShaderManager();
81
418
    Shader* grab(const std::string& shader_prefix);
 
419
 
 
420
    void enableWarnings(bool warnings);
 
421
 
 
422
    void manage(Shader* shader);
 
423
 
 
424
    void unload();
 
425
    void reload();
82
426
};
83
427
 
84
428
extern ShaderManager shadermanager;