2f6e6947b28029b9830e1d9aee78e595580a249b
[movit] / util.cpp
1 #include <epoxy/gl.h>
2 #include <assert.h>
3 #include <math.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <locale>
8 #include <sstream>
9 #include <string>
10 #include <Eigen/Core>
11
12 #include "fp16.h"
13 #include "init.h"
14 #include "util.h"
15
16 #if defined(__APPLE__)
17 #include <OpenGL/OpenGL.h>
18 #elif defined(WIN32)
19 #include <epoxy/wgl.h>
20 #else
21 #include <epoxy/glx.h>
22 #include <epoxy/egl.h>
23 #endif
24
25 using namespace std;
26
27 namespace movit {
28
29 extern string *movit_data_directory;
30
31 void hsv2rgb(float h, float s, float v, float *r, float *g, float *b)
32 {
33         if (h < 0.0f) {
34                 h += 2.0f * M_PI;
35         }
36         float c = v * s;
37         float hp = (h * 180.0 / M_PI) / 60.0;
38         float x = c * (1 - fabs(fmod(hp, 2.0f) - 1.0f));
39
40         if (hp >= 0 && hp < 1) {
41                 *r = c;
42                 *g = x;
43                 *b = 0.0f;
44         } else if (hp >= 1 && hp < 2) {
45                 *r = x;
46                 *g = c;
47                 *b = 0.0f;
48         } else if (hp >= 2 && hp < 3) {
49                 *r = 0.0f;
50                 *g = c;
51                 *b = x;
52         } else if (hp >= 3 && hp < 4) {
53                 *r = 0.0f;
54                 *g = x;
55                 *b = c;
56         } else if (hp >= 4 && hp < 5) {
57                 *r = x;
58                 *g = 0.0f;
59                 *b = c;
60         } else {
61                 *r = c;
62                 *g = 0.0f;
63                 *b = x;
64         }
65
66         float m = v - c;
67         *r += m;
68         *g += m;
69         *b += m;
70 }
71
72 void hsv2rgb_normalized(float h, float s, float v, float *r, float *g, float *b)
73 {
74         float ref_r, ref_g, ref_b;
75         hsv2rgb(h, s, v, r, g, b);
76         hsv2rgb(h, 0.0f, v, &ref_r, &ref_g, &ref_b);
77         float lum = 0.2126 * *r + 0.7152 * *g + 0.0722 * *b;
78         float ref_lum = 0.2126 * ref_r + 0.7152 * ref_g + 0.0722 * ref_b;
79         if (lum > 1e-3) {
80                 float fac = ref_lum / lum;
81                 *r *= fac;
82                 *g *= fac;
83                 *b *= fac;
84         }
85 }
86
87 string read_file(const string &filename)
88 {
89         const string full_pathname = *movit_data_directory + "/" + filename;
90
91         FILE *fp = fopen(full_pathname.c_str(), "r");
92         if (fp == nullptr) {
93                 perror(full_pathname.c_str());
94                 exit(1);
95         }
96
97         int ret = fseek(fp, 0, SEEK_END);
98         if (ret == -1) {
99                 perror("fseek(SEEK_END)");
100                 exit(1);
101         }
102
103         int size = ftell(fp);
104
105         ret = fseek(fp, 0, SEEK_SET);
106         if (ret == -1) {
107                 perror("fseek(SEEK_SET)");
108                 exit(1);
109         }
110
111         string str;
112         str.resize(size);
113         ret = fread(&str[0], size, 1, fp);
114         if (ret == -1) {
115                 perror("fread");
116                 exit(1);
117         }
118         if (ret == 0) {
119                 fprintf(stderr, "Short read when trying to read %d bytes from %s\n",
120                         size, full_pathname.c_str());
121                 exit(1);
122         }
123         fclose(fp);
124
125         return str;
126 }
127
128 string read_version_dependent_file(const string &base, const string &extension)
129 {
130         if (movit_shader_model == MOVIT_GLSL_130) {
131                 return read_file(base + ".130." + extension);
132         } else if (movit_shader_model == MOVIT_GLSL_150) {
133                 return read_file(base + ".150." + extension);
134         } else if (movit_shader_model == MOVIT_ESSL_300) {
135                 return read_file(base + ".300es." + extension);
136         } else {
137                 assert(false);
138         }
139 }
140
141 GLuint compile_shader(const string &shader_src, GLenum type)
142 {
143         GLuint obj = glCreateShader(type);
144         const GLchar* source[] = { shader_src.data() };
145         const GLint length[] = { (GLint)shader_src.size() };
146         glShaderSource(obj, 1, source, length);
147         glCompileShader(obj);
148
149         GLchar info_log[4096];
150         GLsizei log_length = sizeof(info_log) - 1;
151         glGetShaderInfoLog(obj, log_length, &log_length, info_log);
152         info_log[log_length] = 0; 
153         if (strlen(info_log) > 0) {
154                 fprintf(stderr, "Shader compile log: %s\n", info_log);
155         }
156
157         GLint status;
158         glGetShaderiv(obj, GL_COMPILE_STATUS, &status);
159         if (status == GL_FALSE) {
160                 fprintf(stderr, "Failed to compile shader: %s\n", shader_src.c_str());
161                 exit(1);
162         }
163
164         return obj;
165 }
166
167 void print_3x3_matrix(const Eigen::Matrix3d& m)
168 {
169         printf("%6.4f %6.4f %6.4f\n", m(0,0), m(0,1), m(0,2));
170         printf("%6.4f %6.4f %6.4f\n", m(1,0), m(1,1), m(1,2));
171         printf("%6.4f %6.4f %6.4f\n", m(2,0), m(2,1), m(2,2));
172         printf("\n");
173 }
174
175 string output_glsl_mat3(const string &name, const Eigen::Matrix3d &m)
176 {
177         // Use stringstream to be independent of the current locale in a thread-safe manner.
178         stringstream ss;
179         ss.imbue(locale("C"));
180         ss.precision(8);
181         ss << scientific;
182         ss << "const mat3 " << name << " = mat3(\n";
183         ss << "    " << m(0,0) << ", " << m(1,0) << ", " << m(2,0) << ",\n";
184         ss << "    " << m(0,1) << ", " << m(1,1) << ", " << m(2,1) << ",\n";
185         ss << "    " << m(0,2) << ", " << m(1,2) << ", " << m(2,2) << ");\n\n";
186         return ss.str();
187 }
188
189 string output_glsl_float(const string &name, float x)
190 {
191         // Use stringstream to be independent of the current locale in a thread-safe manner.
192         stringstream ss;
193         ss.imbue(locale("C"));
194         ss.precision(8);
195         ss << scientific;
196         ss << "const float " << name << " = " << x << ";\n";
197         return ss.str();
198 }
199
200 string output_glsl_vec2(const string &name, float x, float y)
201 {
202         // Use stringstream to be independent of the current locale in a thread-safe manner.
203         stringstream ss;
204         ss.imbue(locale("C"));
205         ss.precision(8);
206         ss << scientific;
207         ss << "const vec2 " << name << " = vec2(" << x << ", " << y << ");\n";
208         return ss.str();
209 }
210
211 string output_glsl_vec3(const string &name, float x, float y, float z)
212 {
213         // Use stringstream to be independent of the current locale in a thread-safe manner.
214         stringstream ss;
215         ss.imbue(locale("C"));
216         ss.precision(8);
217         ss << scientific;
218         ss << "const vec3 " << name << " = vec3(" << x << ", " << y << ", " << z << ");\n";
219         return ss.str();
220 }
221
222 GLuint generate_vbo(GLint size, GLenum type, GLsizeiptr data_size, const GLvoid *data)
223 {
224         GLuint vbo;
225         glGenBuffers(1, &vbo);
226         check_error();
227         glBindBuffer(GL_ARRAY_BUFFER, vbo);
228         check_error();
229         glBufferData(GL_ARRAY_BUFFER, data_size, data, GL_STATIC_DRAW);
230         check_error();
231         glBindBuffer(GL_ARRAY_BUFFER, 0);
232         check_error();
233
234         return vbo;
235 }
236
237 GLuint fill_vertex_attribute(GLuint glsl_program_num, const string &attribute_name, GLint size, GLenum type, GLsizeiptr data_size, const GLvoid *data)
238 {
239         int attrib = glGetAttribLocation(glsl_program_num, attribute_name.c_str());
240         if (attrib == -1) {
241                 return -1;
242         }
243
244         GLuint vbo = generate_vbo(size, type, data_size, data);
245
246         glBindBuffer(GL_ARRAY_BUFFER, vbo);
247         check_error();
248         glEnableVertexAttribArray(attrib);
249         check_error();
250         glVertexAttribPointer(attrib, size, type, GL_FALSE, 0, BUFFER_OFFSET(0));
251         check_error();
252         glBindBuffer(GL_ARRAY_BUFFER, 0);
253         check_error();
254
255         return vbo;
256 }
257
258 void cleanup_vertex_attribute(GLuint glsl_program_num, const string &attribute_name, GLuint vbo)
259 {
260         int attrib = glGetAttribLocation(glsl_program_num, attribute_name.c_str());
261         if (attrib == -1) {
262                 return;
263         }
264
265         glDisableVertexAttribArray(attrib);
266         check_error();
267         glDeleteBuffers(1, &vbo);
268         check_error();
269 }
270
271 unsigned div_round_up(unsigned a, unsigned b)
272 {
273         return (a + b - 1) / b;
274 }
275
276 // Algorithm from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2.
277 unsigned next_power_of_two(unsigned v)
278 {
279         v--;
280         v |= v >> 1;
281         v |= v >> 2;
282         v |= v >> 4;
283         v |= v >> 8;
284         v |= v >> 16;
285         v++;
286         return v;
287 }
288
289 void *get_gl_context_identifier()
290 {
291 #if defined(__APPLE__)
292         return (void *)CGLGetCurrentContext();
293 #elif defined(WIN32)
294         return (void *)wglGetCurrentContext();
295 #else
296         void *ret = (void *)eglGetCurrentContext();
297         if (ret != nullptr) {
298                 return ret;
299         }
300         return (void *)glXGetCurrentContext();
301 #endif
302 }
303
304 void abort_gl_error(GLenum err, const char *filename, int line)
305 {
306         const char *err_text = "unknown";
307
308         // All errors listed in the glGetError(3G) man page.
309         switch (err) {
310         case GL_NO_ERROR:
311                 err_text = "GL_NO_ERROR";  // Should not happen.
312                 break;
313         case GL_INVALID_ENUM:
314                 err_text = "GL_INVALID_ENUM";
315                 break;
316         case GL_INVALID_VALUE:
317                 err_text = "GL_INVALID_VALUE";
318                 break;
319         case GL_INVALID_OPERATION:
320                 err_text = "GL_INVALID_OPERATION";
321                 break;
322         case GL_INVALID_FRAMEBUFFER_OPERATION:
323                 err_text = "GL_INVALID_FRAMEBUFFER_OPERATION";
324                 break;
325         case GL_OUT_OF_MEMORY:
326                 err_text = "GL_OUT_OF_MEMORY";
327                 break;
328         case GL_STACK_UNDERFLOW:
329                 err_text = "GL_STACK_UNDERFLOW";
330                 break;
331         case GL_STACK_OVERFLOW:
332                 err_text = "GL_STACK_OVERFLOW";
333                 break;
334         }
335         fprintf(stderr, "GL error 0x%x (%s) at %s:%d\n", err, err_text, filename, line);
336         abort();
337 }
338
339 }  // namespace movit