@spiffcommerce/preview 3.6.2-rc.3 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrVertexDeclaration.esm.js

@@ -0,0 +1,151 @@
+import { ShaderStore as i } from "../../Engines/shaderStore.esm.js";
+import "./decalVertexDeclaration.esm.js";
+const e = "pbrVertexDeclaration", f = `uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef ALBEDO
+uniform mat4 albedoMatrix;
+uniform vec2 vAlbedoInfos;
+#endif
+#ifdef AMBIENT
+uniform mat4 ambientMatrix;
+uniform vec4 vAmbientInfos;
+#endif
+#ifdef OPACITY
+uniform mat4 opacityMatrix;
+uniform vec2 vOpacityInfos;
+#endif
+#ifdef EMISSIVE
+uniform vec2 vEmissiveInfos;
+uniform mat4 emissiveMatrix;
+#endif
+#ifdef LIGHTMAP
+uniform vec2 vLightmapInfos;
+uniform mat4 lightmapMatrix;
+#endif
+#ifdef REFLECTIVITY 
+uniform vec3 vReflectivityInfos;
+uniform mat4 reflectivityMatrix;
+#endif
+#ifdef METALLIC_REFLECTANCE
+uniform vec2 vMetallicReflectanceInfos;
+uniform mat4 metallicReflectanceMatrix;
+#endif
+#ifdef REFLECTANCE
+uniform vec2 vReflectanceInfos;
+uniform mat4 reflectanceMatrix;
+#endif
+#ifdef MICROSURFACEMAP
+uniform vec2 vMicroSurfaceSamplerInfos;
+uniform mat4 microSurfaceSamplerMatrix;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;
+uniform mat4 bumpMatrix;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+#ifdef REFLECTION
+uniform vec2 vReflectionInfos;
+uniform mat4 reflectionMatrix;
+#endif
+#ifdef CLEARCOAT
+#if defined(CLEARCOAT_TEXTURE) || defined(CLEARCOAT_TEXTURE_ROUGHNESS)
+uniform vec4 vClearCoatInfos;
+#endif
+#ifdef CLEARCOAT_TEXTURE
+uniform mat4 clearCoatMatrix;
+#endif
+#ifdef CLEARCOAT_TEXTURE_ROUGHNESS
+uniform mat4 clearCoatRoughnessMatrix;
+#endif
+#ifdef CLEARCOAT_BUMP
+uniform vec2 vClearCoatBumpInfos;
+uniform mat4 clearCoatBumpMatrix;
+#endif
+#ifdef CLEARCOAT_TINT_TEXTURE
+uniform vec2 vClearCoatTintInfos;
+uniform mat4 clearCoatTintMatrix;
+#endif
+#endif
+#ifdef IRIDESCENCE
+#if defined(IRIDESCENCE_TEXTURE) || defined(IRIDESCENCE_THICKNESS_TEXTURE)
+uniform vec4 vIridescenceInfos;
+#endif
+#ifdef IRIDESCENCE_TEXTURE
+uniform mat4 iridescenceMatrix;
+#endif
+#ifdef IRIDESCENCE_THICKNESS_TEXTURE
+uniform mat4 iridescenceThicknessMatrix;
+#endif
+#endif
+#ifdef ANISOTROPIC
+#ifdef ANISOTROPIC_TEXTURE
+uniform vec2 vAnisotropyInfos;
+uniform mat4 anisotropyMatrix;
+#endif
+#endif
+#ifdef SHEEN
+#if defined(SHEEN_TEXTURE) || defined(SHEEN_TEXTURE_ROUGHNESS)
+uniform vec4 vSheenInfos;
+#endif
+#ifdef SHEEN_TEXTURE
+uniform mat4 sheenMatrix;
+#endif
+#ifdef SHEEN_TEXTURE_ROUGHNESS
+uniform mat4 sheenRoughnessMatrix;
+#endif
+#endif
+#ifdef SUBSURFACE
+#ifdef SS_REFRACTION
+uniform vec4 vRefractionInfos;
+uniform mat4 refractionMatrix;
+#endif
+#ifdef SS_THICKNESSANDMASK_TEXTURE
+uniform vec2 vThicknessInfos;
+uniform mat4 thicknessMatrix;
+#endif
+#ifdef SS_REFRACTIONINTENSITY_TEXTURE
+uniform vec2 vRefractionIntensityInfos;
+uniform mat4 refractionIntensityMatrix;
+#endif
+#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE
+uniform vec2 vTranslucencyIntensityInfos;
+uniform mat4 translucencyIntensityMatrix;
+#endif
+#endif
+#ifdef NORMAL
+#if defined(USESPHERICALFROMREFLECTIONMAP) && defined(USESPHERICALINVERTEX)
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#ifdef SPHERICAL_HARMONICS
+uniform vec3 vSphericalL00;
+uniform vec3 vSphericalL1_1;
+uniform vec3 vSphericalL10;
+uniform vec3 vSphericalL11;
+uniform vec3 vSphericalL2_2;
+uniform vec3 vSphericalL2_1;
+uniform vec3 vSphericalL20;
+uniform vec3 vSphericalL21;
+uniform vec3 vSphericalL22;
+#else
+uniform vec3 vSphericalX;
+uniform vec3 vSphericalY;
+uniform vec3 vSphericalZ;
+uniform vec3 vSphericalXX_ZZ;
+uniform vec3 vSphericalYY_ZZ;
+uniform vec3 vSphericalZZ;
+uniform vec3 vSphericalXY;
+uniform vec3 vSphericalYZ;
+uniform vec3 vSphericalZX;
+#endif
+#endif
+#endif
+#endif
+#ifdef DETAIL
+uniform vec4 vDetailInfos;
+uniform mat4 detailMatrix;
+#endif
+#include<decalVertexDeclaration>
+#define ADDITIONAL_VERTEX_DECLARATION
+`;
+i.IncludesShadersStore[e] = f;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/pointCloudVertex.esm.js

