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