Cleanup: DRW: Move ModelMatrix declaration to common_view_lib
[blender.git] / source / blender / gpu / shaders / gpu_shader_material.glsl
1
2 /* Converters */
3
4 float convert_rgba_to_float(vec4 color)
5 {
6   return dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
7 }
8
9 float exp_blender(float f)
10 {
11   return pow(2.71828182846, f);
12 }
13
14 float compatible_pow(float x, float y)
15 {
16   if (y == 0.0) /* x^0 -> 1, including 0^0 */
17     return 1.0;
18
19   /* glsl pow doesn't accept negative x */
20   if (x < 0.0) {
21     if (mod(-y, 2.0) == 0.0)
22       return pow(-x, y);
23     else
24       return -pow(-x, y);
25   }
26   else if (x == 0.0)
27     return 0.0;
28
29   return pow(x, y);
30 }
31
32 void rgb_to_hsv(vec4 rgb, out vec4 outcol)
33 {
34   float cmax, cmin, h, s, v, cdelta;
35   vec3 c;
36
37   cmax = max(rgb[0], max(rgb[1], rgb[2]));
38   cmin = min(rgb[0], min(rgb[1], rgb[2]));
39   cdelta = cmax - cmin;
40
41   v = cmax;
42   if (cmax != 0.0)
43     s = cdelta / cmax;
44   else {
45     s = 0.0;
46     h = 0.0;
47   }
48
49   if (s == 0.0) {
50     h = 0.0;
51   }
52   else {
53     c = (vec3(cmax) - rgb.xyz) / cdelta;
54
55     if (rgb.x == cmax)
56       h = c[2] - c[1];
57     else if (rgb.y == cmax)
58       h = 2.0 + c[0] - c[2];
59     else
60       h = 4.0 + c[1] - c[0];
61
62     h /= 6.0;
63
64     if (h < 0.0)
65       h += 1.0;
66   }
67
68   outcol = vec4(h, s, v, rgb.w);
69 }
70
71 void hsv_to_rgb(vec4 hsv, out vec4 outcol)
72 {
73   float i, f, p, q, t, h, s, v;
74   vec3 rgb;
75
76   h = hsv[0];
77   s = hsv[1];
78   v = hsv[2];
79
80   if (s == 0.0) {
81     rgb = vec3(v, v, v);
82   }
83   else {
84     if (h == 1.0)
85       h = 0.0;
86
87     h *= 6.0;
88     i = floor(h);
89     f = h - i;
90     rgb = vec3(f, f, f);
91     p = v * (1.0 - s);
92     q = v * (1.0 - (s * f));
93     t = v * (1.0 - (s * (1.0 - f)));
94
95     if (i == 0.0)
96       rgb = vec3(v, t, p);
97     else if (i == 1.0)
98       rgb = vec3(q, v, p);
99     else if (i == 2.0)
100       rgb = vec3(p, v, t);
101     else if (i == 3.0)
102       rgb = vec3(p, q, v);
103     else if (i == 4.0)
104       rgb = vec3(t, p, v);
105     else
106       rgb = vec3(v, p, q);
107   }
108
109   outcol = vec4(rgb, hsv.w);
110 }
111
112 void color_to_normal_new_shading(vec3 color, out vec3 normal)
113 {
114   normal = vec3(2.0) * color - vec3(1.0);
115 }
116
117 void color_to_blender_normal_new_shading(vec3 color, out vec3 normal)
118 {
119   normal = vec3(2.0, -2.0, -2.0) * color - vec3(1.0);
120 }
121
122 #ifndef M_PI
123 #  define M_PI 3.14159265358979323846
124 #endif
125 #ifndef M_1_PI
126 #  define M_1_PI 0.318309886183790671538
127 #endif
128
129 /*********** SHADER NODES ***************/
130
131 void particle_info(vec4 sprops,
132                    vec4 loc,
133                    vec3 vel,
134                    vec3 avel,
135                    out float index,
136                    out float random,
137                    out float age,
138                    out float life_time,
139                    out vec3 location,
140                    out float size,
141                    out vec3 velocity,
142                    out vec3 angular_velocity)
143 {
144   index = sprops.x;
145   random = loc.w;
146   age = sprops.y;
147   life_time = sprops.z;
148   size = sprops.w;
149
150   location = loc.xyz;
151   velocity = vel;
152   angular_velocity = avel;
153 }
154
155 void vect_normalize(vec3 vin, out vec3 vout)
156 {
157   vout = normalize(vin);
158 }
159
160 void direction_transform_m4v3(vec3 vin, mat4 mat, out vec3 vout)
161 {
162   vout = (mat * vec4(vin, 0.0)).xyz;
163 }
164
165 void normal_transform_transposed_m4v3(vec3 vin, mat4 mat, out vec3 vout)
166 {
167   vout = transpose(mat3(mat)) * vin;
168 }
169
170 void point_transform_m4v3(vec3 vin, mat4 mat, out vec3 vout)
171 {
172   vout = (mat * vec4(vin, 1.0)).xyz;
173 }
174
175 void point_texco_remap_square(vec3 vin, out vec3 vout)
176 {
177   vout = vin * 2.0 - 1.0;
178 }
179
180 void point_texco_clamp(vec3 vin, sampler2D ima, out vec3 vout)
181 {
182   vec2 half_texel_size = 0.5 / vec2(textureSize(ima, 0).xy);
183   vout = clamp(vin, half_texel_size.xyy, 1.0 - half_texel_size.xyy);
184 }
185
186 void point_map_to_sphere(vec3 vin, out vec3 vout)
187 {
188   float len = length(vin);
189   float v, u;
190   if (len > 0.0) {
191     if (vin.x == 0.0 && vin.y == 0.0)
192       u = 0.0;
193     else
194       u = (1.0 - atan(vin.x, vin.y) / M_PI) / 2.0;
195
196     v = 1.0 - acos(vin.z / len) / M_PI;
197   }
198   else
199     v = u = 0.0;
200
201   vout = vec3(u, v, 0.0);
202 }
203
204 void point_map_to_tube(vec3 vin, out vec3 vout)
205 {
206   float u, v;
207   v = (vin.z + 1.0) * 0.5;
208   float len = sqrt(vin.x * vin.x + vin.y * vin[1]);
209   if (len > 0.0)
210     u = (1.0 - (atan(vin.x / len, vin.y / len) / M_PI)) * 0.5;
211   else
212     v = u = 0.0;
213
214   vout = vec3(u, v, 0.0);
215 }
216
217 void mapping(
218     vec3 vec, vec4 m0, vec4 m1, vec4 m2, vec4 m3, vec3 minvec, vec3 maxvec, out vec3 outvec)
219 {
220   mat4 mat = mat4(m0, m1, m2, m3);
221   outvec = (mat * vec4(vec, 1.0)).xyz;
222   outvec = clamp(outvec, minvec, maxvec);
223 }
224
225 void camera(vec3 co, out vec3 outview, out float outdepth, out float outdist)
226 {
227   outdepth = abs(co.z);
228   outdist = length(co);
229   outview = normalize(co);
230 }
231
232 void math_add(float val1, float val2, out float outval)
233 {
234   outval = val1 + val2;
235 }
236
237 void math_subtract(float val1, float val2, out float outval)
238 {
239   outval = val1 - val2;
240 }
241
242 void math_multiply(float val1, float val2, out float outval)
243 {
244   outval = val1 * val2;
245 }
246
247 void math_divide(float val1, float val2, out float outval)
248 {
249   if (val2 == 0.0)
250     outval = 0.0;
251   else
252     outval = val1 / val2;
253 }
254
255 void math_sine(float val, out float outval)
256 {
257   outval = sin(val);
258 }
259
260 void math_cosine(float val, out float outval)
261 {
262   outval = cos(val);
263 }
264
265 void math_tangent(float val, out float outval)
266 {
267   outval = tan(val);
268 }
269
270 void math_asin(float val, out float outval)
271 {
272   if (val <= 1.0 && val >= -1.0)
273     outval = asin(val);
274   else
275     outval = 0.0;
276 }
277
278 void math_acos(float val, out float outval)
279 {
280   if (val <= 1.0 && val >= -1.0)
281     outval = acos(val);
282   else
283     outval = 0.0;
284 }
285
286 void math_atan(float val, out float outval)
287 {
288   outval = atan(val);
289 }
290
291 void math_pow(float val1, float val2, out float outval)
292 {
293   if (val1 >= 0.0) {
294     outval = compatible_pow(val1, val2);
295   }
296   else {
297     float val2_mod_1 = mod(abs(val2), 1.0);
298
299     if (val2_mod_1 > 0.999 || val2_mod_1 < 0.001)
300       outval = compatible_pow(val1, floor(val2 + 0.5));
301     else
302       outval = 0.0;
303   }
304 }
305
306 void math_log(float val1, float val2, out float outval)
307 {
308   if (val1 > 0.0 && val2 > 0.0)
309     outval = log2(val1) / log2(val2);
310   else
311     outval = 0.0;
312 }
313
314 void math_max(float val1, float val2, out float outval)
315 {
316   outval = max(val1, val2);
317 }
318
319 void math_min(float val1, float val2, out float outval)
320 {
321   outval = min(val1, val2);
322 }
323
324 void math_round(float val, out float outval)
325 {
326   outval = floor(val + 0.5);
327 }
328
329 void math_less_than(float val1, float val2, out float outval)
330 {
331   if (val1 < val2)
332     outval = 1.0;
333   else
334     outval = 0.0;
335 }
336
337 void math_greater_than(float val1, float val2, out float outval)
338 {
339   if (val1 > val2)
340     outval = 1.0;
341   else
342     outval = 0.0;
343 }
344
345 void math_modulo(float val1, float val2, out float outval)
346 {
347   if (val2 == 0.0)
348     outval = 0.0;
349   else
350     outval = mod(val1, val2);
351
352   /* change sign to match C convention, mod in GLSL will take absolute for negative numbers,
353    * see https://www.opengl.org/sdk/docs/man/html/mod.xhtml */
354   outval = (val1 > 0.0) ? outval : outval - val2;
355 }
356
357 void math_abs(float val1, out float outval)
358 {
359   outval = abs(val1);
360 }
361
362 void math_atan2(float val1, float val2, out float outval)
363 {
364   outval = atan(val1, val2);
365 }
366
367 void math_floor(float val, out float outval)
368 {
369   outval = floor(val);
370 }
371
372 void math_ceil(float val, out float outval)
373 {
374   outval = ceil(val);
375 }
376
377 void math_fract(float val, out float outval)
378 {
379   outval = val - floor(val);
380 }
381
382 void math_sqrt(float val, out float outval)
383 {
384   if (val > 0.0)
385     outval = sqrt(val);
386   else
387     outval = 0.0;
388 }
389
390 void squeeze(float val, float width, float center, out float outval)
391 {
392   outval = 1.0 / (1.0 + pow(2.71828183, -((val - center) * width)));
393 }
394
395 void vec_math_add(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
396 {
397   outvec = v1 + v2;
398   outval = (abs(outvec[0]) + abs(outvec[1]) + abs(outvec[2])) * 0.333333;
399 }
400
401 void vec_math_sub(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
402 {
403   outvec = v1 - v2;
404   outval = (abs(outvec[0]) + abs(outvec[1]) + abs(outvec[2])) * 0.333333;
405 }
406
407 void vec_math_average(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
408 {
409   outvec = v1 + v2;
410   outval = length(outvec);
411   outvec = normalize(outvec);
412 }
413 void vec_math_mix(float strength, vec3 v1, vec3 v2, out vec3 outvec)
414 {
415   outvec = strength * v1 + (1 - strength) * v2;
416 }
417
418 void vec_math_dot(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
419 {
420   outvec = vec3(0);
421   outval = dot(v1, v2);
422 }
423
424 void vec_math_cross(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
425 {
426   outvec = cross(v1, v2);
427   outval = length(outvec);
428   outvec /= outval;
429 }
430
431 void vec_math_normalize(vec3 v, out vec3 outvec, out float outval)
432 {
433   outval = length(v);
434   outvec = normalize(v);
435 }
436
437 void vec_math_negate(vec3 v, out vec3 outv)
438 {
439   outv = -v;
440 }
441
442 void invert_z(vec3 v, out vec3 outv)
443 {
444   v.z = -v.z;
445   outv = v;
446 }
447
448 void normal_new_shading(vec3 nor, vec3 dir, out vec3 outnor, out float outdot)
449 {
450   outnor = dir;
451   outdot = dot(normalize(nor), dir);
452 }
453
454 void curves_vec(float fac, vec3 vec, sampler1DArray curvemap, float layer, out vec3 outvec)
455 {
456   vec4 co = vec4(vec * 0.5 + 0.5, layer);
457   outvec.x = texture(curvemap, co.xw).x;
458   outvec.y = texture(curvemap, co.yw).y;
459   outvec.z = texture(curvemap, co.zw).z;
460   outvec = mix(vec, outvec, fac);
461 }
462
463 /* ext is vec4(in_x, in_dy, out_x, out_dy). */
464 float curve_extrapolate(float x, float y, vec4 ext)
465 {
466   if (x < 0.0) {
467     return y + x * ext.y;
468   }
469   else if (x > 1.0) {
470     return y + (x - 1.0) * ext.w;
471   }
472   else {
473     return y;
474   }
475 }
476
477 #define RANGE_RESCALE(x, min, range) ((x - min) * range)
478
479 void curves_rgb(float fac,
480                 vec4 col,
481                 sampler1DArray curvemap,
482                 float layer,
483                 vec4 range,
484                 vec4 ext_r,
485                 vec4 ext_g,
486                 vec4 ext_b,
487                 vec4 ext_a,
488                 out vec4 outcol)
489 {
490   vec4 co = vec4(RANGE_RESCALE(col.rgb, ext_a.x, range.a), layer);
491   vec3 samp;
492   samp.r = texture(curvemap, co.xw).a;
493   samp.g = texture(curvemap, co.yw).a;
494   samp.b = texture(curvemap, co.zw).a;
495
496   samp.r = curve_extrapolate(co.x, samp.r, ext_a);
497   samp.g = curve_extrapolate(co.y, samp.g, ext_a);
498   samp.b = curve_extrapolate(co.z, samp.b, ext_a);
499
500   vec3 rgb_min = vec3(ext_r.x, ext_g.x, ext_b.x);
501   co.xyz = RANGE_RESCALE(samp.rgb, rgb_min, range.rgb);
502
503   samp.r = texture(curvemap, co.xw).r;
504   samp.g = texture(curvemap, co.yw).g;
505   samp.b = texture(curvemap, co.zw).b;
506
507   outcol.r = curve_extrapolate(co.x, samp.r, ext_r);
508   outcol.g = curve_extrapolate(co.y, samp.g, ext_g);
509   outcol.b = curve_extrapolate(co.z, samp.b, ext_b);
510   outcol.a = col.a;
511
512   outcol = mix(col, outcol, fac);
513 }
514
515 void curves_rgb_opti(float fac,
516                      vec4 col,
517                      sampler1DArray curvemap,
518                      float layer,
519                      vec4 range,
520                      vec4 ext_a,
521                      out vec4 outcol)
522 {
523   vec4 co = vec4(RANGE_RESCALE(col.rgb, ext_a.x, range.a), layer);
524   vec3 samp;
525   samp.r = texture(curvemap, co.xw).a;
526   samp.g = texture(curvemap, co.yw).a;
527   samp.b = texture(curvemap, co.zw).a;
528
529   outcol.r = curve_extrapolate(co.x, samp.r, ext_a);
530   outcol.g = curve_extrapolate(co.y, samp.g, ext_a);
531   outcol.b = curve_extrapolate(co.z, samp.b, ext_a);
532   outcol.a = col.a;
533
534   outcol = mix(col, outcol, fac);
535 }
536
537 void set_value(float val, out float outval)
538 {
539   outval = val;
540 }
541
542 void set_rgb(vec3 col, out vec3 outcol)
543 {
544   outcol = col;
545 }
546
547 void set_rgba(vec4 col, out vec4 outcol)
548 {
549   outcol = col;
550 }
551
552 void set_value_zero(out float outval)
553 {
554   outval = 0.0;
555 }
556
557 void set_value_one(out float outval)
558 {
559   outval = 1.0;
560 }
561
562 void set_rgb_zero(out vec3 outval)
563 {
564   outval = vec3(0.0);
565 }
566
567 void set_rgb_one(out vec3 outval)
568 {
569   outval = vec3(1.0);
570 }
571
572 void set_rgba_zero(out vec4 outval)
573 {
574   outval = vec4(0.0);
575 }
576
577 void set_rgba_one(out vec4 outval)
578 {
579   outval = vec4(1.0);
580 }
581
582 void brightness_contrast(vec4 col, float brightness, float contrast, out vec4 outcol)
583 {
584   float a = 1.0 + contrast;
585   float b = brightness - contrast * 0.5;
586
587   outcol.r = max(a * col.r + b, 0.0);
588   outcol.g = max(a * col.g + b, 0.0);
589   outcol.b = max(a * col.b + b, 0.0);
590   outcol.a = col.a;
591 }
592
593 void mix_blend(float fac, vec4 col1, vec4 col2, out vec4 outcol)
594 {
595   fac = clamp(fac, 0.0, 1.0);
596   outcol = mix(col1, col2, fac);
597   outcol.a = col1.a;
598 }
599
600 void mix_add(float fac, vec4 col1, vec4 col2, out vec4 outcol)
601 {
602   fac = clamp(fac, 0.0, 1.0);
603   outcol = mix(col1, col1 + col2, fac);
604   outcol.a = col1.a;
605 }
606
607 void mix_mult(float fac, vec4 col1, vec4 col2, out vec4 outcol)
608 {
609   fac = clamp(fac, 0.0, 1.0);
610   outcol = mix(col1, col1 * col2, fac);
611   outcol.a = col1.a;
612 }
613
614 void mix_screen(float fac, vec4 col1, vec4 col2, out vec4 outcol)
615 {
616   fac = clamp(fac, 0.0, 1.0);
617   float facm = 1.0 - fac;
618
619   outcol = vec4(1.0) - (vec4(facm) + fac * (vec4(1.0) - col2)) * (vec4(1.0) - col1);
620   outcol.a = col1.a;
621 }
622
623 void mix_overlay(float fac, vec4 col1, vec4 col2, out vec4 outcol)
624 {
625   fac = clamp(fac, 0.0, 1.0);
626   float facm = 1.0 - fac;
627
628   outcol = col1;
629
630   if (outcol.r < 0.5)
631     outcol.r *= facm + 2.0 * fac * col2.r;
632   else
633     outcol.r = 1.0 - (facm + 2.0 * fac * (1.0 - col2.r)) * (1.0 - outcol.r);
634
635   if (outcol.g < 0.5)
636     outcol.g *= facm + 2.0 * fac * col2.g;
637   else
638     outcol.g = 1.0 - (facm + 2.0 * fac * (1.0 - col2.g)) * (1.0 - outcol.g);
639
640   if (outcol.b < 0.5)
641     outcol.b *= facm + 2.0 * fac * col2.b;
642   else
643     outcol.b = 1.0 - (facm + 2.0 * fac * (1.0 - col2.b)) * (1.0 - outcol.b);
644 }
645
646 void mix_sub(float fac, vec4 col1, vec4 col2, out vec4 outcol)
647 {
648   fac = clamp(fac, 0.0, 1.0);
649   outcol = mix(col1, col1 - col2, fac);
650   outcol.a = col1.a;
651 }
652
653 void mix_div(float fac, vec4 col1, vec4 col2, out vec4 outcol)
654 {
655   fac = clamp(fac, 0.0, 1.0);
656   float facm = 1.0 - fac;
657
658   outcol = col1;
659
660   if (col2.r != 0.0)
661     outcol.r = facm * outcol.r + fac * outcol.r / col2.r;
662   if (col2.g != 0.0)
663     outcol.g = facm * outcol.g + fac * outcol.g / col2.g;
664   if (col2.b != 0.0)
665     outcol.b = facm * outcol.b + fac * outcol.b / col2.b;
666 }
667
668 void mix_diff(float fac, vec4 col1, vec4 col2, out vec4 outcol)
669 {
670   fac = clamp(fac, 0.0, 1.0);
671   outcol = mix(col1, abs(col1 - col2), fac);
672   outcol.a = col1.a;
673 }
674
675 void mix_dark(float fac, vec4 col1, vec4 col2, out vec4 outcol)
676 {
677   fac = clamp(fac, 0.0, 1.0);
678   outcol.rgb = min(col1.rgb, col2.rgb * fac);
679   outcol.a = col1.a;
680 }
681
682 void mix_light(float fac, vec4 col1, vec4 col2, out vec4 outcol)
683 {
684   fac = clamp(fac, 0.0, 1.0);
685   outcol.rgb = max(col1.rgb, col2.rgb * fac);
686   outcol.a = col1.a;
687 }
688
689 void mix_dodge(float fac, vec4 col1, vec4 col2, out vec4 outcol)
690 {
691   fac = clamp(fac, 0.0, 1.0);
692   outcol = col1;
693
694   if (outcol.r != 0.0) {
695     float tmp = 1.0 - fac * col2.r;
696     if (tmp <= 0.0)
697       outcol.r = 1.0;
698     else if ((tmp = outcol.r / tmp) > 1.0)
699       outcol.r = 1.0;
700     else
701       outcol.r = tmp;
702   }
703   if (outcol.g != 0.0) {
704     float tmp = 1.0 - fac * col2.g;
705     if (tmp <= 0.0)
706       outcol.g = 1.0;
707     else if ((tmp = outcol.g / tmp) > 1.0)
708       outcol.g = 1.0;
709     else
710       outcol.g = tmp;
711   }
712   if (outcol.b != 0.0) {
713     float tmp = 1.0 - fac * col2.b;
714     if (tmp <= 0.0)
715       outcol.b = 1.0;
716     else if ((tmp = outcol.b / tmp) > 1.0)
717       outcol.b = 1.0;
718     else
719       outcol.b = tmp;
720   }
721 }
722
723 void mix_burn(float fac, vec4 col1, vec4 col2, out vec4 outcol)
724 {
725   fac = clamp(fac, 0.0, 1.0);
726   float tmp, facm = 1.0 - fac;
727
728   outcol = col1;
729
730   tmp = facm + fac * col2.r;
731   if (tmp <= 0.0)
732     outcol.r = 0.0;
733   else if ((tmp = (1.0 - (1.0 - outcol.r) / tmp)) < 0.0)
734     outcol.r = 0.0;
735   else if (tmp > 1.0)
736     outcol.r = 1.0;
737   else
738     outcol.r = tmp;
739
740   tmp = facm + fac * col2.g;
741   if (tmp <= 0.0)
742     outcol.g = 0.0;
743   else if ((tmp = (1.0 - (1.0 - outcol.g) / tmp)) < 0.0)
744     outcol.g = 0.0;
745   else if (tmp > 1.0)
746     outcol.g = 1.0;
747   else
748     outcol.g = tmp;
749
750   tmp = facm + fac * col2.b;
751   if (tmp <= 0.0)
752     outcol.b = 0.0;
753   else if ((tmp = (1.0 - (1.0 - outcol.b) / tmp)) < 0.0)
754     outcol.b = 0.0;
755   else if (tmp > 1.0)
756     outcol.b = 1.0;
757   else
758     outcol.b = tmp;
759 }
760
761 void mix_hue(float fac, vec4 col1, vec4 col2, out vec4 outcol)
762 {
763   fac = clamp(fac, 0.0, 1.0);
764   float facm = 1.0 - fac;
765
766   outcol = col1;
767
768   vec4 hsv, hsv2, tmp;
769   rgb_to_hsv(col2, hsv2);
770
771   if (hsv2.y != 0.0) {
772     rgb_to_hsv(outcol, hsv);
773     hsv.x = hsv2.x;
774     hsv_to_rgb(hsv, tmp);
775
776     outcol = mix(outcol, tmp, fac);
777     outcol.a = col1.a;
778   }
779 }
780
781 void mix_sat(float fac, vec4 col1, vec4 col2, out vec4 outcol)
782 {
783   fac = clamp(fac, 0.0, 1.0);
784   float facm = 1.0 - fac;
785
786   outcol = col1;
787
788   vec4 hsv, hsv2;
789   rgb_to_hsv(outcol, hsv);
790
791   if (hsv.y != 0.0) {
792     rgb_to_hsv(col2, hsv2);
793
794     hsv.y = facm * hsv.y + fac * hsv2.y;
795     hsv_to_rgb(hsv, outcol);
796   }
797 }
798
799 void mix_val(float fac, vec4 col1, vec4 col2, out vec4 outcol)
800 {
801   fac = clamp(fac, 0.0, 1.0);
802   float facm = 1.0 - fac;
803
804   vec4 hsv, hsv2;
805   rgb_to_hsv(col1, hsv);
806   rgb_to_hsv(col2, hsv2);
807
808   hsv.z = facm * hsv.z + fac * hsv2.z;
809   hsv_to_rgb(hsv, outcol);
810 }
811
812 void mix_color(float fac, vec4 col1, vec4 col2, out vec4 outcol)
813 {
814   fac = clamp(fac, 0.0, 1.0);
815   float facm = 1.0 - fac;
816
817   outcol = col1;
818
819   vec4 hsv, hsv2, tmp;
820   rgb_to_hsv(col2, hsv2);
821
822   if (hsv2.y != 0.0) {
823     rgb_to_hsv(outcol, hsv);
824     hsv.x = hsv2.x;
825     hsv.y = hsv2.y;
826     hsv_to_rgb(hsv, tmp);
827
828     outcol = mix(outcol, tmp, fac);
829     outcol.a = col1.a;
830   }
831 }
832
833 void mix_soft(float fac, vec4 col1, vec4 col2, out vec4 outcol)
834 {
835   fac = clamp(fac, 0.0, 1.0);
836   float facm = 1.0 - fac;
837
838   vec4 one = vec4(1.0);
839   vec4 scr = one - (one - col2) * (one - col1);
840   outcol = facm * col1 + fac * ((one - col1) * col2 * col1 + col1 * scr);
841 }
842
843 void mix_linear(float fac, vec4 col1, vec4 col2, out vec4 outcol)
844 {
845   fac = clamp(fac, 0.0, 1.0);
846
847   outcol = col1 + fac * (2.0 * (col2 - vec4(0.5)));
848 }
849
850 void valtorgb_opti_constant(
851     float fac, float edge, vec4 color1, vec4 color2, out vec4 outcol, out float outalpha)
852 {
853   outcol = (fac > edge) ? color2 : color1;
854   outalpha = outcol.a;
855 }
856
857 void valtorgb_opti_linear(
858     float fac, vec2 mulbias, vec4 color1, vec4 color2, out vec4 outcol, out float outalpha)
859 {
860   fac = clamp(fac * mulbias.x + mulbias.y, 0.0, 1.0);
861   outcol = mix(color1, color2, fac);
862   outalpha = outcol.a;
863 }
864
865 void valtorgb(float fac, sampler1DArray colormap, float layer, out vec4 outcol, out float outalpha)
866 {
867   outcol = texture(colormap, vec2(fac, layer));
868   outalpha = outcol.a;
869 }
870
871 void valtorgb_nearest(
872     float fac, sampler1DArray colormap, float layer, out vec4 outcol, out float outalpha)
873 {
874   fac = clamp(fac, 0.0, 1.0);
875   outcol = texelFetch(colormap, ivec2(fac * (textureSize(colormap, 0).x - 1), layer), 0);
876   outalpha = outcol.a;
877 }
878
879 void rgbtobw(vec4 color, out float outval)
880 {
881   vec3 factors = vec3(0.2126, 0.7152, 0.0722);
882   outval = dot(color.rgb, factors);
883 }
884
885 void invert(float fac, vec4 col, out vec4 outcol)
886 {
887   outcol.xyz = mix(col.xyz, vec3(1.0) - col.xyz, fac);
888   outcol.w = col.w;
889 }
890
891 void clamp_vec3(vec3 vec, vec3 min, vec3 max, out vec3 out_vec)
892 {
893   out_vec = clamp(vec, min, max);
894 }
895
896 void clamp_val(float value, float min, float max, out float out_value)
897 {
898   out_value = clamp(value, min, max);
899 }
900
901 void hue_sat(float hue, float sat, float value, float fac, vec4 col, out vec4 outcol)
902 {
903   vec4 hsv;
904
905   rgb_to_hsv(col, hsv);
906
907   hsv[0] = fract(hsv[0] + hue + 0.5);
908   hsv[1] = clamp(hsv[1] * sat, 0.0, 1.0);
909   hsv[2] = hsv[2] * value;
910
911   hsv_to_rgb(hsv, outcol);
912
913   outcol = mix(col, outcol, fac);
914 }
915
916 void separate_rgb(vec4 col, out float r, out float g, out float b)
917 {
918   r = col.r;
919   g = col.g;
920   b = col.b;
921 }
922
923 void combine_rgb(float r, float g, float b, out vec4 col)
924 {
925   col = vec4(r, g, b, 1.0);
926 }
927
928 void separate_xyz(vec3 vec, out float x, out float y, out float z)
929 {
930   x = vec.r;
931   y = vec.g;
932   z = vec.b;
933 }
934
935 void combine_xyz(float x, float y, float z, out vec3 vec)
936 {
937   vec = vec3(x, y, z);
938 }
939
940 void separate_hsv(vec4 col, out float h, out float s, out float v)
941 {
942   vec4 hsv;
943
944   rgb_to_hsv(col, hsv);
945   h = hsv[0];
946   s = hsv[1];
947   v = hsv[2];
948 }
949
950 void combine_hsv(float h, float s, float v, out vec4 col)
951 {
952   hsv_to_rgb(vec4(h, s, v, 1.0), col);
953 }
954
955 void output_node(vec4 rgb, float alpha, out vec4 outrgb)
956 {
957   outrgb = vec4(rgb.rgb, alpha);
958 }
959
960 /*********** TEXTURES ***************/
961
962 void texco_norm(vec3 normal, out vec3 outnormal)
963 {
964   /* corresponds to shi->orn, which is negated so cancels
965      out blender normal negation */
966   outnormal = normalize(normal);
967 }
968
969 vec3 mtex_2d_mapping(vec3 vec)
970 {
971   return vec3(vec.xy * 0.5 + vec2(0.5), vec.z);
972 }
973
974 /** helper method to extract the upper left 3x3 matrix from a 4x4 matrix */
975 mat3 to_mat3(mat4 m4)
976 {
977   mat3 m3;
978   m3[0] = m4[0].xyz;
979   m3[1] = m4[1].xyz;
980   m3[2] = m4[2].xyz;
981   return m3;
982 }
983
984 /*********** NEW SHADER UTILITIES **************/
985
986 float fresnel_dielectric_0(float eta)
987 {
988   /* compute fresnel reflactance at normal incidence => cosi = 1.0 */
989   float A = (eta - 1.0) / (eta + 1.0);
990
991   return A * A;
992 }
993
994 float fresnel_dielectric_cos(float cosi, float eta)
995 {
996   /* compute fresnel reflectance without explicitly computing
997    * the refracted direction */
998   float c = abs(cosi);
999   float g = eta * eta - 1.0 + c * c;
1000   float result;
1001
1002   if (g > 0.0) {
1003     g = sqrt(g);
1004     float A = (g - c) / (g + c);
1005     float B = (c * (g + c) - 1.0) / (c * (g - c) + 1.0);
1006     result = 0.5 * A * A * (1.0 + B * B);
1007   }
1008   else {
1009     result = 1.0; /* TIR (no refracted component) */
1010   }
1011
1012   return result;
1013 }
1014
1015 float fresnel_dielectric(vec3 Incoming, vec3 Normal, float eta)
1016 {
1017   /* compute fresnel reflectance without explicitly computing
1018    * the refracted direction */
1019   return fresnel_dielectric_cos(dot(Incoming, Normal), eta);
1020 }
1021
1022 float hypot(float x, float y)
1023 {
1024   return sqrt(x * x + y * y);
1025 }
1026
1027 void generated_from_orco(vec3 orco, out vec3 generated)
1028 {
1029 #ifdef VOLUMETRICS
1030 #  ifdef MESH_SHADER
1031   generated = volumeObjectLocalCoord;
1032 #  else
1033   generated = worldPosition;
1034 #  endif
1035 #else
1036   generated = orco;
1037 #endif
1038 }
1039
1040 int floor_to_int(float x)
1041 {
1042   return int(floor(x));
1043 }
1044
1045 int quick_floor(float x)
1046 {
1047   return int(x) - ((x < 0) ? 1 : 0);
1048 }
1049
1050 float integer_noise(int n)
1051 {
1052   int nn;
1053   n = (n + 1013) & 0x7fffffff;
1054   n = (n >> 13) ^ n;
1055   nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
1056   return 0.5 * (float(nn) / 1073741824.0);
1057 }
1058
1059 uint hash(uint kx, uint ky, uint kz)
1060 {
1061 #define rot(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
1062 #define final(a, b, c) \
1063   { \
1064     c ^= b; \
1065     c -= rot(b, 14); \
1066     a ^= c; \
1067     a -= rot(c, 11); \
1068     b ^= a; \
1069     b -= rot(a, 25); \
1070     c ^= b; \
1071     c -= rot(b, 16); \
1072     a ^= c; \
1073     a -= rot(c, 4); \
1074     b ^= a; \
1075     b -= rot(a, 14); \
1076     c ^= b; \
1077     c -= rot(b, 24); \
1078   }
1079   // now hash the data!
1080   uint a, b, c, len = 3u;
1081   a = b = c = 0xdeadbeefu + (len << 2u) + 13u;
1082
1083   c += kz;
1084   b += ky;
1085   a += kx;
1086   final(a, b, c);
1087
1088   return c;
1089 #undef rot
1090 #undef final
1091 }
1092
1093 uint hash(int kx, int ky, int kz)
1094 {
1095   return hash(uint(kx), uint(ky), uint(kz));
1096 }
1097
1098 float bits_to_01(uint bits)
1099 {
1100   return (float(bits) / 4294967295.0);
1101 }
1102
1103 float cellnoise(vec3 p)
1104 {
1105   int ix = quick_floor(p.x);
1106   int iy = quick_floor(p.y);
1107   int iz = quick_floor(p.z);
1108
1109   return bits_to_01(hash(uint(ix), uint(iy), uint(iz)));
1110 }
1111
1112 vec3 cellnoise_color(vec3 p)
1113 {
1114   float r = cellnoise(p.xyz);
1115   float g = cellnoise(p.yxz);
1116   float b = cellnoise(p.yzx);
1117
1118   return vec3(r, g, b);
1119 }
1120
1121 float floorfrac(float x, out int i)
1122 {
1123   float x_floor = floor(x);
1124   i = int(x_floor);
1125   return x - x_floor;
1126 }
1127
1128 /* bsdfs */
1129
1130 vec3 tint_from_color(vec3 color)
1131 {
1132   float lum = dot(color, vec3(0.3, 0.6, 0.1)); /* luminance approx. */
1133   return (lum > 0) ? color / lum : vec3(1.0);  /* normalize lum. to isolate hue+sat */
1134 }
1135
1136 void convert_metallic_to_specular_tinted(vec3 basecol,
1137                                          vec3 basecol_tint,
1138                                          float metallic,
1139                                          float specular_fac,
1140                                          float specular_tint,
1141                                          out vec3 diffuse,
1142                                          out vec3 f0)
1143 {
1144   vec3 tmp_col = mix(vec3(1.0), basecol_tint, specular_tint);
1145   f0 = mix((0.08 * specular_fac) * tmp_col, basecol, metallic);
1146   diffuse = basecol * (1.0 - metallic);
1147 }
1148
1149 vec3 principled_sheen(float NV, vec3 basecol_tint, float sheen_tint)
1150 {
1151   float f = 1.0 - NV;
1152   /* Temporary fix for T59784. Normal map seems to contain NaNs for tangent space normal maps,
1153    * therefore we need to clamp value. */
1154   f = clamp(f, 0.0, 1.0);
1155   /* Empirical approximation (manual curve fitting). Can be refined. */
1156   float sheen = f * f * f * 0.077 + f * 0.01 + 0.00026;
1157   return sheen * mix(vec3(1.0), basecol_tint, sheen_tint);
1158 }
1159
1160 #ifndef VOLUMETRICS
1161 void node_bsdf_diffuse(vec4 color, float roughness, vec3 N, out Closure result)
1162 {
1163   N = normalize(N);
1164   vec3 vN = mat3(ViewMatrix) * N;
1165   result = CLOSURE_DEFAULT;
1166   result.ssr_normal = normal_encode(vN, viewCameraVec);
1167   eevee_closure_diffuse(N, color.rgb, 1.0, result.radiance);
1168   result.radiance *= color.rgb;
1169 }
1170
1171 void node_bsdf_glossy(vec4 color, float roughness, vec3 N, float ssr_id, out Closure result)
1172 {
1173   N = normalize(N);
1174   vec3 out_spec, ssr_spec;
1175   eevee_closure_glossy(N, vec3(1.0), int(ssr_id), roughness, 1.0, out_spec, ssr_spec);
1176   vec3 vN = mat3(ViewMatrix) * N;
1177   result = CLOSURE_DEFAULT;
1178   result.radiance = out_spec * color.rgb;
1179   result.ssr_data = vec4(ssr_spec * color.rgb, roughness);
1180   result.ssr_normal = normal_encode(vN, viewCameraVec);
1181   result.ssr_id = int(ssr_id);
1182 }
1183
1184 void node_bsdf_anisotropic(vec4 color,
1185                            float roughness,
1186                            float anisotropy,
1187                            float rotation,
1188                            vec3 N,
1189                            vec3 T,
1190                            out Closure result)
1191 {
1192   node_bsdf_glossy(color, roughness, N, -1, result);
1193 }
1194
1195 void node_bsdf_glass(
1196     vec4 color, float roughness, float ior, vec3 N, float ssr_id, out Closure result)
1197 {
1198   N = normalize(N);
1199   vec3 out_spec, out_refr, ssr_spec;
1200   vec3 refr_color = (refractionDepth > 0.0) ? color.rgb * color.rgb :
1201                                               color.rgb; /* Simulate 2 transmission event */
1202   eevee_closure_glass(
1203       N, vec3(1.0), int(ssr_id), roughness, 1.0, ior, out_spec, out_refr, ssr_spec);
1204   out_refr *= refr_color;
1205   out_spec *= color.rgb;
1206   float fresnel = F_eta(ior, dot(N, cameraVec));
1207   vec3 vN = mat3(ViewMatrix) * N;
1208   result = CLOSURE_DEFAULT;
1209   result.radiance = mix(out_refr, out_spec, fresnel);
1210   result.ssr_data = vec4(ssr_spec * color.rgb * fresnel, roughness);
1211   result.ssr_normal = normal_encode(vN, viewCameraVec);
1212   result.ssr_id = int(ssr_id);
1213 }
1214
1215 void node_bsdf_toon(vec4 color, float size, float tsmooth, vec3 N, out Closure result)
1216 {
1217   node_bsdf_diffuse(color, 0.0, N, result);
1218 }
1219
1220 void node_bsdf_principled(vec4 base_color,
1221                           float subsurface,
1222                           vec3 subsurface_radius,
1223                           vec4 subsurface_color,
1224                           float metallic,
1225                           float specular,
1226                           float specular_tint,
1227                           float roughness,
1228                           float anisotropic,
1229                           float anisotropic_rotation,
1230                           float sheen,
1231                           float sheen_tint,
1232                           float clearcoat,
1233                           float clearcoat_roughness,
1234                           float ior,
1235                           float transmission,
1236                           float transmission_roughness,
1237                           vec4 emission,
1238                           float alpha,
1239                           vec3 N,
1240                           vec3 CN,
1241                           vec3 T,
1242                           vec3 I,
1243                           float ssr_id,
1244                           float sss_id,
1245                           vec3 sss_scale,
1246                           out Closure result)
1247 {
1248   N = normalize(N);
1249   ior = max(ior, 1e-5);
1250   metallic = saturate(metallic);
1251   transmission = saturate(transmission);
1252   float dielectric = 1.0 - metallic;
1253   transmission *= dielectric;
1254   sheen *= dielectric;
1255   subsurface_color *= dielectric;
1256
1257   vec3 diffuse, f0, out_diff, out_spec, out_trans, out_refr, ssr_spec;
1258   vec3 ctint = tint_from_color(base_color.rgb);
1259   convert_metallic_to_specular_tinted(
1260       base_color.rgb, ctint, metallic, specular, specular_tint, diffuse, f0);
1261
1262   float NV = dot(N, cameraVec);
1263   vec3 out_sheen = sheen * principled_sheen(NV, ctint, sheen_tint);
1264
1265   /* Far from being accurate, but 2 glossy evaluation is too expensive.
1266    * Most noticeable difference is at grazing angles since the bsdf lut
1267    * f0 color interpolation is done on top of this interpolation. */
1268   vec3 f0_glass = mix(vec3(1.0), base_color.rgb, specular_tint);
1269   float fresnel = F_eta(ior, NV);
1270   vec3 spec_col = F_color_blend(ior, fresnel, f0_glass) * fresnel;
1271   f0 = mix(f0, spec_col, transmission);
1272
1273   vec3 mixed_ss_base_color = mix(diffuse, subsurface_color.rgb, subsurface);
1274
1275   float sss_scalef = dot(sss_scale, vec3(1.0 / 3.0)) * subsurface;
1276   eevee_closure_principled(N,
1277                            mixed_ss_base_color,
1278                            f0,
1279                            int(ssr_id),
1280                            roughness,
1281                            CN,
1282                            clearcoat * 0.25,
1283                            clearcoat_roughness,
1284                            1.0,
1285                            sss_scalef,
1286                            ior,
1287                            out_diff,
1288                            out_trans,
1289                            out_spec,
1290                            out_refr,
1291                            ssr_spec);
1292
1293   vec3 refr_color = base_color.rgb;
1294   refr_color *= (refractionDepth > 0.0) ? refr_color :
1295                                           vec3(1.0); /* Simulate 2 transmission event */
1296   out_refr *= refr_color * (1.0 - fresnel) * transmission;
1297
1298   vec3 vN = mat3(ViewMatrix) * N;
1299   result = CLOSURE_DEFAULT;
1300   result.radiance = out_spec + out_refr;
1301   result.radiance += out_diff * out_sheen; /* Coarse approx. */
1302 #  ifndef USE_SSS
1303   result.radiance += (out_diff + out_trans) * mixed_ss_base_color * (1.0 - transmission);
1304 #  endif
1305   result.ssr_data = vec4(ssr_spec, roughness);
1306   result.ssr_normal = normal_encode(vN, viewCameraVec);
1307   result.ssr_id = int(ssr_id);
1308 #  ifdef USE_SSS
1309   result.sss_data.a = sss_scalef;
1310   result.sss_data.rgb = out_diff + out_trans;
1311 #    ifdef USE_SSS_ALBEDO
1312   result.sss_albedo.rgb = mixed_ss_base_color;
1313 #    else
1314   result.sss_data.rgb *= mixed_ss_base_color;
1315 #    endif
1316   result.sss_data.rgb *= (1.0 - transmission);
1317 #  endif
1318   result.radiance += emission.rgb;
1319   result.opacity = alpha;
1320 }
1321
1322 void node_bsdf_principled_dielectric(vec4 base_color,
1323                                      float subsurface,
1324                                      vec3 subsurface_radius,
1325                                      vec4 subsurface_color,
1326                                      float metallic,
1327                                      float specular,
1328                                      float specular_tint,
1329                                      float roughness,
1330                                      float anisotropic,
1331                                      float anisotropic_rotation,
1332                                      float sheen,
1333                                      float sheen_tint,
1334                                      float clearcoat,
1335                                      float clearcoat_roughness,
1336                                      float ior,
1337                                      float transmission,
1338                                      float transmission_roughness,
1339                                      vec4 emission,
1340                                      float alpha,
1341                                      vec3 N,
1342                                      vec3 CN,
1343                                      vec3 T,
1344                                      vec3 I,
1345                                      float ssr_id,
1346                                      float sss_id,
1347                                      vec3 sss_scale,
1348                                      out Closure result)
1349 {
1350   N = normalize(N);
1351   metallic = saturate(metallic);
1352   float dielectric = 1.0 - metallic;
1353
1354   vec3 diffuse, f0, out_diff, out_spec, ssr_spec;
1355   vec3 ctint = tint_from_color(base_color.rgb);
1356   convert_metallic_to_specular_tinted(
1357       base_color.rgb, ctint, metallic, specular, specular_tint, diffuse, f0);
1358
1359   float NV = dot(N, cameraVec);
1360   vec3 out_sheen = sheen * principled_sheen(NV, ctint, sheen_tint);
1361
1362   eevee_closure_default(N, diffuse, f0, int(ssr_id), roughness, 1.0, out_diff, out_spec, ssr_spec);
1363
1364   vec3 vN = mat3(ViewMatrix) * N;
1365   result = CLOSURE_DEFAULT;
1366   result.radiance = out_spec + out_diff * (diffuse + out_sheen);
1367   result.ssr_data = vec4(ssr_spec, roughness);
1368   result.ssr_normal = normal_encode(vN, viewCameraVec);
1369   result.ssr_id = int(ssr_id);
1370   result.radiance += emission.rgb;
1371   result.opacity = alpha;
1372 }
1373
1374 void node_bsdf_principled_metallic(vec4 base_color,
1375                                    float subsurface,
1376                                    vec3 subsurface_radius,
1377                                    vec4 subsurface_color,
1378                                    float metallic,
1379                                    float specular,
1380                                    float specular_tint,
1381                                    float roughness,
1382                                    float anisotropic,
1383                                    float anisotropic_rotation,
1384                                    float sheen,
1385                                    float sheen_tint,
1386                                    float clearcoat,
1387                                    float clearcoat_roughness,
1388                                    float ior,
1389                                    float transmission,
1390                                    float transmission_roughness,
1391                                    vec4 emission,
1392                                    float alpha,
1393                                    vec3 N,
1394                                    vec3 CN,
1395                                    vec3 T,
1396                                    vec3 I,
1397                                    float ssr_id,
1398                                    float sss_id,
1399                                    vec3 sss_scale,
1400                                    out Closure result)
1401 {
1402   N = normalize(N);
1403   vec3 out_spec, ssr_spec;
1404
1405   eevee_closure_glossy(N, base_color.rgb, int(ssr_id), roughness, 1.0, out_spec, ssr_spec);
1406
1407   vec3 vN = mat3(ViewMatrix) * N;
1408   result = CLOSURE_DEFAULT;
1409   result.radiance = out_spec;
1410   result.ssr_data = vec4(ssr_spec, roughness);
1411   result.ssr_normal = normal_encode(vN, viewCameraVec);
1412   result.ssr_id = int(ssr_id);
1413   result.radiance += emission.rgb;
1414   result.opacity = alpha;
1415 }
1416
1417 void node_bsdf_principled_clearcoat(vec4 base_color,
1418                                     float subsurface,
1419                                     vec3 subsurface_radius,
1420                                     vec4 subsurface_color,
1421                                     float metallic,
1422                                     float specular,
1423                                     float specular_tint,
1424                                     float roughness,
1425                                     float anisotropic,
1426                                     float anisotropic_rotation,
1427                                     float sheen,
1428                                     float sheen_tint,
1429                                     float clearcoat,
1430                                     float clearcoat_roughness,
1431                                     float ior,
1432                                     float transmission,
1433                                     float transmission_roughness,
1434                                     vec4 emission,
1435                                     float alpha,
1436                                     vec3 N,
1437                                     vec3 CN,
1438                                     vec3 T,
1439                                     vec3 I,
1440                                     float ssr_id,
1441                                     float sss_id,
1442                                     vec3 sss_scale,
1443                                     out Closure result)
1444 {
1445   vec3 out_spec, ssr_spec;
1446   N = normalize(N);
1447
1448   eevee_closure_clearcoat(N,
1449                           base_color.rgb,
1450                           int(ssr_id),
1451                           roughness,
1452                           CN,
1453                           clearcoat * 0.25,
1454                           clearcoat_roughness,
1455                           1.0,
1456                           out_spec,
1457                           ssr_spec);
1458
1459   vec3 vN = mat3(ViewMatrix) * N;
1460   result = CLOSURE_DEFAULT;
1461   result.radiance = out_spec;
1462   result.ssr_data = vec4(ssr_spec, roughness);
1463   result.ssr_normal = normal_encode(vN, viewCameraVec);
1464   result.ssr_id = int(ssr_id);
1465   result.radiance += emission.rgb;
1466   result.opacity = alpha;
1467 }
1468
1469 void node_bsdf_principled_subsurface(vec4 base_color,
1470                                      float subsurface,
1471                                      vec3 subsurface_radius,
1472                                      vec4 subsurface_color,
1473                                      float metallic,
1474                                      float specular,
1475                                      float specular_tint,
1476                                      float roughness,
1477                                      float anisotropic,
1478                                      float anisotropic_rotation,
1479                                      float sheen,
1480                                      float sheen_tint,
1481                                      float clearcoat,
1482                                      float clearcoat_roughness,
1483                                      float ior,
1484                                      float transmission,
1485                                      float transmission_roughness,
1486                                      vec4 emission,
1487                                      float alpha,
1488                                      vec3 N,
1489                                      vec3 CN,
1490                                      vec3 T,
1491                                      vec3 I,
1492                                      float ssr_id,
1493                                      float sss_id,
1494                                      vec3 sss_scale,
1495                                      out Closure result)
1496 {
1497   metallic = saturate(metallic);
1498   N = normalize(N);
1499
1500   vec3 diffuse, f0, out_diff, out_spec, out_trans, ssr_spec;
1501   vec3 ctint = tint_from_color(base_color.rgb);
1502   convert_metallic_to_specular_tinted(
1503       base_color.rgb, ctint, metallic, specular, specular_tint, diffuse, f0);
1504
1505   subsurface_color = subsurface_color * (1.0 - metallic);
1506   vec3 mixed_ss_base_color = mix(diffuse, subsurface_color.rgb, subsurface);
1507   float sss_scalef = dot(sss_scale, vec3(1.0 / 3.0)) * subsurface;
1508
1509   float NV = dot(N, cameraVec);
1510   vec3 out_sheen = sheen * principled_sheen(NV, ctint, sheen_tint);
1511
1512   eevee_closure_skin(N,
1513                      mixed_ss_base_color,
1514                      f0,
1515                      int(ssr_id),
1516                      roughness,
1517                      1.0,
1518                      sss_scalef,
1519                      out_diff,
1520                      out_trans,
1521                      out_spec,
1522                      ssr_spec);
1523
1524   vec3 vN = mat3(ViewMatrix) * N;
1525   result = CLOSURE_DEFAULT;
1526   result.radiance = out_spec;
1527   result.ssr_data = vec4(ssr_spec, roughness);
1528   result.ssr_normal = normal_encode(vN, viewCameraVec);
1529   result.ssr_id = int(ssr_id);
1530 #  ifdef USE_SSS
1531   result.sss_data.a = sss_scalef;
1532   result.sss_data.rgb = out_diff + out_trans;
1533 #    ifdef USE_SSS_ALBEDO
1534   result.sss_albedo.rgb = mixed_ss_base_color;
1535 #    else
1536   result.sss_data.rgb *= mixed_ss_base_color;
1537 #    endif
1538 #  else
1539   result.radiance += (out_diff + out_trans) * mixed_ss_base_color;
1540 #  endif
1541   result.radiance += out_diff * out_sheen;
1542   result.radiance += emission.rgb;
1543   result.opacity = alpha;
1544 }
1545
1546 void node_bsdf_principled_glass(vec4 base_color,
1547                                 float subsurface,
1548                                 vec3 subsurface_radius,
1549                                 vec4 subsurface_color,
1550                                 float metallic,
1551                                 float specular,
1552                                 float specular_tint,
1553                                 float roughness,
1554                                 float anisotropic,
1555                                 float anisotropic_rotation,
1556                                 float sheen,
1557                                 float sheen_tint,
1558                                 float clearcoat,
1559                                 float clearcoat_roughness,
1560                                 float ior,
1561                                 float transmission,
1562                                 float transmission_roughness,
1563                                 vec4 emission,
1564                                 float alpha,
1565                                 vec3 N,
1566                                 vec3 CN,
1567                                 vec3 T,
1568                                 vec3 I,
1569                                 float ssr_id,
1570                                 float sss_id,
1571                                 vec3 sss_scale,
1572                                 out Closure result)
1573 {
1574   ior = max(ior, 1e-5);
1575   N = normalize(N);
1576
1577   vec3 f0, out_spec, out_refr, ssr_spec;
1578   f0 = mix(vec3(1.0), base_color.rgb, specular_tint);
1579
1580   eevee_closure_glass(
1581       N, vec3(1.0), int(ssr_id), roughness, 1.0, ior, out_spec, out_refr, ssr_spec);
1582
1583   vec3 refr_color = base_color.rgb;
1584   refr_color *= (refractionDepth > 0.0) ? refr_color :
1585                                           vec3(1.0); /* Simulate 2 transmission events */
1586   out_refr *= refr_color;
1587
1588   float fresnel = F_eta(ior, dot(N, cameraVec));
1589   vec3 spec_col = F_color_blend(ior, fresnel, f0);
1590   out_spec *= spec_col;
1591   ssr_spec *= spec_col * fresnel;
1592
1593   vec3 vN = mat3(ViewMatrix) * N;
1594   result = CLOSURE_DEFAULT;
1595   result.radiance = mix(out_refr, out_spec, fresnel);
1596   result.ssr_data = vec4(ssr_spec, roughness);
1597   result.ssr_normal = normal_encode(vN, viewCameraVec);
1598   result.ssr_id = int(ssr_id);
1599   result.radiance += emission.rgb;
1600   result.opacity = alpha;
1601 }
1602
1603 void node_bsdf_translucent(vec4 color, vec3 N, out Closure result)
1604 {
1605   node_bsdf_diffuse(color, 0.0, -N, result);
1606 }
1607
1608 void node_bsdf_transparent(vec4 color, out Closure result)
1609 {
1610   /* this isn't right */
1611   result = CLOSURE_DEFAULT;
1612   result.radiance = vec3(0.0);
1613   result.opacity = clamp(1.0 - dot(color.rgb, vec3(0.3333334)), 0.0, 1.0);
1614   result.ssr_id = TRANSPARENT_CLOSURE_FLAG;
1615 }
1616
1617 void node_bsdf_velvet(vec4 color, float sigma, vec3 N, out Closure result)
1618 {
1619   node_bsdf_diffuse(color, 0.0, N, result);
1620 }
1621
1622 void node_subsurface_scattering(vec4 color,
1623                                 float scale,
1624                                 vec3 radius,
1625                                 float sharpen,
1626                                 float texture_blur,
1627                                 vec3 N,
1628                                 float sss_id,
1629                                 out Closure result)
1630 {
1631 #  if defined(USE_SSS)
1632   N = normalize(N);
1633   vec3 out_diff, out_trans;
1634   vec3 vN = mat3(ViewMatrix) * N;
1635   result = CLOSURE_DEFAULT;
1636   result.ssr_data = vec4(0.0);
1637   result.ssr_normal = normal_encode(vN, viewCameraVec);
1638   result.ssr_id = -1;
1639   result.sss_data.a = scale;
1640   eevee_closure_subsurface(N, color.rgb, 1.0, scale, out_diff, out_trans);
1641   result.sss_data.rgb = out_diff + out_trans;
1642 #    ifdef USE_SSS_ALBEDO
1643   /* Not perfect for texture_blur not exactly equal to 0.0 or 1.0. */
1644   result.sss_albedo.rgb = mix(color.rgb, vec3(1.0), texture_blur);
1645   result.sss_data.rgb *= mix(vec3(1.0), color.rgb, texture_blur);
1646 #    else
1647   result.sss_data.rgb *= color.rgb;
1648 #    endif
1649 #  else
1650   node_bsdf_diffuse(color, 0.0, N, result);
1651 #  endif
1652 }
1653
1654 void node_bsdf_refraction(vec4 color, float roughness, float ior, vec3 N, out Closure result)
1655 {
1656   N = normalize(N);
1657   vec3 out_refr;
1658   color.rgb *= (refractionDepth > 0.0) ? color.rgb : vec3(1.0); /* Simulate 2 absorption event. */
1659   eevee_closure_refraction(N, roughness, ior, out_refr);
1660   vec3 vN = mat3(ViewMatrix) * N;
1661   result = CLOSURE_DEFAULT;
1662   result.ssr_normal = normal_encode(vN, viewCameraVec);
1663   result.radiance = out_refr * color.rgb;
1664   result.ssr_id = REFRACT_CLOSURE_FLAG;
1665 }
1666
1667 void node_ambient_occlusion(
1668     vec4 color, float distance, vec3 normal, out vec4 result_color, out float result_ao)
1669 {
1670   vec3 bent_normal;
1671   vec4 rand = texelFetch(utilTex, ivec3(ivec2(gl_FragCoord.xy) % LUT_SIZE, 2.0), 0);
1672   result_ao = occlusion_compute(normalize(normal), viewPosition, 1.0, rand, bent_normal);
1673   result_color = result_ao * color;
1674 }
1675
1676 #endif /* VOLUMETRICS */
1677
1678 /* emission */
1679
1680 void node_emission(vec4 color, float strength, vec3 vN, out Closure result)
1681 {
1682 #ifndef VOLUMETRICS
1683   color *= strength;
1684   result = CLOSURE_DEFAULT;
1685   result.radiance = color.rgb;
1686   result.opacity = color.a;
1687   result.ssr_normal = normal_encode(vN, viewCameraVec);
1688 #else
1689   result = Closure(vec3(0.0), vec3(0.0), color.rgb * strength, 0.0);
1690 #endif
1691 }
1692
1693 void node_wireframe(float size, vec2 barycentric, vec3 barycentric_dist, out float fac)
1694 {
1695   vec3 barys = barycentric.xyy;
1696   barys.z = 1.0 - barycentric.x - barycentric.y;
1697
1698   size *= 0.5;
1699   vec3 s = step(-size, -barys * barycentric_dist);
1700
1701   fac = max(s.x, max(s.y, s.z));
1702 }
1703
1704 void node_wireframe_screenspace(float size, vec2 barycentric, out float fac)
1705 {
1706   vec3 barys = barycentric.xyy;
1707   barys.z = 1.0 - barycentric.x - barycentric.y;
1708
1709   size *= (1.0 / 3.0);
1710   vec3 dx = dFdx(barys);
1711   vec3 dy = dFdy(barys);
1712   vec3 deltas = sqrt(dx * dx + dy * dy);
1713
1714   vec3 s = step(-deltas * size, -barys);
1715
1716   fac = max(s.x, max(s.y, s.z));
1717 }
1718
1719 /* background */
1720
1721 void node_tex_environment_texco(vec3 viewvec, out vec3 worldvec)
1722 {
1723 #ifdef MESH_SHADER
1724   worldvec = worldPosition;
1725 #else
1726   vec4 v = (ProjectionMatrix[3][3] == 0.0) ? vec4(viewvec, 1.0) : vec4(0.0, 0.0, 1.0, 1.0);
1727   vec4 co_homogenous = (ProjectionMatrixInverse * v);
1728
1729   vec3 co = co_homogenous.xyz / co_homogenous.w;
1730 #  if defined(WORLD_BACKGROUND) || defined(PROBE_CAPTURE)
1731   worldvec = mat3(ViewMatrixInverse) * co;
1732 #  else
1733   worldvec = mat3(ModelMatrixInverse) * (mat3(ViewMatrixInverse) * co);
1734 #  endif
1735 #endif
1736 }
1737
1738 void node_background(vec4 color, float strength, out Closure result)
1739 {
1740 #ifndef VOLUMETRICS
1741   color *= strength;
1742   result = CLOSURE_DEFAULT;
1743   result.radiance = color.rgb;
1744   result.opacity = color.a;
1745 #else
1746   result = CLOSURE_DEFAULT;
1747 #endif
1748 }
1749
1750 /* volumes */
1751
1752 void node_volume_scatter(vec4 color, float density, float anisotropy, out Closure result)
1753 {
1754 #ifdef VOLUMETRICS
1755   result = Closure(vec3(0.0), color.rgb * density, vec3(0.0), anisotropy);
1756 #else
1757   result = CLOSURE_DEFAULT;
1758 #endif
1759 }
1760
1761 void node_volume_absorption(vec4 color, float density, out Closure result)
1762 {
1763 #ifdef VOLUMETRICS
1764   result = Closure((1.0 - color.rgb) * density, vec3(0.0), vec3(0.0), 0.0);
1765 #else
1766   result = CLOSURE_DEFAULT;
1767 #endif
1768 }
1769
1770 void node_blackbody(float temperature, sampler1DArray spectrummap, float layer, out vec4 color)
1771 {
1772   if (temperature >= 12000.0) {
1773     color = vec4(0.826270103, 0.994478524, 1.56626022, 1.0);
1774   }
1775   else if (temperature < 965.0) {
1776     color = vec4(4.70366907, 0.0, 0.0, 1.0);
1777   }
1778   else {
1779     float t = (temperature - 965.0) / (12000.0 - 965.0);
1780     color = vec4(texture(spectrummap, vec2(t, layer)).rgb, 1.0);
1781   }
1782 }
1783
1784 void node_volume_principled(vec4 color,
1785                             float density,
1786                             float anisotropy,
1787                             vec4 absorption_color,
1788                             float emission_strength,
1789                             vec4 emission_color,
1790                             float blackbody_intensity,
1791                             vec4 blackbody_tint,
1792                             float temperature,
1793                             float density_attribute,
1794                             vec4 color_attribute,
1795                             float temperature_attribute,
1796                             sampler1DArray spectrummap,
1797                             float layer,
1798                             out Closure result)
1799 {
1800 #ifdef VOLUMETRICS
1801   vec3 absorption_coeff = vec3(0.0);
1802   vec3 scatter_coeff = vec3(0.0);
1803   vec3 emission_coeff = vec3(0.0);
1804
1805   /* Compute density. */
1806   density = max(density, 0.0);
1807
1808   if (density > 1e-5) {
1809     density = max(density * density_attribute, 0.0);
1810   }
1811
1812   if (density > 1e-5) {
1813     /* Compute scattering and absorption coefficients. */
1814     vec3 scatter_color = color.rgb * color_attribute.rgb;
1815
1816     scatter_coeff = scatter_color * density;
1817     absorption_color.rgb = sqrt(max(absorption_color.rgb, 0.0));
1818     absorption_coeff = max(1.0 - scatter_color, 0.0) * max(1.0 - absorption_color.rgb, 0.0) *
1819                        density;
1820   }
1821
1822   /* Compute emission. */
1823   emission_strength = max(emission_strength, 0.0);
1824
1825   if (emission_strength > 1e-5) {
1826     emission_coeff += emission_strength * emission_color.rgb;
1827   }
1828
1829   if (blackbody_intensity > 1e-3) {
1830     /* Add temperature from attribute. */
1831     float T = max(temperature * max(temperature_attribute, 0.0), 0.0);
1832
1833     /* Stefan-Boltzman law. */
1834     float T2 = T * T;
1835     float T4 = T2 * T2;
1836     float sigma = 5.670373e-8 * 1e-6 / M_PI;
1837     float intensity = sigma * mix(1.0, T4, blackbody_intensity);
1838
1839     if (intensity > 1e-5) {
1840       vec4 bb;
1841       node_blackbody(T, spectrummap, layer, bb);
1842       emission_coeff += bb.rgb * blackbody_tint.rgb * intensity;
1843     }
1844   }
1845
1846   result = Closure(absorption_coeff, scatter_coeff, emission_coeff, anisotropy);
1847 #else
1848   result = CLOSURE_DEFAULT;
1849 #endif
1850 }
1851
1852 /* closures */
1853
1854 void node_mix_shader(float fac, Closure shader1, Closure shader2, out Closure shader)
1855 {
1856   shader = closure_mix(shader1, shader2, fac);
1857 }
1858
1859 void node_add_shader(Closure shader1, Closure shader2, out Closure shader)
1860 {
1861   shader = closure_add(shader1, shader2);
1862 }
1863
1864 /* fresnel */
1865
1866 void node_fresnel(float ior, vec3 N, vec3 I, out float result)
1867 {
1868   N = normalize(N);
1869   /* handle perspective/orthographic */
1870   vec3 I_view = (ProjectionMatrix[3][3] == 0.0) ? normalize(I) : vec3(0.0, 0.0, -1.0);
1871
1872   float eta = max(ior, 0.00001);
1873   result = fresnel_dielectric(I_view, N, (gl_FrontFacing) ? eta : 1.0 / eta);
1874 }
1875
1876 /* layer_weight */
1877
1878 void node_layer_weight(float blend, vec3 N, vec3 I, out float fresnel, out float facing)
1879 {
1880   N = normalize(N);
1881
1882   /* fresnel */
1883   float eta = max(1.0 - blend, 0.00001);
1884   vec3 I_view = (ProjectionMatrix[3][3] == 0.0) ? normalize(I) : vec3(0.0, 0.0, -1.0);
1885
1886   fresnel = fresnel_dielectric(I_view, N, (gl_FrontFacing) ? 1.0 / eta : eta);
1887
1888   /* facing */
1889   facing = abs(dot(I_view, N));
1890   if (blend != 0.5) {
1891     blend = clamp(blend, 0.0, 0.99999);
1892     blend = (blend < 0.5) ? 2.0 * blend : 0.5 / (1.0 - blend);
1893     facing = pow(facing, blend);
1894   }
1895   facing = 1.0 - facing;
1896 }
1897
1898 /* gamma */
1899
1900 void node_gamma(vec4 col, float gamma, out vec4 outcol)
1901 {
1902   outcol = col;
1903
1904   if (col.r > 0.0)
1905     outcol.r = compatible_pow(col.r, gamma);
1906   if (col.g > 0.0)
1907     outcol.g = compatible_pow(col.g, gamma);
1908   if (col.b > 0.0)
1909     outcol.b = compatible_pow(col.b, gamma);
1910 }
1911
1912 /* geometry */
1913
1914 void node_attribute_volume_density(sampler3D tex, out vec4 outcol, out vec3 outvec, out float outf)
1915 {
1916 #if defined(MESH_SHADER) && defined(VOLUMETRICS)
1917   vec3 cos = volumeObjectLocalCoord;
1918 #else
1919   vec3 cos = vec3(0.0);
1920 #endif
1921   outvec = texture(tex, cos).aaa;
1922   outcol = vec4(outvec, 1.0);
1923   outf = dot(vec3(1.0 / 3.0), outvec);
1924 }
1925
1926 uniform vec3 volumeColor = vec3(1.0);
1927
1928 void node_attribute_volume_color(sampler3D tex, out vec4 outcol, out vec3 outvec, out float outf)
1929 {
1930 #if defined(MESH_SHADER) && defined(VOLUMETRICS)
1931   vec3 cos = volumeObjectLocalCoord;
1932 #else
1933   vec3 cos = vec3(0.0);
1934 #endif
1935
1936   vec4 value = texture(tex, cos).rgba;
1937   /* Density is premultiplied for interpolation, divide it out here. */
1938   if (value.a > 1e-8)
1939     value.rgb /= value.a;
1940
1941   outvec = value.rgb * volumeColor;
1942   outcol = vec4(outvec, 1.0);
1943   outf = dot(vec3(1.0 / 3.0), outvec);
1944 }
1945
1946 void node_attribute_volume_flame(sampler3D tex, out vec4 outcol, out vec3 outvec, out float outf)
1947 {
1948 #if defined(MESH_SHADER) && defined(VOLUMETRICS)
1949   vec3 cos = volumeObjectLocalCoord;
1950 #else
1951   vec3 cos = vec3(0.0);
1952 #endif
1953   outf = texture(tex, cos).r;
1954   outvec = vec3(outf, outf, outf);
1955   outcol = vec4(outf, outf, outf, 1.0);
1956 }
1957
1958 void node_attribute_volume_temperature(
1959     sampler3D tex, vec2 temperature, out vec4 outcol, out vec3 outvec, out float outf)
1960 {
1961 #if defined(MESH_SHADER) && defined(VOLUMETRICS)
1962   vec3 cos = volumeObjectLocalCoord;
1963 #else
1964   vec3 cos = vec3(0.0);
1965 #endif
1966   float flame = texture(tex, cos).r;
1967
1968   outf = (flame > 0.01) ? temperature.x + flame * (temperature.y - temperature.x) : 0.0;
1969   outvec = vec3(outf, outf, outf);
1970   outcol = vec4(outf, outf, outf, 1.0);
1971 }
1972
1973 void node_attribute(vec3 attr, out vec4 outcol, out vec3 outvec, out float outf)
1974 {
1975   outcol = vec4(attr, 1.0);
1976   outvec = attr;
1977   outf = dot(vec3(1.0 / 3.0), attr);
1978 }
1979
1980 void node_uvmap(vec3 attr_uv, out vec3 outvec)
1981 {
1982   outvec = attr_uv;
1983 }
1984
1985 void tangent_orco_x(vec3 orco_in, out vec3 orco_out)
1986 {
1987   orco_out = orco_in.xzy * vec3(0.0, -0.5, 0.5) + vec3(0.0, 0.25, -0.25);
1988 }
1989
1990 void tangent_orco_y(vec3 orco_in, out vec3 orco_out)
1991 {
1992   orco_out = orco_in.zyx * vec3(-0.5, 0.0, 0.5) + vec3(0.25, 0.0, -0.25);
1993 }
1994
1995 void tangent_orco_z(vec3 orco_in, out vec3 orco_out)
1996 {
1997   orco_out = orco_in.yxz * vec3(-0.5, 0.5, 0.0) + vec3(0.25, -0.25, 0.0);
1998 }
1999
2000 void node_tangentmap(vec4 attr_tangent, out vec3 tangent)
2001 {
2002   tangent = normalize(attr_tangent.xyz);
2003 }
2004
2005 void node_tangent(vec3 N, vec3 orco, mat4 objmat, out vec3 T)
2006 {
2007   T = (objmat * vec4(orco, 0.0)).xyz;
2008   T = cross(N, normalize(cross(T, N)));
2009 }
2010
2011 void node_geometry(vec3 I,
2012                    vec3 N,
2013                    vec3 orco,
2014                    mat4 objmat,
2015                    mat4 toworld,
2016                    vec2 barycentric,
2017                    out vec3 position,
2018                    out vec3 normal,
2019                    out vec3 tangent,
2020                    out vec3 true_normal,
2021                    out vec3 incoming,
2022                    out vec3 parametric,
2023                    out float backfacing,
2024                    out float pointiness)
2025 {
2026   /* handle perspective/orthographic */
2027   vec3 I_view = (ProjectionMatrix[3][3] == 0.0) ? normalize(I) : vec3(0.0, 0.0, -1.0);
2028   incoming = -(toworld * vec4(I_view, 0.0)).xyz;
2029
2030 #if defined(WORLD_BACKGROUND) || defined(PROBE_CAPTURE)
2031   position = -incoming;
2032   true_normal = normal = incoming;
2033   tangent = parametric = vec3(0.0);
2034   vec3(0.0);
2035   backfacing = 0.0;
2036   pointiness = 0.0;
2037 #else
2038
2039   position = worldPosition;
2040 #  ifndef VOLUMETRICS
2041   normal = normalize(gl_FrontFacing ? worldNormal : -worldNormal);
2042   vec3 B = dFdx(worldPosition);
2043   vec3 T = dFdy(worldPosition);
2044   true_normal = normalize(cross(B, T));
2045 #  else
2046   normal = (toworld * vec4(N, 0.0)).xyz;
2047   true_normal = normal;
2048 #  endif
2049   tangent_orco_z(orco, orco);
2050   node_tangent(N, orco, objmat, tangent);
2051
2052   parametric = vec3(barycentric, 0.0);
2053   backfacing = (gl_FrontFacing) ? 0.0 : 1.0;
2054   pointiness = 0.5;
2055 #endif
2056 }
2057
2058 void generated_texco(vec3 I, vec3 attr_orco, out vec3 generated)
2059 {
2060   vec4 v = (ProjectionMatrix[3][3] == 0.0) ? vec4(I, 1.0) : vec4(0.0, 0.0, 1.0, 1.0);
2061   vec4 co_homogenous = (ProjectionMatrixInverse * v);
2062   vec4 co = vec4(co_homogenous.xyz / co_homogenous.w, 0.0);
2063   co.xyz = normalize(co.xyz);
2064 #if defined(WORLD_BACKGROUND) || defined(PROBE_CAPTURE)
2065   generated = (ViewMatrixInverse * co).xyz;
2066 #else
2067   generated_from_orco(attr_orco, generated);
2068 #endif
2069 }
2070
2071 void node_tex_coord(vec3 I,
2072                     vec3 wN,
2073                     mat4 obmatinv,
2074                     vec4 camerafac,
2075                     vec3 attr_orco,
2076                     vec3 attr_uv,
2077                     out vec3 generated,
2078                     out vec3 normal,
2079                     out vec3 uv,
2080                     out vec3 object,
2081                     out vec3 camera,
2082                     out vec3 window,
2083                     out vec3 reflection)
2084 {
2085   generated = attr_orco;
2086   normal = normalize(normal_world_to_object(wN));
2087   uv = attr_uv;
2088   object = (obmatinv * (ViewMatrixInverse * vec4(I, 1.0))).xyz;
2089   camera = vec3(I.xy, -I.z);
2090   vec4 projvec = ProjectionMatrix * vec4(I, 1.0);
2091   window = vec3(mtex_2d_mapping(projvec.xyz / projvec.w).xy * camerafac.xy + camerafac.zw, 0.0);
2092   reflection = reflect(cameraVec, normalize(wN));
2093 }
2094
2095 void node_tex_coord_background(vec3 I,
2096                                vec3 N,
2097                                mat4 obmatinv,
2098                                vec4 camerafac,
2099                                vec3 attr_orco,
2100                                vec3 attr_uv,
2101                                out vec3 generated,
2102                                out vec3 normal,
2103                                out vec3 uv,
2104                                out vec3 object,
2105                                out vec3 camera,
2106                                out vec3 window,
2107                                out vec3 reflection)
2108 {
2109   vec4 v = (ProjectionMatrix[3][3] == 0.0) ? vec4(I, 1.0) : vec4(0.0, 0.0, 1.0, 1.0);
2110   vec4 co_homogenous = (ProjectionMatrixInverse * v);
2111
2112   vec4 co = vec4(co_homogenous.xyz / co_homogenous.w, 0.0);
2113
2114   co = normalize(co);
2115
2116   vec3 coords = (ViewMatrixInverse * co).xyz;
2117
2118   generated = coords;
2119   normal = -coords;
2120   uv = vec3(attr_uv.xy, 0.0);
2121   object = coords;
2122
2123   camera = vec3(co.xy, -co.z);
2124   window = vec3(mtex_2d_mapping(I).xy * camerafac.xy + camerafac.zw, 0.0);
2125
2126   reflection = -coords;
2127 }
2128
2129 #if defined(WORLD_BACKGROUND) || (defined(PROBE_CAPTURE) && !defined(MESH_SHADER))
2130 #  define node_tex_coord node_tex_coord_background
2131 #endif
2132
2133 /* textures */
2134
2135 float calc_gradient(vec3 p, int gradient_type)
2136 {
2137   float x, y, z;
2138   x = p.x;
2139   y = p.y;
2140   z = p.z;
2141   if (gradient_type == 0) { /* linear */
2142     return x;
2143   }
2144   else if (gradient_type == 1) { /* quadratic */
2145     float r = max(x, 0.0);
2146     return r * r;
2147   }
2148   else if (gradient_type == 2) { /* easing */
2149     float r = min(max(x, 0.0), 1.0);
2150     float t = r * r;
2151     return (3.0 * t - 2.0 * t * r);
2152   }
2153   else if (gradient_type == 3) { /* diagonal */
2154     return (x + y) * 0.5;
2155   }
2156   else if (gradient_type == 4) { /* radial */
2157     return atan(y, x) / (M_PI * 2) + 0.5;
2158   }
2159   else {
2160     /* Bias a little bit for the case where p is a unit length vector,
2161      * to get exactly zero instead of a small random value depending
2162      * on float precision. */
2163     float r = max(0.999999 - sqrt(x * x + y * y + z * z), 0.0);
2164     if (gradient_type == 5) { /* quadratic sphere */
2165       return r * r;
2166     }
2167     else if (gradient_type == 6) { /* sphere */
2168       return r;
2169     }
2170   }
2171   return 0.0;
2172 }
2173
2174 void node_tex_gradient(vec3 co, float gradient_type, out vec4 color, out float fac)
2175 {
2176   float f = calc_gradient(co, int(gradient_type));
2177   f = clamp(f, 0.0, 1.0);
2178
2179   color = vec4(f, f, f, 1.0);
2180   fac = f;
2181 }
2182
2183 void node_tex_checker(
2184     vec3 co, vec4 color1, vec4 color2, float scale, out vec4 color, out float fac)
2185 {
2186   vec3 p = co * scale;
2187
2188   /* Prevent precision issues on unit coordinates. */
2189   p = (p + 0.000001) * 0.999999;
2190
2191   int xi = int(abs(floor(p.x)));
2192   int yi = int(abs(floor(p.y)));
2193   int zi = int(abs(floor(p.z)));
2194
2195   bool check = ((mod(xi, 2) == mod(yi, 2)) == bool(mod(zi, 2)));
2196
2197   color = check ? color1 : color2;
2198   fac = check ? 1.0 : 0.0;
2199 }
2200
2201 vec2 calc_brick_texture(vec3 p,
2202                         float mortar_size,
2203                         float mortar_smooth,
2204                         float bias,
2205                         float brick_width,
2206                         float row_height,
2207                         float offset_amount,
2208                         int offset_frequency,
2209                         float squash_amount,
2210                         int squash_frequency)
2211 {
2212   int bricknum, rownum;
2213   float offset = 0.0;
2214   float x, y;
2215
2216   rownum = floor_to_int(p.y / row_height);
2217
2218   if (offset_frequency != 0 && squash_frequency != 0) {
2219     brick_width *= (rownum % squash_frequency != 0) ? 1.0 : squash_amount;           /* squash */
2220     offset = (rownum % offset_frequency != 0) ? 0.0 : (brick_width * offset_amount); /* offset */
2221   }
2222
2223   bricknum = floor_to_int((p.x + offset) / brick_width);
2224
2225   x = (p.x + offset) - brick_width * bricknum;
2226   y = p.y - row_height * rownum;
2227
2228   float tint = clamp((integer_noise((rownum << 16) + (bricknum & 0xFFFF)) + bias), 0.0, 1.0);
2229
2230   float min_dist = min(min(x, y), min(brick_width - x, row_height - y));
2231   if (min_dist >= mortar_size) {
2232     return vec2(tint, 0.0);
2233   }
2234   else if (mortar_smooth == 0.0) {
2235     return vec2(tint, 1.0);
2236   }
2237   else {
2238     min_dist = 1.0 - min_dist / mortar_size;
2239     return vec2(tint, smoothstep(0.0, mortar_smooth, min_dist));
2240   }
2241 }
2242
2243 void node_tex_brick(vec3 co,
2244                     vec4 color1,
2245                     vec4 color2,
2246                     vec4 mortar,
2247                     float scale,
2248                     float mortar_size,
2249                     float mortar_smooth,
2250                     float bias,
2251                     float brick_width,
2252                     float row_height,
2253                     float offset_amount,
2254                     float offset_frequency,
2255                     float squash_amount,
2256                     float squash_frequency,
2257                     out vec4 color,
2258                     out float fac)
2259 {
2260   vec2 f2 = calc_brick_texture(co * scale,
2261                                mortar_size,
2262                                mortar_smooth,
2263                                bias,
2264                                brick_width,
2265                                row_height,
2266                                offset_amount,
2267                                int(offset_frequency),
2268                                squash_amount,
2269                                int(squash_frequency));
2270   float tint = f2.x;
2271   float f = f2.y;
2272   if (f != 1.0) {
2273     float facm = 1.0 - tint;
2274     color1 = facm * color1 + tint * color2;
2275   }
2276   color = mix(color1, mortar, f);
2277   fac = f;
2278 }
2279
2280 void node_tex_clouds(vec3 co, float size, out vec4 color, out float fac)
2281 {
2282   color = vec4(1.0);
2283   fac = 1.0;
2284 }
2285
2286 void node_tex_environment_equirectangular(vec3 co, float clamp_size, sampler2D ima, out vec3 uv)
2287 {
2288   vec3 nco = normalize(co);
2289   uv.x = -atan(nco.y, nco.x) / (2.0 * M_PI) + 0.5;
2290   uv.y = atan(nco.z, hypot(nco.x, nco.y)) / M_PI + 0.5;
2291
2292   /* Fix pole bleeding */
2293   float half_height = clamp_size / float(textureSize(ima, 0).y);
2294   uv.y = clamp(uv.y, half_height, 1.0 - half_height);
2295   uv.z = 0.0;
2296 }
2297
2298 void node_tex_environment_mirror_ball(vec3 co, out vec3 uv)
2299 {
2300   vec3 nco = normalize(co);
2301   nco.y -= 1.0;
2302
2303   float div = 2.0 * sqrt(max(-0.5 * nco.y, 0.0));
2304   nco /= max(1e-8, div);
2305
2306   uv = 0.5 * nco.xzz + 0.5;
2307 }
2308
2309 void node_tex_environment_empty(vec3 co, out vec4 color)
2310 {
2311   color = vec4(1.0, 0.0, 1.0, 1.0);
2312 }
2313
2314 /* 16bits floats limits. Higher/Lower values produce +/-inf. */
2315 #define safe_color(a) (clamp(a, -65520.0, 65520.0))
2316
2317 void tex_color_alpha_clear(vec4 color, out vec4 result)
2318 {
2319   result = vec4(color.rgb, 1.0);
2320 }
2321
2322 void tex_color_alpha_unpremultiply(vec4 color, out vec4 result)
2323 {
2324   if (color.a == 0.0 || color.a == 1.0) {
2325     result = vec4(color.rgb, 1.0);
2326   }
2327   else {
2328     result = vec4(color.rgb / color.a, 1.0);
2329   }
2330 }
2331
2332 void node_tex_image_linear(vec3 co, sampler2D ima, out vec4 color, out float alpha)
2333 {
2334   color = safe_color(texture(ima, co.xy));
2335   alpha = color.a;
2336 }
2337
2338 void node_tex_image_linear_no_mip(vec3 co, sampler2D ima, out vec4 color, out float alpha)
2339 {
2340   color = safe_color(textureLod(ima, co.xy, 0.0));
2341   alpha = color.a;
2342 }
2343
2344 void node_tex_image_nearest(vec3 co, sampler2D ima, out vec4 color, out float alpha)
2345 {
2346   ivec2 pix = ivec2(fract(co.xy) * textureSize(ima, 0).xy);
2347   color = safe_color(texelFetch(ima, pix, 0));
2348   alpha = color.a;
2349 }
2350
2351 /* @arg f: signed distance to texel center. */
2352 void cubic_bspline_coefs(vec2 f, out vec2 w0, out vec2 w1, out vec2 w2, out vec2 w3)
2353 {
2354   vec2 f2 = f * f;
2355   vec2 f3 = f2 * f;
2356   /* Bspline coefs (optimized) */
2357   w3 = f3 / 6.0;
2358   w0 = -w3 + f2 * 0.5 - f * 0.5 + 1.0 / 6.0;
2359   w1 = f3 * 0.5 - f2 * 1.0 + 2.0 / 3.0;
2360   w2 = 1.0 - w0 - w1 - w3;
2361 }
2362
2363 void node_tex_image_cubic_ex(
2364     vec3 co, sampler2D ima, float do_extend, out vec4 color, out float alpha)
2365 {
2366   vec2 tex_size = vec2(textureSize(ima, 0).xy);
2367
2368   co.xy *= tex_size;
2369   /* texel center */
2370   vec2 tc = floor(co.xy - 0.5) + 0.5;
2371   vec2 w0, w1, w2, w3;
2372   cubic_bspline_coefs(co.xy - tc, w0, w1, w2, w3);
2373
2374 #if 1 /* Optimized version using 4 filtered tap. */
2375   vec2 s0 = w0 + w1;
2376   vec2 s1 = w2 + w3;
2377
2378   vec2 f0 = w1 / (w0 + w1);
2379   vec2 f1 = w3 / (w2 + w3);
2380
2381   vec4 final_co;
2382   final_co.xy = tc - 1.0 + f0;
2383   final_co.zw = tc + 1.0 + f1;
2384
2385   if (do_extend == 1.0) {
2386     final_co = clamp(final_co, vec4(0.5), tex_size.xyxy - 0.5);
2387   }
2388   final_co /= tex_size.xyxy;
2389
2390   color = safe_color(textureLod(ima, final_co.xy, 0.0)) * s0.x * s0.y;
2391   color += safe_color(textureLod(ima, final_co.zy, 0.0)) * s1.x * s0.y;
2392   color += safe_color(textureLod(ima, final_co.xw, 0.0)) * s0.x * s1.y;
2393   color += safe_color(textureLod(ima, final_co.zw, 0.0)) * s1.x * s1.y;
2394
2395 #else /* Reference bruteforce 16 tap. */
2396   color = texelFetch(ima, ivec2(tc + vec2(-1.0, -1.0)), 0) * w0.x * w0.y;
2397   color += texelFetch(ima, ivec2(tc + vec2(0.0, -1.0)), 0) * w1.x * w0.y;
2398   color += texelFetch(ima, ivec2(tc + vec2(1.0, -1.0)), 0) * w2.x * w0.y;
2399   color += texelFetch(ima, ivec2(tc + vec2(2.0, -1.0)), 0) * w3.x * w0.y;
2400
2401   color += texelFetch(ima, ivec2(tc + vec2(-1.0, 0.0)), 0) * w0.x * w1.y;
2402   color += texelFetch(ima, ivec2(tc + vec2(0.0, 0.0)), 0) * w1.x * w1.y;
2403   color += texelFetch(ima, ivec2(tc + vec2(1.0, 0.0)), 0) * w2.x * w1.y;
2404   color += texelFetch(ima, ivec2(tc + vec2(2.0, 0.0)), 0) * w3.x * w1.y;
2405
2406   color += texelFetch(ima, ivec2(tc + vec2(-1.0, 1.0)), 0) * w0.x * w2.y;
2407   color += texelFetch(ima, ivec2(tc + vec2(0.0, 1.0)), 0) * w1.x * w2.y;
2408   color += texelFetch(ima, ivec2(tc + vec2(1.0, 1.0)), 0) * w2.x * w2.y;
2409   color += texelFetch(ima, ivec2(tc + vec2(2.0, 1.0)), 0) * w3.x * w2.y;
2410
2411   color += texelFetch(ima, ivec2(tc + vec2(-1.0, 2.0)), 0) * w0.x * w3.y;
2412   color += texelFetch(ima, ivec2(tc + vec2(0.0, 2.0)), 0) * w1.x * w3.y;
2413   color += texelFetch(ima, ivec2(tc + vec2(1.0, 2.0)), 0) * w2.x * w3.y;
2414   color += texelFetch(ima, ivec2(tc + vec2(2.0, 2.0)), 0) * w3.x * w3.y;
2415 #endif
2416
2417   alpha = color.a;
2418 }
2419
2420 void node_tex_image_cubic(vec3 co, sampler2D ima, out vec4 color, out float alpha)
2421 {
2422   node_tex_image_cubic_ex(co, ima, 0.0, color, alpha);
2423 }
2424
2425 void node_tex_image_cubic_extend(vec3 co, sampler2D ima, out vec4 color, out float alpha)
2426 {
2427   node_tex_image_cubic_ex(co, ima, 1.0, color, alpha);
2428 }
2429
2430 void node_tex_image_smart(vec3 co, sampler2D ima, out vec4 color, out float alpha)
2431 {
2432   /* use cubic for now */
2433   node_tex_image_cubic_ex(co, ima, 0.0, color, alpha);
2434 }
2435
2436 void tex_box_sample_linear(
2437     vec3 texco, vec3 N, sampler2D ima, out vec4 color1, out vec4 color2, out vec4 color3)
2438 {
2439   /* X projection */
2440   vec2 uv = texco.yz;
2441   if (N.x < 0.0) {
2442     uv.x = 1.0 - uv.x;
2443   }
2444   color1 = texture(ima, uv);
2445   /* Y projection */
2446   uv = texco.xz;
2447   if (N.y > 0.0) {
2448     uv.x = 1.0 - uv.x;
2449   }
2450   color2 = texture(ima, uv);
2451   /* Z projection */
2452   uv = texco.yx;
2453   if (N.z > 0.0) {
2454     uv.x = 1.0 - uv.x;
2455   }
2456   color3 = texture(ima, uv);
2457 }
2458
2459 void tex_box_sample_nearest(
2460     vec3 texco, vec3 N, sampler2D ima, out vec4 color1, out vec4 color2, out vec4 color3)
2461 {
2462   /* X projection */
2463   vec2 uv = texco.yz;
2464   if (N.x < 0.0) {
2465     uv.x = 1.0 - uv.x;
2466   }
2467   ivec2 pix = ivec2(uv.xy * textureSize(ima, 0).xy);
2468   color1 = texelFetch(ima, pix, 0);
2469   /* Y projection */
2470   uv = texco.xz;
2471   if (N.y > 0.0) {
2472     uv.x = 1.0 - uv.x;
2473   }
2474   pix = ivec2(uv.xy * textureSize(ima, 0).xy);
2475   color2 = texelFetch(ima, pix, 0);
2476   /* Z projection */
2477   uv = texco.yx;
2478   if (N.z > 0.0) {
2479     uv.x = 1.0 - uv.x;
2480   }
2481   pix = ivec2(uv.xy * textureSize(ima, 0).xy);
2482   color3 = texelFetch(ima, pix, 0);
2483 }
2484
2485 void tex_box_sample_cubic(
2486     vec3 texco, vec3 N, sampler2D ima, out vec4 color1, out vec4 color2, out vec4 color3)
2487 {
2488   float alpha;
2489   /* X projection */
2490   vec2 uv = texco.yz;
2491   if (N.x < 0.0) {
2492     uv.x = 1.0 - uv.x;
2493   }
2494   node_tex_image_cubic_ex(uv.xyy, ima, 0.0, color1, alpha);
2495   /* Y projection */
2496   uv = texco.xz;
2497   if (N.y > 0.0) {
2498     uv.x = 1.0 - uv.x;
2499   }
2500   node_tex_image_cubic_ex(uv.xyy, ima, 0.0, color2, alpha);
2501   /* Z projection */
2502   uv = texco.yx;
2503   if (N.z > 0.0) {
2504     uv.x = 1.0 - uv.x;
2505   }
2506   node_tex_image_cubic_ex(uv.xyy, ima, 0.0, color3, alpha);
2507 }
2508
2509 void tex_box_sample_smart(
2510     vec3 texco, vec3 N, sampler2D ima, out vec4 color1, out vec4 color2, out vec4 color3)
2511 {
2512   tex_box_sample_cubic(texco, N, ima, color1, color2, color3);
2513 }
2514
2515 void node_tex_image_box(vec3 texco,
2516                         vec3 N,
2517                         vec4 color1,
2518                         vec4 color2,
2519                         vec4 color3,
2520                         sampler2D ima,
2521                         float blend,
2522                         out vec4 color,
2523                         out float alpha)
2524 {
2525   /* project from direction vector to barycentric coordinates in triangles */
2526   N = abs(N);
2527   N /= dot(N, vec3(1.0));
2528
2529   /* basic idea is to think of this as a triangle, each corner representing
2530    * one of the 3 faces of the cube. in the corners we have single textures,
2531    * in between we blend between two textures, and in the middle we a blend
2532    * between three textures.
2533    *
2534    * the Nxyz values are the barycentric coordinates in an equilateral
2535    * triangle, which in case of blending, in the middle has a smaller
2536    * equilateral triangle where 3 textures blend. this divides things into
2537    * 7 zones, with an if () test for each zone
2538    * EDIT: Now there is only 4 if's. */
2539
2540   float limit = 0.5 + 0.5 * blend;
2541
2542   vec3 weight;
2543   weight = N.xyz / (N.xyx + N.yzz);
2544   weight = clamp((weight - 0.5 * (1.0 - blend)) / max(1e-8, blend), 0.0, 1.0);
2545
2546   /* test for mixes between two textures */
2547   if (N.z < (1.0 - limit) * (N.y + N.x)) {
2548     weight.z = 0.0;
2549     weight.y = 1.0 - weight.x;
2550   }
2551   else if (N.x < (1.0 - limit) * (N.y + N.z)) {
2552     weight.x = 0.0;
2553     weight.z = 1.0 - weight.y;
2554   }
2555   else if (N.y < (1.0 - limit) * (N.x + N.z)) {
2556     weight.y = 0.0;
2557     weight.x = 1.0 - weight.z;
2558   }
2559   else {
2560     /* last case, we have a mix between three */
2561     weight = ((2.0 - limit) * N + (limit - 1.0)) / max(1e-8, blend);
2562   }
2563
2564   color = weight.x * color1 + weight.y * color2 + weight.z * color3;
2565   alpha = color.a;
2566 }
2567
2568 void tex_clip_linear(vec3 co, sampler2D ima, vec4 icolor, out vec4 color, out float alpha)
2569 {
2570   vec2 tex_size = vec2(textureSize(ima, 0).xy);
2571   vec2 minco = min(co.xy, 1.0 - co.xy);
2572   minco = clamp(minco * tex_size + 0.5, 0.0, 1.0);
2573   float fac = minco.x * minco.y;
2574
2575   color = mix(vec4(0.0), icolor, fac);
2576   alpha = color.a;
2577 }
2578
2579 void tex_clip_nearest(vec3 co, sampler2D ima, vec4 icolor, out vec4 color, out float alpha)
2580 {
2581   vec4 minco = vec4(co.xy, 1.0 - co.xy);
2582   color = (any(lessThan(minco, vec4(0.0)))) ? vec4(0.0) : icolor;
2583   alpha = color.a;
2584 }
2585
2586 void tex_clip_cubic(vec3 co, sampler2D ima, vec4 icolor, out vec4 color, out float alpha)
2587 {
2588   vec2 tex_size = vec2(textureSize(ima, 0).xy);
2589
2590   co.xy *= tex_size;
2591   /* texel center */
2592   vec2 tc = floor(co.xy - 0.5) + 0.5;
2593   vec2 w0, w1, w2, w3;
2594   cubic_bspline_coefs(co.xy - tc, w0, w1, w2, w3);
2595
2596   /* TODO Optimize this part. I'm sure there is a smarter way to do that.
2597    * Could do that when sampling? */
2598 #define CLIP_CUBIC_SAMPLE(samp, size) \
2599   (float(all(greaterThan(samp, vec2(-0.5)))) * float(all(lessThan(ivec2(samp), itex_size))))
2600   ivec2 itex_size = textureSize(ima, 0).xy;
2601   float fac;
2602   fac = CLIP_CUBIC_SAMPLE(tc + vec2(-1.0, -1.0), itex_size) * w0.x * w0.y;
2603   fac += CLIP_CUBIC_SAMPLE(tc + vec2(0.0, -1.0), itex_size) * w1.x * w0.y;
2604   fac += CLIP_CUBIC_SAMPLE(tc + vec2(1.0, -1.0), itex_size) * w2.x * w0.y;
2605   fac += CLIP_CUBIC_SAMPLE(tc + vec2(2.0, -1.0), itex_size) * w3.x * w0.y;
2606
2607   fac += CLIP_CUBIC_SAMPLE(tc + vec2(-1.0, 0.0), itex_size) * w0.x * w1.y;
2608   fac += CLIP_CUBIC_SAMPLE(tc + vec2(0.0, 0.0), itex_size) * w1.x * w1.y;
2609   fac += CLIP_CUBIC_SAMPLE(tc + vec2(1.0, 0.0), itex_size) * w2.x * w1.y;
2610   fac += CLIP_CUBIC_SAMPLE(tc + vec2(2.0, 0.0), itex_size) * w3.x * w1.y;
2611
2612   fac += CLIP_CUBIC_SAMPLE(tc + vec2(-1.0, 1.0), itex_size) * w0.x * w2.y;
2613   fac += CLIP_CUBIC_SAMPLE(tc + vec2(0.0, 1.0), itex_size) * w1.x * w2.y;
2614   fac += CLIP_CUBIC_SAMPLE(tc + vec2(1.0, 1.0), itex_size) * w2.x * w2.y;
2615   fac += CLIP_CUBIC_SAMPLE(tc + vec2(2.0, 1.0), itex_size) * w3.x * w2.y;
2616
2617   fac += CLIP_CUBIC_SAMPLE(tc + vec2(-1.0, 2.0), itex_size) * w0.x * w3.y;
2618   fac += CLIP_CUBIC_SAMPLE(tc + vec2(0.0, 2.0), itex_size) * w1.x * w3.y;
2619   fac += CLIP_CUBIC_SAMPLE(tc + vec2(1.0, 2.0), itex_size) * w2.x * w3.y;
2620   fac += CLIP_CUBIC_SAMPLE(tc + vec2(2.0, 2.0), itex_size) * w3.x * w3.y;
2621 #undef CLIP_CUBIC_SAMPLE
2622
2623   color = mix(vec4(0.0), icolor, fac);
2624   alpha = color.a;
2625 }
2626
2627 void tex_clip_smart(vec3 co, sampler2D ima, vec4 icolor, out vec4 color, out float alpha)
2628 {
2629   tex_clip_cubic(co, ima, icolor, color, alpha);
2630 }
2631
2632 void node_tex_image_empty(vec3 co, out vec4 color, out float alpha)
2633 {
2634   color = vec4(0.0);
2635   alpha = 0.0;
2636 }
2637
2638 void node_tex_magic(
2639     vec3 co, float scale, float distortion, float depth, out vec4 color, out float fac)
2640 {
2641   vec3 p = co * scale;
2642   float x = sin((p.x + p.y + p.z) * 5.0);
2643   float y = cos((-p.x + p.y - p.z) * 5.0);
2644   float z = -cos((-p.x - p.y + p.z) * 5.0);
2645
2646   if (depth > 0) {
2647     x *= distortion;
2648     y *= distortion;
2649     z *= distortion;
2650     y = -cos(x - y + z);
2651     y *= distortion;
2652     if (depth > 1) {
2653       x = cos(x - y - z);
2654       x *= distortion;
2655       if (depth > 2) {
2656         z = sin(-x - y - z);
2657         z *= distortion;
2658         if (depth > 3) {
2659           x = -cos(-x + y - z);
2660           x *= distortion;
2661           if (depth > 4) {
2662             y = -sin(-x + y + z);
2663             y *= distortion;
2664             if (depth > 5) {
2665               y = -cos(-x + y + z);
2666               y *= distortion;
2667               if (depth > 6) {
2668                 x = cos(x + y + z);
2669                 x *= distortion;
2670                 if (depth > 7) {
2671                   z = sin(x + y - z);
2672                   z *= distortion;
2673                   if (depth > 8) {
2674                     x = -cos(-x - y + z);
2675                     x *= distortion;
2676                     if (depth > 9) {
2677                       y = -sin(x - y + z);
2678                       y *= distortion;
2679                     }
2680                   }
2681                 }
2682               }
2683             }
2684           }
2685         }
2686       }
2687     }
2688   }
2689   if (distortion != 0.0) {
2690     distortion *= 2.0;
2691     x /= distortion;
2692     y /= distortion;
2693     z /= distortion;
2694   }
2695
2696   color = vec4(0.5 - x, 0.5 - y, 0.5 - z, 1.0);
2697   fac = (color.x + color.y + color.z) / 3.0;
2698 }
2699
2700 float noise_fade(float t)
2701 {
2702   return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
2703 }
2704
2705 float noise_scale3(float result)
2706 {
2707   return 0.9820 * result;
2708 }
2709
2710 float noise_nerp(float t, float a, float b)
2711 {
2712   return (1.0 - t) * a + t * b;
2713 }
2714
2715 float noise_grad(uint hash, float x, float y, float z)
2716 {
2717   uint h = hash & 15u;
2718   float u = h < 8u ? x : y;
2719   float vt = ((h == 12u) || (h == 14u)) ? x : z;
2720   float v = h < 4u ? y : vt;
2721   return (((h & 1u) != 0u) ? -u : u) + (((h & 2u) != 0u) ? -v : v);
2722 }
2723
2724 float noise_perlin(float x, float y, float z)
2725 {
2726   int X;
2727   float fx = floorfrac(x, X);
2728   int Y;
2729   float fy = floorfrac(y, Y);
2730   int Z;
2731   float fz = floorfrac(z, Z);
2732
2733   float u = noise_fade(fx);
2734   float v = noise_fade(fy);
2735   float w = noise_fade(fz);
2736
2737   float noise_u[2], noise_v[2];
2738
2739   noise_u[0] = noise_nerp(
2740       u, noise_grad(hash(X, Y, Z), fx, fy, fz), noise_grad(hash(X + 1, Y, Z), fx - 1.0, fy, fz));
2741
2742   noise_u[1] = noise_nerp(u,
2743                           noise_grad(hash(X, Y + 1, Z), fx, fy - 1.0, fz),
2744                           noise_grad(hash(X + 1, Y + 1, Z), fx - 1.0, fy - 1.0, fz));
2745
2746   noise_v[0] = noise_nerp(v, noise_u[0], noise_u[1]);
2747
2748   noise_u[0] = noise_nerp(u,
2749                           noise_grad(hash(X, Y, Z + 1), fx, fy, fz - 1.0),
2750                           noise_grad(hash(X + 1, Y, Z + 1), fx - 1.0, fy, fz - 1.0));
2751
2752   noise_u[1] = noise_nerp(u,
2753                           noise_grad(hash(X, Y + 1, Z + 1), fx, fy - 1.0, fz - 1.0),
2754                           noise_grad(hash(X + 1, Y + 1, Z + 1), fx - 1.0, fy - 1.0, fz - 1.0));
2755
2756   noise_v[1] = noise_nerp(v, noise_u[0], noise_u[1]);
2757
2758   float r = noise_scale3(noise_nerp(w, noise_v[0], noise_v[1]));
2759
2760   return (isinf(r)) ? 0.0 : r;
2761 }
2762
2763 float noise(vec3 p)
2764 {
2765   return 0.5 * noise_perlin(p.x, p.y, p.z) + 0.5;
2766 }
2767
2768 float snoise(vec3 p)
2769 {
2770   return noise_perlin(p.x, p.y, p.z);
2771 }
2772
2773 float noise_turbulence(vec3 p, float octaves, int hard)
2774 {
2775   float fscale = 1.0;
2776   float amp = 1.0;
2777   float sum = 0.0;
2778   octaves = clamp(octaves, 0.0, 16.0);
2779   int n = int(octaves);
2780   for (int i = 0; i <= n; i++) {
2781     float t = noise(fscale * p);
2782     if (hard != 0) {
2783       t = abs(2.0 * t - 1.0);
2784     }
2785     sum += t * amp;
2786     amp *= 0.5;
2787     fscale *= 2.0;
2788   }
2789   float rmd = octaves - floor(octaves);
2790   if (rmd != 0.0) {
2791     float t = noise(fscale * p);
2792     if (hard != 0) {
2793       t = abs(2.0 * t - 1.0);
2794     }
2795     float sum2 = sum + t * amp;
2796     sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
2797     sum2 *= (float(1 << (n + 1)) / float((1 << (n + 2)) - 1));
2798     return (1.0 - rmd) * sum + rmd * sum2;
2799   }
2800   else {
2801     sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
2802     return sum;
2803   }
2804 }
2805
2806 void node_tex_noise(
2807     vec3 co, float scale, float detail, float distortion, out vec4 color, out float fac)
2808 {
2809   vec3 p = co * scale;
2810   int hard = 0;
2811   if (distortion != 0.0) {
2812     vec3 r, offset = vec3(13.5, 13.5, 13.5);
2813     r.x = noise(p + offset) * distortion;
2814     r.y = noise(p) * distortion;
2815     r.z = noise(p - offset) * distortion;
2816     p += r;
2817   }
2818
2819   fac = noise_turbulence(p, detail, hard);
2820   color = vec4(fac,
2821                noise_turbulence(vec3(p.y, p.x, p.z), detail, hard),
2822                noise_turbulence(vec3(p.y, p.z, p.x), detail, hard),
2823                1);
2824 }
2825
2826 /* Musgrave fBm
2827  *
2828  * H: fractal increment parameter
2829  * lacunarity: gap between successive frequencies
2830  * octaves: number of frequencies in the fBm
2831  *
2832  * from "Texturing and Modelling: A procedural approach"
2833  */
2834
2835 float noise_musgrave_fBm(vec3 p, float H, float lacunarity, float octaves)
2836 {
2837   float rmd;
2838   float value = 0.0;
2839   float pwr = 1.0;
2840   float pwHL = pow(lacunarity, -H);
2841
2842   for (int i = 0; i < int(octaves); i++) {
2843     value += snoise(p) * pwr;
2844     pwr *= pwHL;
2845     p *= lacunarity;
2846   }
2847
2848   rmd = octaves - floor(octaves);
2849   if (rmd != 0.0)
2850     value += rmd * snoise(p) * pwr;
2851
2852   return value;
2853 }
2854
2855 /* Musgrave Multifractal
2856  *
2857  * H: highest fractal dimension
2858  * lacunarity: gap between successive frequencies
2859  * octaves: number of frequencies in the fBm
2860  */
2861
2862 float noise_musgrave_multi_fractal(vec3 p, float H, float lacunarity, float octaves)
2863 {
2864   float rmd;
2865   float value = 1.0;
2866   float pwr = 1.0;
2867   float pwHL = pow(lacunarity, -H);
2868
2869   for (int i = 0; i < int(octaves); i++) {
2870     value *= (pwr * snoise(p) + 1.0);
2871     pwr *= pwHL;
2872     p *= lacunarity;
2873   }
2874
2875   rmd = octaves - floor(octaves);
2876   if (rmd != 0.0)
2877     value *= (rmd * pwr * snoise(p) + 1.0); /* correct? */
2878
2879   return value;
2880 }
2881
2882 /* Musgrave Heterogeneous Terrain
2883  *
2884  * H: fractal dimension of the roughest area
2885  * lacunarity: gap between successive frequencies
2886  * octaves: number of frequencies in the fBm
2887  * offset: raises the terrain from `sea level'
2888  */
2889
2890 float noise_musgrave_hetero_terrain(vec3 p, float H, float lacunarity, float octaves, float offset)
2891 {
2892   float value, increment, rmd;
2893   float pwHL = pow(lacunarity, -H);
2894   float pwr = pwHL;
2895
2896   /* first unscaled octave of function; later octaves are scaled */
2897   value = offset + snoise(p);
2898   p *= lacunarity;
2899
2900   for (int i = 1; i < int(octaves); i++) {
2901     increment = (snoise(p) + offset) * pwr * value;
2902     value += increment;
2903     pwr *= pwHL;
2904     p *= lacunarity;
2905   }
2906
2907   rmd = octaves - floor(octaves);
2908   if (rmd != 0.0) {
2909     increment = (snoise(p) + offset) * pwr * value;
2910     value += rmd * increment;
2911   }
2912
2913   return value;
2914 }
2915
2916 /* Hybrid Additive/Multiplicative Multifractal Terrain
2917  *
2918  * H: fractal dimension of the roughest area
2919  * lacunarity: gap between successive frequencies
2920  * octaves: number of frequencies in the fBm
2921  * offset: raises the terrain from `sea level'
2922  */
2923
2924 float noise_musgrave_hybrid_multi_fractal(
2925     vec3 p, float H, float lacunarity, float octaves, float offset, float gain)
2926 {
2927   float result, signal, weight, rmd;
2928   float pwHL = pow(lacunarity, -H);
2929   float pwr = pwHL;
2930
2931   result = snoise(p) + offset;
2932   weight = gain * result;
2933   p *= lacunarity;
2934
2935   for (int i = 1; (weight > 0.001f) && (i < int(octaves)); i++) {
2936     if (weight > 1.0)
2937       weight = 1.0;
2938
2939     signal = (snoise(p) + offset) * pwr;
2940     pwr *= pwHL;
2941     result += weight * signal;
2942     weight *= gain * signal;
2943     p *= lacunarity;
2944   }
2945
2946   rmd = octaves - floor(octaves);
2947   if (rmd != 0.0)
2948     result += rmd * ((snoise(p) + offset) * pwr);
2949
2950   return result;
2951 }
2952
2953 /* Ridged Multifractal Terrain
2954  *
2955  * H: fractal dimension of the roughest area
2956  * lacunarity: gap between successive frequencies
2957  * octaves: number of frequencies in the fBm
2958  * offset: raises the terrain from `sea level'
2959  */
2960
2961 float noise_musgrave_ridged_multi_fractal(
2962     vec3 p, float H, float lacunarity, float octaves, float offset, float gain)
2963 {
2964   float result, signal, weight;
2965   float pwHL = pow(lacunarity, -H);
2966   float pwr = pwHL;
2967
2968   signal = offset - abs(snoise(p));
2969   signal *= signal;
2970   result = signal;
2971   weight = 1.0;
2972
2973   for (int i = 1; i < int(octaves); i++) {
2974     p *= lacunarity;
2975     weight = clamp(signal * gain, 0.0, 1.0);
2976     signal = offset - abs(snoise(p));
2977     signal *= signal;
2978     signal *= weight;
2979     result += signal * pwr;
2980     pwr *= pwHL;
2981   }
2982
2983   return result;
2984 }
2985
2986 float svm_musgrave(int type,
2987                    float dimension,
2988                    float lacunarity,
2989                    float octaves,
2990                    float offset,
2991                    float intensity,
2992                    float gain,
2993                    vec3 p)
2994 {
2995   if (type == 0 /* NODE_MUSGRAVE_MULTIFRACTAL */)
2996     return intensity * noise_musgrave_multi_fractal(p, dimension, lacunarity, octaves);
2997   else if (type == 1 /* NODE_MUSGRAVE_FBM */)
2998     return intensity * noise_musgrave_fBm(p, dimension, lacunarity, octaves);
2999   else if (type == 2 /* NODE_MUSGRAVE_HYBRID_MULTIFRACTAL */)
3000     return intensity *
3001            noise_musgrave_hybrid_multi_fractal(p, dimension, lacunarity, octaves, offset, gain);
3002   else if (type == 3 /* NODE_MUSGRAVE_RIDGED_MULTIFRACTAL */)
3003     return intensity *
3004            noise_musgrave_ridged_multi_fractal(p, dimension, lacunarity, octaves, offset, gain);
3005   else if (type == 4 /* NODE_MUSGRAVE_HETERO_TERRAIN */)
3006     return intensity * noise_musgrave_hetero_terrain(p, dimension, lacunarity, octaves, offset);
3007   return 0.0;
3008 }
3009
3010 void node_tex_musgrave(vec3 co,
3011                        float scale,
3012                        float detail,
3013                        float dimension,
3014                        float lacunarity,
3015                        float offset,
3016                        float gain,
3017                        float type,
3018                        out vec4 color,
3019                        out float fac)
3020 {
3021   fac = svm_musgrave(int(type), dimension, lacunarity, detail, offset, 1.0, gain, co *scale);
3022
3023   color = vec4(fac, fac, fac, 1.0);
3024 }
3025
3026 void node_tex_sky(vec3 co, out vec4 color)
3027 {
3028   color = vec4(1.0);
3029 }
3030
3031 void node_tex_voronoi(vec3 co,
3032                       float scale,
3033                       float exponent,
3034                       float coloring,
3035                       float metric,
3036                       float feature,
3037                       out vec4 color,
3038                       out float fac)
3039 {
3040   vec3 p = co * scale;
3041   int xx, yy, zz, xi, yi, zi;
3042   vec4 da = vec4(1e10);
3043   vec3 pa[4] = vec3[4](vec3(0.0), vec3(0.0), vec3(0.0), vec3(0.0));
3044
3045   xi = floor_to_int(p[0]);
3046   yi = floor_to_int(p[1]);
3047   zi = floor_to_int(p[2]);
3048
3049   for (xx = xi - 1; xx <= xi + 1; xx++) {
3050     for (yy = yi - 1; yy <= yi + 1; yy++) {
3051       for (zz = zi - 1; zz <= zi + 1; zz++) {
3052         vec3 ip = vec3(xx, yy, zz);
3053         vec3 vp = cellnoise_color(ip);
3054         vec3 pd = p - (vp + ip);
3055
3056         float d = 0.0;
3057         if (metric == 0.0) { /* SHD_VORONOI_DISTANCE 0 */
3058           d = dot(pd, pd);
3059         }
3060         else if (metric == 1.0) { /* SHD_VORONOI_MANHATTAN 1 */
3061           d = abs(pd[0]) + abs(pd[1]) + abs(pd[2]);
3062         }
3063         else if (metric == 2.0) { /* SHD_VORONOI_CHEBYCHEV 2 */
3064           d = max(abs(pd[0]), max(abs(pd[1]), abs(pd[2])));
3065         }
3066         else if (metric == 3.0) { /* SHD_VORONOI_MINKOWSKI 3 */
3067           d = pow(pow(abs(pd[0]), exponent) + pow(abs(pd[1]), exponent) +
3068                       pow(abs(pd[2]), exponent),
3069                   1.0 / exponent);
3070         }
3071
3072         vp += vec3(xx, yy, zz);
3073         if (d < da[0]) {
3074           da.yzw = da.xyz;
3075           da[0] = d;
3076
3077           pa[3] = pa[2];
3078           pa[2] = pa[1];
3079           pa[1] = pa[0];
3080           pa[0] = vp;
3081         }
3082         else if (d < da[1]) {
3083           da.zw = da.yz;
3084           da[1] = d;
3085
3086           pa[3] = pa[2];
3087           pa[2] = pa[1];
3088           pa[1] = vp;
3089         }
3090         else if (d < da[2]) {
3091           da[3] = da[2];
3092           da[2] = d;
3093
3094           pa[3] = pa[2];
3095           pa[2] = vp;
3096         }
3097         else if (d < da[3]) {
3098           da[3] = d;
3099           pa[3] = vp;
3100         }
3101       }
3102     }
3103   }
3104
3105   if (coloring == 0.0) {
3106     /* Intensity output */
3107     if (feature == 0.0) { /* F1 */
3108       fac = abs(da[0]);
3109     }
3110     else if (feature == 1.0) { /* F2 */
3111       fac = abs(da[1]);
3112     }
3113     else if (feature == 2.0) { /* F3 */
3114       fac = abs(da[2]);
3115     }
3116     else if (feature == 3.0) { /* F4 */
3117       fac = abs(da[3]);
3118     }
3119     else if (feature == 4.0) { /* F2F1 */
3120       fac = abs(da[1] - da[0]);
3121     }
3122     color = vec4(fac, fac, fac, 1.0);
3123   }
3124   else {
3125     /* Color output */
3126     vec3 col = vec3(fac, fac, fac);
3127     if (feature == 0.0) { /* F1 */
3128       col = pa[0];
3129     }
3130     else if (feature == 1.0) { /* F2 */
3131       col = pa[1];
3132     }
3133     else if (feature == 2.0) { /* F3 */
3134       col = pa[2];
3135     }
3136     else if (feature == 3.0) { /* F4 */
3137       col = pa[3];
3138     }
3139     else if (feature == 4.0) { /* F2F1 */
3140       col = abs(pa[1] - pa[0]);
3141     }
3142
3143     color = vec4(cellnoise_color(col), 1.0);
3144     fac = (color.x + color.y + color.z) * (1.0 / 3.0);
3145   }
3146 }
3147
3148 float calc_wave(
3149     vec3 p, float distortion, float detail, float detail_scale, int wave_type, int wave_profile)
3150 {
3151   float n;
3152
3153   if (wave_type == 0) /* type bands */
3154     n = (p.x + p.y + p.z) * 10.0;
3155   else /* type rings */
3156     n = length(p) * 20.0;
3157
3158   if (distortion != 0.0)
3159     n += distortion * noise_turbulence(p * detail_scale, detail, 0);
3160
3161   if (wave_profile == 0) { /* profile sin */
3162     return 0.5 + 0.5 * sin(n);
3163   }
3164   else { /* profile saw */
3165     n /= 2.0 * M_PI;
3166     n -= int(n);
3167     return (n < 0.0) ? n + 1.0 : n;
3168   }
3169 }
3170
3171 void node_tex_wave(vec3 co,
3172                    float scale,
3173                    float distortion,
3174                    float detail,
3175                    float detail_scale,
3176                    float wave_type,
3177                    float wave_profile,
3178                    out vec4 color,
3179                    out float fac)
3180 {
3181   float f;
3182   f = calc_wave(co * scale, distortion, detail, detail_scale, int(wave_type), int(wave_profile));
3183
3184   color = vec4(f, f, f, 1.0);
3185   fac = f;
3186 }
3187
3188 /* light path */
3189
3190 void node_light_path(out float is_camera_ray,
3191                      out float is_shadow_ray,
3192                      out float is_diffuse_ray,
3193                      out float is_glossy_ray,
3194                      out float is_singular_ray,
3195                      out float is_reflection_ray,
3196                      out float is_transmission_ray,
3197                      out float ray_length,
3198                      out float ray_depth,
3199                      out float diffuse_depth,
3200                      out float glossy_depth,
3201                      out float transparent_depth,
3202                      out float transmission_depth)
3203 {
3204   /* Supported. */
3205   is_camera_ray = (rayType == EEVEE_RAY_CAMERA) ? 1.0 : 0.0;
3206   is_shadow_ray = (rayType == EEVEE_RAY_SHADOW) ? 1.0 : 0.0;
3207   is_diffuse_ray = (rayType == EEVEE_RAY_DIFFUSE) ? 1.0 : 0.0;
3208   is_glossy_ray = (rayType == EEVEE_RAY_GLOSSY) ? 1.0 : 0.0;
3209   /* Kind of supported. */
3210   is_singular_ray = is_glossy_ray;
3211   is_reflection_ray = is_glossy_ray;
3212   is_transmission_ray = is_glossy_ray;
3213   ray_depth = rayDepth;
3214   diffuse_depth = (is_diffuse_ray == 1.0) ? rayDepth : 0.0;
3215   glossy_depth = (is_glossy_ray == 1.0) ? rayDepth : 0.0;
3216   transmission_depth = (is_transmission_ray == 1.0) ? glossy_depth : 0.0;
3217   /* Not supported. */
3218   ray_length = 1.0;
3219   transparent_depth = 0.0;
3220 }
3221
3222 void node_light_falloff(
3223     float strength, float tsmooth, out float quadratic, out float linear, out float constant)
3224 {
3225   quadratic = strength;
3226   linear = strength;
3227   constant = strength;
3228 }
3229
3230 void node_object_info(mat4 obmat,
3231                       vec4 info,
3232                       float mat_index,
3233                       out vec3 location,
3234                       out float object_index,
3235                       out float material_index,
3236                       out float random)
3237 {
3238   location = obmat[3].xyz;
3239   object_index = info.x;
3240   material_index = mat_index;
3241   random = info.z;
3242 }
3243
3244 void node_normal_map(vec4 info, vec4 tangent, vec3 normal, vec3 texnormal, out vec3 outnormal)
3245 {
3246   if (all(equal(tangent, vec4(0.0, 0.0, 0.0, 1.0)))) {
3247     outnormal = normal;
3248     return;
3249   }
3250   tangent *= (gl_FrontFacing ? 1.0 : -1.0);
3251   vec3 B = tangent.w * cross(normal, tangent.xyz) * info.w;
3252
3253   outnormal = texnormal.x * tangent.xyz + texnormal.y * B + texnormal.z * normal;
3254   outnormal = normalize(outnormal);
3255 }
3256
3257 void node_bump(
3258     float strength, float dist, float height, vec3 N, vec3 surf_pos, float invert, out vec3 result)
3259 {
3260   N = mat3(ViewMatrix) * normalize(N);
3261   dist *= invert;
3262
3263   vec3 dPdx = dFdx(surf_pos);
3264   vec3 dPdy = dFdy(surf_pos);
3265
3266   /* Get surface tangents from normal. */
3267   vec3 Rx = cross(dPdy, N);
3268   vec3 Ry = cross(N, dPdx);
3269
3270   /* Compute surface gradient and determinant. */
3271   float det = dot(dPdx, Rx);
3272
3273   float dHdx = dFdx(height);
3274   float dHdy = dFdy(height);
3275   vec3 surfgrad = dHdx * Rx + dHdy * Ry;
3276
3277   strength = max(strength, 0.0);
3278
3279   result = normalize(abs(det) * N - dist * sign(det) * surfgrad);
3280   result = normalize(mix(N, result, strength));
3281
3282   result = mat3(ViewMatrixInverse) * result;
3283 }
3284
3285 void node_bevel(float radius, vec3 N, out vec3 result)
3286 {
3287   result = N;
3288 }
3289
3290 void node_hair_info(out float is_strand,
3291                     out float intercept,
3292                     out float thickness,
3293                     out vec3 tangent,
3294                     out float random)
3295 {
3296 #ifdef HAIR_SHADER
3297   is_strand = 1.0;
3298   intercept = hairTime;
3299   thickness = hairThickness;
3300   tangent = normalize(hairTangent);
3301   random = wang_hash_noise(
3302       uint(hairStrandID)); /* TODO: could be precomputed per strand instead. */
3303 #else
3304   is_strand = 0.0;
3305   intercept = 0.0;
3306   thickness = 0.0;
3307   tangent = vec3(1.0);
3308   random = 0.0;
3309 #endif
3310 }
3311
3312 void node_displacement_object(
3313     float height, float midlevel, float scale, vec3 N, mat4 obmat, out vec3 result)
3314 {
3315   N = (vec4(N, 0.0) * obmat).xyz;
3316   result = (height - midlevel) * scale * normalize(N);
3317   result = (obmat * vec4(result, 0.0)).xyz;
3318 }
3319
3320 void node_displacement_world(float height, float midlevel, float scale, vec3 N, out vec3 result)
3321 {
3322   result = (height - midlevel) * scale * normalize(N);
3323 }
3324
3325 void node_vector_displacement_tangent(vec4 vector,
3326                                       float midlevel,
3327                                       float scale,
3328                                       vec4 tangent,
3329                                       vec3 normal,
3330                                       mat4 obmat,
3331                                       mat4 viewmat,
3332                                       out vec3 result)
3333 {
3334   /* TODO(fclem) this is broken. revisit latter. */
3335   vec3 N_object = normalize(((vec4(normal, 0.0) * viewmat) * obmat).xyz);
3336   vec3 T_object = normalize(((vec4(tangent.xyz, 0.0) * viewmat) * obmat).xyz);
3337   vec3 B_object = tangent.w * normalize(cross(N_object, T_object));
3338
3339   vec3 offset = (vector.xyz - vec3(midlevel)) * scale;
3340   result = offset.x * T_object + offset.y * N_object + offset.z * B_object;
3341   result = (obmat * vec4(result, 0.0)).xyz;
3342 }
3343
3344 void node_vector_displacement_object(
3345     vec4 vector, float midlevel, float scale, mat4 obmat, out vec3 result)
3346 {
3347   result = (vector.xyz - vec3(midlevel)) * scale;
3348   result = (obmat * vec4(result, 0.0)).xyz;
3349 }
3350
3351 void node_vector_displacement_world(vec4 vector, float midlevel, float scale, out vec3 result)
3352 {
3353   result = (vector.xyz - vec3(midlevel)) * scale;
3354 }
3355
3356 /* output */
3357
3358 void node_output_material(Closure surface, Closure volume, vec3 displacement, out Closure result)
3359 {
3360 #ifdef VOLUMETRICS
3361   result = volume;
3362 #else
3363   result = surface;
3364 #endif
3365 }
3366
3367 uniform float backgroundAlpha;
3368
3369 void node_output_world(Closure surface, Closure volume, out Closure result)
3370 {
3371 #ifndef VOLUMETRICS
3372   result.radiance = surface.radiance * backgroundAlpha;
3373   result.opacity = backgroundAlpha;
3374 #else
3375   result = volume;
3376 #endif /* VOLUMETRICS */
3377 }
3378
3379 #ifndef VOLUMETRICS
3380 /* TODO : clean this ifdef mess */
3381 /* EEVEE output */
3382 void world_normals_get(out vec3 N)
3383 {
3384 #  ifdef HAIR_SHADER
3385   vec3 B = normalize(cross(worldNormal, hairTangent));
3386   float cos_theta;
3387   if (hairThicknessRes == 1) {
3388     vec4 rand = texelFetch(utilTex, ivec3(ivec2(gl_FragCoord.xy) % LUT_SIZE, 2.0), 0);
3389     /* Random cosine normal distribution on the hair surface. */
3390     cos_theta = rand.x * 2.0 - 1.0;
3391   }
3392   else {
3393     /* Shade as a cylinder. */
3394     cos_theta = hairThickTime / hairThickness;
3395   }
3396   float sin_theta = sqrt(max(0.0, 1.0 - cos_theta * cos_theta));
3397   N = normalize(worldNormal * sin_theta + B * cos_theta);
3398 #  else
3399   N = gl_FrontFacing ? worldNormal : -worldNormal;
3400 #  endif
3401 }
3402
3403 void node_eevee_specular(vec4 diffuse,
3404                          vec4 specular,
3405                          float roughness,
3406                          vec4 emissive,
3407                          float transp,
3408                          vec3 normal,
3409                          float clearcoat,
3410                          float clearcoat_roughness,
3411                          vec3 clearcoat_normal,
3412                          float occlusion,
3413                          float ssr_id,
3414                          out Closure result)
3415 {
3416   vec3 out_diff, out_spec, ssr_spec;
3417   eevee_closure_default_clearcoat(normal,
3418                                   diffuse.rgb,
3419                                   specular.rgb,
3420                                   int(ssr_id),
3421                                   roughness,
3422                                   clearcoat_normal,
3423                                   clearcoat * 0.25,
3424                                   clearcoat_roughness,
3425                                   occlusion,
3426                                   out_diff,
3427                                   out_spec,
3428                                   ssr_spec);
3429
3430   vec3 vN = normalize(mat3(ViewMatrix) * normal);
3431   result = CLOSURE_DEFAULT;
3432   result.radiance = out_diff * diffuse.rgb + out_spec + emissive.rgb;
3433   result.opacity = 1.0 - transp;
3434   result.ssr_data = vec4(ssr_spec, roughness);
3435   result.ssr_normal = normal_encode(vN, viewCameraVec);
3436   result.ssr_id = int(ssr_id);
3437 }
3438
3439 void node_shader_to_rgba(Closure cl, out vec4 outcol, out float outalpha)
3440 {
3441   vec4 spec_accum = vec4(0.0);
3442   if (ssrToggle && cl.ssr_id == outputSsrId) {
3443     vec3 V = cameraVec;
3444     vec3 vN = normal_decode(cl.ssr_normal, viewCameraVec);
3445     vec3 N = transform_direction(ViewMatrixInverse, vN);
3446     float roughness = cl.ssr_data.a;
3447     float roughnessSquared = max(1e-3, roughness * roughness);
3448     fallback_cubemap(N, V, worldPosition, viewPosition, roughness, roughnessSquared, spec_accum);
3449   }
3450
3451   outalpha = cl.opacity;
3452   outcol = vec4((spec_accum.rgb * cl.ssr_data.rgb) + cl.radiance, 1.0);
3453
3454 #  ifdef USE_SSS
3455 #    ifdef USE_SSS_ALBEDO
3456   outcol.rgb += cl.sss_data.rgb * cl.sss_albedo;
3457 #    else
3458   outcol.rgb += cl.sss_data.rgb;
3459 #    endif
3460 #  endif
3461 }
3462
3463 #endif /* VOLUMETRICS */