@@ -0,0 +1,6 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const d = "pointCloudVertex", i = `#if defined(POINTSIZE) && !defined(WEBGPU)
+gl_PointSize=pointSize;
+#endif
+`;
+e.IncludesShadersStore[d] = i;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/prePassDeclaration.esm.js

@@ -0,0 +1,13 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "prePassDeclaration", r = `#ifdef PREPASS
+#extension GL_EXT_draw_buffers : require
+layout(location=0) out highp vec4 glFragData[{X}];highp vec4 gl_FragColor;
+#ifdef PREPASS_DEPTH
+varying highp vec3 vViewPos;
+#endif
+#ifdef PREPASS_VELOCITY
+varying highp vec4 vCurrentPosition;varying highp vec4 vPreviousPosition;
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] = r;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/prePassVertex.esm.js

@@ -0,0 +1,37 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "prePassVertex", s = `#ifdef PREPASS_DEPTH
+vViewPos=(view*worldPos).rgb;
+#endif
+#if defined(PREPASS_VELOCITY) && defined(BONES_VELOCITY_ENABLED)
+vCurrentPosition=viewProjection*worldPos;
+#if NUM_BONE_INFLUENCERS>0
+mat4 previousInfluence;
+previousInfluence=mPreviousBones[int(matricesIndices[0])]*matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+previousInfluence+=mPreviousBones[int(matricesIndices[1])]*matricesWeights[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>2
+previousInfluence+=mPreviousBones[int(matricesIndices[2])]*matricesWeights[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>3
+previousInfluence+=mPreviousBones[int(matricesIndices[3])]*matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];
+#endif 
+#if NUM_BONE_INFLUENCERS>5
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>6
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>7
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];
+#endif
+vPreviousPosition=previousViewProjection*finalPreviousWorld*previousInfluence*vec4(positionUpdated,1.0);
+#else
+vPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] = s;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/prePassVertexDeclaration.esm.js

@@ -0,0 +1,13 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const i = "prePassVertexDeclaration", r = `#ifdef PREPASS
+#ifdef PREPASS_DEPTH
+varying vec3 vViewPos;
+#endif
+#ifdef PREPASS_VELOCITY
+uniform mat4 previousViewProjection;
+varying vec4 vCurrentPosition;
+varying vec4 vPreviousPosition;
+#endif
+#endif
+`;
+e.IncludesShadersStore[i] = r;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/reflectionFunction.esm.js

