mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-01 17:36:21 +03:00
df4b931988
Reorganized resources to keep source part in src and real-time scripts in resource folder. For the installation result no changes, still installed to src for windows.
1237 lines
41 KiB
GLSL
1237 lines
41 KiB
GLSL
#ifdef ADAPTIVE_SAMPLING
|
|
#extension GL_ARB_shader_image_load_store : require
|
|
#endif
|
|
#ifdef ADAPTIVE_SAMPLING_ATOMIC
|
|
#extension GL_NV_shader_atomic_float : require
|
|
#endif
|
|
|
|
#ifdef USE_TEXTURES
|
|
#extension GL_ARB_bindless_texture : require
|
|
#endif
|
|
|
|
//! Normalized pixel coordinates.
|
|
in vec2 vPixel;
|
|
|
|
//! Sub-pixel offset in for FSAA.
|
|
uniform vec2 uFsaaOffset;
|
|
//! Sub-pixel offset in Y direction for FSAA.
|
|
uniform float uOffsetY;
|
|
|
|
//! Origin of viewing ray in left-top corner.
|
|
uniform vec3 uOriginLT;
|
|
//! Origin of viewing ray in left-bottom corner.
|
|
uniform vec3 uOriginLB;
|
|
//! Origin of viewing ray in right-top corner.
|
|
uniform vec3 uOriginRT;
|
|
//! Origin of viewing ray in right-bottom corner.
|
|
uniform vec3 uOriginRB;
|
|
|
|
//! Width of the rendering window.
|
|
uniform int uWinSizeX;
|
|
//! Height of the rendering window.
|
|
uniform int uWinSizeY;
|
|
|
|
//! Direction of viewing ray in left-top corner.
|
|
uniform vec3 uDirectLT;
|
|
//! Direction of viewing ray in left-bottom corner.
|
|
uniform vec3 uDirectLB;
|
|
//! Direction of viewing ray in right-top corner.
|
|
uniform vec3 uDirectRT;
|
|
//! Direction of viewing ray in right-bottom corner.
|
|
uniform vec3 uDirectRB;
|
|
|
|
//! Inverse model-view-projection matrix.
|
|
uniform mat4 uUnviewMat;
|
|
|
|
//! Model-view-projection matrix.
|
|
uniform mat4 uViewMat;
|
|
|
|
//! Texture buffer of data records of bottom-level BVH nodes.
|
|
uniform isamplerBuffer uSceneNodeInfoTexture;
|
|
//! Texture buffer of minimum points of bottom-level BVH nodes.
|
|
uniform samplerBuffer uSceneMinPointTexture;
|
|
//! Texture buffer of maximum points of bottom-level BVH nodes.
|
|
uniform samplerBuffer uSceneMaxPointTexture;
|
|
//! Texture buffer of transformations of high-level BVH nodes.
|
|
uniform samplerBuffer uSceneTransformTexture;
|
|
|
|
//! Texture buffer of vertex coords.
|
|
uniform samplerBuffer uGeometryVertexTexture;
|
|
//! Texture buffer of vertex normals.
|
|
uniform samplerBuffer uGeometryNormalTexture;
|
|
#ifdef USE_TEXTURES
|
|
//! Texture buffer of per-vertex UV-coordinates.
|
|
uniform samplerBuffer uGeometryTexCrdTexture;
|
|
#endif
|
|
//! Texture buffer of triangle indices.
|
|
uniform isamplerBuffer uGeometryTriangTexture;
|
|
|
|
//! Texture buffer of material properties.
|
|
uniform samplerBuffer uRaytraceMaterialTexture;
|
|
//! Texture buffer of light source properties.
|
|
uniform samplerBuffer uRaytraceLightSrcTexture;
|
|
|
|
#ifdef BACKGROUND_CUBEMAP
|
|
//! Environment cubemap texture.
|
|
uniform samplerCube uEnvMapTexture;
|
|
//! Coefficient of Y controlling horizontal flip of cubemap
|
|
uniform int uYCoeff;
|
|
//! Coefficient of Z controlling vertical flip of cubemap
|
|
uniform int uZCoeff;
|
|
#else
|
|
//! Environment map texture.
|
|
uniform sampler2D uEnvMapTexture;
|
|
#endif
|
|
|
|
//! Total number of light sources.
|
|
uniform int uLightCount;
|
|
//! Intensity of global ambient light.
|
|
uniform vec4 uGlobalAmbient;
|
|
|
|
//! Enables/disables hard shadows.
|
|
uniform int uShadowsEnabled;
|
|
//! Enables/disables specular reflections.
|
|
uniform int uReflectEnabled;
|
|
//! Enables/disables environment map lighting.
|
|
uniform int uEnvMapEnabled;
|
|
//! Enables/disables environment map background.
|
|
uniform int uEnvMapForBack;
|
|
|
|
//! Radius of bounding sphere of the scene.
|
|
uniform float uSceneRadius;
|
|
//! Scene epsilon to prevent self-intersections.
|
|
uniform float uSceneEpsilon;
|
|
|
|
#ifdef USE_TEXTURES
|
|
//! Unique 64-bit handles of OpenGL textures.
|
|
uniform uvec2 uTextureSamplers[MAX_TEX_NUMBER];
|
|
#endif
|
|
|
|
#ifdef ADAPTIVE_SAMPLING
|
|
//! OpenGL image used for accumulating rendering result.
|
|
volatile restrict layout(r32f) uniform image2D uRenderImage;
|
|
|
|
#ifdef ADAPTIVE_SAMPLING_ATOMIC
|
|
//! OpenGL image storing offsets of sampled pixels blocks.
|
|
coherent restrict layout(rg32i) uniform iimage2D uOffsetImage;
|
|
#else
|
|
//! OpenGL image defining per-tile amount of samples.
|
|
volatile restrict layout(r32i) uniform iimage2D uTilesImage;
|
|
#endif
|
|
|
|
//! Screen space tile size.
|
|
uniform ivec2 uTileSize;
|
|
#endif
|
|
|
|
//! Top color of gradient background.
|
|
uniform vec4 uBackColorTop;
|
|
//! Bottom color of gradient background.
|
|
uniform vec4 uBackColorBot;
|
|
|
|
//! Aperture radius of camera used for depth-of-field
|
|
uniform float uApertureRadius;
|
|
|
|
//! Focal distance of camera used for depth-of field
|
|
uniform float uFocalPlaneDist;
|
|
|
|
//! Camera position used for projective mode
|
|
uniform vec3 uEyeOrig;
|
|
|
|
//! Camera view direction used for projective mode
|
|
uniform vec3 uEyeView;
|
|
|
|
//! Camera's screen vertical direction used for projective mode
|
|
uniform vec3 uEyeVert;
|
|
|
|
//! Camera's screen horizontal direction used for projective mode
|
|
uniform vec3 uEyeSide;
|
|
|
|
//! Camera's screen size used for projective mode
|
|
uniform vec2 uEyeSize;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// Specific data types
|
|
|
|
//! Stores ray parameters.
|
|
struct SRay
|
|
{
|
|
vec3 Origin;
|
|
vec3 Direct;
|
|
};
|
|
|
|
//! Stores intersection parameters.
|
|
struct SIntersect
|
|
{
|
|
float Time;
|
|
vec2 UV;
|
|
vec3 Normal;
|
|
};
|
|
|
|
//! Stores triangle's vertex indexes and vertexes itself
|
|
struct STriangle
|
|
{
|
|
ivec4 TriIndex;
|
|
vec3 Points[3];
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// Some useful constants
|
|
|
|
#define MAXFLOAT 1e15f
|
|
|
|
#define SMALL vec3 (exp2 (-80.0f))
|
|
|
|
#define ZERO vec3 (0.0f, 0.0f, 0.0f)
|
|
#define UNIT vec3 (1.0f, 1.0f, 1.0f)
|
|
|
|
#define AXIS_X vec3 (1.0f, 0.0f, 0.0f)
|
|
#define AXIS_Y vec3 (0.0f, 1.0f, 0.0f)
|
|
#define AXIS_Z vec3 (0.0f, 0.0f, 1.0f)
|
|
|
|
#define M_PI 3.141592653f
|
|
#define M_2_PI 6.283185307f
|
|
#define M_PI_2 1.570796327f
|
|
|
|
#define LUMA vec3 (0.2126f, 0.7152f, 0.0722f)
|
|
|
|
// =======================================================================
|
|
// function : MatrixRowMultiplyDir
|
|
// purpose : Multiplies a vector by matrix
|
|
// =======================================================================
|
|
vec3 MatrixRowMultiplyDir (in vec3 v,
|
|
in vec4 m0,
|
|
in vec4 m1,
|
|
in vec4 m2)
|
|
{
|
|
return vec3 (dot (m0.xyz, v),
|
|
dot (m1.xyz, v),
|
|
dot (m2.xyz, v));
|
|
}
|
|
|
|
//! 32-bit state of random number generator.
|
|
uint RandState;
|
|
|
|
// =======================================================================
|
|
// function : SeedRand
|
|
// purpose : Applies hash function by Thomas Wang to randomize seeds
|
|
// (see http://www.burtleburtle.net/bob/hash/integer.html)
|
|
// =======================================================================
|
|
void SeedRand (in int theSeed, in int theSizeX, in int theRadius)
|
|
{
|
|
RandState = uint (int (gl_FragCoord.y) / theRadius * theSizeX + int (gl_FragCoord.x) / theRadius + theSeed);
|
|
|
|
RandState = (RandState + 0x479ab41du) + (RandState << 8);
|
|
RandState = (RandState ^ 0xe4aa10ceu) ^ (RandState >> 5);
|
|
RandState = (RandState + 0x9942f0a6u) - (RandState << 14);
|
|
RandState = (RandState ^ 0x5aedd67du) ^ (RandState >> 3);
|
|
RandState = (RandState + 0x17bea992u) + (RandState << 7);
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : RandInt
|
|
// purpose : Generates integer using Xorshift algorithm by G. Marsaglia
|
|
// =======================================================================
|
|
uint RandInt()
|
|
{
|
|
RandState ^= (RandState << 13);
|
|
RandState ^= (RandState >> 17);
|
|
RandState ^= (RandState << 5);
|
|
|
|
return RandState;
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : RandFloat
|
|
// purpose : Generates a random float in 0 <= x < 1 range
|
|
// =======================================================================
|
|
float RandFloat()
|
|
{
|
|
return float (RandInt()) * (1.f / 4294967296.f);
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : MatrixColMultiplyPnt
|
|
// purpose : Multiplies a vector by matrix
|
|
// =======================================================================
|
|
vec3 MatrixColMultiplyPnt (in vec3 v,
|
|
in vec4 m0,
|
|
in vec4 m1,
|
|
in vec4 m2,
|
|
in vec4 m3)
|
|
{
|
|
return vec3 (m0.x * v.x + m1.x * v.y + m2.x * v.z + m3.x,
|
|
m0.y * v.x + m1.y * v.y + m2.y * v.z + m3.y,
|
|
m0.z * v.x + m1.z * v.y + m2.z * v.z + m3.z);
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : MatrixColMultiplyDir
|
|
// purpose : Multiplies a vector by matrix
|
|
// =======================================================================
|
|
vec3 MatrixColMultiplyDir (in vec3 v,
|
|
in vec4 m0,
|
|
in vec4 m1,
|
|
in vec4 m2)
|
|
{
|
|
return vec3 (m0.x * v.x + m1.x * v.y + m2.x * v.z,
|
|
m0.y * v.x + m1.y * v.y + m2.y * v.z,
|
|
m0.z * v.x + m1.z * v.y + m2.z * v.z);
|
|
}
|
|
|
|
//=======================================================================
|
|
// function : InverseDirection
|
|
// purpose : Returns safely inverted direction of the given one
|
|
//=======================================================================
|
|
vec3 InverseDirection (in vec3 theInput)
|
|
{
|
|
vec3 anInverse = 1.f / max (abs (theInput), SMALL);
|
|
|
|
return mix (-anInverse, anInverse, step (ZERO, theInput));
|
|
}
|
|
|
|
//=======================================================================
|
|
// function : BackgroundColor
|
|
// purpose : Returns color of gradient background
|
|
//=======================================================================
|
|
vec4 BackgroundColor()
|
|
{
|
|
#ifdef ADAPTIVE_SAMPLING_ATOMIC
|
|
|
|
ivec2 aFragCoord = ivec2 (gl_FragCoord.xy);
|
|
|
|
ivec2 aTileXY = imageLoad (uOffsetImage, aFragCoord / uTileSize).xy * uTileSize;
|
|
|
|
aTileXY.y += aFragCoord.y % min (uWinSizeY - aTileXY.y, uTileSize.y);
|
|
|
|
return mix (uBackColorBot, uBackColorTop, float (aTileXY.y) / uWinSizeY);
|
|
|
|
#else
|
|
|
|
return mix (uBackColorBot, uBackColorTop, vPixel.y);
|
|
|
|
#endif
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// Functions for compute ray-object intersection
|
|
|
|
//=======================================================================
|
|
// function : sampleUniformDisk
|
|
// purpose :
|
|
//=======================================================================
|
|
vec2 sampleUniformDisk ()
|
|
{
|
|
vec2 aPoint;
|
|
|
|
float aKsi1 = 2.f * RandFloat () - 1.f;
|
|
float aKsi2 = 2.f * RandFloat () - 1.f;
|
|
|
|
if (aKsi1 > -aKsi2)
|
|
{
|
|
if (aKsi1 > aKsi2)
|
|
aPoint = vec2 (aKsi1, (M_PI / 4.f) * (0.f + aKsi2 / aKsi1));
|
|
else
|
|
aPoint = vec2 (aKsi2, (M_PI / 4.f) * (2.f - aKsi1 / aKsi2));
|
|
}
|
|
else
|
|
{
|
|
if (aKsi1 < aKsi2)
|
|
aPoint = vec2 (-aKsi1, (M_PI / 4.f) * (4.f + aKsi2 / aKsi1));
|
|
else
|
|
aPoint = vec2 (-aKsi2, (M_PI / 4.f) * (6.f - aKsi1 / aKsi2));
|
|
}
|
|
|
|
return vec2 (sin (aPoint.y), cos (aPoint.y)) * aPoint.x;
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : GenerateRay
|
|
// purpose :
|
|
// =======================================================================
|
|
SRay GenerateRay (in vec2 thePixel)
|
|
{
|
|
#ifndef DEPTH_OF_FIELD
|
|
|
|
vec3 aP0 = mix (uOriginLB, uOriginRB, thePixel.x);
|
|
vec3 aP1 = mix (uOriginLT, uOriginRT, thePixel.x);
|
|
|
|
vec3 aD0 = mix (uDirectLB, uDirectRB, thePixel.x);
|
|
vec3 aD1 = mix (uDirectLT, uDirectRT, thePixel.x);
|
|
|
|
vec3 aDirection = normalize (mix (aD0, aD1, thePixel.y));
|
|
|
|
return SRay (mix (aP0, aP1, thePixel.y), aDirection);
|
|
|
|
#else
|
|
|
|
vec2 aPixel = uEyeSize * (thePixel - vec2 (0.5f)) * 2.f;
|
|
|
|
vec2 aAperturePnt = sampleUniformDisk () * uApertureRadius;
|
|
|
|
vec3 aLocalDir = normalize (vec3 (
|
|
aPixel * uFocalPlaneDist - aAperturePnt, uFocalPlaneDist));
|
|
|
|
vec3 aOrigin = uEyeOrig +
|
|
uEyeSide * aAperturePnt.x +
|
|
uEyeVert * aAperturePnt.y;
|
|
|
|
vec3 aDirect = uEyeView * aLocalDir.z +
|
|
uEyeSide * aLocalDir.x +
|
|
uEyeVert * aLocalDir.y;
|
|
|
|
return SRay (aOrigin, aDirect);
|
|
|
|
#endif
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : IntersectSphere
|
|
// purpose : Computes ray-sphere intersection
|
|
// =======================================================================
|
|
float IntersectSphere (in SRay theRay, in float theRadius)
|
|
{
|
|
float aDdotD = dot (theRay.Direct, theRay.Direct);
|
|
float aDdotO = dot (theRay.Direct, theRay.Origin);
|
|
float aOdotO = dot (theRay.Origin, theRay.Origin);
|
|
|
|
float aD = aDdotO * aDdotO - aDdotD * (aOdotO - theRadius * theRadius);
|
|
|
|
if (aD > 0.0f)
|
|
{
|
|
float aTime = (sqrt (aD) - aDdotO) * (1.0f / aDdotD);
|
|
|
|
return aTime > 0.0f ? aTime : MAXFLOAT;
|
|
}
|
|
|
|
return MAXFLOAT;
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : IntersectTriangle
|
|
// purpose : Computes ray-triangle intersection (branchless version)
|
|
// =======================================================================
|
|
void IntersectTriangle (in SRay theRay,
|
|
in vec3 thePnt0,
|
|
in vec3 thePnt1,
|
|
in vec3 thePnt2,
|
|
out vec3 theUVT,
|
|
out vec3 theNorm)
|
|
{
|
|
vec3 aToTrg = thePnt0 - theRay.Origin;
|
|
|
|
vec3 aEdge0 = thePnt1 - thePnt0;
|
|
vec3 aEdge1 = thePnt0 - thePnt2;
|
|
|
|
theNorm = cross (aEdge1, aEdge0);
|
|
|
|
vec3 theVect = cross (theRay.Direct, aToTrg);
|
|
|
|
theUVT = vec3 (dot (theNorm, aToTrg),
|
|
dot (theVect, aEdge1),
|
|
dot (theVect, aEdge0)) * (1.f / dot (theNorm, theRay.Direct));
|
|
|
|
theUVT.x = any (lessThan (theUVT, ZERO)) || (theUVT.y + theUVT.z) > 1.f ? MAXFLOAT : theUVT.x;
|
|
}
|
|
|
|
#define EMPTY_ROOT ivec4(0)
|
|
|
|
//! Utility structure containing information about
|
|
//! currently traversing sub-tree of scene's BVH.
|
|
struct SSubTree
|
|
{
|
|
//! Transformed ray.
|
|
SRay TrsfRay;
|
|
|
|
//! Inversed ray direction.
|
|
vec3 Inverse;
|
|
|
|
//! Parameters of sub-root node.
|
|
ivec4 SubData;
|
|
};
|
|
|
|
#define MATERIAL_AMBN(index) (19 * index + 0)
|
|
#define MATERIAL_DIFF(index) (19 * index + 1)
|
|
#define MATERIAL_SPEC(index) (19 * index + 2)
|
|
#define MATERIAL_EMIS(index) (19 * index + 3)
|
|
#define MATERIAL_REFL(index) (19 * index + 4)
|
|
#define MATERIAL_REFR(index) (19 * index + 5)
|
|
#define MATERIAL_TRAN(index) (19 * index + 6)
|
|
#define MATERIAL_TRS1(index) (19 * index + 7)
|
|
#define MATERIAL_TRS2(index) (19 * index + 8)
|
|
#define MATERIAL_TRS3(index) (19 * index + 9)
|
|
|
|
#define TRS_OFFSET(treelet) treelet.SubData.x
|
|
#define BVH_OFFSET(treelet) treelet.SubData.y
|
|
#define VRT_OFFSET(treelet) treelet.SubData.z
|
|
#define TRG_OFFSET(treelet) treelet.SubData.w
|
|
|
|
//! Identifies the absence of intersection.
|
|
#define INVALID_HIT ivec4 (-1)
|
|
|
|
//! Global stack shared between traversal functions.
|
|
int Stack[STACK_SIZE];
|
|
|
|
// =======================================================================
|
|
// function : pop
|
|
// purpose :
|
|
// =======================================================================
|
|
int pop (inout int theHead)
|
|
{
|
|
int aData = Stack[theHead];
|
|
|
|
int aMask = aData >> 26;
|
|
int aNode = aMask & 0x3;
|
|
|
|
aMask >>= 2;
|
|
|
|
if ((aMask & 0x3) == aNode)
|
|
{
|
|
--theHead;
|
|
}
|
|
else
|
|
{
|
|
aMask |= (aMask << 2) & 0x30;
|
|
|
|
Stack[theHead] = (aData & 0x03FFFFFF) | (aMask << 26);
|
|
}
|
|
|
|
return (aData & 0x03FFFFFF) + aNode;
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : SceneNearestHit
|
|
// purpose : Finds intersection with nearest scene triangle
|
|
// =======================================================================
|
|
STriangle SceneNearestHit (in SRay theRay, in vec3 theInverse, inout SIntersect theHit, out int theTrsfId)
|
|
{
|
|
STriangle aTriangle = STriangle (INVALID_HIT, vec3[](vec3(0.0), vec3(0.0), vec3(0.0)));
|
|
|
|
int aNode = 0; // node to traverse
|
|
int aHead = -1; // pointer of stack
|
|
int aStop = -1; // BVH level switch
|
|
|
|
SSubTree aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
|
|
|
|
for (bool toContinue = true; toContinue; /* none */)
|
|
{
|
|
ivec4 aData = texelFetch (uSceneNodeInfoTexture, aNode);
|
|
|
|
if (aData.x == 0) // if inner node
|
|
{
|
|
aData.y += BVH_OFFSET (aSubTree);
|
|
|
|
vec4 aHitTimes = vec4 (MAXFLOAT,
|
|
MAXFLOAT,
|
|
MAXFLOAT,
|
|
MAXFLOAT);
|
|
|
|
vec3 aRayOriginInverse = -aSubTree.TrsfRay.Origin * aSubTree.Inverse;
|
|
|
|
vec3 aNodeMin0 = texelFetch (uSceneMinPointTexture, aData.y + 0).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMin1 = texelFetch (uSceneMinPointTexture, aData.y + 1).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMin2 = texelFetch (uSceneMinPointTexture, aData.y + min (2, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMin3 = texelFetch (uSceneMinPointTexture, aData.y + min (3, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMax0 = texelFetch (uSceneMaxPointTexture, aData.y + 0).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMax1 = texelFetch (uSceneMaxPointTexture, aData.y + 1).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMax2 = texelFetch (uSceneMaxPointTexture, aData.y + min (2, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMax3 = texelFetch (uSceneMaxPointTexture, aData.y + min (3, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
|
|
vec3 aTimeMax = max (aNodeMin0, aNodeMax0);
|
|
vec3 aTimeMin = min (aNodeMin0, aNodeMax0);
|
|
|
|
float aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
|
|
float aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
|
|
|
|
aHitTimes.x = (aTimeEnter <= aTimeLeave && aTimeEnter <= theHit.Time && aTimeLeave >= 0.f) ? aTimeEnter : MAXFLOAT;
|
|
|
|
aTimeMax = max (aNodeMin1, aNodeMax1);
|
|
aTimeMin = min (aNodeMin1, aNodeMax1);
|
|
|
|
aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
|
|
aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
|
|
|
|
aHitTimes.y = (aTimeEnter <= aTimeLeave && aTimeEnter <= theHit.Time && aTimeLeave >= 0.f) ? aTimeEnter : MAXFLOAT;
|
|
|
|
aTimeMax = max (aNodeMin2, aNodeMax2);
|
|
aTimeMin = min (aNodeMin2, aNodeMax2);
|
|
|
|
aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
|
|
aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
|
|
|
|
aHitTimes.z = (aTimeEnter <= aTimeLeave && aTimeEnter <= theHit.Time && aTimeLeave >= 0.f && aData.z > 1) ? aTimeEnter : MAXFLOAT;
|
|
|
|
aTimeMax = max (aNodeMin3, aNodeMax3);
|
|
aTimeMin = min (aNodeMin3, aNodeMax3);
|
|
|
|
aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
|
|
aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
|
|
|
|
aHitTimes.w = (aTimeEnter <= aTimeLeave && aTimeEnter <= theHit.Time && aTimeLeave >= 0.f && aData.z > 2) ? aTimeEnter : MAXFLOAT;
|
|
|
|
ivec4 aChildren = ivec4 (0, 1, 2, 3);
|
|
|
|
aChildren.xy = aHitTimes.y < aHitTimes.x ? aChildren.yx : aChildren.xy;
|
|
aHitTimes.xy = aHitTimes.y < aHitTimes.x ? aHitTimes.yx : aHitTimes.xy;
|
|
aChildren.zw = aHitTimes.w < aHitTimes.z ? aChildren.wz : aChildren.zw;
|
|
aHitTimes.zw = aHitTimes.w < aHitTimes.z ? aHitTimes.wz : aHitTimes.zw;
|
|
aChildren.xz = aHitTimes.z < aHitTimes.x ? aChildren.zx : aChildren.xz;
|
|
aHitTimes.xz = aHitTimes.z < aHitTimes.x ? aHitTimes.zx : aHitTimes.xz;
|
|
aChildren.yw = aHitTimes.w < aHitTimes.y ? aChildren.wy : aChildren.yw;
|
|
aHitTimes.yw = aHitTimes.w < aHitTimes.y ? aHitTimes.wy : aHitTimes.yw;
|
|
aChildren.yz = aHitTimes.z < aHitTimes.y ? aChildren.zy : aChildren.yz;
|
|
aHitTimes.yz = aHitTimes.z < aHitTimes.y ? aHitTimes.zy : aHitTimes.yz;
|
|
|
|
if (aHitTimes.x != MAXFLOAT)
|
|
{
|
|
int aHitMask = (aHitTimes.w != MAXFLOAT ? aChildren.w : aChildren.z) << 2
|
|
| (aHitTimes.z != MAXFLOAT ? aChildren.z : aChildren.y);
|
|
|
|
if (aHitTimes.y != MAXFLOAT)
|
|
Stack[++aHead] = aData.y | (aHitMask << 2 | aChildren.y) << 26;
|
|
|
|
aNode = aData.y + aChildren.x;
|
|
}
|
|
else
|
|
{
|
|
toContinue = (aHead >= 0);
|
|
|
|
if (aHead == aStop) // go to top-level BVH
|
|
{
|
|
aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
|
|
}
|
|
|
|
if (aHead >= 0)
|
|
aNode = pop (aHead);
|
|
}
|
|
}
|
|
else if (aData.x < 0) // leaf node (contains triangles)
|
|
{
|
|
vec3 aNormal;
|
|
vec3 aTimeUV;
|
|
|
|
for (int anIdx = aData.y; anIdx <= aData.z; ++anIdx)
|
|
{
|
|
ivec4 aTriIndex = texelFetch (uGeometryTriangTexture, anIdx + TRG_OFFSET (aSubTree));
|
|
vec3 aPoints[3];
|
|
|
|
aPoints[0] = texelFetch (uGeometryVertexTexture, aTriIndex.x += VRT_OFFSET (aSubTree)).xyz;
|
|
aPoints[1] = texelFetch (uGeometryVertexTexture, aTriIndex.y += VRT_OFFSET (aSubTree)).xyz;
|
|
aPoints[2] = texelFetch (uGeometryVertexTexture, aTriIndex.z += VRT_OFFSET (aSubTree)).xyz;
|
|
|
|
IntersectTriangle (aSubTree.TrsfRay, aPoints[0], aPoints[1], aPoints[2], aTimeUV, aNormal);
|
|
|
|
if (aTimeUV.x < theHit.Time)
|
|
{
|
|
aTriangle.TriIndex = aTriIndex;
|
|
for (int i = 0; i < 3; ++i)
|
|
{
|
|
aTriangle.Points[i] = aPoints[i];
|
|
}
|
|
|
|
theTrsfId = TRS_OFFSET (aSubTree);
|
|
|
|
theHit = SIntersect (aTimeUV.x, aTimeUV.yz, aNormal);
|
|
}
|
|
}
|
|
|
|
toContinue = (aHead >= 0);
|
|
|
|
if (aHead == aStop) // go to top-level BVH
|
|
{
|
|
aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
|
|
}
|
|
|
|
if (aHead >= 0)
|
|
aNode = pop (aHead);
|
|
}
|
|
else if (aData.x > 0) // switch node
|
|
{
|
|
aSubTree.SubData = ivec4 (4 * aData.x - 4, aData.yzw); // store BVH sub-root
|
|
|
|
vec4 aInvTransf0 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 0);
|
|
vec4 aInvTransf1 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 1);
|
|
vec4 aInvTransf2 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 2);
|
|
vec4 aInvTransf3 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 3);
|
|
|
|
aSubTree.TrsfRay.Direct = MatrixColMultiplyDir (theRay.Direct,
|
|
aInvTransf0,
|
|
aInvTransf1,
|
|
aInvTransf2);
|
|
|
|
aSubTree.Inverse = mix (-UNIT, UNIT, step (ZERO, aSubTree.TrsfRay.Direct)) /
|
|
max (abs (aSubTree.TrsfRay.Direct), SMALL);
|
|
|
|
aSubTree.TrsfRay.Origin = MatrixColMultiplyPnt (theRay.Origin,
|
|
aInvTransf0,
|
|
aInvTransf1,
|
|
aInvTransf2,
|
|
aInvTransf3);
|
|
|
|
aNode = BVH_OFFSET (aSubTree); // go to sub-root node
|
|
|
|
aStop = aHead; // store current stack pointer
|
|
}
|
|
}
|
|
|
|
return aTriangle;
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : SceneAnyHit
|
|
// purpose : Finds intersection with any scene triangle
|
|
// =======================================================================
|
|
float SceneAnyHit (in SRay theRay, in vec3 theInverse, in float theDistance)
|
|
{
|
|
float aFactor = 1.f;
|
|
|
|
int aNode = 0; // node to traverse
|
|
int aHead = -1; // pointer of stack
|
|
int aStop = -1; // BVH level switch
|
|
|
|
SSubTree aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
|
|
|
|
for (bool toContinue = true; toContinue; /* none */)
|
|
{
|
|
ivec4 aData = texelFetch (uSceneNodeInfoTexture, aNode);
|
|
|
|
if (aData.x == 0) // if inner node
|
|
{
|
|
aData.y += BVH_OFFSET (aSubTree);
|
|
|
|
vec4 aHitTimes = vec4 (MAXFLOAT,
|
|
MAXFLOAT,
|
|
MAXFLOAT,
|
|
MAXFLOAT);
|
|
|
|
vec3 aRayOriginInverse = -aSubTree.TrsfRay.Origin * aSubTree.Inverse;
|
|
|
|
vec3 aNodeMin0 = texelFetch (uSceneMinPointTexture, aData.y + 0).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMin1 = texelFetch (uSceneMinPointTexture, aData.y + 1).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMin2 = texelFetch (uSceneMinPointTexture, aData.y + min (2, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMin3 = texelFetch (uSceneMinPointTexture, aData.y + min (3, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMax0 = texelFetch (uSceneMaxPointTexture, aData.y + 0).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMax1 = texelFetch (uSceneMaxPointTexture, aData.y + 1).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMax2 = texelFetch (uSceneMaxPointTexture, aData.y + min (2, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
vec3 aNodeMax3 = texelFetch (uSceneMaxPointTexture, aData.y + min (3, aData.z)).xyz * aSubTree.Inverse + aRayOriginInverse;
|
|
|
|
vec3 aTimeMax = max (aNodeMin0, aNodeMax0);
|
|
vec3 aTimeMin = min (aNodeMin0, aNodeMax0);
|
|
|
|
float aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
|
|
float aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
|
|
|
|
aHitTimes.x = (aTimeEnter <= aTimeLeave && aTimeEnter <= theDistance && aTimeLeave >= 0.f) ? aTimeEnter : MAXFLOAT;
|
|
|
|
aTimeMax = max (aNodeMin1, aNodeMax1);
|
|
aTimeMin = min (aNodeMin1, aNodeMax1);
|
|
|
|
aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
|
|
aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
|
|
|
|
aHitTimes.y = (aTimeEnter <= aTimeLeave && aTimeEnter <= theDistance && aTimeLeave >= 0.f) ? aTimeEnter : MAXFLOAT;
|
|
|
|
aTimeMax = max (aNodeMin2, aNodeMax2);
|
|
aTimeMin = min (aNodeMin2, aNodeMax2);
|
|
|
|
aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
|
|
aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
|
|
|
|
aHitTimes.z = (aTimeEnter <= aTimeLeave && aTimeEnter <= theDistance && aTimeLeave >= 0.f && aData.z > 1) ? aTimeEnter : MAXFLOAT;
|
|
|
|
aTimeMax = max (aNodeMin3, aNodeMax3);
|
|
aTimeMin = min (aNodeMin3, aNodeMax3);
|
|
|
|
aTimeLeave = min (aTimeMax.x, min (aTimeMax.y, aTimeMax.z));
|
|
aTimeEnter = max (aTimeMin.x, max (aTimeMin.y, aTimeMin.z));
|
|
|
|
aHitTimes.w = (aTimeEnter <= aTimeLeave && aTimeEnter <= theDistance && aTimeLeave >= 0.f && aData.z > 2) ? aTimeEnter : MAXFLOAT;
|
|
|
|
ivec4 aChildren = ivec4 (0, 1, 2, 3);
|
|
|
|
aChildren.xy = aHitTimes.y < aHitTimes.x ? aChildren.yx : aChildren.xy;
|
|
aHitTimes.xy = aHitTimes.y < aHitTimes.x ? aHitTimes.yx : aHitTimes.xy;
|
|
aChildren.zw = aHitTimes.w < aHitTimes.z ? aChildren.wz : aChildren.zw;
|
|
aHitTimes.zw = aHitTimes.w < aHitTimes.z ? aHitTimes.wz : aHitTimes.zw;
|
|
aChildren.xz = aHitTimes.z < aHitTimes.x ? aChildren.zx : aChildren.xz;
|
|
aHitTimes.xz = aHitTimes.z < aHitTimes.x ? aHitTimes.zx : aHitTimes.xz;
|
|
aChildren.yw = aHitTimes.w < aHitTimes.y ? aChildren.wy : aChildren.yw;
|
|
aHitTimes.yw = aHitTimes.w < aHitTimes.y ? aHitTimes.wy : aHitTimes.yw;
|
|
aChildren.yz = aHitTimes.z < aHitTimes.y ? aChildren.zy : aChildren.yz;
|
|
aHitTimes.yz = aHitTimes.z < aHitTimes.y ? aHitTimes.zy : aHitTimes.yz;
|
|
|
|
if (aHitTimes.x != MAXFLOAT)
|
|
{
|
|
int aHitMask = (aHitTimes.w != MAXFLOAT ? aChildren.w : aChildren.z) << 2
|
|
| (aHitTimes.z != MAXFLOAT ? aChildren.z : aChildren.y);
|
|
|
|
if (aHitTimes.y != MAXFLOAT)
|
|
Stack[++aHead] = aData.y | (aHitMask << 2 | aChildren.y) << 26;
|
|
|
|
aNode = aData.y + aChildren.x;
|
|
}
|
|
else
|
|
{
|
|
toContinue = (aHead >= 0);
|
|
|
|
if (aHead == aStop) // go to top-level BVH
|
|
{
|
|
aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
|
|
}
|
|
|
|
if (aHead >= 0)
|
|
aNode = pop (aHead);
|
|
}
|
|
}
|
|
else if (aData.x < 0) // leaf node
|
|
{
|
|
vec3 aNormal;
|
|
vec3 aTimeUV;
|
|
|
|
for (int anIdx = aData.y; anIdx <= aData.z; ++anIdx)
|
|
{
|
|
ivec4 aTriangle = texelFetch (uGeometryTriangTexture, anIdx + TRG_OFFSET (aSubTree));
|
|
|
|
vec3 aPoint0 = texelFetch (uGeometryVertexTexture, aTriangle.x += VRT_OFFSET (aSubTree)).xyz;
|
|
vec3 aPoint1 = texelFetch (uGeometryVertexTexture, aTriangle.y += VRT_OFFSET (aSubTree)).xyz;
|
|
vec3 aPoint2 = texelFetch (uGeometryVertexTexture, aTriangle.z += VRT_OFFSET (aSubTree)).xyz;
|
|
|
|
IntersectTriangle (aSubTree.TrsfRay, aPoint0, aPoint1, aPoint2, aTimeUV, aNormal);
|
|
|
|
#ifdef TRANSPARENT_SHADOWS
|
|
if (aTimeUV.x < theDistance)
|
|
{
|
|
aFactor *= 1.f - texelFetch (uRaytraceMaterialTexture, MATERIAL_TRAN (aTriangle.w)).x;
|
|
}
|
|
#else
|
|
if (aTimeUV.x < theDistance)
|
|
{
|
|
aFactor = 0.f;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
toContinue = (aHead >= 0) && (aFactor > 0.1f);
|
|
|
|
if (aHead == aStop) // go to top-level BVH
|
|
{
|
|
aStop = -1; aSubTree = SSubTree (theRay, theInverse, EMPTY_ROOT);
|
|
}
|
|
|
|
if (aHead >= 0)
|
|
aNode = pop (aHead);
|
|
}
|
|
else if (aData.x > 0) // switch node
|
|
{
|
|
aSubTree.SubData = ivec4 (4 * aData.x - 4, aData.yzw); // store BVH sub-root
|
|
|
|
vec4 aInvTransf0 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 0);
|
|
vec4 aInvTransf1 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 1);
|
|
vec4 aInvTransf2 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 2);
|
|
vec4 aInvTransf3 = texelFetch (uSceneTransformTexture, TRS_OFFSET (aSubTree) + 3);
|
|
|
|
aSubTree.TrsfRay.Direct = MatrixColMultiplyDir (theRay.Direct,
|
|
aInvTransf0,
|
|
aInvTransf1,
|
|
aInvTransf2);
|
|
|
|
aSubTree.TrsfRay.Origin = MatrixColMultiplyPnt (theRay.Origin,
|
|
aInvTransf0,
|
|
aInvTransf1,
|
|
aInvTransf2,
|
|
aInvTransf3);
|
|
|
|
aSubTree.Inverse = mix (-UNIT, UNIT, step (ZERO, aSubTree.TrsfRay.Direct)) / max (abs (aSubTree.TrsfRay.Direct), SMALL);
|
|
|
|
aNode = BVH_OFFSET (aSubTree); // go to sub-root node
|
|
|
|
aStop = aHead; // store current stack pointer
|
|
}
|
|
}
|
|
|
|
return aFactor;
|
|
}
|
|
|
|
#define PI 3.1415926f
|
|
|
|
// =======================================================================
|
|
// function : Latlong
|
|
// purpose : Converts world direction to environment texture coordinates
|
|
// =======================================================================
|
|
vec2 Latlong (in vec3 thePoint, in float theRadius)
|
|
{
|
|
float aPsi = acos (-thePoint.z / theRadius);
|
|
|
|
float aPhi = atan (thePoint.y, thePoint.x) + PI;
|
|
|
|
return vec2 (aPhi * 0.1591549f,
|
|
aPsi * 0.3183098f);
|
|
}
|
|
|
|
#ifdef BACKGROUND_CUBEMAP
|
|
//! Transform texture coordinates for cubemap lookup.
|
|
vec3 cubemapVectorTransform (in vec3 theVec, in float theRadius)
|
|
{
|
|
vec3 aVec = theVec.yzx;
|
|
aVec.y *= float(uYCoeff);
|
|
aVec.z *= float(uZCoeff);
|
|
return aVec;
|
|
}
|
|
#endif
|
|
|
|
// =======================================================================
|
|
// function : SmoothNormal
|
|
// purpose : Interpolates normal across the triangle
|
|
// =======================================================================
|
|
vec3 SmoothNormal (in vec2 theUV, in ivec4 theTriangle)
|
|
{
|
|
vec3 aNormal0 = texelFetch (uGeometryNormalTexture, theTriangle.x).xyz;
|
|
vec3 aNormal1 = texelFetch (uGeometryNormalTexture, theTriangle.y).xyz;
|
|
vec3 aNormal2 = texelFetch (uGeometryNormalTexture, theTriangle.z).xyz;
|
|
|
|
return normalize (aNormal1 * theUV.x +
|
|
aNormal2 * theUV.y +
|
|
aNormal0 * (1.0f - theUV.x - theUV.y));
|
|
}
|
|
|
|
#define POLYGON_OFFSET_UNIT 0.f
|
|
#define POLYGON_OFFSET_FACTOR 1.f
|
|
#define POLYGON_OFFSET_SCALE 0.006f
|
|
|
|
// =======================================================================
|
|
// function : PolygonOffset
|
|
// purpose : Computes OpenGL polygon offset
|
|
// =======================================================================
|
|
float PolygonOffset (in vec3 theNormal, in vec3 thePoint)
|
|
{
|
|
vec4 aProjectedNorm = vec4 (theNormal, -dot (theNormal, thePoint)) * uUnviewMat;
|
|
|
|
float aPolygonOffset = POLYGON_OFFSET_UNIT;
|
|
|
|
if (aProjectedNorm.z * aProjectedNorm.z > 1e-20f)
|
|
{
|
|
aProjectedNorm.xy *= 1.f / aProjectedNorm.z;
|
|
|
|
aPolygonOffset += POLYGON_OFFSET_FACTOR * max (abs (aProjectedNorm.x),
|
|
abs (aProjectedNorm.y));
|
|
}
|
|
|
|
return aPolygonOffset;
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : SmoothUV
|
|
// purpose : Interpolates UV coordinates across the triangle
|
|
// =======================================================================
|
|
#ifdef USE_TEXTURES
|
|
vec2 SmoothUV (in vec2 theUV, in ivec4 theTriangle, out vec2[3] theUVs)
|
|
{
|
|
theUVs[0] = texelFetch (uGeometryTexCrdTexture, theTriangle.x).st;
|
|
theUVs[1] = texelFetch (uGeometryTexCrdTexture, theTriangle.y).st;
|
|
theUVs[2] = texelFetch (uGeometryTexCrdTexture, theTriangle.z).st;
|
|
|
|
return theUVs[1] * theUV.x +
|
|
theUVs[2] * theUV.y +
|
|
theUVs[0] * (1.0f - theUV.x - theUV.y);
|
|
}
|
|
|
|
vec2 SmoothUV (in vec2 theUV, in ivec4 theTriangle)
|
|
{
|
|
vec2 aUVs[3];
|
|
return SmoothUV (theUV, theTriangle, aUVs);
|
|
}
|
|
#endif
|
|
|
|
// =======================================================================
|
|
// function : FetchEnvironment
|
|
// purpose :
|
|
// =======================================================================
|
|
vec4 FetchEnvironment (in vec3 theTexCoord, in float theRadius, in bool theIsBackground)
|
|
{
|
|
if (uEnvMapEnabled == 0)
|
|
{
|
|
#ifdef PATH_TRACING
|
|
return theIsBackground ? vec4 (0.0, 0.0, 0.0, 1.0) : uGlobalAmbient;
|
|
#else
|
|
return vec4 (0.0, 0.0, 0.0, 1.0);
|
|
#endif
|
|
}
|
|
|
|
vec4 anAmbScale = theIsBackground ? vec4(1.0) : uGlobalAmbient;
|
|
vec4 anEnvColor =
|
|
#ifdef BACKGROUND_CUBEMAP
|
|
textureLod (uEnvMapTexture, cubemapVectorTransform (theTexCoord, theRadius), 0.0);
|
|
#else
|
|
textureLod (uEnvMapTexture, Latlong (theTexCoord, theRadius), 0.0);
|
|
#endif
|
|
return anEnvColor * anAmbScale;
|
|
}
|
|
|
|
// =======================================================================
|
|
// function : Refract
|
|
// purpose : Computes refraction ray (also handles TIR)
|
|
// =======================================================================
|
|
#ifndef PATH_TRACING
|
|
vec3 Refract (in vec3 theInput,
|
|
in vec3 theNormal,
|
|
in float theRefractIndex,
|
|
in float theInvRefractIndex)
|
|
{
|
|
float aNdotI = dot (theInput, theNormal);
|
|
|
|
float anIndex = aNdotI < 0.0f
|
|
? theInvRefractIndex
|
|
: theRefractIndex;
|
|
|
|
float aSquare = anIndex * anIndex * (1.0f - aNdotI * aNdotI);
|
|
|
|
if (aSquare > 1.0f)
|
|
{
|
|
return reflect (theInput, theNormal);
|
|
}
|
|
|
|
float aNdotT = sqrt (1.0f - aSquare);
|
|
|
|
return normalize (anIndex * theInput -
|
|
(anIndex * aNdotI + (aNdotI < 0.0f ? aNdotT : -aNdotT)) * theNormal);
|
|
}
|
|
#endif
|
|
|
|
#define MIN_SLOPE 0.0001f
|
|
#define EPS_SCALE 8.0000f
|
|
|
|
#define THRESHOLD vec3 (0.1f)
|
|
|
|
#define INVALID_BOUNCES 1000
|
|
|
|
#define LIGHT_POS(index) (2 * index + 1)
|
|
#define LIGHT_PWR(index) (2 * index + 0)
|
|
|
|
// =======================================================================
|
|
// function : Radiance
|
|
// purpose : Computes color along the given ray
|
|
// =======================================================================
|
|
#ifndef PATH_TRACING
|
|
vec4 Radiance (in SRay theRay, in vec3 theInverse)
|
|
{
|
|
vec3 aResult = vec3 (0.0f);
|
|
vec4 aWeight = vec4 (1.0f);
|
|
|
|
int aTrsfId;
|
|
|
|
float aRaytraceDepth = MAXFLOAT;
|
|
float aRefractionIdx = 0.0;
|
|
|
|
for (int aDepth = 0; aDepth < NB_BOUNCES; ++aDepth)
|
|
{
|
|
SIntersect aHit = SIntersect (MAXFLOAT, vec2 (ZERO), ZERO);
|
|
|
|
ivec4 aTriIndex = SceneNearestHit (theRay, theInverse, aHit, aTrsfId).TriIndex;
|
|
|
|
if (aTriIndex.x == -1)
|
|
{
|
|
vec4 aColor = vec4 (0.0);
|
|
|
|
if (bool(uEnvMapForBack) || aWeight.w == 0.0 /* reflection */)
|
|
{
|
|
float aRadius = uSceneRadius;
|
|
vec3 aTexCoord = vec3 (0.0);
|
|
|
|
if (aDepth == 0 || (aRefractionIdx == 1.0 && aWeight.w != 0.0))
|
|
{
|
|
vec2 aPixel = uEyeSize * (vPixel - vec2 (0.5)) * 2.0;
|
|
vec2 anAperturePnt = sampleUniformDisk() * uApertureRadius;
|
|
vec3 aLocalDir = normalize (vec3 (aPixel * uFocalPlaneDist - anAperturePnt, uFocalPlaneDist));
|
|
vec3 aDirect = uEyeView * aLocalDir.z +
|
|
uEyeSide * aLocalDir.x +
|
|
uEyeVert * aLocalDir.y;
|
|
|
|
aTexCoord = aDirect * uSceneRadius;
|
|
aRadius = length (aTexCoord);
|
|
}
|
|
else
|
|
{
|
|
float aTime = IntersectSphere (theRay, uSceneRadius);
|
|
aTexCoord = theRay.Direct * aTime + theRay.Origin;
|
|
}
|
|
|
|
aColor = FetchEnvironment (aTexCoord, aRadius, aWeight.w != 0.0);
|
|
}
|
|
else
|
|
{
|
|
aColor = BackgroundColor();
|
|
}
|
|
|
|
aResult += aWeight.xyz * aColor.xyz; aWeight.w *= aColor.w;
|
|
|
|
break; // terminate path
|
|
}
|
|
|
|
vec3 aInvTransf0 = texelFetch (uSceneTransformTexture, aTrsfId + 0).xyz;
|
|
vec3 aInvTransf1 = texelFetch (uSceneTransformTexture, aTrsfId + 1).xyz;
|
|
vec3 aInvTransf2 = texelFetch (uSceneTransformTexture, aTrsfId + 2).xyz;
|
|
|
|
aHit.Normal = normalize (vec3 (dot (aInvTransf0, aHit.Normal),
|
|
dot (aInvTransf1, aHit.Normal),
|
|
dot (aInvTransf2, aHit.Normal)));
|
|
|
|
theRay.Origin += theRay.Direct * aHit.Time; // intersection point
|
|
|
|
// Evaluate depth on first hit
|
|
if (aDepth == 0)
|
|
{
|
|
vec4 aNDCPoint = uViewMat * vec4 (theRay.Origin, 1.f);
|
|
|
|
float aPolygonOffset = PolygonOffset (aHit.Normal, theRay.Origin);
|
|
#ifdef THE_ZERO_TO_ONE_DEPTH
|
|
aRaytraceDepth = (aNDCPoint.z / aNDCPoint.w + aPolygonOffset * POLYGON_OFFSET_SCALE);
|
|
#else
|
|
aRaytraceDepth = (aNDCPoint.z / aNDCPoint.w + aPolygonOffset * POLYGON_OFFSET_SCALE) * 0.5f + 0.5f;
|
|
#endif
|
|
}
|
|
|
|
vec3 aNormal = SmoothNormal (aHit.UV, aTriIndex);
|
|
|
|
aNormal = normalize (vec3 (dot (aInvTransf0, aNormal),
|
|
dot (aInvTransf1, aNormal),
|
|
dot (aInvTransf2, aNormal)));
|
|
|
|
vec3 aAmbient = texelFetch (
|
|
uRaytraceMaterialTexture, MATERIAL_AMBN (aTriIndex.w)).rgb;
|
|
vec4 aDiffuse = texelFetch (
|
|
uRaytraceMaterialTexture, MATERIAL_DIFF (aTriIndex.w));
|
|
vec4 aSpecular = texelFetch (
|
|
uRaytraceMaterialTexture, MATERIAL_SPEC (aTriIndex.w));
|
|
vec4 aOpacity = texelFetch (
|
|
uRaytraceMaterialTexture, MATERIAL_TRAN (aTriIndex.w));
|
|
|
|
#ifdef USE_TEXTURES
|
|
if (aDiffuse.w >= 0.f)
|
|
{
|
|
vec4 aTexCoord = vec4 (SmoothUV (aHit.UV, aTriIndex), 0.f, 1.f);
|
|
|
|
vec4 aTrsfRow1 = texelFetch (
|
|
uRaytraceMaterialTexture, MATERIAL_TRS1 (aTriIndex.w));
|
|
vec4 aTrsfRow2 = texelFetch (
|
|
uRaytraceMaterialTexture, MATERIAL_TRS2 (aTriIndex.w));
|
|
|
|
aTexCoord.st = vec2 (dot (aTrsfRow1, aTexCoord),
|
|
dot (aTrsfRow2, aTexCoord));
|
|
|
|
vec4 aTexColor = textureLod (
|
|
sampler2D (uTextureSamplers[int(aDiffuse.w)]), aTexCoord.st, 0.f);
|
|
|
|
aDiffuse.rgb *= aTexColor.rgb;
|
|
aAmbient.rgb *= aTexColor.rgb;
|
|
|
|
// keep refractive index untouched (Z component)
|
|
aOpacity.xy = vec2 (aTexColor.w * aOpacity.x, 1.0f - aTexColor.w * aOpacity.x);
|
|
}
|
|
#endif
|
|
|
|
vec3 aEmission = texelFetch (
|
|
uRaytraceMaterialTexture, MATERIAL_EMIS (aTriIndex.w)).rgb;
|
|
|
|
float aGeomFactor = dot (aNormal, theRay.Direct);
|
|
|
|
aResult.xyz += aWeight.xyz * aOpacity.x * (
|
|
uGlobalAmbient.xyz * aAmbient * max (abs (aGeomFactor), 0.5f) + aEmission);
|
|
|
|
vec3 aSidedNormal = mix (aNormal, -aNormal, step (0.0f, aGeomFactor));
|
|
|
|
for (int aLightIdx = 0; aLightIdx < uLightCount; ++aLightIdx)
|
|
{
|
|
vec4 aLight = texelFetch (
|
|
uRaytraceLightSrcTexture, LIGHT_POS (aLightIdx));
|
|
|
|
float aDistance = MAXFLOAT;
|
|
|
|
if (aLight.w != 0.0f) // point light source
|
|
{
|
|
aDistance = length (aLight.xyz -= theRay.Origin);
|
|
|
|
aLight.xyz *= 1.0f / aDistance;
|
|
}
|
|
|
|
float aLdotN = dot (aLight.xyz, aSidedNormal);
|
|
|
|
if (aLdotN > 0.0f) // first check if light source is important
|
|
{
|
|
float aVisibility = 1.0f;
|
|
|
|
if (bool(uShadowsEnabled))
|
|
{
|
|
SRay aShadow = SRay (theRay.Origin, aLight.xyz);
|
|
|
|
aShadow.Origin += uSceneEpsilon * (aLight.xyz +
|
|
mix (-aHit.Normal, aHit.Normal, step (0.0f, dot (aHit.Normal, aLight.xyz))));
|
|
|
|
vec3 aInverse = 1.0f / max (abs (aLight.xyz), SMALL);
|
|
|
|
aVisibility = SceneAnyHit (
|
|
aShadow, mix (-aInverse, aInverse, step (ZERO, aLight.xyz)), aDistance);
|
|
}
|
|
|
|
if (aVisibility > 0.0f)
|
|
{
|
|
vec3 aIntensity = min (UNIT, vec3 (texelFetch (
|
|
uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx))));
|
|
|
|
float aRdotV = dot (reflect (aLight.xyz, aSidedNormal), theRay.Direct);
|
|
|
|
aResult.xyz += aWeight.xyz * (aOpacity.x * aVisibility) * aIntensity *
|
|
(aDiffuse.xyz * aLdotN + aSpecular.xyz * pow (max (0.f, aRdotV), aSpecular.w));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aOpacity.x != 1.0f)
|
|
{
|
|
aWeight *= aOpacity.y;
|
|
aRefractionIdx = aOpacity.z;
|
|
|
|
if (aOpacity.z != 1.0f)
|
|
{
|
|
theRay.Direct = Refract (theRay.Direct, aNormal, aOpacity.z, aOpacity.w);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aWeight *= bool(uReflectEnabled) ?
|
|
texelFetch (uRaytraceMaterialTexture, MATERIAL_REFL (aTriIndex.w)) : vec4 (0.0f);
|
|
|
|
vec3 aReflect = reflect (theRay.Direct, aNormal);
|
|
|
|
if (dot (aReflect, aHit.Normal) * dot (theRay.Direct, aHit.Normal) > 0.0f)
|
|
{
|
|
aReflect = reflect (theRay.Direct, aHit.Normal);
|
|
}
|
|
|
|
theRay.Direct = aReflect;
|
|
}
|
|
|
|
if (all (lessThanEqual (aWeight.xyz, THRESHOLD)))
|
|
{
|
|
aDepth = INVALID_BOUNCES;
|
|
}
|
|
else if (aOpacity.x == 1.0f || aOpacity.z != 1.0f) // if no simple transparency
|
|
{
|
|
theRay.Origin += aHit.Normal * mix (
|
|
-uSceneEpsilon, uSceneEpsilon, step (0.0f, dot (aHit.Normal, theRay.Direct)));
|
|
|
|
theInverse = 1.0f / max (abs (theRay.Direct), SMALL);
|
|
|
|
theInverse = mix (-theInverse, theInverse, step (ZERO, theRay.Direct));
|
|
}
|
|
|
|
theRay.Origin += theRay.Direct * uSceneEpsilon;
|
|
}
|
|
|
|
gl_FragDepth = aRaytraceDepth;
|
|
|
|
return vec4 (aResult.x,
|
|
aResult.y,
|
|
aResult.z,
|
|
aWeight.w);
|
|
}
|
|
#endif
|