10bf8af7575d7855e9e38148f2d0e9087ec27450
[occt.git] / src / Shaders / RaytraceBase.fs
1 #ifdef USE_TEXTURES
2   #extension GL_ARB_bindless_texture : require
3 #endif
4
5 //! Normalized pixel coordinates.
6 in vec2 vPixel;
7
8 //! Sub-pixel offset in X direction for FSAA.
9 uniform float uOffsetX = 0.f;
10 //! Sub-pixel offset in Y direction for FSAA.
11 uniform float uOffsetY = 0.f;
12
13 //! Origin of viewing ray in left-top corner.
14 uniform vec3 uOriginLT;
15 //! Origin of viewing ray in left-bottom corner.
16 uniform vec3 uOriginLB;
17 //! Origin of viewing ray in right-top corner.
18 uniform vec3 uOriginRT;
19 //! Origin of viewing ray in right-bottom corner.
20 uniform vec3 uOriginRB;
21
22 //! Direction of viewing ray in left-top corner.
23 uniform vec3 uDirectLT;
24 //! Direction of viewing ray in left-bottom corner.
25 uniform vec3 uDirectLB;
26 //! Direction of viewing ray in right-top corner.
27 uniform vec3 uDirectRT;
28 //! Direction of viewing ray in right-bottom corner.
29 uniform vec3 uDirectRB;
30
31 //! Inverse model-view-projection matrix.
32 uniform mat4 uUnviewMat;
33
34 //! Texture buffer of data records of high-level BVH nodes.
35 uniform isamplerBuffer uSceneNodeInfoTexture;
36 //! Texture buffer of minimum points of high-level BVH nodes.
37 uniform samplerBuffer uSceneMinPointTexture;
38 //! Texture buffer of maximum points of high-level BVH nodes.
39 uniform samplerBuffer uSceneMaxPointTexture;
40 //! Texture buffer of transformations of high-level BVH nodes.
41 uniform samplerBuffer uSceneTransformTexture;
42
43 //! Texture buffer of data records of bottom-level BVH nodes.
44 uniform isamplerBuffer uObjectNodeInfoTexture;
45 //! Texture buffer of minimum points of bottom-level BVH nodes.
46 uniform samplerBuffer uObjectMinPointTexture;
47 //! Texture buffer of maximum points of bottom-level BVH nodes.
48 uniform samplerBuffer uObjectMaxPointTexture;
49
50 //! Texture buffer of vertex coords.
51 uniform samplerBuffer uGeometryVertexTexture;
52 //! Texture buffer of vertex normals.
53 uniform samplerBuffer uGeometryNormalTexture;
54 #ifdef USE_TEXTURES
55   //! Texture buffer of per-vertex UV-coordinates.
56   uniform samplerBuffer uGeometryTexCrdTexture;
57 #endif
58 //! Texture buffer of triangle indices.
59 uniform isamplerBuffer uGeometryTriangTexture;
60
61 //! Texture buffer of material properties.
62 uniform samplerBuffer uRaytraceMaterialTexture;
63 //! Texture buffer of light source properties.
64 uniform samplerBuffer uRaytraceLightSrcTexture;
65 //! Environment map texture.
66 uniform sampler2D uEnvironmentMapTexture;
67
68 //! Input pre-raytracing image rendered by OpenGL.
69 uniform sampler2D uOpenGlColorTexture;
70 //! Input pre-raytracing depth image rendered by OpenGL.
71 uniform sampler2D uOpenGlDepthTexture;
72
73 //! Total number of light sources.
74 uniform int uLightCount;
75 //! Intensity of global ambient light.
76 uniform vec4 uGlobalAmbient;
77
78 //! Enables/disables environment map.
79 uniform int uEnvironmentEnable;
80 //! Enables/disables computation of shadows.
81 uniform int uShadowsEnable;
82 //! Enables/disables computation of reflections.
83 uniform int uReflectionsEnable;
84
85 //! Radius of bounding sphere of the scene.
86 uniform float uSceneRadius;
87 //! Scene epsilon to prevent self-intersections.
88 uniform float uSceneEpsilon;
89
90 #ifdef USE_TEXTURES
91   //! Unique 64-bit handles of OpenGL textures.
92   uniform sampler2D uTextureSamplers[MAX_TEX_NUMBER];
93 #endif
94
95 /////////////////////////////////////////////////////////////////////////////////////////
96 // Specific data types
97   
98 //! Stores ray parameters.
99 struct SRay
100 {
101   vec3 Origin;
102   
103   vec3 Direct;
104 };
105
106 //! Stores intersection parameters.
107 struct SIntersect
108 {
109   float Time;
110   
111   vec2 UV;
112   
113   vec3 Normal;
114 };
115
116 /////////////////////////////////////////////////////////////////////////////////////////
117 // Some useful constants
118
119 #define MAXFLOAT 1e15f
120
121 #define SMALL vec3 (exp2 (-80.0f))
122
123 #define ZERO vec3 (0.0f, 0.0f, 0.0f)
124 #define UNIT vec3 (1.0f, 1.0f, 1.0f)
125
126 #define AXIS_X vec3 (1.0f, 0.0f, 0.0f)
127 #define AXIS_Y vec3 (0.0f, 1.0f, 0.0f)
128 #define AXIS_Z vec3 (0.0f, 0.0f, 1.0f)
129
130 // =======================================================================
131 // function : MatrixRowMultiplyDir
132 // purpose  : Multiplies a vector by matrix
133 // =======================================================================
134 vec3 MatrixRowMultiplyDir (in vec3 v,
135                            in vec4 m0,
136                            in vec4 m1,
137                            in vec4 m2)
138 {
139   return vec3 (dot (m0.xyz, v),
140                dot (m1.xyz, v),
141                dot (m2.xyz, v));
142 }
143
144 // =======================================================================
145 // function : MatrixColMultiplyPnt
146 // purpose  : Multiplies a vector by matrix
147 // =======================================================================
148 vec3 MatrixColMultiplyPnt (in vec3 v,
149                            in vec4 m0,
150                            in vec4 m1,
151                            in vec4 m2,
152                            in vec4 m3)
153 {
154   return vec3 (m0[0] * v.x + m1[0] * v.y + m2[0] * v.z + m3[0],
155                m0[1] * v.x + m1[1] * v.y + m2[1] * v.z + m3[1],
156                m0[2] * v.x + m1[2] * v.y + m2[2] * v.z + m3[2]);
157 }
158
159 // =======================================================================
160 // function : MatrixColMultiplyDir
161 // purpose  : Multiplies a vector by matrix
162 // =======================================================================
163 vec3 MatrixColMultiplyDir (in vec3 v,
164                            in vec4 m0,
165                            in vec4 m1,
166                            in vec4 m2,
167                            in vec4 m3)
168 {
169   return vec3 (m0[0] * v.x + m1[0] * v.y + m2[0] * v.z,
170                m0[1] * v.x + m1[1] * v.y + m2[1] * v.z,
171                m0[2] * v.x + m1[2] * v.y + m2[2] * v.z);
172 }
173
174 /////////////////////////////////////////////////////////////////////////////////////////
175 // Functions for compute ray-object intersection
176
177 // =======================================================================
178 // function : GenerateRay
179 // purpose  :
180 // =======================================================================
181 SRay GenerateRay (in vec2 thePixel)
182 {
183   vec3 aP0 = mix (uOriginLB, uOriginRB, thePixel.x);
184   vec3 aP1 = mix (uOriginLT, uOriginRT, thePixel.x);
185
186   vec3 aD0 = mix (uDirectLB, uDirectRB, thePixel.x);
187   vec3 aD1 = mix (uDirectLT, uDirectRT, thePixel.x);
188
189   vec3 aDirection = normalize (mix (aD0, aD1, thePixel.y));
190
191   return SRay (mix (aP0, aP1, thePixel.y), aDirection);
192 }
193
194 // =======================================================================
195 // function : ComputeOpenGlDepth
196 // purpose  :
197 // =======================================================================
198 float ComputeOpenGlDepth (in SRay theRay)
199 {
200   // a depth in range [0,1]
201   float anOpenGlDepth = texelFetch (uOpenGlDepthTexture, ivec2 (gl_FragCoord.xy), 0).r;
202   // pixel point in NDC-space [-1,1]
203   vec4 aPoint = vec4 (2.0f * vPixel.x - 1.0f,
204                       2.0f * vPixel.y - 1.0f,
205                       2.0f * anOpenGlDepth - 1.0f,
206                       1.0f);
207   vec4 aFinal = uUnviewMat * aPoint;
208   aFinal.xyz *= 1.f / aFinal.w;
209
210   return (anOpenGlDepth < 1.f) ? length (aFinal.xyz - theRay.Origin) : MAXFLOAT;
211 }
212
213 // =======================================================================
214 // function : ComputeOpenGlColor
215 // purpose  :
216 // =======================================================================
217 vec4 ComputeOpenGlColor (in SRay theRay)
218 {
219   vec4 anOpenGlColor = texelFetch (uOpenGlColorTexture, ivec2 (gl_FragCoord.xy), 0);
220   // During blending with factors GL_SRC_ALPHA and GL_ONE_MINUS_SRC_ALPHA (for text and markers)
221   // the alpha channel (written in the color buffer) was squared.
222   anOpenGlColor.a = 1.f - sqrt (anOpenGlColor.a);
223
224   return anOpenGlColor;
225 }
226
227 // =======================================================================
228 // function : IntersectSphere
229 // purpose  : Computes ray-sphere intersection
230 // =======================================================================
231 float IntersectSphere (in SRay theRay, in float theRadius)
232 {
233   float aDdotD = dot (theRay.Direct, theRay.Direct);
234   float aDdotO = dot (theRay.Direct, theRay.Origin);
235   float aOdotO = dot (theRay.Origin, theRay.Origin);
236   
237   float aD = aDdotO * aDdotO - aDdotD * (aOdotO - theRadius * theRadius);
238   
239   if (aD > 0.0f)
240   {
241     float aTime = (sqrt (aD) - aDdotO) * (1.0f / aDdotD);
242     
243     return aTime > 0.0f ? aTime : MAXFLOAT;
244   }
245   
246   return MAXFLOAT;
247 }
248
249 // =======================================================================
250 // function : IntersectTriangle
251 // purpose  : Computes ray-triangle intersection (branchless version)
252 // =======================================================================
253 float IntersectTriangle (in SRay theRay,
254                          in vec3 thePnt0,
255                          in vec3 thePnt1,
256                          in vec3 thePnt2,
257                          out vec2 theUV,
258                          out vec3 theNorm)
259 {
260   vec3 aEdge0 = thePnt1 - thePnt0;
261   vec3 aEdge1 = thePnt0 - thePnt2;
262   
263   theNorm = cross (aEdge1, aEdge0);
264
265   vec3 aEdge2 = (1.0f / dot (theNorm, theRay.Direct)) * (thePnt0 - theRay.Origin);
266   
267   float aTime = dot (theNorm, aEdge2);
268
269   vec3 theVec = cross (theRay.Direct, aEdge2);
270   
271   theUV.x = dot (theVec, aEdge1);
272   theUV.y = dot (theVec, aEdge0);
273   
274   return bool (int(aTime >= 0.0f) &
275                int(theUV.x >= 0.0f) &
276                int(theUV.y >= 0.0f) &
277                int(theUV.x + theUV.y <= 1.0f)) ? aTime : MAXFLOAT;
278 }
279
280 //! Identifies the absence of intersection.
281 #define INALID_HIT ivec4 (-1)
282
283 //! Global stack shared between traversal functions.
284 int Stack[STACK_SIZE];
285
286 // =======================================================================
287 // function : ObjectNearestHit
288 // purpose  : Finds intersection with nearest object triangle
289 // =======================================================================
290 ivec4 ObjectNearestHit (in int theBVHOffset, in int theVrtOffset, in int theTrgOffset,
291   in SRay theRay, in vec3 theInverse, inout SIntersect theHit, in int theSentinel)
292 {
293   int aHead = theSentinel;  // stack pointer
294   int aNode = theBVHOffset; // node to visit
295
296   ivec4 aTriIndex = INALID_HIT;
297
298   while (true)
299   {
300     ivec3 aData = texelFetch (uObjectNodeInfoTexture, aNode).xyz;
301
302     if (aData.x == 0) // if inner node
303     {
304       float aTimeOut;
305       float aTimeLft;
306       float aTimeRgh;
307       
308       aData.y += theBVHOffset;
309       aData.z += theBVHOffset;
310   
311       vec3 aNodeMinLft = texelFetch (uObjectMinPointTexture, aData.y).xyz;
312       vec3 aNodeMaxLft = texelFetch (uObjectMaxPointTexture, aData.y).xyz;
313       vec3 aNodeMinRgh = texelFetch (uObjectMinPointTexture, aData.z).xyz;
314       vec3 aNodeMaxRgh = texelFetch (uObjectMaxPointTexture, aData.z).xyz;
315
316       vec3 aTime0 = (aNodeMinLft - theRay.Origin) * theInverse;
317       vec3 aTime1 = (aNodeMaxLft - theRay.Origin) * theInverse;
318       
319       vec3 aTimeMax = max (aTime0, aTime1);
320       vec3 aTimeMin = min (aTime0, aTime1);
321
322       aTime0 = (aNodeMinRgh - theRay.Origin) * theInverse;
323       aTime1 = (aNodeMaxRgh - theRay.Origin) * theInverse;
324       
325       aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
326       aTimeLft = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
327
328       int aHitLft = int(aTimeLft <= aTimeOut) & int(aTimeOut >= 0.0f) & int(aTimeLft <= theHit.Time);
329
330       aTimeMax = max (aTime0, aTime1);
331       aTimeMin = min (aTime0, aTime1);
332
333       aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
334       aTimeRgh = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
335
336       int aHitRgh = int(aTimeRgh <= aTimeOut) & int(aTimeOut >= 0.0f) & int(aTimeRgh <= theHit.Time);
337
338       if (bool(aHitLft & aHitRgh))
339       {
340         aNode = (aTimeLft < aTimeRgh) ? aData.y : aData.z;
341         
342         Stack[++aHead] = (aTimeLft < aTimeRgh) ? aData.z : aData.y;
343       }
344       else
345       {
346         if (bool(aHitLft | aHitRgh))
347         {
348           aNode = bool(aHitLft) ? aData.y : aData.z;
349         }
350         else
351         {
352           if (aHead == theSentinel)
353             return aTriIndex;
354
355           aNode = Stack[aHead--];
356         }
357       }
358     }
359     else // if leaf node
360     {
361       vec3 aNormal;
362       vec2 aParams;
363
364       for (int anIdx = aData.y; anIdx <= aData.z; ++anIdx)
365       {
366         ivec4 aTriangle = texelFetch (uGeometryTriangTexture, anIdx + theTrgOffset);
367
368         vec3 aPoint0 = texelFetch (uGeometryVertexTexture, aTriangle.x += theVrtOffset).xyz;
369         vec3 aPoint1 = texelFetch (uGeometryVertexTexture, aTriangle.y += theVrtOffset).xyz;
370         vec3 aPoint2 = texelFetch (uGeometryVertexTexture, aTriangle.z += theVrtOffset).xyz;
371
372         float aTime = IntersectTriangle (theRay,
373                                          aPoint0,
374                                          aPoint1,
375                                          aPoint2,
376                                          aParams,
377                                          aNormal);
378                                          
379         if (aTime < theHit.Time)
380         {
381           aTriIndex = aTriangle;
382
383           theHit = SIntersect (aTime, aParams, aNormal);
384         }
385       }
386       
387       if (aHead == theSentinel)
388         return aTriIndex;
389
390       aNode = Stack[aHead--];
391     }
392   }
393
394   return aTriIndex;
395 }
396
397 #define MATERIAL_AMBN(index) (11 * index + 0)
398 #define MATERIAL_DIFF(index) (11 * index + 1)
399 #define MATERIAL_SPEC(index) (11 * index + 2)
400 #define MATERIAL_EMIS(index) (11 * index + 3)
401 #define MATERIAL_REFL(index) (11 * index + 4)
402 #define MATERIAL_REFR(index) (11 * index + 5)
403 #define MATERIAL_TRAN(index) (11 * index + 6)
404 #define MATERIAL_TRS1(index) (11 * index + 7)
405 #define MATERIAL_TRS2(index) (11 * index + 8)
406 #define MATERIAL_TRS3(index) (11 * index + 9)
407
408 // =======================================================================
409 // function : ObjectAnyHit
410 // purpose  : Finds intersection with any object triangle
411 // =======================================================================
412 float ObjectAnyHit (in int theBVHOffset, in int theVrtOffset, in int theTrgOffset,
413   in SRay theRay, in vec3 theInverse, in float theDistance, in int theSentinel)
414 {
415   int aHead = theSentinel;  // stack pointer
416   int aNode = theBVHOffset; // node to visit
417
418 #ifdef TRANSPARENT_SHADOWS
419   float aFactor = 1.0f;
420 #endif
421
422   while (true)
423   {
424     ivec4 aData = texelFetch (uObjectNodeInfoTexture, aNode);
425
426     if (aData.x == 0) // if inner node
427     {
428       float aTimeOut;
429       float aTimeLft;
430       float aTimeRgh;
431
432       aData.y += theBVHOffset;
433       aData.z += theBVHOffset;
434   
435       vec3 aNodeMinLft = texelFetch (uObjectMinPointTexture, aData.y).xyz;
436       vec3 aNodeMaxLft = texelFetch (uObjectMaxPointTexture, aData.y).xyz;
437       vec3 aNodeMinRgh = texelFetch (uObjectMinPointTexture, aData.z).xyz;
438       vec3 aNodeMaxRgh = texelFetch (uObjectMaxPointTexture, aData.z).xyz;
439
440       vec3 aTime0 = (aNodeMinLft - theRay.Origin) * theInverse;
441       vec3 aTime1 = (aNodeMaxLft - theRay.Origin) * theInverse;
442
443       vec3 aTimeMax = max (aTime0, aTime1);
444       vec3 aTimeMin = min (aTime0, aTime1);
445
446       aTime0 = (aNodeMinRgh - theRay.Origin) * theInverse;
447       aTime1 = (aNodeMaxRgh - theRay.Origin) * theInverse;
448       
449       aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
450       aTimeLft = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
451
452       int aHitLft = int(aTimeLft <= aTimeOut) & int(aTimeOut >= 0.0f) & int(aTimeLft <= theDistance);
453
454       aTimeMax = max (aTime0, aTime1);
455       aTimeMin = min (aTime0, aTime1);
456
457       aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
458       aTimeRgh = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
459
460       int aHitRgh = int(aTimeRgh <= aTimeOut) & int(aTimeOut >= 0.0f) & int(aTimeRgh <= theDistance);
461
462       if (bool(aHitLft & aHitRgh))
463       {
464         aNode = (aTimeLft < aTimeRgh) ? aData.y : aData.z;
465
466         Stack[++aHead] = (aTimeLft < aTimeRgh) ? aData.z : aData.y;
467       }
468       else
469       {
470         if (bool(aHitLft | aHitRgh))
471         {
472           aNode = bool(aHitLft) ? aData.y : aData.z;
473         }
474         else
475         {
476 #ifdef TRANSPARENT_SHADOWS
477           if (aHead == theSentinel)
478             return aFactor;
479 #else
480           if (aHead == theSentinel)
481             return 1.0f;
482 #endif
483
484           aNode = Stack[aHead--];
485         }
486       }
487     }
488     else // if leaf node
489     {
490       vec3 aNormal;
491       vec2 aParams;
492
493       for (int anIdx = aData.y; anIdx <= aData.z; ++anIdx)
494       {
495         ivec4 aTriangle = texelFetch (uGeometryTriangTexture, anIdx + theTrgOffset);
496
497         vec3 aPoint0 = texelFetch (uGeometryVertexTexture, aTriangle.x + theVrtOffset).xyz;
498         vec3 aPoint1 = texelFetch (uGeometryVertexTexture, aTriangle.y + theVrtOffset).xyz;
499         vec3 aPoint2 = texelFetch (uGeometryVertexTexture, aTriangle.z + theVrtOffset).xyz;
500
501         float aTime = IntersectTriangle (theRay,
502                                          aPoint0,
503                                          aPoint1,
504                                          aPoint2,
505                                          aParams,
506                                          aNormal);
507
508 #ifdef TRANSPARENT_SHADOWS
509         if (aTime < theDistance)
510         {
511           aFactor *= 1.0f - texelFetch (uRaytraceMaterialTexture, MATERIAL_TRAN (aTriangle.w)).x;
512         }
513 #else
514         if (aTime < theDistance)
515           return 0.0f;
516 #endif
517       }
518
519 #ifdef TRANSPARENT_SHADOWS
520       if (aHead == theSentinel || aFactor < 0.1f)
521         return aFactor;
522 #else
523       if (aHead == theSentinel)
524         return 1.0f;
525 #endif
526
527       aNode = Stack[aHead--];
528     }
529   }
530
531 #ifdef TRANSPARENT_SHADOWS
532   return aFactor;
533 #else
534   return 1.0f;
535 #endif
536 }
537
538 // =======================================================================
539 // function : SceneNearestHit
540 // purpose  : Finds intersection with nearest scene triangle
541 // =======================================================================
542 ivec4 SceneNearestHit (in SRay theRay, in vec3 theInverse, inout SIntersect theHit, out int theObjectId)
543 {
544   int aHead = -1; // stack pointer
545   int aNode =  0; // node to visit
546
547   ivec4 aHitObject = INALID_HIT;
548
549   while (true)
550   {
551     ivec4 aData = texelFetch (uSceneNodeInfoTexture, aNode);
552
553     if (aData.x != 0) // if leaf node
554     {
555       vec3 aNodeMin = texelFetch (uSceneMinPointTexture, aNode).xyz;
556       vec3 aNodeMax = texelFetch (uSceneMaxPointTexture, aNode).xyz;
557
558       vec3 aTime0 = (aNodeMin - theRay.Origin) * theInverse;
559       vec3 aTime1 = (aNodeMax - theRay.Origin) * theInverse;
560
561       vec3 aTimes = min (aTime0, aTime1);
562
563       if (max (aTimes.x, max (aTimes.y, aTimes.z)) < theHit.Time)
564       {
565         // fetch object transformation
566         int anObjectId = aData.x - 1;
567
568         vec4 aInvTransf0 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 0);
569         vec4 aInvTransf1 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 1);
570         vec4 aInvTransf2 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 2);
571         vec4 aInvTransf3 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 3);
572
573         SRay aTrsfRay = SRay (
574           MatrixColMultiplyPnt (theRay.Origin, aInvTransf0, aInvTransf1, aInvTransf2, aInvTransf3),
575           MatrixColMultiplyDir (theRay.Direct, aInvTransf0, aInvTransf1, aInvTransf2, aInvTransf3));
576
577         vec3 aTrsfInverse = 1.0f / max (abs (aTrsfRay.Direct), SMALL);
578
579         aTrsfInverse.x = aTrsfRay.Direct.x < 0.f ? -aTrsfInverse.x : aTrsfInverse.x;
580         aTrsfInverse.y = aTrsfRay.Direct.y < 0.f ? -aTrsfInverse.y : aTrsfInverse.y;
581         aTrsfInverse.z = aTrsfRay.Direct.z < 0.f ? -aTrsfInverse.z : aTrsfInverse.z;
582
583         ivec4 aTriIndex = ObjectNearestHit (
584           aData.y, aData.z, aData.w, aTrsfRay, aTrsfInverse, theHit, aHead);
585
586         if (aTriIndex.x != -1)
587         {
588           aHitObject = ivec4 (aTriIndex.x,  // vertex 0
589                               aTriIndex.y,  // vertex 1
590                               aTriIndex.z,  // vertex 2
591                               aTriIndex.w); // material
592
593           theObjectId = anObjectId;
594         }
595       }
596       
597       if (aHead < 0)
598         return aHitObject;
599
600       aNode = Stack[aHead--];
601     }
602     else // if inner node
603     {
604       float aTimeOut;
605       float aTimeLft;
606       float aTimeRgh;
607
608       vec3 aNodeMinLft = texelFetch (uSceneMinPointTexture, aData.y).xyz;
609       vec3 aNodeMaxLft = texelFetch (uSceneMaxPointTexture, aData.y).xyz;
610       vec3 aNodeMinRgh = texelFetch (uSceneMinPointTexture, aData.z).xyz;
611       vec3 aNodeMaxRgh = texelFetch (uSceneMaxPointTexture, aData.z).xyz;
612
613       vec3 aTime0 = (aNodeMinLft - theRay.Origin) * theInverse;
614       vec3 aTime1 = (aNodeMaxLft - theRay.Origin) * theInverse;
615
616       vec3 aTimeMax = max (aTime0, aTime1);
617       vec3 aTimeMin = min (aTime0, aTime1);
618
619       aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
620       aTimeLft = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
621
622       int aHitLft = int(aTimeLft <= aTimeOut) & int(aTimeOut >= 0.0f) & int(aTimeLft <= theHit.Time);
623       
624       aTime0 = (aNodeMinRgh - theRay.Origin) * theInverse;
625       aTime1 = (aNodeMaxRgh - theRay.Origin) * theInverse;
626
627       aTimeMax = max (aTime0, aTime1);
628       aTimeMin = min (aTime0, aTime1);
629
630       aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
631       aTimeRgh = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
632       
633       int aHitRgh = int(aTimeRgh <= aTimeOut) & int(aTimeOut >= 0.0f) & int(aTimeRgh <= theHit.Time);
634
635       if (bool(aHitLft & aHitRgh))
636       {
637         aNode = (aTimeLft < aTimeRgh) ? aData.y : aData.z;
638
639         Stack[++aHead] = (aTimeLft < aTimeRgh) ? aData.z : aData.y;
640       }
641       else
642       {
643         if (bool(aHitLft | aHitRgh))
644         {
645           aNode = bool(aHitLft) ? aData.y : aData.z;
646         }
647         else
648         {
649           if (aHead < 0)
650             return aHitObject;
651
652           aNode = Stack[aHead--];
653         }
654       }
655     }
656   }
657   
658   return aHitObject;
659 }
660
661 // =======================================================================
662 // function : SceneAnyHit
663 // purpose  : Finds intersection with any scene triangle
664 // =======================================================================
665 float SceneAnyHit (in SRay theRay, in vec3 theInverse, in float theDistance)
666 {
667   int aHead = -1; // stack pointer
668   int aNode =  0; // node to visit
669
670 #ifdef TRANSPARENT_SHADOWS
671   float aFactor = 1.0f;
672 #endif
673
674   while (true)
675   {
676     ivec4 aData = texelFetch (uSceneNodeInfoTexture, aNode);
677
678     if (aData.x != 0) // if leaf node
679     {
680       // fetch object transformation
681       int anObjectId = aData.x - 1;
682
683       vec4 aInvTransf0 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 0);
684       vec4 aInvTransf1 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 1);
685       vec4 aInvTransf2 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 2);
686       vec4 aInvTransf3 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 3);
687
688       SRay aTrsfRay = SRay (
689         MatrixColMultiplyPnt (theRay.Origin, aInvTransf0, aInvTransf1, aInvTransf2, aInvTransf3),
690         MatrixColMultiplyDir (theRay.Direct, aInvTransf0, aInvTransf1, aInvTransf2, aInvTransf3));
691
692       vec3 aTrsfInverse = 1.0f / max (abs (aTrsfRay.Direct), SMALL);
693
694       aTrsfInverse.x = aTrsfRay.Direct.x < 0.0f ? -aTrsfInverse.x : aTrsfInverse.x;
695       aTrsfInverse.y = aTrsfRay.Direct.y < 0.0f ? -aTrsfInverse.y : aTrsfInverse.y;
696       aTrsfInverse.z = aTrsfRay.Direct.z < 0.0f ? -aTrsfInverse.z : aTrsfInverse.z;
697
698 #ifdef TRANSPARENT_SHADOWS
699       aFactor *= ObjectAnyHit (
700         aData.y, aData.z, aData.w, aTrsfRay, aTrsfInverse, theDistance, aHead);
701
702       if (aHead < 0 || aFactor < 0.1f)
703         return aFactor;
704 #else
705       bool isShadow = 0.0f == ObjectAnyHit (
706         aData.y, aData.z, aData.w, aTrsfRay, aTrsfInverse, theDistance, aHead);
707
708       if (aHead < 0 || isShadow)
709         return isShadow ? 0.0f : 1.0f;
710 #endif
711
712       aNode = Stack[aHead--];
713     }
714     else // if inner node
715     {
716       float aTimeOut;
717       float aTimeLft;
718       float aTimeRgh;
719
720       vec3 aNodeMinLft = texelFetch (uSceneMinPointTexture, aData.y).xyz;
721       vec3 aNodeMaxLft = texelFetch (uSceneMaxPointTexture, aData.y).xyz;
722       vec3 aNodeMinRgh = texelFetch (uSceneMinPointTexture, aData.z).xyz;
723       vec3 aNodeMaxRgh = texelFetch (uSceneMaxPointTexture, aData.z).xyz;
724       
725       vec3 aTime0 = (aNodeMinLft - theRay.Origin) * theInverse;
726       vec3 aTime1 = (aNodeMaxLft - theRay.Origin) * theInverse;
727
728       vec3 aTimeMax = max (aTime0, aTime1);
729       vec3 aTimeMin = min (aTime0, aTime1);
730
731       aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
732       aTimeLft = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
733
734       int aHitLft = int(aTimeLft <= aTimeOut) & int(aTimeOut >= 0.0f) & int(aTimeLft <= theDistance);
735       
736       aTime0 = (aNodeMinRgh - theRay.Origin) * theInverse;
737       aTime1 = (aNodeMaxRgh - theRay.Origin) * theInverse;
738
739       aTimeMax = max (aTime0, aTime1);
740       aTimeMin = min (aTime0, aTime1);
741
742       aTimeOut = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
743       aTimeRgh = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
744       
745       int aHitRgh = int(aTimeRgh <= aTimeOut) & int(aTimeOut >= 0.0f) & int(aTimeRgh <= theDistance);
746
747       if (bool(aHitLft & aHitRgh))
748       {
749         aNode = (aTimeLft < aTimeRgh) ? aData.y : aData.z;
750
751         Stack[++aHead] = (aTimeLft < aTimeRgh) ? aData.z : aData.y;
752       }
753       else
754       {
755         if (bool(aHitLft | aHitRgh))
756         {
757           aNode = bool(aHitLft) ? aData.y : aData.z;
758         }
759         else
760         {
761 #ifdef TRANSPARENT_SHADOWS
762           if (aHead < 0)
763             return aFactor;
764 #else
765           if (aHead < 0)
766             return 1.0f;
767 #endif
768
769           aNode = Stack[aHead--];
770         }
771       }
772     }
773   }
774
775 #ifdef TRANSPARENT_SHADOWS
776   return aFactor;
777 #else
778   return 1.0f;
779 #endif
780 }
781
782 #define PI 3.1415926f
783
784 // =======================================================================
785 // function : Latlong
786 // purpose  : Converts world direction to environment texture coordinates
787 // =======================================================================
788 vec2 Latlong (in vec3 thePoint, in float theRadius)
789 {
790   float aPsi = acos (-thePoint.z / theRadius);
791
792   float aPhi = atan (thePoint.y, thePoint.x) + PI;
793
794   return vec2 (aPhi * 0.1591549f,
795                aPsi * 0.3183098f);
796 }
797
798 // =======================================================================
799 // function : SmoothNormal
800 // purpose  : Interpolates normal across the triangle
801 // =======================================================================
802 vec3 SmoothNormal (in vec2 theUV, in ivec4 theTriangle)
803 {
804   vec3 aNormal0 = texelFetch (uGeometryNormalTexture, theTriangle.x).xyz;
805   vec3 aNormal1 = texelFetch (uGeometryNormalTexture, theTriangle.y).xyz;
806   vec3 aNormal2 = texelFetch (uGeometryNormalTexture, theTriangle.z).xyz;
807
808   return normalize (aNormal1 * theUV.x +
809                     aNormal2 * theUV.y +
810                     aNormal0 * (1.0f - theUV.x - theUV.y));
811 }
812
813 // =======================================================================
814 // function : SmoothUV
815 // purpose  : Interpolates UV coordinates across the triangle
816 // =======================================================================
817 #ifdef USE_TEXTURES
818 vec2 SmoothUV (in vec2 theUV, in ivec4 theTriangle)
819 {
820   vec2 aTexCrd0 = texelFetch (uGeometryTexCrdTexture, theTriangle.x).st;
821   vec2 aTexCrd1 = texelFetch (uGeometryTexCrdTexture, theTriangle.y).st;
822   vec2 aTexCrd2 = texelFetch (uGeometryTexCrdTexture, theTriangle.z).st;
823
824   return aTexCrd1 * theUV.x +
825          aTexCrd2 * theUV.y +
826          aTexCrd0 * (1.0f - theUV.x - theUV.y);
827 }
828 #endif
829
830 // =======================================================================
831 // function : Refract
832 // purpose  : Computes refraction ray (also handles TIR)
833 // =======================================================================
834 vec3 Refract (in vec3 theInput,
835               in vec3 theNormal,
836               in float theRefractIndex,
837               in float theInvRefractIndex)
838 {
839   float aNdotI = dot (theInput, theNormal);
840
841   float anIndex = aNdotI < 0.0f
842                 ? theInvRefractIndex
843                 : theRefractIndex;
844
845   float aSquare = anIndex * anIndex * (1.0f - aNdotI * aNdotI);
846
847   if (aSquare > 1.0f)
848   {
849     return reflect (theInput, theNormal);
850   }
851
852   float aNdotT = sqrt (1.0f - aSquare);
853
854   return normalize (anIndex * theInput -
855     (anIndex * aNdotI + (aNdotI < 0.0f ? aNdotT : -aNdotT)) * theNormal);
856 }
857
858 #define MIN_SLOPE 0.0001f
859 #define EPS_SCALE 8.0000f
860
861 #define THRESHOLD vec3 (0.1f)
862
863 #define LIGHT_POS(index) (2 * index + 1)
864 #define LIGHT_PWR(index) (2 * index + 0)
865
866 // =======================================================================
867 // function : Radiance
868 // purpose  : Computes color along the given ray
869 // =======================================================================
870 vec4 Radiance (in SRay theRay, in vec3 theInverse)
871 {
872   vec3 aResult = vec3 (0.0f);
873   vec4 aWeight = vec4 (1.0f);
874
875   int anObjectId;
876
877   float anOpenGlDepth = ComputeOpenGlDepth (theRay);
878
879   for (int aDepth = 0; aDepth < NB_BOUNCES; ++aDepth)
880   {
881     SIntersect aHit = SIntersect (MAXFLOAT, vec2 (ZERO), ZERO);
882
883     ivec4 aTriIndex = SceneNearestHit (theRay, theInverse, aHit, anObjectId);
884
885     if (aTriIndex.x == -1)
886     {
887       vec4 aColor = vec4 (0.0f, 0.0f, 0.0f, 1.0f);
888
889       if (aWeight.w != 0.0f)
890       {
891         if (anOpenGlDepth != MAXFLOAT)
892           aColor = ComputeOpenGlColor (theRay);
893       }
894       else if (bool(uEnvironmentEnable))
895       {
896         float aTime = IntersectSphere (theRay, uSceneRadius);
897
898         aColor = textureLod (uEnvironmentMapTexture, Latlong (
899           theRay.Direct * aTime + theRay.Origin, uSceneRadius), 0.0f);
900       }
901
902       return vec4 (aResult.xyz + aWeight.xyz * aColor.xyz, aWeight.w * aColor.w);
903     }
904
905     aHit.Normal = normalize (aHit.Normal);
906     
907     // For polygons that are parallel to the screen plane, the depth slope
908     // is equal to 1, resulting in small polygon offset. For polygons that
909     // that are at a large angle to the screen, the depth slope tends to 1,
910     // resulting in a larger polygon offset
911     float aPolygonOffset = uSceneEpsilon * min (
912       EPS_SCALE / abs (dot (theRay.Direct, aHit.Normal)), EPS_SCALE / MIN_SLOPE);
913
914     if (anOpenGlDepth - aPolygonOffset < aHit.Time)
915     {
916       vec4 aColor = ComputeOpenGlColor (theRay);
917
918       aResult += aWeight.xyz * aColor.xyz;
919       aWeight *= aColor.w;
920     }
921
922     vec3 aPoint = theRay.Direct * aHit.Time + theRay.Origin;
923
924     vec3 aAmbient  = texelFetch (
925       uRaytraceMaterialTexture, MATERIAL_AMBN (aTriIndex.w)).rgb;
926     vec4 aDiffuse  = texelFetch (
927       uRaytraceMaterialTexture, MATERIAL_DIFF (aTriIndex.w));
928     vec4 aSpecular = texelFetch (
929       uRaytraceMaterialTexture, MATERIAL_SPEC (aTriIndex.w));
930     vec4 aOpacity  = texelFetch (
931       uRaytraceMaterialTexture, MATERIAL_TRAN (aTriIndex.w));
932     vec3 aEmission = texelFetch (
933       uRaytraceMaterialTexture, MATERIAL_EMIS (aTriIndex.w)).rgb;
934
935 #ifdef USE_TEXTURES
936     if (aDiffuse.w >= 0.f)
937     {
938       vec4 aTexCoord = vec4 (SmoothUV (aHit.UV, aTriIndex), 0.f, 1.f);
939
940       vec4 aTrsfRow1 = texelFetch (
941         uRaytraceMaterialTexture, MATERIAL_TRS1 (aTriIndex.w));
942       vec4 aTrsfRow2 = texelFetch (
943         uRaytraceMaterialTexture, MATERIAL_TRS2 (aTriIndex.w));
944
945       aTexCoord.st = vec2 (dot (aTrsfRow1, aTexCoord),
946                            dot (aTrsfRow2, aTexCoord));
947
948       vec3 aTexColor = textureLod (
949         uTextureSamplers[int(aDiffuse.w)], aTexCoord.st, 0.f).rgb;
950
951       aDiffuse.rgb *= aTexColor;
952       aAmbient.rgb *= aTexColor;
953     }
954 #endif
955
956     vec4 aInvTransf0 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 0);
957     vec4 aInvTransf1 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 1);
958     vec4 aInvTransf2 = texelFetch (uSceneTransformTexture, anObjectId * 4 + 2);
959
960     vec3 aNormal = SmoothNormal (aHit.UV, aTriIndex);
961
962     aNormal = normalize (MatrixRowMultiplyDir (
963       aNormal, aInvTransf0, aInvTransf1, aInvTransf2));
964
965     for (int aLightIdx = 0; aLightIdx < uLightCount; ++aLightIdx)
966     {
967       vec4 aLight = texelFetch (
968         uRaytraceLightSrcTexture, LIGHT_POS (aLightIdx));
969       
970       float aDistance = MAXFLOAT;
971       
972       if (aLight.w != 0.0f) // point light source
973       {
974         aDistance = length (aLight.xyz -= aPoint);
975         
976         aLight.xyz *= 1.0f / aDistance;
977       }
978
979       SRay aShadow = SRay (aPoint + aLight.xyz * uSceneEpsilon, aLight.xyz);
980       
981       aShadow.Origin += aHit.Normal * uSceneEpsilon *
982         (dot (aHit.Normal, aLight.xyz) >= 0.0f ? 1.0f : -1.0f);
983       
984       float aVisibility = 1.0f;
985      
986       if (bool(uShadowsEnable))
987       {
988         vec3 aInverse = 1.0f / max (abs (aLight.xyz), SMALL);
989
990         aInverse.x = aLight.x < 0.0f ? -aInverse.x : aInverse.x;
991         aInverse.y = aLight.y < 0.0f ? -aInverse.y : aInverse.y;
992         aInverse.z = aLight.z < 0.0f ? -aInverse.z : aInverse.z;
993
994         aVisibility = SceneAnyHit (aShadow, aInverse, aDistance);
995       }
996       
997       if (aVisibility > 0.0f)
998       {
999         vec3 aIntensity = vec3 (texelFetch (
1000           uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx)));
1001
1002         float aLdotN = dot (aShadow.Direct, aNormal);
1003
1004         if (aOpacity.y > 0.0f)   // force two-sided lighting
1005           aLdotN = abs (aLdotN); // for transparent surfaces
1006
1007         if (aLdotN > 0.0f)
1008         {
1009           float aRdotV = dot (reflect (aShadow.Direct, aNormal), theRay.Direct);
1010
1011           aResult.xyz += aWeight.xyz * (aOpacity.x * aVisibility) * aIntensity *
1012             (aDiffuse.rgb * aLdotN + aSpecular.xyz * pow (max (0.0f, aRdotV), aSpecular.w));
1013         }
1014       }
1015     }
1016
1017     aResult.xyz += aWeight.xyz * aOpacity.x * (uGlobalAmbient.xyz *
1018       aAmbient * max (abs (dot (aNormal, theRay.Direct)), 0.5f) + aEmission);
1019
1020     if (aOpacity.x != 1.0f)
1021     {
1022       aWeight *= aOpacity.y;
1023
1024       if (aOpacity.z != 1.0f)
1025       {
1026         theRay.Direct = Refract (theRay.Direct, aNormal, aOpacity.z, aOpacity.w);
1027
1028         theInverse = 1.0f / max (abs (theRay.Direct), SMALL);
1029
1030         theInverse.x = theRay.Direct.x < 0.0f ? -theInverse.x : theInverse.x;
1031         theInverse.y = theRay.Direct.y < 0.0f ? -theInverse.y : theInverse.y;
1032         theInverse.z = theRay.Direct.z < 0.0f ? -theInverse.z : theInverse.z;
1033
1034         aPoint += aHit.Normal * (dot (aHit.Normal, theRay.Direct) >= 0.0f ? uSceneEpsilon : -uSceneEpsilon);
1035
1036         // Disable combining image with OpenGL output
1037         anOpenGlDepth = MAXFLOAT;
1038       }
1039       else
1040       {
1041         anOpenGlDepth -= aHit.Time + uSceneEpsilon;
1042       }
1043     }
1044     else
1045     {
1046       aWeight *= bool(uReflectionsEnable) ?
1047         texelFetch (uRaytraceMaterialTexture, MATERIAL_REFL (aTriIndex.w)) : vec4 (0.0f);
1048
1049       theRay.Direct = reflect (theRay.Direct, aNormal);
1050
1051       if (dot (theRay.Direct, aHit.Normal) < 0.0f)
1052       {
1053         theRay.Direct = reflect (theRay.Direct, aHit.Normal);
1054       }
1055
1056       theInverse = 1.0f / max (abs (theRay.Direct), SMALL);
1057
1058       theInverse.x = theRay.Direct.x < 0.0f ? -theInverse.x : theInverse.x;
1059       theInverse.y = theRay.Direct.y < 0.0f ? -theInverse.y : theInverse.y;
1060       theInverse.z = theRay.Direct.z < 0.0f ? -theInverse.z : theInverse.z;
1061
1062       aPoint += aHit.Normal * (dot (aHit.Normal, theRay.Direct) >= 0.0f ? uSceneEpsilon : -uSceneEpsilon);
1063
1064       // Disable combining image with OpenGL output
1065       anOpenGlDepth = MAXFLOAT;
1066     }
1067
1068     if (all (lessThanEqual (aWeight.xyz, THRESHOLD)))
1069     {
1070       return vec4 (aResult.x,
1071                    aResult.y,
1072                    aResult.z,
1073                    aWeight.w);
1074     }
1075
1076     theRay.Origin = theRay.Direct * uSceneEpsilon + aPoint;
1077   }
1078
1079   return vec4 (aResult.x,
1080                aResult.y,
1081                aResult.z,
1082                aWeight.w);
1083 }