@@ -0,0 +1,116 @@
+import { ShaderStore as o } from "../../Engines/shaderStore.esm.js";
+const e = "reflectionFunction", r = `vec3 computeFixedEquirectangularCoords(vec4 worldPos,vec3 worldNormal,vec3 direction)
+{
+float lon=atan(direction.z,direction.x);
+float lat=acos(direction.y);
+vec2 sphereCoords=vec2(lon,lat)*RECIPROCAL_PI2*2.0;
+float s=sphereCoords.x*0.5+0.5;
+float t=sphereCoords.y;
+return vec3(s,t,0); 
+}
+vec3 computeMirroredFixedEquirectangularCoords(vec4 worldPos,vec3 worldNormal,vec3 direction)
+{
+float lon=atan(direction.z,direction.x);
+float lat=acos(direction.y);
+vec2 sphereCoords=vec2(lon,lat)*RECIPROCAL_PI2*2.0;
+float s=sphereCoords.x*0.5+0.5;
+float t=sphereCoords.y;
+return vec3(1.0-s,t,0); 
+}
+vec3 computeEquirectangularCoords(vec4 worldPos,vec3 worldNormal,vec3 eyePosition,mat4 reflectionMatrix)
+{
+vec3 cameraToVertex=normalize(worldPos.xyz-eyePosition);
+vec3 r=normalize(reflect(cameraToVertex,worldNormal));
+r=vec3(reflectionMatrix*vec4(r,0));
+float lon=atan(r.z,r.x);
+float lat=acos(r.y);
+vec2 sphereCoords=vec2(lon,lat)*RECIPROCAL_PI2*2.0;
+float s=sphereCoords.x*0.5+0.5;
+float t=sphereCoords.y;
+return vec3(s,t,0);
+}
+vec3 computeSphericalCoords(vec4 worldPos,vec3 worldNormal,mat4 view,mat4 reflectionMatrix)
+{
+vec3 viewDir=normalize(vec3(view*worldPos));
+vec3 viewNormal=normalize(vec3(view*vec4(worldNormal,0.0)));
+vec3 r=reflect(viewDir,viewNormal);
+r=vec3(reflectionMatrix*vec4(r,0));
+r.z=r.z-1.0;
+float m=2.0*length(r);
+return vec3(r.x/m+0.5,1.0-r.y/m-0.5,0);
+}
+vec3 computePlanarCoords(vec4 worldPos,vec3 worldNormal,vec3 eyePosition,mat4 reflectionMatrix)
+{
+vec3 viewDir=worldPos.xyz-eyePosition;
+vec3 coords=normalize(reflect(viewDir,worldNormal));
+return vec3(reflectionMatrix*vec4(coords,1));
+}
+vec3 computeCubicCoords(vec4 worldPos,vec3 worldNormal,vec3 eyePosition,mat4 reflectionMatrix)
+{
+vec3 viewDir=normalize(worldPos.xyz-eyePosition);
+vec3 coords=reflect(viewDir,worldNormal);
+coords=vec3(reflectionMatrix*vec4(coords,0));
+#ifdef INVERTCUBICMAP
+coords.y*=-1.0;
+#endif
+return coords;
+}
+vec3 computeCubicLocalCoords(vec4 worldPos,vec3 worldNormal,vec3 eyePosition,mat4 reflectionMatrix,vec3 reflectionSize,vec3 reflectionPosition)
+{
+vec3 viewDir=normalize(worldPos.xyz-eyePosition);
+vec3 coords=reflect(viewDir,worldNormal);
+coords=parallaxCorrectNormal(worldPos.xyz,coords,reflectionSize,reflectionPosition);
+coords=vec3(reflectionMatrix*vec4(coords,0));
+#ifdef INVERTCUBICMAP
+coords.y*=-1.0;
+#endif
+return coords;
+}
+vec3 computeProjectionCoords(vec4 worldPos,mat4 view,mat4 reflectionMatrix)
+{
+return vec3(reflectionMatrix*(view*worldPos));
+}
+vec3 computeSkyBoxCoords(vec3 positionW,mat4 reflectionMatrix)
+{
+return vec3(reflectionMatrix*vec4(positionW,1.));
+}
+#ifdef REFLECTION
+vec3 computeReflectionCoords(vec4 worldPos,vec3 worldNormal)
+{
+#ifdef REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED
+vec3 direction=normalize(vDirectionW);
+return computeMirroredFixedEquirectangularCoords(worldPos,worldNormal,direction);
+#endif
+#ifdef REFLECTIONMAP_EQUIRECTANGULAR_FIXED
+vec3 direction=normalize(vDirectionW);
+return computeFixedEquirectangularCoords(worldPos,worldNormal,direction);
+#endif
+#ifdef REFLECTIONMAP_EQUIRECTANGULAR
+return computeEquirectangularCoords(worldPos,worldNormal,vEyePosition.xyz,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_SPHERICAL
+return computeSphericalCoords(worldPos,worldNormal,view,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_PLANAR
+return computePlanarCoords(worldPos,worldNormal,vEyePosition.xyz,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_CUBIC
+#ifdef USE_LOCAL_REFLECTIONMAP_CUBIC
+return computeCubicLocalCoords(worldPos,worldNormal,vEyePosition.xyz,reflectionMatrix,vReflectionSize,vReflectionPosition);
+#else
+return computeCubicCoords(worldPos,worldNormal,vEyePosition.xyz,reflectionMatrix);
+#endif
+#endif
+#ifdef REFLECTIONMAP_PROJECTION
+return computeProjectionCoords(worldPos,view,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_SKYBOX
+return computeSkyBoxCoords(vPositionUVW,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_EXPLICIT
+return vec3(0,0,0);
+#endif
+}
+#endif
+`;
+o.IncludesShadersStore[e] = r;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/samplerFragmentAlternateDeclaration.esm.js

