Cleanup: comments (long lines) in gpu
[blender.git] / source / blender / gpu / intern / gpu_codegen.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2005 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup gpu
22  *
23  * Convert material node-trees to GLSL.
24  */
25
26 #include "MEM_guardedalloc.h"
27
28 #include "DNA_customdata_types.h"
29 #include "DNA_image_types.h"
30 #include "DNA_material_types.h"
31 #include "DNA_node_types.h"
32
33 #include "BLI_blenlib.h"
34 #include "BLI_hash_mm2a.h"
35 #include "BLI_link_utils.h"
36 #include "BLI_utildefines.h"
37 #include "BLI_dynstr.h"
38 #include "BLI_ghash.h"
39 #include "BLI_threads.h"
40
41 #include "PIL_time.h"
42
43 #include "GPU_extensions.h"
44 #include "GPU_glew.h"
45 #include "GPU_material.h"
46 #include "GPU_shader.h"
47 #include "GPU_texture.h"
48 #include "GPU_uniformbuffer.h"
49
50 #include "BLI_sys_types.h" /* for intptr_t support */
51
52 #include "gpu_codegen.h"
53
54 #include <string.h>
55 #include <stdarg.h>
56
57 extern char datatoc_gpu_shader_material_glsl[];
58 extern char datatoc_gpu_shader_geometry_glsl[];
59
60 static char *glsl_material_library = NULL;
61
62 /* -------------------- GPUPass Cache ------------------ */
63 /**
64  * Internal shader cache: This prevent the shader recompilation / stall when
65  * using undo/redo AND also allows for GPUPass reuse if the Shader code is the
66  * same for 2 different Materials. Unused GPUPasses are free by Garbage collection.
67  */
68
69 /* Only use one linklist that contains the GPUPasses grouped by hash. */
70 static GPUPass *pass_cache = NULL;
71 static SpinLock pass_cache_spin;
72
73 static uint32_t gpu_pass_hash(const char *frag_gen, const char *defs, GPUVertAttrLayers *attrs)
74 {
75   BLI_HashMurmur2A hm2a;
76   BLI_hash_mm2a_init(&hm2a, 0);
77   BLI_hash_mm2a_add(&hm2a, (uchar *)frag_gen, strlen(frag_gen));
78   if (attrs) {
79     for (int att_idx = 0; att_idx < attrs->totlayer; att_idx++) {
80       char *name = attrs->layer[att_idx].name;
81       BLI_hash_mm2a_add(&hm2a, (uchar *)name, strlen(name));
82     }
83   }
84   if (defs)
85     BLI_hash_mm2a_add(&hm2a, (uchar *)defs, strlen(defs));
86
87   return BLI_hash_mm2a_end(&hm2a);
88 }
89
90 /* Search by hash only. Return first pass with the same hash.
91  * There is hash collision if (pass->next && pass->next->hash == hash) */
92 static GPUPass *gpu_pass_cache_lookup(uint32_t hash)
93 {
94   BLI_spin_lock(&pass_cache_spin);
95   /* Could be optimized with a Lookup table. */
96   for (GPUPass *pass = pass_cache; pass; pass = pass->next) {
97     if (pass->hash == hash) {
98       BLI_spin_unlock(&pass_cache_spin);
99       return pass;
100     }
101   }
102   BLI_spin_unlock(&pass_cache_spin);
103   return NULL;
104 }
105
106 /* Check all possible passes with the same hash. */
107 static GPUPass *gpu_pass_cache_resolve_collision(GPUPass *pass,
108                                                  const char *vert,
109                                                  const char *geom,
110                                                  const char *frag,
111                                                  const char *defs,
112                                                  uint32_t hash)
113 {
114   BLI_spin_lock(&pass_cache_spin);
115   /* Collision, need to strcmp the whole shader. */
116   for (; pass && (pass->hash == hash); pass = pass->next) {
117     if ((defs != NULL) && (strcmp(pass->defines, defs) != 0)) { /* Pass */
118     }
119     else if ((geom != NULL) && (strcmp(pass->geometrycode, geom) != 0)) { /* Pass */
120     }
121     else if ((strcmp(pass->fragmentcode, frag) == 0) && (strcmp(pass->vertexcode, vert) == 0)) {
122       BLI_spin_unlock(&pass_cache_spin);
123       return pass;
124     }
125   }
126   BLI_spin_unlock(&pass_cache_spin);
127   return NULL;
128 }
129
130 /* -------------------- GPU Codegen ------------------ */
131
132 /* type definitions and constants */
133
134 #define MAX_FUNCTION_NAME 64
135 #define MAX_PARAMETER 32
136
137 typedef enum {
138   FUNCTION_QUAL_IN,
139   FUNCTION_QUAL_OUT,
140   FUNCTION_QUAL_INOUT,
141 } GPUFunctionQual;
142
143 typedef struct GPUFunction {
144   char name[MAX_FUNCTION_NAME];
145   eGPUType paramtype[MAX_PARAMETER];
146   GPUFunctionQual paramqual[MAX_PARAMETER];
147   int totparam;
148 } GPUFunction;
149
150 /* Indices match the eGPUType enum */
151 static const char *GPU_DATATYPE_STR[17] = {
152     "",
153     "float",
154     "vec2",
155     "vec3",
156     "vec4",
157     NULL,
158     NULL,
159     NULL,
160     NULL,
161     "mat3",
162     NULL,
163     NULL,
164     NULL,
165     NULL,
166     NULL,
167     NULL,
168     "mat4",
169 };
170
171 /* GLSL code parsing for finding function definitions.
172  * These are stored in a hash for lookup when creating a material. */
173
174 static GHash *FUNCTION_HASH = NULL;
175 #if 0
176 static char *FUNCTION_PROTOTYPES = NULL;
177 static GPUShader *FUNCTION_LIB = NULL;
178 #endif
179
180 static int gpu_str_prefix(const char *str, const char *prefix)
181 {
182   while (*str && *prefix) {
183     if (*str != *prefix)
184       return 0;
185
186     str++;
187     prefix++;
188   }
189
190   return (*prefix == '\0');
191 }
192
193 static char *gpu_str_skip_token(char *str, char *token, int max)
194 {
195   int len = 0;
196
197   /* skip a variable/function name */
198   while (*str) {
199     if (ELEM(*str, ' ', '(', ')', ',', ';', '\t', '\n', '\r'))
200       break;
201     else {
202       if (token && len < max - 1) {
203         *token = *str;
204         token++;
205         len++;
206       }
207       str++;
208     }
209   }
210
211   if (token)
212     *token = '\0';
213
214   /* skip the next special characters:
215    * note the missing ')' */
216   while (*str) {
217     if (ELEM(*str, ' ', '(', ',', ';', '\t', '\n', '\r'))
218       str++;
219     else
220       break;
221   }
222
223   return str;
224 }
225
226 static void gpu_parse_functions_string(GHash *hash, char *code)
227 {
228   GPUFunction *function;
229   eGPUType type;
230   GPUFunctionQual qual;
231   int i;
232
233   while ((code = strstr(code, "void "))) {
234     function = MEM_callocN(sizeof(GPUFunction), "GPUFunction");
235
236     code = gpu_str_skip_token(code, NULL, 0);
237     code = gpu_str_skip_token(code, function->name, MAX_FUNCTION_NAME);
238
239     /* get parameters */
240     while (*code && *code != ')') {
241       /* test if it's an input or output */
242       qual = FUNCTION_QUAL_IN;
243       if (gpu_str_prefix(code, "out "))
244         qual = FUNCTION_QUAL_OUT;
245       if (gpu_str_prefix(code, "inout "))
246         qual = FUNCTION_QUAL_INOUT;
247       if ((qual != FUNCTION_QUAL_IN) || gpu_str_prefix(code, "in "))
248         code = gpu_str_skip_token(code, NULL, 0);
249
250       /* test for type */
251       type = GPU_NONE;
252       for (i = 1; i < ARRAY_SIZE(GPU_DATATYPE_STR); i++) {
253         if (GPU_DATATYPE_STR[i] && gpu_str_prefix(code, GPU_DATATYPE_STR[i])) {
254           type = i;
255           break;
256         }
257       }
258
259       if (!type && gpu_str_prefix(code, "samplerCube")) {
260         type = GPU_TEXCUBE;
261       }
262       if (!type && gpu_str_prefix(code, "sampler2DShadow")) {
263         type = GPU_SHADOW2D;
264       }
265       if (!type && gpu_str_prefix(code, "sampler1DArray")) {
266         type = GPU_TEX1D_ARRAY;
267       }
268       if (!type && gpu_str_prefix(code, "sampler2D")) {
269         type = GPU_TEX2D;
270       }
271       if (!type && gpu_str_prefix(code, "sampler3D")) {
272         type = GPU_TEX3D;
273       }
274
275       if (!type && gpu_str_prefix(code, "Closure")) {
276         type = GPU_CLOSURE;
277       }
278
279       if (type) {
280         /* add parameter */
281         code = gpu_str_skip_token(code, NULL, 0);
282         code = gpu_str_skip_token(code, NULL, 0);
283         function->paramqual[function->totparam] = qual;
284         function->paramtype[function->totparam] = type;
285         function->totparam++;
286       }
287       else {
288         fprintf(stderr, "GPU invalid function parameter in %s.\n", function->name);
289         break;
290       }
291     }
292
293     if (function->name[0] == '\0' || function->totparam == 0) {
294       fprintf(stderr, "GPU functions parse error.\n");
295       MEM_freeN(function);
296       break;
297     }
298
299     BLI_ghash_insert(hash, function->name, function);
300   }
301 }
302
303 #if 0
304 static char *gpu_generate_function_prototyps(GHash *hash)
305 {
306   DynStr *ds = BLI_dynstr_new();
307   GHashIterator *ghi;
308   GPUFunction *function;
309   char *name, *prototypes;
310   int a;
311
312   /* automatically generate function prototypes to add to the top of the
313    * generated code, to avoid have to add the actual code & recompile all */
314   ghi = BLI_ghashIterator_new(hash);
315
316   for (; !BLI_ghashIterator_done(ghi); BLI_ghashIterator_step(ghi)) {
317     name = BLI_ghashIterator_getValue(ghi);
318     function = BLI_ghashIterator_getValue(ghi);
319
320     BLI_dynstr_appendf(ds, "void %s(", name);
321     for (a = 0; a < function->totparam; a++) {
322       if (function->paramqual[a] == FUNCTION_QUAL_OUT)
323         BLI_dynstr_append(ds, "out ");
324       else if (function->paramqual[a] == FUNCTION_QUAL_INOUT)
325         BLI_dynstr_append(ds, "inout ");
326
327       if (function->paramtype[a] == GPU_TEX2D)
328         BLI_dynstr_append(ds, "sampler2D");
329       else if (function->paramtype[a] == GPU_SHADOW2D)
330         BLI_dynstr_append(ds, "sampler2DShadow");
331       else
332         BLI_dynstr_append(ds, GPU_DATATYPE_STR[function->paramtype[a]]);
333 #  if 0
334       BLI_dynstr_appendf(ds, " param%d", a);
335 #  endif
336
337       if (a != function->totparam - 1)
338         BLI_dynstr_append(ds, ", ");
339     }
340     BLI_dynstr_append(ds, ");\n");
341   }
342
343   BLI_dynstr_append(ds, "\n");
344
345   prototypes = BLI_dynstr_get_cstring(ds);
346   BLI_dynstr_free(ds);
347
348   return prototypes;
349 }
350 #endif
351
352 static GPUFunction *gpu_lookup_function(const char *name)
353 {
354   if (!FUNCTION_HASH) {
355     FUNCTION_HASH = BLI_ghash_str_new("GPU_lookup_function gh");
356     gpu_parse_functions_string(FUNCTION_HASH, glsl_material_library);
357   }
358
359   return BLI_ghash_lookup(FUNCTION_HASH, (const void *)name);
360 }
361
362 void gpu_codegen_init(void)
363 {
364   GPU_code_generate_glsl_lib();
365 }
366
367 void gpu_codegen_exit(void)
368 {
369   extern Material defmaterial; /* render module abuse... */
370
371   if (defmaterial.gpumaterial.first)
372     GPU_material_free(&defmaterial.gpumaterial);
373
374   if (FUNCTION_HASH) {
375     BLI_ghash_free(FUNCTION_HASH, NULL, MEM_freeN);
376     FUNCTION_HASH = NULL;
377   }
378
379   GPU_shader_free_builtin_shaders();
380
381   if (glsl_material_library) {
382     MEM_freeN(glsl_material_library);
383     glsl_material_library = NULL;
384   }
385
386 #if 0
387   if (FUNCTION_PROTOTYPES) {
388     MEM_freeN(FUNCTION_PROTOTYPES);
389     FUNCTION_PROTOTYPES = NULL;
390   }
391   if (FUNCTION_LIB) {
392     GPU_shader_free(FUNCTION_LIB);
393     FUNCTION_LIB = NULL;
394   }
395 #endif
396 }
397
398 /* GLSL code generation */
399
400 static void codegen_convert_datatype(DynStr *ds, int from, int to, const char *tmp, int id)
401 {
402   char name[1024];
403
404   BLI_snprintf(name, sizeof(name), "%s%d", tmp, id);
405
406   if (from == to) {
407     BLI_dynstr_append(ds, name);
408   }
409   else if (to == GPU_FLOAT) {
410     if (from == GPU_VEC4)
411       BLI_dynstr_appendf(ds, "convert_rgba_to_float(%s)", name);
412     else if (from == GPU_VEC3)
413       BLI_dynstr_appendf(ds, "(%s.r + %s.g + %s.b) / 3.0", name, name, name);
414     else if (from == GPU_VEC2)
415       BLI_dynstr_appendf(ds, "%s.r", name);
416   }
417   else if (to == GPU_VEC2) {
418     if (from == GPU_VEC4)
419       BLI_dynstr_appendf(ds, "vec2((%s.r + %s.g + %s.b) / 3.0, %s.a)", name, name, name, name);
420     else if (from == GPU_VEC3)
421       BLI_dynstr_appendf(ds, "vec2((%s.r + %s.g + %s.b) / 3.0, 1.0)", name, name, name);
422     else if (from == GPU_FLOAT)
423       BLI_dynstr_appendf(ds, "vec2(%s, 1.0)", name);
424   }
425   else if (to == GPU_VEC3) {
426     if (from == GPU_VEC4)
427       BLI_dynstr_appendf(ds, "%s.rgb", name);
428     else if (from == GPU_VEC2)
429       BLI_dynstr_appendf(ds, "vec3(%s.r, %s.r, %s.r)", name, name, name);
430     else if (from == GPU_FLOAT)
431       BLI_dynstr_appendf(ds, "vec3(%s, %s, %s)", name, name, name);
432   }
433   else if (to == GPU_VEC4) {
434     if (from == GPU_VEC3)
435       BLI_dynstr_appendf(ds, "vec4(%s, 1.0)", name);
436     else if (from == GPU_VEC2)
437       BLI_dynstr_appendf(ds, "vec4(%s.r, %s.r, %s.r, %s.g)", name, name, name, name);
438     else if (from == GPU_FLOAT)
439       BLI_dynstr_appendf(ds, "vec4(%s, %s, %s, 1.0)", name, name, name);
440   }
441   else if (to == GPU_CLOSURE) {
442     if (from == GPU_VEC4)
443       BLI_dynstr_appendf(ds, "closure_emission(%s.rgb)", name);
444     else if (from == GPU_VEC3)
445       BLI_dynstr_appendf(ds, "closure_emission(%s.rgb)", name);
446     else if (from == GPU_VEC2)
447       BLI_dynstr_appendf(ds, "closure_emission(%s.rrr)", name);
448     else if (from == GPU_FLOAT)
449       BLI_dynstr_appendf(ds, "closure_emission(vec3(%s, %s, %s))", name, name, name);
450   }
451   else {
452     BLI_dynstr_append(ds, name);
453   }
454 }
455
456 static void codegen_print_datatype(DynStr *ds, const eGPUType type, float *data)
457 {
458   int i;
459
460   BLI_dynstr_appendf(ds, "%s(", GPU_DATATYPE_STR[type]);
461
462   for (i = 0; i < type; i++) {
463     BLI_dynstr_appendf(ds, "%.12f", data[i]);
464     if (i == type - 1)
465       BLI_dynstr_append(ds, ")");
466     else
467       BLI_dynstr_append(ds, ", ");
468   }
469 }
470
471 static int codegen_input_has_texture(GPUInput *input)
472 {
473   if (input->link)
474     return 0;
475   else
476     return (input->source == GPU_SOURCE_TEX);
477 }
478
479 const char *GPU_builtin_name(eGPUBuiltin builtin)
480 {
481   if (builtin == GPU_VIEW_MATRIX)
482     return "unfviewmat";
483   else if (builtin == GPU_OBJECT_MATRIX)
484     return "unfobmat";
485   else if (builtin == GPU_INVERSE_VIEW_MATRIX)
486     return "unfinvviewmat";
487   else if (builtin == GPU_INVERSE_OBJECT_MATRIX)
488     return "unfinvobmat";
489   else if (builtin == GPU_INVERSE_NORMAL_MATRIX)
490     return "unfinvnormat";
491   else if (builtin == GPU_LOC_TO_VIEW_MATRIX)
492     return "unflocaltoviewmat";
493   else if (builtin == GPU_INVERSE_LOC_TO_VIEW_MATRIX)
494     return "unfinvlocaltoviewmat";
495   else if (builtin == GPU_VIEW_POSITION)
496     return "varposition";
497   else if (builtin == GPU_VIEW_NORMAL)
498     return "varnormal";
499   else if (builtin == GPU_OBCOLOR)
500     return "unfobcolor";
501   else if (builtin == GPU_AUTO_BUMPSCALE)
502     return "unfobautobumpscale";
503   else if (builtin == GPU_CAMERA_TEXCO_FACTORS)
504     return "unfcameratexfactors";
505   else if (builtin == GPU_PARTICLE_SCALAR_PROPS)
506     return "unfparticlescalarprops";
507   else if (builtin == GPU_PARTICLE_LOCATION)
508     return "unfparticleco";
509   else if (builtin == GPU_PARTICLE_VELOCITY)
510     return "unfparticlevel";
511   else if (builtin == GPU_PARTICLE_ANG_VELOCITY)
512     return "unfparticleangvel";
513   else if (builtin == GPU_OBJECT_INFO)
514     return "unfobjectinfo";
515   else if (builtin == GPU_VOLUME_DENSITY)
516     return "sampdensity";
517   else if (builtin == GPU_VOLUME_FLAME)
518     return "sampflame";
519   else if (builtin == GPU_VOLUME_TEMPERATURE)
520     return "unftemperature";
521   else if (builtin == GPU_BARYCENTRIC_TEXCO)
522     return "unfbarycentrictex";
523   else if (builtin == GPU_BARYCENTRIC_DIST)
524     return "unfbarycentricdist";
525   else
526     return "";
527 }
528
529 /* assign only one texid per buffer to avoid sampling the same texture twice */
530 static void codegen_set_texid(GHash *bindhash, GPUInput *input, int *texid, void *key)
531 {
532   if (BLI_ghash_haskey(bindhash, key)) {
533     /* Reuse existing texid */
534     input->texid = POINTER_AS_INT(BLI_ghash_lookup(bindhash, key));
535   }
536   else {
537     /* Allocate new texid */
538     input->texid = *texid;
539     (*texid)++;
540     input->bindtex = true;
541     BLI_ghash_insert(bindhash, key, POINTER_FROM_INT(input->texid));
542   }
543 }
544
545 static void codegen_set_unique_ids(ListBase *nodes)
546 {
547   GHash *bindhash;
548   GPUNode *node;
549   GPUInput *input;
550   GPUOutput *output;
551   int id = 1, texid = 0;
552
553   bindhash = BLI_ghash_ptr_new("codegen_set_unique_ids1 gh");
554
555   for (node = nodes->first; node; node = node->next) {
556     for (input = node->inputs.first; input; input = input->next) {
557       /* set id for unique names of uniform variables */
558       input->id = id++;
559
560       /* set texid used for settings texture slot */
561       if (codegen_input_has_texture(input)) {
562         input->bindtex = false;
563         if (input->ima) {
564           /* input is texture from image */
565           codegen_set_texid(bindhash, input, &texid, input->ima);
566         }
567         else if (input->coba) {
568           /* input is color band texture, check coba pointer */
569           codegen_set_texid(bindhash, input, &texid, input->coba);
570         }
571         else {
572           /* Either input->ima or input->coba should be non-NULL. */
573           BLI_assert(0);
574         }
575       }
576     }
577
578     for (output = node->outputs.first; output; output = output->next) {
579       /* set id for unique names of tmp variables storing output */
580       output->id = id++;
581     }
582   }
583
584   BLI_ghash_free(bindhash, NULL, NULL);
585 }
586
587 /**
588  * It will create an UBO for GPUMaterial if there is any GPU_DYNAMIC_UBO.
589  */
590 static int codegen_process_uniforms_functions(GPUMaterial *material, DynStr *ds, ListBase *nodes)
591 {
592   GPUNode *node;
593   GPUInput *input;
594   const char *name;
595   int builtins = 0;
596   ListBase ubo_inputs = {NULL, NULL};
597
598   /* print uniforms */
599   for (node = nodes->first; node; node = node->next) {
600     for (input = node->inputs.first; input; input = input->next) {
601       if (input->source == GPU_SOURCE_TEX) {
602         /* create exactly one sampler for each texture */
603         if (codegen_input_has_texture(input) && input->bindtex) {
604           BLI_dynstr_appendf(ds,
605                              "uniform %s samp%d;\n",
606                              (input->coba) ? "sampler1DArray" : "sampler2D",
607                              input->texid);
608         }
609       }
610       else if (input->source == GPU_SOURCE_BUILTIN) {
611         /* only define each builtin uniform/varying once */
612         if (!(builtins & input->builtin)) {
613           builtins |= input->builtin;
614           name = GPU_builtin_name(input->builtin);
615
616           if (gpu_str_prefix(name, "samp")) {
617             if ((input->builtin == GPU_VOLUME_DENSITY) || (input->builtin == GPU_VOLUME_FLAME)) {
618               BLI_dynstr_appendf(ds, "uniform sampler3D %s;\n", name);
619             }
620           }
621           else if (gpu_str_prefix(name, "unf")) {
622             BLI_dynstr_appendf(ds, "uniform %s %s;\n", GPU_DATATYPE_STR[input->type], name);
623           }
624           else {
625             BLI_dynstr_appendf(ds, "in %s %s;\n", GPU_DATATYPE_STR[input->type], name);
626           }
627         }
628       }
629       else if (input->source == GPU_SOURCE_STRUCT) {
630         /* Add other struct here if needed. */
631         BLI_dynstr_appendf(ds, "Closure strct%d = CLOSURE_DEFAULT;\n", input->id);
632       }
633       else if (input->source == GPU_SOURCE_UNIFORM) {
634         if (!input->link) {
635           /* We handle the UBOuniforms separately. */
636           BLI_addtail(&ubo_inputs, BLI_genericNodeN(input));
637         }
638       }
639       else if (input->source == GPU_SOURCE_CONSTANT) {
640         BLI_dynstr_appendf(ds, "const %s cons%d = ", GPU_DATATYPE_STR[input->type], input->id);
641         codegen_print_datatype(ds, input->type, input->vec);
642         BLI_dynstr_append(ds, ";\n");
643       }
644       else if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
645         BLI_dynstr_appendf(ds, "in %s var%d;\n", GPU_DATATYPE_STR[input->type], input->attr_id);
646       }
647     }
648   }
649
650   /* Handle the UBO block separately. */
651   if ((material != NULL) && !BLI_listbase_is_empty(&ubo_inputs)) {
652     GPU_material_uniform_buffer_create(material, &ubo_inputs);
653
654     /* Inputs are sorted */
655     BLI_dynstr_appendf(ds, "\nlayout (std140) uniform %s {\n", GPU_UBO_BLOCK_NAME);
656
657     for (LinkData *link = ubo_inputs.first; link; link = link->next) {
658       input = link->data;
659       BLI_dynstr_appendf(ds, "\t%s unf%d;\n", GPU_DATATYPE_STR[input->type], input->id);
660     }
661     BLI_dynstr_append(ds, "};\n");
662     BLI_freelistN(&ubo_inputs);
663   }
664
665   BLI_dynstr_append(ds, "\n");
666
667   return builtins;
668 }
669
670 static void codegen_declare_tmps(DynStr *ds, ListBase *nodes)
671 {
672   GPUNode *node;
673   GPUOutput *output;
674
675   for (node = nodes->first; node; node = node->next) {
676     /* declare temporary variables for node output storage */
677     for (output = node->outputs.first; output; output = output->next) {
678       if (output->type == GPU_CLOSURE) {
679         BLI_dynstr_appendf(ds, "\tClosure tmp%d;\n", output->id);
680       }
681       else {
682         BLI_dynstr_appendf(ds, "\t%s tmp%d;\n", GPU_DATATYPE_STR[output->type], output->id);
683       }
684     }
685   }
686
687   BLI_dynstr_append(ds, "\n");
688 }
689
690 static void codegen_call_functions(DynStr *ds, ListBase *nodes, GPUOutput *finaloutput)
691 {
692   GPUNode *node;
693   GPUInput *input;
694   GPUOutput *output;
695
696   for (node = nodes->first; node; node = node->next) {
697     BLI_dynstr_appendf(ds, "\t%s(", node->name);
698
699     for (input = node->inputs.first; input; input = input->next) {
700       if (input->source == GPU_SOURCE_TEX) {
701         BLI_dynstr_appendf(ds, "samp%d", input->texid);
702       }
703       else if (input->source == GPU_SOURCE_OUTPUT) {
704         codegen_convert_datatype(
705             ds, input->link->output->type, input->type, "tmp", input->link->output->id);
706       }
707       else if (input->source == GPU_SOURCE_BUILTIN) {
708         /* TODO(fclem) get rid of that. */
709         if (input->builtin == GPU_INVERSE_VIEW_MATRIX)
710           BLI_dynstr_append(ds, "viewinv");
711         else if (input->builtin == GPU_VIEW_MATRIX)
712           BLI_dynstr_append(ds, "viewmat");
713         else if (input->builtin == GPU_CAMERA_TEXCO_FACTORS)
714           BLI_dynstr_append(ds, "camtexfac");
715         else if (input->builtin == GPU_LOC_TO_VIEW_MATRIX)
716           BLI_dynstr_append(ds, "localtoviewmat");
717         else if (input->builtin == GPU_INVERSE_LOC_TO_VIEW_MATRIX)
718           BLI_dynstr_append(ds, "invlocaltoviewmat");
719         else if (input->builtin == GPU_BARYCENTRIC_DIST)
720           BLI_dynstr_append(ds, "barycentricDist");
721         else if (input->builtin == GPU_BARYCENTRIC_TEXCO)
722           BLI_dynstr_append(ds, "barytexco");
723         else if (input->builtin == GPU_OBJECT_MATRIX)
724           BLI_dynstr_append(ds, "objmat");
725         else if (input->builtin == GPU_INVERSE_OBJECT_MATRIX)
726           BLI_dynstr_append(ds, "objinv");
727         else if (input->builtin == GPU_INVERSE_NORMAL_MATRIX)
728           BLI_dynstr_append(ds, "norinv");
729         else if (input->builtin == GPU_VIEW_POSITION)
730           BLI_dynstr_append(ds, "viewposition");
731         else if (input->builtin == GPU_VIEW_NORMAL)
732           BLI_dynstr_append(ds, "facingnormal");
733         else
734           BLI_dynstr_append(ds, GPU_builtin_name(input->builtin));
735       }
736       else if (input->source == GPU_SOURCE_STRUCT) {
737         BLI_dynstr_appendf(ds, "strct%d", input->id);
738       }
739       else if (input->source == GPU_SOURCE_UNIFORM) {
740         BLI_dynstr_appendf(ds, "unf%d", input->id);
741       }
742       else if (input->source == GPU_SOURCE_CONSTANT) {
743         BLI_dynstr_appendf(ds, "cons%d", input->id);
744       }
745       else if (input->source == GPU_SOURCE_ATTR) {
746         BLI_dynstr_appendf(ds, "var%d", input->attr_id);
747       }
748
749       BLI_dynstr_append(ds, ", ");
750     }
751
752     for (output = node->outputs.first; output; output = output->next) {
753       BLI_dynstr_appendf(ds, "tmp%d", output->id);
754       if (output->next)
755         BLI_dynstr_append(ds, ", ");
756     }
757
758     BLI_dynstr_append(ds, ");\n");
759   }
760
761   BLI_dynstr_appendf(ds, "\n\treturn tmp%d", finaloutput->id);
762   BLI_dynstr_append(ds, ";\n");
763 }
764
765 static char *code_generate_fragment(GPUMaterial *material,
766                                     ListBase *nodes,
767                                     GPUOutput *output,
768                                     int *rbuiltins)
769 {
770   DynStr *ds = BLI_dynstr_new();
771   char *code;
772   int builtins;
773
774 #if 0
775   BLI_dynstr_append(ds, FUNCTION_PROTOTYPES);
776 #endif
777
778   codegen_set_unique_ids(nodes);
779   *rbuiltins = builtins = codegen_process_uniforms_functions(material, ds, nodes);
780
781   if (builtins & GPU_BARYCENTRIC_TEXCO)
782     BLI_dynstr_append(ds, "in vec2 barycentricTexCo;\n");
783
784   if (builtins & GPU_BARYCENTRIC_DIST)
785     BLI_dynstr_append(ds, "flat in vec3 barycentricDist;\n");
786
787   BLI_dynstr_append(ds, "Closure nodetree_exec(void)\n{\n");
788
789   if (builtins & GPU_BARYCENTRIC_TEXCO) {
790     BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
791     BLI_dynstr_append(ds,
792                       "\tvec2 barytexco = vec2((fract(barycentricTexCo.y) != 0.0)\n"
793                       "\t                      ? barycentricTexCo.x\n"
794                       "\t                      : 1.0 - barycentricTexCo.x,\n"
795                       "\t                      0.0);\n");
796     BLI_dynstr_append(ds, "#else\n");
797     BLI_dynstr_append(ds, "\tvec2 barytexco = barycentricTexCo;\n");
798     BLI_dynstr_append(ds, "#endif\n");
799   }
800   /* TODO(fclem) get rid of that. */
801   if (builtins & GPU_VIEW_MATRIX)
802     BLI_dynstr_append(ds, "\t#define viewmat ViewMatrix\n");
803   if (builtins & GPU_CAMERA_TEXCO_FACTORS)
804     BLI_dynstr_append(ds, "\t#define camtexfac CameraTexCoFactors\n");
805   if (builtins & GPU_OBJECT_MATRIX)
806     BLI_dynstr_append(ds, "\t#define objmat ModelMatrix\n");
807   if (builtins & GPU_INVERSE_OBJECT_MATRIX)
808     BLI_dynstr_append(ds, "\t#define objinv ModelMatrixInverse\n");
809   if (builtins & GPU_INVERSE_NORMAL_MATRIX)
810     BLI_dynstr_append(ds, "\t#define norinv NormalMatrixInverse\n");
811   if (builtins & GPU_INVERSE_VIEW_MATRIX)
812     BLI_dynstr_append(ds, "\t#define viewinv ViewMatrixInverse\n");
813   if (builtins & GPU_LOC_TO_VIEW_MATRIX)
814     BLI_dynstr_append(ds, "\t#define localtoviewmat ModelViewMatrix\n");
815   if (builtins & GPU_INVERSE_LOC_TO_VIEW_MATRIX)
816     BLI_dynstr_append(ds, "\t#define invlocaltoviewmat ModelViewMatrixInverse\n");
817   if (builtins & GPU_VIEW_NORMAL)
818     BLI_dynstr_append(ds, "\tvec3 facingnormal = gl_FrontFacing? viewNormal: -viewNormal;\n");
819   if (builtins & GPU_VIEW_POSITION)
820     BLI_dynstr_append(ds, "\t#define viewposition viewPosition\n");
821
822   codegen_declare_tmps(ds, nodes);
823   codegen_call_functions(ds, nodes, output);
824
825   BLI_dynstr_append(ds, "}\n");
826
827   /* XXX This cannot go into gpu_shader_material.glsl because main()
828    * would be parsed and generate error */
829   /* Old glsl mode compat. */
830   BLI_dynstr_append(ds, "#ifndef NODETREE_EXEC\n");
831   BLI_dynstr_append(ds, "out vec4 fragColor;\n");
832   BLI_dynstr_append(ds, "void main()\n");
833   BLI_dynstr_append(ds, "{\n");
834   BLI_dynstr_append(ds, "\tClosure cl = nodetree_exec();\n");
835   BLI_dynstr_append(ds, "\tfragColor = vec4(cl.radiance, cl.opacity);\n");
836   BLI_dynstr_append(ds, "}\n");
837   BLI_dynstr_append(ds, "#endif\n\n");
838
839   /* create shader */
840   code = BLI_dynstr_get_cstring(ds);
841   BLI_dynstr_free(ds);
842
843 #if 0
844   if (G.debug & G_DEBUG)
845     printf("%s\n", code);
846 #endif
847
848   return code;
849 }
850
851 static const char *attr_prefix_get(CustomDataType type)
852 {
853   switch (type) {
854     case CD_ORCO:
855       return "orco";
856     case CD_MTFACE:
857       return "u";
858     case CD_TANGENT:
859       return "t";
860     case CD_MCOL:
861       return "c";
862     case CD_AUTO_FROM_NAME:
863       return "a";
864     default:
865       BLI_assert(false && "GPUVertAttr Prefix type not found : This should not happen!");
866       return "";
867   }
868 }
869
870 static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool use_geom)
871 {
872   DynStr *ds = BLI_dynstr_new();
873   GPUNode *node;
874   GPUInput *input;
875   char *code;
876   int builtins = 0;
877
878   /* Hairs uv and col attributes are passed by bufferTextures. */
879   BLI_dynstr_append(ds,
880                     "#ifdef HAIR_SHADER\n"
881                     "#define DEFINE_ATTR(type, attr) uniform samplerBuffer attr\n"
882                     "#else\n"
883                     "#define DEFINE_ATTR(type, attr) in type attr\n"
884                     "#endif\n");
885
886   for (node = nodes->first; node; node = node->next) {
887     for (input = node->inputs.first; input; input = input->next) {
888       if (input->source == GPU_SOURCE_BUILTIN) {
889         builtins |= input->builtin;
890       }
891       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
892         /* XXX FIXME : see notes in mesh_render_data_create() */
893         /* NOTE : Replicate changes to mesh_render_data_create() in draw_cache_impl_mesh.c */
894         if (input->attr_type == CD_ORCO) {
895           /* OPTI : orco is computed from local positions, but only if no modifier is present. */
896           BLI_dynstr_append(ds, "uniform vec3 OrcoTexCoFactors[2];\n");
897           BLI_dynstr_append(ds, "DEFINE_ATTR(vec4, orco);\n");
898         }
899         else if (input->attr_name[0] == '\0') {
900           BLI_dynstr_appendf(ds,
901                              "DEFINE_ATTR(%s, %s);\n",
902                              GPU_DATATYPE_STR[input->type],
903                              attr_prefix_get(input->attr_type));
904           BLI_dynstr_appendf(
905               ds, "#define att%d %s\n", input->attr_id, attr_prefix_get(input->attr_type));
906         }
907         else {
908           uint hash = BLI_ghashutil_strhash_p(input->attr_name);
909           BLI_dynstr_appendf(ds,
910                              "DEFINE_ATTR(%s, %s%u);\n",
911                              GPU_DATATYPE_STR[input->type],
912                              attr_prefix_get(input->attr_type),
913                              hash);
914           BLI_dynstr_appendf(
915               ds, "#define att%d %s%u\n", input->attr_id, attr_prefix_get(input->attr_type), hash);
916           /* Auto attribute can be vertex color byte buffer.
917            * We need to know and convert them to linear space in VS. */
918           if (input->attr_type == CD_AUTO_FROM_NAME) {
919             BLI_dynstr_appendf(ds, "uniform bool ba%u;\n", hash);
920             BLI_dynstr_appendf(ds, "#define att%d_is_srgb ba%u\n", input->attr_id, hash);
921           }
922         }
923         BLI_dynstr_appendf(ds,
924                            "out %s var%d%s;\n",
925                            GPU_DATATYPE_STR[input->type],
926                            input->attr_id,
927                            use_geom ? "g" : "");
928       }
929     }
930   }
931
932   if (builtins & GPU_BARYCENTRIC_TEXCO) {
933     BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
934     BLI_dynstr_appendf(ds, "out vec2 barycentricTexCo%s;\n", use_geom ? "g" : "");
935     BLI_dynstr_append(ds, "#endif\n");
936   }
937
938   if (builtins & GPU_BARYCENTRIC_DIST) {
939     BLI_dynstr_append(ds, "out vec3 barycentricPosg;\n");
940   }
941
942   BLI_dynstr_append(ds, "\n");
943
944   BLI_dynstr_append(ds,
945                     "#define USE_ATTR\n"
946                     "uniform mat3 NormalMatrix;\n"
947                     "uniform mat4 ModelMatrixInverse;\n"
948                     "uniform mat4 ModelMatrix;\n"
949                     "vec3 srgb_to_linear_attr(vec3 c) {\n"
950                     "\tc = max(c, vec3(0.0));\n"
951                     "\tvec3 c1 = c * (1.0 / 12.92);\n"
952                     "\tvec3 c2 = pow((c + 0.055) * (1.0 / 1.055), vec3(2.4));\n"
953                     "\treturn mix(c1, c2, step(vec3(0.04045), c));\n"
954                     "}\n\n");
955
956   /* Prototype because defined later. */
957   BLI_dynstr_append(ds,
958                     "vec2 hair_get_customdata_vec2(const samplerBuffer);\n"
959                     "vec3 hair_get_customdata_vec3(const samplerBuffer);\n"
960                     "vec4 hair_get_customdata_vec4(const samplerBuffer);\n"
961                     "vec3 hair_get_strand_pos(void);\n"
962                     "int hair_get_base_id(void);\n"
963                     "\n");
964
965   BLI_dynstr_append(ds, "void pass_attr(in vec3 position) {\n");
966
967   BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
968
969   if (builtins & GPU_BARYCENTRIC_TEXCO) {
970     /* To match cycles without breaking into individual segment we encode if we need to invert
971      * the first component into the second component. We invert if the barycentricTexCo.y
972      * is NOT 0.0 or 1.0. */
973     BLI_dynstr_append(ds, "\tint _base_id = hair_get_base_id();\n");
974     BLI_dynstr_appendf(
975         ds, "\tbarycentricTexCo%s.x = float((_base_id %% 2) == 1);\n", use_geom ? "g" : "");
976     BLI_dynstr_appendf(
977         ds, "\tbarycentricTexCo%s.y = float(((_base_id %% 4) %% 3) > 0);\n", use_geom ? "g" : "");
978   }
979
980   if (builtins & GPU_BARYCENTRIC_DIST) {
981     BLI_dynstr_append(ds, "\tbarycentricPosg = position;\n");
982   }
983
984   for (node = nodes->first; node; node = node->next) {
985     for (input = node->inputs.first; input; input = input->next) {
986       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
987         if (input->attr_type == CD_TANGENT) {
988           /* Not supported by hairs */
989           BLI_dynstr_appendf(ds, "\tvar%d%s = vec4(0.0);\n", input->attr_id, use_geom ? "g" : "");
990         }
991         else if (input->attr_type == CD_ORCO) {
992           BLI_dynstr_appendf(ds,
993                              "\tvar%d%s = OrcoTexCoFactors[0] + (ModelMatrixInverse * "
994                              "vec4(hair_get_strand_pos(), 1.0)).xyz * OrcoTexCoFactors[1];\n",
995                              input->attr_id,
996                              use_geom ? "g" : "");
997           /* TODO: fix ORCO with modifiers. */
998         }
999         else {
1000           BLI_dynstr_appendf(ds,
1001                              "\tvar%d%s = hair_get_customdata_%s(att%d);\n",
1002                              input->attr_id,
1003                              use_geom ? "g" : "",
1004                              GPU_DATATYPE_STR[input->type],
1005                              input->attr_id);
1006         }
1007       }
1008     }
1009   }
1010
1011   BLI_dynstr_append(ds, "#else /* MESH_SHADER */\n");
1012
1013   /* GPU_BARYCENTRIC_TEXCO cannot be computed based on gl_VertexID
1014    * for MESH_SHADER because of indexed drawing. In this case a
1015    * geometry shader is needed. */
1016
1017   if (builtins & GPU_BARYCENTRIC_DIST) {
1018     BLI_dynstr_append(ds, "\tbarycentricPosg = (ModelMatrix * vec4(position, 1.0)).xyz;\n");
1019   }
1020
1021   for (node = nodes->first; node; node = node->next) {
1022     for (input = node->inputs.first; input; input = input->next) {
1023       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
1024         if (input->attr_type == CD_TANGENT) { /* silly exception */
1025           BLI_dynstr_appendf(ds,
1026                              "\tvar%d%s.xyz = NormalMatrix * att%d.xyz;\n",
1027                              input->attr_id,
1028                              use_geom ? "g" : "",
1029                              input->attr_id);
1030           BLI_dynstr_appendf(
1031               ds, "\tvar%d%s.w = att%d.w;\n", input->attr_id, use_geom ? "g" : "", input->attr_id);
1032           /* Normalize only if vector is not null. */
1033           BLI_dynstr_appendf(ds,
1034                              "\tfloat lvar%d = dot(var%d%s.xyz, var%d%s.xyz);\n",
1035                              input->attr_id,
1036                              input->attr_id,
1037                              use_geom ? "g" : "",
1038                              input->attr_id,
1039                              use_geom ? "g" : "");
1040           BLI_dynstr_appendf(ds,
1041                              "\tvar%d%s.xyz *= (lvar%d > 0.0) ? inversesqrt(lvar%d) : 1.0;\n",
1042                              input->attr_id,
1043                              use_geom ? "g" : "",
1044                              input->attr_id,
1045                              input->attr_id);
1046         }
1047         else if (input->attr_type == CD_ORCO) {
1048           BLI_dynstr_appendf(ds,
1049                              "\tvar%d%s = OrcoTexCoFactors[0] + position * OrcoTexCoFactors[1];\n",
1050                              input->attr_id,
1051                              use_geom ? "g" : "");
1052           /* See mesh_create_loop_orco() for explanation. */
1053           BLI_dynstr_appendf(ds,
1054                              "\tif (orco.w == 0.0) { var%d%s = orco.xyz * 0.5 + 0.5; }\n",
1055                              input->attr_id,
1056                              use_geom ? "g" : "");
1057         }
1058         else if (input->attr_type == CD_MCOL) {
1059           BLI_dynstr_appendf(ds,
1060                              "\tvar%d%s = srgb_to_linear_attr(att%d);\n",
1061                              input->attr_id,
1062                              use_geom ? "g" : "",
1063                              input->attr_id);
1064         }
1065         else if (input->attr_type == CD_AUTO_FROM_NAME) {
1066           BLI_dynstr_appendf(ds,
1067                              "\tvar%d%s = (att%d_is_srgb) ? srgb_to_linear_attr(att%d) : att%d;\n",
1068                              input->attr_id,
1069                              use_geom ? "g" : "",
1070                              input->attr_id,
1071                              input->attr_id,
1072                              input->attr_id);
1073         }
1074         else {
1075           BLI_dynstr_appendf(
1076               ds, "\tvar%d%s = att%d;\n", input->attr_id, use_geom ? "g" : "", input->attr_id);
1077         }
1078       }
1079     }
1080   }
1081   BLI_dynstr_append(ds, "#endif /* HAIR_SHADER */\n");
1082
1083   BLI_dynstr_append(ds, "}\n");
1084
1085   if (use_geom) {
1086     /* XXX HACK: Eevee specific. */
1087     char *vert_new, *vert_new2;
1088     vert_new = BLI_str_replaceN(vert_code, "worldPosition", "worldPositiong");
1089     vert_new2 = vert_new;
1090     vert_new = BLI_str_replaceN(vert_new2, "viewPosition", "viewPositiong");
1091     MEM_freeN(vert_new2);
1092     vert_new2 = vert_new;
1093     vert_new = BLI_str_replaceN(vert_new2, "worldNormal", "worldNormalg");
1094     MEM_freeN(vert_new2);
1095     vert_new2 = vert_new;
1096     vert_new = BLI_str_replaceN(vert_new2, "viewNormal", "viewNormalg");
1097     MEM_freeN(vert_new2);
1098
1099     BLI_dynstr_append(ds, vert_new);
1100
1101     MEM_freeN(vert_new);
1102   }
1103   else {
1104     BLI_dynstr_append(ds, vert_code);
1105   }
1106
1107   code = BLI_dynstr_get_cstring(ds);
1108
1109   BLI_dynstr_free(ds);
1110
1111 #if 0
1112   if (G.debug & G_DEBUG)
1113     printf("%s\n", code);
1114 #endif
1115
1116   return code;
1117 }
1118
1119 static char *code_generate_geometry(ListBase *nodes, const char *geom_code, const char *defines)
1120 {
1121   DynStr *ds = BLI_dynstr_new();
1122   GPUNode *node;
1123   GPUInput *input;
1124   char *code;
1125   int builtins = 0;
1126
1127   /* XXX we should not make specific eevee cases here. */
1128   bool is_hair_shader = (strstr(defines, "HAIR_SHADER") != NULL);
1129
1130   /* Create prototype because attributes cannot be declared before layout. */
1131   BLI_dynstr_append(ds, "void pass_attr(in int vert);\n");
1132   BLI_dynstr_append(ds, "void calc_barycentric_distances(vec3 pos0, vec3 pos1, vec3 pos2);\n");
1133   BLI_dynstr_append(ds, "#define USE_ATTR\n");
1134
1135   /* Generate varying declarations. */
1136   for (node = nodes->first; node; node = node->next) {
1137     for (input = node->inputs.first; input; input = input->next) {
1138       if (input->source == GPU_SOURCE_BUILTIN) {
1139         builtins |= input->builtin;
1140       }
1141       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
1142         BLI_dynstr_appendf(ds, "in %s var%dg[];\n", GPU_DATATYPE_STR[input->type], input->attr_id);
1143         BLI_dynstr_appendf(ds, "out %s var%d;\n", GPU_DATATYPE_STR[input->type], input->attr_id);
1144       }
1145     }
1146   }
1147
1148   if (builtins & GPU_BARYCENTRIC_TEXCO) {
1149     BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
1150     BLI_dynstr_append(ds, "in vec2 barycentricTexCog[];\n");
1151     BLI_dynstr_append(ds, "#endif\n");
1152
1153     BLI_dynstr_append(ds, "out vec2 barycentricTexCo;\n");
1154   }
1155
1156   if (builtins & GPU_BARYCENTRIC_DIST) {
1157     BLI_dynstr_append(ds, "in vec3 barycentricPosg[];\n");
1158     BLI_dynstr_append(ds, "flat out vec3 barycentricDist;\n");
1159   }
1160
1161   if (geom_code == NULL) {
1162     /* Force geometry usage if GPU_BARYCENTRIC_DIST or GPU_BARYCENTRIC_TEXCO are used.
1163      * Note: GPU_BARYCENTRIC_TEXCO only requires it if the shader is not drawing hairs. */
1164     if ((builtins & (GPU_BARYCENTRIC_DIST | GPU_BARYCENTRIC_TEXCO)) == 0 || is_hair_shader) {
1165       /* Early out */
1166       BLI_dynstr_free(ds);
1167       return NULL;
1168     }
1169     else {
1170       /* Force geom shader usage */
1171       /* TODO put in external file. */
1172       BLI_dynstr_append(ds, "layout(triangles) in;\n");
1173       BLI_dynstr_append(ds, "layout(triangle_strip, max_vertices=3) out;\n");
1174
1175       BLI_dynstr_append(ds, "in vec3 worldPositiong[];\n");
1176       BLI_dynstr_append(ds, "in vec3 viewPositiong[];\n");
1177       BLI_dynstr_append(ds, "in vec3 worldNormalg[];\n");
1178       BLI_dynstr_append(ds, "in vec3 viewNormalg[];\n");
1179
1180       BLI_dynstr_append(ds, "out vec3 worldPosition;\n");
1181       BLI_dynstr_append(ds, "out vec3 viewPosition;\n");
1182       BLI_dynstr_append(ds, "out vec3 worldNormal;\n");
1183       BLI_dynstr_append(ds, "out vec3 viewNormal;\n");
1184
1185       BLI_dynstr_append(ds, "void main(){\n");
1186
1187       if (builtins & GPU_BARYCENTRIC_DIST) {
1188         BLI_dynstr_append(ds,
1189                           "\tcalc_barycentric_distances(barycentricPosg[0], barycentricPosg[1], "
1190                           "barycentricPosg[2]);\n");
1191       }
1192
1193       BLI_dynstr_append(ds, "\tgl_Position = gl_in[0].gl_Position;\n");
1194       BLI_dynstr_append(ds, "\tpass_attr(0);\n");
1195       BLI_dynstr_append(ds, "\tEmitVertex();\n");
1196
1197       BLI_dynstr_append(ds, "\tgl_Position = gl_in[1].gl_Position;\n");
1198       BLI_dynstr_append(ds, "\tpass_attr(1);\n");
1199       BLI_dynstr_append(ds, "\tEmitVertex();\n");
1200
1201       BLI_dynstr_append(ds, "\tgl_Position = gl_in[2].gl_Position;\n");
1202       BLI_dynstr_append(ds, "\tpass_attr(2);\n");
1203       BLI_dynstr_append(ds, "\tEmitVertex();\n");
1204       BLI_dynstr_append(ds, "};\n");
1205     }
1206   }
1207   else {
1208     BLI_dynstr_append(ds, geom_code);
1209   }
1210
1211   if (builtins & GPU_BARYCENTRIC_DIST) {
1212     BLI_dynstr_append(ds, "void calc_barycentric_distances(vec3 pos0, vec3 pos1, vec3 pos2) {\n");
1213     BLI_dynstr_append(ds, "\tvec3 edge21 = pos2 - pos1;\n");
1214     BLI_dynstr_append(ds, "\tvec3 edge10 = pos1 - pos0;\n");
1215     BLI_dynstr_append(ds, "\tvec3 edge02 = pos0 - pos2;\n");
1216     BLI_dynstr_append(ds, "\tvec3 d21 = normalize(edge21);\n");
1217     BLI_dynstr_append(ds, "\tvec3 d10 = normalize(edge10);\n");
1218     BLI_dynstr_append(ds, "\tvec3 d02 = normalize(edge02);\n");
1219
1220     BLI_dynstr_append(ds, "\tfloat d = dot(d21, edge02);\n");
1221     BLI_dynstr_append(ds, "\tbarycentricDist.x = sqrt(dot(edge02, edge02) - d * d);\n");
1222     BLI_dynstr_append(ds, "\td = dot(d02, edge10);\n");
1223     BLI_dynstr_append(ds, "\tbarycentricDist.y = sqrt(dot(edge10, edge10) - d * d);\n");
1224     BLI_dynstr_append(ds, "\td = dot(d10, edge21);\n");
1225     BLI_dynstr_append(ds, "\tbarycentricDist.z = sqrt(dot(edge21, edge21) - d * d);\n");
1226     BLI_dynstr_append(ds, "}\n");
1227   }
1228
1229   /* Generate varying assignments. */
1230   BLI_dynstr_append(ds, "void pass_attr(in int vert) {\n");
1231
1232   /* XXX HACK: Eevee specific. */
1233   if (geom_code == NULL) {
1234     BLI_dynstr_append(ds, "\tworldPosition = worldPositiong[vert];\n");
1235     BLI_dynstr_append(ds, "\tviewPosition = viewPositiong[vert];\n");
1236     BLI_dynstr_append(ds, "\tworldNormal = worldNormalg[vert];\n");
1237     BLI_dynstr_append(ds, "\tviewNormal = viewNormalg[vert];\n");
1238   }
1239
1240   if (builtins & GPU_BARYCENTRIC_TEXCO) {
1241     BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
1242     BLI_dynstr_append(ds, "\tbarycentricTexCo = barycentricTexCog[vert];\n");
1243     BLI_dynstr_append(ds, "#else\n");
1244     BLI_dynstr_append(ds, "\tbarycentricTexCo.x = float((vert % 3) == 0);\n");
1245     BLI_dynstr_append(ds, "\tbarycentricTexCo.y = float((vert % 3) == 1);\n");
1246     BLI_dynstr_append(ds, "#endif\n");
1247   }
1248
1249   for (node = nodes->first; node; node = node->next) {
1250     for (input = node->inputs.first; input; input = input->next) {
1251       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
1252         /* TODO let shader choose what to do depending on what the attribute is. */
1253         BLI_dynstr_appendf(ds, "\tvar%d = var%dg[vert];\n", input->attr_id, input->attr_id);
1254       }
1255     }
1256   }
1257   BLI_dynstr_append(ds, "}\n");
1258
1259   code = BLI_dynstr_get_cstring(ds);
1260   BLI_dynstr_free(ds);
1261
1262   return code;
1263 }
1264
1265 void GPU_code_generate_glsl_lib(void)
1266 {
1267   DynStr *ds;
1268
1269   /* only initialize the library once */
1270   if (glsl_material_library)
1271     return;
1272
1273   ds = BLI_dynstr_new();
1274
1275   BLI_dynstr_append(ds, datatoc_gpu_shader_material_glsl);
1276
1277   glsl_material_library = BLI_dynstr_get_cstring(ds);
1278
1279   BLI_dynstr_free(ds);
1280 }
1281
1282 /* GPU pass binding/unbinding */
1283
1284 GPUShader *GPU_pass_shader_get(GPUPass *pass)
1285 {
1286   return pass->shader;
1287 }
1288
1289 void GPU_nodes_extract_dynamic_inputs(GPUShader *shader, ListBase *inputs, ListBase *nodes)
1290 {
1291   GPUNode *node;
1292   GPUInput *next, *input;
1293
1294   BLI_listbase_clear(inputs);
1295
1296   if (!shader)
1297     return;
1298
1299   for (node = nodes->first; node; node = node->next) {
1300     int z = 0;
1301     for (input = node->inputs.first; input; input = next, z++) {
1302       next = input->next;
1303
1304       /* attributes don't need to be bound, they already have
1305        * an id that the drawing functions will use. Builtins have
1306        * constant names. */
1307       if (ELEM(input->source, GPU_SOURCE_ATTR, GPU_SOURCE_BUILTIN)) {
1308         continue;
1309       }
1310
1311       if (input->source == GPU_SOURCE_TEX)
1312         BLI_snprintf(input->shadername, sizeof(input->shadername), "samp%d", input->texid);
1313       else {
1314         BLI_snprintf(input->shadername, sizeof(input->shadername), "unf%d", input->id);
1315       }
1316
1317       if (input->source == GPU_SOURCE_TEX) {
1318         if (input->bindtex) {
1319           input->shaderloc = GPU_shader_get_uniform_ensure(shader, input->shadername);
1320           /* extract nodes */
1321           BLI_remlink(&node->inputs, input);
1322           BLI_addtail(inputs, input);
1323         }
1324       }
1325     }
1326   }
1327 }
1328
1329 /* Node Link Functions */
1330
1331 static GPUNodeLink *GPU_node_link_create(void)
1332 {
1333   GPUNodeLink *link = MEM_callocN(sizeof(GPUNodeLink), "GPUNodeLink");
1334   link->users++;
1335
1336   return link;
1337 }
1338
1339 static void gpu_node_link_free(GPUNodeLink *link)
1340 {
1341   link->users--;
1342
1343   if (link->users < 0)
1344     fprintf(stderr, "GPU_node_link_free: negative refcount\n");
1345
1346   if (link->users == 0) {
1347     if (link->output)
1348       link->output->link = NULL;
1349     MEM_freeN(link);
1350   }
1351 }
1352
1353 /* Node Functions */
1354
1355 static GPUNode *GPU_node_begin(const char *name)
1356 {
1357   GPUNode *node = MEM_callocN(sizeof(GPUNode), "GPUNode");
1358
1359   node->name = name;
1360
1361   return node;
1362 }
1363
1364 static void gpu_node_input_link(GPUNode *node, GPUNodeLink *link, const eGPUType type)
1365 {
1366   GPUInput *input;
1367   GPUNode *outnode;
1368   const char *name;
1369
1370   if (link->link_type == GPU_NODE_LINK_OUTPUT) {
1371     outnode = link->output->node;
1372     name = outnode->name;
1373     input = outnode->inputs.first;
1374
1375     if ((STR_ELEM(name, "set_value", "set_rgb", "set_rgba")) && (input->type == type)) {
1376       input = MEM_dupallocN(outnode->inputs.first);
1377       if (input->link)
1378         input->link->users++;
1379       BLI_addtail(&node->inputs, input);
1380       return;
1381     }
1382   }
1383
1384   input = MEM_callocN(sizeof(GPUInput), "GPUInput");
1385   input->node = node;
1386   input->type = type;
1387
1388   switch (link->link_type) {
1389     case GPU_NODE_LINK_BUILTIN:
1390       input->source = GPU_SOURCE_BUILTIN;
1391       input->builtin = link->builtin;
1392       break;
1393     case GPU_NODE_LINK_OUTPUT:
1394       input->source = GPU_SOURCE_OUTPUT;
1395       input->link = link;
1396       link->users++;
1397       break;
1398     case GPU_NODE_LINK_COLORBAND:
1399       input->source = GPU_SOURCE_TEX;
1400       input->coba = link->coba;
1401       break;
1402     case GPU_NODE_LINK_IMAGE_BLENDER:
1403       input->source = GPU_SOURCE_TEX;
1404       input->ima = link->ima;
1405       input->iuser = link->iuser;
1406       input->image_isdata = link->image_isdata;
1407       break;
1408     case GPU_NODE_LINK_ATTR:
1409       input->source = GPU_SOURCE_ATTR;
1410       input->attr_type = link->attr_type;
1411       BLI_strncpy(input->attr_name, link->attr_name, sizeof(input->attr_name));
1412       break;
1413     case GPU_NODE_LINK_CONSTANT:
1414       input->source = (type == GPU_CLOSURE) ? GPU_SOURCE_STRUCT : GPU_SOURCE_CONSTANT;
1415       break;
1416     case GPU_NODE_LINK_UNIFORM:
1417       input->source = GPU_SOURCE_UNIFORM;
1418       break;
1419     default:
1420       break;
1421   }
1422
1423   if (ELEM(input->source, GPU_SOURCE_CONSTANT, GPU_SOURCE_UNIFORM)) {
1424     memcpy(input->vec, link->data, type * sizeof(float));
1425   }
1426
1427   if (link->link_type != GPU_NODE_LINK_OUTPUT) {
1428     MEM_freeN(link);
1429   }
1430   BLI_addtail(&node->inputs, input);
1431 }
1432
1433 static const char *gpu_uniform_set_function_from_type(eNodeSocketDatatype type)
1434 {
1435   switch (type) {
1436     /* For now INT is supported as float. */
1437     case SOCK_INT:
1438     case SOCK_FLOAT:
1439       return "set_value";
1440     case SOCK_VECTOR:
1441       return "set_rgb";
1442     case SOCK_RGBA:
1443       return "set_rgba";
1444     default:
1445       BLI_assert(!"No gpu function for non-supported eNodeSocketDatatype");
1446       return NULL;
1447   }
1448 }
1449
1450 /**
1451  * Link stack uniform buffer.
1452  * This is called for the input/output sockets that are note connected.
1453  */
1454 static GPUNodeLink *gpu_uniformbuffer_link(GPUMaterial *mat,
1455                                            bNode *node,
1456                                            GPUNodeStack *stack,
1457                                            const int index,
1458                                            const eNodeSocketInOut in_out)
1459 {
1460   bNodeSocket *socket;
1461
1462   if (in_out == SOCK_IN) {
1463     socket = BLI_findlink(&node->inputs, index);
1464   }
1465   else {
1466     socket = BLI_findlink(&node->outputs, index);
1467   }
1468
1469   BLI_assert(socket != NULL);
1470   BLI_assert(socket->in_out == in_out);
1471
1472   if ((socket->flag & SOCK_HIDE_VALUE) == 0) {
1473     GPUNodeLink *link;
1474     switch (socket->type) {
1475       case SOCK_FLOAT: {
1476         bNodeSocketValueFloat *socket_data = socket->default_value;
1477         link = GPU_uniform(&socket_data->value);
1478         break;
1479       }
1480       case SOCK_VECTOR: {
1481         bNodeSocketValueVector *socket_data = socket->default_value;
1482         link = GPU_uniform(socket_data->value);
1483         break;
1484       }
1485       case SOCK_RGBA: {
1486         bNodeSocketValueRGBA *socket_data = socket->default_value;
1487         link = GPU_uniform(socket_data->value);
1488         break;
1489       }
1490       default:
1491         return NULL;
1492         break;
1493     }
1494
1495     if (in_out == SOCK_IN) {
1496       GPU_link(mat, gpu_uniform_set_function_from_type(socket->type), link, &stack->link);
1497     }
1498     return link;
1499   }
1500   return NULL;
1501 }
1502
1503 static void gpu_node_input_socket(
1504     GPUMaterial *material, bNode *bnode, GPUNode *node, GPUNodeStack *sock, const int index)
1505 {
1506   if (sock->link) {
1507     gpu_node_input_link(node, sock->link, sock->type);
1508   }
1509   else if ((material != NULL) &&
1510            (gpu_uniformbuffer_link(material, bnode, sock, index, SOCK_IN) != NULL)) {
1511     gpu_node_input_link(node, sock->link, sock->type);
1512   }
1513   else {
1514     gpu_node_input_link(node, GPU_constant(sock->vec), sock->type);
1515   }
1516 }
1517
1518 static void gpu_node_output(GPUNode *node, const eGPUType type, GPUNodeLink **link)
1519 {
1520   GPUOutput *output = MEM_callocN(sizeof(GPUOutput), "GPUOutput");
1521
1522   output->type = type;
1523   output->node = node;
1524
1525   if (link) {
1526     *link = output->link = GPU_node_link_create();
1527     output->link->link_type = GPU_NODE_LINK_OUTPUT;
1528     output->link->output = output;
1529
1530     /* note: the caller owns the reference to the link, GPUOutput
1531      * merely points to it, and if the node is destroyed it will
1532      * set that pointer to NULL */
1533   }
1534
1535   BLI_addtail(&node->outputs, output);
1536 }
1537
1538 void GPU_inputs_free(ListBase *inputs)
1539 {
1540   GPUInput *input;
1541
1542   for (input = inputs->first; input; input = input->next) {
1543     if (input->link)
1544       gpu_node_link_free(input->link);
1545   }
1546
1547   BLI_freelistN(inputs);
1548 }
1549
1550 static void gpu_node_free(GPUNode *node)
1551 {
1552   GPUOutput *output;
1553
1554   GPU_inputs_free(&node->inputs);
1555
1556   for (output = node->outputs.first; output; output = output->next)
1557     if (output->link) {
1558       output->link->output = NULL;
1559       gpu_node_link_free(output->link);
1560     }
1561
1562   BLI_freelistN(&node->outputs);
1563   MEM_freeN(node);
1564 }
1565
1566 static void gpu_nodes_free(ListBase *nodes)
1567 {
1568   GPUNode *node;
1569
1570   while ((node = BLI_pophead(nodes))) {
1571     gpu_node_free(node);
1572   }
1573 }
1574
1575 /* vertex attributes */
1576
1577 void GPU_nodes_get_vertex_attrs(ListBase *nodes, GPUVertAttrLayers *attrs)
1578 {
1579   GPUNode *node;
1580   GPUInput *input;
1581   int a;
1582
1583   /* convert attributes requested by node inputs to an array of layers,
1584    * checking for duplicates and assigning id's starting from zero. */
1585
1586   memset(attrs, 0, sizeof(*attrs));
1587
1588   for (node = nodes->first; node; node = node->next) {
1589     for (input = node->inputs.first; input; input = input->next) {
1590       if (input->source == GPU_SOURCE_ATTR) {
1591         for (a = 0; a < attrs->totlayer; a++) {
1592           if (attrs->layer[a].type == input->attr_type &&
1593               STREQ(attrs->layer[a].name, input->attr_name)) {
1594             break;
1595           }
1596         }
1597
1598         if (a < GPU_MAX_ATTR) {
1599           if (a == attrs->totlayer) {
1600             input->attr_id = attrs->totlayer++;
1601             input->attr_first = true;
1602
1603             attrs->layer[a].type = input->attr_type;
1604             attrs->layer[a].attr_id = input->attr_id;
1605             BLI_strncpy(attrs->layer[a].name, input->attr_name, sizeof(attrs->layer[a].name));
1606           }
1607           else {
1608             input->attr_id = attrs->layer[a].attr_id;
1609           }
1610         }
1611       }
1612     }
1613   }
1614 }
1615
1616 /* varargs linking  */
1617
1618 GPUNodeLink *GPU_attribute(const CustomDataType type, const char *name)
1619 {
1620   GPUNodeLink *link = GPU_node_link_create();
1621   link->link_type = GPU_NODE_LINK_ATTR;
1622   link->attr_name = name;
1623   /* Fall back to the UV layer, which matches old behavior. */
1624   if (type == CD_AUTO_FROM_NAME && name[0] == '\0') {
1625     link->attr_type = CD_MTFACE;
1626   }
1627   else {
1628     link->attr_type = type;
1629   }
1630   return link;
1631 }
1632
1633 GPUNodeLink *GPU_constant(float *num)
1634 {
1635   GPUNodeLink *link = GPU_node_link_create();
1636   link->link_type = GPU_NODE_LINK_CONSTANT;
1637   link->data = num;
1638   return link;
1639 }
1640
1641 GPUNodeLink *GPU_uniform(float *num)
1642 {
1643   GPUNodeLink *link = GPU_node_link_create();
1644   link->link_type = GPU_NODE_LINK_UNIFORM;
1645   link->data = num;
1646   return link;
1647 }
1648
1649 GPUNodeLink *GPU_image(Image *ima, ImageUser *iuser, bool is_data)
1650 {
1651   GPUNodeLink *link = GPU_node_link_create();
1652   link->link_type = GPU_NODE_LINK_IMAGE_BLENDER;
1653   link->ima = ima;
1654   link->iuser = iuser;
1655   link->image_isdata = is_data;
1656   return link;
1657 }
1658
1659 GPUNodeLink *GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *row)
1660 {
1661   GPUNodeLink *link = GPU_node_link_create();
1662   link->link_type = GPU_NODE_LINK_COLORBAND;
1663   link->coba = gpu_material_ramp_texture_row_set(mat, size, pixels, row);
1664   MEM_freeN(pixels);
1665   return link;
1666 }
1667
1668 GPUNodeLink *GPU_builtin(eGPUBuiltin builtin)
1669 {
1670   GPUNodeLink *link = GPU_node_link_create();
1671   link->link_type = GPU_NODE_LINK_BUILTIN;
1672   link->builtin = builtin;
1673   return link;
1674 }
1675
1676 bool GPU_link(GPUMaterial *mat, const char *name, ...)
1677 {
1678   GPUNode *node;
1679   GPUFunction *function;
1680   GPUNodeLink *link, **linkptr;
1681   va_list params;
1682   int i;
1683
1684   function = gpu_lookup_function(name);
1685   if (!function) {
1686     fprintf(stderr, "GPU failed to find function %s\n", name);
1687     return false;
1688   }
1689
1690   node = GPU_node_begin(name);
1691
1692   va_start(params, name);
1693   for (i = 0; i < function->totparam; i++) {
1694     if (function->paramqual[i] != FUNCTION_QUAL_IN) {
1695       linkptr = va_arg(params, GPUNodeLink **);
1696       gpu_node_output(node, function->paramtype[i], linkptr);
1697     }
1698     else {
1699       link = va_arg(params, GPUNodeLink *);
1700       gpu_node_input_link(node, link, function->paramtype[i]);
1701     }
1702   }
1703   va_end(params);
1704
1705   gpu_material_add_node(mat, node);
1706
1707   return true;
1708 }
1709
1710 bool GPU_stack_link(GPUMaterial *material,
1711                     bNode *bnode,
1712                     const char *name,
1713                     GPUNodeStack *in,
1714                     GPUNodeStack *out,
1715                     ...)
1716 {
1717   GPUNode *node;
1718   GPUFunction *function;
1719   GPUNodeLink *link, **linkptr;
1720   va_list params;
1721   int i, totin, totout;
1722
1723   function = gpu_lookup_function(name);
1724   if (!function) {
1725     fprintf(stderr, "GPU failed to find function %s\n", name);
1726     return false;
1727   }
1728
1729   node = GPU_node_begin(name);
1730   totin = 0;
1731   totout = 0;
1732
1733   if (in) {
1734     for (i = 0; !in[i].end; i++) {
1735       if (in[i].type != GPU_NONE) {
1736         gpu_node_input_socket(material, bnode, node, &in[i], i);
1737         totin++;
1738       }
1739     }
1740   }
1741
1742   if (out) {
1743     for (i = 0; !out[i].end; i++) {
1744       if (out[i].type != GPU_NONE) {
1745         gpu_node_output(node, out[i].type, &out[i].link);
1746         totout++;
1747       }
1748     }
1749   }
1750
1751   va_start(params, out);
1752   for (i = 0; i < function->totparam; i++) {
1753     if (function->paramqual[i] != FUNCTION_QUAL_IN) {
1754       if (totout == 0) {
1755         linkptr = va_arg(params, GPUNodeLink **);
1756         gpu_node_output(node, function->paramtype[i], linkptr);
1757       }
1758       else
1759         totout--;
1760     }
1761     else {
1762       if (totin == 0) {
1763         link = va_arg(params, GPUNodeLink *);
1764         if (link->socket)
1765           gpu_node_input_socket(NULL, NULL, node, link->socket, -1);
1766         else
1767           gpu_node_input_link(node, link, function->paramtype[i]);
1768       }
1769       else
1770         totin--;
1771     }
1772   }
1773   va_end(params);
1774
1775   gpu_material_add_node(material, node);
1776
1777   return true;
1778 }
1779
1780 GPUNodeLink *GPU_uniformbuffer_link_out(GPUMaterial *mat,
1781                                         bNode *node,
1782                                         GPUNodeStack *stack,
1783                                         const int index)
1784 {
1785   return gpu_uniformbuffer_link(mat, node, stack, index, SOCK_OUT);
1786 }
1787
1788 /* Pass create/free */
1789
1790 static void gpu_nodes_tag(GPUNodeLink *link)
1791 {
1792   GPUNode *node;
1793   GPUInput *input;
1794
1795   if (!link->output)
1796     return;
1797
1798   node = link->output->node;
1799   if (node->tag)
1800     return;
1801
1802   node->tag = true;
1803   for (input = node->inputs.first; input; input = input->next)
1804     if (input->link)
1805       gpu_nodes_tag(input->link);
1806 }
1807
1808 void GPU_nodes_prune(ListBase *nodes, GPUNodeLink *outlink)
1809 {
1810   GPUNode *node, *next;
1811
1812   for (node = nodes->first; node; node = node->next)
1813     node->tag = false;
1814
1815   gpu_nodes_tag(outlink);
1816
1817   for (node = nodes->first; node; node = next) {
1818     next = node->next;
1819
1820     if (!node->tag) {
1821       BLI_remlink(nodes, node);
1822       gpu_node_free(node);
1823     }
1824   }
1825 }
1826
1827 static bool gpu_pass_is_valid(GPUPass *pass)
1828 {
1829   /* Shader is not null if compilation is successful. */
1830   return (pass->compiled == false || pass->shader != NULL);
1831 }
1832
1833 GPUPass *GPU_generate_pass(GPUMaterial *material,
1834                            GPUNodeLink *frag_outlink,
1835                            struct GPUVertAttrLayers *attrs,
1836                            ListBase *nodes,
1837                            int *builtins,
1838                            const char *vert_code,
1839                            const char *geom_code,
1840                            const char *frag_lib,
1841                            const char *defines)
1842 {
1843   char *vertexcode, *geometrycode, *fragmentcode;
1844   GPUPass *pass = NULL, *pass_hash = NULL;
1845
1846   /* prune unused nodes */
1847   GPU_nodes_prune(nodes, frag_outlink);
1848
1849   GPU_nodes_get_vertex_attrs(nodes, attrs);
1850
1851   /* generate code */
1852   char *fragmentgen = code_generate_fragment(material, nodes, frag_outlink->output, builtins);
1853
1854   /* Cache lookup: Reuse shaders already compiled */
1855   uint32_t hash = gpu_pass_hash(fragmentgen, defines, attrs);
1856   pass_hash = gpu_pass_cache_lookup(hash);
1857
1858   if (pass_hash && (pass_hash->next == NULL || pass_hash->next->hash != hash)) {
1859     /* No collision, just return the pass. */
1860     MEM_freeN(fragmentgen);
1861     if (!gpu_pass_is_valid(pass_hash)) {
1862       /* Shader has already been created but failed to compile. */
1863       return NULL;
1864     }
1865     pass_hash->refcount += 1;
1866     return pass_hash;
1867   }
1868
1869   /* Either the shader is not compiled or there is a hash collision...
1870    * continue generating the shader strings. */
1871   char *tmp = BLI_strdupcat(frag_lib, glsl_material_library);
1872
1873   geometrycode = code_generate_geometry(nodes, geom_code, defines);
1874   vertexcode = code_generate_vertex(nodes, vert_code, (geometrycode != NULL));
1875   fragmentcode = BLI_strdupcat(tmp, fragmentgen);
1876
1877   MEM_freeN(fragmentgen);
1878   MEM_freeN(tmp);
1879
1880   if (pass_hash) {
1881     /* Cache lookup: Reuse shaders already compiled */
1882     pass = gpu_pass_cache_resolve_collision(
1883         pass_hash, vertexcode, geometrycode, fragmentcode, defines, hash);
1884   }
1885
1886   if (pass) {
1887     /* Cache hit. Reuse the same GPUPass and GPUShader. */
1888     if (!gpu_pass_is_valid(pass)) {
1889       /* Shader has already been created but failed to compile. */
1890       return NULL;
1891     }
1892
1893     MEM_SAFE_FREE(vertexcode);
1894     MEM_SAFE_FREE(fragmentcode);
1895     MEM_SAFE_FREE(geometrycode);
1896
1897     pass->refcount += 1;
1898   }
1899   else {
1900     /* We still create a pass even if shader compilation
1901      * fails to avoid trying to compile again and again. */
1902     pass = MEM_callocN(sizeof(GPUPass), "GPUPass");
1903     pass->shader = NULL;
1904     pass->refcount = 1;
1905     pass->hash = hash;
1906     pass->vertexcode = vertexcode;
1907     pass->fragmentcode = fragmentcode;
1908     pass->geometrycode = geometrycode;
1909     pass->defines = (defines) ? BLI_strdup(defines) : NULL;
1910     pass->compiled = false;
1911
1912     BLI_spin_lock(&pass_cache_spin);
1913     if (pass_hash != NULL) {
1914       /* Add after the first pass having the same hash. */
1915       pass->next = pass_hash->next;
1916       pass_hash->next = pass;
1917     }
1918     else {
1919       /* No other pass have same hash, just prepend to the list. */
1920       BLI_LINKS_PREPEND(pass_cache, pass);
1921     }
1922     BLI_spin_unlock(&pass_cache_spin);
1923   }
1924
1925   return pass;
1926 }
1927
1928 static int count_active_texture_sampler(GPUShader *shader, char *source)
1929 {
1930   char *code = source;
1931   int samplers_id[64]; /* Remember this is per stage. */
1932   int sampler_len = 0;
1933
1934   while ((code = strstr(code, "uniform "))) {
1935     /* Move past "uniform". */
1936     code += 7;
1937     /* Skip following spaces. */
1938     while (*code == ' ') {
1939       code++;
1940     }
1941     /* Skip "i" from potential isamplers. */
1942     if (*code == 'i') {
1943       code++;
1944     }
1945     /* Skip following spaces. */
1946     if (gpu_str_prefix(code, "sampler")) {
1947       /* Move past "uniform". */
1948       code += 7;
1949       /* Skip sampler type suffix. */
1950       while (*code != ' ' && *code != '\0') {
1951         code++;
1952       }
1953       /* Skip following spaces. */
1954       while (*code == ' ') {
1955         code++;
1956       }
1957
1958       if (*code != '\0') {
1959         char sampler_name[64];
1960         code = gpu_str_skip_token(code, sampler_name, sizeof(sampler_name));
1961         int id = GPU_shader_get_uniform_ensure(shader, sampler_name);
1962
1963         if (id == -1) {
1964           continue;
1965         }
1966         /* Catch duplicates. */
1967         bool is_duplicate = false;
1968         for (int i = 0; i < sampler_len; ++i) {
1969           if (samplers_id[i] == id) {
1970             is_duplicate = true;
1971           }
1972         }
1973
1974         if (!is_duplicate) {
1975           samplers_id[sampler_len] = id;
1976           sampler_len++;
1977         }
1978       }
1979     }
1980   }
1981
1982   return sampler_len;
1983 }
1984
1985 static bool gpu_pass_shader_validate(GPUPass *pass)
1986 {
1987   if (pass->shader == NULL) {
1988     return false;
1989   }
1990
1991   /* NOTE: The only drawback of this method is that it will count a sampler
1992    * used in the fragment shader and only declared (but not used) in the vertex
1993    * shader as used by both. But this corner case is not happening for now. */
1994   int vert_samplers_len = count_active_texture_sampler(pass->shader, pass->vertexcode);
1995   int frag_samplers_len = count_active_texture_sampler(pass->shader, pass->fragmentcode);
1996
1997   int total_samplers_len = vert_samplers_len + frag_samplers_len;
1998
1999   /* Validate against opengl limit. */
2000   if ((frag_samplers_len > GPU_max_textures_frag()) ||
2001       (vert_samplers_len > GPU_max_textures_vert())) {
2002     return false;
2003   }
2004
2005   if (pass->geometrycode) {
2006     int geom_samplers_len = count_active_texture_sampler(pass->shader, pass->geometrycode);
2007     total_samplers_len += geom_samplers_len;
2008     if (geom_samplers_len > GPU_max_textures_geom()) {
2009       return false;
2010     }
2011   }
2012
2013   return (total_samplers_len <= GPU_max_textures());
2014 }
2015
2016 void GPU_pass_compile(GPUPass *pass, const char *shname)
2017 {
2018   if (!pass->compiled) {
2019     pass->shader = GPU_shader_create(
2020         pass->vertexcode, pass->fragmentcode, pass->geometrycode, NULL, pass->defines, shname);
2021
2022     /* NOTE: Some drivers / gpu allows more active samplers than the opengl limit.
2023      * We need to make sure to count active samplers to avoid undefined behavior. */
2024     if (!gpu_pass_shader_validate(pass)) {
2025       if (pass->shader != NULL) {
2026         fprintf(stderr, "GPUShader: error: too many samplers in shader.\n");
2027         GPU_shader_free(pass->shader);
2028       }
2029       pass->shader = NULL;
2030     }
2031     else if (!BLI_thread_is_main()) {
2032       /* For some Intel drivers, you must use the program at least once
2033        * in the rendering context that it is linked. */
2034       glUseProgram(GPU_shader_get_program(pass->shader));
2035       glUseProgram(0);
2036     }
2037
2038     pass->compiled = true;
2039   }
2040 }
2041
2042 void GPU_pass_release(GPUPass *pass)
2043 {
2044   BLI_assert(pass->refcount > 0);
2045   pass->refcount--;
2046 }
2047
2048 static void gpu_pass_free(GPUPass *pass)
2049 {
2050   BLI_assert(pass->refcount == 0);
2051   if (pass->shader) {
2052     GPU_shader_free(pass->shader);
2053   }
2054   MEM_SAFE_FREE(pass->fragmentcode);
2055   MEM_SAFE_FREE(pass->geometrycode);
2056   MEM_SAFE_FREE(pass->vertexcode);
2057   MEM_SAFE_FREE(pass->defines);
2058   MEM_freeN(pass);
2059 }
2060
2061 void GPU_pass_free_nodes(ListBase *nodes)
2062 {
2063   gpu_nodes_free(nodes);
2064 }
2065
2066 void GPU_pass_cache_garbage_collect(void)
2067 {
2068   static int lasttime = 0;
2069   const int shadercollectrate = 60; /* hardcoded for now. */
2070   int ctime = (int)PIL_check_seconds_timer();
2071
2072   if (ctime < shadercollectrate + lasttime)
2073     return;
2074
2075   lasttime = ctime;
2076
2077   BLI_spin_lock(&pass_cache_spin);
2078   GPUPass *next, **prev_pass = &pass_cache;
2079   for (GPUPass *pass = pass_cache; pass; pass = next) {
2080     next = pass->next;
2081     if (pass->refcount == 0) {
2082       /* Remove from list */
2083       *prev_pass = next;
2084       gpu_pass_free(pass);
2085     }
2086     else {
2087       prev_pass = &pass->next;
2088     }
2089   }
2090   BLI_spin_unlock(&pass_cache_spin);
2091 }
2092
2093 void GPU_pass_cache_init(void)
2094 {
2095   BLI_spin_init(&pass_cache_spin);
2096 }
2097
2098 void GPU_pass_cache_free(void)
2099 {
2100   BLI_spin_lock(&pass_cache_spin);
2101   while (pass_cache) {
2102     GPUPass *next = pass_cache->next;
2103     gpu_pass_free(pass_cache);
2104     pass_cache = next;
2105   }
2106   BLI_spin_unlock(&pass_cache_spin);
2107
2108   BLI_spin_end(&pass_cache_spin);
2109 }