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