@@ -0,0 +1,20 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const E = "samplerFragmentAlternateDeclaration", N = `#ifdef _DEFINENAME_
+#if _DEFINENAME_DIRECTUV==1
+#define v_VARYINGNAME_UV vMainUV1
+#elif _DEFINENAME_DIRECTUV==2
+#define v_VARYINGNAME_UV vMainUV2
+#elif _DEFINENAME_DIRECTUV==3
+#define v_VARYINGNAME_UV vMainUV3
+#elif _DEFINENAME_DIRECTUV==4
+#define v_VARYINGNAME_UV vMainUV4
+#elif _DEFINENAME_DIRECTUV==5
+#define v_VARYINGNAME_UV vMainUV5
+#elif _DEFINENAME_DIRECTUV==6
+#define v_VARYINGNAME_UV vMainUV6
+#else
+varying vec2 v_VARYINGNAME_UV;
+#endif
+#endif
+`;
+e.IncludesShadersStore[E] = N;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/samplerFragmentDeclaration.esm.js

@@ -0,0 +1,21 @@
+import { ShaderStore as E } from "../../Engines/shaderStore.esm.js";
+const e = "samplerFragmentDeclaration", _ = `#ifdef _DEFINENAME_
+#if _DEFINENAME_DIRECTUV==1
+#define v_VARYINGNAME_UV vMainUV1
+#elif _DEFINENAME_DIRECTUV==2
+#define v_VARYINGNAME_UV vMainUV2
+#elif _DEFINENAME_DIRECTUV==3
+#define v_VARYINGNAME_UV vMainUV3
+#elif _DEFINENAME_DIRECTUV==4
+#define v_VARYINGNAME_UV vMainUV4
+#elif _DEFINENAME_DIRECTUV==5
+#define v_VARYINGNAME_UV vMainUV5
+#elif _DEFINENAME_DIRECTUV==6
+#define v_VARYINGNAME_UV vMainUV6
+#else
+varying vec2 v_VARYINGNAME_UV;
+#endif
+uniform sampler2D _SAMPLERNAME_Sampler;
+#endif
+`;
+E.IncludesShadersStore[e] = _;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/samplerVertexDeclaration.esm.js

@@ -0,0 +1,6 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const r = "samplerVertexDeclaration", a = `#if defined(_DEFINENAME_) && _DEFINENAME_DIRECTUV==0
+varying vec2 v_VARYINGNAME_UV;
+#endif
+`;
+e.IncludesShadersStore[r] = a;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/samplerVertexImplementation.esm.js

