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