Untitled
Loading...
Searching...
No Matches
shaders.c
Go to the documentation of this file.
1
2#include "load/init.h"
3#include "utilities/types.h"
4#include "core/shaders.h"
5#include <stdint.h>
6#include <string.h>
7#include <stdlib.h>
8#include <stdio.h>
9
10char * read_file(const char *filename) {
11
12 FILE * f = fopen(filename, "rb");
13 if (!f) return NULL;
14 fseek(f, 0, SEEK_END);
15 long size = ftell(f);
16 rewind(f);
17 char * buffer = (char *)malloc(size + 1);
18 if (!buffer) return NULL;
19 size_t bytes_read = fread(buffer, 1, size, f);
20 buffer[bytes_read] = '\0';
21 fclose(f);
22
23 size_t write_idx = 0;
24 for (size_t i = 0; i < bytes_read; i++) {
25 if (buffer[i] != '\r') {
26 buffer[write_idx++] = buffer[i];
27 }
28 }
29 buffer[write_idx] = '\0';
30 return buffer;
31
32}
33
34GLuint create_compute_shader(const char *filename) {
35
36 const char *src = read_file(filename);
37 if (!src) {
38 fprintf(stderr, "Failed to read shader file: %s\n", filename);
39 return 0;
40 }
41
42 GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
43 GLint src_len = (GLint)strlen(src);
44 glShaderSource(shader, 1, &src, &src_len);
45 glCompileShader(shader);
46 free((void*)src); // don't forget to free it after compile
47
48 GLint status;
49 glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
50 if (!status) {
51 char log[2048];
52 glGetShaderInfoLog(shader, 2048, NULL, log);
53 fprintf(stderr, "Compute Shader Error %s: %s\n", filename, log);
54 exit(0);
55 return 0;
56 }
57
58 GLuint program = glCreateProgram();
59 glAttachShader(program, shader);
60 glLinkProgram(program);
61
62 GLint status2;
63 glGetProgramiv(program, GL_LINK_STATUS, &status2);
64 if (!status2) {
65 char log[2048];
66 glGetProgramInfoLog(program, 2048, NULL, log);
67 fprintf(stderr, "Compute Shader LINKER Error %s: %s\n", filename, log);
68 exit(0);
69 return 0;
70 }
71
72 glDeleteShader(shader);
73 return program;
74}
75
76
77GLuint compile_shader(GLenum type, const char *filename) {
78 const char *source = read_file(filename);
79 if (!source) return 0;
80
81 GLuint shader = glCreateShader(type);
82 glShaderSource(shader, 1, &source, NULL);
83 glCompileShader(shader);
84 free((void *)source);
85
86 GLint success;
87 glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
88 char log[512];
89 if (!success) {
90
91 glGetShaderInfoLog(shader, 512, NULL, log);
92 printf("\\nShader compile error (%s):\\n%s\\n", filename, log);
93 exit(0);
94 return 0;
95 } else {
96 glGetShaderInfoLog(shader, 512, NULL, log);
97 if (strlen(log) > 0) {
98 printf("Shader compile warning (%s):\\n%s\\n", filename, log);
99 }
100 }
101
102 return shader;
103}
104
105GLuint compile_gbuffer_frag_shader(GLenum type, const char *filename, int i) {
106 const char *source = read_file(filename);
107 if (!source) return 0;
108
109 GLuint shader = glCreateShader(type);
110
111 const char * version = "#version 460\n";
112 char macro[256];
113 switch(i)
114 {
115 case DVIEW_DEFAULT:
116 sprintf(macro, "\n");
117 break;
118 case DVIEW_ALBEDO:
119 sprintf(macro, "#define ALBEDO\n");
120 break;
121 case DVIEW_ARM:
122 sprintf(macro, "#define ARM\n");
123 break;
124 case DVIEW_EMISSIVE:
125 sprintf(macro, "#define EMISSIVE\n");
126 break;
127 case DVIEW_AO:
128 sprintf(macro, "#define AO\n");
129 break;
130 case DVIEW_UV:
131 sprintf(macro, "#define UV\n");
132 break;
133 case DVIEW_POM_VDIR:
134 sprintf(macro, "#define POM_VDIR\n");
135 break;
136 case DVIEW_CLUSTERS:
137 sprintf(macro, "#define CLUSTERS\n");
138 break;
139 case DVIEW_NORMAL:
140 sprintf(macro, "#define NORMAL\n");
141 break;
143 sprintf(macro, "#define ORIGINAL_NORMAL\n");
144 break;
145 case DVIEW_DIRECT:
146 sprintf(macro, "#define DIRECT\n");
147 break;
148 case DVIEW_INDIRECT:
149 sprintf(macro, "#define INDIRECT\n");
150 break;
152 sprintf(macro, "#define LM_IRRADIANCE\n");
153 break;
155 sprintf(macro, "#define LM_DIRECTIONAL\n");
156 break;
157 case DVIEW_RPROBE:
158 sprintf(macro, "#define RPROBE\n");
159 break;
160 case DVIEW_SPECULAR:
161 sprintf(macro, "#define SPECULAR\n");
162 break;
163 case DVIEW_MAX:
164 sprintf(macro, "#define POM\n");
165 break;
166 default:
167 break;
168 }
169 const char * sources[3] =
170 {
171 version, macro, source
172 };
173
174 glShaderSource(shader, 3, sources, NULL);
175
176 glCompileShader(shader);
177 free((void *)source);
178
179 GLint success;
180 glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
181 char log[512];
182 if (!success) {
183
184 glGetShaderInfoLog(shader, 512, NULL, log);
185 printf("\\nShader compile error (%s):\\n%s\\n", filename, log);
186 exit(0);
187 return 0;
188 } else {
189 glGetShaderInfoLog(shader, 512, NULL, log);
190 if (strlen(log) > 0) {
191 printf("Shader compile warning (%s):\\n%s\\n", filename, log);
192 }
193 }
194
195 return shader;
196}
197
198GLuint compile_uber_frag_shader(GLenum type, const char *filename, int i) {
199 const char *source = read_file(filename);
200 if (!source) return 0;
201
202 GLuint shader = glCreateShader(type);
203
204 const char * version = "#version 430 core\n";
205 char macro[256];
206 switch(i)
207 {
208 case DVIEW_DEFAULT:
209 sprintf(macro, "\n");
210 break;
211 case DVIEW_ALBEDO:
212 sprintf(macro, "#define ALBEDO\n");
213 break;
214 case DVIEW_ARM:
215 sprintf(macro, "#define ARM\n");
216 break;
217 case DVIEW_EMISSIVE:
218 sprintf(macro, "#define EMISSIVE\n");
219 break;
220 case DVIEW_AO:
221 sprintf(macro, "#define AO\n");
222 break;
223 case DVIEW_UV:
224 sprintf(macro, "#define DVIEW_UV\n");
225 break;
226 case DVIEW_POM_VDIR:
227 sprintf(macro, "#define POM_VDIR\n");
228 break;
229 case DVIEW_CLUSTERS:
230 sprintf(macro, "#define CLUSTERS\n");
231 break;
232 case DVIEW_NORMAL:
233 sprintf(macro, "#define NORMAL\n");
234 break;
236 sprintf(macro, "#define ORIGINAL_NORMAL\n");
237 break;
238 case DVIEW_DIRECT:
239 sprintf(macro, "#define DIRECT\n");
240 break;
241 case DVIEW_INDIRECT:
242 sprintf(macro, "#define INDIRECT\n");
243 break;
245 sprintf(macro, "#define LM_IRRADIANCE\n");
246 break;
248 sprintf(macro, "#define LM_DIRECTIONAL\n");
249 break;
250 case DVIEW_RPROBE:
251 sprintf(macro, "#define RPROBE\n");
252 break;
253 case DVIEW_SPECULAR:
254 sprintf(macro, "#define SPECULAR\n");
255 break;
256 case DVIEW_MAX:
257 sprintf(macro, "#define POM\n");
258 break;
259 default:
260 break;
261 }
262 const char * sources[3] =
263 {
264 version, macro, source
265 };
266
267 glShaderSource(shader, 3, sources, NULL);
268
269 glCompileShader(shader);
270 free((void *)source);
271
272 GLint success;
273 glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
274 char log[512];
275 if (!success) {
276
277 glGetShaderInfoLog(shader, 512, NULL, log);
278 printf("\\nShader compile error %s (%s):\\n%s\\n", macro, filename, log);
279 exit(0);
280 return 0;
281 } else {
282 glGetShaderInfoLog(shader, 512, NULL, log);
283 if (strlen(log) > 0) {
284 printf("Shader compile warning %s (%s):\\n%s\\n", macro, filename, log);
285 }
286 }
287
288 return shader;
289}
290
291GLuint compile_postprocess_shader(GLenum type, const char *filename, uint32_t PP_OPTIONS, bool is_dview, PostprocessDView dview) {
292 const char *source = read_file(filename);
293 if (!source) return 0;
294
295 GLuint shader = glCreateShader(type);
296
297 const char * version = "#version 430 core\n";
298 char macro[10000];
299 macro[0] = '\0';
300 if (is_dview)
301 {
302 switch(dview)
303 {
304 case PPDVIEW_DEPTH:
305 strcat(macro, "#define DEPTH\n");
306 break;
307 case PPDVIEW_VEL:
308 strcat(macro, "#define VEL\n");
309 break;
310 case PPDVIEW_BOKEH:
311 strcat(macro, "#define BOKEH\n");
312 break;
313 case PPDVIEW_LM:
314 strcat(macro, "#define LM\n");
315 break;
316 default:
317 break;
318 }
319 }
320 else
321 {
322 if (PP_OPTIONS & (1 << PP_MBLUR))
323 {
324 strcat(macro, "#define MBLUR\n");
325 }
326 if (PP_OPTIONS & (1 << PP_DOF))
327 {
328 strcat(macro, "#define DOF\n");
329 }
330 if (PP_OPTIONS & (1 << PP_BLOOM))
331 {
332 strcat(macro, "#define BLOOM\n");
333 }
334 if (PP_OPTIONS & (1 << PP_NOISE))
335 {
336 strcat(macro, "#define NOISE\n");
337 }
338 if (PP_OPTIONS & (1 << PP_ACES))
339 {
340 strcat(macro, "#define ACES\n");
341 }
342 if (PP_OPTIONS & (1 << PP_LUT))
343 {
344 strcat(macro, "#define LUT\n");
345 }
346
347 }
348 const char * sources[3] =
349 {
350 version, macro, source
351 };
352
353 glShaderSource(shader, 3, sources, NULL);
354
355 glCompileShader(shader);
356 free((void *)source);
357
358 GLint success;
359 glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
360 char log[512];
361 if (!success) {
362
363 glGetShaderInfoLog(shader, 512, NULL, log);
364 printf("\\nShader compile error %s (%s):\\n%s\\n", macro, filename, log);
365 exit(0);
366 return 0;
367 } else {
368 glGetShaderInfoLog(shader, 512, NULL, log);
369 if (strlen(log) > 0) {
370 printf("Shader compile warning %s (%s):\\n%s\\n", macro, filename, log);
371 }
372 }
373
374 return shader;
375}
376
377GLuint create_shader_program(const char * vertex_path, const char * fragment_path) {
378 GLuint vertex_shader = compile_shader(GL_VERTEX_SHADER, vertex_path);
379 GLuint fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_path);
380 if (!vertex_shader || !fragment_shader) return 0;
381
382 GLuint program = glCreateProgram();
383 glAttachShader(program, vertex_shader);
384 glAttachShader(program, fragment_shader);
385 glLinkProgram(program);
386
387 GLint success;
388 glGetProgramiv(program, GL_LINK_STATUS, &success);
389 char log[512];
390 if (!success) {
391
392 glGetProgramInfoLog(program, 512, NULL, log);
393 printf("Shader link error:\\n%s\\n", log);
394 exit(0);
395 return 0;
396 } else {
397 glGetProgramInfoLog(program, 512, NULL, log);
398 if (strlen(log) > 0) {
399 printf("Shader link warning:\\n%s\\n", log);
400 }
401 }
402
403 glDeleteShader(vertex_shader);
404 glDeleteShader(fragment_shader);
405
406 return program;
407}
408
409GLuint create_geometry_shader_program(const char *vertexPath, const char * geometryPath, const char *fragmentPath) {
410 GLuint vertexShader = compile_shader(GL_VERTEX_SHADER, vertexPath);
411 GLuint geometryShader = compile_shader(GL_GEOMETRY_SHADER, geometryPath);
412 GLuint fragmentShader = compile_shader(GL_FRAGMENT_SHADER, fragmentPath);
413 if (!vertexShader || !geometryShader || !fragmentShader) return 0;
414
415 GLuint program = glCreateProgram();
416 glAttachShader(program, vertexShader);
417 glAttachShader(program, geometryShader);
418 glAttachShader(program, fragmentShader);
419 glLinkProgram(program);
420
421 GLint success;
422 glGetProgramiv(program, GL_LINK_STATUS, &success);
423 char log[512];
424 if (!success) {
425
426 glGetProgramInfoLog(program, 512, NULL, log);
427 printf("Shader link error:\\n%s\\n", log);
428 exit(0);
429 return 0;
430 } else {
431 glGetProgramInfoLog(program, 512, NULL, log);
432 if (strlen(log) > 0) {
433 printf("Shader link warning:\\n%s\\n", log);
434 }
435}
436
437 glDeleteShader(vertexShader);
438 glDeleteShader(geometryShader);
439 glDeleteShader(fragmentShader);
440
441 return program;
442}
443
444
445GLuint create_gbuffer_program(const char *vertexPath, const char *fragmentPath, int i) {
446 GLuint vertexShader = compile_shader(GL_VERTEX_SHADER, vertexPath);
447 GLuint fragmentShader = compile_gbuffer_frag_shader(GL_FRAGMENT_SHADER, fragmentPath, i);
448 if (!vertexShader || !fragmentShader) return 0;
449
450 GLuint program = glCreateProgram();
451 glAttachShader(program, vertexShader);
452 glAttachShader(program, fragmentShader);
453 glLinkProgram(program);
454
455 GLint success;
456 glGetProgramiv(program, GL_LINK_STATUS, &success);
457 char log[512];
458 if (!success) {
459
460 glGetProgramInfoLog(program, 512, NULL, log);
461 printf("Shader link error:\\n%s\\n", log);
462 exit(0);
463 return 0;
464 } else {
465 glGetProgramInfoLog(program, 512, NULL, log);
466 if (strlen(log) > 0) {
467 printf("Shader link warning:\\n%s\\n", log);
468 }
469 }
470
471 glDeleteShader(vertexShader);
472 glDeleteShader(fragmentShader);
473
474 return program;
475}
476
477
478GLuint create_ubershader_program(const char *vertexPath, const char * geometryPath, const char *fragmentPath, int i) {
479 GLuint vertexShader = compile_shader(GL_VERTEX_SHADER, vertexPath);
480 GLuint fragmentShader = compile_uber_frag_shader(GL_FRAGMENT_SHADER, fragmentPath, i);
481 if (!vertexShader || !fragmentShader) return 0;
482
483 GLuint program = glCreateProgram();
484 glAttachShader(program, vertexShader);
485 glAttachShader(program, fragmentShader);
486 glLinkProgram(program);
487
488 GLint success;
489 glGetProgramiv(program, GL_LINK_STATUS, &success);
490 char log[512];
491 if (!success) {
492
493 glGetProgramInfoLog(program, 512, NULL, log);
494 printf("Shader link error:\\n%s\\n", log);
495 exit(0);
496 return 0;
497 } else {
498 glGetProgramInfoLog(program, 512, NULL, log);
499 if (strlen(log) > 0) {
500 printf("Shader link warning:\\n%s\\n", log);
501 }
502}
503
504 glDeleteShader(vertexShader);
505 glDeleteShader(fragmentShader);
506
507 return program;
508}
509
510
511GLuint create_postprocess_program(const char *vertexPath, const char *fragmentPath, int i, bool is_dview, PostprocessDView dview) {
512 GLuint vertexShader = compile_shader(GL_VERTEX_SHADER, vertexPath);
513 GLuint fragmentShader = compile_postprocess_shader(GL_FRAGMENT_SHADER, fragmentPath, i, is_dview, dview);
514 if (!vertexShader || !fragmentShader) return 0;
515
516 GLuint program = glCreateProgram();
517 glAttachShader(program, vertexShader);
518 glAttachShader(program, fragmentShader);
519 glLinkProgram(program);
520
521 GLint success;
522 glGetProgramiv(program, GL_LINK_STATUS, &success);
523 char log[512];
524 if (!success) {
525
526 glGetProgramInfoLog(program, 512, NULL, log);
527 printf("Shader link error:\\n%s\\n", log);
528 exit(0);
529 return 0;
530 } else {
531 glGetProgramInfoLog(program, 512, NULL, log);
532 if (strlen(log) > 0) {
533 printf("Shader link warning:\\n%s\\n", log);
534 }
535}
536
537 glDeleteShader(vertexShader);
538 glDeleteShader(fragmentShader);
539
540 return program;
541}
542
544{
545
546 for (int i = 0; i < UBERSHADER_VERSIONS; i++)
547 {
548
549 ShaderProgram * dynamic_shader = &DYNAMIC_SHADER[i];
550 sprintf(dynamic_shader->vert_path, "../src/render/dynamic.vert");
551 sprintf(dynamic_shader->geom_path, "../src/render/dynamic.geom");
552 sprintf(dynamic_shader->frag_path, "../src/render/dynamic.frag");
553
554
555 dynamic_shader->program = create_ubershader_program(dynamic_shader->vert_path, dynamic_shader->geom_path, dynamic_shader->frag_path, i);
556 }
557
558
559 sprintf(DYNAMIC_SHADER[DVIEW_DEFAULT].name, "default");
560 sprintf(DYNAMIC_SHADER[DVIEW_ALBEDO].name, "albedo");
561 sprintf(DYNAMIC_SHADER[DVIEW_ARM].name, "arm");
562 sprintf(DYNAMIC_SHADER[DVIEW_EMISSIVE].name, "em");
563 sprintf(DYNAMIC_SHADER[DVIEW_AO].name, "ao");
564 sprintf(DYNAMIC_SHADER[DVIEW_UV].name, "uv");
565 sprintf(DYNAMIC_SHADER[DVIEW_POM_VDIR].name, "pom_vdir");
566 sprintf(DYNAMIC_SHADER[DVIEW_CLUSTERS].name, "clusters");
567 sprintf(DYNAMIC_SHADER[DVIEW_NORMAL].name, "normal");
568 sprintf(DYNAMIC_SHADER[DVIEW_ORIGINAL_NORMAL].name, "original_normal");
569 sprintf(DYNAMIC_SHADER[DVIEW_DIRECT].name, "direct");
570 sprintf(DYNAMIC_SHADER[DVIEW_INDIRECT].name, "indirect");
571 sprintf(DYNAMIC_SHADER[DVIEW_LM_IRRADIANCE].name, "lm_irradiance");
572 sprintf(DYNAMIC_SHADER[DVIEW_LM_DIRECTIONAL].name, "lm_directional");
573 sprintf(DYNAMIC_SHADER[DVIEW_RPROBE].name, "rprobe");
574 sprintf(DYNAMIC_SHADER[DVIEW_SPECULAR].name, "specular");
575 sprintf(DYNAMIC_SHADER[DVIEW_MAX].name, "POM");
576
577
578
579 for (int i = 0; i < UBERSHADER_VERSIONS; i++)
580 {
581
582 ShaderProgram * dynamic_shader = &DYNAMIC_SHADER[i];
583 dynamic_shader->uniforms[0].location = glGetUniformLocation(dynamic_shader->program, "uLightmap");
584 sprintf(dynamic_shader->uniforms[0].name, "uLightmap");
585 dynamic_shader->uniforms[1].location = glGetUniformLocation(dynamic_shader->program, "use_probe");
586 sprintf(dynamic_shader->uniforms[1].name, "use_probe");
587 dynamic_shader->uniforms[2].location = glGetUniformLocation(dynamic_shader->program, "index_offset");
588 sprintf(dynamic_shader->uniforms[2].name, "lm_offset");
589 dynamic_shader->uniforms[3].location = glGetUniformLocation(dynamic_shader->program, "material");
590 sprintf(dynamic_shader->uniforms[3].name, "material");
591 dynamic_shader->uniforms[4].location = glGetUniformLocation(dynamic_shader->program, "uShadowmap");
592 sprintf(dynamic_shader->uniforms[4].name, "uShadowmap");
593 dynamic_shader->uniforms[5].location = glGetUniformLocation(dynamic_shader->program, "probe_tex");
594 sprintf(dynamic_shader->uniforms[5].name, "probe_tex");
595 dynamic_shader->uniforms[6].location = glGetUniformLocation(dynamic_shader->program, "uSkybox");
596 sprintf(dynamic_shader->uniforms[6].name, "uSkybox");
597 dynamic_shader->uniforms[7].location = glGetUniformLocation(dynamic_shader->program, "uBRDFLUT");
598 sprintf(dynamic_shader->uniforms[7].name, "uBRDFLUT");
599 dynamic_shader->uniforms[8].location = glGetUniformLocation(dynamic_shader->program, "uTime");
600 sprintf(dynamic_shader->uniforms[8].name, "uTime");
601 dynamic_shader->uniforms[9].location = glGetUniformLocation(dynamic_shader->program, "uRProbe");
602 sprintf(dynamic_shader->uniforms[9].name, "uRProbe");
603 dynamic_shader->uniforms[10].location = glGetUniformLocation(dynamic_shader->program, "uFBM");
604 sprintf(dynamic_shader->uniforms[10].name, "uFBM");
605 dynamic_shader->uniforms[11].location = glGetUniformLocation(dynamic_shader->program, "probe_bake");
606 sprintf(dynamic_shader->uniforms[11].name, "probe_bake");
607 dynamic_shader->uniforms[12].location = glGetUniformLocation(dynamic_shader->program, "index_offset");
608 sprintf(dynamic_shader->uniforms[12].name, "index_count");
609 dynamic_shader->uniforms[13].location = glGetUniformLocation(dynamic_shader->program, "index_offset");
610 sprintf(dynamic_shader->uniforms[13].name, "start_index");
611 dynamic_shader->uniforms[14].location = glGetUniformLocation(dynamic_shader->program, "uDirectionalmap");
612 sprintf(dynamic_shader->uniforms[14].name, "uDirectionalmap");
613 dynamic_shader->uniforms[15].location = glGetUniformLocation(dynamic_shader->program, "probe_spacing");
614 sprintf(dynamic_shader->uniforms[15].name, "probe_spacing");
615 dynamic_shader->uniforms[16].location = glGetUniformLocation(dynamic_shader->program, "probe_origin");
616 sprintf(dynamic_shader->uniforms[16].name, "probe_origin");
617 dynamic_shader->uniforms[17].location = glGetUniformLocation(dynamic_shader->program, "probe_grid_size");
618 sprintf(dynamic_shader->uniforms[17].name, "probe_grid_size");
619 dynamic_shader->uniforms[18].location = glGetUniformLocation(dynamic_shader->program, "uDiffuse");
620 sprintf(dynamic_shader->uniforms[18].name, "gAlbedo");
621 dynamic_shader->uniforms[19].location = glGetUniformLocation(dynamic_shader->program, "uNormal");
622 sprintf(dynamic_shader->uniforms[19].name, "uNormal");
623 dynamic_shader->uniforms[20].location = glGetUniformLocation(dynamic_shader->program, "uARM");
624 sprintf(dynamic_shader->uniforms[20].name, "uARM");
625 dynamic_shader->uniforms[21].location = glGetUniformLocation(dynamic_shader->program, "uEmissive");
626 sprintf(dynamic_shader->uniforms[21].name, "uEmissive");
627 dynamic_shader->uniforms[22].location = glGetUniformLocation(dynamic_shader->program, "uSSAO");
628 sprintf(dynamic_shader->uniforms[22].name, "uSSAO");
629 dynamic_shader->uniforms[23].location = glGetUniformLocation(dynamic_shader->program, "uLPVDepthPadded");
630 sprintf(dynamic_shader->uniforms[23].name, "uLPVDepthPadded");
631 }
632
633}
634
636{
637 sprintf(SHADOW_MAP_SHADER.vert_path, "../src/render/shadow.vert");
638 sprintf(SHADOW_MAP_SHADER.frag_path, "../src/render/shadow.frag");
639
641
642
643 sprintf(SHADOW_MAP_SHADER.uniforms[0].name, "projection");
644 SHADOW_MAP_SHADER.uniforms[0].location = glGetUniformLocation(SHADOW_MAP_SHADER.program, "projection");
645 sprintf(SHADOW_MAP_SHADER.uniforms[1].name, "view");
646 SHADOW_MAP_SHADER.uniforms[1].location = glGetUniformLocation(SHADOW_MAP_SHADER.program, "view");
647
648
649 sprintf(POINT_LIGHT_SHADOW_SHADER.vert_path, "../src/render/point_light_shadows.vert");
650 sprintf(POINT_LIGHT_SHADOW_SHADER.geom_path, "../src/render/point_light_shadows.geom");
651 sprintf(POINT_LIGHT_SHADOW_SHADER.frag_path, "../src/render/point_light_shadows.frag");
652 // POINT_LIGHT_SHADOW_SHADER.program = create_shader_program(POINT_LIGHT_SHADOW_SHADER.vert_path, POINT_LIGHT_SHADOW_SHADER.frag_path);
654
655 sprintf(POINT_LIGHT_SHADOW_SHADER.uniforms[0].name, "vp");
657 sprintf(POINT_LIGHT_SHADOW_SHADER.uniforms[1].name, "uLightPos");
658 POINT_LIGHT_SHADOW_SHADER.uniforms[1].location = glGetUniformLocation(POINT_LIGHT_SHADOW_SHADER.program, "uLightPos");
659 sprintf(POINT_LIGHT_SHADOW_SHADER.uniforms[2].name, "uFar");
661 sprintf(POINT_LIGHT_SHADOW_SHADER.uniforms[3].name, "uLayerOffset");
662 POINT_LIGHT_SHADOW_SHADER.uniforms[3].location = glGetUniformLocation(POINT_LIGHT_SHADOW_SHADER.program, "uLayerOffset");
663}
664
666{
667 sprintf(WIREFRAME_SHADER.vert_path, "../src/render/wireframe.vert");
668 sprintf(WIREFRAME_SHADER.frag_path, "../src/render/wireframe.frag");
669
671
672}
673
674
676{
677
678
679 uint32_t perm_count = 1 << PP_MAX;
680 uint32_t * permutations = calloc(perm_count, sizeof(uint32_t));
681 for (int i = 0; i < perm_count; i++)
682 {
683 int count = 0;
684 for (int j = perm_count-1; j >= 0; j--)
685 {
686 permutations[i] |= ((i >> j) & 1) << j;
687 count++;
688 }
689 }
690
691 PP_SHADER_VERSIONS = perm_count;
692
693 for (int i = 0; i < perm_count; i++)
694 {
695
696 sprintf(POSTPROCESS_SHADER[i].vert_path, "../src/render/postprocess.vert");
697 sprintf(POSTPROCESS_SHADER[i].frag_path, "../src/render/postprocess.frag");
698 POSTPROCESS_SHADER[i].program = create_postprocess_program(POSTPROCESS_SHADER[i].vert_path, POSTPROCESS_SHADER[i].frag_path, permutations[i], false, 0);
699 POSTPROCESS_SHADER[i].perm = permutations[i];
700 }
701 for (int i = perm_count; i < perm_count + PPDVIEW_MAX - 1; i++)
702 {
703
704 sprintf(POSTPROCESS_SHADER[i].vert_path, "../src/render/postprocess.vert");
705 sprintf(POSTPROCESS_SHADER[i].frag_path, "../src/render/postprocess.frag");
706 POSTPROCESS_SHADER[i].program = create_postprocess_program(POSTPROCESS_SHADER[i].vert_path, POSTPROCESS_SHADER[i].frag_path, 0, true, i - perm_count + 1);
707 }
708
709 for (int i = 0; i < perm_count + PPDVIEW_MAX - 1; i++)
710 {
711 sprintf(POSTPROCESS_SHADER[i].uniforms[0].name, "uScene");
712 POSTPROCESS_SHADER[i].uniforms[0].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uScene");
713 sprintf(POSTPROCESS_SHADER[i].uniforms[1].name, "uHistory");
714 POSTPROCESS_SHADER[i].uniforms[1].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uHistory");
715 sprintf(POSTPROCESS_SHADER[i].uniforms[2].name, "uTime");
716 POSTPROCESS_SHADER[i].uniforms[2].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uTime");
717 sprintf(POSTPROCESS_SHADER[i].uniforms[3].name, "uMBLUR");
718 POSTPROCESS_SHADER[i].uniforms[3].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uMBLUR");
719 sprintf(POSTPROCESS_SHADER[i].uniforms[4].name, "uTAA");
720 POSTPROCESS_SHADER[i].uniforms[4].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uTAA");
721 sprintf(POSTPROCESS_SHADER[i].uniforms[5].name, "uFBM");
722 POSTPROCESS_SHADER[i].uniforms[5].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uFBM");
723 sprintf(POSTPROCESS_SHADER[i].uniforms[6].name, "uDPP");
724 POSTPROCESS_SHADER[i].uniforms[6].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uDPP");
725 sprintf(POSTPROCESS_SHADER[i].uniforms[7].name, "uText");
726 POSTPROCESS_SHADER[i].uniforms[7].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uText");
727 sprintf(POSTPROCESS_SHADER[i].uniforms[8].name, "uSSR");
728 POSTPROCESS_SHADER[i].uniforms[8].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uSSR");
729 sprintf(POSTPROCESS_SHADER[i].uniforms[9].name, "uCurrentSSR");
730 POSTPROCESS_SHADER[i].uniforms[9].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uCurrentSSR");
731 sprintf(POSTPROCESS_SHADER[i].uniforms[10].name, "gVel");
732 POSTPROCESS_SHADER[i].uniforms[10].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "gVel");
733 sprintf(POSTPROCESS_SHADER[i].uniforms[11].name, "uBokeh");
734 POSTPROCESS_SHADER[i].uniforms[11].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uBokeh");
735 sprintf(POSTPROCESS_SHADER[i].uniforms[12].name, "uCOC");
736 POSTPROCESS_SHADER[i].uniforms[12].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uCOC");
737 sprintf(POSTPROCESS_SHADER[i].uniforms[13].name, "uDOF");
738 POSTPROCESS_SHADER[i].uniforms[13].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uDOF");
739 sprintf(POSTPROCESS_SHADER[i].uniforms[14].name, "uBloom");
740 POSTPROCESS_SHADER[i].uniforms[14].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uBloom");
741 sprintf(POSTPROCESS_SHADER[i].uniforms[15].name, "uLUT");
742 POSTPROCESS_SHADER[i].uniforms[15].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uLUT");
743 sprintf(POSTPROCESS_SHADER[i].uniforms[16].name, "uFocalLength");
744 POSTPROCESS_SHADER[i].uniforms[16].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uFocalLength");
745 sprintf(POSTPROCESS_SHADER[i].uniforms[17].name, "uFStop");
746 POSTPROCESS_SHADER[i].uniforms[17].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uFStop");
747 sprintf(POSTPROCESS_SHADER[i].uniforms[18].name, "uSensorHeight");
748 POSTPROCESS_SHADER[i].uniforms[18].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uSensorHeight");
749 sprintf(POSTPROCESS_SHADER[i].uniforms[19].name, "uDOFMaxBlurRadius");
750 POSTPROCESS_SHADER[i].uniforms[19].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uDOFMaxBlurRadius");
751 sprintf(POSTPROCESS_SHADER[i].uniforms[20].name, "uLM");
752 POSTPROCESS_SHADER[i].uniforms[20].location = glGetUniformLocation(POSTPROCESS_SHADER[i].program, "uLM");
753
754 }
755
756
757
758
759 free(permutations);
760
761}
763{
764
765 sprintf(BRDF_SHADER.vert_path, "../src/render/postprocess.vert");
766 sprintf(BRDF_SHADER.frag_path, "../src/utilities/brdf.frag");
767
769
770
771 BRDF_SHADER.uniforms[0].location = glGetUniformLocation(BRDF_SHADER.program, "uScene");
772 sprintf(BRDF_SHADER.uniforms[0].name, "uScene");
773
774}
776{
777
778 sprintf(SKY_SHADER.vert_path, "../src/render/sky.vert");
779 sprintf(SKY_SHADER.frag_path, "../src/render/sky.frag");
780
782 SKY_SHADER.uniforms[0].location = glGetUniformLocation(SKY_SHADER.program, "uCubemap");
783 sprintf(SKY_SHADER.uniforms[0].name, "uCubemap");
784
785}
787{
788
789 sprintf(LIGHTMAP_SHADER.vert_path, "../src/light/lightmap.vert");
790 sprintf(LIGHTMAP_SHADER.frag_path, "../src/light/lightmap.frag");
791
793
794}
796{
797
798 sprintf(TEXT_SHADER.vert_path, "../src/ui/text.vert");
799 sprintf(TEXT_SHADER.frag_path, "../src/ui/text.frag");
800
802
803 sprintf(TEXT_SHADER.uniforms[0].name, "uOrtho");
804 TEXT_SHADER.uniforms[0].location = glGetUniformLocation(TEXT_SHADER.program, "uOrtho");
805 sprintf(TEXT_SHADER.uniforms[1].name, "uFontAtlas");
806 TEXT_SHADER.uniforms[1].location = glGetUniformLocation(TEXT_SHADER.program, "uFontAtlas");
807 sprintf(TEXT_SHADER.uniforms[2].name, "uShadowPass");
808 TEXT_SHADER.uniforms[2].location = glGetUniformLocation(TEXT_SHADER.program, "uShadowPass");
809
810}
812{
813
814 sprintf(UI_SHADER.vert_path, "../src/ui/ui.vert");
815 sprintf(UI_SHADER.frag_path, "../src/ui/ui.frag");
816
818
819 sprintf(UI_SHADER.uniforms[0].name, "uOrtho");
820 UI_SHADER.uniforms[0].location = glGetUniformLocation(UI_SHADER.program, "uOrtho");
821 sprintf(UI_SHADER.uniforms[1].name, "uShadowPass");
822 UI_SHADER.uniforms[1].location = glGetUniformLocation(UI_SHADER.program, "uShadowPass");
823
824}
826{
827
828 // sprintf(SSR_SHADER.vert_path, "./postprocess.vert");
829 // sprintf(SSR_SHADER.frag_path, "./ssr.frag");
830
831 // SSR_SHADER.program = create_shader_program(SSR_SHADER.vert_path, SSR_SHADER.frag_path);
832 // sprintf(SSR_SHADER.uniforms[0].name, "gNormal");
833 // SSR_SHADER.uniforms[0].location = glGetUniformLocation(SSR_SHADER.program, "gNormal");
834 // sprintf(SSR_SHADER.uniforms[1].name, "gDepth");
835 // SSR_SHADER.uniforms[1].location = glGetUniformLocation(SSR_SHADER.program, "gDepth");
836 // sprintf(SSR_SHADER.uniforms[2].name, "gAlbedo");
837 // SSR_SHADER.uniforms[2].location = glGetUniformLocation(SSR_SHADER.program, "gAlbedo");
838 // sprintf(SSR_SHADER.uniforms[3].name, "gExtra");
839 // SSR_SHADER.uniforms[3].location = glGetUniformLocation(SSR_SHADER.program, "gExtra");
840 // sprintf(SSR_SHADER.uniforms[4].name, "uScene");
841 // SSR_SHADER.uniforms[4].location = glGetUniformLocation(SSR_SHADER.program, "uScene");
842 // sprintf(SSR_SHADER.uniforms[5].name, "uTime");
843 // SSR_SHADER.uniforms[5].location = glGetUniformLocation(SSR_SHADER.program, "uTime");
844
845 // sprintf(SSR_BLUR_SHADER.vert_path, "./postprocess.vert");
846 // sprintf(SSR_BLUR_SHADER.frag_path, "./ssr_blur.frag");
847
848 // SSR_BLUR_SHADER.program = create_shader_program(SSR_BLUR_SHADER.vert_path, SSR_BLUR_SHADER.frag_path);
849
850 // sprintf(SSR_BLUR_SHADER.uniforms[0].name, "uSSRInput");
851 // SSR_BLUR_SHADER.uniforms[0].location = glGetUniformLocation(SSR_BLUR_SHADER.program, "uSSRInput");
852 // sprintf(SSR_BLUR_SHADER.uniforms[1].name, "gDepth");
853 // SSR_BLUR_SHADER.uniforms[1].location = glGetUniformLocation(SSR_BLUR_SHADER.program, "gDepth");
854 // sprintf(SSR_BLUR_SHADER.uniforms[2].name, "gNormal");
855 // SSR_BLUR_SHADER.uniforms[2].location = glGetUniformLocation(SSR_BLUR_SHADER.program, "gNormal");
856 // sprintf(SSR_BLUR_SHADER.uniforms[3].name, "gExtra");
857 // SSR_BLUR_SHADER.uniforms[3].location = glGetUniformLocation(SSR_BLUR_SHADER.program, "gExtra");
858
859 // sprintf(SSR_HISTORY_SHADER.vert_path, "./postprocess.vert");
860 // sprintf(SSR_HISTORY_SHADER.frag_path, "./ssr_history.frag");
861 // SSR_HISTORY_SHADER.program = create_shader_program(SSR_HISTORY_SHADER.vert_path, SSR_HISTORY_SHADER.frag_path);
862
863 // sprintf(SSR_HISTORY_SHADER.uniforms[0].name, "uSSR");
864 // SSR_HISTORY_SHADER.uniforms[0].location = glGetUniformLocation(SSR_HISTORY_SHADER.program, "uSSR");
865 // sprintf(SSR_HISTORY_SHADER.uniforms[1].name, "uScene");
866 // SSR_HISTORY_SHADER.uniforms[1].location = glGetUniformLocation(SSR_HISTORY_SHADER.program, "uScene");
867 // sprintf(SSR_HISTORY_SHADER.uniforms[2].name, "uHistorySSR");
868 // SSR_HISTORY_SHADER.uniforms[2].location = glGetUniformLocation(SSR_HISTORY_SHADER.program, "uHistorySSR");
869 // sprintf(SSR_HISTORY_SHADER.uniforms[3].name, "gVel");
870 // SSR_HISTORY_SHADER.uniforms[3].location = glGetUniformLocation(SSR_HISTORY_SHADER.program, "gVel");
871
872 // sprintf(SSR_HISTORY_SHADER.uniforms[4].name, "gDepth");
873 // SSR_HISTORY_SHADER.uniforms[4].location = glGetUniformLocation(SSR_HISTORY_SHADER.program, "gDepth");
874 // sprintf(SSR_HISTORY_SHADER.uniforms[5].name, "uJitterOffset");
875 // SSR_HISTORY_SHADER.uniforms[5].location = glGetUniformLocation(SSR_HISTORY_SHADER.program, "uJitterOffset");
876
877}
879{
880
881
882 LIGHTMAP_BOUNCE_SHADER = create_compute_shader("../src/light/lightmap_bounce.comp");
883 LIGHTMAP_DENOISE_SHADER = create_compute_shader("../src/light/lightmap_denoise.comp");
884 LIGHTMAP_DILATE_SHADER = create_compute_shader("../src/light/lightmap_dilate.comp");
885 PROBE_BAKE_SHADER = create_compute_shader("../src/light/probe_bake.comp");
886 PROBE_UNPACK_SHADER = create_compute_shader("../src/light/probe_unpack.comp");
887 DIRECTIONAL_MAP_NORMALIZE_SHADER = create_compute_shader("../src/light/directional_map_normalize.comp");
888
889}
891{
892
893 INIT_CLUSTER_AABBS_SHADER = create_compute_shader("../src/render/init_cluster_aabbs.comp");
894
895
896 CULL_CLUSTERS_SHADER.program = create_compute_shader("../src/render/cull_clusters.comp");
897 sprintf(CULL_CLUSTERS_SHADER.uniforms[0].name, "uGridSize");
898 CULL_CLUSTERS_SHADER.uniforms[0].location = glGetUniformLocation(CULL_CLUSTERS_SHADER.program, "uGridSize");
899 sprintf(CULL_CLUSTERS_SHADER.uniforms[1].name, "uNear");
900 CULL_CLUSTERS_SHADER.uniforms[1].location = glGetUniformLocation(CULL_CLUSTERS_SHADER.program, "uNear");
901 sprintf(CULL_CLUSTERS_SHADER.uniforms[2].name, "uFar");
902 CULL_CLUSTERS_SHADER.uniforms[2].location = glGetUniformLocation(CULL_CLUSTERS_SHADER.program, "uFar");
903 sprintf(CULL_CLUSTERS_SHADER.uniforms[3].name, "uMaxLightsPerCluster");
904 CULL_CLUSTERS_SHADER.uniforms[3].location = glGetUniformLocation(CULL_CLUSTERS_SHADER.program, "uMaxLightsPerCluster");
905 sprintf(CULL_CLUSTERS_SHADER.uniforms[4].name, "uLightCount");
906 CULL_CLUSTERS_SHADER.uniforms[4].location = glGetUniformLocation(CULL_CLUSTERS_SHADER.program, "uLightCount");
907
908}
910{
911
912 sprintf(CULL_DRAW_CALLS_SHADER.vert_path, "../src/render/cull_draw_calls.comp");
913 CULL_DRAW_CALLS_SHADER.program = create_compute_shader("../src/render/cull_draw_calls.comp");
914
915 sprintf(CULL_DRAW_CALLS_SHADER.uniforms[0].name, "uInstanceCount");
916 CULL_DRAW_CALLS_SHADER.uniforms[0].location = glGetUniformLocation(CULL_DRAW_CALLS_SHADER.program, "uInstanceCount");
917 sprintf(CULL_DRAW_CALLS_SHADER.uniforms[1].name, "planes");
918 CULL_DRAW_CALLS_SHADER.uniforms[1].location = glGetUniformLocation(CULL_DRAW_CALLS_SHADER.program, "planes");
919 sprintf(CULL_DRAW_CALLS_SHADER.uniforms[2].name, "uArrayOffset");
920 CULL_DRAW_CALLS_SHADER.uniforms[2].location = glGetUniformLocation(CULL_DRAW_CALLS_SHADER.program, "uArrayOffset");
921
922
923 sprintf(INDIRECT_PREFIX_SHADER.vert_path, "../src/render/indirect_prefix.comp");
924 INDIRECT_PREFIX_SHADER.program = create_compute_shader("../src/render/indirect_prefix.comp");
925
926 sprintf(INDIRECT_PREFIX_SHADER.uniforms[0].name, "n");
928
929 sprintf(ELEMENTS_PREFIX_SHADER.vert_path, "../src/render/elements_prefix.comp");
930 ELEMENTS_PREFIX_SHADER.program = create_compute_shader("../src/render/elements_prefix.comp");
931 sprintf(ELEMENTS_PREFIX_SHADER.uniforms[0].name, "n");
933
934
935
936
937 sprintf(CULL_POINT_LIGHT_SHADOWS_SHADER.vert_path, "../src/render/cull_point_light_shadows.comp");
938 CULL_POINT_LIGHT_SHADOWS_SHADER.program = create_compute_shader("../src/render/cull_point_light_shadows.comp");
939
940 sprintf(CULL_POINT_LIGHT_SHADOWS_SHADER.uniforms[0].name, "uLightPos");
942 sprintf(CULL_POINT_LIGHT_SHADOWS_SHADER.uniforms[1].name, "uLightRadius");
944 sprintf(CULL_POINT_LIGHT_SHADOWS_SHADER.uniforms[2].name, "uInstanceCount");
946
947 sprintf(CULL_POINT_LIGHT_SHADOWS_SHADER.uniforms[3].name, "uArrayOffset");
949
950
951
952}
953// void init_rprobe_shader()
954// {
955// sprintf(GGX_RPROBE_SHADER.vert_path, "./ggx_rprobe.vert");
956// sprintf(GGX_RPROBE_SHADER.frag_path, "./ggx_rprobe.frag");
957
958// GGX_RPROBE_SHADER.program = create_shader_program(GGX_RPROBE_SHADER.vert_path, GGX_RPROBE_SHADER.frag_path);
959// }
960
962{
963 AUDIO_PROBE_BAKE_SHADER = create_compute_shader("../src/audio/audio_probe_bake.comp");
964
965}
966
968{
969
970 sprintf(DEPTH_PRE_PASS_SHADER[0].name, "default");
971 // sprintf(DEPTH_PRE_PASS_SHADER[1].name, "POM");
972
973 for (int i = 0; i < GBUFFER_VERSIONS; i++)
974 {
975 sprintf(DEPTH_PRE_PASS_SHADER[i].vert_path, "../src/render/depth_pre_pass.vert");
976 sprintf(DEPTH_PRE_PASS_SHADER[i].frag_path, "../src/render/depth_pre_pass.frag");
978 }
979 sprintf(DEPTH_PRE_PASS_SHADER_MSAA[0].name, "default");
980 // sprintf(DEPTH_PRE_PASS_SHADER_MSAA[1].name, "POM");
981
982 for (int i = 0; i < GBUFFER_VERSIONS; i++)
983 {
984 sprintf(DEPTH_PRE_PASS_SHADER_MSAA[i].vert_path, "../src/render/depth_pre_pass_no_gbuffer.vert");
985 sprintf(DEPTH_PRE_PASS_SHADER_MSAA[i].frag_path, "../src/render/depth_pre_pass_no_gbuffer.frag");
987 }
988
989
990 sprintf(DEPTH_DOWNSAMPLE_SHADER.vert_path, "../src/render/postprocess.vert");
991 sprintf(DEPTH_DOWNSAMPLE_SHADER.frag_path, "../src/render/depth_downsample.frag");
992
993
995 sprintf(DEPTH_DOWNSAMPLE_SHADER.uniforms[0].name, "uDepth");
996 DEPTH_DOWNSAMPLE_SHADER.uniforms[0].location = glGetUniformLocation(DEPTH_DOWNSAMPLE_SHADER.program, "uDepth");
997}
999{
1000
1001 sprintf(SSAO_SHADER.vert_path, "../src/render/postprocess.vert");
1002 sprintf(SSAO_SHADER.frag_path, "../src/render/ssao.frag");
1003
1005
1006 sprintf(SSAO_SHADER.uniforms[0].name, "uDepth");
1007 SSAO_SHADER.uniforms[0].location = glGetUniformLocation(SSAO_SHADER.program, "uDepth");
1008 sprintf(SSAO_SHADER.uniforms[1].name, "gNormal");
1009 SSAO_SHADER.uniforms[1].location = glGetUniformLocation(SSAO_SHADER.program, "gNormal");
1010 sprintf(SSAO_SHADER.uniforms[2].name, "uNoise");
1011 SSAO_SHADER.uniforms[2].location = glGetUniformLocation(SSAO_SHADER.program, "uNoise");
1012 sprintf(SSAO_SHADER.uniforms[3].name, "uSSAOResolution");
1013 SSAO_SHADER.uniforms[3].location = glGetUniformLocation(SSAO_SHADER.program, "uSSAOResolution");
1014
1015
1016 sprintf(SSAO_BLUR_SHADER.vert_path, "../src/render/postprocess.vert");
1017 sprintf(SSAO_BLUR_SHADER.frag_path, "../src/render/ssao_blur.frag");
1018
1020 sprintf(SSAO_BLUR_SHADER.uniforms[0].name, "uSSAOInput");
1021 SSAO_BLUR_SHADER.uniforms[0].location = glGetUniformLocation(SSAO_BLUR_SHADER.program, "uSSAOInput");
1022 sprintf(SSAO_BLUR_SHADER.uniforms[1].name, "uDepth");
1023 SSAO_BLUR_SHADER.uniforms[1].location = glGetUniformLocation(SSAO_BLUR_SHADER.program, "uDepth");
1024
1025}
1026
1028{
1029
1030 sprintf(COC_SHADER.vert_path, "../src/render/postprocess.vert");
1031 sprintf(COC_SHADER.frag_path, "../src/render/coc.frag");
1032
1034
1035
1036 sprintf(COC_SHADER.uniforms[0].name, "gDepth");
1037 COC_SHADER.uniforms[0].location = glGetUniformLocation(COC_SHADER.program, "gDepth");
1038
1039 sprintf(COC_SHADER.uniforms[1].name, "uScene");
1040 COC_SHADER.uniforms[1].location = glGetUniformLocation(COC_SHADER.program, "uScene");
1041
1042 sprintf(COC_SHADER.uniforms[2].name, "uFocalLength");
1043 COC_SHADER.uniforms[2].location = glGetUniformLocation(COC_SHADER.program, "uFocalLength");
1044
1045 sprintf(COC_SHADER.uniforms[3].name, "uFStop");
1046 COC_SHADER.uniforms[3].location = glGetUniformLocation(COC_SHADER.program, "uFStop");
1047
1048 sprintf(COC_SHADER.uniforms[4].name, "uSensorHeight");
1049 COC_SHADER.uniforms[4].location = glGetUniformLocation(COC_SHADER.program, "uSensorHeight");
1050
1051 sprintf(COC_SHADER.uniforms[5].name, "uMaxBlurRadius");
1052 COC_SHADER.uniforms[5].location = glGetUniformLocation(COC_SHADER.program, "uMaxBlurRadius");
1053
1054 sprintf(BOKEH_SHADER.vert_path, "../src/render/postprocess.vert");
1055 sprintf(BOKEH_SHADER.frag_path, "../src/render/bokeh.frag");
1056
1058
1059
1060 sprintf(BOKEH_SHADER.uniforms[0].name, "uCOC");
1061 BOKEH_SHADER.uniforms[0].location = glGetUniformLocation(BOKEH_SHADER.program, "uCOC");
1062
1063 sprintf(BOKEH_SHADER.uniforms[1].name, "uTexelSize");
1064 BOKEH_SHADER.uniforms[1].location = glGetUniformLocation(BOKEH_SHADER.program, "uTexelSize");
1065
1066
1067
1068
1069
1070 sprintf(FOCAL_DISTANCE_SHADER.vert_path, "../src/render/focal_distance.comp");
1071 FOCAL_DISTANCE_SHADER.program = create_compute_shader("../src/render/focal_distance.comp");
1072
1073 sprintf(FOCAL_DISTANCE_SHADER.uniforms[0].name, "gDepth");
1074 FOCAL_DISTANCE_SHADER.uniforms[0].location = glGetUniformLocation(FOCAL_DISTANCE_SHADER.program, "gDepth");
1075 sprintf(FOCAL_DISTANCE_SHADER.uniforms[1].name, "uTexelSize");
1076 FOCAL_DISTANCE_SHADER.uniforms[1].location = glGetUniformLocation(FOCAL_DISTANCE_SHADER.program, "uTexelSize");
1077 sprintf(FOCAL_DISTANCE_SHADER.uniforms[2].name, "uResolution");
1078 FOCAL_DISTANCE_SHADER.uniforms[2].location = glGetUniformLocation(FOCAL_DISTANCE_SHADER.program, "uResolution");
1079 sprintf(FOCAL_DISTANCE_SHADER.uniforms[3].name, "uDT");
1080 FOCAL_DISTANCE_SHADER.uniforms[3].location = glGetUniformLocation(FOCAL_DISTANCE_SHADER.program, "uDT");
1081
1082
1083
1084}
1085
1087{
1088
1089 sprintf(BLOOM_SHADER.vert_path, "../src/render/postprocess.vert");
1090 sprintf(BLOOM_SHADER.frag_path, "../src/render/bloom.frag");
1091
1093
1094
1095 sprintf(BLOOM_SHADER.uniforms[0].name, "uScene");
1096 BLOOM_SHADER.uniforms[0].location = glGetUniformLocation(BLOOM_SHADER.program, "uScene");
1097
1098 sprintf(BLOOM_BLUR_SHADER.vert_path, "../src/render/postprocess.vert");
1099 sprintf(BLOOM_BLUR_SHADER.frag_path, "../src/render/bloom_blur.frag");
1100
1102
1103 sprintf(BLOOM_BLUR_SHADER.uniforms[0].name, "uBloom");
1104 BLOOM_BLUR_SHADER.uniforms[0].location = glGetUniformLocation(BLOOM_BLUR_SHADER.program, "uBloom");
1105 sprintf(BLOOM_BLUR_SHADER.uniforms[1].name, "uDirection");
1106 BLOOM_BLUR_SHADER.uniforms[1].location = glGetUniformLocation(BLOOM_BLUR_SHADER.program, "uDirection");
1107 sprintf(BLOOM_BLUR_SHADER.uniforms[2].name, "uTexel");
1108 BLOOM_BLUR_SHADER.uniforms[2].location = glGetUniformLocation(BLOOM_BLUR_SHADER.program, "uTexel");
1109
1110 sprintf(BLOOM_DOWNSCALE_SHADER.vert_path, "../src/render/postprocess.vert");
1111 sprintf(BLOOM_DOWNSCALE_SHADER.frag_path, "../src/render/bloom_downscale.frag");
1112
1114 sprintf(BLOOM_DOWNSCALE_SHADER.uniforms[0].name, "srcTexture");
1115 BLOOM_DOWNSCALE_SHADER.uniforms[0].location = glGetUniformLocation(BLOOM_DOWNSCALE_SHADER.program, "srcTexture");
1116
1117
1118 sprintf(BLOOM_UPSCALE_SHADER.vert_path, "../src/render/postprocess.vert");
1119 sprintf(BLOOM_UPSCALE_SHADER.frag_path, "../src/render/bloom_upscale.frag");
1120
1122
1123 sprintf(BLOOM_DOWNSCALE_SHADER.uniforms[0].name, "srcTexture");
1124 BLOOM_DOWNSCALE_SHADER.uniforms[0].location = glGetUniformLocation(BLOOM_DOWNSCALE_SHADER.program, "srcTexture");
1125 sprintf(BLOOM_UPSCALE_SHADER.uniforms[1].name, "uFilterRadius");
1126 BLOOM_UPSCALE_SHADER.uniforms[1].location = glGetUniformLocation(BLOOM_UPSCALE_SHADER.program, "uFilterRadius");
1127
1128}
1129
1130
1132{
1133
1134 glDeleteShader(LIGHTMAP_BOUNCE_SHADER);
1135 glDeleteShader(LIGHTMAP_DENOISE_SHADER);
1136 glDeleteShader(LIGHTMAP_DILATE_SHADER);
1137 glDeleteShader(PROBE_BAKE_SHADER);
1138 glDeleteShader(PROBE_UNPACK_SHADER);
1139 glDeleteShader(DIRECTIONAL_MAP_NORMALIZE_SHADER);
1140 for (int i = 0; i < UBERSHADER_VERSIONS; i++)
1141 {
1142 glDeleteShader(DYNAMIC_SHADER[i].program);
1143 }
1144 glDeleteShader(SHADOW_MAP_SHADER.program);
1145 glDeleteShader(WIREFRAME_SHADER.program);
1146 for (int i = 0; i < PP_SHADER_VERSIONS; i++)
1147 {
1148 glDeleteShader(POSTPROCESS_SHADER[i].program);
1149 }
1150 glDeleteShader(SKY_SHADER.program);
1151 glDeleteShader(LIGHTMAP_SHADER.program);
1152 glDeleteShader(BRDF_SHADER.program);
1153 for (int i = 0; i < GBUFFER_VERSIONS; i++)
1154 {
1155 glDeleteShader(DEPTH_PRE_PASS_SHADER[i].program);
1156 }
1157 glDeleteShader(POINT_LIGHT_SHADOW_SHADER.program);
1158 glDeleteShader(TEXT_SHADER.program);
1159 glDeleteShader(UI_SHADER.program);
1160 glDeleteShader(SSR_SHADER.program);
1161 glDeleteShader(SSR_BLUR_SHADER.program);
1162 glDeleteShader(SSR_HISTORY_SHADER.program);
1163 glDeleteShader(SSAO_SHADER.program);
1164 glDeleteShader(SSAO_BLUR_SHADER.program);
1165 glDeleteShader(COC_SHADER.program);
1166 glDeleteShader(BOKEH_SHADER.program);
1167 glDeleteShader(FOCAL_DISTANCE_SHADER.program);
1169 glDeleteShader(INDIRECT_PREFIX_SHADER.program);
1170 glDeleteShader(ELEMENTS_PREFIX_SHADER.program);
1171 glDeleteShader(CULL_DRAW_CALLS_SHADER.program);
1172 glDeleteShader(CULL_CLUSTERS_SHADER.program);
1173 glDeleteShader(BLOOM_SHADER.program);
1174 glDeleteShader(BLOOM_BLUR_SHADER.program);
1175 glDeleteShader(BLOOM_DOWNSCALE_SHADER.program);
1176 glDeleteShader(BLOOM_UPSCALE_SHADER.program);
1177 glDeleteShader(AUDIO_PROBE_BAKE_SHADER);
1178 glDeleteShader(INIT_CLUSTER_AABBS_SHADER);
1179
1180
1184
1189
1191
1194 // init_rprobe_shader();
1203
1204}
#define GBUFFER_VERSIONS
Maxmimum gbuffer shader branches.
char name[256]
@ PP_MBLUR
@ PP_LUT
@ PP_BLOOM
@ PP_DOF
@ PP_ACES
@ PP_MAX
@ PP_NOISE
GLuint program
Program handle.
char geom_path[256]
Path to geometry shader.
uint32_t perm
Which permutation of a shader branch this is.
char frag_path[256]
Path to fragment shader.
char vert_path[256]
Path to vertex shader (or compute shader).
#define UBERSHADER_VERSIONS
Maxmimum main shader brances.
PostprocessDView
Postprocess debug view shader branches.
@ PPDVIEW_LM
@ PPDVIEW_DEPTH
@ PPDVIEW_MAX
@ PPDVIEW_BOKEH
@ PPDVIEW_VEL
@ DVIEW_CLUSTERS
@ DVIEW_POM_VDIR
@ DVIEW_LM_DIRECTIONAL
@ DVIEW_AO
@ DVIEW_INDIRECT
@ DVIEW_NORMAL
@ DVIEW_DEFAULT
@ DVIEW_ALBEDO
@ DVIEW_RPROBE
@ DVIEW_SPECULAR
@ DVIEW_ARM
@ DVIEW_DIRECT
@ DVIEW_ORIGINAL_NORMAL
@ DVIEW_LM_IRRADIANCE
@ DVIEW_EMISSIVE
@ DVIEW_MAX
@ DVIEW_UV
GLuint location
Uniform uniforms[32]
Uniforms for shader data.
OpenGL ShaderPrograms: vertex, fragment, geometry, and compute.
Important globals for the entire engine and initialization functions that are mainly called on engine...
ShaderProgram INDIRECT_PREFIX_SHADER
render/indirect_prefix.comp
Definition main.c:122
GLuint INIT_CLUSTER_AABBS_SHADER
render/init_cluster_aabbs.comp
Definition main.c:274
ShaderProgram SSR_BLUR_SHADER
Definition main.c:108
ShaderProgram TEXT_SHADER
ui/text.vert ui/text.frag
Definition main.c:131
ShaderProgram SSAO_BLUR_SHADER
render/ssao_blur.frag
Definition main.c:106
ShaderProgram BLOOM_BLUR_SHADER
render/bloom_blur.frag
Definition main.c:113
ShaderProgram UI_SHADER
ui/ui.vert ui/ui.frag
Definition main.c:132
GLuint LIGHTMAP_BOUNCE_SHADER
light/lightmap_bounce.comp
Definition main.c:225
ShaderProgram COC_SHADER
render/coc.frag
Definition main.c:110
ShaderProgram DEPTH_PRE_PASS_SHADER[1]
render/depth_pre_pass.vert render/depth_pre_pass.frag
Definition main.c:116
ShaderProgram CULL_DRAW_CALLS_SHADER
render/cull_draw_calls.comp
Definition main.c:121
ShaderProgram POSTPROCESS_SHADER[128]
render/postprocess.vert render/postprocess.frag
Definition main.c:119
ShaderProgram CULL_POINT_LIGHT_SHADOWS_SHADER
render/cull_point_light_shadows.comp
Definition main.c:124
ShaderProgram DEPTH_DOWNSAMPLE_SHADER
render/depth_downsample.frag
Definition main.c:133
ShaderProgram LIGHTMAP_SHADER
light/lightmap.vert light/lightmap.frag
Definition main.c:128
GLuint LIGHTMAP_DILATE_SHADER
light/lightmap_dilate.comp
Definition main.c:227
ShaderProgram SKY_SHADER
render/sky.vert render/sky.frag
Definition main.c:127
GLuint PROBE_UNPACK_SHADER
light/probe_unpack.comp
Definition main.c:230
uint32_t PP_SHADER_VERSIONS
Definition main.c:272
ShaderProgram SSR_HISTORY_SHADER
Definition main.c:109
GLuint LIGHTMAP_DENOISE_SHADER
light/lightmap_denoise.comp
Definition main.c:226
GLuint DIRECTIONAL_MAP_NORMALIZE_SHADER
light/directional_map_normalize.comp
Definition main.c:231
ShaderProgram CULL_CLUSTERS_SHADER
render/cull_clusters.comp
Definition main.c:120
GLuint AUDIO_PROBE_BAKE_SHADER
audio/audio_probe_bake.comp
Definition main.c:229
ShaderProgram BLOOM_DOWNSCALE_SHADER
render/bloom_downscale.frag
Definition main.c:125
ShaderProgram SHADOW_MAP_SHADER
render/shadow.vert render/shadow.frag
Definition main.c:115
ShaderProgram POINT_LIGHT_SHADOW_SHADER
render/point_light_shadows.vert render/point_light_shadows.geom render/point_light_shadows....
Definition main.c:130
ShaderProgram WIREFRAME_SHADER
render/wireframe.vert render/wireframe.frag
Definition main.c:118
ShaderProgram ELEMENTS_PREFIX_SHADER
render/elements_prefix.comp
Definition main.c:123
ShaderProgram BLOOM_SHADER
render/bloom.frag
Definition main.c:112
ShaderProgram BLOOM_UPSCALE_SHADER
render/bloom_upscale.frag
Definition main.c:126
ShaderProgram SSAO_SHADER
render/ssao.frag
Definition main.c:105
ShaderProgram BRDF_SHADER
utilities/brdf.frag
Definition main.c:129
ShaderProgram SSR_SHADER
Definition main.c:107
ShaderProgram DYNAMIC_SHADER[32]
render/dynamic.vert render/dynamic.frag
Definition main.c:114
ShaderProgram DEPTH_PRE_PASS_SHADER_MSAA[1]
render/depth_pre_pass_no_gbuffer.vert render/depth_pre_pass_no_gbuffer.frag
Definition main.c:117
ShaderProgram BOKEH_SHADER
render/bokeh.frag
Definition main.c:111
ShaderProgram FOCAL_DISTANCE_SHADER
render/focal_distance.comp
Definition main.c:308
GLuint PROBE_BAKE_SHADER
light/probe_bake.comp
Definition main.c:228
void init_ssao_shader()
Definition shaders.c:998
void init_audio_shader()
Definition shaders.c:961
GLuint compile_uber_frag_shader(GLenum type, const char *filename, int i)
Definition shaders.c:198
GLuint create_geometry_shader_program(const char *vertexPath, const char *geometryPath, const char *fragmentPath)
Definition shaders.c:409
GLuint create_gbuffer_program(const char *vertexPath, const char *fragmentPath, int i)
Definition shaders.c:445
void init_text_shader()
Definition shaders.c:795
void init_brdf_shader()
Definition shaders.c:762
void init_sky_shader()
Definition shaders.c:775
void SHADERS_INIT()
Deletes and then recompiles and links all engine shaders.
Definition shaders.c:1131
GLuint compile_gbuffer_frag_shader(GLenum type, const char *filename, int i)
Definition shaders.c:105
GLuint create_ubershader_program(const char *vertexPath, const char *geometryPath, const char *fragmentPath, int i)
Definition shaders.c:478
GLuint create_shader_program(const char *vertex_path, const char *fragment_path)
Compiles and links vert and frag pairs.
Definition shaders.c:377
void init_dynamic_shader()
Definition shaders.c:543
void init_postprocess_shader()
Definition shaders.c:675
GLuint compile_shader(GLenum type, const char *filename)
Compiles a non-compute shader.
Definition shaders.c:77
void init_lightmap_bounce_compute_shader()
Definition shaders.c:878
void init_shadow_map_shader()
Definition shaders.c:635
GLuint create_postprocess_program(const char *vertexPath, const char *fragmentPath, int i, bool is_dview, PostprocessDView dview)
Definition shaders.c:511
GLuint compile_postprocess_shader(GLenum type, const char *filename, uint32_t PP_OPTIONS, bool is_dview, PostprocessDView dview)
Definition shaders.c:291
void init_bloom_shader()
Definition shaders.c:1086
char * read_file(const char *filename)
Reads a file into raw bytes.
Definition shaders.c:10
GLuint create_compute_shader(const char *filename)
Creates a compute shader.
Definition shaders.c:34
void init_cull_draw_calls_compute_shader()
Definition shaders.c:909
void init_ui_shader()
Definition shaders.c:811
void init_wireframe_shader()
Definition shaders.c:665
void init_dof_shader()
Definition shaders.c:1027
void init_cull_clusers_compute_shader()
Definition shaders.c:890
void init_SSR_shader()
Definition shaders.c:825
void init_lightmap_shader()
Definition shaders.c:786
void init_depth_pre_pass_shader()
Definition shaders.c:967
Initialization for ShaderPrograms.
const int size
Definition sky.frag:9