visibility determination
[vrlugburz] / src / sdr.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <errno.h>
5 #include <stdarg.h>
6 #include <assert.h>
7 #include "opengl.h"
8
9 #if defined(unix) || defined(__unix__)
10 #include <unistd.h>
11 #include <sys/stat.h>
12 #endif  /* unix */
13
14 #include "sdr.h"
15
16 static const char *sdrtypestr(unsigned int sdrtype);
17 static int sdrtypeidx(unsigned int sdrtype);
18
19
20 unsigned int create_vertex_shader(const char *src)
21 {
22         return create_shader(src, GL_VERTEX_SHADER);
23 }
24
25 unsigned int create_pixel_shader(const char *src)
26 {
27         return create_shader(src, GL_FRAGMENT_SHADER);
28 }
29
30 unsigned int create_tessctl_shader(const char *src)
31 {
32 #ifdef GL_TESS_CONTROL_SHADER
33         return create_shader(src, GL_TESS_CONTROL_SHADER);
34 #else
35         return 0;
36 #endif
37 }
38
39 unsigned int create_tesseval_shader(const char *src)
40 {
41 #ifdef GL_TESS_EVALUATION_SHADER
42         return create_shader(src, GL_TESS_EVALUATION_SHADER);
43 #else
44         return 0;
45 #endif
46 }
47
48 unsigned int create_geometry_shader(const char *src)
49 {
50 #ifdef GL_GEOMETRY_SHADER
51         return create_shader(src, GL_GEOMETRY_SHADER);
52 #else
53         return 0;
54 #endif
55 }
56
57 unsigned int create_shader(const char *src, unsigned int sdr_type)
58 {
59         unsigned int sdr;
60         int success, info_len;
61         char *info_str = 0;
62         const char *src_str[3], *header, *footer;
63         int src_str_count = 0;
64         GLenum err;
65
66         if((header = get_shader_header(sdr_type))) {
67                 src_str[src_str_count++] = header;
68         }
69         src_str[src_str_count++] = src;
70         if((footer = get_shader_footer(sdr_type))) {
71                 src_str[src_str_count++] = footer;
72         }
73
74         sdr = glCreateShader(sdr_type);
75         assert(glGetError() == GL_NO_ERROR);
76         glShaderSource(sdr, src_str_count, src_str, 0);
77         err = glGetError();
78         assert(err == GL_NO_ERROR);
79         glCompileShader(sdr);
80         assert(glGetError() == GL_NO_ERROR);
81
82         glGetShaderiv(sdr, GL_COMPILE_STATUS, &success);
83         assert(glGetError() == GL_NO_ERROR);
84         glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &info_len);
85         assert(glGetError() == GL_NO_ERROR);
86
87         if(info_len) {
88                 if((info_str = malloc(info_len + 1))) {
89                         glGetShaderInfoLog(sdr, info_len, 0, info_str);
90                         assert(glGetError() == GL_NO_ERROR);
91                         info_str[info_len] = 0;
92                 }
93         }
94
95         if(success) {
96                 fprintf(stderr, info_str ? "done: %s\n" : "done\n", info_str);
97         } else {
98                 fprintf(stderr, info_str ? "failed: %s\n" : "failed\n", info_str);
99                 glDeleteShader(sdr);
100                 sdr = 0;
101         }
102
103         free(info_str);
104         return sdr;
105 }
106
107 void free_shader(unsigned int sdr)
108 {
109         glDeleteShader(sdr);
110 }
111
112 unsigned int load_vertex_shader(const char *fname)
113 {
114         return load_shader(fname, GL_VERTEX_SHADER);
115 }
116
117 unsigned int load_pixel_shader(const char *fname)
118 {
119         return load_shader(fname, GL_FRAGMENT_SHADER);
120 }
121
122 unsigned int load_tessctl_shader(const char *fname)
123 {
124 #ifdef GL_TESS_CONTROL_SHADER
125         return load_shader(fname, GL_TESS_CONTROL_SHADER);
126 #else
127         return 0;
128 #endif
129 }
130
131 unsigned int load_tesseval_shader(const char *fname)
132 {
133 #ifdef GL_TESS_EVALUATION_SHADER
134         return load_shader(fname, GL_TESS_EVALUATION_SHADER);
135 #else
136         return 0;
137 #endif
138 }
139
140 unsigned int load_geometry_shader(const char *fname)
141 {
142 #ifdef GL_GEOMETRY_SHADER
143         return load_shader(fname, GL_GEOMETRY_SHADER);
144 #else
145         return 0;
146 #endif
147 }
148
149 unsigned int load_shader(const char *fname, unsigned int sdr_type)
150 {
151         unsigned int sdr;
152         size_t filesize;
153         FILE *fp;
154         char *src;
155
156         if(!(fp = fopen(fname, "rb"))) {
157                 fprintf(stderr, "failed to open shader %s: %s\n", fname, strerror(errno));
158                 return 0;
159         }
160
161         fseek(fp, 0, SEEK_END);
162         filesize = ftell(fp);
163         fseek(fp, 0, SEEK_SET);
164
165         if(!(src = malloc(filesize + 1))) {
166                 fclose(fp);
167                 return 0;
168         }
169         fread(src, 1, filesize, fp);
170         src[filesize] = 0;
171         fclose(fp);
172
173         fprintf(stderr, "compiling %s shader: %s... ", sdrtypestr(sdr_type), fname);
174         sdr = create_shader(src, sdr_type);
175
176         free(src);
177         return sdr;
178 }
179
180
181 /* ---- gpu programs ---- */
182
183 unsigned int create_program(void)
184 {
185         unsigned int prog = glCreateProgram();
186         assert(glGetError() == GL_NO_ERROR);
187         return prog;
188 }
189
190 unsigned int create_program_link(unsigned int sdr0, ...)
191 {
192         unsigned int prog, sdr;
193         va_list ap;
194
195         if(!(prog = create_program())) {
196                 return 0;
197         }
198
199         attach_shader(prog, sdr0);
200         if(glGetError()) {
201                 return 0;
202         }
203
204         va_start(ap, sdr0);
205         while((sdr = va_arg(ap, unsigned int))) {
206                 attach_shader(prog, sdr);
207                 if(glGetError()) {
208                         return 0;
209                 }
210         }
211         va_end(ap);
212
213         if(link_program(prog) == -1) {
214                 free_program(prog);
215                 return 0;
216         }
217         return prog;
218 }
219
220 unsigned int create_program_load(const char *vfile, const char *pfile)
221 {
222         unsigned int vs = 0, ps = 0;
223
224         if(vfile && *vfile && !(vs = load_vertex_shader(vfile))) {
225                 return 0;
226         }
227         if(pfile && *pfile && !(ps = load_pixel_shader(pfile))) {
228                 return 0;
229         }
230         return create_program_link(vs, ps, 0);
231 }
232
233 void free_program(unsigned int sdr)
234 {
235         glDeleteProgram(sdr);
236 }
237
238 void attach_shader(unsigned int prog, unsigned int sdr)
239 {
240         int err;
241
242         if(prog && sdr) {
243                 assert(glGetError() == GL_NO_ERROR);
244                 glAttachShader(prog, sdr);
245                 if((err = glGetError()) != GL_NO_ERROR) {
246                         fprintf(stderr, "failed to attach shader %u to program %u (err: 0x%x)\n", sdr, prog, err);
247                         abort();
248                 }
249         }
250 }
251
252 int link_program(unsigned int prog)
253 {
254         int linked, info_len, retval = 0;
255         char *info_str = 0;
256
257         glLinkProgram(prog);
258         assert(glGetError() == GL_NO_ERROR);
259         glGetProgramiv(prog, GL_LINK_STATUS, &linked);
260         assert(glGetError() == GL_NO_ERROR);
261         glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &info_len);
262         assert(glGetError() == GL_NO_ERROR);
263
264         if(info_len) {
265                 if((info_str = malloc(info_len + 1))) {
266                         glGetProgramInfoLog(prog, info_len, 0, info_str);
267                         assert(glGetError() == GL_NO_ERROR);
268                         info_str[info_len] = 0;
269                 }
270         }
271
272         if(linked) {
273                 fprintf(stderr, info_str ? "linking done: %s\n" : "linking done\n", info_str);
274         } else {
275                 fprintf(stderr, info_str ? "linking failed: %s\n" : "linking failed\n", info_str);
276                 retval = -1;
277         }
278
279         free(info_str);
280         return retval;
281 }
282
283 int bind_program(unsigned int prog)
284 {
285         GLenum err;
286
287         glUseProgram(prog);
288         if(prog && (err = glGetError()) != GL_NO_ERROR) {
289                 /* maybe the program is not linked, try linking first */
290                 if(err == GL_INVALID_OPERATION) {
291                         if(link_program(prog) == -1) {
292                                 return -1;
293                         }
294                         glUseProgram(prog);
295                         return glGetError() == GL_NO_ERROR ? 0 : -1;
296                 }
297                 return -1;
298         }
299         return 0;
300 }
301
302 /* ugly but I'm not going to write the same bloody code over and over */
303 #define BEGIN_UNIFORM_CODE \
304         int loc, curr_prog; \
305         glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); \
306         if((unsigned int)curr_prog != prog && bind_program(prog) == -1) { \
307                 return -1; \
308         } \
309         if((loc = glGetUniformLocation(prog, name)) != -1)
310
311 #define END_UNIFORM_CODE \
312         if((unsigned int)curr_prog != prog) { \
313                 bind_program(curr_prog); \
314         } \
315         return loc == -1 ? -1 : 0
316
317 int get_uniform_loc(unsigned int prog, const char *name)
318 {
319         int loc, curr_prog;
320         glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);
321         if((unsigned int)curr_prog != prog && bind_program(prog) == -1) {
322                 return -1;
323         }
324         loc = glGetUniformLocation(prog, name);
325         if((unsigned int)curr_prog != prog) {
326                 bind_program(curr_prog);
327         }
328         return loc;
329 }
330
331 int set_uniform_int(unsigned int prog, const char *name, int val)
332 {
333         BEGIN_UNIFORM_CODE {
334                 glUniform1i(loc, val);
335         }
336         END_UNIFORM_CODE;
337 }
338
339 int set_uniform_float(unsigned int prog, const char *name, float val)
340 {
341         BEGIN_UNIFORM_CODE {
342                 glUniform1f(loc, val);
343         }
344         END_UNIFORM_CODE;
345 }
346
347 int set_uniform_float2(unsigned int prog, const char *name, float x, float y)
348 {
349         BEGIN_UNIFORM_CODE {
350                 glUniform2f(loc, x, y);
351         }
352         END_UNIFORM_CODE;
353 }
354
355 int set_uniform_float3(unsigned int prog, const char *name, float x, float y, float z)
356 {
357         BEGIN_UNIFORM_CODE {
358                 glUniform3f(loc, x, y, z);
359         }
360         END_UNIFORM_CODE;
361 }
362
363 int set_uniform_float4(unsigned int prog, const char *name, float x, float y, float z, float w)
364 {
365         BEGIN_UNIFORM_CODE {
366                 glUniform4f(loc, x, y, z, w);
367         }
368         END_UNIFORM_CODE;
369 }
370
371 int set_uniform_matrix4(unsigned int prog, const char *name, const float *mat)
372 {
373         BEGIN_UNIFORM_CODE {
374                 glUniformMatrix4fv(loc, 1, GL_FALSE, mat);
375         }
376         END_UNIFORM_CODE;
377 }
378
379 int set_uniform_matrix4_transposed(unsigned int prog, const char *name, const float *mat)
380 {
381         BEGIN_UNIFORM_CODE {
382                 glUniformMatrix4fv(loc, 1, GL_TRUE, mat);
383         }
384         END_UNIFORM_CODE;
385 }
386
387 int get_attrib_loc(unsigned int prog, const char *name)
388 {
389         int loc, curr_prog;
390
391         glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog);
392         if((unsigned int)curr_prog != prog && bind_program(prog) == -1) {
393                 return -1;
394         }
395
396         loc = glGetAttribLocation(prog, (char*)name);
397
398         if((unsigned int)curr_prog != prog) {
399                 bind_program(curr_prog);
400         }
401         return loc;
402 }
403
404 void set_attrib_float3(int attr_loc, float x, float y, float z)
405 {
406         glVertexAttrib3f(attr_loc, x, y, z);
407 }
408
409 /* ---- shader composition ---- */
410 struct string {
411         char *text;
412         int len;
413 };
414
415 #define NUM_SHADER_TYPES        5
416 static struct string header[NUM_SHADER_TYPES];
417 static struct string footer[NUM_SHADER_TYPES];
418
419 static void clear_string(struct string *str)
420 {
421         free(str->text);
422         str->text = 0;
423         str->len = 0;
424 }
425
426 static void append_string(struct string *str, const char *s)
427 {
428         int len, newlen;
429         char *newstr;
430
431         if(!s || !*s) return;
432
433         len = strlen(s);
434         newlen = str->len + len;
435         if(!(newstr = malloc(newlen + 2))) {    /* leave space for a possible newline */
436                 fprintf(stderr, "shader composition: failed to append string of size %d\n", len);
437                 abort();
438         }
439
440         if(str->text) {
441                 memcpy(newstr, str->text, str->len);
442         }
443         memcpy(newstr + str->len, s, len + 1);
444
445         if(s[len - 1] != '\n') {
446                 newstr[newlen] = '\n';
447                 newstr[newlen + 1] = 0;
448         }
449
450         free(str->text);
451         str->text = newstr;
452         str->len = newlen;
453 }
454
455 void clear_shader_header(unsigned int type)
456 {
457         if(type) {
458                 int idx = sdrtypeidx(type);
459                 clear_string(&header[idx]);
460         } else {
461                 int i;
462                 for(i=0; i<NUM_SHADER_TYPES; i++) {
463                         clear_string(&header[i]);
464                 }
465         }
466 }
467
468 void clear_shader_footer(unsigned int type)
469 {
470         if(type) {
471                 int idx = sdrtypeidx(type);
472                 clear_string(&footer[idx]);
473         } else {
474                 int i;
475                 for(i=0; i<NUM_SHADER_TYPES; i++) {
476                         clear_string(&footer[i]);
477                 }
478         }
479 }
480
481 void add_shader_header(unsigned int type, const char *s)
482 {
483         if(type) {
484                 int idx = sdrtypeidx(type);
485                 append_string(&header[idx], s);
486         } else {
487                 int i;
488                 for(i=0; i<NUM_SHADER_TYPES; i++) {
489                         append_string(&header[i], s);
490                 }
491         }
492 }
493
494 void add_shader_footer(unsigned int type, const char *s)
495 {
496         if(type) {
497                 int idx = sdrtypeidx(type);
498                 append_string(&footer[idx], s);
499         } else {
500                 int i;
501                 for(i=0; i<NUM_SHADER_TYPES; i++) {
502                         append_string(&footer[i], s);
503                 }
504         }
505 }
506
507 const char *get_shader_header(unsigned int type)
508 {
509         int idx = sdrtypeidx(type);
510         return header[idx].text;
511 }
512
513 const char *get_shader_footer(unsigned int type)
514 {
515         int idx = sdrtypeidx(type);
516         return footer[idx].text;
517 }
518
519 static const char *sdrtypestr(unsigned int sdrtype)
520 {
521         switch(sdrtype) {
522         case GL_VERTEX_SHADER:
523                 return "vertex";
524         case GL_FRAGMENT_SHADER:
525                 return "pixel";
526 #ifdef GL_TESS_CONTROL_SHADER
527         case GL_TESS_CONTROL_SHADER:
528                 return "tessellation control";
529 #endif
530 #ifdef GL_TESS_EVALUATION_SHADER
531         case GL_TESS_EVALUATION_SHADER:
532                 return "tessellation evaluation";
533 #endif
534 #ifdef GL_GEOMETRY_SHADER
535         case GL_GEOMETRY_SHADER:
536                 return "geometry";
537 #endif
538
539         default:
540                 break;
541         }
542         return "<unknown>";
543 }
544
545 static int sdrtypeidx(unsigned int sdrtype)
546 {
547         switch(sdrtype) {
548         case GL_VERTEX_SHADER:
549                 return 0;
550         case GL_FRAGMENT_SHADER:
551                 return 1;
552         case GL_TESS_CONTROL_SHADER:
553                 return 2;
554         case GL_TESS_EVALUATION_SHADER:
555                 return 3;
556         case GL_GEOMETRY_SHADER:
557                 return 4;
558         default:
559                 break;
560         }
561         return 0;
562 }