Eevee: Hair: Disable SSR for hairs.
[blender.git] / source / blender / draw / engines / eevee / shaders / bsdf_common_lib.glsl
1
2 #define M_PI        3.14159265358979323846  /* pi */
3 #define M_2PI       6.28318530717958647692  /* 2*pi */
4 #define M_PI_2      1.57079632679489661923  /* pi/2 */
5 #define M_1_PI      0.318309886183790671538  /* 1/pi */
6 #define M_1_2PI     0.159154943091895335768  /* 1/(2*pi) */
7 #define M_1_PI2     0.101321183642337771443  /* 1/(pi^2) */
8
9 #define LUT_SIZE 64
10
11 /* Buffers */
12 uniform sampler2D colorBuffer;
13 uniform sampler2D depthBuffer;
14 uniform sampler2D maxzBuffer;
15 uniform sampler2D minzBuffer;
16 uniform sampler2DArray planarDepth;
17
18 #define cameraForward   normalize(ViewMatrixInverse[2].xyz)
19 #define cameraPos       ViewMatrixInverse[3].xyz
20 #define cameraVec      ((ProjectionMatrix[3][3] == 0.0) ? normalize(cameraPos - worldPosition) : cameraForward)
21 #define viewCameraVec  ((ProjectionMatrix[3][3] == 0.0) ? normalize(-viewPosition) : vec3(0.0, 0.0, 1.0))
22
23 /* ------- Structures -------- */
24
25 /* ------ Lights ----- */
26 struct LightData {
27         vec4 position_influence;      /* w : InfluenceRadius */
28         vec4 color_spec;              /* w : Spec Intensity */
29         vec4 spotdata_radius_shadow;  /* x : spot size, y : spot blend, z : radius, w: shadow id */
30         vec4 rightvec_sizex;          /* xyz: Normalized up vector, w: area size X or spot scale X */
31         vec4 upvec_sizey;             /* xyz: Normalized right vector, w: area size Y or spot scale Y */
32         vec4 forwardvec_type;         /* xyz: Normalized forward vector, w: Lamp Type */
33 };
34
35 /* convenience aliases */
36 #define l_color        color_spec.rgb
37 #define l_spec         color_spec.a
38 #define l_position     position_influence.xyz
39 #define l_influence    position_influence.w
40 #define l_sizex        rightvec_sizex.w
41 #define l_sizey        upvec_sizey.w
42 #define l_right        rightvec_sizex.xyz
43 #define l_up           upvec_sizey.xyz
44 #define l_forward      forwardvec_type.xyz
45 #define l_type         forwardvec_type.w
46 #define l_spot_size    spotdata_radius_shadow.x
47 #define l_spot_blend   spotdata_radius_shadow.y
48 #define l_radius       spotdata_radius_shadow.z
49 #define l_shadowid     spotdata_radius_shadow.w
50
51 /* ------ Shadows ----- */
52 #ifndef MAX_CASCADE_NUM
53 #define MAX_CASCADE_NUM 4
54 #endif
55
56 struct ShadowData {
57         vec4 near_far_bias_exp;
58         vec4 shadow_data_start_end;
59         vec4 contact_shadow_data;
60 };
61
62 struct ShadowCubeData {
63         vec4 position;
64 };
65
66 struct ShadowCascadeData {
67         mat4 shadowmat[MAX_CASCADE_NUM];
68         vec4 split_start_distances;
69         vec4 split_end_distances;
70 };
71
72 /* convenience aliases */
73 #define sh_near   near_far_bias_exp.x
74 #define sh_far    near_far_bias_exp.y
75 #define sh_bias   near_far_bias_exp.z
76 #define sh_exp    near_far_bias_exp.w
77 #define sh_bleed  near_far_bias_exp.w
78 #define sh_tex_start    shadow_data_start_end.x
79 #define sh_data_start   shadow_data_start_end.y
80 #define sh_multi_nbr    shadow_data_start_end.z
81 #define sh_blur         shadow_data_start_end.w
82 #define sh_contact_dist            contact_shadow_data.x
83 #define sh_contact_offset          contact_shadow_data.y
84 #define sh_contact_spread          contact_shadow_data.z
85 #define sh_contact_thickness       contact_shadow_data.w
86
87 /* ------- Convenience functions --------- */
88
89 vec3 mul(mat3 m, vec3 v) { return m * v; }
90 mat3 mul(mat3 m1, mat3 m2) { return m1 * m2; }
91 vec3 transform_direction(mat4 m, vec3 v) { return mat3(m) * v; }
92 vec3 transform_point(mat4 m, vec3 v) { return (m * vec4(v, 1.0)).xyz; }
93 vec3 project_point(mat4 m, vec3 v) {
94         vec4 tmp = m * vec4(v, 1.0);
95         return tmp.xyz / tmp.w;
96 }
97
98 #define min3(a, b, c)                   min(a, min(b, c))
99 #define min4(a, b, c, d)                min(a, min3(b, c, d))
100 #define min5(a, b, c, d, e)             min(a, min4(b, c, d, e))
101 #define min6(a, b, c, d, e, f)          min(a, min5(b, c, d, e, f))
102 #define min7(a, b, c, d, e, f, g)       min(a, min6(b, c, d, e, f, g))
103 #define min8(a, b, c, d, e, f, g, h)    min(a, min7(b, c, d, e, f, g, h))
104 #define min9(a, b, c, d, e, f, g, h, i) min(a, min8(b, c, d, e, f, g, h, i))
105
106 #define max3(a, b, c)                   max(a, max(b, c))
107 #define max4(a, b, c, d)                max(a, max3(b, c, d))
108 #define max5(a, b, c, d, e)             max(a, max4(b, c, d, e))
109 #define max6(a, b, c, d, e, f)          max(a, max5(b, c, d, e, f))
110 #define max7(a, b, c, d, e, f, g)       max(a, max6(b, c, d, e, f, g))
111 #define max8(a, b, c, d, e, f, g, h)    max(a, max7(b, c, d, e, f, g, h))
112 #define max9(a, b, c, d, e, f, g, h, i) max(a, max8(b, c, d, e, f, g, h, i))
113
114 #define avg3(a, b, c)                   (a + b + c) * (1.0 / 3.0)
115 #define avg4(a, b, c, d)                (a + b + c + d) * (1.0 / 4.0)
116 #define avg5(a, b, c, d, e)             (a + b + c + d + e) * (1.0 / 5.0)
117 #define avg6(a, b, c, d, e, f)          (a + b + c + d + e + f) * (1.0 / 6.0)
118 #define avg7(a, b, c, d, e, f, g)       (a + b + c + d + e + f + g) * (1.0 / 7.0)
119 #define avg8(a, b, c, d, e, f, g, h)    (a + b + c + d + e + f + g + h) * (1.0 / 8.0)
120 #define avg9(a, b, c, d, e, f, g, h, i) (a + b + c + d + e + f + g + h + i) * (1.0 / 9.0)
121
122 float min_v2(vec2 v) { return min(v.x, v.y); }
123 float min_v3(vec3 v) { return min(v.x, min(v.y, v.z)); }
124 float max_v2(vec2 v) { return max(v.x, v.y); }
125 float max_v3(vec3 v) { return max(v.x, max(v.y, v.z)); }
126
127 float sum(vec2 v) { return dot(vec2(1.0), v); }
128 float sum(vec3 v) { return dot(vec3(1.0), v); }
129 float sum(vec4 v) { return dot(vec4(1.0), v); }
130
131 float saturate(float a) { return clamp(a, 0.0, 1.0); }
132 vec2 saturate(vec2 a) { return clamp(a, 0.0, 1.0); }
133 vec3 saturate(vec3 a) { return clamp(a, 0.0, 1.0); }
134 vec4 saturate(vec4 a) { return clamp(a, 0.0, 1.0); }
135
136 float distance_squared(vec2 a, vec2 b) { a -= b; return dot(a, a); }
137 float distance_squared(vec3 a, vec3 b) { a -= b; return dot(a, a); }
138 float len_squared(vec3 a) { return dot(a, a); }
139
140 float inverse_distance(vec3 V) { return max( 1 / length(V), 1e-8); }
141
142 vec2 mip_ratio_interp(float mip) {
143         float low_mip = floor(mip);
144         return mix(mipRatio[int(low_mip)], mipRatio[int(low_mip + 1.0)], mip - low_mip);
145 }
146 /* ------- Fast Math ------- */
147
148 /* [Drobot2014a] Low Level Optimizations for GCN */
149 float fast_sqrt(float v)
150 {
151         return intBitsToFloat(0x1fbd1df5 + (floatBitsToInt(v) >> 1));
152 }
153
154 vec2 fast_sqrt(vec2 v)
155 {
156         return intBitsToFloat(0x1fbd1df5 + (floatBitsToInt(v) >> 1));
157 }
158
159 /* [Eberly2014] GPGPU Programming for Games and Science */
160 float fast_acos(float v)
161 {
162         float res = -0.156583 * abs(v) + M_PI_2;
163         res *= fast_sqrt(1.0 - abs(v));
164         return (v >= 0) ? res : M_PI - res;
165 }
166
167 vec2 fast_acos(vec2 v)
168 {
169         vec2 res = -0.156583 * abs(v) + M_PI_2;
170         res *= fast_sqrt(1.0 - abs(v));
171         v.x = (v.x >= 0) ? res.x : M_PI - res.x;
172         v.y = (v.y >= 0) ? res.y : M_PI - res.y;
173         return v;
174 }
175
176 float point_plane_projection_dist(vec3 lineorigin, vec3 planeorigin, vec3 planenormal)
177 {
178         return dot(planenormal, planeorigin - lineorigin);
179 }
180
181 float line_plane_intersect_dist(vec3 lineorigin, vec3 linedirection, vec3 planeorigin, vec3 planenormal)
182 {
183         return dot(planenormal, planeorigin - lineorigin) / dot(planenormal, linedirection);
184 }
185
186 float line_plane_intersect_dist(vec3 lineorigin, vec3 linedirection, vec4 plane)
187 {
188         vec3 plane_co = plane.xyz * (-plane.w / len_squared(plane.xyz));
189         vec3 h = lineorigin - plane_co;
190         return -dot(plane.xyz, h) / dot(plane.xyz, linedirection);
191 }
192
193 vec3 line_plane_intersect(vec3 lineorigin, vec3 linedirection, vec3 planeorigin, vec3 planenormal)
194 {
195         float dist = line_plane_intersect_dist(lineorigin, linedirection, planeorigin, planenormal);
196         return lineorigin + linedirection * dist;
197 }
198
199 vec3 line_plane_intersect(vec3 lineorigin, vec3 linedirection, vec4 plane)
200 {
201         float dist = line_plane_intersect_dist(lineorigin, linedirection, plane);
202         return lineorigin + linedirection * dist;
203 }
204
205 float line_aligned_plane_intersect_dist(vec3 lineorigin, vec3 linedirection, vec3 planeorigin)
206 {
207         /* aligned plane normal */
208         vec3 L = planeorigin - lineorigin;
209         float diskdist = length(L);
210         vec3 planenormal = -normalize(L);
211         return -diskdist / dot(planenormal, linedirection);
212 }
213
214 vec3 line_aligned_plane_intersect(vec3 lineorigin, vec3 linedirection, vec3 planeorigin)
215 {
216         float dist = line_aligned_plane_intersect_dist(lineorigin, linedirection, planeorigin);
217         if (dist < 0) {
218                 /* if intersection is behind we fake the intersection to be
219                  * really far and (hopefully) not inside the radius of interest */
220                 dist = 1e16;
221         }
222         return lineorigin + linedirection * dist;
223 }
224
225 float line_unit_sphere_intersect_dist(vec3 lineorigin, vec3 linedirection)
226 {
227         float a = dot(linedirection, linedirection);
228         float b = dot(linedirection, lineorigin);
229         float c = dot(lineorigin, lineorigin) - 1;
230
231         float dist = 1e15;
232         float determinant = b * b - a * c;
233         if (determinant >= 0)
234                 dist = (sqrt(determinant) - b) / a;
235
236         return dist;
237 }
238
239 float line_unit_box_intersect_dist(vec3 lineorigin, vec3 linedirection)
240 {
241         /* https://seblagarde.wordpress.com/2012/09/29/image-based-lighting-approaches-and-parallax-corrected-cubemap/ */
242         vec3 firstplane  = (vec3( 1.0) - lineorigin) / linedirection;
243         vec3 secondplane = (vec3(-1.0) - lineorigin) / linedirection;
244         vec3 furthestplane = max(firstplane, secondplane);
245
246         return min_v3(furthestplane);
247 }
248
249
250 /* Return texture coordinates to sample Surface LUT */
251 vec2 lut_coords(float cosTheta, float roughness)
252 {
253         float theta = acos(cosTheta);
254         vec2 coords = vec2(roughness, theta / M_PI_2);
255
256         /* scale and bias coordinates, for correct filtered lookup */
257         return coords * (LUT_SIZE - 1.0) / LUT_SIZE + 0.5 / LUT_SIZE;
258 }
259
260 /* -- Tangent Space conversion -- */
261 vec3 tangent_to_world(vec3 vector, vec3 N, vec3 T, vec3 B)
262 {
263         return T * vector.x + B * vector.y + N * vector.z;
264 }
265
266 vec3 world_to_tangent(vec3 vector, vec3 N, vec3 T, vec3 B)
267 {
268         return vec3( dot(T, vector), dot(B, vector), dot(N, vector));
269 }
270
271 void make_orthonormal_basis(vec3 N, out vec3 T, out vec3 B)
272 {
273         vec3 UpVector = abs(N.z) < 0.99999 ? vec3(0.0,0.0,1.0) : vec3(1.0,0.0,0.0);
274         T = normalize( cross(UpVector, N) );
275         B = cross(N, T);
276 }
277
278 /* ---- Opengl Depth conversion ---- */
279
280 float linear_depth(bool is_persp, float z, float zf, float zn)
281 {
282         if (is_persp) {
283                 return (zn  * zf) / (z * (zn - zf) + zf);
284         }
285         else {
286                 return (z * 2.0 - 1.0) * zf;
287         }
288 }
289
290 float buffer_depth(bool is_persp, float z, float zf, float zn)
291 {
292         if (is_persp) {
293                 return (zf * (zn - z)) / (z * (zn - zf));
294         }
295         else {
296                 return (z / (zf * 2.0)) + 0.5;
297         }
298 }
299
300 float get_view_z_from_depth(float depth)
301 {
302         if (ProjectionMatrix[3][3] == 0.0) {
303                 float d = 2.0 * depth - 1.0;
304                 return -ProjectionMatrix[3][2] / (d + ProjectionMatrix[2][2]);
305         }
306         else {
307                 return viewVecs[0].z + depth * viewVecs[1].z;
308         }
309 }
310
311 float get_depth_from_view_z(float z)
312 {
313         if (ProjectionMatrix[3][3] == 0.0) {
314                 float d = (-ProjectionMatrix[3][2] / z) - ProjectionMatrix[2][2];
315                 return d * 0.5 + 0.5;
316         }
317         else {
318                 return (z - viewVecs[0].z) / viewVecs[1].z;
319         }
320 }
321
322 vec2 get_uvs_from_view(vec3 view)
323 {
324         vec3 ndc = project_point(ProjectionMatrix, view);
325         return ndc.xy * 0.5 + 0.5;
326 }
327
328 vec3 get_view_space_from_depth(vec2 uvcoords, float depth)
329 {
330         if (ProjectionMatrix[3][3] == 0.0) {
331                 return vec3(viewVecs[0].xy + uvcoords * viewVecs[1].xy, 1.0) * get_view_z_from_depth(depth);
332         }
333         else {
334                 return viewVecs[0].xyz + vec3(uvcoords, depth) * viewVecs[1].xyz;
335         }
336 }
337
338 vec3 get_world_space_from_depth(vec2 uvcoords, float depth)
339 {
340         return (ViewMatrixInverse * vec4(get_view_space_from_depth(uvcoords, depth), 1.0)).xyz;
341 }
342
343 vec3 get_specular_reflection_dominant_dir(vec3 N, vec3 V, float roughness)
344 {
345         vec3 R = -reflect(V, N);
346         float smoothness = 1.0 - roughness;
347         float fac = smoothness * (sqrt(smoothness) + roughness);
348         return normalize(mix(N, R, fac));
349 }
350
351 float specular_occlusion(float NV, float AO, float roughness)
352 {
353         return saturate(pow(NV + AO, roughness) - 1.0 + AO);
354 }
355
356 /* --- Refraction utils --- */
357
358 float ior_from_f0(float f0)
359 {
360         float f = sqrt(f0);
361         return (-f - 1.0) / (f - 1.0);
362 }
363
364 float f0_from_ior(float eta)
365 {
366         float A = (eta - 1.0) / (eta + 1.0);
367         return A * A;
368 }
369
370 vec3 get_specular_refraction_dominant_dir(vec3 N, vec3 V, float roughness, float ior)
371 {
372         /* TODO: This a bad approximation. Better approximation should fit
373          * the refracted vector and roughness into the best prefiltered reflection
374          * lobe. */
375         /* Correct the IOR for ior < 1.0 to not see the abrupt delimitation or the TIR */
376         ior = (ior < 1.0) ? mix(ior, 1.0, roughness) : ior;
377         float eta = 1.0 / ior;
378
379         float NV = dot(N, -V);
380
381         /* Custom Refraction. */
382         float k = 1.0 - eta * eta * (1.0 - NV * NV);
383         k = max(0.0, k); /* Only this changes. */
384         vec3 R = eta * -V - (eta * NV + sqrt(k)) * N;
385
386         return R;
387 }
388
389 float get_btdf_lut(sampler2DArray btdf_lut_tex, float NV, float roughness, float ior)
390 {
391         const vec3 lut_scale_bias_texel_size = vec3((LUT_SIZE - 1.0), 0.5, 1.5) / LUT_SIZE;
392
393         vec3 coords;
394         /* Try to compensate for the low resolution and interpolation error. */
395         coords.x = (ior > 1.0)
396                    ? (0.9 + lut_scale_bias_texel_size.z) + (0.1 - lut_scale_bias_texel_size.z) * f0_from_ior(ior)
397                    : (0.9 + lut_scale_bias_texel_size.z) * ior * ior;
398         coords.y = 1.0 - saturate(NV);
399         coords.xy *= lut_scale_bias_texel_size.x;
400         coords.xy += lut_scale_bias_texel_size.y;
401
402         const float lut_lvl_ofs = 4.0; /* First texture lvl of roughness. */
403         const float lut_lvl_scale = 16.0; /* How many lvl of roughness in the lut. */
404
405         float mip = roughness * lut_lvl_scale;
406         float mip_floor = floor(mip);
407
408         coords.z = lut_lvl_ofs + mip_floor + 1.0;
409         float btdf_high = textureLod(btdf_lut_tex, coords, 0.0).r;
410
411         coords.z -= 1.0;
412         float btdf_low = textureLod(btdf_lut_tex, coords, 0.0).r;
413
414         float btdf = (ior == 1.0) ? 1.0 : mix(btdf_low, btdf_high, mip - coords.z);
415
416         return btdf;
417 }
418
419 /* ---- Encode / Decode Normal buffer data ---- */
420 /* From http://aras-p.info/texts/CompactNormalStorage.html
421  * Using Method #4: Spheremap Transform */
422 vec2 normal_encode(vec3 n, vec3 view)
423 {
424         float p = sqrt(n.z * 8.0 + 8.0);
425         return n.xy / p + 0.5;
426 }
427
428 vec3 normal_decode(vec2 enc, vec3 view)
429 {
430         vec2 fenc = enc * 4.0 - 2.0;
431         float f = dot(fenc, fenc);
432         float g = sqrt(1.0 - f / 4.0);
433         vec3 n;
434         n.xy = fenc*g;
435         n.z = 1 - f / 2;
436         return n;
437 }
438
439 /* ---- RGBM (shared multiplier) encoding ---- */
440 /* From http://iwasbeingirony.blogspot.fr/2010/06/difference-between-rgbm-and-rgbd.html */
441
442 /* Higher RGBM_MAX_RANGE gives imprecision issues in low intensity. */
443 #define RGBM_MAX_RANGE 512.0
444
445 vec4 rgbm_encode(vec3 rgb)
446 {
447         float maxRGB = max_v3(rgb);
448         float M = maxRGB / RGBM_MAX_RANGE;
449         M = ceil(M * 255.0) / 255.0;
450         return vec4(rgb / (M * RGBM_MAX_RANGE), M);
451 }
452
453 vec3 rgbm_decode(vec4 data)
454 {
455         return data.rgb * (data.a * RGBM_MAX_RANGE);
456 }
457
458 /* ---- RGBE (shared exponent) encoding ---- */
459 vec4 rgbe_encode(vec3 rgb)
460 {
461         float maxRGB = max_v3(rgb);
462         float fexp = ceil(log2(maxRGB));
463         return vec4(rgb / exp2(fexp), (fexp + 128.0) / 255.0);
464 }
465
466 vec3 rgbe_decode(vec4 data)
467 {
468         float fexp = data.a * 255.0 - 128.0;
469         return data.rgb * exp2(fexp);
470 }
471
472 #if 1
473 #define irradiance_encode rgbe_encode
474 #define irradiance_decode rgbe_decode
475 #else /* No ecoding (when using floating point format) */
476 #define irradiance_encode(X) (X).rgbb
477 #define irradiance_decode(X) (X).rgb
478 #endif
479
480 /* Irradiance Visibility Encoding */
481 #if 1
482 vec4 visibility_encode(vec2 accum, float range)
483 {
484         accum /= range;
485
486         vec4 data;
487         data.x = fract(accum.x);
488         data.y = floor(accum.x) / 255.0;
489         data.z = fract(accum.y);
490         data.w = floor(accum.y) / 255.0;
491
492         return data;
493 }
494
495 vec2 visibility_decode(vec4 data, float range)
496 {
497         return (data.xz + data.yw * 255.0) * range;
498 }
499 #else /* No ecoding (when using floating point format) */
500 vec4 visibility_encode(vec2 accum, float range)
501 {
502         return accum.xyxy;
503 }
504
505 vec2 visibility_decode(vec4 data, float range)
506 {
507         return data.xy;
508 }
509 #endif
510
511 /* Fresnel monochromatic, perfect mirror */
512 float F_eta(float eta, float cos_theta)
513 {
514         /* compute fresnel reflectance without explicitly computing
515          * the refracted direction */
516         float c = abs(cos_theta);
517         float g = eta * eta - 1.0 + c * c;
518         float result;
519
520         if (g > 0.0) {
521                 g = sqrt(g);
522                 vec2 g_c = vec2(g) + vec2(c, -c);
523                 float A = g_c.y / g_c.x;
524                 A *= A;
525                 g_c *= c;
526                 float B = (g_c.y - 1.0) / (g_c.x + 1.0);
527                 B *= B;
528                 result = 0.5 * A * (1.0 + B);
529         }
530         else {
531                 result = 1.0;  /* TIR (no refracted component) */
532         }
533
534         return result;
535 }
536
537 /* Fresnel */
538 vec3 F_schlick(vec3 f0, float cos_theta)
539 {
540         float fac = 1.0 - cos_theta;
541         float fac2 = fac * fac;
542         fac = fac2 * fac2 * fac;
543
544         /* Unreal specular matching : if specular color is below 2% intensity,
545          * (using green channel for intensity) treat as shadowning */
546         return saturate(50.0 * dot(f0, vec3(0.3, 0.6, 0.1))) * fac + (1.0 - fac) * f0;
547 }
548
549 /* Fresnel approximation for LTC area lights (not MRP) */
550 vec3 F_area(vec3 f0, vec2 lut)
551 {
552         vec2 fac = normalize(lut.xy); /* XXX FIXME this does not work!!! */
553
554         /* Unreal specular matching : if specular color is below 2% intensity,
555          * treat as shadowning */
556         return saturate(50.0 * dot(f0, vec3(0.3, 0.6, 0.1))) * fac.y + fac.x * f0;
557 }
558
559 /* Fresnel approximation for IBL */
560 vec3 F_ibl(vec3 f0, vec2 lut)
561 {
562         /* Unreal specular matching : if specular color is below 2% intensity,
563          * treat as shadowning */
564         return saturate(50.0 * dot(f0, vec3(0.3, 0.6, 0.1))) * lut.y + lut.x * f0;
565 }
566
567 /* GGX */
568 float D_ggx_opti(float NH, float a2)
569 {
570         float tmp = (NH * a2 - NH) * NH + 1.0;
571         return M_PI * tmp*tmp; /* Doing RCP and mul a2 at the end */
572 }
573
574 float G1_Smith_GGX(float NX, float a2)
575 {
576         /* Using Brian Karis approach and refactoring by NX/NX
577          * this way the (2*NL)*(2*NV) in G = G1(V) * G1(L) gets canceled by the brdf denominator 4*NL*NV
578          * Rcp is done on the whole G later
579          * Note that this is not convenient for the transmition formula */
580         return NX + sqrt(NX * (NX - NX * a2) + a2);
581         /* return 2 / (1 + sqrt(1 + a2 * (1 - NX*NX) / (NX*NX) ) ); /* Reference function */
582 }
583
584 float bsdf_ggx(vec3 N, vec3 L, vec3 V, float roughness)
585 {
586         float a = roughness;
587         float a2 = a * a;
588
589         vec3 H = normalize(L + V);
590         float NH = max(dot(N, H), 1e-8);
591         float NL = max(dot(N, L), 1e-8);
592         float NV = max(dot(N, V), 1e-8);
593
594         float G = G1_Smith_GGX(NV, a2) * G1_Smith_GGX(NL, a2); /* Doing RCP at the end */
595         float D = D_ggx_opti(NH, a2);
596
597         /* Denominator is canceled by G1_Smith */
598         /* bsdf = D * G / (4.0 * NL * NV); /* Reference function */
599         return NL * a2 / (D * G); /* NL to Fit cycles Equation : line. 345 in bsdf_microfacet.h */
600 }
601
602 void accumulate_light(vec3 light, float fac, inout vec4 accum)
603 {
604         accum += vec4(light, 1.0) * min(fac, (1.0 - accum.a));
605 }
606
607 /* ----------- Cone Apperture Approximation --------- */
608
609 /* Return a fitted cone angle given the input roughness */
610 float cone_cosine(float r)
611 {
612         /* Using phong gloss
613          * roughness = sqrt(2/(gloss+2)) */
614         float gloss = -2 + 2 / (r * r);
615         /* Drobot 2014 in GPUPro5 */
616         // return cos(2.0 * sqrt(2.0 / (gloss + 2)));
617         /* Uludag 2014 in GPUPro5 */
618         // return pow(0.244, 1 / (gloss + 1));
619         /* Jimenez 2016 in Practical Realtime Strategies for Accurate Indirect Occlusion*/
620         return exp2(-3.32193 * r * r);
621 }
622
623 /* --------- Closure ---------- */
624 #ifdef VOLUMETRICS
625
626 struct Closure {
627         vec3 absorption;
628         vec3 scatter;
629         vec3 emission;
630         float anisotropy;
631 };
632
633 #define CLOSURE_DEFAULT Closure(vec3(0.0), vec3(0.0), vec3(0.0), 0.0)
634
635 Closure closure_mix(Closure cl1, Closure cl2, float fac)
636 {
637         Closure cl;
638         cl.absorption = mix(cl1.absorption, cl2.absorption, fac);
639         cl.scatter = mix(cl1.scatter, cl2.scatter, fac);
640         cl.emission = mix(cl1.emission, cl2.emission, fac);
641         cl.anisotropy = mix(cl1.anisotropy, cl2.anisotropy, fac);
642         return cl;
643 }
644
645 Closure closure_add(Closure cl1, Closure cl2)
646 {
647         Closure cl;
648         cl.absorption = cl1.absorption + cl2.absorption;
649         cl.scatter = cl1.scatter + cl2.scatter;
650         cl.emission = cl1.emission + cl2.emission;
651         cl.anisotropy = (cl1.anisotropy + cl2.anisotropy) / 2.0; /* Average phase (no multi lobe) */
652         return cl;
653 }
654
655 #else /* VOLUMETRICS */
656
657 struct Closure {
658         vec3 radiance;
659         float opacity;
660 #  ifdef USE_SSS
661         vec4 sss_data;
662 #    ifdef USE_SSS_ALBEDO
663         vec3 sss_albedo;
664 #    endif
665 #  endif
666         vec4 ssr_data;
667         vec2 ssr_normal;
668         int ssr_id;
669 };
670
671 /* This is hacking ssr_id to tag transparent bsdf */
672 #define TRANSPARENT_CLOSURE_FLAG -2
673 #define REFRACT_CLOSURE_FLAG -3
674 #define NO_SSR -999
675
676 #  ifdef USE_SSS
677 #    ifdef USE_SSS_ALBEDO
678 #define CLOSURE_DEFAULT Closure(vec3(0.0), 1.0, vec4(0.0), vec3(0.0), vec4(0.0), vec2(0.0), -1)
679 #    else
680 #define CLOSURE_DEFAULT Closure(vec3(0.0), 1.0, vec4(0.0), vec4(0.0), vec2(0.0), -1)
681 #    endif
682 #  else
683 #define CLOSURE_DEFAULT Closure(vec3(0.0), 1.0, vec4(0.0), vec2(0.0), -1)
684 #  endif
685
686 uniform int outputSsrId;
687
688 Closure closure_mix(Closure cl1, Closure cl2, float fac)
689 {
690         Closure cl;
691
692         if (cl1.ssr_id == TRANSPARENT_CLOSURE_FLAG) {
693                 cl1.radiance = cl2.radiance;
694                 cl1.ssr_normal = cl2.ssr_normal;
695                 cl1.ssr_data = cl2.ssr_data;
696                 cl1.ssr_id = cl2.ssr_id;
697 #  ifdef USE_SSS
698                 cl1.sss_data = cl2.sss_data;
699 #    ifdef USE_SSS_ALBEDO
700                 cl1.sss_albedo = cl2.sss_albedo;
701 #    endif
702 #  endif
703         }
704         if (cl2.ssr_id == TRANSPARENT_CLOSURE_FLAG) {
705                 cl2.radiance = cl1.radiance;
706                 cl2.ssr_normal = cl1.ssr_normal;
707                 cl2.ssr_data = cl1.ssr_data;
708                 cl2.ssr_id = cl1.ssr_id;
709 #  ifdef USE_SSS
710                 cl2.sss_data = cl1.sss_data;
711 #    ifdef USE_SSS_ALBEDO
712                 cl2.sss_albedo = cl1.sss_albedo;
713 #    endif
714 #  endif
715         }
716         if (cl1.ssr_id == outputSsrId) {
717                 cl.ssr_data = mix(cl1.ssr_data.xyzw, vec4(vec3(0.0), cl1.ssr_data.w), fac); /* do not blend roughness */
718                 cl.ssr_normal = cl1.ssr_normal;
719                 cl.ssr_id = cl1.ssr_id;
720         }
721         else {
722                 cl.ssr_data = mix(vec4(vec3(0.0), cl2.ssr_data.w), cl2.ssr_data.xyzw, fac); /* do not blend roughness */
723                 cl.ssr_normal = cl2.ssr_normal;
724                 cl.ssr_id = cl2.ssr_id;
725         }
726         cl.radiance = mix(cl1.radiance, cl2.radiance, fac);
727         cl.opacity = mix(cl1.opacity, cl2.opacity, fac);
728
729 #  ifdef USE_SSS
730         cl.sss_data.rgb = mix(cl1.sss_data.rgb, cl2.sss_data.rgb, fac);
731         cl.sss_data.a = (cl1.sss_data.a > 0.0) ? cl1.sss_data.a : cl2.sss_data.a;
732 #    ifdef USE_SSS_ALBEDO
733         /* TODO Find a solution to this. Dither? */
734         cl.sss_albedo = (cl1.sss_data.a > 0.0) ? cl1.sss_albedo : cl2.sss_albedo;
735 #    endif
736 #  endif
737
738         return cl;
739 }
740
741 Closure closure_add(Closure cl1, Closure cl2)
742 {
743         Closure cl = (cl1.ssr_id == outputSsrId) ? cl1 : cl2;
744 #  ifdef USE_SSS
745         cl.sss_data = (cl1.sss_data.a > 0.0) ? cl1.sss_data : cl2.sss_data;
746 #    ifdef USE_SSS_ALBEDO
747         /* TODO Find a solution to this. Dither? */
748         cl.sss_albedo = (cl1.sss_data.a > 0.0) ? cl1.sss_albedo : cl2.sss_albedo;
749 #    endif
750 #  endif
751         cl.radiance = cl1.radiance + cl2.radiance;
752         cl.opacity = saturate(cl1.opacity + cl2.opacity);
753         return cl;
754 }
755
756 #  if defined(MESH_SHADER) && !defined(USE_ALPHA_HASH) && !defined(USE_ALPHA_CLIP) && !defined(SHADOW_SHADER) && !defined(USE_MULTIPLY)
757 layout(location = 0) out vec4 fragColor;
758 layout(location = 1) out vec4 ssrNormals;
759 layout(location = 2) out vec4 ssrData;
760 #    ifdef USE_SSS
761 layout(location = 3) out vec4 sssData;
762 #      ifdef USE_SSS_ALBEDO
763 layout(location = 4) out vec4 sssAlbedo;
764 #      endif /* USE_SSS_ALBEDO */
765 #    endif /* USE_SSS */
766
767 Closure nodetree_exec(void); /* Prototype */
768
769 #    if defined(USE_ALPHA_BLEND_VOLUMETRICS)
770 /* Prototype because this file is included before volumetric_lib.glsl */
771 vec4 volumetric_resolve(vec4 scene_color, vec2 frag_uvs, float frag_depth);
772 #    endif
773
774 #define NODETREE_EXEC
775 void main()
776 {
777         Closure cl = nodetree_exec();
778 #    ifndef USE_ALPHA_BLEND
779         /* Prevent alpha hash material writing into alpha channel. */
780         cl.opacity = 1.0;
781 #    endif
782
783 #    if defined(USE_ALPHA_BLEND_VOLUMETRICS)
784         /* XXX fragile, better use real viewport resolution */
785         vec2 uvs = gl_FragCoord.xy / vec2(2 * textureSize(maxzBuffer, 0).xy);
786         fragColor = volumetric_resolve(vec4(cl.radiance, cl.opacity), uvs, gl_FragCoord.z);
787 #    else
788         fragColor = vec4(cl.radiance, cl.opacity);
789 #    endif
790
791         ssrNormals = cl.ssr_normal.xyyy;
792         ssrData = cl.ssr_data;
793 #    ifdef USE_SSS
794         sssData = cl.sss_data;
795 #      ifdef USE_SSS_ALBEDO
796         sssAlbedo = cl.sss_albedo.rgbb;
797 #      endif
798 #    endif
799
800         /* For Probe capture */
801 #    ifdef USE_SSS
802 #      ifdef USE_SSS_ALBEDO
803         fragColor.rgb += cl.sss_data.rgb * cl.sss_albedo.rgb * float(!sssToggle);
804 #      else
805         fragColor.rgb += cl.sss_data.rgb * float(!sssToggle);
806 #      endif
807 #    endif
808 }
809
810 #  endif /* MESH_SHADER && !SHADOW_SHADER */
811
812 #endif /* VOLUMETRICS */
813
814 Closure nodetree_exec(void); /* Prototype */
815
816 /* TODO find a better place */
817 #ifdef USE_MULTIPLY
818
819 out vec4 fragColor;
820
821 #define NODETREE_EXEC
822 void main()
823 {
824         Closure cl = nodetree_exec();
825         fragColor = vec4(mix(vec3(1.0), cl.radiance, cl.opacity), 1.0);
826 }
827 #endif