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