0031037: Foundation Classes - add class Message_PrinterSystemLog for printing message...
[occt.git] / src / Shaders / RaytraceBase.fs
1 #ifdef ADAPTIVE_SAMPLING
2   #extension GL_ARB_shader_image_load_store : require
3 #endif
4 #ifdef ADAPTIVE_SAMPLING_ATOMIC
5   #extension GL_NV_shader_atomic_float : require
6 #endif
7
8 #ifdef USE_TEXTURES
9   #extension GL_ARB_bindless_texture : require
10 #endif
11
12 //! Normalized pixel coordinates.
13 in vec2 vPixel;
14
15 //! Sub-pixel offset in X direction for FSAA.
16 uniform float uOffsetX = 0.f;
17 //! Sub-pixel offset in Y direction for FSAA.
18 uniform float uOffsetY = 0.f;
19
20 //! Origin of viewing ray in left-top corner.
21 uniform vec3 uOriginLT;
22 //! Origin of viewing ray in left-bottom corner.
23 uniform vec3 uOriginLB;
24 //! Origin of viewing ray in right-top corner.
25 uniform vec3 uOriginRT;
26 //! Origin of viewing ray in right-bottom corner.
27 uniform vec3 uOriginRB;
28
29 //! Width of the rendering window.
30 uniform int uWinSizeX;
31 //! Height of the rendering window.
32 uniform int uWinSizeY;
33
34 //! Direction of viewing ray in left-top corner.
35 uniform vec3 uDirectLT;
36 //! Direction of viewing ray in left-bottom corner.
37 uniform vec3 uDirectLB;
38 //! Direction of viewing ray in right-top corner.
39 uniform vec3 uDirectRT;
40 //! Direction of viewing ray in right-bottom corner.
41 uniform vec3 uDirectRB;
42
43 //! Inverse model-view-projection matrix.
44 uniform mat4 uUnviewMat;
45
46 //! Model-view-projection matrix.
47 uniform mat4 uViewMat;
48
49 //! Texture buffer of data records of bottom-level BVH nodes.
50 uniform isamplerBuffer uSceneNodeInfoTexture;
51 //! Texture buffer of minimum points of bottom-level BVH nodes.
52 uniform samplerBuffer uSceneMinPointTexture;
53 //! Texture buffer of maximum points of bottom-level BVH nodes.
54 uniform samplerBuffer uSceneMaxPointTexture;
55 //! Texture buffer of transformations of high-level BVH nodes.
56 uniform samplerBuffer uSceneTransformTexture;
57
58 //! Texture buffer of vertex coords.
59 uniform samplerBuffer uGeometryVertexTexture;
60 //! Texture buffer of vertex normals.
61 uniform samplerBuffer uGeometryNormalTexture;
62 #ifdef USE_TEXTURES
63   //! Texture buffer of per-vertex UV-coordinates.
64   uniform samplerBuffer uGeometryTexCrdTexture;
65 #endif
66 //! Texture buffer of triangle indices.
67 uniform isamplerBuffer uGeometryTriangTexture;
68
69 //! Texture buffer of material properties.
70 uniform samplerBuffer uRaytraceMaterialTexture;
71 //! Texture buffer of light source properties.
72 uniform samplerBuffer uRaytraceLightSrcTexture;
73 //! Environment map texture.
74 uniform sampler2D uEnvironmentMapTexture;
75
76 //! Total number of light sources.
77 uniform int uLightCount;
78 //! Intensity of global ambient light.
79 uniform vec4 uGlobalAmbient;
80
81 //! Enables/disables hard shadows.
82 uniform int uShadowsEnabled;
83 //! Enables/disables specular reflections.
84 uniform int uReflectEnabled;
85 //! Enables/disables spherical environment map.
86 uniform int uSphereMapEnabled;
87 //! Enables/disables environment map background.
88 uniform int uSphereMapForBack;
89
90 //! Radius of bounding sphere of the scene.
91 uniform float uSceneRadius;
92 //! Scene epsilon to prevent self-intersections.
93 uniform float uSceneEpsilon;
94
95 #ifdef USE_TEXTURES
96   //! Unique 64-bit handles of OpenGL textures.
97   uniform uvec2 uTextureSamplers[MAX_TEX_NUMBER];
98 #endif
99
100 #ifdef ADAPTIVE_SAMPLING
101   //! OpenGL image used for accumulating rendering result.
102   volatile restrict layout(r32f) uniform image2D  uRenderImage;
103
104 #ifdef ADAPTIVE_SAMPLING_ATOMIC
105   //! OpenGL image storing offsets of sampled pixels blocks.
106   coherent restrict layout(rg32i) uniform iimage2D uOffsetImage;
107 #else
108   //! OpenGL image defining per-tile amount of samples.
109   volatile restrict layout(r32i) uniform iimage2D uTilesImage;
110 #endif
111
112   //! Screen space tile size.
113   uniform ivec2 uTileSize;
114 #endif
115
116 //! Top color of gradient background.
117 uniform vec4 uBackColorTop = vec4 (0.0);
118 //! Bottom color of gradient background.
119 uniform vec4 uBackColorBot = vec4 (0.0);
120
121 //! Aperture radius of camera used for depth-of-field
122 uniform float uApertureRadius = 0.f;
123
124 //! Focal distance of camera used for depth-of field
125 uniform float uFocalPlaneDist = 10.f;
126
127 //! Camera position used for projective mode
128 uniform vec3 uEyeOrig;
129
130 //! Camera view direction used for projective mode
131 uniform vec3 uEyeView;
132
133 //! Camera's screen vertical direction used for projective mode
134 uniform vec3 uEyeVert;
135
136 //! Camera's screen horizontal direction used for projective mode
137 uniform vec3 uEyeSide;
138
139 //! Camera's screen size used for projective mode
140 uniform vec2 uEyeSize;
141
142 /////////////////////////////////////////////////////////////////////////////////////////
143 // Specific data types
144
145 //! Stores ray parameters.
146 struct SRay
147 {
148   vec3 Origin;
149
150   vec3 Direct;
151 };
152
153 //! Stores intersection parameters.
154 struct SIntersect
155 {
156   float Time;
157
158   vec2 UV;
159
160   vec3 Normal;
161 };
162
163 /////////////////////////////////////////////////////////////////////////////////////////
164 // Some useful constants
165
166 #define MAXFLOAT 1e15f
167
168 #define SMALL vec3 (exp2 (-80.0f))
169
170 #define ZERO vec3 (0.0f, 0.0f, 0.0f)
171 #define UNIT vec3 (1.0f, 1.0f, 1.0f)
172
173 #define AXIS_X vec3 (1.0f, 0.0f, 0.0f)
174 #define AXIS_Y vec3 (0.0f, 1.0f, 0.0f)
175 #define AXIS_Z vec3 (0.0f, 0.0f, 1.0f)
176
177 #define M_PI   3.141592653f
178 #define M_2_PI 6.283185307f
179 #define M_PI_2 1.570796327f
180
181 #define LUMA vec3 (0.2126f, 0.7152f, 0.0722f)
182
183 // =======================================================================
184 // function : MatrixRowMultiplyDir
185 // purpose  : Multiplies a vector by matrix
186 // =======================================================================
187 vec3 MatrixRowMultiplyDir (in vec3 v,
188                            in vec4 m0,
189                            in vec4 m1,
190                            in vec4 m2)
191 {
192   return vec3 (dot (m0.xyz, v),
193                dot (m1.xyz, v),
194                dot (m2.xyz, v));
195 }
196
197 //! 32-bit state of random number generator.
198 uint RandState;
199
200 // =======================================================================
201 // function : SeedRand
202 // purpose  : Applies hash function by Thomas Wang to randomize seeds
203 //            (see http://www.burtleburtle.net/bob/hash/integer.html)
204 // =======================================================================
205 void SeedRand (in int theSeed, in int theSizeX, in int theRadius)
206 {
207   RandState = uint (int (gl_FragCoord.y) / theRadius * theSizeX + int (gl_FragCoord.x) / theRadius + theSeed);
208
209   RandState = (RandState + 0x479ab41du) + (RandState <<  8);
210   RandState = (RandState ^ 0xe4aa10ceu) ^ (RandState >>  5);
211   RandState = (RandState + 0x9942f0a6u) - (RandState << 14);
212   RandState = (RandState ^ 0x5aedd67du) ^ (RandState >>  3);
213   RandState = (RandState + 0x17bea992u) + (RandState <<  7);
214 }
215
216 // =======================================================================
217 // function : RandInt
218 // purpose  : Generates integer using Xorshift algorithm by G. Marsaglia
219 // =======================================================================
220 uint RandInt()
221 {
222   RandState ^= (RandState << 13);
223   RandState ^= (RandState >> 17);
224   RandState ^= (RandState <<  5);
225
226   return RandState;
227 }
228
229 // =======================================================================
230 // function : RandFloat
231 // purpose  : Generates a random float in 0 <= x < 1 range
232 // =======================================================================
233 float RandFloat()
234 {
235   return float (RandInt()) * (1.f / 4294967296.f);
236 }
237
238 // =======================================================================
239 // function : MatrixColMultiplyPnt
240 // purpose  : Multiplies a vector by matrix
241 // =======================================================================
242 vec3 MatrixColMultiplyPnt (in vec3 v,
243                            in vec4 m0,
244                            in vec4 m1,
245                            in vec4 m2,
246                            in vec4 m3)
247 {
248   return vec3 (m0.x * v.x + m1.x * v.y + m2.x * v.z + m3.x,
249                m0.y * v.x + m1.y * v.y + m2.y * v.z + m3.y,
250                m0.z * v.x + m1.z * v.y + m2.z * v.z + m3.z);
251 }
252
253 // =======================================================================
254 // function : MatrixColMultiplyDir
255 // purpose  : Multiplies a vector by matrix
256 // =======================================================================
257 vec3 MatrixColMultiplyDir (in vec3 v,
258                            in vec4 m0,
259                            in vec4 m1,
260                            in vec4 m2)
261 {
262   return vec3 (m0.x * v.x + m1.x * v.y + m2.x * v.z,
263                m0.y * v.x + m1.y * v.y + m2.y * v.z,
264                m0.z * v.x + m1.z * v.y + m2.z * v.z);
265 }
266
267 //=======================================================================
268 // function : InverseDirection
269 // purpose  : Returns safely inverted direction of the given one
270 //=======================================================================
271 vec3 InverseDirection (in vec3 theInput)
272 {
273   vec3 anInverse = 1.f / max (abs (theInput), SMALL);
274
275   return mix (-anInverse, anInverse, step (ZERO, theInput));
276 }
277
278 //=======================================================================
279 // function : BackgroundColor
280 // purpose  : Returns color of gradient background
281 //=======================================================================
282 vec4 BackgroundColor()
283 {
284 #ifdef ADAPTIVE_SAMPLING_ATOMIC
285
286   ivec2 aFragCoord = ivec2 (gl_FragCoord.xy);
287
288   ivec2 aTileXY = imageLoad (uOffsetImage, aFragCoord / uTileSize).xy * uTileSize;
289
290   aTileXY.y += aFragCoord.y % min (uWinSizeY - aTileXY.y, uTileSize.y);
291
292   return mix (uBackColorBot, uBackColorTop, float (aTileXY.y) / uWinSizeY);
293
294 #else
295
296   return mix (uBackColorBot, uBackColorTop, vPixel.y);
297
298 #endif
299 }
300
301 /////////////////////////////////////////////////////////////////////////////////////////
302 // Functions for compute ray-object intersection
303
304 //=======================================================================
305 // function : sampleUniformDisk
306 // purpose  :
307 //=======================================================================
308 vec2 sampleUniformDisk ()
309 {
310   vec2 aPoint;
311
312   float aKsi1 = 2.f * RandFloat () - 1.f;
313   float aKsi2 = 2.f * RandFloat () - 1.f;
314
315   if (aKsi1 > -aKsi2)
316   {
317     if (aKsi1 > aKsi2)
318       aPoint = vec2 (aKsi1, (M_PI / 4.f) * (0.f + aKsi2 / aKsi1));
319     else
320       aPoint = vec2 (aKsi2, (M_PI / 4.f) * (2.f - aKsi1 / aKsi2));
321   }
322   else
323   {
324     if (aKsi1 < aKsi2)
325       aPoint = vec2 (-aKsi1, (M_PI / 4.f) * (4.f + aKsi2 / aKsi1));
326     else
327       aPoint = vec2 (-aKsi2, (M_PI / 4.f) * (6.f - aKsi1 / aKsi2));
328   }
329
330   return vec2 (sin (aPoint.y), cos (aPoint.y)) * aPoint.x;
331 }
332
333 // =======================================================================
334 // function : GenerateRay
335 // purpose  :
336 // =======================================================================
337 SRay GenerateRay (in vec2 thePixel)
338 {
339 #ifndef DEPTH_OF_FIELD
340
341   vec3 aP0 = mix (uOriginLB, uOriginRB, thePixel.x);
342   vec3 aP1 = mix (uOriginLT, uOriginRT, thePixel.x);
343
344   vec3 aD0 = mix (uDirectLB, uDirectRB, thePixel.x);
345   vec3 aD1 = mix (uDirectLT, uDirectRT, thePixel.x);
346
347   vec3 aDirection = normalize (mix (aD0, aD1, thePixel.y));
348
349   return SRay (mix (aP0, aP1, thePixel.y), aDirection);
350
351 #else
352
353   vec2 aPixel = uEyeSize * (thePixel - vec2 (0.5f)) * 2.f;
354
355   vec2 aAperturePnt = sampleUniformDisk () * uApertureRadius;
356
357   vec3 aLocalDir = normalize (vec3 (
358     aPixel * uFocalPlaneDist - aAperturePnt, uFocalPlaneDist));
359
360   vec3 aOrigin = uEyeOrig +
361                  uEyeSide * aAperturePnt.x +
362                  uEyeVert * aAperturePnt.y;
363
364   vec3 aDirect = uEyeView * aLocalDir.z +
365                  uEyeSide * aLocalDir.x +
366                  uEyeVert * aLocalDir.y;
367
368   return SRay (aOrigin, aDirect);
369
370 #endif
371 }
372
373 // =======================================================================
374 // function : IntersectSphere
375 // purpose  : Computes ray-sphere intersection
376 // =======================================================================
377 float IntersectSphere (in SRay theRay, in float theRadius)
378 {
379   float aDdotD = dot (theRay.Direct, theRay.Direct);
380   float aDdotO = dot (theRay.Direct, theRay.Origin);
381   float aOdotO = dot (theRay.Origin, theRay.Origin);
382
383   float aD = aDdotO * aDdotO - aDdotD * (aOdotO - theRadius * theRadius);
384
385   if (aD > 0.0f)
386   {
387     float aTime = (sqrt (aD) - aDdotO) * (1.0f / aDdotD);
388     
389     return aTime > 0.0f ? aTime : MAXFLOAT;
390   }
391
392   return MAXFLOAT;
393 }
394
395 // =======================================================================
396 // function : IntersectTriangle
397 // purpose  : Computes ray-triangle intersection (branchless version)
398 // =======================================================================
399 void IntersectTriangle (in SRay theRay,
400                         in vec3 thePnt0,
401                         in vec3 thePnt1,
402                         in vec3 thePnt2,
403                         out vec3 theUVT,
404                         out vec3 theNorm)
405 {
406   vec3 aToTrg = thePnt0 - theRay.Origin;
407
408   vec3 aEdge0 = thePnt1 - thePnt0;
409   vec3 aEdge1 = thePnt0 - thePnt2;
410
411   theNorm = cross (aEdge1, aEdge0);
412
413   vec3 theVect = cross (theRay.Direct, aToTrg);
414
415   theUVT = vec3 (dot (theNorm, aToTrg),
416                  dot (theVect, aEdge1),
417                  dot (theVect, aEdge0)) * (1.f / dot (theNorm, theRay.Direct));
418
419   theUVT.x = any (lessThan (theUVT, ZERO)) || (theUVT.y + theUVT.z) > 1.f ? MAXFLOAT : theUVT.x;
420 }
421
422 #define EMPTY_ROOT ivec4(0)
423
424 //! Utility structure containing information about
425 //! currently traversing sub-tree of scene's BVH.
426 struct SSubTree
427 {
428   //! Transformed ray.
429   SRay  TrsfRay;
430
431   //! Inversed ray direction.
432   vec3  Inverse;
433
434   //! Parameters of sub-root node.
435   ivec4 SubData;
436 };
437
438 #define MATERIAL_AMBN(index) (19 * index + 0)
439 #define MATERIAL_DIFF(index) (19 * index + 1)
440 #define MATERIAL_SPEC(index) (19 * index + 2)
441 #define MATERIAL_EMIS(index) (19 * index + 3)
442 #define MATERIAL_REFL(index) (19 * index + 4)
443 #define MATERIAL_REFR(index) (19 * index + 5)
444 #define MATERIAL_TRAN(index) (19 * index + 6)
445 #define MATERIAL_TRS1(index) (19 * index + 7)
446 #define MATERIAL_TRS2(index) (19 * index + 8)
447 #define MATERIAL_TRS3(index) (19 * index + 9)
448
449 #define TRS_OFFSET(treelet) treelet.SubData.x
450 #define BVH_OFFSET(treelet) treelet.SubData.y
451 #define VRT_OFFSET(treelet) treelet.SubData.z
452 #define TRG_OFFSET(treelet) treelet.SubData.w
453
454 //! Identifies the absence of intersection.
455 #define INALID_HIT ivec4 (-1)
456
457 //! Global stack shared between traversal functions.
458 int Stack[STACK_SIZE];
459
460 // =======================================================================
461 // function : pop
462 // purpose  :
463 // =======================================================================
464 int pop (inout int theHead)
465 {
466   int aData = Stack[theHead];
467
468   int aMask = aData >> 26;
469   int aNode = aMask & 0x3;
470
471   aMask >>= 2;
472
473   if ((aMask & 0x3) == aNode)
474   {
475     --theHead;
476   }
477   else
478   {
479     aMask |= (aMask << 2) & 0x30;
480
481     Stack[theHead] = (aData & 0x03FFFFFF) | (aMask << 26);
482   }
483
484   return (aData & 0x03FFFFFF) + aNode;
485 }
486
487 // =======================================================================
488 // function : SceneNearestHit
489 // purpose  : Finds intersection with nearest scene triangle
490 // =======================================================================
491 ivec4 SceneNearestHit (in SRay theRay, in vec3 theInverse, inout SIntersect theHit, out int theTrsfId)
492 {
493   ivec4 aTriIndex = INALID_HIT;
494
495   int aNode =  0; // node to traverse
496   int aHead = -1; // pointer of stack
497   int aStop = -1; // BVH level switch
498
499   SSubTree aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
500
501   for (bool toContinue = true; toContinue; /* none */)
502   {
503     ivec4 aData = texelFetch (uSceneNodeInfoTexture, aNode);
504
505     if (aData.x == 0) // if inner node
506     {
507       aData.y += BVH_OFFSET (aSubTree);
508
509       vec4 aHitTimes = vec4 (MAXFLOAT,
510                              MAXFLOAT,
511                              MAXFLOAT,
512                              MAXFLOAT);
513
514       vec3 aRayOriginInverse = -aSubTree.TrsfRay.Origin * aSubTree.Inverse;
515
516       vec3 aNodeMin0 = texelFetch (uSceneMinPointTexture, aData.y +                0).xyz * aSubTree.Inverse + aRayOriginInverse;
517       vec3 aNodeMin1 = texelFetch (uSceneMinPointTexture, aData.y +                1).xyz * aSubTree.Inverse + aRayOriginInverse;
518       vec3 aNodeMin2 = texelFetch (uSceneMinPointTexture, aData.y + min (2, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
519       vec3 aNodeMin3 = texelFetch (uSceneMinPointTexture, aData.y + min (3, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
520       vec3 aNodeMax0 = texelFetch (uSceneMaxPointTexture, aData.y +                0).xyz * aSubTree.Inverse + aRayOriginInverse;
521       vec3 aNodeMax1 = texelFetch (uSceneMaxPointTexture, aData.y +                1).xyz * aSubTree.Inverse + aRayOriginInverse;
522       vec3 aNodeMax2 = texelFetch (uSceneMaxPointTexture, aData.y + min (2, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
523       vec3 aNodeMax3 = texelFetch (uSceneMaxPointTexture, aData.y + min (3, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
524
525       vec3 aTimeMax = max (aNodeMin0, aNodeMax0);
526       vec3 aTimeMin = min (aNodeMin0, aNodeMax0);
527
528       float aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
529       float aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
530
531       aHitTimes.x = (aTimeEnter <= aTimeLeave && aTimeEnter <= theHit.Time && aTimeLeave >= 0.f) ? aTimeEnter : MAXFLOAT;
532
533       aTimeMax = max (aNodeMin1, aNodeMax1);
534       aTimeMin = min (aNodeMin1, aNodeMax1);
535
536       aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
537       aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
538
539       aHitTimes.y = (aTimeEnter <= aTimeLeave && aTimeEnter <= theHit.Time && aTimeLeave >= 0.f) ? aTimeEnter : MAXFLOAT;
540
541       aTimeMax = max (aNodeMin2, aNodeMax2);
542       aTimeMin = min (aNodeMin2, aNodeMax2);
543
544       aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
545       aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
546
547       aHitTimes.z = (aTimeEnter <= aTimeLeave && aTimeEnter <= theHit.Time && aTimeLeave >= 0.f && aData.z > 1) ? aTimeEnter : MAXFLOAT;
548
549       aTimeMax = max (aNodeMin3, aNodeMax3);
550       aTimeMin = min (aNodeMin3, aNodeMax3);
551
552       aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
553       aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
554
555       aHitTimes.w = (aTimeEnter <= aTimeLeave && aTimeEnter <= theHit.Time && aTimeLeave >= 0.f && aData.z > 2) ? aTimeEnter : MAXFLOAT;
556
557       ivec4 aChildren = ivec4 (0, 1, 2, 3);
558
559       aChildren.xy = aHitTimes.y < aHitTimes.x ? aChildren.yx : aChildren.xy;
560       aHitTimes.xy = aHitTimes.y < aHitTimes.x ? aHitTimes.yx : aHitTimes.xy;
561       aChildren.zw = aHitTimes.w < aHitTimes.z ? aChildren.wz : aChildren.zw;
562       aHitTimes.zw = aHitTimes.w < aHitTimes.z ? aHitTimes.wz : aHitTimes.zw;
563       aChildren.xz = aHitTimes.z < aHitTimes.x ? aChildren.zx : aChildren.xz;
564       aHitTimes.xz = aHitTimes.z < aHitTimes.x ? aHitTimes.zx : aHitTimes.xz;
565       aChildren.yw = aHitTimes.w < aHitTimes.y ? aChildren.wy : aChildren.yw;
566       aHitTimes.yw = aHitTimes.w < aHitTimes.y ? aHitTimes.wy : aHitTimes.yw;
567       aChildren.yz = aHitTimes.z < aHitTimes.y ? aChildren.zy : aChildren.yz;
568       aHitTimes.yz = aHitTimes.z < aHitTimes.y ? aHitTimes.zy : aHitTimes.yz;
569
570       if (aHitTimes.x != MAXFLOAT)
571       {
572         int aHitMask = (aHitTimes.w != MAXFLOAT ? aChildren.w : aChildren.z) << 2
573                      | (aHitTimes.z != MAXFLOAT ? aChildren.z : aChildren.y);
574
575         if (aHitTimes.y != MAXFLOAT)
576           Stack[++aHead] = aData.y | (aHitMask << 2 | aChildren.y) << 26;
577
578         aNode = aData.y + aChildren.x;
579       }
580       else
581       {
582         toContinue = (aHead >= 0);
583
584         if (aHead == aStop) // go to top-level BVH
585         {
586           aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
587         }
588
589         if (aHead >= 0)
590           aNode = pop (aHead);
591       }
592     }
593     else if (aData.x < 0) // leaf node (contains triangles)
594     {
595       vec3 aNormal;
596       vec3 aTimeUV;
597
598       for (int anIdx = aData.y; anIdx <= aData.z; ++anIdx)
599       {
600         ivec4 aTriangle = texelFetch (uGeometryTriangTexture, anIdx + TRG_OFFSET (aSubTree));
601
602         vec3 aPoint0 = texelFetch (uGeometryVertexTexture, aTriangle.x += VRT_OFFSET (aSubTree)).xyz;
603         vec3 aPoint1 = texelFetch (uGeometryVertexTexture, aTriangle.y += VRT_OFFSET (aSubTree)).xyz;
604         vec3 aPoint2 = texelFetch (uGeometryVertexTexture, aTriangle.z += VRT_OFFSET (aSubTree)).xyz;
605
606         IntersectTriangle (aSubTree.TrsfRay, aPoint0, aPoint1, aPoint2, aTimeUV, aNormal);
607
608         if (aTimeUV.x < theHit.Time)
609         {
610           aTriIndex = aTriangle;
611
612           theTrsfId = TRS_OFFSET (aSubTree);
613
614           theHit = SIntersect (aTimeUV.x, aTimeUV.yz, aNormal);
615         }
616       }
617
618       toContinue = (aHead >= 0);
619
620       if (aHead == aStop) // go to top-level BVH
621       {
622         aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
623       }
624
625       if (aHead >= 0)
626         aNode = pop (aHead);
627     }
628     else if (aData.x > 0) // switch node
629     {
630       aSubTree.SubData = ivec4 (4 * aData.x - 4, aData.yzw); // store BVH sub-root
631
632       vec4 aInvTransf0 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 0);
633       vec4 aInvTransf1 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 1);
634       vec4 aInvTransf2 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 2);
635       vec4 aInvTransf3 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 3);
636
637       aSubTree.TrsfRay.Direct = MatrixColMultiplyDir (theRay.Direct,
638                                                       aInvTransf0,
639                                                       aInvTransf1,
640                                                       aInvTransf2);
641
642       aSubTree.Inverse = mix (-UNIT, UNIT, step (ZERO, aSubTree.TrsfRay.Direct)) /
643         max (abs (aSubTree.TrsfRay.Direct), SMALL);
644
645       aSubTree.TrsfRay.Origin = MatrixColMultiplyPnt (theRay.Origin,
646                                                       aInvTransf0,
647                                                       aInvTransf1,
648                                                       aInvTransf2,
649                                                       aInvTransf3);
650
651       aNode = BVH_OFFSET (aSubTree); // go to sub-root node
652
653       aStop = aHead; // store current stack pointer
654     }
655   }
656
657   return aTriIndex;
658 }
659
660 // =======================================================================
661 // function : SceneAnyHit
662 // purpose  : Finds intersection with any scene triangle
663 // =======================================================================
664 float SceneAnyHit (in SRay theRay, in vec3 theInverse, in float theDistance)
665 {
666   float aFactor = 1.f;
667
668   int aNode =  0; // node to traverse
669   int aHead = -1; // pointer of stack
670   int aStop = -1; // BVH level switch
671
672   SSubTree aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
673
674   for (bool toContinue = true; toContinue; /* none */)
675   {
676     ivec4 aData = texelFetch (uSceneNodeInfoTexture, aNode);
677
678     if (aData.x == 0) // if inner node
679     {
680       aData.y += BVH_OFFSET (aSubTree);
681
682       vec4 aHitTimes = vec4 (MAXFLOAT,
683                              MAXFLOAT,
684                              MAXFLOAT,
685                              MAXFLOAT);
686
687       vec3 aRayOriginInverse = -aSubTree.TrsfRay.Origin * aSubTree.Inverse;
688
689       vec3 aNodeMin0 = texelFetch (uSceneMinPointTexture, aData.y +                0).xyz * aSubTree.Inverse + aRayOriginInverse;
690       vec3 aNodeMin1 = texelFetch (uSceneMinPointTexture, aData.y +                1).xyz * aSubTree.Inverse + aRayOriginInverse;
691       vec3 aNodeMin2 = texelFetch (uSceneMinPointTexture, aData.y + min (2, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
692       vec3 aNodeMin3 = texelFetch (uSceneMinPointTexture, aData.y + min (3, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
693       vec3 aNodeMax0 = texelFetch (uSceneMaxPointTexture, aData.y +                0).xyz * aSubTree.Inverse + aRayOriginInverse;
694       vec3 aNodeMax1 = texelFetch (uSceneMaxPointTexture, aData.y +                1).xyz * aSubTree.Inverse + aRayOriginInverse;
695       vec3 aNodeMax2 = texelFetch (uSceneMaxPointTexture, aData.y + min (2, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
696       vec3 aNodeMax3 = texelFetch (uSceneMaxPointTexture, aData.y + min (3, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
697
698       vec3 aTimeMax = max (aNodeMin0, aNodeMax0);
699       vec3 aTimeMin = min (aNodeMin0, aNodeMax0);
700
701       float aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
702       float aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
703
704       aHitTimes.x = (aTimeEnter <= aTimeLeave && aTimeEnter <= theDistance && aTimeLeave >= 0.f) ? aTimeEnter : MAXFLOAT;
705
706       aTimeMax = max (aNodeMin1, aNodeMax1);
707       aTimeMin = min (aNodeMin1, aNodeMax1);
708
709       aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
710       aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
711
712       aHitTimes.y = (aTimeEnter <= aTimeLeave && aTimeEnter <= theDistance && aTimeLeave >= 0.f) ? aTimeEnter : MAXFLOAT;
713
714       aTimeMax = max (aNodeMin2, aNodeMax2);
715       aTimeMin = min (aNodeMin2, aNodeMax2);
716
717       aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
718       aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
719
720       aHitTimes.z = (aTimeEnter <= aTimeLeave && aTimeEnter <= theDistance && aTimeLeave >= 0.f && aData.z > 1) ? aTimeEnter : MAXFLOAT;
721
722       aTimeMax = max (aNodeMin3, aNodeMax3);
723       aTimeMin = min (aNodeMin3, aNodeMax3);
724
725       aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
726       aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
727
728       aHitTimes.w = (aTimeEnter <= aTimeLeave && aTimeEnter <= theDistance && aTimeLeave >= 0.f && aData.z > 2) ? aTimeEnter : MAXFLOAT;
729
730       ivec4 aChildren = ivec4 (0, 1, 2, 3);
731
732       aChildren.xy = aHitTimes.y < aHitTimes.x ? aChildren.yx : aChildren.xy;
733       aHitTimes.xy = aHitTimes.y < aHitTimes.x ? aHitTimes.yx : aHitTimes.xy;
734       aChildren.zw = aHitTimes.w < aHitTimes.z ? aChildren.wz : aChildren.zw;
735       aHitTimes.zw = aHitTimes.w < aHitTimes.z ? aHitTimes.wz : aHitTimes.zw;
736       aChildren.xz = aHitTimes.z < aHitTimes.x ? aChildren.zx : aChildren.xz;
737       aHitTimes.xz = aHitTimes.z < aHitTimes.x ? aHitTimes.zx : aHitTimes.xz;
738       aChildren.yw = aHitTimes.w < aHitTimes.y ? aChildren.wy : aChildren.yw;
739       aHitTimes.yw = aHitTimes.w < aHitTimes.y ? aHitTimes.wy : aHitTimes.yw;
740       aChildren.yz = aHitTimes.z < aHitTimes.y ? aChildren.zy : aChildren.yz;
741       aHitTimes.yz = aHitTimes.z < aHitTimes.y ? aHitTimes.zy : aHitTimes.yz;
742
743       if (aHitTimes.x != MAXFLOAT)
744       {
745         int aHitMask = (aHitTimes.w != MAXFLOAT ? aChildren.w : aChildren.z) << 2
746                      | (aHitTimes.z != MAXFLOAT ? aChildren.z : aChildren.y);
747
748         if (aHitTimes.y != MAXFLOAT)
749           Stack[++aHead] = aData.y | (aHitMask << 2 | aChildren.y) << 26;
750
751         aNode = aData.y + aChildren.x;
752       }
753       else
754       {
755         toContinue = (aHead >= 0);
756
757         if (aHead == aStop) // go to top-level BVH
758         {
759           aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
760         }
761
762         if (aHead >= 0)
763           aNode = pop (aHead);
764       }
765     }
766     else if (aData.x < 0) // leaf node
767     {
768       vec3 aNormal;
769       vec3 aTimeUV;
770
771       for (int anIdx = aData.y; anIdx <= aData.z; ++anIdx)
772       {
773         ivec4 aTriangle = texelFetch (uGeometryTriangTexture, anIdx + TRG_OFFSET (aSubTree));
774
775         vec3 aPoint0 = texelFetch (uGeometryVertexTexture, aTriangle.x += VRT_OFFSET (aSubTree)).xyz;
776         vec3 aPoint1 = texelFetch (uGeometryVertexTexture, aTriangle.y += VRT_OFFSET (aSubTree)).xyz;
777         vec3 aPoint2 = texelFetch (uGeometryVertexTexture, aTriangle.z += VRT_OFFSET (aSubTree)).xyz;
778
779         IntersectTriangle (aSubTree.TrsfRay, aPoint0, aPoint1, aPoint2, aTimeUV, aNormal);
780
781 #ifdef TRANSPARENT_SHADOWS
782         if (aTimeUV.x < theDistance)
783         {
784           aFactor *= 1.f - texelFetch (uRaytraceMaterialTexture, MATERIAL_TRAN (aTriangle.w)).x;
785         }
786 #else
787         if (aTimeUV.x < theDistance)
788         {
789           aFactor = 0.f;
790         }
791 #endif
792       }
793
794       toContinue = (aHead >= 0) && (aFactor > 0.1f);
795
796       if (aHead == aStop) // go to top-level BVH
797       {
798         aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
799       }
800
801       if (aHead >= 0)
802         aNode = pop (aHead);
803     }
804     else if (aData.x > 0) // switch node
805     {
806       aSubTree.SubData = ivec4 (4 * aData.x - 4, aData.yzw); // store BVH sub-root
807
808       vec4 aInvTransf0 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 0);
809       vec4 aInvTransf1 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 1);
810       vec4 aInvTransf2 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 2);
811       vec4 aInvTransf3 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 3);
812
813       aSubTree.TrsfRay.Direct = MatrixColMultiplyDir (theRay.Direct,
814                                                       aInvTransf0,
815                                                       aInvTransf1,
816                                                       aInvTransf2);
817
818       aSubTree.TrsfRay.Origin = MatrixColMultiplyPnt (theRay.Origin,
819                                                       aInvTransf0,
820                                                       aInvTransf1,
821                                                       aInvTransf2,
822                                                       aInvTransf3);
823
824       aSubTree.Inverse = mix (-UNIT, UNIT, step (ZERO, aSubTree.TrsfRay.Direct)) / max (abs (aSubTree.TrsfRay.Direct), SMALL);
825
826       aNode = BVH_OFFSET (aSubTree); // go to sub-root node
827
828       aStop = aHead; // store current stack pointer
829     }
830   }
831
832   return aFactor;
833 }
834
835 #define PI 3.1415926f
836
837 // =======================================================================
838 // function : Latlong
839 // purpose  : Converts world direction to environment texture coordinates
840 // =======================================================================
841 vec2 Latlong (in vec3 thePoint, in float theRadius)
842 {
843   float aPsi = acos (-thePoint.z / theRadius);
844
845   float aPhi = atan (thePoint.y, thePoint.x) + PI;
846
847   return vec2 (aPhi * 0.1591549f,
848                aPsi * 0.3183098f);
849 }
850
851 // =======================================================================
852 // function : SmoothNormal
853 // purpose  : Interpolates normal across the triangle
854 // =======================================================================
855 vec3 SmoothNormal (in vec2 theUV, in ivec4 theTriangle)
856 {
857   vec3 aNormal0 = texelFetch (uGeometryNormalTexture, theTriangle.x).xyz;
858   vec3 aNormal1 = texelFetch (uGeometryNormalTexture, theTriangle.y).xyz;
859   vec3 aNormal2 = texelFetch (uGeometryNormalTexture, theTriangle.z).xyz;
860
861   return normalize (aNormal1 * theUV.x +
862                     aNormal2 * theUV.y +
863                     aNormal0 * (1.0f - theUV.x - theUV.y));
864 }
865
866 #define POLYGON_OFFSET_UNIT 0.f
867 #define POLYGON_OFFSET_FACTOR 1.f
868 #define POLYGON_OFFSET_SCALE 0.006f
869
870 // =======================================================================
871 // function : PolygonOffset
872 // purpose  : Computes OpenGL polygon offset
873 // =======================================================================
874 float PolygonOffset (in vec3 theNormal, in vec3 thePoint)
875 {
876   vec4 aProjectedNorm = vec4 (theNormal, -dot (theNormal, thePoint)) * uUnviewMat;
877
878   float aPolygonOffset = POLYGON_OFFSET_UNIT;
879
880   if (aProjectedNorm.z * aProjectedNorm.z > 1e-20f)
881   {
882     aProjectedNorm.xy *= 1.f / aProjectedNorm.z;
883
884     aPolygonOffset += POLYGON_OFFSET_FACTOR * max (abs (aProjectedNorm.x),
885                                                    abs (aProjectedNorm.y));
886   }
887
888   return aPolygonOffset;
889 }
890
891 // =======================================================================
892 // function : SmoothUV
893 // purpose  : Interpolates UV coordinates across the triangle
894 // =======================================================================
895 #ifdef USE_TEXTURES
896 vec2 SmoothUV (in vec2 theUV, in ivec4 theTriangle)
897 {
898   vec2 aTexCrd0 = texelFetch (uGeometryTexCrdTexture, theTriangle.x).st;
899   vec2 aTexCrd1 = texelFetch (uGeometryTexCrdTexture, theTriangle.y).st;
900   vec2 aTexCrd2 = texelFetch (uGeometryTexCrdTexture, theTriangle.z).st;
901
902   return aTexCrd1 * theUV.x +
903          aTexCrd2 * theUV.y +
904          aTexCrd0 * (1.0f - theUV.x - theUV.y);
905 }
906 #endif
907
908 // =======================================================================
909 // function : FetchEnvironment
910 // purpose  :
911 // =======================================================================
912 vec4 FetchEnvironment (in vec2 theTexCoord)
913 {
914   return uSphereMapEnabled == 0 ?
915     vec4 (0.f, 0.f, 0.f, 1.f) : textureLod (uEnvironmentMapTexture, theTexCoord, 0.f);
916 }
917
918 // =======================================================================
919 // function : Refract
920 // purpose  : Computes refraction ray (also handles TIR)
921 // =======================================================================
922 #ifndef PATH_TRACING
923 vec3 Refract (in vec3 theInput,
924               in vec3 theNormal,
925               in float theRefractIndex,
926               in float theInvRefractIndex)
927 {
928   float aNdotI = dot (theInput, theNormal);
929
930   float anIndex = aNdotI < 0.0f
931                 ? theInvRefractIndex
932                 : theRefractIndex;
933
934   float aSquare = anIndex * anIndex * (1.0f - aNdotI * aNdotI);
935
936   if (aSquare > 1.0f)
937   {
938     return reflect (theInput, theNormal);
939   }
940
941   float aNdotT = sqrt (1.0f - aSquare);
942
943   return normalize (anIndex * theInput -
944     (anIndex * aNdotI + (aNdotI < 0.0f ? aNdotT : -aNdotT)) * theNormal);
945 }
946 #endif
947
948 #define MIN_SLOPE 0.0001f
949 #define EPS_SCALE 8.0000f
950
951 #define THRESHOLD vec3 (0.1f)
952
953 #define INVALID_BOUNCES 1000
954
955 #define LIGHT_POS(index) (2 * index + 1)
956 #define LIGHT_PWR(index) (2 * index + 0)
957
958 // =======================================================================
959 // function : Radiance
960 // purpose  : Computes color along the given ray
961 // =======================================================================
962 #ifndef PATH_TRACING
963 vec4 Radiance (in SRay theRay, in vec3 theInverse)
964 {
965   vec3 aResult = vec3 (0.0f);
966   vec4 aWeight = vec4 (1.0f);
967
968   int aTrsfId;
969
970   float aRaytraceDepth = MAXFLOAT;
971
972   for (int aDepth = 0; aDepth < NB_BOUNCES; ++aDepth)
973   {
974     SIntersect aHit = SIntersect (MAXFLOAT, vec2 (ZERO), ZERO);
975
976     ivec4 aTriIndex = SceneNearestHit (theRay, theInverse, aHit, aTrsfId);
977
978     if (aTriIndex.x == -1)
979     {
980       vec4 aColor = vec4 (0.0);
981
982       if (bool(uSphereMapForBack) || aWeight.w == 0.0f /* reflection */)
983       {
984         float aTime = IntersectSphere (theRay, uSceneRadius);
985
986         aColor = FetchEnvironment (Latlong (
987           theRay.Direct * aTime + theRay.Origin, uSceneRadius));
988       }
989       else
990       {
991         aColor = BackgroundColor();
992       }
993
994       aResult += aWeight.xyz * aColor.xyz; aWeight.w *= aColor.w;
995
996       break; // terminate path
997     }
998
999     vec3 aInvTransf0 = texelFetch (uSceneTransformTexture, aTrsfId + 0).xyz;
1000     vec3 aInvTransf1 = texelFetch (uSceneTransformTexture, aTrsfId + 1).xyz;
1001     vec3 aInvTransf2 = texelFetch (uSceneTransformTexture, aTrsfId + 2).xyz;
1002
1003     aHit.Normal = normalize (vec3 (dot (aInvTransf0, aHit.Normal),
1004                                    dot (aInvTransf1, aHit.Normal),
1005                                    dot (aInvTransf2, aHit.Normal)));
1006
1007     theRay.Origin += theRay.Direct * aHit.Time; // intersection point
1008
1009     // Evaluate depth on first hit
1010     if (aDepth == 0)
1011     {
1012       vec4 aNDCPoint = uViewMat * vec4 (theRay.Origin, 1.f);
1013
1014       float aPolygonOffset = PolygonOffset (aHit.Normal, theRay.Origin);
1015       aRaytraceDepth = (aNDCPoint.z / aNDCPoint.w + aPolygonOffset * POLYGON_OFFSET_SCALE) * 0.5f + 0.5f;
1016     }
1017
1018     vec3 aNormal = SmoothNormal (aHit.UV, aTriIndex);
1019
1020     aNormal = normalize (vec3 (dot (aInvTransf0, aNormal),
1021                                dot (aInvTransf1, aNormal),
1022                                dot (aInvTransf2, aNormal)));
1023
1024     vec3 aAmbient  = texelFetch (
1025       uRaytraceMaterialTexture, MATERIAL_AMBN (aTriIndex.w)).rgb;
1026     vec4 aDiffuse  = texelFetch (
1027       uRaytraceMaterialTexture, MATERIAL_DIFF (aTriIndex.w));
1028     vec4 aSpecular = texelFetch (
1029       uRaytraceMaterialTexture, MATERIAL_SPEC (aTriIndex.w));
1030     vec4 aOpacity  = texelFetch (
1031       uRaytraceMaterialTexture, MATERIAL_TRAN (aTriIndex.w));
1032
1033 #ifdef USE_TEXTURES
1034     if (aDiffuse.w >= 0.f)
1035     {
1036       vec4 aTexCoord = vec4 (SmoothUV (aHit.UV, aTriIndex), 0.f, 1.f);
1037
1038       vec4 aTrsfRow1 = texelFetch (
1039         uRaytraceMaterialTexture, MATERIAL_TRS1 (aTriIndex.w));
1040       vec4 aTrsfRow2 = texelFetch (
1041         uRaytraceMaterialTexture, MATERIAL_TRS2 (aTriIndex.w));
1042
1043       aTexCoord.st = vec2 (dot (aTrsfRow1, aTexCoord),
1044                            dot (aTrsfRow2, aTexCoord));
1045
1046       vec4 aTexColor = textureLod (
1047         sampler2D (uTextureSamplers[int(aDiffuse.w)]), aTexCoord.st, 0.f);
1048
1049       aDiffuse.rgb *= aTexColor.rgb;
1050       aAmbient.rgb *= aTexColor.rgb;
1051
1052       // keep refractive index untouched (Z component)
1053       aOpacity.xy = vec2 (aTexColor.w * aOpacity.x, 1.0f - aTexColor.w * aOpacity.x);
1054     }
1055 #endif
1056
1057     vec3 aEmission = texelFetch (
1058       uRaytraceMaterialTexture, MATERIAL_EMIS (aTriIndex.w)).rgb;
1059
1060     float aGeomFactor = dot (aNormal, theRay.Direct);
1061
1062     aResult.xyz += aWeight.xyz * aOpacity.x * (
1063       uGlobalAmbient.xyz * aAmbient * max (abs (aGeomFactor), 0.5f) + aEmission);
1064
1065     vec3 aSidedNormal = mix (aNormal, -aNormal, step (0.0f, aGeomFactor));
1066
1067     for (int aLightIdx = 0; aLightIdx < uLightCount; ++aLightIdx)
1068     {
1069       vec4 aLight = texelFetch (
1070         uRaytraceLightSrcTexture, LIGHT_POS (aLightIdx));
1071
1072       float aDistance = MAXFLOAT;
1073
1074       if (aLight.w != 0.0f) // point light source
1075       {
1076         aDistance = length (aLight.xyz -= theRay.Origin);
1077
1078         aLight.xyz *= 1.0f / aDistance;
1079       }
1080
1081       float aLdotN = dot (aLight.xyz, aSidedNormal);
1082
1083       if (aLdotN > 0.0f) // first check if light source is important
1084       {
1085         float aVisibility = 1.0f;
1086
1087         if (bool(uShadowsEnabled))
1088         {
1089           SRay aShadow = SRay (theRay.Origin, aLight.xyz);
1090
1091           aShadow.Origin += uSceneEpsilon * (aLight.xyz +
1092             mix (-aHit.Normal, aHit.Normal, step (0.0f, dot (aHit.Normal, aLight.xyz))));
1093
1094           vec3 aInverse = 1.0f / max (abs (aLight.xyz), SMALL);
1095
1096           aVisibility = SceneAnyHit (
1097             aShadow, mix (-aInverse, aInverse, step (ZERO, aLight.xyz)), aDistance);
1098         }
1099
1100         if (aVisibility > 0.0f)
1101         {
1102           vec3 aIntensity = min (UNIT, vec3 (texelFetch (
1103             uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx))));
1104
1105           float aRdotV = dot (reflect (aLight.xyz, aSidedNormal), theRay.Direct);
1106
1107           aResult.xyz += aWeight.xyz * (aOpacity.x * aVisibility) * aIntensity *
1108             (aDiffuse.xyz * aLdotN + aSpecular.xyz * pow (max (0.f, aRdotV), aSpecular.w));
1109         }
1110       }
1111     }
1112
1113     if (aOpacity.x != 1.0f)
1114     {
1115       aWeight *= aOpacity.y;
1116
1117       if (aOpacity.z != 1.0f)
1118       {
1119         theRay.Direct = Refract (theRay.Direct, aNormal, aOpacity.z, aOpacity.w);
1120       }
1121     }
1122     else
1123     {
1124       aWeight *= bool(uReflectEnabled) ?
1125         texelFetch (uRaytraceMaterialTexture, MATERIAL_REFL (aTriIndex.w)) : vec4 (0.0f);
1126
1127       vec3 aReflect = reflect (theRay.Direct, aNormal);
1128
1129       if (dot (aReflect, aHit.Normal) * dot (theRay.Direct, aHit.Normal) > 0.0f)
1130       {
1131         aReflect = reflect (theRay.Direct, aHit.Normal);
1132       }
1133
1134       theRay.Direct = aReflect;
1135     }
1136
1137     if (all (lessThanEqual (aWeight.xyz, THRESHOLD)))
1138     {
1139       aDepth = INVALID_BOUNCES;
1140     }
1141     else if (aOpacity.x == 1.0f || aOpacity.z != 1.0f) // if no simple transparency
1142     {
1143       theRay.Origin += aHit.Normal * mix (
1144         -uSceneEpsilon, uSceneEpsilon, step (0.0f, dot (aHit.Normal, theRay.Direct)));
1145
1146       theInverse = 1.0f / max (abs (theRay.Direct), SMALL);
1147
1148       theInverse = mix (-theInverse, theInverse, step (ZERO, theRay.Direct));
1149     }
1150
1151     theRay.Origin += theRay.Direct * uSceneEpsilon;
1152   }
1153
1154   gl_FragDepth = aRaytraceDepth;
1155
1156   return vec4 (aResult.x,
1157                aResult.y,
1158                aResult.z,
1159                aWeight.w);
1160 }
1161 #endif