@@ -0,0 +1,39 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const _ = "samplerVertexImplementation", N = `#if defined(_DEFINENAME_) && _DEFINENAME_DIRECTUV==0
+if (v_INFONAME_==0.)
+{
+v_VARYINGNAME_UV=vec2(_MATRIXNAME_Matrix*vec4(uvUpdated,1.0,0.0));
+}
+#ifdef UV2
+else if (v_INFONAME_==1.)
+{
+v_VARYINGNAME_UV=vec2(_MATRIXNAME_Matrix*vec4(uv2,1.0,0.0));
+}
+#endif
+#ifdef UV3
+else if (v_INFONAME_==2.)
+{
+v_VARYINGNAME_UV=vec2(_MATRIXNAME_Matrix*vec4(uv3,1.0,0.0));
+}
+#endif
+#ifdef UV4
+else if (v_INFONAME_==3.)
+{
+v_VARYINGNAME_UV=vec2(_MATRIXNAME_Matrix*vec4(uv4,1.0,0.0));
+}
+#endif
+#ifdef UV5
+else if (v_INFONAME_==4.)
+{
+v_VARYINGNAME_UV=vec2(_MATRIXNAME_Matrix*vec4(uv5,1.0,0.0));
+}
+#endif
+#ifdef UV6
+else if (v_INFONAME_==5.)
+{
+v_VARYINGNAME_UV=vec2(_MATRIXNAME_Matrix*vec4(uv6,1.0,0.0));
+}
+#endif
+#endif
+`;
+e.IncludesShadersStore[_] = N;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/sceneUboDeclaration.esm.js

@@ -0,0 +1,13 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const o = "sceneUboDeclaration", t = `layout(std140,column_major) uniform;
+uniform Scene {
+mat4 viewProjection;
+#ifdef MULTIVIEW
+mat4 viewProjectionR;
+#endif 
+mat4 view;
+mat4 projection;
+vec4 vEyePosition;
+};
+`;
+e.IncludesShadersStore[o] = t;

package/dist/node_modules/@babylonjs/core/Shaders/ShadersInclude/screenSpaceRayTrace.esm.js

