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