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