@@ -0,0 +1,208 @@
+import { ShaderStore as e } from "../../Engines/shaderStore.esm.js";
+const a = "screenSpaceRayTrace", t = `float distanceSquared(vec2 a,vec2 b) { a-=b; return dot(a,a); }
+/**
+param csOrigin Camera-space ray origin,which must be 
+within the view volume and must have z>0.01 and project within the valid screen rectangle
+param csDirection Unit length camera-space ray direction
+param projectToPixelMatrix A projection matrix that maps to **pixel** coordinates 
+(**not** [-1,+1] normalized device coordinates).
+param csZBuffer The camera-space Z buffer
+param csZBufferSize Dimensions of csZBuffer
+param csZThickness Camera space csZThickness to ascribe to each pixel in the depth buffer
+param nearPlaneZ Positive number. Doesn't have to be THE actual near plane,just a reasonable value
+for clipping rays headed towards the camera
+param stride Step in horizontal or vertical pixels between samples. This is a float
+because integer math is slow on GPUs,but should be set to an integer>=1
+param jitterFraction Number between 0 and 1 for how far to bump the ray in stride units
+to conceal banding artifacts,plus the stride ray offset.
+param maxSteps Maximum number of iterations. Higher gives better images but may be slow
+param maxRayTraceDistance Maximum camera-space distance to trace before returning a miss
+param selfCollisionNumSkip Number of steps to skip at start when raytracing to avoid self collisions.
+1 is a reasonable value,depending on the scene you may need to set this value to 2
+param hitPixel Pixel coordinates of the first intersection with the scene
+param numIterations number of iterations performed
+param csHitPoint Camera space location of the ray hit
+*/
+#define inline
+bool traceScreenSpaceRay1(
+vec3 csOrigin,
+vec3 csDirection,
+mat4 projectToPixelMatrix,
+sampler2D csZBuffer,
+vec2 csZBufferSize,
+#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER
+sampler2D csZBackBuffer,
+float csZBackSizeFactor,
+#endif
+float csZThickness,
+float nearPlaneZ,
+float stride,
+float jitterFraction,
+float maxSteps,
+float maxRayTraceDistance,
+float selfCollisionNumSkip,
+out vec2 startPixel,
+out vec2 hitPixel,
+out vec3 csHitPoint,
+out float numIterations
+#ifdef SSRAYTRACE_DEBUG
+,out vec3 debugColor
+#endif
+)
+{
+#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE
+float rayLength=(csOrigin.z+csDirection.z*maxRayTraceDistance)>-nearPlaneZ ? (-nearPlaneZ-csOrigin.z)/csDirection.z : maxRayTraceDistance;
+#else
+float rayLength=(csOrigin.z+csDirection.z*maxRayTraceDistance)<nearPlaneZ ? (nearPlaneZ-csOrigin.z)/csDirection.z : maxRayTraceDistance;
+#endif
+vec3 csEndPoint=csOrigin+csDirection*rayLength;
+hitPixel=vec2(-1.0,-1.0);
+vec4 H0=projectToPixelMatrix*vec4(csOrigin,1.0);
+vec4 H1=projectToPixelMatrix*vec4(csEndPoint,1.0);
+float k0=1.0/H0.w;
+float k1=1.0/H1.w;
+vec3 Q0=csOrigin*k0;
+vec3 Q1=csEndPoint*k1;
+vec2 P0=H0.xy*k0;
+vec2 P1=H1.xy*k1;
+#ifdef SSRAYTRACE_CLIP_TO_FRUSTUM
+float xMax=csZBufferSize.x-0.5,xMin=0.5,yMax=csZBufferSize.y-0.5,yMin=0.5;
+float alpha=0.0;
+if ((P1.y>yMax) || (P1.y<yMin)) {
+alpha=(P1.y-((P1.y>yMax) ? yMax : yMin))/(P1.y-P0.y);
+}
+if ((P1.x>xMax) || (P1.x<xMin)) {
+alpha=max(alpha,(P1.x-((P1.x>xMax) ? xMax : xMin))/(P1.x-P0.x));
+}
+P1=mix(P1,P0,alpha); k1=mix(k1,k0,alpha); Q1=mix(Q1,Q0,alpha);
+#endif
+P1+=vec2((distanceSquared(P0,P1)<0.0001) ? 0.01 : 0.0);
+vec2 delta=P1-P0;
+bool permute=false;
+if (abs(delta.x)<abs(delta.y)) { 
+permute=true;
+delta=delta.yx;
+P0=P0.yx;
+P1=P1.yx; 
+}
+float stepDirection=sign(delta.x);
+float invdx=stepDirection/delta.x;
+vec2 dP=vec2(stepDirection,delta.y*invdx);
+vec3 dQ=(Q1-Q0)*invdx;
+float dk=(k1-k0)*invdx;
+float zMin=min(csEndPoint.z,csOrigin.z);
+float zMax=max(csEndPoint.z,csOrigin.z);
+dP*=stride; dQ*=stride; dk*=stride;
+P0+=dP*jitterFraction; Q0+=dQ*jitterFraction; k0+=dk*jitterFraction;
+vec4 pqk=vec4(P0,Q0.z,k0);
+vec4 dPQK=vec4(dP,dQ.z,dk);
+startPixel=permute ? P0.yx : P0.xy;
+float prevZMaxEstimate=csOrigin.z;
+float rayZMin=prevZMaxEstimate,rayZMax=prevZMaxEstimate;
+float sceneZMax=rayZMax+1e4;
+float end=P1.x*stepDirection;
+bool hit=false;
+float stepCount;
+for (stepCount=0.0;
+stepCount<=selfCollisionNumSkip ||
+(pqk.x*stepDirection)<=end &&
+stepCount<maxSteps &&
+!hit &&
+sceneZMax != 0.0; 
+pqk+=dPQK,++stepCount)
+{
+hitPixel=permute ? pqk.yx : pqk.xy;
+rayZMin=prevZMaxEstimate;
+rayZMax=(dPQK.z*0.5+pqk.z)/(dPQK.w*0.5+pqk.w);
+rayZMax=clamp(rayZMax,zMin,zMax);
+prevZMaxEstimate=rayZMax;
+if (rayZMin>rayZMax) { 
+float t=rayZMin; rayZMin=rayZMax; rayZMax=t;
+}
+sceneZMax=texelFetch(csZBuffer,ivec2(hitPixel),0).r;
+#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE
+#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER
+float sceneBackZ=texelFetch(csZBackBuffer,ivec2(hitPixel/csZBackSizeFactor),0).r;
+hit=(rayZMax>=sceneBackZ-csZThickness) && (rayZMin<=sceneZMax);
+#else
+hit=(rayZMax>=sceneZMax-csZThickness) && (rayZMin<=sceneZMax);
+#endif
+#else
+#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER
+float sceneBackZ=texelFetch(csZBackBuffer,ivec2(hitPixel/csZBackSizeFactor),0).r;
+hit=(rayZMin<=sceneBackZ+csZThickness) && (rayZMax>=sceneZMax) && (sceneZMax != 0.0);
+#else
+hit=(rayZMin<=sceneZMax+csZThickness) && (rayZMax>=sceneZMax);
+#endif
+#endif
+}
+pqk-=dPQK;
+stepCount-=1.0;
+if (((pqk.x+dPQK.x)*stepDirection)>end || (stepCount+1.0)>=maxSteps || sceneZMax==0.0) {
+hit=false;
+}
+#ifdef SSRAYTRACE_ENABLE_REFINEMENT
+if (stride>1.0 && hit) {
+pqk-=dPQK;
+stepCount-=1.0;
+float invStride=1.0/stride;
+dPQK*=invStride;
+float refinementStepCount=0.0;
+prevZMaxEstimate=pqk.z/pqk.w;
+rayZMax=prevZMaxEstimate;
+sceneZMax=rayZMax+1e7;
+for (;
+refinementStepCount<=1.0 ||
+(refinementStepCount<=stride*1.4) &&
+(rayZMax<sceneZMax) && (sceneZMax != 0.0);
+pqk+=dPQK,refinementStepCount+=1.0)
+{
+rayZMin=prevZMaxEstimate;
+rayZMax=(dPQK.z*0.5+pqk.z)/(dPQK.w*0.5+pqk.w);
+rayZMax=clamp(rayZMax,zMin,zMax);
+prevZMaxEstimate=rayZMax;
+rayZMax=max(rayZMax,rayZMin);
+hitPixel=permute ? pqk.yx : pqk.xy;
+sceneZMax=texelFetch(csZBuffer,ivec2(hitPixel),0).r;
+}
+pqk-=dPQK;
+refinementStepCount-=1.0;
+stepCount+=refinementStepCount/stride;
+}
+#endif
+Q0.xy+=dQ.xy*stepCount;
+Q0.z=pqk.z;
+csHitPoint=Q0/pqk.w;
+numIterations=stepCount+1.0;
+#ifdef SSRAYTRACE_DEBUG
+if (((pqk.x+dPQK.x)*stepDirection)>end) {
+debugColor=vec3(0,0,1);
+} else if ((stepCount+1.0)>=maxSteps) {
+debugColor=vec3(1,0,0);
+} else if (sceneZMax==0.0) {
+debugColor=vec3(1,1,0);
+} else {
+debugColor=vec3(0,stepCount/maxSteps,0);
+}
+#endif
+return hit;
+}
+/**
+texCoord: in the [0,1] range
+depth: depth in view space (range [znear,zfar]])
+*/
+vec3 computeViewPosFromUVDepth(vec2 texCoord,float depth,mat4 projection,mat4 invProjectionMatrix) {
+vec4 ndc;
+ndc.xy=texCoord*2.0-1.0;
+#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE
+ndc.z=-projection[2].z-projection[3].z/depth;
+#else
+ndc.z=projection[2].z+projection[3].z/depth;
+#endif
+ndc.w=1.0;
+vec4 eyePos=invProjectionMatrix*ndc;
+eyePos.xyz/=eyePos.w;
+return eyePos.xyz;
+}
+`;
+e.IncludesShadersStore[a] = t;