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