Fix T63435 Incorrect fresnel and normals for hair strands on EEVEE
[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, "#ifdef HAIR_SHADER\n");
896     BLI_dynstr_append(ds, "\tvec3 n;\n");
897     BLI_dynstr_append(ds, "\tworld_normals_get(n);\n");
898     BLI_dynstr_append(ds, "\tvec3 facingnormal = transform_direction(ViewMatrix, n);\n");
899     BLI_dynstr_append(ds, "#else\n");
900     BLI_dynstr_append(ds, "\tvec3 facingnormal = gl_FrontFacing? viewNormal: -viewNormal;\n");
901     BLI_dynstr_append(ds, "#endif\n");
902   }
903   if (builtins & GPU_VIEW_POSITION) {
904     BLI_dynstr_append(ds, "\t#define viewposition viewPosition\n");
905   }
906
907   codegen_declare_tmps(ds, nodes);
908   codegen_call_functions(ds, nodes, output);
909
910   BLI_dynstr_append(ds, "}\n");
911
912   /* XXX This cannot go into gpu_shader_material.glsl because main()
913    * would be parsed and generate error */
914   /* Old glsl mode compat. */
915   BLI_dynstr_append(ds, "#ifndef NODETREE_EXEC\n");
916   BLI_dynstr_append(ds, "out vec4 fragColor;\n");
917   BLI_dynstr_append(ds, "void main()\n");
918   BLI_dynstr_append(ds, "{\n");
919   BLI_dynstr_append(ds, "\tClosure cl = nodetree_exec();\n");
920   BLI_dynstr_append(ds, "\tfragColor = vec4(cl.radiance, cl.opacity);\n");
921   BLI_dynstr_append(ds, "}\n");
922   BLI_dynstr_append(ds, "#endif\n\n");
923
924   /* create shader */
925   code = BLI_dynstr_get_cstring(ds);
926   BLI_dynstr_free(ds);
927
928 #if 0
929   if (G.debug & G_DEBUG)
930     printf("%s\n", code);
931 #endif
932
933   return code;
934 }
935
936 static const char *attr_prefix_get(CustomDataType type)
937 {
938   switch (type) {
939     case CD_ORCO:
940       return "orco";
941     case CD_MTFACE:
942       return "u";
943     case CD_TANGENT:
944       return "t";
945     case CD_MCOL:
946       return "c";
947     case CD_AUTO_FROM_NAME:
948       return "a";
949     default:
950       BLI_assert(false && "GPUVertAttr Prefix type not found : This should not happen!");
951       return "";
952   }
953 }
954
955 static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool use_geom)
956 {
957   DynStr *ds = BLI_dynstr_new();
958   GPUNode *node;
959   GPUInput *input;
960   char *code;
961   int builtins = 0;
962
963   /* Hairs uv and col attributes are passed by bufferTextures. */
964   BLI_dynstr_append(ds,
965                     "#ifdef HAIR_SHADER\n"
966                     "#define DEFINE_ATTR(type, attr) uniform samplerBuffer attr\n"
967                     "#else\n"
968                     "#define DEFINE_ATTR(type, attr) in type attr\n"
969                     "#endif\n");
970
971   for (node = nodes->first; node; node = node->next) {
972     for (input = node->inputs.first; input; input = input->next) {
973       if (input->source == GPU_SOURCE_BUILTIN) {
974         builtins |= input->builtin;
975       }
976       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
977         /* XXX FIXME : see notes in mesh_render_data_create() */
978         /* NOTE : Replicate changes to mesh_render_data_create() in draw_cache_impl_mesh.c */
979         if (input->attr_type == CD_ORCO) {
980           /* OPTI : orco is computed from local positions, but only if no modifier is present. */
981           BLI_dynstr_append(ds, "uniform vec3 OrcoTexCoFactors[2];\n");
982           BLI_dynstr_append(ds, "DEFINE_ATTR(vec4, orco);\n");
983         }
984         else if (input->attr_name[0] == '\0') {
985           BLI_dynstr_appendf(ds,
986                              "DEFINE_ATTR(%s, %s);\n",
987                              GPU_DATATYPE_STR[input->type],
988                              attr_prefix_get(input->attr_type));
989           BLI_dynstr_appendf(
990               ds, "#define att%d %s\n", input->attr_id, attr_prefix_get(input->attr_type));
991         }
992         else {
993           uint hash = BLI_ghashutil_strhash_p(input->attr_name);
994           BLI_dynstr_appendf(ds,
995                              "DEFINE_ATTR(%s, %s%u);\n",
996                              GPU_DATATYPE_STR[input->type],
997                              attr_prefix_get(input->attr_type),
998                              hash);
999           BLI_dynstr_appendf(
1000               ds, "#define att%d %s%u\n", input->attr_id, attr_prefix_get(input->attr_type), hash);
1001           /* Auto attribute can be vertex color byte buffer.
1002            * We need to know and convert them to linear space in VS. */
1003           if (input->attr_type == CD_AUTO_FROM_NAME) {
1004             BLI_dynstr_appendf(ds, "uniform bool ba%u;\n", hash);
1005             BLI_dynstr_appendf(ds, "#define att%d_is_srgb ba%u\n", input->attr_id, hash);
1006           }
1007         }
1008         BLI_dynstr_appendf(ds,
1009                            "out %s var%d%s;\n",
1010                            GPU_DATATYPE_STR[input->type],
1011                            input->attr_id,
1012                            use_geom ? "g" : "");
1013       }
1014     }
1015   }
1016
1017   if (builtins & GPU_BARYCENTRIC_TEXCO) {
1018     BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
1019     BLI_dynstr_appendf(ds, "out vec2 barycentricTexCo%s;\n", use_geom ? "g" : "");
1020     BLI_dynstr_append(ds, "#endif\n");
1021   }
1022
1023   if (builtins & GPU_BARYCENTRIC_DIST) {
1024     BLI_dynstr_append(ds, "out vec3 barycentricPosg;\n");
1025   }
1026
1027   BLI_dynstr_append(ds, "\n");
1028
1029   BLI_dynstr_append(ds,
1030                     "#define USE_ATTR\n"
1031                     "uniform mat3 NormalMatrix;\n"
1032                     "uniform mat4 ModelMatrixInverse;\n"
1033                     "uniform mat4 ModelMatrix;\n"
1034                     "vec3 srgb_to_linear_attr(vec3 c) {\n"
1035                     "\tc = max(c, vec3(0.0));\n"
1036                     "\tvec3 c1 = c * (1.0 / 12.92);\n"
1037                     "\tvec3 c2 = pow((c + 0.055) * (1.0 / 1.055), vec3(2.4));\n"
1038                     "\treturn mix(c1, c2, step(vec3(0.04045), c));\n"
1039                     "}\n\n");
1040
1041   /* Prototype because defined later. */
1042   BLI_dynstr_append(ds,
1043                     "vec2 hair_get_customdata_vec2(const samplerBuffer);\n"
1044                     "vec3 hair_get_customdata_vec3(const samplerBuffer);\n"
1045                     "vec4 hair_get_customdata_vec4(const samplerBuffer);\n"
1046                     "vec3 hair_get_strand_pos(void);\n"
1047                     "int hair_get_base_id(void);\n"
1048                     "\n");
1049
1050   BLI_dynstr_append(ds, "void pass_attr(in vec3 position) {\n");
1051
1052   BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
1053
1054   if (builtins & GPU_BARYCENTRIC_TEXCO) {
1055     /* To match cycles without breaking into individual segment we encode if we need to invert
1056      * the first component into the second component. We invert if the barycentricTexCo.y
1057      * is NOT 0.0 or 1.0. */
1058     BLI_dynstr_append(ds, "\tint _base_id = hair_get_base_id();\n");
1059     BLI_dynstr_appendf(
1060         ds, "\tbarycentricTexCo%s.x = float((_base_id %% 2) == 1);\n", use_geom ? "g" : "");
1061     BLI_dynstr_appendf(
1062         ds, "\tbarycentricTexCo%s.y = float(((_base_id %% 4) %% 3) > 0);\n", use_geom ? "g" : "");
1063   }
1064
1065   if (builtins & GPU_BARYCENTRIC_DIST) {
1066     BLI_dynstr_append(ds, "\tbarycentricPosg = position;\n");
1067   }
1068
1069   for (node = nodes->first; node; node = node->next) {
1070     for (input = node->inputs.first; input; input = input->next) {
1071       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
1072         if (input->attr_type == CD_TANGENT) {
1073           /* Not supported by hairs */
1074           BLI_dynstr_appendf(ds, "\tvar%d%s = vec4(0.0);\n", input->attr_id, use_geom ? "g" : "");
1075         }
1076         else if (input->attr_type == CD_ORCO) {
1077           BLI_dynstr_appendf(ds,
1078                              "\tvar%d%s = OrcoTexCoFactors[0] + (ModelMatrixInverse * "
1079                              "vec4(hair_get_strand_pos(), 1.0)).xyz * OrcoTexCoFactors[1];\n",
1080                              input->attr_id,
1081                              use_geom ? "g" : "");
1082           /* TODO: fix ORCO with modifiers. */
1083         }
1084         else {
1085           BLI_dynstr_appendf(ds,
1086                              "\tvar%d%s = hair_get_customdata_%s(att%d);\n",
1087                              input->attr_id,
1088                              use_geom ? "g" : "",
1089                              GPU_DATATYPE_STR[input->type],
1090                              input->attr_id);
1091         }
1092       }
1093     }
1094   }
1095
1096   BLI_dynstr_append(ds, "#else /* MESH_SHADER */\n");
1097
1098   /* GPU_BARYCENTRIC_TEXCO cannot be computed based on gl_VertexID
1099    * for MESH_SHADER because of indexed drawing. In this case a
1100    * geometry shader is needed. */
1101
1102   if (builtins & GPU_BARYCENTRIC_DIST) {
1103     BLI_dynstr_append(ds, "\tbarycentricPosg = (ModelMatrix * vec4(position, 1.0)).xyz;\n");
1104   }
1105
1106   for (node = nodes->first; node; node = node->next) {
1107     for (input = node->inputs.first; input; input = input->next) {
1108       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
1109         if (input->attr_type == CD_TANGENT) { /* silly exception */
1110           BLI_dynstr_appendf(ds,
1111                              "\tvar%d%s.xyz = NormalMatrix * att%d.xyz;\n",
1112                              input->attr_id,
1113                              use_geom ? "g" : "",
1114                              input->attr_id);
1115           BLI_dynstr_appendf(
1116               ds, "\tvar%d%s.w = att%d.w;\n", input->attr_id, use_geom ? "g" : "", input->attr_id);
1117           /* Normalize only if vector is not null. */
1118           BLI_dynstr_appendf(ds,
1119                              "\tfloat lvar%d = dot(var%d%s.xyz, var%d%s.xyz);\n",
1120                              input->attr_id,
1121                              input->attr_id,
1122                              use_geom ? "g" : "",
1123                              input->attr_id,
1124                              use_geom ? "g" : "");
1125           BLI_dynstr_appendf(ds,
1126                              "\tvar%d%s.xyz *= (lvar%d > 0.0) ? inversesqrt(lvar%d) : 1.0;\n",
1127                              input->attr_id,
1128                              use_geom ? "g" : "",
1129                              input->attr_id,
1130                              input->attr_id);
1131         }
1132         else if (input->attr_type == CD_ORCO) {
1133           BLI_dynstr_appendf(ds,
1134                              "\tvar%d%s = OrcoTexCoFactors[0] + position * OrcoTexCoFactors[1];\n",
1135                              input->attr_id,
1136                              use_geom ? "g" : "");
1137           /* See mesh_create_loop_orco() for explanation. */
1138           BLI_dynstr_appendf(ds,
1139                              "\tif (orco.w == 0.0) { var%d%s = orco.xyz * 0.5 + 0.5; }\n",
1140                              input->attr_id,
1141                              use_geom ? "g" : "");
1142         }
1143         else if (input->attr_type == CD_MCOL) {
1144           BLI_dynstr_appendf(ds,
1145                              "\tvar%d%s = srgb_to_linear_attr(att%d);\n",
1146                              input->attr_id,
1147                              use_geom ? "g" : "",
1148                              input->attr_id);
1149         }
1150         else if (input->attr_type == CD_AUTO_FROM_NAME) {
1151           BLI_dynstr_appendf(ds,
1152                              "\tvar%d%s = (att%d_is_srgb) ? srgb_to_linear_attr(att%d) : att%d;\n",
1153                              input->attr_id,
1154                              use_geom ? "g" : "",
1155                              input->attr_id,
1156                              input->attr_id,
1157                              input->attr_id);
1158         }
1159         else {
1160           BLI_dynstr_appendf(
1161               ds, "\tvar%d%s = att%d;\n", input->attr_id, use_geom ? "g" : "", input->attr_id);
1162         }
1163       }
1164     }
1165   }
1166   BLI_dynstr_append(ds, "#endif /* HAIR_SHADER */\n");
1167
1168   BLI_dynstr_append(ds, "}\n");
1169
1170   if (use_geom) {
1171     /* XXX HACK: Eevee specific. */
1172     char *vert_new, *vert_new2;
1173     vert_new = BLI_str_replaceN(vert_code, "worldPosition", "worldPositiong");
1174     vert_new2 = vert_new;
1175     vert_new = BLI_str_replaceN(vert_new2, "viewPosition", "viewPositiong");
1176     MEM_freeN(vert_new2);
1177     vert_new2 = vert_new;
1178     vert_new = BLI_str_replaceN(vert_new2, "worldNormal", "worldNormalg");
1179     MEM_freeN(vert_new2);
1180     vert_new2 = vert_new;
1181     vert_new = BLI_str_replaceN(vert_new2, "viewNormal", "viewNormalg");
1182     MEM_freeN(vert_new2);
1183
1184     BLI_dynstr_append(ds, vert_new);
1185
1186     MEM_freeN(vert_new);
1187   }
1188   else {
1189     BLI_dynstr_append(ds, vert_code);
1190   }
1191
1192   code = BLI_dynstr_get_cstring(ds);
1193
1194   BLI_dynstr_free(ds);
1195
1196 #if 0
1197   if (G.debug & G_DEBUG)
1198     printf("%s\n", code);
1199 #endif
1200
1201   return code;
1202 }
1203
1204 static char *code_generate_geometry(ListBase *nodes, const char *geom_code, const char *defines)
1205 {
1206   DynStr *ds = BLI_dynstr_new();
1207   GPUNode *node;
1208   GPUInput *input;
1209   char *code;
1210   int builtins = 0;
1211
1212   /* XXX we should not make specific eevee cases here. */
1213   bool is_hair_shader = (strstr(defines, "HAIR_SHADER") != NULL);
1214
1215   /* Create prototype because attributes cannot be declared before layout. */
1216   BLI_dynstr_append(ds, "void pass_attr(in int vert);\n");
1217   BLI_dynstr_append(ds, "void calc_barycentric_distances(vec3 pos0, vec3 pos1, vec3 pos2);\n");
1218   BLI_dynstr_append(ds, "#define USE_ATTR\n");
1219
1220   /* Generate varying declarations. */
1221   for (node = nodes->first; node; node = node->next) {
1222     for (input = node->inputs.first; input; input = input->next) {
1223       if (input->source == GPU_SOURCE_BUILTIN) {
1224         builtins |= input->builtin;
1225       }
1226       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
1227         BLI_dynstr_appendf(ds, "in %s var%dg[];\n", GPU_DATATYPE_STR[input->type], input->attr_id);
1228         BLI_dynstr_appendf(ds, "out %s var%d;\n", GPU_DATATYPE_STR[input->type], input->attr_id);
1229       }
1230     }
1231   }
1232
1233   if (builtins & GPU_BARYCENTRIC_TEXCO) {
1234     BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
1235     BLI_dynstr_append(ds, "in vec2 barycentricTexCog[];\n");
1236     BLI_dynstr_append(ds, "#endif\n");
1237
1238     BLI_dynstr_append(ds, "out vec2 barycentricTexCo;\n");
1239   }
1240
1241   if (builtins & GPU_BARYCENTRIC_DIST) {
1242     BLI_dynstr_append(ds, "in vec3 barycentricPosg[];\n");
1243     BLI_dynstr_append(ds, "flat out vec3 barycentricDist;\n");
1244   }
1245
1246   if (geom_code == NULL) {
1247     /* Force geometry usage if GPU_BARYCENTRIC_DIST or GPU_BARYCENTRIC_TEXCO are used.
1248      * Note: GPU_BARYCENTRIC_TEXCO only requires it if the shader is not drawing hairs. */
1249     if ((builtins & (GPU_BARYCENTRIC_DIST | GPU_BARYCENTRIC_TEXCO)) == 0 || is_hair_shader) {
1250       /* Early out */
1251       BLI_dynstr_free(ds);
1252       return NULL;
1253     }
1254     else {
1255       /* Force geom shader usage */
1256       /* TODO put in external file. */
1257       BLI_dynstr_append(ds, "layout(triangles) in;\n");
1258       BLI_dynstr_append(ds, "layout(triangle_strip, max_vertices=3) out;\n");
1259
1260       BLI_dynstr_append(ds, "in vec3 worldPositiong[];\n");
1261       BLI_dynstr_append(ds, "in vec3 viewPositiong[];\n");
1262       BLI_dynstr_append(ds, "in vec3 worldNormalg[];\n");
1263       BLI_dynstr_append(ds, "in vec3 viewNormalg[];\n");
1264
1265       BLI_dynstr_append(ds, "out vec3 worldPosition;\n");
1266       BLI_dynstr_append(ds, "out vec3 viewPosition;\n");
1267       BLI_dynstr_append(ds, "out vec3 worldNormal;\n");
1268       BLI_dynstr_append(ds, "out vec3 viewNormal;\n");
1269
1270       BLI_dynstr_append(ds, "void main(){\n");
1271
1272       if (builtins & GPU_BARYCENTRIC_DIST) {
1273         BLI_dynstr_append(ds,
1274                           "\tcalc_barycentric_distances(barycentricPosg[0], barycentricPosg[1], "
1275                           "barycentricPosg[2]);\n");
1276       }
1277
1278       BLI_dynstr_append(ds, "\tgl_Position = gl_in[0].gl_Position;\n");
1279       BLI_dynstr_append(ds, "\tpass_attr(0);\n");
1280       BLI_dynstr_append(ds, "\tEmitVertex();\n");
1281
1282       BLI_dynstr_append(ds, "\tgl_Position = gl_in[1].gl_Position;\n");
1283       BLI_dynstr_append(ds, "\tpass_attr(1);\n");
1284       BLI_dynstr_append(ds, "\tEmitVertex();\n");
1285
1286       BLI_dynstr_append(ds, "\tgl_Position = gl_in[2].gl_Position;\n");
1287       BLI_dynstr_append(ds, "\tpass_attr(2);\n");
1288       BLI_dynstr_append(ds, "\tEmitVertex();\n");
1289       BLI_dynstr_append(ds, "};\n");
1290     }
1291   }
1292   else {
1293     BLI_dynstr_append(ds, geom_code);
1294   }
1295
1296   if (builtins & GPU_BARYCENTRIC_DIST) {
1297     BLI_dynstr_append(ds, "void calc_barycentric_distances(vec3 pos0, vec3 pos1, vec3 pos2) {\n");
1298     BLI_dynstr_append(ds, "\tvec3 edge21 = pos2 - pos1;\n");
1299     BLI_dynstr_append(ds, "\tvec3 edge10 = pos1 - pos0;\n");
1300     BLI_dynstr_append(ds, "\tvec3 edge02 = pos0 - pos2;\n");
1301     BLI_dynstr_append(ds, "\tvec3 d21 = normalize(edge21);\n");
1302     BLI_dynstr_append(ds, "\tvec3 d10 = normalize(edge10);\n");
1303     BLI_dynstr_append(ds, "\tvec3 d02 = normalize(edge02);\n");
1304
1305     BLI_dynstr_append(ds, "\tfloat d = dot(d21, edge02);\n");
1306     BLI_dynstr_append(ds, "\tbarycentricDist.x = sqrt(dot(edge02, edge02) - d * d);\n");
1307     BLI_dynstr_append(ds, "\td = dot(d02, edge10);\n");
1308     BLI_dynstr_append(ds, "\tbarycentricDist.y = sqrt(dot(edge10, edge10) - d * d);\n");
1309     BLI_dynstr_append(ds, "\td = dot(d10, edge21);\n");
1310     BLI_dynstr_append(ds, "\tbarycentricDist.z = sqrt(dot(edge21, edge21) - d * d);\n");
1311     BLI_dynstr_append(ds, "}\n");
1312   }
1313
1314   /* Generate varying assignments. */
1315   BLI_dynstr_append(ds, "void pass_attr(in int vert) {\n");
1316
1317   /* XXX HACK: Eevee specific. */
1318   if (geom_code == NULL) {
1319     BLI_dynstr_append(ds, "\tworldPosition = worldPositiong[vert];\n");
1320     BLI_dynstr_append(ds, "\tviewPosition = viewPositiong[vert];\n");
1321     BLI_dynstr_append(ds, "\tworldNormal = worldNormalg[vert];\n");
1322     BLI_dynstr_append(ds, "\tviewNormal = viewNormalg[vert];\n");
1323   }
1324
1325   if (builtins & GPU_BARYCENTRIC_TEXCO) {
1326     BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
1327     BLI_dynstr_append(ds, "\tbarycentricTexCo = barycentricTexCog[vert];\n");
1328     BLI_dynstr_append(ds, "#else\n");
1329     BLI_dynstr_append(ds, "\tbarycentricTexCo.x = float((vert % 3) == 0);\n");
1330     BLI_dynstr_append(ds, "\tbarycentricTexCo.y = float((vert % 3) == 1);\n");
1331     BLI_dynstr_append(ds, "#endif\n");
1332   }
1333
1334   for (node = nodes->first; node; node = node->next) {
1335     for (input = node->inputs.first; input; input = input->next) {
1336       if (input->source == GPU_SOURCE_ATTR && input->attr_first) {
1337         /* TODO let shader choose what to do depending on what the attribute is. */
1338         BLI_dynstr_appendf(ds, "\tvar%d = var%dg[vert];\n", input->attr_id, input->attr_id);
1339       }
1340     }
1341   }
1342   BLI_dynstr_append(ds, "}\n");
1343
1344   code = BLI_dynstr_get_cstring(ds);
1345   BLI_dynstr_free(ds);
1346
1347   return code;
1348 }
1349
1350 void GPU_code_generate_glsl_lib(void)
1351 {
1352   DynStr *ds;
1353
1354   /* only initialize the library once */
1355   if (glsl_material_library) {
1356     return;
1357   }
1358
1359   ds = BLI_dynstr_new();
1360
1361   BLI_dynstr_append(ds, datatoc_gpu_shader_material_glsl);
1362
1363   glsl_material_library = BLI_dynstr_get_cstring(ds);
1364
1365   BLI_dynstr_free(ds);
1366 }
1367
1368 /* GPU pass binding/unbinding */
1369
1370 GPUShader *GPU_pass_shader_get(GPUPass *pass)
1371 {
1372   return pass->shader;
1373 }
1374
1375 void GPU_nodes_extract_dynamic_inputs(GPUShader *shader, ListBase *inputs, ListBase *nodes)
1376 {
1377   GPUNode *node;
1378   GPUInput *next, *input;
1379
1380   BLI_listbase_clear(inputs);
1381
1382   if (!shader) {
1383     return;
1384   }
1385
1386   for (node = nodes->first; node; node = node->next) {
1387     int z = 0;
1388     for (input = node->inputs.first; input; input = next, z++) {
1389       next = input->next;
1390
1391       /* attributes don't need to be bound, they already have
1392        * an id that the drawing functions will use. Builtins have
1393        * constant names. */
1394       if (ELEM(input->source, GPU_SOURCE_ATTR, GPU_SOURCE_BUILTIN)) {
1395         continue;
1396       }
1397
1398       if (input->source == GPU_SOURCE_TEX) {
1399         BLI_snprintf(input->shadername, sizeof(input->shadername), "samp%d", input->texid);
1400       }
1401       else {
1402         BLI_snprintf(input->shadername, sizeof(input->shadername), "unf%d", input->id);
1403       }
1404
1405       if (input->source == GPU_SOURCE_TEX) {
1406         if (input->bindtex) {
1407           input->shaderloc = GPU_shader_get_uniform_ensure(shader, input->shadername);
1408           /* extract nodes */
1409           BLI_remlink(&node->inputs, input);
1410           BLI_addtail(inputs, input);
1411         }
1412       }
1413     }
1414   }
1415 }
1416
1417 /* Node Link Functions */
1418
1419 static GPUNodeLink *GPU_node_link_create(void)
1420 {
1421   GPUNodeLink *link = MEM_callocN(sizeof(GPUNodeLink), "GPUNodeLink");
1422   link->users++;
1423
1424   return link;
1425 }
1426
1427 static void gpu_node_link_free(GPUNodeLink *link)
1428 {
1429   link->users--;
1430
1431   if (link->users < 0) {
1432     fprintf(stderr, "GPU_node_link_free: negative refcount\n");
1433   }
1434
1435   if (link->users == 0) {
1436     if (link->output) {
1437       link->output->link = NULL;
1438     }
1439     MEM_freeN(link);
1440   }
1441 }
1442
1443 /* Node Functions */
1444
1445 static GPUNode *GPU_node_begin(const char *name)
1446 {
1447   GPUNode *node = MEM_callocN(sizeof(GPUNode), "GPUNode");
1448
1449   node->name = name;
1450
1451   return node;
1452 }
1453
1454 static void gpu_node_input_link(GPUNode *node, GPUNodeLink *link, const eGPUType type)
1455 {
1456   GPUInput *input;
1457   GPUNode *outnode;
1458   const char *name;
1459
1460   if (link->link_type == GPU_NODE_LINK_OUTPUT) {
1461     outnode = link->output->node;
1462     name = outnode->name;
1463     input = outnode->inputs.first;
1464
1465     if ((STR_ELEM(name, "set_value", "set_rgb", "set_rgba")) && (input->type == type)) {
1466       input = MEM_dupallocN(outnode->inputs.first);
1467       if (input->link) {
1468         input->link->users++;
1469       }
1470       BLI_addtail(&node->inputs, input);
1471       return;
1472     }
1473   }
1474
1475   input = MEM_callocN(sizeof(GPUInput), "GPUInput");
1476   input->node = node;
1477   input->type = type;
1478
1479   switch (link->link_type) {
1480     case GPU_NODE_LINK_BUILTIN:
1481       input->source = GPU_SOURCE_BUILTIN;
1482       input->builtin = link->builtin;
1483       break;
1484     case GPU_NODE_LINK_OUTPUT:
1485       input->source = GPU_SOURCE_OUTPUT;
1486       input->link = link;
1487       link->users++;
1488       break;
1489     case GPU_NODE_LINK_COLORBAND:
1490       input->source = GPU_SOURCE_TEX;
1491       input->coba = link->coba;
1492       break;
1493     case GPU_NODE_LINK_IMAGE_BLENDER:
1494       input->source = GPU_SOURCE_TEX;
1495       input->ima = link->ima;
1496       input->iuser = link->iuser;
1497       input->image_isdata = link->image_isdata;
1498       break;
1499     case GPU_NODE_LINK_ATTR:
1500       input->source = GPU_SOURCE_ATTR;
1501       input->attr_type = link->attr_type;
1502       BLI_strncpy(input->attr_name, link->attr_name, sizeof(input->attr_name));
1503       break;
1504     case GPU_NODE_LINK_CONSTANT:
1505       input->source = (type == GPU_CLOSURE) ? GPU_SOURCE_STRUCT : GPU_SOURCE_CONSTANT;
1506       break;
1507     case GPU_NODE_LINK_UNIFORM:
1508       input->source = GPU_SOURCE_UNIFORM;
1509       break;
1510     default:
1511       break;
1512   }
1513
1514   if (ELEM(input->source, GPU_SOURCE_CONSTANT, GPU_SOURCE_UNIFORM)) {
1515     memcpy(input->vec, link->data, type * sizeof(float));
1516   }
1517
1518   if (link->link_type != GPU_NODE_LINK_OUTPUT) {
1519     MEM_freeN(link);
1520   }
1521   BLI_addtail(&node->inputs, input);
1522 }
1523
1524 static const char *gpu_uniform_set_function_from_type(eNodeSocketDatatype type)
1525 {
1526   switch (type) {
1527     /* For now INT is supported as float. */
1528     case SOCK_INT:
1529     case SOCK_FLOAT:
1530       return "set_value";
1531     case SOCK_VECTOR:
1532       return "set_rgb";
1533     case SOCK_RGBA:
1534       return "set_rgba";
1535     default:
1536       BLI_assert(!"No gpu function for non-supported eNodeSocketDatatype");
1537       return NULL;
1538   }
1539 }
1540
1541 /**
1542  * Link stack uniform buffer.
1543  * This is called for the input/output sockets that are note connected.
1544  */
1545 static GPUNodeLink *gpu_uniformbuffer_link(GPUMaterial *mat,
1546                                            bNode *node,
1547                                            GPUNodeStack *stack,
1548                                            const int index,
1549                                            const eNodeSocketInOut in_out)
1550 {
1551   bNodeSocket *socket;
1552
1553   if (in_out == SOCK_IN) {
1554     socket = BLI_findlink(&node->inputs, index);
1555   }
1556   else {
1557     socket = BLI_findlink(&node->outputs, index);
1558   }
1559
1560   BLI_assert(socket != NULL);
1561   BLI_assert(socket->in_out == in_out);
1562
1563   if ((socket->flag & SOCK_HIDE_VALUE) == 0) {
1564     GPUNodeLink *link;
1565     switch (socket->type) {
1566       case SOCK_FLOAT: {
1567         bNodeSocketValueFloat *socket_data = socket->default_value;
1568         link = GPU_uniform(&socket_data->value);
1569         break;
1570       }
1571       case SOCK_VECTOR: {
1572         bNodeSocketValueVector *socket_data = socket->default_value;
1573         link = GPU_uniform(socket_data->value);
1574         break;
1575       }
1576       case SOCK_RGBA: {
1577         bNodeSocketValueRGBA *socket_data = socket->default_value;
1578         link = GPU_uniform(socket_data->value);
1579         break;
1580       }
1581       default:
1582         return NULL;
1583         break;
1584     }
1585
1586     if (in_out == SOCK_IN) {
1587       GPU_link(mat, gpu_uniform_set_function_from_type(socket->type), link, &stack->link);
1588     }
1589     return link;
1590   }
1591   return NULL;
1592 }
1593
1594 static void gpu_node_input_socket(
1595     GPUMaterial *material, bNode *bnode, GPUNode *node, GPUNodeStack *sock, const int index)
1596 {
1597   if (sock->link) {
1598     gpu_node_input_link(node, sock->link, sock->type);
1599   }
1600   else if ((material != NULL) &&
1601            (gpu_uniformbuffer_link(material, bnode, sock, index, SOCK_IN) != NULL)) {
1602     gpu_node_input_link(node, sock->link, sock->type);
1603   }
1604   else {
1605     gpu_node_input_link(node, GPU_constant(sock->vec), sock->type);
1606   }
1607 }
1608
1609 static void gpu_node_output(GPUNode *node, const eGPUType type, GPUNodeLink **link)
1610 {
1611   GPUOutput *output = MEM_callocN(sizeof(GPUOutput), "GPUOutput");
1612
1613   output->type = type;
1614   output->node = node;
1615
1616   if (link) {
1617     *link = output->link = GPU_node_link_create();
1618     output->link->link_type = GPU_NODE_LINK_OUTPUT;
1619     output->link->output = output;
1620
1621     /* note: the caller owns the reference to the link, GPUOutput
1622      * merely points to it, and if the node is destroyed it will
1623      * set that pointer to NULL */
1624   }
1625
1626   BLI_addtail(&node->outputs, output);
1627 }
1628
1629 void GPU_inputs_free(ListBase *inputs)
1630 {
1631   GPUInput *input;
1632
1633   for (input = inputs->first; input; input = input->next) {
1634     if (input->link) {
1635       gpu_node_link_free(input->link);
1636     }
1637   }
1638
1639   BLI_freelistN(inputs);
1640 }
1641
1642 static void gpu_node_free(GPUNode *node)
1643 {
1644   GPUOutput *output;
1645
1646   GPU_inputs_free(&node->inputs);
1647
1648   for (output = node->outputs.first; output; output = output->next) {
1649     if (output->link) {
1650       output->link->output = NULL;
1651       gpu_node_link_free(output->link);
1652     }
1653   }
1654
1655   BLI_freelistN(&node->outputs);
1656   MEM_freeN(node);
1657 }
1658
1659 static void gpu_nodes_free(ListBase *nodes)
1660 {
1661   GPUNode *node;
1662
1663   while ((node = BLI_pophead(nodes))) {
1664     gpu_node_free(node);
1665   }
1666 }
1667
1668 /* vertex attributes */
1669
1670 void GPU_nodes_get_vertex_attrs(ListBase *nodes, GPUVertAttrLayers *attrs)
1671 {
1672   GPUNode *node;
1673   GPUInput *input;
1674   int a;
1675
1676   /* convert attributes requested by node inputs to an array of layers,
1677    * checking for duplicates and assigning id's starting from zero. */
1678
1679   memset(attrs, 0, sizeof(*attrs));
1680
1681   for (node = nodes->first; node; node = node->next) {
1682     for (input = node->inputs.first; input; input = input->next) {
1683       if (input->source == GPU_SOURCE_ATTR) {
1684         for (a = 0; a < attrs->totlayer; a++) {
1685           if (attrs->layer[a].type == input->attr_type &&
1686               STREQ(attrs->layer[a].name, input->attr_name)) {
1687             break;
1688           }
1689         }
1690
1691         if (a < GPU_MAX_ATTR) {
1692           if (a == attrs->totlayer) {
1693             input->attr_id = attrs->totlayer++;
1694             input->attr_first = true;
1695
1696             attrs->layer[a].type = input->attr_type;
1697             attrs->layer[a].attr_id = input->attr_id;
1698             BLI_strncpy(attrs->layer[a].name, input->attr_name, sizeof(attrs->layer[a].name));
1699           }
1700           else {
1701             input->attr_id = attrs->layer[a].attr_id;
1702           }
1703         }
1704       }
1705     }
1706   }
1707 }
1708
1709 /* varargs linking  */
1710
1711 GPUNodeLink *GPU_attribute(const CustomDataType type, const char *name)
1712 {
1713   GPUNodeLink *link = GPU_node_link_create();
1714   link->link_type = GPU_NODE_LINK_ATTR;
1715   link->attr_name = name;
1716   /* Fall back to the UV layer, which matches old behavior. */
1717   if (type == CD_AUTO_FROM_NAME && name[0] == '\0') {
1718     link->attr_type = CD_MTFACE;
1719   }
1720   else {
1721     link->attr_type = type;
1722   }
1723   return link;
1724 }
1725
1726 GPUNodeLink *GPU_constant(float *num)
1727 {
1728   GPUNodeLink *link = GPU_node_link_create();
1729   link->link_type = GPU_NODE_LINK_CONSTANT;
1730   link->data = num;
1731   return link;
1732 }
1733
1734 GPUNodeLink *GPU_uniform(float *num)
1735 {
1736   GPUNodeLink *link = GPU_node_link_create();
1737   link->link_type = GPU_NODE_LINK_UNIFORM;
1738   link->data = num;
1739   return link;
1740 }
1741
1742 GPUNodeLink *GPU_image(Image *ima, ImageUser *iuser, bool is_data)
1743 {
1744   GPUNodeLink *link = GPU_node_link_create();
1745   link->link_type = GPU_NODE_LINK_IMAGE_BLENDER;
1746   link->ima = ima;
1747   link->iuser = iuser;
1748   link->image_isdata = is_data;
1749   return link;
1750 }
1751
1752 GPUNodeLink *GPU_color_band(GPUMaterial *mat, int size, float *pixels, float *row)
1753 {
1754   GPUNodeLink *link = GPU_node_link_create();
1755   link->link_type = GPU_NODE_LINK_COLORBAND;
1756   link->coba = gpu_material_ramp_texture_row_set(mat, size, pixels, row);
1757   MEM_freeN(pixels);
1758   return link;
1759 }
1760
1761 GPUNodeLink *GPU_builtin(eGPUBuiltin builtin)
1762 {
1763   GPUNodeLink *link = GPU_node_link_create();
1764   link->link_type = GPU_NODE_LINK_BUILTIN;
1765   link->builtin = builtin;
1766   return link;
1767 }
1768
1769 bool GPU_link(GPUMaterial *mat, const char *name, ...)
1770 {
1771   GPUNode *node;
1772   GPUFunction *function;
1773   GPUNodeLink *link, **linkptr;
1774   va_list params;
1775   int i;
1776
1777   function = gpu_lookup_function(name);
1778   if (!function) {
1779     fprintf(stderr, "GPU failed to find function %s\n", name);
1780     return false;
1781   }
1782
1783   node = GPU_node_begin(name);
1784
1785   va_start(params, name);
1786   for (i = 0; i < function->totparam; i++) {
1787     if (function->paramqual[i] != FUNCTION_QUAL_IN) {
1788       linkptr = va_arg(params, GPUNodeLink **);
1789       gpu_node_output(node, function->paramtype[i], linkptr);
1790     }
1791     else {
1792       link = va_arg(params, GPUNodeLink *);
1793       gpu_node_input_link(node, link, function->paramtype[i]);
1794     }
1795   }
1796   va_end(params);
1797
1798   gpu_material_add_node(mat, node);
1799
1800   return true;
1801 }
1802
1803 bool GPU_stack_link(GPUMaterial *material,
1804                     bNode *bnode,
1805                     const char *name,
1806                     GPUNodeStack *in,
1807                     GPUNodeStack *out,
1808                     ...)
1809 {
1810   GPUNode *node;
1811   GPUFunction *function;
1812   GPUNodeLink *link, **linkptr;
1813   va_list params;
1814   int i, totin, totout;
1815
1816   function = gpu_lookup_function(name);
1817   if (!function) {
1818     fprintf(stderr, "GPU failed to find function %s\n", name);
1819     return false;
1820   }
1821
1822   node = GPU_node_begin(name);
1823   totin = 0;
1824   totout = 0;
1825
1826   if (in) {
1827     for (i = 0; !in[i].end; i++) {
1828       if (in[i].type != GPU_NONE) {
1829         gpu_node_input_socket(material, bnode, node, &in[i], i);
1830         totin++;
1831       }
1832     }
1833   }
1834
1835   if (out) {
1836     for (i = 0; !out[i].end; i++) {
1837       if (out[i].type != GPU_NONE) {
1838         gpu_node_output(node, out[i].type, &out[i].link);
1839         totout++;
1840       }
1841     }
1842   }
1843
1844   va_start(params, out);
1845   for (i = 0; i < function->totparam; i++) {
1846     if (function->paramqual[i] != FUNCTION_QUAL_IN) {
1847       if (totout == 0) {
1848         linkptr = va_arg(params, GPUNodeLink **);
1849         gpu_node_output(node, function->paramtype[i], linkptr);
1850       }
1851       else {
1852         totout--;
1853       }
1854     }
1855     else {
1856       if (totin == 0) {
1857         link = va_arg(params, GPUNodeLink *);
1858         if (link->socket) {
1859           gpu_node_input_socket(NULL, NULL, node, link->socket, -1);
1860         }
1861         else {
1862           gpu_node_input_link(node, link, function->paramtype[i]);
1863         }
1864       }
1865       else {
1866         totin--;
1867       }
1868     }
1869   }
1870   va_end(params);
1871
1872   gpu_material_add_node(material, node);
1873
1874   return true;
1875 }
1876
1877 GPUNodeLink *GPU_uniformbuffer_link_out(GPUMaterial *mat,
1878                                         bNode *node,
1879                                         GPUNodeStack *stack,
1880                                         const int index)
1881 {
1882   return gpu_uniformbuffer_link(mat, node, stack, index, SOCK_OUT);
1883 }
1884
1885 /* Pass create/free */
1886
1887 static void gpu_nodes_tag(GPUNodeLink *link)
1888 {
1889   GPUNode *node;
1890   GPUInput *input;
1891
1892   if (!link->output) {
1893     return;
1894   }
1895
1896   node = link->output->node;
1897   if (node->tag) {
1898     return;
1899   }
1900
1901   node->tag = true;
1902   for (input = node->inputs.first; input; input = input->next) {
1903     if (input->link) {
1904       gpu_nodes_tag(input->link);
1905     }
1906   }
1907 }
1908
1909 void GPU_nodes_prune(ListBase *nodes, GPUNodeLink *outlink)
1910 {
1911   GPUNode *node, *next;
1912
1913   for (node = nodes->first; node; node = node->next) {
1914     node->tag = false;
1915   }
1916
1917   gpu_nodes_tag(outlink);
1918
1919   for (node = nodes->first; node; node = next) {
1920     next = node->next;
1921
1922     if (!node->tag) {
1923       BLI_remlink(nodes, node);
1924       gpu_node_free(node);
1925     }
1926   }
1927 }
1928
1929 static bool gpu_pass_is_valid(GPUPass *pass)
1930 {
1931   /* Shader is not null if compilation is successful. */
1932   return (pass->compiled == false || pass->shader != NULL);
1933 }
1934
1935 GPUPass *GPU_generate_pass(GPUMaterial *material,
1936                            GPUNodeLink *frag_outlink,
1937                            struct GPUVertAttrLayers *attrs,
1938                            ListBase *nodes,
1939                            int *builtins,
1940                            const char *vert_code,
1941                            const char *geom_code,
1942                            const char *frag_lib,
1943                            const char *defines)
1944 {
1945   char *vertexcode, *geometrycode, *fragmentcode;
1946   GPUPass *pass = NULL, *pass_hash = NULL;
1947
1948   /* prune unused nodes */
1949   GPU_nodes_prune(nodes, frag_outlink);
1950
1951   GPU_nodes_get_vertex_attrs(nodes, attrs);
1952
1953   /* generate code */
1954   char *fragmentgen = code_generate_fragment(material, nodes, frag_outlink->output, builtins);
1955
1956   /* Cache lookup: Reuse shaders already compiled */
1957   uint32_t hash = gpu_pass_hash(fragmentgen, defines, attrs);
1958   pass_hash = gpu_pass_cache_lookup(hash);
1959
1960   if (pass_hash && (pass_hash->next == NULL || pass_hash->next->hash != hash)) {
1961     /* No collision, just return the pass. */
1962     MEM_freeN(fragmentgen);
1963     if (!gpu_pass_is_valid(pass_hash)) {
1964       /* Shader has already been created but failed to compile. */
1965       return NULL;
1966     }
1967     pass_hash->refcount += 1;
1968     return pass_hash;
1969   }
1970
1971   /* Either the shader is not compiled or there is a hash collision...
1972    * continue generating the shader strings. */
1973   char *tmp = BLI_strdupcat(frag_lib, glsl_material_library);
1974
1975   geometrycode = code_generate_geometry(nodes, geom_code, defines);
1976   vertexcode = code_generate_vertex(nodes, vert_code, (geometrycode != NULL));
1977   fragmentcode = BLI_strdupcat(tmp, fragmentgen);
1978
1979   MEM_freeN(fragmentgen);
1980   MEM_freeN(tmp);
1981
1982   if (pass_hash) {
1983     /* Cache lookup: Reuse shaders already compiled */
1984     pass = gpu_pass_cache_resolve_collision(
1985         pass_hash, vertexcode, geometrycode, fragmentcode, defines, hash);
1986   }
1987
1988   if (pass) {
1989     /* Cache hit. Reuse the same GPUPass and GPUShader. */
1990     if (!gpu_pass_is_valid(pass)) {
1991       /* Shader has already been created but failed to compile. */
1992       return NULL;
1993     }
1994
1995     MEM_SAFE_FREE(vertexcode);
1996     MEM_SAFE_FREE(fragmentcode);
1997     MEM_SAFE_FREE(geometrycode);
1998
1999     pass->refcount += 1;
2000   }
2001   else {
2002     /* We still create a pass even if shader compilation
2003      * fails to avoid trying to compile again and again. */
2004     pass = MEM_callocN(sizeof(GPUPass), "GPUPass");
2005     pass->shader = NULL;
2006     pass->refcount = 1;
2007     pass->hash = hash;
2008     pass->vertexcode = vertexcode;
2009     pass->fragmentcode = fragmentcode;
2010     pass->geometrycode = geometrycode;
2011     pass->defines = (defines) ? BLI_strdup(defines) : NULL;
2012     pass->compiled = false;
2013
2014     BLI_spin_lock(&pass_cache_spin);
2015     if (pass_hash != NULL) {
2016       /* Add after the first pass having the same hash. */
2017       pass->next = pass_hash->next;
2018       pass_hash->next = pass;
2019     }
2020     else {
2021       /* No other pass have same hash, just prepend to the list. */
2022       BLI_LINKS_PREPEND(pass_cache, pass);
2023     }
2024     BLI_spin_unlock(&pass_cache_spin);
2025   }
2026
2027   return pass;
2028 }
2029
2030 static int count_active_texture_sampler(GPUShader *shader, char *source)
2031 {
2032   char *code = source;
2033   int samplers_id[64]; /* Remember this is per stage. */
2034   int sampler_len = 0;
2035
2036   while ((code = strstr(code, "uniform "))) {
2037     /* Move past "uniform". */
2038     code += 7;
2039     /* Skip following spaces. */
2040     while (*code == ' ') {
2041       code++;
2042     }
2043     /* Skip "i" from potential isamplers. */
2044     if (*code == 'i') {
2045       code++;
2046     }
2047     /* Skip following spaces. */
2048     if (gpu_str_prefix(code, "sampler")) {
2049       /* Move past "uniform". */
2050       code += 7;
2051       /* Skip sampler type suffix. */
2052       while (*code != ' ' && *code != '\0') {
2053         code++;
2054       }
2055       /* Skip following spaces. */
2056       while (*code == ' ') {
2057         code++;
2058       }
2059
2060       if (*code != '\0') {
2061         char sampler_name[64];
2062         code = gpu_str_skip_token(code, sampler_name, sizeof(sampler_name));
2063         int id = GPU_shader_get_uniform_ensure(shader, sampler_name);
2064
2065         if (id == -1) {
2066           continue;
2067         }
2068         /* Catch duplicates. */
2069         bool is_duplicate = false;
2070         for (int i = 0; i < sampler_len; ++i) {
2071           if (samplers_id[i] == id) {
2072             is_duplicate = true;
2073           }
2074         }
2075
2076         if (!is_duplicate) {
2077           samplers_id[sampler_len] = id;
2078           sampler_len++;
2079         }
2080       }
2081     }
2082   }
2083
2084   return sampler_len;
2085 }
2086
2087 static bool gpu_pass_shader_validate(GPUPass *pass)
2088 {
2089   if (pass->shader == NULL) {
2090     return false;
2091   }
2092
2093   /* NOTE: The only drawback of this method is that it will count a sampler
2094    * used in the fragment shader and only declared (but not used) in the vertex
2095    * shader as used by both. But this corner case is not happening for now. */
2096   int vert_samplers_len = count_active_texture_sampler(pass->shader, pass->vertexcode);
2097   int frag_samplers_len = count_active_texture_sampler(pass->shader, pass->fragmentcode);
2098
2099   int total_samplers_len = vert_samplers_len + frag_samplers_len;
2100
2101   /* Validate against opengl limit. */
2102   if ((frag_samplers_len > GPU_max_textures_frag()) ||
2103       (vert_samplers_len > GPU_max_textures_vert())) {
2104     return false;
2105   }
2106
2107   if (pass->geometrycode) {
2108     int geom_samplers_len = count_active_texture_sampler(pass->shader, pass->geometrycode);
2109     total_samplers_len += geom_samplers_len;
2110     if (geom_samplers_len > GPU_max_textures_geom()) {
2111       return false;
2112     }
2113   }
2114
2115   return (total_samplers_len <= GPU_max_textures());
2116 }
2117
2118 void GPU_pass_compile(GPUPass *pass, const char *shname)
2119 {
2120   if (!pass->compiled) {
2121     pass->shader = GPU_shader_create(
2122         pass->vertexcode, pass->fragmentcode, pass->geometrycode, NULL, pass->defines, shname);
2123
2124     /* NOTE: Some drivers / gpu allows more active samplers than the opengl limit.
2125      * We need to make sure to count active samplers to avoid undefined behavior. */
2126     if (!gpu_pass_shader_validate(pass)) {
2127       if (pass->shader != NULL) {
2128         fprintf(stderr, "GPUShader: error: too many samplers in shader.\n");
2129         GPU_shader_free(pass->shader);
2130       }
2131       pass->shader = NULL;
2132     }
2133     else if (!BLI_thread_is_main()) {
2134       /* For some Intel drivers, you must use the program at least once
2135        * in the rendering context that it is linked. */
2136       glUseProgram(GPU_shader_get_program(pass->shader));
2137       glUseProgram(0);
2138     }
2139
2140     pass->compiled = true;
2141   }
2142 }
2143
2144 void GPU_pass_release(GPUPass *pass)
2145 {
2146   BLI_assert(pass->refcount > 0);
2147   pass->refcount--;
2148 }
2149
2150 static void gpu_pass_free(GPUPass *pass)
2151 {
2152   BLI_assert(pass->refcount == 0);
2153   if (pass->shader) {
2154     GPU_shader_free(pass->shader);
2155   }
2156   MEM_SAFE_FREE(pass->fragmentcode);
2157   MEM_SAFE_FREE(pass->geometrycode);
2158   MEM_SAFE_FREE(pass->vertexcode);
2159   MEM_SAFE_FREE(pass->defines);
2160   MEM_freeN(pass);
2161 }
2162
2163 void GPU_pass_free_nodes(ListBase *nodes)
2164 {
2165   gpu_nodes_free(nodes);
2166 }
2167
2168 void GPU_pass_cache_garbage_collect(void)
2169 {
2170   static int lasttime = 0;
2171   const int shadercollectrate = 60; /* hardcoded for now. */
2172   int ctime = (int)PIL_check_seconds_timer();
2173
2174   if (ctime < shadercollectrate + lasttime) {
2175     return;
2176   }
2177
2178   lasttime = ctime;
2179
2180   BLI_spin_lock(&pass_cache_spin);
2181   GPUPass *next, **prev_pass = &pass_cache;
2182   for (GPUPass *pass = pass_cache; pass; pass = next) {
2183     next = pass->next;
2184     if (pass->refcount == 0) {
2185       /* Remove from list */
2186       *prev_pass = next;
2187       gpu_pass_free(pass);
2188     }
2189     else {
2190       prev_pass = &pass->next;
2191     }
2192   }
2193   BLI_spin_unlock(&pass_cache_spin);
2194 }
2195
2196 void GPU_pass_cache_init(void)
2197 {
2198   BLI_spin_init(&pass_cache_spin);
2199 }
2200
2201 void GPU_pass_cache_free(void)
2202 {
2203   BLI_spin_lock(&pass_cache_spin);
2204   while (pass_cache) {
2205     GPUPass *next = pass_cache->next;
2206     gpu_pass_free(pass_cache);
2207     pass_cache = next;
2208   }
2209   BLI_spin_unlock(&pass_cache_spin);
2210
2211   BLI_spin_end(&pass_cache_spin);
2212 }