Change to using GLEW everywhere.
[movit] / effect.cpp
1 #include <stdio.h>
2 #include <string.h>
3 #include <assert.h>
4 #include <GL/glew.h>
5
6 #include "effect.h"
7 #include "effect_chain.h"
8 #include "util.h"
9
10 GLint get_uniform_location(GLuint glsl_program_num, const std::string &prefix, const std::string &key)
11 {
12         std::string name = prefix + "_" + key;
13         return glGetUniformLocation(glsl_program_num, name.c_str());
14 }
15
16 void set_uniform_int(GLuint glsl_program_num, const std::string &prefix, const std::string &key, int value)
17 {
18         GLint location = get_uniform_location(glsl_program_num, prefix, key);
19         if (location == -1) {
20                 return;
21         }
22         check_error();
23         glUniform1i(location, value);
24         check_error();
25 }
26
27 void set_uniform_float(GLuint glsl_program_num, const std::string &prefix, const std::string &key, float value)
28 {
29         GLint location = get_uniform_location(glsl_program_num, prefix, key);
30         if (location == -1) {
31                 return;
32         }
33         check_error();
34         glUniform1f(location, value);
35         check_error();
36 }
37
38 void set_uniform_vec2(GLuint glsl_program_num, const std::string &prefix, const std::string &key, const float *values)
39 {
40         GLint location = get_uniform_location(glsl_program_num, prefix, key);
41         if (location == -1) {
42                 return;
43         }
44         check_error();
45         glUniform2fv(location, 1, values);
46         check_error();
47 }
48
49 void set_uniform_vec3(GLuint glsl_program_num, const std::string &prefix, const std::string &key, const float *values)
50 {
51         GLint location = get_uniform_location(glsl_program_num, prefix, key);
52         if (location == -1) {
53                 return;
54         }
55         check_error();
56         glUniform3fv(location, 1, values);
57         check_error();
58 }
59
60 void set_uniform_vec4_array(GLuint glsl_program_num, const std::string &prefix, const std::string &key, const float *values, size_t num_values)
61 {
62         GLint location = get_uniform_location(glsl_program_num, prefix, key);
63         if (location == -1) {
64                 return;
65         }
66         check_error();
67         glUniform4fv(location, num_values, values);
68         check_error();
69 }
70
71 void set_uniform_mat3(GLuint glsl_program_num, const std::string &prefix, const std::string &key, const Eigen::Matrix3d& matrix)
72 {
73         GLint location = get_uniform_location(glsl_program_num, prefix, key);
74         if (location == -1) {
75                 return;
76         }
77         check_error();
78
79         // Convert to float (GLSL has no double matrices).
80         float matrixf[9];
81         for (unsigned y = 0; y < 3; ++y) {
82                 for (unsigned x = 0; x < 3; ++x) {
83                         matrixf[y + x * 3] = matrix(y, x);
84                 }
85         }
86
87         glUniformMatrix3fv(location, 1, GL_FALSE, matrixf);
88         check_error();
89 }
90
91 bool Effect::set_int(const std::string &key, int value)
92 {
93         if (params_int.count(key) == 0) {
94                 return false;
95         }
96         *params_int[key] = value;
97         return true;
98 }
99
100 bool Effect::set_float(const std::string &key, float value)
101 {
102         if (params_float.count(key) == 0) {
103                 return false;
104         }
105         *params_float[key] = value;
106         return true;
107 }
108
109 bool Effect::set_vec2(const std::string &key, const float *values)
110 {
111         if (params_vec2.count(key) == 0) {
112                 return false;
113         }
114         memcpy(params_vec2[key], values, sizeof(float) * 2);
115         return true;
116 }
117
118 bool Effect::set_vec3(const std::string &key, const float *values)
119 {
120         if (params_vec3.count(key) == 0) {
121                 return false;
122         }
123         memcpy(params_vec3[key], values, sizeof(float) * 3);
124         return true;
125 }
126
127 void Effect::register_int(const std::string &key, int *value)
128 {
129         assert(params_int.count(key) == 0);
130         params_int[key] = value;
131 }
132
133 void Effect::register_float(const std::string &key, float *value)
134 {
135         assert(params_float.count(key) == 0);
136         params_float[key] = value;
137 }
138
139 void Effect::register_vec2(const std::string &key, float *values)
140 {
141         assert(params_vec2.count(key) == 0);
142         params_vec2[key] = values;
143 }
144
145 void Effect::register_vec3(const std::string &key, float *values)
146 {
147         assert(params_vec3.count(key) == 0);
148         params_vec3[key] = values;
149 }
150
151 void Effect::register_1d_texture(const std::string &key, float *values, size_t size)
152 {
153         assert(params_tex_1d.count(key) == 0);
154
155         Texture1D tex;
156         tex.values = values;
157         tex.size = size;
158         tex.needs_update = false;
159         glGenTextures(1, &tex.texture_num);
160
161         glBindTexture(GL_TEXTURE_1D, tex.texture_num);
162         check_error();
163         glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
164         check_error();
165         glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
166         check_error();
167         glTexImage1D(GL_TEXTURE_1D, 0, GL_LUMINANCE16F_ARB, size, 0, GL_LUMINANCE, GL_FLOAT, values);
168         check_error();
169
170         params_tex_1d[key] = tex;
171 }
172
173 void Effect::invalidate_1d_texture(const std::string &key)
174 {
175         assert(params_tex_1d.count(key) != 0);
176         params_tex_1d[key].needs_update = true;
177 }
178
179 // Output convenience uniforms for each parameter.
180 // These will be filled in per-frame.
181 std::string Effect::output_convenience_uniforms() const
182 {
183         std::string output = "";
184         for (std::map<std::string, float*>::const_iterator it = params_float.begin();
185              it != params_float.end();
186              ++it) {
187                 char buf[256];
188                 sprintf(buf, "uniform float PREFIX(%s);\n", it->first.c_str());
189                 output.append(buf);
190         }
191         for (std::map<std::string, float*>::const_iterator it = params_vec2.begin();
192              it != params_vec2.end();
193              ++it) {
194                 char buf[256];
195                 sprintf(buf, "uniform vec2 PREFIX(%s);\n", it->first.c_str());
196                 output.append(buf);
197         }
198         for (std::map<std::string, float*>::const_iterator it = params_vec3.begin();
199              it != params_vec3.end();
200              ++it) {
201                 char buf[256];
202                 sprintf(buf, "uniform vec3 PREFIX(%s);\n", it->first.c_str());
203                 output.append(buf);
204         }
205         for (std::map<std::string, Texture1D>::const_iterator it = params_tex_1d.begin();
206              it != params_tex_1d.end();
207              ++it) {
208                 char buf[256];
209                 sprintf(buf, "uniform sampler1D PREFIX(%s);\n", it->first.c_str());
210                 output.append(buf);
211         }
212         return output;
213 }
214
215 void Effect::set_gl_state(GLuint glsl_program_num, const std::string& prefix, unsigned *sampler_num)
216 {
217         for (std::map<std::string, float*>::const_iterator it = params_float.begin();
218              it != params_float.end();
219              ++it) {
220                 set_uniform_float(glsl_program_num, prefix, it->first, *it->second);
221         }
222         for (std::map<std::string, float*>::const_iterator it = params_vec2.begin();
223              it != params_vec2.end();
224              ++it) {
225                 set_uniform_vec2(glsl_program_num, prefix, it->first, it->second);
226         }
227         for (std::map<std::string, float*>::const_iterator it = params_vec3.begin();
228              it != params_vec3.end();
229              ++it) {
230                 set_uniform_vec3(glsl_program_num, prefix, it->first, it->second);
231         }
232
233         for (std::map<std::string, Texture1D>::iterator it = params_tex_1d.begin();
234              it != params_tex_1d.end();
235              ++it) {
236                 glActiveTexture(GL_TEXTURE0 + *sampler_num);
237                 check_error();
238                 glBindTexture(GL_TEXTURE_1D, it->second.texture_num);
239                 check_error();
240
241                 if (it->second.needs_update) {
242                         glTexImage1D(GL_TEXTURE_1D, 0, GL_LUMINANCE16F_ARB, it->second.size, 0, GL_LUMINANCE, GL_FLOAT, it->second.values);
243                         check_error();
244                         it->second.needs_update = false;
245                 }
246
247                 set_uniform_int(glsl_program_num, prefix, it->first, *sampler_num);
248                 ++*sampler_num;
249         }
250 }
251
252 void Effect::clear_gl_state() {}