Merge branch 'master' into blender2.8
[blender.git] / source / blender / gpu / shaders / gpu_shader_material.glsl
1
2 uniform mat4 ModelMatrix;
3 uniform mat4 ModelViewMatrix;
4 uniform mat4 ModelViewMatrixInverse;
5 uniform mat3 NormalMatrix;
6
7 #ifndef ATTRIB
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(vec3 color, out vec3 normal)
145 {
146         normal.x =  2.0 * ((color.r) - 0.5);
147         normal.y = -2.0 * ((color.g) - 0.5);
148         normal.z =  2.0 * ((color.b) - 0.5);
149 }
150
151 void color_to_normal_new_shading(vec3 color, out vec3 normal)
152 {
153         normal.x =  2.0 * ((color.r) - 0.5);
154         normal.y =  2.0 * ((color.g) - 0.5);
155         normal.z =  2.0 * ((color.b) - 0.5);
156 }
157
158 void color_to_blender_normal_new_shading(vec3 color, out vec3 normal)
159 {
160         normal.x =  2.0 * ((color.r) - 0.5);
161         normal.y = -2.0 * ((color.g) - 0.5);
162         normal.z = -2.0 * ((color.b) - 0.5);
163 }
164 #ifndef M_PI
165 #define M_PI 3.14159265358979323846
166 #endif
167 #ifndef M_1_PI
168 #define M_1_PI 0.318309886183790671538
169 #endif
170
171 /*********** SHADER NODES ***************/
172
173 void particle_info(
174         vec4 sprops, vec4 loc, vec3 vel, vec3 avel,
175         out float index, out float random, out float age,
176         out float life_time, out vec3 location,
177         out float size, out vec3 velocity, out vec3 angular_velocity)
178 {
179         index = sprops.x;
180         random = loc.w;
181         age = sprops.y;
182         life_time = sprops.z;
183         size = sprops.w;
184
185         location = loc.xyz;
186         velocity = vel;
187         angular_velocity = avel;
188 }
189
190 void vect_normalize(vec3 vin, out vec3 vout)
191 {
192         vout = normalize(vin);
193 }
194
195 void direction_transform_m4v3(vec3 vin, mat4 mat, out vec3 vout)
196 {
197         vout = (mat * vec4(vin, 0.0)).xyz;
198 }
199
200 void point_transform_m4v3(vec3 vin, mat4 mat, out vec3 vout)
201 {
202         vout = (mat * vec4(vin, 1.0)).xyz;
203 }
204
205 void point_texco_remap_square(vec3 vin, out vec3 vout)
206 {
207         vout = vec3(vin - vec3(0.5, 0.5, 0.5)) * 2.0;
208 }
209
210 void point_map_to_sphere(vec3 vin, out vec3 vout)
211 {
212         float len = length(vin);
213         float v, u;
214         if (len > 0.0) {
215                 if (vin.x == 0.0 && vin.y == 0.0)
216                         u = 0.0;
217                 else
218                         u = (1.0 - atan(vin.x, vin.y) / M_PI) / 2.0;
219
220                 v = 1.0 - acos(vin.z / len) / M_PI;
221         }
222         else
223                 v = u = 0.0;
224
225         vout = vec3(u, v, 0.0);
226 }
227
228 void point_map_to_tube(vec3 vin, out vec3 vout)
229 {
230         float u, v;
231         v = (vin.z + 1.0) * 0.5;
232         float len = sqrt(vin.x * vin.x + vin.y * vin[1]);
233         if (len > 0.0)
234                 u = (1.0 - (atan(vin.x / len, vin.y / len) / M_PI)) * 0.5;
235         else
236                 v = u = 0.0;
237
238         vout = vec3(u, v, 0.0);
239 }
240
241 void mapping(vec3 vec, mat4 mat, vec3 minvec, vec3 maxvec, float domin, float domax, out vec3 outvec)
242 {
243         outvec = (mat * vec4(vec, 1.0)).xyz;
244         if (domin == 1.0)
245                 outvec = max(outvec, minvec);
246         if (domax == 1.0)
247                 outvec = min(outvec, maxvec);
248 }
249
250 void camera(vec3 co, out vec3 outview, out float outdepth, out float outdist)
251 {
252         outdepth = abs(co.z);
253         outdist = length(co);
254         outview = normalize(co);
255 }
256
257 void math_add(float val1, float val2, out float outval)
258 {
259         outval = val1 + val2;
260 }
261
262 void math_subtract(float val1, float val2, out float outval)
263 {
264         outval = val1 - val2;
265 }
266
267 void math_multiply(float val1, float val2, out float outval)
268 {
269         outval = val1 * val2;
270 }
271
272 void math_divide(float val1, float val2, out float outval)
273 {
274         if (val2 == 0.0)
275                 outval = 0.0;
276         else
277                 outval = val1 / val2;
278 }
279
280 void math_sine(float val, out float outval)
281 {
282         outval = sin(val);
283 }
284
285 void math_cosine(float val, out float outval)
286 {
287         outval = cos(val);
288 }
289
290 void math_tangent(float val, out float outval)
291 {
292         outval = tan(val);
293 }
294
295 void math_asin(float val, out float outval)
296 {
297         if (val <= 1.0 && val >= -1.0)
298                 outval = asin(val);
299         else
300                 outval = 0.0;
301 }
302
303 void math_acos(float val, out float outval)
304 {
305         if (val <= 1.0 && val >= -1.0)
306                 outval = acos(val);
307         else
308                 outval = 0.0;
309 }
310
311 void math_atan(float val, out float outval)
312 {
313         outval = atan(val);
314 }
315
316 void math_pow(float val1, float val2, out float outval)
317 {
318         if (val1 >= 0.0) {
319                 outval = compatible_pow(val1, val2);
320         }
321         else {
322                 float val2_mod_1 = mod(abs(val2), 1.0);
323
324                 if (val2_mod_1 > 0.999 || val2_mod_1 < 0.001)
325                         outval = compatible_pow(val1, floor(val2 + 0.5));
326                 else
327                         outval = 0.0;
328         }
329 }
330
331 void math_log(float val1, float val2, out float outval)
332 {
333         if (val1 > 0.0  && val2 > 0.0)
334                 outval = log2(val1) / log2(val2);
335         else
336                 outval = 0.0;
337 }
338
339 void math_max(float val1, float val2, out float outval)
340 {
341         outval = max(val1, val2);
342 }
343
344 void math_min(float val1, float val2, out float outval)
345 {
346         outval = min(val1, val2);
347 }
348
349 void math_round(float val, out float outval)
350 {
351         outval = floor(val + 0.5);
352 }
353
354 void math_less_than(float val1, float val2, out float outval)
355 {
356         if (val1 < val2)
357                 outval = 1.0;
358         else
359                 outval = 0.0;
360 }
361
362 void math_greater_than(float val1, float val2, out float outval)
363 {
364         if (val1 > val2)
365                 outval = 1.0;
366         else
367                 outval = 0.0;
368 }
369
370 void math_modulo(float val1, float val2, out float outval)
371 {
372         if (val2 == 0.0)
373                 outval = 0.0;
374         else
375                 outval = mod(val1, val2);
376
377         /* change sign to match C convention, mod in GLSL will take absolute for negative numbers,
378          * see https://www.opengl.org/sdk/docs/man/html/mod.xhtml */
379         outval = (val1 > 0.0) ? outval : outval - val2;
380 }
381
382 void math_abs(float val1, out float outval)
383 {
384         outval = abs(val1);
385 }
386
387 void math_atan2(float val1, float val2, out float outval)
388 {
389         outval = atan(val1, val2);
390 }
391
392 void math_floor(float val, out float outval)
393 {
394         outval = floor(val);
395 }
396
397 void math_ceil(float val, out float outval)
398 {
399         outval = ceil(val);
400 }
401
402 void math_fract(float val, out float outval)
403 {
404         outval = val - floor(val);
405 }
406
407 void math_sqrt(float val, out float outval)
408 {
409         if (val > 0.0)
410                 outval = sqrt(val);
411         else
412                 outval = 0.0;
413 }
414
415 void squeeze(float val, float width, float center, out float outval)
416 {
417         outval = 1.0 / (1.0 + pow(2.71828183, -((val - center) * width)));
418 }
419
420 void vec_math_add(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_sub(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
427 {
428         outvec = v1 - v2;
429         outval = (abs(outvec[0]) + abs(outvec[1]) + abs(outvec[2])) * 0.333333;
430 }
431
432 void vec_math_average(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
433 {
434         outvec = v1 + v2;
435         outval = length(outvec);
436         outvec = normalize(outvec);
437 }
438 void vec_math_mix(float strength, vec3 v1, vec3 v2, out vec3 outvec)
439 {
440         outvec = strength * v1 + (1 - strength) * v2;
441 }
442
443 void vec_math_dot(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
444 {
445         outvec = vec3(0);
446         outval = dot(v1, v2);
447 }
448
449 void vec_math_cross(vec3 v1, vec3 v2, out vec3 outvec, out float outval)
450 {
451         outvec = cross(v1, v2);
452         outval = length(outvec);
453         outvec /= outval;
454 }
455
456 void vec_math_normalize(vec3 v, out vec3 outvec, out float outval)
457 {
458         outval = length(v);
459         outvec = normalize(v);
460 }
461
462 void vec_math_negate(vec3 v, out vec3 outv)
463 {
464         outv = -v;
465 }
466
467 void invert_z(vec3 v, out vec3 outv)
468 {
469         v.z = -v.z;
470         outv = v;
471 }
472
473 void normal(vec3 dir, vec3 nor, out vec3 outnor, out float outdot)
474 {
475         outnor = nor;
476         outdot = -dot(dir, nor);
477 }
478
479 void normal_new_shading(vec3 dir, vec3 nor, out vec3 outnor, out float outdot)
480 {
481         outnor = normalize(nor);
482         outdot = dot(normalize(dir), nor);
483 }
484
485 void curves_vec(float fac, vec3 vec, sampler2D curvemap, out vec3 outvec)
486 {
487         outvec.x = texture(curvemap, vec2((vec.x + 1.0) * 0.5, 0.0)).x;
488         outvec.y = texture(curvemap, vec2((vec.y + 1.0) * 0.5, 0.0)).y;
489         outvec.z = texture(curvemap, vec2((vec.z + 1.0) * 0.5, 0.0)).z;
490
491         if (fac != 1.0)
492                 outvec = (outvec * fac) + (vec * (1.0 - fac));
493
494 }
495
496 void curves_rgb(float fac, vec4 col, sampler2D curvemap, out vec4 outcol)
497 {
498         outcol.r = texture(curvemap, vec2(texture(curvemap, vec2(col.r, 0.0)).a, 0.0)).r;
499         outcol.g = texture(curvemap, vec2(texture(curvemap, vec2(col.g, 0.0)).a, 0.0)).g;
500         outcol.b = texture(curvemap, vec2(texture(curvemap, vec2(col.b, 0.0)).a, 0.0)).b;
501
502         if (fac != 1.0)
503                 outcol = (outcol * fac) + (col * (1.0 - fac));
504
505         outcol.a = col.a;
506 }
507
508 void set_value(float val, out float outval)
509 {
510         outval = val;
511 }
512
513 void set_rgb(vec3 col, out vec3 outcol)
514 {
515         outcol = col;
516 }
517
518 void set_rgba(vec4 col, out vec4 outcol)
519 {
520         outcol = col;
521 }
522
523 void set_value_zero(out float outval)
524 {
525         outval = 0.0;
526 }
527
528 void set_value_one(out float outval)
529 {
530         outval = 1.0;
531 }
532
533 void set_rgb_zero(out vec3 outval)
534 {
535         outval = vec3(0.0);
536 }
537
538 void set_rgb_one(out vec3 outval)
539 {
540         outval = vec3(1.0);
541 }
542
543 void set_rgba_zero(out vec4 outval)
544 {
545         outval = vec4(0.0);
546 }
547
548 void set_rgba_one(out vec4 outval)
549 {
550         outval = vec4(1.0);
551 }
552
553 void brightness_contrast(vec4 col, float brightness, float contrast, out vec4 outcol)
554 {
555         float a = 1.0 + contrast;
556         float b = brightness - contrast * 0.5;
557
558         outcol.r = max(a * col.r + b, 0.0);
559         outcol.g = max(a * col.g + b, 0.0);
560         outcol.b = max(a * col.b + b, 0.0);
561         outcol.a = col.a;
562 }
563
564 void mix_blend(float fac, vec4 col1, vec4 col2, out vec4 outcol)
565 {
566         fac = clamp(fac, 0.0, 1.0);
567         outcol = mix(col1, col2, fac);
568         outcol.a = col1.a;
569 }
570
571 void mix_add(float fac, vec4 col1, vec4 col2, out vec4 outcol)
572 {
573         fac = clamp(fac, 0.0, 1.0);
574         outcol = mix(col1, col1 + col2, fac);
575         outcol.a = col1.a;
576 }
577
578 void mix_mult(float fac, vec4 col1, vec4 col2, out vec4 outcol)
579 {
580         fac = clamp(fac, 0.0, 1.0);
581         outcol = mix(col1, col1 * col2, fac);
582         outcol.a = col1.a;
583 }
584
585 void mix_screen(float fac, vec4 col1, vec4 col2, out vec4 outcol)
586 {
587         fac = clamp(fac, 0.0, 1.0);
588         float facm = 1.0 - fac;
589
590         outcol = vec4(1.0) - (vec4(facm) + fac * (vec4(1.0) - col2)) * (vec4(1.0) - col1);
591         outcol.a = col1.a;
592 }
593
594 void mix_overlay(float fac, vec4 col1, vec4 col2, out vec4 outcol)
595 {
596         fac = clamp(fac, 0.0, 1.0);
597         float facm = 1.0 - fac;
598
599         outcol = col1;
600
601         if (outcol.r < 0.5)
602                 outcol.r *= facm + 2.0 * fac * col2.r;
603         else
604                 outcol.r = 1.0 - (facm + 2.0 * fac * (1.0 - col2.r)) * (1.0 - outcol.r);
605
606         if (outcol.g < 0.5)
607                 outcol.g *= facm + 2.0 * fac * col2.g;
608         else
609                 outcol.g = 1.0 - (facm + 2.0 * fac * (1.0 - col2.g)) * (1.0 - outcol.g);
610
611         if (outcol.b < 0.5)
612                 outcol.b *= facm + 2.0 * fac * col2.b;
613         else
614                 outcol.b = 1.0 - (facm + 2.0 * fac * (1.0 - col2.b)) * (1.0 - outcol.b);
615 }
616
617 void mix_sub(float fac, vec4 col1, vec4 col2, out vec4 outcol)
618 {
619         fac = clamp(fac, 0.0, 1.0);
620         outcol = mix(col1, col1 - col2, fac);
621         outcol.a = col1.a;
622 }
623
624 void mix_div(float fac, vec4 col1, vec4 col2, out vec4 outcol)
625 {
626         fac = clamp(fac, 0.0, 1.0);
627         float facm = 1.0 - fac;
628
629         outcol = col1;
630
631         if (col2.r != 0.0) outcol.r = facm * outcol.r + fac * outcol.r / col2.r;
632         if (col2.g != 0.0) outcol.g = facm * outcol.g + fac * outcol.g / col2.g;
633         if (col2.b != 0.0) outcol.b = facm * outcol.b + fac * outcol.b / col2.b;
634 }
635
636 void mix_diff(float fac, vec4 col1, vec4 col2, out vec4 outcol)
637 {
638         fac = clamp(fac, 0.0, 1.0);
639         outcol = mix(col1, abs(col1 - col2), fac);
640         outcol.a = col1.a;
641 }
642
643 void mix_dark(float fac, vec4 col1, vec4 col2, out vec4 outcol)
644 {
645         fac = clamp(fac, 0.0, 1.0);
646         outcol.rgb = min(col1.rgb, col2.rgb * fac);
647         outcol.a = col1.a;
648 }
649
650 void mix_light(float fac, vec4 col1, vec4 col2, out vec4 outcol)
651 {
652         fac = clamp(fac, 0.0, 1.0);
653         outcol.rgb = max(col1.rgb, col2.rgb * fac);
654         outcol.a = col1.a;
655 }
656
657 void mix_dodge(float fac, vec4 col1, vec4 col2, out vec4 outcol)
658 {
659         fac = clamp(fac, 0.0, 1.0);
660         outcol = col1;
661
662         if (outcol.r != 0.0) {
663                 float tmp = 1.0 - fac * col2.r;
664                 if (tmp <= 0.0)
665                         outcol.r = 1.0;
666                 else if ((tmp = outcol.r / tmp) > 1.0)
667                         outcol.r = 1.0;
668                 else
669                         outcol.r = tmp;
670         }
671         if (outcol.g != 0.0) {
672                 float tmp = 1.0 - fac * col2.g;
673                 if (tmp <= 0.0)
674                         outcol.g = 1.0;
675                 else if ((tmp = outcol.g / tmp) > 1.0)
676                         outcol.g = 1.0;
677                 else
678                         outcol.g = tmp;
679         }
680         if (outcol.b != 0.0) {
681                 float tmp = 1.0 - fac * col2.b;
682                 if (tmp <= 0.0)
683                         outcol.b = 1.0;
684                 else if ((tmp = outcol.b / tmp) > 1.0)
685                         outcol.b = 1.0;
686                 else
687                         outcol.b = tmp;
688         }
689 }
690
691 void mix_burn(float fac, vec4 col1, vec4 col2, out vec4 outcol)
692 {
693         fac = clamp(fac, 0.0, 1.0);
694         float tmp, facm = 1.0 - fac;
695
696         outcol = col1;
697
698         tmp = facm + fac * col2.r;
699         if (tmp <= 0.0)
700                 outcol.r = 0.0;
701         else if ((tmp = (1.0 - (1.0 - outcol.r) / tmp)) < 0.0)
702                 outcol.r = 0.0;
703         else if (tmp > 1.0)
704                 outcol.r = 1.0;
705         else
706                 outcol.r = tmp;
707
708         tmp = facm + fac * col2.g;
709         if (tmp <= 0.0)
710                 outcol.g = 0.0;
711         else if ((tmp = (1.0 - (1.0 - outcol.g) / tmp)) < 0.0)
712                 outcol.g = 0.0;
713         else if (tmp > 1.0)
714                 outcol.g = 1.0;
715         else
716                 outcol.g = tmp;
717
718         tmp = facm + fac * col2.b;
719         if (tmp <= 0.0)
720                 outcol.b = 0.0;
721         else if ((tmp = (1.0 - (1.0 - outcol.b) / tmp)) < 0.0)
722                 outcol.b = 0.0;
723         else if (tmp > 1.0)
724                 outcol.b = 1.0;
725         else
726                 outcol.b = tmp;
727 }
728
729 void mix_hue(float fac, vec4 col1, vec4 col2, out vec4 outcol)
730 {
731         fac = clamp(fac, 0.0, 1.0);
732         float facm = 1.0 - fac;
733
734         outcol = col1;
735
736         vec4 hsv, hsv2, tmp;
737         rgb_to_hsv(col2, hsv2);
738
739         if (hsv2.y != 0.0) {
740                 rgb_to_hsv(outcol, hsv);
741                 hsv.x = hsv2.x;
742                 hsv_to_rgb(hsv, tmp);
743
744                 outcol = mix(outcol, tmp, fac);
745                 outcol.a = col1.a;
746         }
747 }
748
749 void mix_sat(float fac, vec4 col1, vec4 col2, out vec4 outcol)
750 {
751         fac = clamp(fac, 0.0, 1.0);
752         float facm = 1.0 - fac;
753
754         outcol = col1;
755
756         vec4 hsv, hsv2;
757         rgb_to_hsv(outcol, hsv);
758
759         if (hsv.y != 0.0) {
760                 rgb_to_hsv(col2, hsv2);
761
762                 hsv.y = facm * hsv.y + fac * hsv2.y;
763                 hsv_to_rgb(hsv, outcol);
764         }
765 }
766
767 void mix_val(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         vec4 hsv, hsv2;
773         rgb_to_hsv(col1, hsv);
774         rgb_to_hsv(col2, hsv2);
775
776         hsv.z = facm * hsv.z + fac * hsv2.z;
777         hsv_to_rgb(hsv, outcol);
778 }
779
780 void mix_color(float fac, vec4 col1, vec4 col2, out vec4 outcol)
781 {
782         fac = clamp(fac, 0.0, 1.0);
783         float facm = 1.0 - fac;
784
785         outcol = col1;
786
787         vec4 hsv, hsv2, tmp;
788         rgb_to_hsv(col2, hsv2);
789
790         if (hsv2.y != 0.0) {
791                 rgb_to_hsv(outcol, hsv);
792                 hsv.x = hsv2.x;
793                 hsv.y = hsv2.y;
794                 hsv_to_rgb(hsv, tmp);
795
796                 outcol = mix(outcol, tmp, fac);
797                 outcol.a = col1.a;
798         }
799 }
800
801 void mix_soft(float fac, vec4 col1, vec4 col2, out vec4 outcol)
802 {
803         fac = clamp(fac, 0.0, 1.0);
804         float facm = 1.0 - fac;
805
806         vec4 one = vec4(1.0);
807         vec4 scr = one - (one - col2) * (one - col1);
808         outcol = facm * col1 + fac * ((one - col1) * col2 * col1 + col1 * scr);
809 }
810
811 void mix_linear(float fac, vec4 col1, vec4 col2, out vec4 outcol)
812 {
813         fac = clamp(fac, 0.0, 1.0);
814
815         outcol = col1 + fac * (2.0 * (col2 - vec4(0.5)));
816 }
817
818 void valtorgb(float fac, sampler2D colormap, out vec4 outcol, out float outalpha)
819 {
820         outcol = texture(colormap, vec2(fac, 0.0));
821         outalpha = outcol.a;
822 }
823
824 void rgbtobw(vec4 color, out float outval)
825 {
826         vec3 factors = vec3(0.2126, 0.7152, 0.0722);
827         outval = dot(color.rgb, factors);
828 }
829
830 void invert(float fac, vec4 col, out vec4 outcol)
831 {
832         outcol.xyz = mix(col.xyz, vec3(1.0) - col.xyz, fac);
833         outcol.w = col.w;
834 }
835
836 void clamp_vec3(vec3 vec, vec3 min, vec3 max, out vec3 out_vec)
837 {
838         out_vec = clamp(vec, min, max);
839 }
840
841 void clamp_val(float value, float min, float max, out float out_value)
842 {
843         out_value = clamp(value, min, max);
844 }
845
846 void hue_sat(float hue, float sat, float value, float fac, vec4 col, out vec4 outcol)
847 {
848         vec4 hsv;
849
850         rgb_to_hsv(col, hsv);
851
852         hsv[0] += (hue - 0.5);
853         if (hsv[0] > 1.0) hsv[0] -= 1.0; else if (hsv[0] < 0.0) hsv[0] += 1.0;
854         hsv[1] *= sat;
855         if (hsv[1] > 1.0) hsv[1] = 1.0; else if (hsv[1] < 0.0) hsv[1] = 0.0;
856         hsv[2] *= value;
857         if (hsv[2] > 1.0) hsv[2] = 1.0; else if (hsv[2] < 0.0) hsv[2] = 0.0;
858
859         hsv_to_rgb(hsv, outcol);
860
861         outcol = mix(col, outcol, fac);
862 }
863
864 void separate_rgb(vec4 col, out float r, out float g, out float b)
865 {
866         r = col.r;
867         g = col.g;
868         b = col.b;
869 }
870
871 void combine_rgb(float r, float g, float b, out vec4 col)
872 {
873         col = vec4(r, g, b, 1.0);
874 }
875
876 void separate_xyz(vec3 vec, out float x, out float y, out float z)
877 {
878         x = vec.r;
879         y = vec.g;
880         z = vec.b;
881 }
882
883 void combine_xyz(float x, float y, float z, out vec3 vec)
884 {
885         vec = vec3(x, y, z);
886 }
887
888 void separate_hsv(vec4 col, out float h, out float s, out float v)
889 {
890         vec4 hsv;
891
892         rgb_to_hsv(col, hsv);
893         h = hsv[0];
894         s = hsv[1];
895         v = hsv[2];
896 }
897
898 void combine_hsv(float h, float s, float v, out vec4 col)
899 {
900         hsv_to_rgb(vec4(h, s, v, 1.0), col);
901 }
902
903 void output_node(vec4 rgb, float alpha, out vec4 outrgb)
904 {
905         outrgb = vec4(rgb.rgb, alpha);
906 }
907
908 /*********** TEXTURES ***************/
909
910 void texco_norm(vec3 normal, out vec3 outnormal)
911 {
912         /* corresponds to shi->orn, which is negated so cancels
913            out blender normal negation */
914         outnormal = normalize(normal);
915 }
916
917 vec3 mtex_2d_mapping(vec3 vec)
918 {
919         return vec3(vec.xy * 0.5 + vec2(0.5), vec.z);
920 }
921
922 /** helper method to extract the upper left 3x3 matrix from a 4x4 matrix */
923 mat3 to_mat3(mat4 m4)
924 {
925         mat3 m3;
926         m3[0] = m4[0].xyz;
927         m3[1] = m4[1].xyz;
928         m3[2] = m4[2].xyz;
929         return m3;
930 }
931
932 /*********** NEW SHADER UTILITIES **************/
933
934 float fresnel_dielectric_0(float eta)
935 {
936         /* compute fresnel reflactance at normal incidence => cosi = 1.0 */
937         float A = (eta - 1.0) / (eta + 1.0);
938
939         return A * A;
940 }
941
942 float fresnel_dielectric_cos(float cosi, float eta)
943 {
944         /* compute fresnel reflectance without explicitly computing
945          * the refracted direction */
946         float c = abs(cosi);
947         float g = eta * eta - 1.0 + c * c;
948         float result;
949
950         if (g > 0.0) {
951                 g = sqrt(g);
952                 float A = (g - c) / (g + c);
953                 float B = (c * (g + c) - 1.0) / (c * (g - c) + 1.0);
954                 result = 0.5 * A * A * (1.0 + B * B);
955         }
956         else {
957                 result = 1.0;  /* TIR (no refracted component) */
958         }
959
960         return result;
961 }
962
963 float fresnel_dielectric(vec3 Incoming, vec3 Normal, float eta)
964 {
965         /* compute fresnel reflectance without explicitly computing
966          * the refracted direction */
967         return fresnel_dielectric_cos(dot(Incoming, Normal), eta);
968 }
969
970 float hypot(float x, float y)
971 {
972         return sqrt(x * x + y * y);
973 }
974
975 void generated_from_orco(vec3 orco, out vec3 generated)
976 {
977 #ifdef VOLUMETRICS
978 #ifdef MESH_SHADER
979         generated = volumeObjectLocalCoord;
980 #else
981         generated = worldPosition;
982 #endif
983 #else
984         generated = orco;
985 #endif
986 }
987
988 int floor_to_int(float x)
989 {
990         return int(floor(x));
991 }
992
993 int quick_floor(float x)
994 {
995         return int(x) - ((x < 0) ? 1 : 0);
996 }
997
998 float integer_noise(int n)
999 {
1000         int nn;
1001         n = (n + 1013) & 0x7fffffff;
1002         n = (n >> 13) ^ n;
1003         nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
1004         return 0.5 * (float(nn) / 1073741824.0);
1005 }
1006
1007 uint hash(uint kx, uint ky, uint kz)
1008 {
1009 #define rot(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
1010 #define final(a, b, c) \
1011 { \
1012         c ^= b; c -= rot(b, 14); \
1013         a ^= c; a -= rot(c, 11); \
1014         b ^= a; b -= rot(a, 25); \
1015         c ^= b; c -= rot(b, 16); \
1016         a ^= c; a -= rot(c, 4);  \
1017         b ^= a; b -= rot(a, 14); \
1018         c ^= b; c -= rot(b, 24); \
1019 }
1020         // now hash the data!
1021         uint a, b, c, len = 3u;
1022         a = b = c = 0xdeadbeefu + (len << 2u) + 13u;
1023
1024         c += kz;
1025         b += ky;
1026         a += kx;
1027         final (a, b, c);
1028
1029         return c;
1030 #undef rot
1031 #undef final
1032 }
1033
1034 uint hash(int kx, int ky, int kz)
1035 {
1036         return hash(uint(kx), uint(ky), uint(kz));
1037 }
1038
1039 float bits_to_01(uint bits)
1040 {
1041         return (float(bits) / 4294967295.0);
1042 }
1043
1044 float cellnoise(vec3 p)
1045 {
1046         int ix = quick_floor(p.x);
1047         int iy = quick_floor(p.y);
1048         int iz = quick_floor(p.z);
1049
1050         return bits_to_01(hash(uint(ix), uint(iy), uint(iz)));
1051 }
1052
1053 vec3 cellnoise_color(vec3 p)
1054 {
1055         float r = cellnoise(p);
1056         float g = cellnoise(vec3(p.y, p.x, p.z));
1057         float b = cellnoise(vec3(p.y, p.z, p.x));
1058
1059         return vec3(r, g, b);
1060 }
1061
1062 float floorfrac(float x, out int i)
1063 {
1064         i = floor_to_int(x);
1065         return x - i;
1066 }
1067
1068 /* bsdfs */
1069
1070 void convert_metallic_to_specular_tinted(
1071         vec3 basecol, float metallic, float specular_fac, float specular_tint,
1072         out vec3 diffuse, out vec3 f0)
1073 {
1074         vec3 dielectric = vec3(0.034) * specular_fac * 2.0;
1075         float lum = dot(basecol, vec3(0.3, 0.6, 0.1)); /* luminance approx. */
1076         vec3 tint = lum > 0 ? basecol / lum : vec3(1.0); /* normalize lum. to isolate hue+sat */
1077         f0 = mix(dielectric * mix(vec3(1.0), tint, specular_tint), basecol, metallic);
1078         diffuse = mix(basecol, vec3(0.0), metallic);
1079 }
1080
1081 #ifndef VOLUMETRICS
1082 void node_bsdf_diffuse(vec4 color, float roughness, vec3 N, out Closure result)
1083 {
1084         vec3 vN = normalize(mat3(ViewMatrix) * N);
1085         result = CLOSURE_DEFAULT;
1086         result.ssr_normal = normal_encode(vN, viewCameraVec);
1087         eevee_closure_diffuse(N, color.rgb, 1.0, result.radiance);
1088         result.radiance *= color.rgb;
1089 }
1090
1091 void node_bsdf_glossy(vec4 color, float roughness, vec3 N, float ssr_id, out Closure result)
1092 {
1093         vec3 out_spec, ssr_spec;
1094         eevee_closure_glossy(N, vec3(1.0), int(ssr_id), roughness, 1.0, out_spec, ssr_spec);
1095         vec3 vN = normalize(mat3(ViewMatrix) * N);
1096         result = CLOSURE_DEFAULT;
1097         result.radiance = out_spec * color.rgb;
1098         result.ssr_data = vec4(ssr_spec * color.rgb, roughness);
1099         result.ssr_normal = normal_encode(vN, viewCameraVec);
1100         result.ssr_id = int(ssr_id);
1101 }
1102
1103 void node_bsdf_anisotropic(
1104         vec4 color, float roughness, float anisotropy, float rotation, vec3 N, vec3 T,
1105         out Closure result)
1106 {
1107         node_bsdf_diffuse(color, 0.0, N, result);
1108 }
1109
1110 void node_bsdf_glass(vec4 color, float roughness, float ior, vec3 N, float ssr_id, out Closure result)
1111 {
1112         vec3 out_spec, out_refr, ssr_spec;
1113         vec3 refr_color = (refractionDepth > 0.0) ? color.rgb * color.rgb : color.rgb; /* Simulate 2 transmission event */
1114         eevee_closure_glass(N, vec3(1.0), int(ssr_id), roughness, 1.0, ior, out_spec, out_refr, ssr_spec);
1115         out_refr *= refr_color;
1116         out_spec *= color.rgb;
1117         float fresnel = F_eta(ior, dot(N, cameraVec));
1118         vec3 vN = normalize(mat3(ViewMatrix) * N);
1119         result = CLOSURE_DEFAULT;
1120         result.radiance = mix(out_refr, out_spec, fresnel);
1121         result.ssr_data = vec4(ssr_spec * color.rgb * fresnel, roughness);
1122         result.ssr_normal = normal_encode(vN, viewCameraVec);
1123         result.ssr_id = int(ssr_id);
1124 }
1125
1126 void node_bsdf_toon(vec4 color, float size, float tsmooth, vec3 N, out Closure result)
1127 {
1128         node_bsdf_diffuse(color, 0.0, N, result);
1129 }
1130
1131 void node_bsdf_principled_clearcoat(vec4 base_color, float subsurface, vec3 subsurface_radius, vec4 subsurface_color, float metallic, float specular,
1132         float specular_tint, float roughness, float anisotropic, float anisotropic_rotation, float sheen, float sheen_tint, float clearcoat,
1133         float clearcoat_roughness, float ior, float transmission, float transmission_roughness, vec3 N, vec3 CN, vec3 T, vec3 I, float ssr_id,
1134         float sss_id, vec3 sss_scale, out Closure result)
1135 {
1136         metallic = saturate(metallic);
1137         transmission = saturate(transmission);
1138
1139         vec3 diffuse, f0, out_diff, out_spec, out_trans, out_refr, ssr_spec;
1140         convert_metallic_to_specular_tinted(base_color.rgb, metallic, specular, specular_tint, diffuse, f0);
1141
1142         transmission *= 1.0 - metallic;
1143         subsurface *= 1.0 - metallic;
1144
1145         clearcoat *= 0.25;
1146         clearcoat *= 1.0 - transmission;
1147
1148 #ifdef USE_SSS
1149         diffuse = mix(diffuse, vec3(0.0), subsurface);
1150 #else
1151         diffuse = mix(diffuse, subsurface_color.rgb, subsurface);
1152 #endif
1153         f0 = mix(f0, vec3(1.0), transmission);
1154
1155         float sss_scalef = dot(sss_scale, vec3(1.0 / 3.0));
1156         eevee_closure_principled(N, diffuse, f0, int(ssr_id), roughness,
1157                                  CN, clearcoat, clearcoat_roughness, 1.0, sss_scalef, ior,
1158                                  out_diff, out_trans, out_spec, out_refr, ssr_spec);
1159
1160         vec3 refr_color = base_color.rgb;
1161         refr_color *= (refractionDepth > 0.0) ? refr_color : vec3(1.0); /* Simulate 2 transmission event */
1162
1163         float fresnel = F_eta(ior, dot(N, cameraVec));
1164         vec3 refr_spec_color = base_color.rgb * fresnel;
1165         /* This bit maybe innacurate. */
1166         out_refr = out_refr * refr_color * (1.0 - fresnel) + out_spec * refr_spec_color;
1167
1168         ssr_spec = mix(ssr_spec, refr_spec_color, transmission);
1169
1170         vec3 vN = normalize(mat3(ViewMatrix) * N);
1171         result = CLOSURE_DEFAULT;
1172         result.radiance = out_spec + out_diff * diffuse;
1173         result.radiance = mix(result.radiance, out_refr, transmission);
1174         result.ssr_data = vec4(ssr_spec, roughness);
1175         result.ssr_normal = normal_encode(vN, viewCameraVec);
1176         result.ssr_id = int(ssr_id);
1177 #ifdef USE_SSS
1178         result.sss_data.a = sss_scalef;
1179         result.sss_data.rgb = out_diff + out_trans;
1180 #ifdef USE_SSS_ALBEDO
1181         result.sss_albedo.rgb = mix(vec3(0.0), subsurface_color.rgb, subsurface);
1182 #else
1183         result.sss_data.rgb *= mix(vec3(0.0), subsurface_color.rgb, subsurface);
1184 #endif
1185         result.sss_data.rgb *= (1.0 - transmission);
1186 #endif
1187 }
1188
1189 void node_bsdf_translucent(vec4 color, vec3 N, out Closure result)
1190 {
1191         node_bsdf_diffuse(color, 0.0, -N, result);
1192 }
1193
1194 void node_bsdf_transparent(vec4 color, out Closure result)
1195 {
1196         /* this isn't right */
1197         result = CLOSURE_DEFAULT;
1198         result.radiance = vec3(0.0);
1199         result.opacity = 0.0;
1200         result.ssr_id = TRANSPARENT_CLOSURE_FLAG;
1201 }
1202
1203 void node_bsdf_velvet(vec4 color, float sigma, vec3 N, out Closure result)
1204 {
1205         node_bsdf_diffuse(color, 0.0, N, result);
1206 }
1207
1208 void node_subsurface_scattering(
1209         vec4 color, float scale, vec3 radius, float sharpen, float texture_blur, vec3 N, float sss_id,
1210         out Closure result)
1211 {
1212 #if defined(USE_SSS)
1213         vec3 out_diff, out_trans;
1214         vec3 vN = normalize(mat3(ViewMatrix) * N);
1215         result = CLOSURE_DEFAULT;
1216         result.ssr_data = vec4(0.0);
1217         result.ssr_normal = normal_encode(vN, viewCameraVec);
1218         result.ssr_id = -1;
1219         result.sss_data.a = scale;
1220         eevee_closure_subsurface(N, color.rgb, 1.0, scale, out_diff, out_trans);
1221         result.sss_data.rgb = out_diff + out_trans;
1222 #ifdef USE_SSS_ALBEDO
1223         /* Not perfect for texture_blur not exaclty equal to 0.0 or 1.0. */
1224         result.sss_albedo.rgb = mix(color.rgb, vec3(1.0), texture_blur);
1225         result.sss_data.rgb *= mix(vec3(1.0), color.rgb, texture_blur);
1226 #else
1227         result.sss_data.rgb *= color.rgb;
1228 #endif
1229 #else
1230         node_bsdf_diffuse(color, 0.0, N, result);
1231 #endif
1232 }
1233
1234 void node_bsdf_refraction(vec4 color, float roughness, float ior, vec3 N, out Closure result)
1235 {
1236         vec3 out_refr;
1237         color.rgb *= (refractionDepth > 0.0) ? color.rgb : vec3(1.0); /* Simulate 2 absorption event. */
1238         eevee_closure_refraction(N, roughness, ior, out_refr);
1239         vec3 vN = normalize(mat3(ViewMatrix) * N);
1240         result = CLOSURE_DEFAULT;
1241         result.ssr_normal = normal_encode(vN, viewCameraVec);
1242         result.radiance = out_refr * color.rgb;
1243         result.ssr_id = REFRACT_CLOSURE_FLAG;
1244 }
1245
1246 void node_ambient_occlusion(vec4 color, float distance, vec3 normal, out vec4 result_color, out float result_ao)
1247 {
1248         vec3 bent_normal;
1249         vec4 rand = texelFetch(utilTex, ivec3(ivec2(gl_FragCoord.xy) % LUT_SIZE, 2.0), 0);
1250         result_ao = occlusion_compute(normalize(normal), viewPosition, 1.0, rand, bent_normal);
1251         result_color = result_ao * color;
1252 }
1253
1254 #endif /* VOLUMETRICS */
1255
1256 /* emission */
1257
1258 void node_emission(vec4 color, float strength, vec3 vN, out Closure result)
1259 {
1260 #ifndef VOLUMETRICS
1261         color *= strength;
1262         result = CLOSURE_DEFAULT;
1263         result.radiance = color.rgb;
1264         result.opacity = color.a;
1265         result.ssr_normal = normal_encode(vN, viewCameraVec);
1266 #else
1267         result = Closure(vec3(0.0), vec3(0.0), color.rgb * strength, 0.0);
1268 #endif
1269 }
1270
1271 /* background */
1272
1273 void background_transform_to_world(vec3 viewvec, out vec3 worldvec)
1274 {
1275         vec4 v = (ProjectionMatrix[3][3] == 0.0) ? vec4(viewvec, 1.0) : vec4(0.0, 0.0, 1.0, 1.0);
1276         vec4 co_homogenous = (ProjectionMatrixInverse * v);
1277
1278         vec4 co = vec4(co_homogenous.xyz / co_homogenous.w, 0.0);
1279 #if defined(WORLD_BACKGROUND) || defined(PROBE_CAPTURE)
1280         worldvec = (ViewMatrixInverse * co).xyz;
1281 #else
1282         worldvec = (ModelViewMatrixInverse * co).xyz;
1283 #endif
1284 }
1285
1286 void node_background(vec4 color, float strength, out Closure result)
1287 {
1288 #ifndef VOLUMETRICS
1289         color *= strength;
1290         result = CLOSURE_DEFAULT;
1291         result.radiance = color.rgb;
1292         result.opacity = color.a;
1293 #else
1294         result = CLOSURE_DEFAULT;
1295 #endif
1296 }
1297
1298 /* volumes */
1299
1300 void node_volume_scatter(vec4 color, float density, float anisotropy, out Closure result)
1301 {
1302 #ifdef VOLUMETRICS
1303         result = Closure(vec3(0.0), color.rgb * density, vec3(0.0), anisotropy);
1304 #else
1305         result = CLOSURE_DEFAULT;
1306 #endif
1307 }
1308
1309 void node_volume_absorption(vec4 color, float density, out Closure result)
1310 {
1311 #ifdef VOLUMETRICS
1312         result = Closure((1.0 - color.rgb) * density, vec3(0.0), vec3(0.0), 0.0);
1313 #else
1314         result = CLOSURE_DEFAULT;
1315 #endif
1316 }
1317
1318 void node_blackbody(float temperature, sampler2D spectrummap, out vec4 color)
1319 {
1320     if(temperature >= 12000.0) {
1321         color = vec4(0.826270103, 0.994478524, 1.56626022, 1.0);
1322     }
1323     else if(temperature < 965.0) {
1324         color = vec4(4.70366907, 0.0, 0.0, 1.0);
1325     }
1326         else {
1327                 float t = (temperature - 965.0) / (12000.0 - 965.0);
1328                 color = vec4(texture(spectrummap, vec2(t, 0.0)).rgb, 1.0);
1329         }
1330 }
1331
1332 void node_volume_principled(
1333         vec4 color,
1334         float density,
1335         float anisotropy,
1336         vec4 absorption_color,
1337         float emission_strength,
1338         vec4 emission_color,
1339         float blackbody_intensity,
1340         vec4 blackbody_tint,
1341         float temperature,
1342         float density_attribute,
1343         vec4 color_attribute,
1344         float temperature_attribute,
1345         sampler2D spectrummap,
1346         out Closure result)
1347 {
1348 #ifdef VOLUMETRICS
1349         vec3 absorption_coeff = vec3(0.0);
1350         vec3 scatter_coeff = vec3(0.0);
1351         vec3 emission_coeff = vec3(0.0);
1352
1353         /* Compute density. */
1354         density = max(density, 0.0);
1355
1356         if(density > 1e-5) {
1357                 density = max(density * density_attribute, 0.0);
1358         }
1359
1360         if(density > 1e-5) {
1361                 /* Compute scattering and absorption coefficients. */
1362                 vec3 scatter_color = color.rgb * color_attribute.rgb;
1363
1364                 scatter_coeff = scatter_color * density;
1365                 absorption_color.rgb = sqrt(max(absorption_color.rgb, 0.0));
1366                 absorption_coeff = max(1.0 - scatter_color, 0.0) * max(1.0 - absorption_color.rgb, 0.0) * density;
1367         }
1368
1369         /* Compute emission. */
1370         emission_strength = max(emission_strength, 0.0);
1371
1372         if(emission_strength > 1e-5) {
1373                 emission_coeff += emission_strength * emission_color.rgb;
1374         }
1375
1376         if(blackbody_intensity > 1e-3) {
1377                 /* Add temperature from attribute. */
1378                 float T = max(temperature * max(temperature_attribute, 0.0), 0.0);
1379
1380                 /* Stefan-Boltzman law. */
1381                 float T4 = (T * T) * (T * T);
1382                 float sigma = 5.670373e-8 * 1e-6 / M_PI;
1383                 float intensity = sigma * mix(1.0, T4, blackbody_intensity);
1384
1385                 if(intensity > 1e-5) {
1386                         vec4 bb;
1387                         node_blackbody(T, spectrummap, bb);
1388                         emission_coeff += bb.rgb * blackbody_tint.rgb * intensity;
1389                 }
1390         }
1391
1392         result = Closure(absorption_coeff, scatter_coeff, emission_coeff, anisotropy);
1393 #else
1394         result = CLOSURE_DEFAULT;
1395 #endif
1396 }
1397
1398 /* closures */
1399
1400 void node_mix_shader(float fac, Closure shader1, Closure shader2, out Closure shader)
1401 {
1402         shader = closure_mix(shader1, shader2, fac);
1403 }
1404
1405 void node_add_shader(Closure shader1, Closure shader2, out Closure shader)
1406 {
1407         shader = closure_add(shader1, shader2);
1408 }
1409
1410 /* fresnel */
1411
1412 void node_fresnel(float ior, vec3 N, vec3 I, out float result)
1413 {
1414         /* handle perspective/orthographic */
1415         vec3 I_view = (ProjectionMatrix[3][3] == 0.0) ? normalize(I) : vec3(0.0, 0.0, -1.0);
1416
1417         float eta = max(ior, 0.00001);
1418         result = fresnel_dielectric(I_view, N, (gl_FrontFacing) ? eta : 1.0 / eta);
1419 }
1420
1421 /* layer_weight */
1422
1423 void node_layer_weight(float blend, vec3 N, vec3 I, out float fresnel, out float facing)
1424 {
1425         /* fresnel */
1426         float eta = max(1.0 - blend, 0.00001);
1427         vec3 I_view = (ProjectionMatrix[3][3] == 0.0) ? normalize(I) : vec3(0.0, 0.0, -1.0);
1428
1429         fresnel = fresnel_dielectric(I_view, N, (gl_FrontFacing) ? 1.0 / eta : eta);
1430
1431         /* facing */
1432         facing = abs(dot(I_view, N));
1433         if (blend != 0.5) {
1434                 blend = clamp(blend, 0.0, 0.99999);
1435                 blend = (blend < 0.5) ? 2.0 * blend : 0.5 / (1.0 - blend);
1436                 facing = pow(facing, blend);
1437         }
1438         facing = 1.0 - facing;
1439 }
1440
1441 /* gamma */
1442
1443 void node_gamma(vec4 col, float gamma, out vec4 outcol)
1444 {
1445         outcol = col;
1446
1447         if (col.r > 0.0)
1448                 outcol.r = compatible_pow(col.r, gamma);
1449         if (col.g > 0.0)
1450                 outcol.g = compatible_pow(col.g, gamma);
1451         if (col.b > 0.0)
1452                 outcol.b = compatible_pow(col.b, gamma);
1453 }
1454
1455 /* geometry */
1456
1457 void node_attribute_volume_density(sampler3D tex, out vec4 outcol, out vec3 outvec, out float outf)
1458 {
1459 #if defined(MESH_SHADER) && defined(VOLUMETRICS)
1460         vec3 cos = volumeObjectLocalCoord;
1461 #else
1462         vec3 cos = vec3(0.0);
1463 #endif
1464         outvec = texture(tex, cos).aaa;
1465         outcol = vec4(outvec, 1.0);
1466         outf = dot(vec3(1.0 / 3.0), outvec);
1467 }
1468
1469 void node_attribute_volume_color(sampler3D tex, out vec4 outcol, out vec3 outvec, out float outf)
1470 {
1471 #if defined(MESH_SHADER) && defined(VOLUMETRICS)
1472         vec3 cos = volumeObjectLocalCoord;
1473 #else
1474         vec3 cos = vec3(0.0);
1475 #endif
1476
1477         vec4 value = texture(tex, cos).rgba;
1478         /* Density is premultiplied for interpolation, divide it out here. */
1479         if (value.a > 1e-8)
1480                 value.rgb /= value.a;
1481
1482         outvec = value.rgb;
1483         outcol = vec4(outvec, 1.0);
1484         outf = dot(vec3(1.0 / 3.0), outvec);
1485 }
1486
1487 void node_attribute_volume_flame(sampler3D tex, out vec4 outcol, out vec3 outvec, out float outf)
1488 {
1489 #if defined(MESH_SHADER) && defined(VOLUMETRICS)
1490         vec3 cos = volumeObjectLocalCoord;
1491 #else
1492         vec3 cos = vec3(0.0);
1493 #endif
1494         outf = texture(tex, cos).r;
1495         outvec = vec3(outf, outf, outf);
1496         outcol = vec4(outf, outf, outf, 1.0);
1497 }
1498
1499 void node_attribute_volume_temperature(sampler3D tex, vec2 temperature, out vec4 outcol, out vec3 outvec, out float outf)
1500 {
1501 #if defined(MESH_SHADER) && defined(VOLUMETRICS)
1502         vec3 cos = volumeObjectLocalCoord;
1503 #else
1504         vec3 cos = vec3(0.0);
1505 #endif
1506         float flame = texture(tex, cos).r;
1507
1508         outf = (flame > 0.01) ? temperature.x + flame * (temperature.y - temperature.x): 0.0;
1509         outvec = vec3(outf, outf, outf);
1510         outcol = vec4(outf, outf, outf, 1.0);
1511 }
1512
1513 void node_attribute(vec3 attr, out vec4 outcol, out vec3 outvec, out float outf)
1514 {
1515         outcol = vec4(attr, 1.0);
1516         outvec = attr;
1517         outf =  dot(vec3(1.0 / 3.0), attr);
1518 }
1519
1520 void node_uvmap(vec3 attr_uv, out vec3 outvec)
1521 {
1522         outvec = attr_uv;
1523 }
1524
1525 void tangent_orco_x(vec3 orco_in, out vec3 orco_out)
1526 {
1527         orco_out = vec3(0.0, (orco_in.z - 0.5) * -0.5, (orco_in.y - 0.5) * 0.5);
1528 }
1529
1530 void tangent_orco_y(vec3 orco_in, out vec3 orco_out)
1531 {
1532         orco_out = vec3((orco_in.z - 0.5) * -0.5, 0.0, (orco_in.x - 0.5) * 0.5);
1533 }
1534
1535 void tangent_orco_z(vec3 orco_in, out vec3 orco_out)
1536 {
1537         orco_out = vec3((orco_in.y - 0.5) * -0.5, (orco_in.x - 0.5) * 0.5, 0.0);
1538 }
1539
1540 void node_tangentmap(vec4 attr_tangent, mat4 toworld, out vec3 tangent)
1541 {
1542         tangent = (toworld * vec4(attr_tangent.xyz, 0.0)).xyz;
1543 }
1544
1545 void node_tangent(vec3 N, vec3 orco, mat4 objmat, mat4 toworld, out vec3 T)
1546 {
1547         N = (toworld * vec4(N, 0.0)).xyz;
1548         T = (objmat * vec4(orco, 0.0)).xyz;
1549         T = cross(N, normalize(cross(T, N)));
1550 }
1551
1552 void node_geometry(
1553         vec3 I, vec3 N, vec3 orco, mat4 objmat, mat4 toworld,
1554         out vec3 position, out vec3 normal, out vec3 tangent,
1555         out vec3 true_normal, out vec3 incoming, out vec3 parametric,
1556         out float backfacing, out float pointiness)
1557 {
1558         position = worldPosition;
1559         normal = (toworld * vec4(N, 0.0)).xyz;
1560         tangent_orco_z(orco, orco);
1561         node_tangent(N, orco, objmat, toworld, tangent);
1562         true_normal = normal;
1563
1564         /* handle perspective/orthographic */
1565         vec3 I_view = (ProjectionMatrix[3][3] == 0.0) ? normalize(I) : vec3(0.0, 0.0, -1.0);
1566         incoming = -(toworld * vec4(I_view, 0.0)).xyz;
1567
1568         parametric = vec3(0.0);
1569         backfacing = (gl_FrontFacing) ? 0.0 : 1.0;
1570         pointiness = 0.5;
1571 }
1572
1573 void node_tex_coord(
1574         vec3 I, vec3 N, mat4 viewinvmat, mat4 obinvmat, vec4 camerafac,
1575         vec3 attr_orco, vec3 attr_uv,
1576         out vec3 generated, out vec3 normal, out vec3 uv, out vec3 object,
1577         out vec3 camera, out vec3 window, out vec3 reflection)
1578 {
1579         generated = attr_orco;
1580         normal = normalize((obinvmat * (viewinvmat * vec4(N, 0.0))).xyz);
1581         uv = attr_uv;
1582         object = (obinvmat * (viewinvmat * vec4(I, 1.0))).xyz;
1583         camera = vec3(I.xy, -I.z);
1584         vec4 projvec = ProjectionMatrix * vec4(I, 1.0);
1585         window = vec3(mtex_2d_mapping(projvec.xyz / projvec.w).xy * camerafac.xy + camerafac.zw, 0.0);
1586
1587         vec3 shade_I = (ProjectionMatrix[3][3] == 0.0) ? normalize(I) : vec3(0.0, 0.0, -1.0);
1588         vec3 view_reflection = reflect(shade_I, normalize(N));
1589         reflection = (viewinvmat * vec4(view_reflection, 0.0)).xyz;
1590 }
1591
1592 void node_tex_coord_background(
1593         vec3 I, vec3 N, mat4 viewinvmat, mat4 obinvmat, vec4 camerafac,
1594         vec3 attr_orco, vec3 attr_uv,
1595         out vec3 generated, out vec3 normal, out vec3 uv, out vec3 object,
1596         out vec3 camera, out vec3 window, out vec3 reflection)
1597 {
1598         vec4 v = (ProjectionMatrix[3][3] == 0.0) ? vec4(I, 1.0) : vec4(0.0, 0.0, 1.0, 1.0);
1599         vec4 co_homogenous = (ProjectionMatrixInverse * v);
1600
1601         vec4 co = vec4(co_homogenous.xyz / co_homogenous.w, 0.0);
1602
1603         co = normalize(co);
1604
1605 #if defined(WORLD_BACKGROUND) || defined(PROBE_CAPTURE)
1606         vec3 coords = (ViewMatrixInverse * co).xyz;
1607 #else
1608         vec3 coords = (ModelViewMatrixInverse * co).xyz;
1609 #endif
1610
1611         generated = coords;
1612         normal = -coords;
1613         uv = vec3(attr_uv.xy, 0.0);
1614         object = coords;
1615
1616         camera = vec3(co.xy, -co.z);
1617         window = (ProjectionMatrix[3][3] == 0.0) ?
1618                  vec3(mtex_2d_mapping(I).xy * camerafac.xy + camerafac.zw, 0.0) :
1619                  vec3(vec2(0.5) * camerafac.xy + camerafac.zw, 0.0);
1620
1621         reflection = -coords;
1622 }
1623
1624 #if defined(WORLD_BACKGROUND) || (defined(PROBE_CAPTURE) && !defined(MESH_SHADER))
1625 #define node_tex_coord node_tex_coord_background
1626 #endif
1627
1628 /* textures */
1629
1630 float calc_gradient(vec3 p, int gradient_type)
1631 {
1632         float x, y, z;
1633         x = p.x;
1634         y = p.y;
1635         z = p.z;
1636         if (gradient_type == 0) {  /* linear */
1637                 return x;
1638         }
1639         else if (gradient_type == 1) {  /* quadratic */
1640                 float r = max(x, 0.0);
1641                 return r * r;
1642         }
1643         else if (gradient_type == 2) {  /* easing */
1644                 float r = min(max(x, 0.0), 1.0);
1645                 float t = r * r;
1646                 return (3.0 * t - 2.0 * t * r);
1647         }
1648         else if (gradient_type == 3) {  /* diagonal */
1649                 return (x + y) * 0.5;
1650         }
1651         else if (gradient_type == 4) {  /* radial */
1652                 return atan(y, x) / (M_PI * 2) + 0.5;
1653         }
1654         else {
1655                 /* Bias a little bit for the case where p is a unit length vector,
1656                  * to get exactly zero instead of a small random value depending
1657                  * on float precision. */
1658                 float r = max(0.999999 - sqrt(x * x + y * y + z * z), 0.0);
1659                 if (gradient_type == 5) {  /* quadratic sphere */
1660                         return r * r;
1661                 }
1662                 else if (gradient_type == 6) {  /* sphere */
1663                         return r;
1664                 }
1665         }
1666         return 0.0;
1667 }
1668
1669 void node_tex_gradient(vec3 co, float gradient_type, out vec4 color, out float fac)
1670 {
1671         float f = calc_gradient(co, int(gradient_type));
1672         f = clamp(f, 0.0, 1.0);
1673
1674         color = vec4(f, f, f, 1.0);
1675         fac = f;
1676 }
1677
1678 void node_tex_checker(vec3 co, vec4 color1, vec4 color2, float scale, out vec4 color, out float fac)
1679 {
1680         vec3 p = co * scale;
1681
1682         /* Prevent precision issues on unit coordinates. */
1683         p.x = (p.x + 0.000001) * 0.999999;
1684         p.y = (p.y + 0.000001) * 0.999999;
1685         p.z = (p.z + 0.000001) * 0.999999;
1686
1687         int xi = int(abs(floor(p.x)));
1688         int yi = int(abs(floor(p.y)));
1689         int zi = int(abs(floor(p.z)));
1690
1691         bool check = ((mod(xi, 2) == mod(yi, 2)) == bool(mod(zi, 2)));
1692
1693         color = check ? color1 : color2;
1694         fac = check ? 1.0 : 0.0;
1695 }
1696
1697 vec2 calc_brick_texture(vec3 p, float mortar_size, float mortar_smooth, float bias,
1698                         float brick_width, float row_height,
1699                         float offset_amount, int offset_frequency,
1700                         float squash_amount, int squash_frequency)
1701 {
1702         int bricknum, rownum;
1703         float offset = 0.0;
1704         float x, y;
1705
1706         rownum = floor_to_int(p.y / row_height);
1707
1708         if (offset_frequency != 0 && squash_frequency != 0) {
1709                 brick_width *= (rownum % squash_frequency != 0) ? 1.0 : squash_amount; /* squash */
1710                 offset = (rownum % offset_frequency != 0) ? 0.0 : (brick_width * offset_amount); /* offset */
1711         }
1712
1713         bricknum = floor_to_int((p.x + offset) / brick_width);
1714
1715         x = (p.x + offset) - brick_width * bricknum;
1716         y = p.y - row_height * rownum;
1717
1718         float tint = clamp((integer_noise((rownum << 16) + (bricknum & 0xFFFF)) + bias), 0.0, 1.0);
1719
1720         float min_dist = min(min(x, y), min(brick_width - x, row_height - y));
1721         if (min_dist >= mortar_size) {
1722                 return vec2(tint, 0.0);
1723         }
1724         else if (mortar_smooth == 0.0) {
1725                 return vec2(tint, 1.0);
1726         }
1727         else {
1728                 min_dist = 1.0 - min_dist/mortar_size;
1729                 return vec2(tint, smoothstep(0.0, mortar_smooth, min_dist));
1730         }
1731 }
1732
1733 void node_tex_brick(vec3 co,
1734                     vec4 color1, vec4 color2,
1735                     vec4 mortar, float scale,
1736                     float mortar_size, float mortar_smooth, float bias,
1737                     float brick_width, float row_height,
1738                     float offset_amount, float offset_frequency,
1739                     float squash_amount, float squash_frequency,
1740                     out vec4 color, out float fac)
1741 {
1742         vec2 f2 = calc_brick_texture(co * scale,
1743                                      mortar_size, mortar_smooth, bias,
1744                                      brick_width, row_height,
1745                                      offset_amount, int(offset_frequency),
1746                                      squash_amount, int(squash_frequency));
1747         float tint = f2.x;
1748         float f = f2.y;
1749         if (f != 1.0) {
1750                 float facm = 1.0 - tint;
1751                 color1 = facm * color1 + tint * color2;
1752         }
1753         color = mix(color1, mortar, f);
1754         fac = f;
1755 }
1756
1757 void node_tex_clouds(vec3 co, float size, out vec4 color, out float fac)
1758 {
1759         color = vec4(1.0);
1760         fac = 1.0;
1761 }
1762
1763 void node_tex_environment_equirectangular(vec3 co, sampler2D ima, out vec4 color)
1764 {
1765         vec3 nco = normalize(co);
1766         float u = -atan(nco.y, nco.x) / (2.0 * M_PI) + 0.5;
1767         float v = atan(nco.z, hypot(nco.x, nco.y)) / M_PI + 0.5;
1768
1769         /* Fix pole bleeding */
1770         float half_width = 0.5 / float(textureSize(ima, 0).x);
1771         v = clamp(v, half_width, 1.0 - half_width);
1772
1773         /* Fix u = 0 seam */
1774         /* This is caused by texture filtering, since uv don't have smooth derivatives
1775          * at u = 0 or 2PI, hardware filtering is using the smallest mipmap for certain
1776          * texels. So we force the highest mipmap and don't do anisotropic filtering. */
1777         color = textureLod(ima, vec2(u, v), 0.0);
1778 }
1779
1780 void node_tex_environment_mirror_ball(vec3 co, sampler2D ima, out vec4 color)
1781 {
1782         vec3 nco = normalize(co);
1783
1784         nco.y -= 1.0;
1785
1786         float div = 2.0 * sqrt(max(-0.5 * nco.y, 0.0));
1787         if (div > 0.0)
1788                 nco /= div;
1789
1790         float u = 0.5 * (nco.x + 1.0);
1791         float v = 0.5 * (nco.z + 1.0);
1792
1793         color = texture(ima, vec2(u, v));
1794 }
1795
1796 void node_tex_environment_empty(vec3 co, out vec4 color)
1797 {
1798         color = vec4(1.0, 0.0, 1.0, 1.0);
1799 }
1800
1801 void node_tex_image(vec3 co, sampler2D ima, out vec4 color, out float alpha)
1802 {
1803         color = texture(ima, co.xy);
1804         alpha = color.a;
1805 }
1806
1807 void node_tex_image_box(vec3 texco,
1808                         vec3 N,
1809                         sampler2D ima,
1810                         float blend,
1811                         out vec4 color,
1812                         out float alpha)
1813 {
1814         vec3 signed_N = N;
1815
1816         /* project from direction vector to barycentric coordinates in triangles */
1817         N = vec3(abs(N.x), abs(N.y), abs(N.z));
1818         N /= (N.x + N.y + N.z);
1819
1820         /* basic idea is to think of this as a triangle, each corner representing
1821          * one of the 3 faces of the cube. in the corners we have single textures,
1822          * in between we blend between two textures, and in the middle we a blend
1823          * between three textures.
1824          *
1825          * the Nxyz values are the barycentric coordinates in an equilateral
1826          * triangle, which in case of blending, in the middle has a smaller
1827          * equilateral triangle where 3 textures blend. this divides things into
1828          * 7 zones, with an if () test for each zone */
1829
1830         vec3 weight = vec3(0.0, 0.0, 0.0);
1831         float limit = 0.5 * (1.0 + blend);
1832
1833         /* first test for corners with single texture */
1834         if (N.x > limit * (N.x + N.y) && N.x > limit * (N.x + N.z)) {
1835                 weight.x = 1.0;
1836         }
1837         else if (N.y > limit * (N.x + N.y) && N.y > limit * (N.y + N.z)) {
1838                 weight.y = 1.0;
1839         }
1840         else if (N.z > limit * (N.x + N.z) && N.z > limit * (N.y + N.z)) {
1841                 weight.z = 1.0;
1842         }
1843         else if (blend > 0.0) {
1844                 /* in case of blending, test for mixes between two textures */
1845                 if (N.z < (1.0 - limit) * (N.y + N.x)) {
1846                         weight.x = N.x / (N.x + N.y);
1847                         weight.x = clamp((weight.x - 0.5 * (1.0 - blend)) / blend, 0.0, 1.0);
1848                         weight.y = 1.0 - weight.x;
1849                 }
1850                 else if (N.x < (1.0 - limit) * (N.y + N.z)) {
1851                         weight.y = N.y / (N.y + N.z);
1852                         weight.y = clamp((weight.y - 0.5 * (1.0 - blend)) / blend, 0.0, 1.0);
1853                         weight.z = 1.0 - weight.y;
1854                 }
1855                 else if (N.y < (1.0 - limit) * (N.x + N.z)) {
1856                         weight.x = N.x / (N.x + N.z);
1857                         weight.x = clamp((weight.x - 0.5 * (1.0 - blend)) / blend, 0.0, 1.0);
1858                         weight.z = 1.0 - weight.x;
1859                 }
1860                 else {
1861                         /* last case, we have a mix between three */
1862                         weight.x = ((2.0 - limit) * N.x + (limit - 1.0)) / (2.0 * limit - 1.0);
1863                         weight.y = ((2.0 - limit) * N.y + (limit - 1.0)) / (2.0 * limit - 1.0);
1864                         weight.z = ((2.0 - limit) * N.z + (limit - 1.0)) / (2.0 * limit - 1.0);
1865                 }
1866         }
1867         else {
1868                 /* Desperate mode, no valid choice anyway, fallback to one side.*/
1869                 weight.x = 1.0;
1870         }
1871         color = vec4(0);
1872         if (weight.x > 0.0) {
1873                 vec2 uv = texco.yz;
1874                 if(signed_N.x < 0.0) {
1875                         uv.x = 1.0 - uv.x;
1876                 }
1877                 color += weight.x * texture(ima, uv);
1878         }
1879         if (weight.y > 0.0) {
1880                 vec2 uv = texco.xz;
1881                 if(signed_N.y > 0.0) {
1882                         uv.x = 1.0 - uv.x;
1883                 }
1884                 color += weight.y * texture(ima, uv);
1885         }
1886         if (weight.z > 0.0) {
1887                 vec2 uv = texco.yx;
1888                 if(signed_N.z > 0.0) {
1889                         uv.x = 1.0 - uv.x;
1890                 }
1891                 color += weight.z * texture(ima, uv);
1892         }
1893
1894         alpha = color.a;
1895 }
1896
1897 void node_tex_image_empty(vec3 co, out vec4 color, out float alpha)
1898 {
1899         color = vec4(0.0);
1900         alpha = 0.0;
1901 }
1902
1903 void node_tex_magic(vec3 co, float scale, float distortion, float depth, out vec4 color, out float fac)
1904 {
1905         vec3 p = co * scale;
1906         float x = sin((p.x + p.y + p.z) * 5.0);
1907         float y = cos((-p.x + p.y - p.z) * 5.0);
1908         float z = -cos((-p.x - p.y + p.z) * 5.0);
1909
1910         if (depth > 0) {
1911                 x *= distortion;
1912                 y *= distortion;
1913                 z *= distortion;
1914                 y = -cos(x - y + z);
1915                 y *= distortion;
1916                 if (depth > 1) {
1917                         x = cos(x - y - z);
1918                         x *= distortion;
1919                         if (depth > 2) {
1920                                 z = sin(-x - y - z);
1921                                 z *= distortion;
1922                                 if (depth > 3) {
1923                                         x = -cos(-x + y - z);
1924                                         x *= distortion;
1925                                         if (depth > 4) {
1926                                                 y = -sin(-x + y + z);
1927                                                 y *= distortion;
1928                                                 if (depth > 5) {
1929                                                         y = -cos(-x + y + z);
1930                                                         y *= distortion;
1931                                                         if (depth > 6) {
1932                                                                 x = cos(x + y + z);
1933                                                                 x *= distortion;
1934                                                                 if (depth > 7) {
1935                                                                         z = sin(x + y - z);
1936                                                                         z *= distortion;
1937                                                                         if (depth > 8) {
1938                                                                                 x = -cos(-x - y + z);
1939                                                                                 x *= distortion;
1940                                                                                 if (depth > 9) {
1941                                                                                         y = -sin(x - y + z);
1942                                                                                         y *= distortion;
1943                                                                                 }
1944                                                                         }
1945                                                                 }
1946                                                         }
1947                                                 }
1948                                         }
1949                                 }
1950                         }
1951                 }
1952         }
1953         if (distortion != 0.0) {
1954                 distortion *= 2.0;
1955                 x /= distortion;
1956                 y /= distortion;
1957                 z /= distortion;
1958         }
1959
1960         color = vec4(0.5 - x, 0.5 - y, 0.5 - z, 1.0);
1961         fac = (color.x + color.y + color.z) / 3.0;
1962 }
1963
1964 float noise_fade(float t)
1965 {
1966         return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
1967 }
1968
1969 float noise_scale3(float result)
1970 {
1971         return 0.9820 * result;
1972 }
1973
1974 float noise_nerp(float t, float a, float b)
1975 {
1976         return (1.0 - t) * a + t * b;
1977 }
1978
1979 float noise_grad(uint hash, float x, float y, float z)
1980 {
1981         uint h = hash & 15u;
1982         float u = h < 8u ? x : y;
1983         float vt = ((h == 12u) || (h == 14u)) ? x : z;
1984         float v = h < 4u ? y : vt;
1985         return (((h & 1u) != 0u) ? -u : u) + (((h & 2u) != 0u) ? -v : v);
1986 }
1987
1988 float noise_perlin(float x, float y, float z)
1989 {
1990         int X; float fx = floorfrac(x, X);
1991         int Y; float fy = floorfrac(y, Y);
1992         int Z; float fz = floorfrac(z, Z);
1993
1994         float u = noise_fade(fx);
1995         float v = noise_fade(fy);
1996         float w = noise_fade(fz);
1997
1998         float noise_u[2], noise_v[2];
1999
2000         noise_u[0] = noise_nerp(u,
2001                 noise_grad(hash(X, Y, Z), fx, fy, fz),
2002                 noise_grad(hash(X + 1, Y, Z), fx - 1.0, fy, fz));
2003
2004         noise_u[1] = noise_nerp(u,
2005                 noise_grad(hash(X, Y + 1, Z), fx, fy - 1.0, fz),
2006                 noise_grad(hash(X + 1, Y + 1, Z), fx - 1.0, fy - 1.0, fz));
2007
2008         noise_v[0] = noise_nerp(v, noise_u[0], noise_u[1]);
2009
2010         noise_u[0] = noise_nerp(u,
2011                 noise_grad(hash(X, Y, Z + 1), fx, fy, fz - 1.0),
2012                 noise_grad(hash(X + 1, Y, Z + 1), fx - 1.0, fy, fz - 1.0));
2013
2014         noise_u[1] = noise_nerp(u,
2015                 noise_grad(hash(X, Y + 1, Z + 1), fx, fy - 1.0, fz - 1.0),
2016                 noise_grad(hash(X + 1, Y + 1, Z + 1), fx - 1.0, fy - 1.0, fz - 1.0));
2017
2018         noise_v[1] = noise_nerp(v, noise_u[0], noise_u[1]);
2019
2020         return noise_scale3(noise_nerp(w, noise_v[0], noise_v[1]));
2021 }
2022
2023 float noise(vec3 p)
2024 {
2025         return 0.5 * noise_perlin(p.x, p.y, p.z) + 0.5;
2026 }
2027
2028 float snoise(vec3 p)
2029 {
2030         return noise_perlin(p.x, p.y, p.z);
2031 }
2032
2033 float noise_turbulence(vec3 p, float octaves, int hard)
2034 {
2035         float fscale = 1.0;
2036         float amp = 1.0;
2037         float sum = 0.0;
2038         octaves = clamp(octaves, 0.0, 16.0);
2039         int n = int(octaves);
2040         for (int i = 0; i <= n; i++) {
2041                 float t = noise(fscale * p);
2042                 if (hard != 0) {
2043                         t = abs(2.0 * t - 1.0);
2044                 }
2045                 sum += t * amp;
2046                 amp *= 0.5;
2047                 fscale *= 2.0;
2048         }
2049         float rmd = octaves - floor(octaves);
2050         if (rmd != 0.0) {
2051                 float t = noise(fscale * p);
2052                 if (hard != 0) {
2053                         t = abs(2.0 * t - 1.0);
2054                 }
2055                 float sum2 = sum + t * amp;
2056                 sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
2057                 sum2 *= (float(1 << (n + 1)) / float((1 << (n + 2)) - 1));
2058                 return (1.0 - rmd) * sum + rmd * sum2;
2059         }
2060         else {
2061                 sum *= (float(1 << n) / float((1 << (n + 1)) - 1));
2062                 return sum;
2063         }
2064 }
2065
2066 void node_tex_noise(vec3 co, float scale, float detail, float distortion, out vec4 color, out float fac)
2067 {
2068         vec3 p = co * scale;
2069         int hard = 0;
2070         if (distortion != 0.0) {
2071                 vec3 r, offset = vec3(13.5, 13.5, 13.5);
2072                 r.x = noise(p + offset) * distortion;
2073                 r.y = noise(p) * distortion;
2074                 r.z = noise(p - offset) * distortion;
2075                 p += r;
2076         }
2077
2078         fac = noise_turbulence(p, detail, hard);
2079         color = vec4(fac,
2080                      noise_turbulence(vec3(p.y, p.x, p.z), detail, hard),
2081                      noise_turbulence(vec3(p.y, p.z, p.x), detail, hard),
2082                      1);
2083 }
2084
2085 /* Musgrave fBm
2086  *
2087  * H: fractal increment parameter
2088  * lacunarity: gap between successive frequencies
2089  * octaves: number of frequencies in the fBm
2090  *
2091  * from "Texturing and Modelling: A procedural approach"
2092  */
2093
2094 float noise_musgrave_fBm(vec3 p, float H, float lacunarity, float octaves)
2095 {
2096         float rmd;
2097         float value = 0.0;
2098         float pwr = 1.0;
2099         float pwHL = pow(lacunarity, -H);
2100
2101         for (int i = 0; i < int(octaves); i++) {
2102                 value += snoise(p) * pwr;
2103                 pwr *= pwHL;
2104                 p *= lacunarity;
2105         }
2106
2107         rmd = octaves - floor(octaves);
2108         if (rmd != 0.0)
2109                 value += rmd * snoise(p) * pwr;
2110
2111         return value;
2112 }
2113
2114 /* Musgrave Multifractal
2115  *
2116  * H: highest fractal dimension
2117  * lacunarity: gap between successive frequencies
2118  * octaves: number of frequencies in the fBm
2119  */
2120
2121 float noise_musgrave_multi_fractal(vec3 p, float H, float lacunarity, float octaves)
2122 {
2123         float rmd;
2124         float value = 1.0;
2125         float pwr = 1.0;
2126         float pwHL = pow(lacunarity, -H);
2127
2128         for (int i = 0; i < int(octaves); i++) {
2129                 value *= (pwr * snoise(p) + 1.0);
2130                 pwr *= pwHL;
2131                 p *= lacunarity;
2132         }
2133
2134         rmd = octaves - floor(octaves);
2135         if (rmd != 0.0)
2136                 value *= (rmd * pwr * snoise(p) + 1.0); /* correct? */
2137
2138         return value;
2139 }
2140
2141 /* Musgrave Heterogeneous Terrain
2142  *
2143  * H: fractal dimension of the roughest area
2144  * lacunarity: gap between successive frequencies
2145  * octaves: number of frequencies in the fBm
2146  * offset: raises the terrain from `sea level'
2147  */
2148
2149 float noise_musgrave_hetero_terrain(vec3 p, float H, float lacunarity, float octaves, float offset)
2150 {
2151         float value, increment, rmd;
2152         float pwHL = pow(lacunarity, -H);
2153         float pwr = pwHL;
2154
2155         /* first unscaled octave of function; later octaves are scaled */
2156         value = offset + snoise(p);
2157         p *= lacunarity;
2158
2159         for (int i = 1; i < int(octaves); i++) {
2160                 increment = (snoise(p) + offset) * pwr * value;
2161                 value += increment;
2162                 pwr *= pwHL;
2163                 p *= lacunarity;
2164         }
2165
2166         rmd = octaves - floor(octaves);
2167         if (rmd != 0.0) {
2168                 increment = (snoise(p) + offset) * pwr * value;
2169                 value += rmd * increment;
2170         }
2171
2172         return value;
2173 }
2174
2175 /* Hybrid Additive/Multiplicative Multifractal Terrain
2176  *
2177  * H: fractal dimension of the roughest area
2178  * lacunarity: gap between successive frequencies
2179  * octaves: number of frequencies in the fBm
2180  * offset: raises the terrain from `sea level'
2181  */
2182
2183 float noise_musgrave_hybrid_multi_fractal(vec3 p, float H, float lacunarity, float octaves, float offset, float gain)
2184 {
2185         float result, signal, weight, rmd;
2186         float pwHL = pow(lacunarity, -H);
2187         float pwr = pwHL;
2188
2189         result = snoise(p) + offset;
2190         weight = gain * result;
2191         p *= lacunarity;
2192
2193         for (int i = 1; (weight > 0.001f) && (i < int(octaves)); i++) {
2194                 if (weight > 1.0)
2195                         weight = 1.0;
2196
2197                 signal = (snoise(p) + offset) * pwr;
2198                 pwr *= pwHL;
2199                 result += weight * signal;
2200                 weight *= gain * signal;
2201                 p *= lacunarity;
2202         }
2203
2204         rmd = octaves - floor(octaves);
2205         if (rmd != 0.0)
2206                 result += rmd * ((snoise(p) + offset) * pwr);
2207
2208         return result;
2209 }
2210
2211 /* Ridged Multifractal Terrain
2212  *
2213  * H: fractal dimension of the roughest area
2214  * lacunarity: gap between successive frequencies
2215  * octaves: number of frequencies in the fBm
2216  * offset: raises the terrain from `sea level'
2217  */
2218
2219 float noise_musgrave_ridged_multi_fractal(vec3 p, float H, float lacunarity, float octaves, float offset, float gain)
2220 {
2221         float result, signal, weight;
2222         float pwHL = pow(lacunarity, -H);
2223         float pwr = pwHL;
2224
2225         signal = offset - abs(snoise(p));
2226         signal *= signal;
2227         result = signal;
2228         weight = 1.0;
2229
2230         for (int i = 1; i < int(octaves); i++) {
2231                 p *= lacunarity;
2232                 weight = clamp(signal * gain, 0.0, 1.0);
2233                 signal = offset - abs(snoise(p));
2234                 signal *= signal;
2235                 signal *= weight;
2236                 result += signal * pwr;
2237                 pwr *= pwHL;
2238         }
2239
2240         return result;
2241 }
2242
2243 float svm_musgrave(int type,
2244                    float dimension,
2245                    float lacunarity,
2246                    float octaves,
2247                    float offset,
2248                    float intensity,
2249                    float gain,
2250                    vec3 p)
2251 {
2252         if (type == 0 /* NODE_MUSGRAVE_MULTIFRACTAL */)
2253                 return intensity * noise_musgrave_multi_fractal(p, dimension, lacunarity, octaves);
2254         else if (type == 1 /* NODE_MUSGRAVE_FBM */)
2255                 return intensity * noise_musgrave_fBm(p, dimension, lacunarity, octaves);
2256         else if (type == 2 /* NODE_MUSGRAVE_HYBRID_MULTIFRACTAL */)
2257                 return intensity * noise_musgrave_hybrid_multi_fractal(p, dimension, lacunarity, octaves, offset, gain);
2258         else if (type == 3 /* NODE_MUSGRAVE_RIDGED_MULTIFRACTAL */)
2259                 return intensity * noise_musgrave_ridged_multi_fractal(p, dimension, lacunarity, octaves, offset, gain);
2260         else if (type == 4 /* NODE_MUSGRAVE_HETERO_TERRAIN */)
2261                 return intensity * noise_musgrave_hetero_terrain(p, dimension, lacunarity, octaves, offset);
2262         return 0.0;
2263 }
2264
2265 void node_tex_musgrave(vec3 co,
2266                        float scale,
2267                        float detail,
2268                        float dimension,
2269                        float lacunarity,
2270                        float offset,
2271                        float gain,
2272                        float type,
2273                        out vec4 color,
2274                        out float fac)
2275 {
2276         fac = svm_musgrave(int(type),
2277                            dimension,
2278                            lacunarity,
2279                            detail,
2280                            offset,
2281                            1.0,
2282                            gain,
2283                            co * scale);
2284
2285         color = vec4(fac, fac, fac, 1.0);
2286 }
2287
2288 void node_tex_sky(vec3 co, out vec4 color)
2289 {
2290         color = vec4(1.0);
2291 }
2292
2293 void node_tex_voronoi(vec3 co, float scale, float coloring, out vec4 color, out float fac)
2294 {
2295         vec3 p = co * scale;
2296         int xx, yy, zz, xi, yi, zi;
2297         float da[4];
2298         vec3 pa[4];
2299
2300         xi = floor_to_int(p[0]);
2301         yi = floor_to_int(p[1]);
2302         zi = floor_to_int(p[2]);
2303
2304         da[0] = 1e+10;
2305         da[1] = 1e+10;
2306         da[2] = 1e+10;
2307         da[3] = 1e+10;
2308
2309         for (xx = xi - 1; xx <= xi + 1; xx++) {
2310                 for (yy = yi - 1; yy <= yi + 1; yy++) {
2311                         for (zz = zi - 1; zz <= zi + 1; zz++) {
2312                                 vec3 ip = vec3(xx, yy, zz);
2313                                 vec3 vp = cellnoise_color(ip);
2314                                 vec3 pd = p - (vp + ip);
2315                                 float d = dot(pd, pd);
2316                                 vp += vec3(xx, yy, zz);
2317                                 if (d < da[0]) {
2318                                         da[3] = da[2];
2319                                         da[2] = da[1];
2320                                         da[1] = da[0];
2321                                         da[0] = d;
2322                                         pa[3] = pa[2];
2323                                         pa[2] = pa[1];
2324                                         pa[1] = pa[0];
2325                                         pa[0] = vp;
2326                                 }
2327                                 else if (d < da[1]) {
2328                                         da[3] = da[2];
2329                                         da[2] = da[1];
2330                                         da[1] = d;
2331
2332                                         pa[3] = pa[2];
2333                                         pa[2] = pa[1];
2334                                         pa[1] = vp;
2335                                 }
2336                                 else if (d < da[2]) {
2337                                         da[3] = da[2];
2338                                         da[2] = d;
2339
2340                                         pa[3] = pa[2];
2341                                         pa[2] = vp;
2342                                 }
2343                                 else if (d < da[3]) {
2344                                         da[3] = d;
2345                                         pa[3] = vp;
2346                                 }
2347                         }
2348                 }
2349         }
2350
2351         if (coloring == 0.0) {
2352                 fac = abs(da[0]);
2353                 color = vec4(fac, fac, fac, 1);
2354         }
2355         else {
2356                 color = vec4(cellnoise_color(pa[0]), 1);
2357                 fac = (color.x + color.y + color.z) * (1.0 / 3.0);
2358         }
2359 }
2360
2361 float calc_wave(vec3 p, float distortion, float detail, float detail_scale, int wave_type, int wave_profile)
2362 {
2363         float n;
2364
2365         if (wave_type == 0) /* type bands */
2366                 n = (p.x + p.y + p.z) * 10.0;
2367         else /* type rings */
2368                 n = length(p) * 20.0;
2369
2370         if (distortion != 0.0)
2371                 n += distortion * noise_turbulence(p * detail_scale, detail, 0);
2372
2373         if (wave_profile == 0) { /* profile sin */
2374                 return 0.5 + 0.5 * sin(n);
2375         }
2376         else { /* profile saw */
2377                 n /= 2.0 * M_PI;
2378                 n -= int(n);
2379                 return (n < 0.0) ? n + 1.0 : n;
2380         }
2381 }
2382
2383 void node_tex_wave(
2384         vec3 co, float scale, float distortion, float detail, float detail_scale, float wave_type, float wave_profile,
2385         out vec4 color, out float fac)
2386 {
2387         float f;
2388         f = calc_wave(co * scale, distortion, detail, detail_scale, int(wave_type), int(wave_profile));
2389
2390         color = vec4(f, f, f, 1.0);
2391         fac = f;
2392 }
2393
2394 /* light path */
2395
2396 void node_light_path(
2397         out float is_camera_ray,
2398         out float is_shadow_ray,
2399         out float is_diffuse_ray,
2400         out float is_glossy_ray,
2401         out float is_singular_ray,
2402         out float is_reflection_ray,
2403         out float is_transmission_ray,
2404         out float ray_length,
2405         out float ray_depth,
2406         out float diffuse_depth,
2407         out float glossy_depth,
2408         out float transparent_depth,
2409         out float transmission_depth)
2410 {
2411 #ifndef PROBE_CAPTURE
2412         is_camera_ray = 1.0;
2413         is_glossy_ray = 0.0;
2414         is_diffuse_ray = 0.0;
2415         is_reflection_ray = 0.0;
2416         is_transmission_ray = 0.0;
2417 #else
2418         is_camera_ray = 0.0;
2419         is_glossy_ray = 1.0;
2420         is_diffuse_ray = 1.0;
2421         is_reflection_ray = 1.0;
2422         is_transmission_ray = 1.0;
2423 #endif
2424         is_shadow_ray = 0.0;
2425         is_singular_ray = 0.0;
2426         ray_length = 1.0;
2427         ray_depth = 1.0;
2428         diffuse_depth = 1.0;
2429         glossy_depth = 1.0;
2430         transparent_depth = 1.0;
2431         transmission_depth = 1.0;
2432 }
2433
2434 void node_light_falloff(float strength, float tsmooth, out float quadratic, out float linear, out float constant)
2435 {
2436         quadratic = strength;
2437         linear = strength;
2438         constant = strength;
2439 }
2440
2441 void node_object_info(mat4 obmat, vec3 info, out vec3 location, out float object_index, out float material_index, out float random)
2442 {
2443         location = obmat[3].xyz;
2444         object_index = info.x;
2445         material_index = info.y;
2446         random = info.z;
2447 }
2448
2449 void node_normal_map(vec4 tangent, vec3 normal, vec3 texnormal, out vec3 outnormal)
2450 {
2451         vec3 B = tangent.w * cross(normal, tangent.xyz);
2452
2453         outnormal = texnormal.x * tangent.xyz + texnormal.y * B + texnormal.z * normal;
2454         outnormal = normalize(outnormal);
2455 }
2456
2457 void node_bump(float strength, float dist, float height, vec3 N, vec3 surf_pos, float invert, out vec3 result)
2458 {
2459         if (invert != 0.0) {
2460                 dist *= -1.0;
2461         }
2462         vec3 dPdx = dFdx(surf_pos);
2463         vec3 dPdy = dFdy(surf_pos);
2464
2465         /* Get surface tangents from normal. */
2466         vec3 Rx = cross(dPdy, N);
2467         vec3 Ry = cross(N, dPdx);
2468
2469         /* Compute surface gradient and determinant. */
2470         float det = dot(dPdx, Rx);
2471         float absdet = abs(det);
2472
2473         float dHdx = dFdx(height);
2474         float dHdy = dFdy(height);
2475         vec3 surfgrad = dHdx * Rx + dHdy * Ry;
2476
2477         strength = max(strength, 0.0);
2478
2479         result = normalize(absdet * N - dist * sign(det) * surfgrad);
2480         result = normalize(strength * result + (1.0 - strength) * N);
2481 }
2482
2483 void node_bevel(float radius, vec3 N, out vec3 result)
2484 {
2485         result = N;
2486 }
2487
2488 void node_hair_info(out float is_strand, out float intercept, out float thickness, out vec3 tangent, out float random)
2489 {
2490 #ifdef HAIR_SHADER
2491         is_strand = 1.0;
2492         intercept = hairTime;
2493         thickness = hairThickness;
2494         tangent = normalize(hairTangent);
2495         random = wang_hash_noise(uint(hairStrandID)); /* TODO: could be precomputed per strand instead. */
2496 #else
2497         is_strand = 0.0;
2498         intercept = 0.0;
2499         thickness = 0.0;
2500         tangent = vec3(1.0);
2501         random = 0.0;
2502 #endif
2503 }
2504
2505 void node_displacement_object(float height, float midlevel, float scale, vec3 N, mat4 obmat, out vec3 result)
2506 {
2507         N = (vec4(N, 0.0) * obmat).xyz;
2508         result = (height - midlevel) * scale * normalize(N);
2509         result = (obmat * vec4(result, 0.0)).xyz;
2510 }
2511
2512 void node_displacement_world(float height, float midlevel, float scale, vec3 N, out vec3 result)
2513 {
2514         result = (height - midlevel) * scale * normalize(N);
2515 }
2516
2517 void node_vector_displacement_tangent(vec4 vector, float midlevel, float scale, vec4 tangent, vec3 normal, mat4 obmat, mat4 viewmat, out vec3 result)
2518 {
2519         vec3 N_object = normalize(((vec4(normal, 0.0) * viewmat) * obmat).xyz);
2520         vec3 T_object = normalize(((vec4(tangent.xyz, 0.0) * viewmat) * obmat).xyz);
2521         vec3 B_object = tangent.w * normalize(cross(N_object, T_object));
2522
2523         vec3 offset = (vector.xyz - vec3(midlevel)) * scale;
2524         result = offset.x * T_object + offset.y * N_object + offset.z * B_object;
2525         result = (obmat * vec4(result, 0.0)).xyz;
2526 }
2527
2528 void node_vector_displacement_object(vec4 vector, float midlevel, float scale, mat4 obmat, out vec3 result)
2529 {
2530         result = (vector.xyz - vec3(midlevel)) * scale;
2531         result = (obmat * vec4(result, 0.0)).xyz;
2532 }
2533
2534 void node_vector_displacement_world(vec4 vector, float midlevel, float scale, out vec3 result)
2535 {
2536         result = (vector.xyz - vec3(midlevel)) * scale;
2537 }
2538
2539 /* output */
2540
2541 void node_output_material(Closure surface, Closure volume, vec3 displacement, out Closure result)
2542 {
2543 #ifdef VOLUMETRICS
2544         result = volume;
2545 #else
2546         result = surface;
2547 #endif
2548 }
2549
2550 uniform float backgroundAlpha;
2551
2552 void node_output_world(Closure surface, Closure volume, out Closure result)
2553 {
2554 #ifndef VOLUMETRICS
2555         result.radiance = surface.radiance;
2556         result.opacity = backgroundAlpha;
2557 #else
2558         result = volume;
2559 #endif /* VOLUMETRICS */
2560 }
2561
2562 #ifndef VOLUMETRICS
2563 /* TODO : clean this ifdef mess */
2564 /* EEVEE output */
2565 void world_normals_get(out vec3 N)
2566 {
2567 #ifdef HAIR_SHADER
2568         vec3 B = normalize(cross(worldNormal, hairTangent));
2569         float cos_theta;
2570         if (hairThicknessRes == 1) {
2571                 vec4 rand = texelFetch(utilTex, ivec3(ivec2(gl_FragCoord.xy) % LUT_SIZE, 2.0), 0);
2572                 /* Random cosine normal distribution on the hair surface. */
2573                 cos_theta = rand.x * 2.0 - 1.0;
2574         }
2575         else {
2576                 /* Shade as a cylinder. */
2577                 cos_theta = hairThickTime / hairThickness;
2578         }
2579         float sin_theta = sqrt(max(0.0, 1.0f - cos_theta*cos_theta));;
2580         N = normalize(worldNormal * sin_theta + B * cos_theta);
2581 #else
2582         N = gl_FrontFacing ? worldNormal : -worldNormal;
2583 #endif
2584 }
2585
2586 void node_eevee_specular(
2587         vec4 diffuse, vec4 specular, float roughness, vec4 emissive, float transp, vec3 normal,
2588         float clearcoat, float clearcoat_roughness, vec3 clearcoat_normal,
2589         float occlusion, float ssr_id, out Closure result)
2590 {
2591         vec3 out_diff, out_spec, ssr_spec;
2592         eevee_closure_default(normal, diffuse.rgb, specular.rgb, int(ssr_id), roughness, occlusion,
2593                               out_diff, out_spec, ssr_spec);
2594
2595         vec3 vN = normalize(mat3(ViewMatrix) * normal);
2596         result = CLOSURE_DEFAULT;
2597         result.radiance = out_diff * diffuse.rgb + out_spec + emissive.rgb;
2598         result.opacity = 1.0 - transp;
2599         result.ssr_data = vec4(ssr_spec, roughness);
2600         result.ssr_normal = normal_encode(vN, viewCameraVec);
2601         result.ssr_id = int(ssr_id);
2602 }
2603
2604 void node_shader_to_rgba(Closure cl, out vec4 outcol, out float outalpha)
2605 {
2606         vec4 spec_accum = vec4(0.0);
2607         if (ssrToggle && cl.ssr_id == outputSsrId) {
2608                 vec3 V = cameraVec;
2609                 vec3 vN = normal_decode(cl.ssr_normal, viewCameraVec);
2610                 vec3 N = transform_direction(ViewMatrixInverse, vN);
2611                 float roughness = cl.ssr_data.a;
2612                 float roughnessSquared = max(1e-3, roughness * roughness);
2613                 fallback_cubemap(N, V, worldPosition, viewPosition, roughness, roughnessSquared, spec_accum);
2614         }
2615
2616         outalpha = cl.opacity;
2617         outcol = vec4((spec_accum.rgb * cl.ssr_data.rgb) + cl.radiance, 1.0);
2618
2619 #   ifdef USE_SSS
2620 #               ifdef USE_SSS_ALBEDO
2621         outcol.rgb += cl.sss_data.rgb * cl.sss_albedo;
2622 #       else
2623         outcol.rgb += cl.sss_data.rgb;
2624 #               endif
2625 #       endif
2626 }
2627
2628 #endif /* VOLUMETRICS */