@babylonjs/core 6.5.0 → 6.6.0

package/Shaders/ShadersInclude/pbrHelperFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"pbrHelperFunctions.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ShadersInclude/pbrHelperFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiEd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"pbrHelperFunctions\";\nconst shader = `#define RECIPROCAL_PI2 0.15915494\n#define RECIPROCAL_PI 0.31830988618\n#define MINIMUMVARIANCE 0.0005\nfloat convertRoughnessToAverageSlope(float roughness)\r{\rreturn square(roughness)+MINIMUMVARIANCE;\r}\rfloat fresnelGrazingReflectance(float reflectance0) {\rfloat reflectance90=saturate(reflectance0*25.0);\rreturn reflectance90;\r}\rvec2 getAARoughnessFactors(vec3 normalVector) {\r#ifdef SPECULARAA\nvec3 nDfdx=dFdx(normalVector.xyz);\rvec3 nDfdy=dFdy(normalVector.xyz);\rfloat slopeSquare=max(dot(nDfdx,nDfdx),dot(nDfdy,nDfdy));\rfloat geometricRoughnessFactor=pow(saturate(slopeSquare),0.333);\rfloat geometricAlphaGFactor=sqrt(slopeSquare);\rgeometricAlphaGFactor*=0.75;\rreturn vec2(geometricRoughnessFactor,geometricAlphaGFactor);\r#else\nreturn vec2(0.);\r#endif\n}\r#ifdef ANISOTROPIC\nvec2 getAnisotropicRoughness(float alphaG,float anisotropy) {\rfloat alphaT=max(alphaG*(1.0+anisotropy),MINIMUMVARIANCE);\rfloat alphaB=max(alphaG*(1.0-anisotropy),MINIMUMVARIANCE);\rreturn vec2(alphaT,alphaB);\r}\rvec3 getAnisotropicBentNormals(const vec3 T,const vec3 B,const vec3 N,const vec3 V,float anisotropy) {\rvec3 anisotropicFrameDirection=anisotropy>=0.0 ? B : T;\rvec3 anisotropicFrameTangent=cross(normalize(anisotropicFrameDirection),V);\rvec3 anisotropicFrameNormal=cross(anisotropicFrameTangent,anisotropicFrameDirection);\rvec3 anisotropicNormal=normalize(mix(N,anisotropicFrameNormal,abs(anisotropy)));\rreturn anisotropicNormal;\r}\r#endif\n#if defined(CLEARCOAT) || defined(SS_REFRACTION)\nvec3 cocaLambert(vec3 alpha,float distance) {\rreturn exp(-alpha*distance);\r}\rvec3 cocaLambert(float NdotVRefract,float NdotLRefract,vec3 alpha,float thickness) {\rreturn cocaLambert(alpha,(thickness*((NdotLRefract+NdotVRefract)/(NdotLRefract*NdotVRefract))));\r}\rvec3 computeColorAtDistanceInMedia(vec3 color,float distance) {\rreturn -log(color)/distance;\r}\rvec3 computeClearCoatAbsorption(float NdotVRefract,float NdotLRefract,vec3 clearCoatColor,float clearCoatThickness,float clearCoatIntensity) {\rvec3 clearCoatAbsorption=mix(vec3(1.0),\rcocaLambert(NdotVRefract,NdotLRefract,clearCoatColor,clearCoatThickness),\rclearCoatIntensity);\rreturn clearCoatAbsorption;\r}\r#endif\n#ifdef MICROSURFACEAUTOMATIC\nfloat computeDefaultMicroSurface(float microSurface,vec3 reflectivityColor)\r{\rconst float kReflectivityNoAlphaWorkflow_SmoothnessMax=0.95;\rfloat reflectivityLuminance=getLuminance(reflectivityColor);\rfloat reflectivityLuma=sqrt(reflectivityLuminance);\rmicroSurface=reflectivityLuma*kReflectivityNoAlphaWorkflow_SmoothnessMax;\rreturn microSurface;\r}\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const pbrHelperFunctions = { name, shader };\n"]}
+{"version":3,"file":"pbrHelperFunctions.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ShadersInclude/pbrHelperFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"pbrHelperFunctions\";\nconst shader = `#define RECIPROCAL_PI2 0.15915494\n#define RECIPROCAL_PI 0.31830988618\n#define MINIMUMVARIANCE 0.0005\nfloat convertRoughnessToAverageSlope(float roughness)\r{\rreturn square(roughness)+MINIMUMVARIANCE;\r}\rfloat fresnelGrazingReflectance(float reflectance0) {\rfloat reflectance90=saturate(reflectance0*25.0);\rreturn reflectance90;\r}\rvec2 getAARoughnessFactors(vec3 normalVector) {\r#ifdef SPECULARAA\nvec3 nDfdx=dFdx(normalVector.xyz);\rvec3 nDfdy=dFdy(normalVector.xyz);\rfloat slopeSquare=max(dot(nDfdx,nDfdx),dot(nDfdy,nDfdy));\rfloat geometricRoughnessFactor=pow(saturate(slopeSquare),0.333);\rfloat geometricAlphaGFactor=sqrt(slopeSquare);\rgeometricAlphaGFactor*=0.75;\rreturn vec2(geometricRoughnessFactor,geometricAlphaGFactor);\r#else\nreturn vec2(0.);\r#endif\n}\r#ifdef ANISOTROPIC\n#ifdef ANISOTROPIC_LEGACY\nvec2 getAnisotropicRoughness(float alphaG,float anisotropy) {\rfloat alphaT=max(alphaG*(1.0+anisotropy),MINIMUMVARIANCE);\rfloat alphaB=max(alphaG*(1.0-anisotropy),MINIMUMVARIANCE);\rreturn vec2(alphaT,alphaB);\r}\rvec3 getAnisotropicBentNormals(const vec3 T,const vec3 B,const vec3 N,const vec3 V,float anisotropy,float roughness) {\rvec3 anisotropicFrameDirection=anisotropy>=0.0 ? B : T;\rvec3 anisotropicFrameTangent=cross(normalize(anisotropicFrameDirection),V);\rvec3 anisotropicFrameNormal=cross(anisotropicFrameTangent,anisotropicFrameDirection);\rvec3 anisotropicNormal=normalize(mix(N,anisotropicFrameNormal,abs(anisotropy)));\rreturn anisotropicNormal;\r}\r#else\nvec2 getAnisotropicRoughness(float alphaG,float anisotropy) {\rfloat alphaT=max(mix(alphaG,1.0,anisotropy*anisotropy),MINIMUMVARIANCE);\rfloat alphaB=max(alphaG,MINIMUMVARIANCE);\rreturn vec2(alphaT,alphaB);\r}\rvec3 getAnisotropicBentNormals(const vec3 T,const vec3 B,const vec3 N,const vec3 V,float anisotropy,float roughness) {\rvec3 bentNormal=cross(B,V);\rbentNormal=normalize(cross(bentNormal,B));\rfloat a=square(square(1.0-anisotropy*(1.0-roughness)));\rbentNormal=normalize(mix(bentNormal,N,a));\rreturn bentNormal;\r}\r#endif\n#endif\n#if defined(CLEARCOAT) || defined(SS_REFRACTION)\nvec3 cocaLambert(vec3 alpha,float distance) {\rreturn exp(-alpha*distance);\r}\rvec3 cocaLambert(float NdotVRefract,float NdotLRefract,vec3 alpha,float thickness) {\rreturn cocaLambert(alpha,(thickness*((NdotLRefract+NdotVRefract)/(NdotLRefract*NdotVRefract))));\r}\rvec3 computeColorAtDistanceInMedia(vec3 color,float distance) {\rreturn -log(color)/distance;\r}\rvec3 computeClearCoatAbsorption(float NdotVRefract,float NdotLRefract,vec3 clearCoatColor,float clearCoatThickness,float clearCoatIntensity) {\rvec3 clearCoatAbsorption=mix(vec3(1.0),\rcocaLambert(NdotVRefract,NdotLRefract,clearCoatColor,clearCoatThickness),\rclearCoatIntensity);\rreturn clearCoatAbsorption;\r}\r#endif\n#ifdef MICROSURFACEAUTOMATIC\nfloat computeDefaultMicroSurface(float microSurface,vec3 reflectivityColor)\r{\rconst float kReflectivityNoAlphaWorkflow_SmoothnessMax=0.95;\rfloat reflectivityLuminance=getLuminance(reflectivityColor);\rfloat reflectivityLuma=sqrt(reflectivityLuminance);\rmicroSurface=reflectivityLuma*kReflectivityNoAlphaWorkflow_SmoothnessMax;\rreturn microSurface;\r}\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const pbrHelperFunctions = { name, shader };\n"]}

package/Shaders/ShadersInclude/screenSpaceRayTrace.js

@@ -24,7 +24,10 @@ hit=(rayZMin<=sceneZMax+csZThickness) && (rayZMax>=sceneZMax);
 if (stride>1.0 && hit) {
 Q0.xy+=dQ.xy*stepCount;
 if (((pqk.x+dPQK.x)*stepDirection)>end) {
-return hit;
+return hit;
+ndc.z=-projection[2].z-projection[3].z/depth;
+ndc.z=projection[2].z+projection[3].z/depth;
+ndc.w=1.0;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
 /** @internal */

package/Shaders/ShadersInclude/screenSpaceRayTrace.js.map

@@ -1 +1 @@
-{"version":3,"file":"screenSpaceRayTrace.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ShadersInclude/screenSpaceRayTrace.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Ld,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"screenSpaceRayTrace\";\nconst shader = `float distanceSquared(vec2 a,vec2 b) { a-=b; return dot(a,a); }\r/**\r\\param csOrigin Camera-space ray origin,which must be \rwithin the view volume and must have z>0.01 and project within the valid screen rectangle\r\\param csDirection Unit length camera-space ray direction\r\\param projectToPixelMatrix A projection matrix that maps to **pixel** coordinates \r(**not** [-1,+1] normalized device coordinates).\r\\param csZBuffer The camera-space Z buffer\r\\param csZBufferSize Dimensions of csZBuffer\r\\param csZThickness Camera space csZThickness to ascribe to each pixel in the depth buffer\r\\param nearPlaneZ Positive number. Doesn't have to be THE actual near plane,just a reasonable value\rfor clipping rays headed towards the camera\r\\param stride Step in horizontal or vertical pixels between samples. This is a float\rbecause integer math is slow on GPUs,but should be set to an integer>=1\r\\param jitterFraction Number between 0 and 1 for how far to bump the ray in stride units\rto conceal banding artifacts,plus the stride ray offset.\r\\param maxSteps Maximum number of iterations. Higher gives better images but may be slow\r\\param maxRayTraceDistance Maximum camera-space distance to trace before returning a miss\r\\param selfCollisionNumSkip Number of steps to skip at start when raytracing to avoid self collisions.\r1 is a reasonable value,depending on the scene you may need to set this value to 2\r\\param hitPixel Pixel coordinates of the first intersection with the scene\r\\param numIterations number of iterations performed\r\\param csHitPoint Camera space location of the ray hit\r*/\r#define inline\nbool traceScreenSpaceRay1(\rvec3 csOrigin,\rvec3 csDirection,\rmat4 projectToPixelMatrix,\rsampler2D csZBuffer,\rvec2 csZBufferSize,\r#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nsampler2D csZBackBuffer,\rfloat csZBackSizeFactor,\r#endif\nfloat csZThickness,\rfloat nearPlaneZ,\rfloat stride,\rfloat jitterFraction,\rfloat maxSteps,\rfloat maxRayTraceDistance,\rfloat selfCollisionNumSkip,\rout vec2 startPixel,\rout vec2 hitPixel,\rout vec3 csHitPoint,\rout float numIterations\r#ifdef SSRAYTRACE_DEBUG\n,out vec3 debugColor\r#endif\n)\r{\r#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE\nfloat rayLength=(csOrigin.z+csDirection.z*maxRayTraceDistance)>-nearPlaneZ ? (-nearPlaneZ-csOrigin.z)/csDirection.z : maxRayTraceDistance;\r#else\nfloat rayLength=(csOrigin.z+csDirection.z*maxRayTraceDistance)<nearPlaneZ ? (nearPlaneZ-csOrigin.z)/csDirection.z : maxRayTraceDistance;\r#endif\nvec3 csEndPoint=csOrigin+csDirection*rayLength;\rhitPixel=vec2(-1.0,-1.0);\rvec4 H0=projectToPixelMatrix*vec4(csOrigin,1.0);\rvec4 H1=projectToPixelMatrix*vec4(csEndPoint,1.0);\rfloat k0=1.0/H0.w;\rfloat k1=1.0/H1.w;\rvec3 Q0=csOrigin*k0;\rvec3 Q1=csEndPoint*k1;\rvec2 P0=H0.xy*k0;\rvec2 P1=H1.xy*k1;\r#ifdef SSRAYTRACE_CLIP_TO_FRUSTUM\nfloat xMax=csZBufferSize.x-0.5,xMin=0.5,yMax=csZBufferSize.y-0.5,yMin=0.5;\rfloat alpha=0.0;\rif ((P1.y>yMax) || (P1.y<yMin)) {\ralpha=(P1.y-((P1.y>yMax) ? yMax : yMin))/(P1.y-P0.y);\r}\rif ((P1.x>xMax) || (P1.x<xMin)) {\ralpha=max(alpha,(P1.x-((P1.x>xMax) ? xMax : xMin))/(P1.x-P0.x));\r}\rP1=mix(P1,P0,alpha); k1=mix(k1,k0,alpha); Q1=mix(Q1,Q0,alpha);\r#endif\nP1+=vec2((distanceSquared(P0,P1)<0.0001) ? 0.01 : 0.0);\rvec2 delta=P1-P0;\rbool permute=false;\rif (abs(delta.x)<abs(delta.y)) { \rpermute=true;\rdelta=delta.yx;\rP0=P0.yx;\rP1=P1.yx; \r}\rfloat stepDirection=sign(delta.x);\rfloat invdx=stepDirection/delta.x;\rvec2 dP=vec2(stepDirection,delta.y*invdx);\rvec3 dQ=(Q1-Q0)*invdx;\rfloat dk=(k1-k0)*invdx;\rfloat zMin=min(csEndPoint.z,csOrigin.z);\rfloat zMax=max(csEndPoint.z,csOrigin.z);\rdP*=stride; dQ*=stride; dk*=stride;\rP0+=dP*jitterFraction; Q0+=dQ*jitterFraction; k0+=dk*jitterFraction;\rvec4 pqk=vec4(P0,Q0.z,k0);\rvec4 dPQK=vec4(dP,dQ.z,dk);\rstartPixel=permute ? P0.yx : P0.xy;\rfloat prevZMaxEstimate=csOrigin.z;\rfloat rayZMin=prevZMaxEstimate,rayZMax=prevZMaxEstimate;\rfloat sceneZMax=rayZMax+1e4;\rfloat end=P1.x*stepDirection;\rbool hit=false;\rfloat stepCount;\rfor (stepCount=0.0;\rstepCount<=selfCollisionNumSkip ||\r(pqk.x*stepDirection)<=end &&\rstepCount<maxSteps &&\r!hit &&\rsceneZMax != 0.0; \rpqk+=dPQK,++stepCount)\r{\rhitPixel=permute ? pqk.yx : pqk.xy;\rrayZMin=prevZMaxEstimate;\rrayZMax=(dPQK.z*0.5+pqk.z)/(dPQK.w*0.5+pqk.w);\rrayZMax=clamp(rayZMax,zMin,zMax);\rprevZMaxEstimate=rayZMax;\rif (rayZMin>rayZMax) { \rfloat t=rayZMin; rayZMin=rayZMax; rayZMax=t;\r}\rsceneZMax=texelFetch(csZBuffer,ivec2(hitPixel),0).r;\r#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE\n#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nfloat sceneBackZ=texelFetch(csZBackBuffer,ivec2(hitPixel/csZBackSizeFactor),0).r;\rhit=(rayZMax>=sceneBackZ-csZThickness) && (rayZMin<=sceneZMax);\r#else\nhit=(rayZMax>=sceneZMax-csZThickness) && (rayZMin<=sceneZMax);\r#endif\n#else\n#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nfloat sceneBackZ=texelFetch(csZBackBuffer,ivec2(hitPixel/csZBackSizeFactor),0).r;\rhit=(rayZMin<=sceneBackZ+csZThickness) && (rayZMax>=sceneZMax) && (sceneZMax != 0.0);\r#else\nhit=(rayZMin<=sceneZMax+csZThickness) && (rayZMax>=sceneZMax);\r#endif\n#endif\n}\rpqk-=dPQK;\rstepCount-=1.0;\rif (((pqk.x+dPQK.x)*stepDirection)>end || (stepCount+1.0)>=maxSteps || sceneZMax==0.0) {\rhit=false;\r}\r#ifdef SSRAYTRACE_ENABLE_REFINEMENT\nif (stride>1.0 && hit) {\rpqk-=dPQK;\rstepCount-=1.0;\rfloat invStride=1.0/stride;\rdPQK*=invStride;\rfloat refinementStepCount=0.0;\rprevZMaxEstimate=pqk.z/pqk.w;\rrayZMax=prevZMaxEstimate;\rsceneZMax=rayZMax+1e7;\rfor (;\rrefinementStepCount<=1.0 ||\r(refinementStepCount<=stride*1.4) &&\r(rayZMax<sceneZMax) && (sceneZMax != 0.0);\rpqk+=dPQK,refinementStepCount+=1.0)\r{\rrayZMin=prevZMaxEstimate;\rrayZMax=(dPQK.z*0.5+pqk.z)/(dPQK.w*0.5+pqk.w);\rrayZMax=clamp(rayZMax,zMin,zMax);\rprevZMaxEstimate=rayZMax;\rrayZMax=max(rayZMax,rayZMin);\rhitPixel=permute ? pqk.yx : pqk.xy;\rsceneZMax=texelFetch(csZBuffer,ivec2(hitPixel),0).r;\r}\rpqk-=dPQK;\rrefinementStepCount-=1.0;\rstepCount+=refinementStepCount/stride;\r}\r#endif\nQ0.xy+=dQ.xy*stepCount;\rQ0.z=pqk.z;\rcsHitPoint=Q0/pqk.w;\rnumIterations=stepCount+1.0;\r#ifdef SSRAYTRACE_DEBUG\nif (((pqk.x+dPQK.x)*stepDirection)>end) {\rdebugColor=vec3(0,0,1);\r} else if ((stepCount+1.0)>=maxSteps) {\rdebugColor=vec3(1,0,0);\r} else if (sceneZMax==0.0) {\rdebugColor=vec3(1,1,0);\r} else {\rdebugColor=vec3(0,stepCount/maxSteps,0);\r}\r#endif\nreturn hit;\r}\r`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const screenSpaceRayTrace = { name, shader };\n"]}
+{"version":3,"file":"screenSpaceRayTrace.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ShadersInclude/screenSpaceRayTrace.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Md,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"screenSpaceRayTrace\";\nconst shader = `float distanceSquared(vec2 a,vec2 b) { a-=b; return dot(a,a); }\r/**\r\\param csOrigin Camera-space ray origin,which must be \rwithin the view volume and must have z>0.01 and project within the valid screen rectangle\r\\param csDirection Unit length camera-space ray direction\r\\param projectToPixelMatrix A projection matrix that maps to **pixel** coordinates \r(**not** [-1,+1] normalized device coordinates).\r\\param csZBuffer The camera-space Z buffer\r\\param csZBufferSize Dimensions of csZBuffer\r\\param csZThickness Camera space csZThickness to ascribe to each pixel in the depth buffer\r\\param nearPlaneZ Positive number. Doesn't have to be THE actual near plane,just a reasonable value\rfor clipping rays headed towards the camera\r\\param stride Step in horizontal or vertical pixels between samples. This is a float\rbecause integer math is slow on GPUs,but should be set to an integer>=1\r\\param jitterFraction Number between 0 and 1 for how far to bump the ray in stride units\rto conceal banding artifacts,plus the stride ray offset.\r\\param maxSteps Maximum number of iterations. Higher gives better images but may be slow\r\\param maxRayTraceDistance Maximum camera-space distance to trace before returning a miss\r\\param selfCollisionNumSkip Number of steps to skip at start when raytracing to avoid self collisions.\r1 is a reasonable value,depending on the scene you may need to set this value to 2\r\\param hitPixel Pixel coordinates of the first intersection with the scene\r\\param numIterations number of iterations performed\r\\param csHitPoint Camera space location of the ray hit\r*/\r#define inline\nbool traceScreenSpaceRay1(\rvec3 csOrigin,\rvec3 csDirection,\rmat4 projectToPixelMatrix,\rsampler2D csZBuffer,\rvec2 csZBufferSize,\r#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nsampler2D csZBackBuffer,\rfloat csZBackSizeFactor,\r#endif\nfloat csZThickness,\rfloat nearPlaneZ,\rfloat stride,\rfloat jitterFraction,\rfloat maxSteps,\rfloat maxRayTraceDistance,\rfloat selfCollisionNumSkip,\rout vec2 startPixel,\rout vec2 hitPixel,\rout vec3 csHitPoint,\rout float numIterations\r#ifdef SSRAYTRACE_DEBUG\n,out vec3 debugColor\r#endif\n)\r{\r#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE\nfloat rayLength=(csOrigin.z+csDirection.z*maxRayTraceDistance)>-nearPlaneZ ? (-nearPlaneZ-csOrigin.z)/csDirection.z : maxRayTraceDistance;\r#else\nfloat rayLength=(csOrigin.z+csDirection.z*maxRayTraceDistance)<nearPlaneZ ? (nearPlaneZ-csOrigin.z)/csDirection.z : maxRayTraceDistance;\r#endif\nvec3 csEndPoint=csOrigin+csDirection*rayLength;\rhitPixel=vec2(-1.0,-1.0);\rvec4 H0=projectToPixelMatrix*vec4(csOrigin,1.0);\rvec4 H1=projectToPixelMatrix*vec4(csEndPoint,1.0);\rfloat k0=1.0/H0.w;\rfloat k1=1.0/H1.w;\rvec3 Q0=csOrigin*k0;\rvec3 Q1=csEndPoint*k1;\rvec2 P0=H0.xy*k0;\rvec2 P1=H1.xy*k1;\r#ifdef SSRAYTRACE_CLIP_TO_FRUSTUM\nfloat xMax=csZBufferSize.x-0.5,xMin=0.5,yMax=csZBufferSize.y-0.5,yMin=0.5;\rfloat alpha=0.0;\rif ((P1.y>yMax) || (P1.y<yMin)) {\ralpha=(P1.y-((P1.y>yMax) ? yMax : yMin))/(P1.y-P0.y);\r}\rif ((P1.x>xMax) || (P1.x<xMin)) {\ralpha=max(alpha,(P1.x-((P1.x>xMax) ? xMax : xMin))/(P1.x-P0.x));\r}\rP1=mix(P1,P0,alpha); k1=mix(k1,k0,alpha); Q1=mix(Q1,Q0,alpha);\r#endif\nP1+=vec2((distanceSquared(P0,P1)<0.0001) ? 0.01 : 0.0);\rvec2 delta=P1-P0;\rbool permute=false;\rif (abs(delta.x)<abs(delta.y)) { \rpermute=true;\rdelta=delta.yx;\rP0=P0.yx;\rP1=P1.yx; \r}\rfloat stepDirection=sign(delta.x);\rfloat invdx=stepDirection/delta.x;\rvec2 dP=vec2(stepDirection,delta.y*invdx);\rvec3 dQ=(Q1-Q0)*invdx;\rfloat dk=(k1-k0)*invdx;\rfloat zMin=min(csEndPoint.z,csOrigin.z);\rfloat zMax=max(csEndPoint.z,csOrigin.z);\rdP*=stride; dQ*=stride; dk*=stride;\rP0+=dP*jitterFraction; Q0+=dQ*jitterFraction; k0+=dk*jitterFraction;\rvec4 pqk=vec4(P0,Q0.z,k0);\rvec4 dPQK=vec4(dP,dQ.z,dk);\rstartPixel=permute ? P0.yx : P0.xy;\rfloat prevZMaxEstimate=csOrigin.z;\rfloat rayZMin=prevZMaxEstimate,rayZMax=prevZMaxEstimate;\rfloat sceneZMax=rayZMax+1e4;\rfloat end=P1.x*stepDirection;\rbool hit=false;\rfloat stepCount;\rfor (stepCount=0.0;\rstepCount<=selfCollisionNumSkip ||\r(pqk.x*stepDirection)<=end &&\rstepCount<maxSteps &&\r!hit &&\rsceneZMax != 0.0; \rpqk+=dPQK,++stepCount)\r{\rhitPixel=permute ? pqk.yx : pqk.xy;\rrayZMin=prevZMaxEstimate;\rrayZMax=(dPQK.z*0.5+pqk.z)/(dPQK.w*0.5+pqk.w);\rrayZMax=clamp(rayZMax,zMin,zMax);\rprevZMaxEstimate=rayZMax;\rif (rayZMin>rayZMax) { \rfloat t=rayZMin; rayZMin=rayZMax; rayZMax=t;\r}\rsceneZMax=texelFetch(csZBuffer,ivec2(hitPixel),0).r;\r#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE\n#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nfloat sceneBackZ=texelFetch(csZBackBuffer,ivec2(hitPixel/csZBackSizeFactor),0).r;\rhit=(rayZMax>=sceneBackZ-csZThickness) && (rayZMin<=sceneZMax);\r#else\nhit=(rayZMax>=sceneZMax-csZThickness) && (rayZMin<=sceneZMax);\r#endif\n#else\n#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nfloat sceneBackZ=texelFetch(csZBackBuffer,ivec2(hitPixel/csZBackSizeFactor),0).r;\rhit=(rayZMin<=sceneBackZ+csZThickness) && (rayZMax>=sceneZMax) && (sceneZMax != 0.0);\r#else\nhit=(rayZMin<=sceneZMax+csZThickness) && (rayZMax>=sceneZMax);\r#endif\n#endif\n}\rpqk-=dPQK;\rstepCount-=1.0;\rif (((pqk.x+dPQK.x)*stepDirection)>end || (stepCount+1.0)>=maxSteps || sceneZMax==0.0) {\rhit=false;\r}\r#ifdef SSRAYTRACE_ENABLE_REFINEMENT\nif (stride>1.0 && hit) {\rpqk-=dPQK;\rstepCount-=1.0;\rfloat invStride=1.0/stride;\rdPQK*=invStride;\rfloat refinementStepCount=0.0;\rprevZMaxEstimate=pqk.z/pqk.w;\rrayZMax=prevZMaxEstimate;\rsceneZMax=rayZMax+1e7;\rfor (;\rrefinementStepCount<=1.0 ||\r(refinementStepCount<=stride*1.4) &&\r(rayZMax<sceneZMax) && (sceneZMax != 0.0);\rpqk+=dPQK,refinementStepCount+=1.0)\r{\rrayZMin=prevZMaxEstimate;\rrayZMax=(dPQK.z*0.5+pqk.z)/(dPQK.w*0.5+pqk.w);\rrayZMax=clamp(rayZMax,zMin,zMax);\rprevZMaxEstimate=rayZMax;\rrayZMax=max(rayZMax,rayZMin);\rhitPixel=permute ? pqk.yx : pqk.xy;\rsceneZMax=texelFetch(csZBuffer,ivec2(hitPixel),0).r;\r}\rpqk-=dPQK;\rrefinementStepCount-=1.0;\rstepCount+=refinementStepCount/stride;\r}\r#endif\nQ0.xy+=dQ.xy*stepCount;\rQ0.z=pqk.z;\rcsHitPoint=Q0/pqk.w;\rnumIterations=stepCount+1.0;\r#ifdef SSRAYTRACE_DEBUG\nif (((pqk.x+dPQK.x)*stepDirection)>end) {\rdebugColor=vec3(0,0,1);\r} else if ((stepCount+1.0)>=maxSteps) {\rdebugColor=vec3(1,0,0);\r} else if (sceneZMax==0.0) {\rdebugColor=vec3(1,1,0);\r} else {\rdebugColor=vec3(0,stepCount/maxSteps,0);\r}\r#endif\nreturn hit;\r}\r/**\rtexCoord: in the [0,1] range\rdepth: depth in view space (range [znear,zfar]])\r*/\rvec3 computeViewPosFromUVDepth(vec2 texCoord,float depth,mat4 projection,mat4 invProjectionMatrix) {\rvec4 ndc;\rndc.xy=texCoord*2.0-1.0;\r#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE\nndc.z=-projection[2].z-projection[3].z/depth;\r#else\nndc.z=projection[2].z+projection[3].z/depth;\r#endif\nndc.w=1.0;\rvec4 eyePos=invProjectionMatrix*ndc;\reyePos.xyz/=eyePos.w;\rreturn eyePos.xyz;\r}\r`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const screenSpaceRayTrace = { name, shader };\n"]}

package/Shaders/glowMapGeneration.fragment.js

@@ -39,7 +39,7 @@ if (finalColor.a<ALPHATESTVALUE)
 vec4 emissive=texture2D(emissiveSampler,vUVEmissive);
 emissive=toGammaSpace(emissive);
 gl_FragColor=emissive*finalColor*glowIntensity;
-gl_FragColor=finalColor;
+gl_FragColor=finalColor*glowIntensity;
 #ifdef HIGHLIGHT
 gl_FragColor.a=glowColor.a;
 }`;

package/Shaders/glowMapGeneration.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"glowMapGeneration.fragment.js","sourceRoot":"","sources":["../../../../lts/core/generated/Shaders/glowMapGeneration.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,+CAA+C,CAAC;AACvD,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,8BAA8B,CAAC;AAC5C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmEb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\n\nconst name = \"glowMapGenerationPixelShader\";\nconst shader = `#if defined(DIFFUSE_ISLINEAR) || defined(EMISSIVE_ISLINEAR)\n#include<helperFunctions>\n#endif\n#ifdef DIFFUSE\nvarying vec2 vUVDiffuse;\runiform sampler2D diffuseSampler;\r#endif\n#ifdef OPACITY\nvarying vec2 vUVOpacity;\runiform sampler2D opacitySampler;\runiform float opacityIntensity;\r#endif\n#ifdef EMISSIVE\nvarying vec2 vUVEmissive;\runiform sampler2D emissiveSampler;\r#endif\n#ifdef VERTEXALPHA\nvarying vec4 vColor;\r#endif\nuniform vec4 glowColor;\runiform float glowIntensity;\r#include<clipPlaneFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\r#include<clipPlaneFragment>\nvec4 finalColor=glowColor;\r#ifdef DIFFUSE\nvec4 albedoTexture=texture2D(diffuseSampler,vUVDiffuse);\r#ifdef DIFFUSE_ISLINEAR\nalbedoTexture=toGammaSpace(albedoTexture);\r#endif\n#ifdef GLOW\nfinalColor.a*=albedoTexture.a;\r#endif\n#ifdef HIGHLIGHT\nfinalColor.a=albedoTexture.a;\r#endif\n#endif\n#ifdef OPACITY\nvec4 opacityMap=texture2D(opacitySampler,vUVOpacity);\r#ifdef OPACITYRGB\nfinalColor.a*=getLuminance(opacityMap.rgb);\r#else\nfinalColor.a*=opacityMap.a;\r#endif\nfinalColor.a*=opacityIntensity;\r#endif\n#ifdef VERTEXALPHA\nfinalColor.a*=vColor.a;\r#endif\n#ifdef ALPHATEST\nif (finalColor.a<ALPHATESTVALUE)\rdiscard;\r#endif\n#ifdef EMISSIVE\nvec4 emissive=texture2D(emissiveSampler,vUVEmissive);\r#ifdef EMISSIVE_ISLINEAR\nemissive=toGammaSpace(emissive);\r#endif\ngl_FragColor=emissive*finalColor*glowIntensity;\r#else\ngl_FragColor=finalColor;\r#endif\n#ifdef HIGHLIGHT\ngl_FragColor.a=glowColor.a;\r#endif\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const glowMapGenerationPixelShader = { name, shader };\n"]}
+{"version":3,"file":"glowMapGeneration.fragment.js","sourceRoot":"","sources":["../../../../lts/core/generated/Shaders/glowMapGeneration.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,+CAA+C,CAAC;AACvD,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,8BAA8B,CAAC;AAC5C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmEb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\n\nconst name = \"glowMapGenerationPixelShader\";\nconst shader = `#if defined(DIFFUSE_ISLINEAR) || defined(EMISSIVE_ISLINEAR)\n#include<helperFunctions>\n#endif\n#ifdef DIFFUSE\nvarying vec2 vUVDiffuse;\runiform sampler2D diffuseSampler;\r#endif\n#ifdef OPACITY\nvarying vec2 vUVOpacity;\runiform sampler2D opacitySampler;\runiform float opacityIntensity;\r#endif\n#ifdef EMISSIVE\nvarying vec2 vUVEmissive;\runiform sampler2D emissiveSampler;\r#endif\n#ifdef VERTEXALPHA\nvarying vec4 vColor;\r#endif\nuniform vec4 glowColor;\runiform float glowIntensity;\r#include<clipPlaneFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\r#include<clipPlaneFragment>\nvec4 finalColor=glowColor;\r#ifdef DIFFUSE\nvec4 albedoTexture=texture2D(diffuseSampler,vUVDiffuse);\r#ifdef DIFFUSE_ISLINEAR\nalbedoTexture=toGammaSpace(albedoTexture);\r#endif\n#ifdef GLOW\nfinalColor.a*=albedoTexture.a;\r#endif\n#ifdef HIGHLIGHT\nfinalColor.a=albedoTexture.a;\r#endif\n#endif\n#ifdef OPACITY\nvec4 opacityMap=texture2D(opacitySampler,vUVOpacity);\r#ifdef OPACITYRGB\nfinalColor.a*=getLuminance(opacityMap.rgb);\r#else\nfinalColor.a*=opacityMap.a;\r#endif\nfinalColor.a*=opacityIntensity;\r#endif\n#ifdef VERTEXALPHA\nfinalColor.a*=vColor.a;\r#endif\n#ifdef ALPHATEST\nif (finalColor.a<ALPHATESTVALUE)\rdiscard;\r#endif\n#ifdef EMISSIVE\nvec4 emissive=texture2D(emissiveSampler,vUVEmissive);\r#ifdef EMISSIVE_ISLINEAR\nemissive=toGammaSpace(emissive);\r#endif\ngl_FragColor=emissive*finalColor*glowIntensity;\r#else\ngl_FragColor=finalColor*glowIntensity;\r#endif\n#ifdef HIGHLIGHT\ngl_FragColor.a=glowColor.a;\r#endif\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const glowMapGenerationPixelShader = { name, shader };\n"]}

package/Shaders/pbr.fragment.js

@@ -181,7 +181,7 @@ alphaFresnelOutParams alphaFresnelOut;
 #ifdef ANISOTROPIC
 anisotropicOutParams anisotropicOut;
 vec3 anisotropyMapData=texture2D(anisotropySampler,vAnisotropyUV+uvOffset).rgb*vAnisotropyInfos.y;
-anisotropicBlock(
+anisotropicBlock(
 anisotropyMapData,
 TBN,
 #ifdef REFLECTION

package/Shaders/pbr.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"pbr.fragment.js","sourceRoot":"","sources":["../../../../lts/core/generated/Shaders/pbr.fragment.ts"],"names":[],"mappings":"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","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/prePassDeclaration\";\nimport \"./ShadersInclude/oitDeclaration\";\nimport \"./ShadersInclude/pbrFragmentDeclaration\";\nimport \"./ShadersInclude/pbrUboDeclaration\";\nimport \"./ShadersInclude/pbrFragmentExtraDeclaration\";\nimport \"./ShadersInclude/lightFragmentDeclaration\";\nimport \"./ShadersInclude/lightUboDeclaration\";\nimport \"./ShadersInclude/pbrFragmentSamplersDeclaration\";\nimport \"./ShadersInclude/imageProcessingDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/logDepthDeclaration\";\nimport \"./ShadersInclude/fogFragmentDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/subSurfaceScatteringFunctions\";\nimport \"./ShadersInclude/importanceSampling\";\nimport \"./ShadersInclude/pbrHelperFunctions\";\nimport \"./ShadersInclude/imageProcessingFunctions\";\nimport \"./ShadersInclude/shadowsFragmentFunctions\";\nimport \"./ShadersInclude/harmonicsFunctions\";\nimport \"./ShadersInclude/pbrDirectLightingSetupFunctions\";\nimport \"./ShadersInclude/pbrDirectLightingFalloffFunctions\";\nimport \"./ShadersInclude/pbrBRDFFunctions\";\nimport \"./ShadersInclude/hdrFilteringFunctions\";\nimport \"./ShadersInclude/pbrDirectLightingFunctions\";\nimport \"./ShadersInclude/pbrIBLFunctions\";\nimport \"./ShadersInclude/bumpFragmentMainFunctions\";\nimport \"./ShadersInclude/bumpFragmentFunctions\";\nimport \"./ShadersInclude/reflectionFunction\";\nimport \"./ShadersInclude/pbrBlockAlbedoOpacity\";\nimport \"./ShadersInclude/pbrBlockReflectivity\";\nimport \"./ShadersInclude/pbrBlockAmbientOcclusion\";\nimport \"./ShadersInclude/pbrBlockAlphaFresnel\";\nimport \"./ShadersInclude/pbrBlockAnisotropic\";\nimport \"./ShadersInclude/pbrBlockReflection\";\nimport \"./ShadersInclude/pbrBlockSheen\";\nimport \"./ShadersInclude/pbrBlockClearcoat\";\nimport \"./ShadersInclude/pbrBlockIridescence\";\nimport \"./ShadersInclude/pbrBlockSubSurface\";\nimport \"./ShadersInclude/clipPlaneFragment\";\nimport \"./ShadersInclude/pbrBlockNormalGeometric\";\nimport \"./ShadersInclude/bumpFragment\";\nimport \"./ShadersInclude/pbrBlockNormalFinal\";\nimport \"./ShadersInclude/depthPrePass\";\nimport \"./ShadersInclude/pbrBlockLightmapInit\";\nimport \"./ShadersInclude/pbrBlockGeometryInfo\";\nimport \"./ShadersInclude/pbrBlockReflectance0\";\nimport \"./ShadersInclude/pbrBlockReflectance\";\nimport \"./ShadersInclude/pbrBlockDirectLighting\";\nimport \"./ShadersInclude/lightFragment\";\nimport \"./ShadersInclude/pbrBlockFinalLitComponents\";\nimport \"./ShadersInclude/pbrBlockFinalUnlitComponents\";\nimport \"./ShadersInclude/pbrBlockFinalColorComposition\";\nimport \"./ShadersInclude/logDepthFragment\";\nimport \"./ShadersInclude/fogFragment\";\nimport \"./ShadersInclude/pbrBlockImageProcessing\";\nimport \"./ShadersInclude/oitFragment\";\nimport \"./ShadersInclude/pbrDebug\";\n\nconst name = \"pbrPixelShader\";\nconst shader = `#if defined(BUMP) || !defined(NORMAL) || defined(FORCENORMALFORWARD) || defined(SPECULARAA) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)\n#extension GL_OES_standard_derivatives : enable\n#endif\n#ifdef LODBASEDMICROSFURACE\n#extension GL_EXT_shader_texture_lod : enable\n#endif\n#define CUSTOM_FRAGMENT_BEGIN\n#ifdef LOGARITHMICDEPTH\n#extension GL_EXT_frag_depth : enable\n#endif\n#include<prePassDeclaration>[SCENE_MRT_COUNT]\nprecision highp float;\r#include<oitDeclaration>\n#ifndef FROMLINEARSPACE\n#define FROMLINEARSPACE\n#endif\n#include<__decl__pbrFragment>\n#include<pbrFragmentExtraDeclaration>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#include<pbrFragmentSamplersDeclaration>\n#include<imageProcessingDeclaration>\n#include<clipPlaneFragmentDeclaration>\n#include<logDepthDeclaration>\n#include<fogFragmentDeclaration>\n#include<helperFunctions>\n#include<subSurfaceScatteringFunctions>\n#include<importanceSampling>\n#include<pbrHelperFunctions>\n#include<imageProcessingFunctions>\n#include<shadowsFragmentFunctions>\n#include<harmonicsFunctions>\n#include<pbrDirectLightingSetupFunctions>\n#include<pbrDirectLightingFalloffFunctions>\n#include<pbrBRDFFunctions>\n#include<hdrFilteringFunctions>\n#include<pbrDirectLightingFunctions>\n#include<pbrIBLFunctions>\n#include<bumpFragmentMainFunctions>\n#include<bumpFragmentFunctions>\n#ifdef REFLECTION\n#include<reflectionFunction>\n#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\n#include<pbrBlockAlbedoOpacity>\n#include<pbrBlockReflectivity>\n#include<pbrBlockAmbientOcclusion>\n#include<pbrBlockAlphaFresnel>\n#include<pbrBlockAnisotropic>\n#include<pbrBlockReflection>\n#include<pbrBlockSheen>\n#include<pbrBlockClearcoat>\n#include<pbrBlockIridescence>\n#include<pbrBlockSubSurface>\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\n#include<pbrBlockNormalGeometric>\n#include<bumpFragment>\n#include<pbrBlockNormalFinal>\nalbedoOpacityOutParams albedoOpacityOut;\r#ifdef ALBEDO\nvec4 albedoTexture=texture2D(albedoSampler,vAlbedoUV+uvOffset);\r#endif\n#ifdef OPACITY\nvec4 opacityMap=texture2D(opacitySampler,vOpacityUV+uvOffset);\r#endif\n#ifdef DECAL\nvec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);\r#endif\nalbedoOpacityBlock(\rvAlbedoColor,\r#ifdef ALBEDO\nalbedoTexture,\rvAlbedoInfos,\r#endif\n#ifdef OPACITY\nopacityMap,\rvOpacityInfos,\r#endif\n#ifdef DETAIL\ndetailColor,\rvDetailInfos,\r#endif\n#ifdef DECAL\ndecalColor,\rvDecalInfos,\r#endif\nalbedoOpacityOut\r);\rvec3 surfaceAlbedo=albedoOpacityOut.surfaceAlbedo;\rfloat alpha=albedoOpacityOut.alpha;\r#define CUSTOM_FRAGMENT_UPDATE_ALPHA\n#include<depthPrePass>\n#define CUSTOM_FRAGMENT_BEFORE_LIGHTS\nambientOcclusionOutParams aoOut;\r#ifdef AMBIENT\nvec3 ambientOcclusionColorMap=texture2D(ambientSampler,vAmbientUV+uvOffset).rgb;\r#endif\nambientOcclusionBlock(\r#ifdef AMBIENT\nambientOcclusionColorMap,\rvAmbientInfos,\r#endif\naoOut\r);\r#include<pbrBlockLightmapInit>\n#ifdef UNLIT\nvec3 diffuseBase=vec3(1.,1.,1.);\r#else\nvec3 baseColor=surfaceAlbedo;\rreflectivityOutParams reflectivityOut;\r#if defined(REFLECTIVITY)\nvec4 surfaceMetallicOrReflectivityColorMap=texture2D(reflectivitySampler,vReflectivityUV+uvOffset);\rvec4 baseReflectivity=surfaceMetallicOrReflectivityColorMap;\r#ifndef METALLICWORKFLOW\n#ifdef REFLECTIVITY_GAMMA\nsurfaceMetallicOrReflectivityColorMap=toLinearSpace(surfaceMetallicOrReflectivityColorMap);\r#endif\nsurfaceMetallicOrReflectivityColorMap.rgb*=vReflectivityInfos.y;\r#endif\n#endif\n#if defined(MICROSURFACEMAP)\nvec4 microSurfaceTexel=texture2D(microSurfaceSampler,vMicroSurfaceSamplerUV+uvOffset)*vMicroSurfaceSamplerInfos.y;\r#endif\n#ifdef METALLICWORKFLOW\nvec4 metallicReflectanceFactors=vMetallicReflectanceFactors;\r#ifdef REFLECTANCE\nvec4 reflectanceFactorsMap=texture2D(reflectanceSampler,vReflectanceUV+uvOffset);\r#ifdef REFLECTANCE_GAMMA\nreflectanceFactorsMap=toLinearSpace(reflectanceFactorsMap);\r#endif\nmetallicReflectanceFactors.rgb*=reflectanceFactorsMap.rgb;\r#endif\n#ifdef METALLIC_REFLECTANCE\nvec4 metallicReflectanceFactorsMap=texture2D(metallicReflectanceSampler,vMetallicReflectanceUV+uvOffset);\r#ifdef METALLIC_REFLECTANCE_GAMMA\nmetallicReflectanceFactorsMap=toLinearSpace(metallicReflectanceFactorsMap);\r#endif\n#ifndef METALLIC_REFLECTANCE_USE_ALPHA_ONLY\nmetallicReflectanceFactors.rgb*=metallicReflectanceFactorsMap.rgb;\r#endif\nmetallicReflectanceFactors*=metallicReflectanceFactorsMap.a;\r#endif\n#endif\nreflectivityBlock(\rvReflectivityColor,\r#ifdef METALLICWORKFLOW\nsurfaceAlbedo,\rmetallicReflectanceFactors,\r#endif\n#ifdef REFLECTIVITY\nvReflectivityInfos,\rsurfaceMetallicOrReflectivityColorMap,\r#endif\n#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)\naoOut.ambientOcclusionColor,\r#endif\n#ifdef MICROSURFACEMAP\nmicroSurfaceTexel,\r#endif\n#ifdef DETAIL\ndetailColor,\rvDetailInfos,\r#endif\nreflectivityOut\r);\rfloat microSurface=reflectivityOut.microSurface;\rfloat roughness=reflectivityOut.roughness;\r#ifdef METALLICWORKFLOW\nsurfaceAlbedo=reflectivityOut.surfaceAlbedo;\r#endif\n#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)\naoOut.ambientOcclusionColor=reflectivityOut.ambientOcclusionColor;\r#endif\n#ifdef ALPHAFRESNEL\n#if defined(ALPHATEST) || defined(ALPHABLEND)\nalphaFresnelOutParams alphaFresnelOut;\ralphaFresnelBlock(\rnormalW,\rviewDirectionW,\ralpha,\rmicroSurface,\ralphaFresnelOut\r);\ralpha=alphaFresnelOut.alpha;\r#endif\n#endif\n#include<pbrBlockGeometryInfo>\n#ifdef ANISOTROPIC\nanisotropicOutParams anisotropicOut;\r#ifdef ANISOTROPIC_TEXTURE\nvec3 anisotropyMapData=texture2D(anisotropySampler,vAnisotropyUV+uvOffset).rgb*vAnisotropyInfos.y;\r#endif\nanisotropicBlock(\rvAnisotropy,\r#ifdef ANISOTROPIC_TEXTURE\nanisotropyMapData,\r#endif\nTBN,\rnormalW,\rviewDirectionW,\ranisotropicOut\r);\r#endif\n#ifdef REFLECTION\nreflectionOutParams reflectionOut;\r#ifndef USE_CUSTOM_REFLECTION\nreflectionBlock(\rvPositionW,\rnormalW,\ralphaG,\rvReflectionMicrosurfaceInfos,\rvReflectionInfos,\rvReflectionColor,\r#ifdef ANISOTROPIC\nanisotropicOut,\r#endif\n#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)\nNdotVUnclamped,\r#endif\n#ifdef LINEARSPECULARREFLECTION\nroughness,\r#endif\nreflectionSampler,\r#if defined(NORMAL) && defined(USESPHERICALINVERTEX)\nvEnvironmentIrradiance,\r#endif\n#ifdef USESPHERICALFROMREFLECTIONMAP\n#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)\nreflectionMatrix,\r#endif\n#endif\n#ifdef USEIRRADIANCEMAP\nirradianceSampler,\r#endif\n#ifndef LODBASEDMICROSFURACE\nreflectionSamplerLow,\rreflectionSamplerHigh,\r#endif\n#ifdef REALTIME_FILTERING\nvReflectionFilteringInfo,\r#endif\nreflectionOut\r);\r#else\n#define CUSTOM_REFLECTION\n#endif\n#endif\n#include<pbrBlockReflectance0>\n#ifdef SHEEN\nsheenOutParams sheenOut;\r#ifdef SHEEN_TEXTURE\nvec4 sheenMapData=texture2D(sheenSampler,vSheenUV+uvOffset);\r#endif\n#if defined(SHEEN_ROUGHNESS) && defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)\nvec4 sheenMapRoughnessData=texture2D(sheenRoughnessSampler,vSheenRoughnessUV+uvOffset)*vSheenInfos.w;\r#endif\nsheenBlock(\rvSheenColor,\r#ifdef SHEEN_ROUGHNESS\nvSheenRoughness,\r#if defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)\nsheenMapRoughnessData,\r#endif\n#endif\nroughness,\r#ifdef SHEEN_TEXTURE\nsheenMapData,\rvSheenInfos.y,\r#endif\nreflectance,\r#ifdef SHEEN_LINKWITHALBEDO\nbaseColor,\rsurfaceAlbedo,\r#endif\n#ifdef ENVIRONMENTBRDF\nNdotV,\renvironmentBrdf,\r#endif\n#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)\nAARoughnessFactors,\rvReflectionMicrosurfaceInfos,\rvReflectionInfos,\rvReflectionColor,\rvLightingIntensity,\rreflectionSampler,\rreflectionOut.reflectionCoords,\rNdotVUnclamped,\r#ifndef LODBASEDMICROSFURACE\nreflectionSamplerLow,\rreflectionSamplerHigh,\r#endif\n#ifdef REALTIME_FILTERING\nvReflectionFilteringInfo,\r#endif\n#if !defined(REFLECTIONMAP_SKYBOX) && defined(RADIANCEOCCLUSION)\nseo,\r#endif\n#if !defined(REFLECTIONMAP_SKYBOX) && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)\neho,\r#endif\n#endif\nsheenOut\r);\r#ifdef SHEEN_LINKWITHALBEDO\nsurfaceAlbedo=sheenOut.surfaceAlbedo;\r#endif\n#endif\n#ifdef CLEARCOAT\n#ifdef CLEARCOAT_TEXTURE\nvec2 clearCoatMapData=texture2D(clearCoatSampler,vClearCoatUV+uvOffset).rg*vClearCoatInfos.y;\r#endif\n#endif\n#ifdef IRIDESCENCE\niridescenceOutParams iridescenceOut;\r#ifdef IRIDESCENCE_TEXTURE\nvec2 iridescenceMapData=texture2D(iridescenceSampler,vIridescenceUV+uvOffset).rg*vIridescenceInfos.y;\r#endif\n#ifdef IRIDESCENCE_THICKNESS_TEXTURE\nvec2 iridescenceThicknessMapData=texture2D(iridescenceThicknessSampler,vIridescenceThicknessUV+uvOffset).rg*vIridescenceInfos.w;\r#endif\niridescenceBlock(\rvIridescenceParams,\rNdotV,\rspecularEnvironmentR0,\r#ifdef IRIDESCENCE_TEXTURE\niridescenceMapData,\r#endif\n#ifdef IRIDESCENCE_THICKNESS_TEXTURE\niridescenceThicknessMapData,\r#endif\n#ifdef CLEARCOAT\nNdotVUnclamped,\r#ifdef CLEARCOAT_TEXTURE\nclearCoatMapData,\r#endif\n#endif\niridescenceOut\r);\rfloat iridescenceIntensity=iridescenceOut.iridescenceIntensity;\rspecularEnvironmentR0=iridescenceOut.specularEnvironmentR0;\r#endif\nclearcoatOutParams clearcoatOut;\r#ifdef CLEARCOAT\n#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)\nvec4 clearCoatMapRoughnessData=texture2D(clearCoatRoughnessSampler,vClearCoatRoughnessUV+uvOffset)*vClearCoatInfos.w;\r#endif\n#if defined(CLEARCOAT_TINT) && defined(CLEARCOAT_TINT_TEXTURE)\nvec4 clearCoatTintMapData=texture2D(clearCoatTintSampler,vClearCoatTintUV+uvOffset);\r#endif\n#ifdef CLEARCOAT_BUMP\nvec4 clearCoatBumpMapData=texture2D(clearCoatBumpSampler,vClearCoatBumpUV+uvOffset);\r#endif\nclearcoatBlock(\rvPositionW,\rgeometricNormalW,\rviewDirectionW,\rvClearCoatParams,\r#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)\nclearCoatMapRoughnessData,\r#endif\nspecularEnvironmentR0,\r#ifdef CLEARCOAT_TEXTURE\nclearCoatMapData,\r#endif\n#ifdef CLEARCOAT_TINT\nvClearCoatTintParams,\rclearCoatColorAtDistance,\rvClearCoatRefractionParams,\r#ifdef CLEARCOAT_TINT_TEXTURE\nclearCoatTintMapData,\r#endif\n#endif\n#ifdef CLEARCOAT_BUMP\nvClearCoatBumpInfos,\rclearCoatBumpMapData,\rvClearCoatBumpUV,\r#if defined(TANGENT) && defined(NORMAL)\nvTBN,\r#else\nvClearCoatTangentSpaceParams,\r#endif\n#ifdef OBJECTSPACE_NORMALMAP\nnormalMatrix,\r#endif\n#endif\n#if defined(FORCENORMALFORWARD) && defined(NORMAL)\nfaceNormal,\r#endif\n#ifdef REFLECTION\nvReflectionMicrosurfaceInfos,\rvReflectionInfos,\rvReflectionColor,\rvLightingIntensity,\rreflectionSampler,\r#ifndef LODBASEDMICROSFURACE\nreflectionSamplerLow,\rreflectionSamplerHigh,\r#endif\n#ifdef REALTIME_FILTERING\nvReflectionFilteringInfo,\r#endif\n#endif\n#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)\n#ifdef RADIANCEOCCLUSION\nambientMonochrome,\r#endif\n#endif\n#if defined(CLEARCOAT_BUMP) || defined(TWOSIDEDLIGHTING)\n(gl_FrontFacing ? 1. : -1.),\r#endif\nclearcoatOut\r);\r#else\nclearcoatOut.specularEnvironmentR0=specularEnvironmentR0;\r#endif\n#include<pbrBlockReflectance>\nsubSurfaceOutParams subSurfaceOut;\r#ifdef SUBSURFACE\n#ifdef SS_THICKNESSANDMASK_TEXTURE\nvec4 thicknessMap=texture2D(thicknessSampler,vThicknessUV+uvOffset);\r#endif\n#ifdef SS_REFRACTIONINTENSITY_TEXTURE\nvec4 refractionIntensityMap=texture2D(refractionIntensitySampler,vRefractionIntensityUV+uvOffset);\r#endif\n#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE\nvec4 translucencyIntensityMap=texture2D(translucencyIntensitySampler,vTranslucencyIntensityUV+uvOffset);\r#endif\nsubSurfaceBlock(\rvSubSurfaceIntensity,\rvThicknessParam,\rvTintColor,\rnormalW,\rspecularEnvironmentReflectance,\r#ifdef SS_THICKNESSANDMASK_TEXTURE\nthicknessMap,\r#endif\n#ifdef SS_REFRACTIONINTENSITY_TEXTURE\nrefractionIntensityMap,\r#endif\n#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE\ntranslucencyIntensityMap,\r#endif\n#ifdef REFLECTION\n#ifdef SS_TRANSLUCENCY\nreflectionMatrix,\r#ifdef USESPHERICALFROMREFLECTIONMAP\n#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)\nreflectionOut.irradianceVector,\r#endif\n#if defined(REALTIME_FILTERING)\nreflectionSampler,\rvReflectionFilteringInfo,\r#endif\n#endif\n#ifdef USEIRRADIANCEMAP\nirradianceSampler,\r#endif\n#endif\n#endif\n#if defined(SS_REFRACTION) || defined(SS_TRANSLUCENCY)\nsurfaceAlbedo,\r#endif\n#ifdef SS_REFRACTION\nvPositionW,\rviewDirectionW,\rview,\rvRefractionInfos,\rrefractionMatrix,\rvRefractionMicrosurfaceInfos,\rvLightingIntensity,\r#ifdef SS_LINKREFRACTIONTOTRANSPARENCY\nalpha,\r#endif\n#ifdef SS_LODINREFRACTIONALPHA\nNdotVUnclamped,\r#endif\n#ifdef SS_LINEARSPECULARREFRACTION\nroughness,\r#endif\nalphaG,\rrefractionSampler,\r#ifndef LODBASEDMICROSFURACE\nrefractionSamplerLow,\rrefractionSamplerHigh,\r#endif\n#ifdef ANISOTROPIC\nanisotropicOut,\r#endif\n#ifdef REALTIME_FILTERING\nvRefractionFilteringInfo,\r#endif\n#ifdef SS_USE_LOCAL_REFRACTIONMAP_CUBIC\nvRefractionPosition,\rvRefractionSize,\r#endif\n#endif\n#ifdef SS_TRANSLUCENCY\nvDiffusionDistance,\r#endif\nsubSurfaceOut\r);\r#ifdef SS_REFRACTION\nsurfaceAlbedo=subSurfaceOut.surfaceAlbedo;\r#ifdef SS_LINKREFRACTIONTOTRANSPARENCY\nalpha=subSurfaceOut.alpha;\r#endif\n#endif\n#else\nsubSurfaceOut.specularEnvironmentReflectance=specularEnvironmentReflectance;\r#endif\n#include<pbrBlockDirectLighting>\n#include<lightFragment>[0..maxSimultaneousLights]\n#include<pbrBlockFinalLitComponents>\n#endif \n#include<pbrBlockFinalUnlitComponents>\n#define CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION\n#include<pbrBlockFinalColorComposition>\n#include<logDepthFragment>\n#include<fogFragment>(color,finalColor)\n#include<pbrBlockImageProcessing>\n#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR\n#ifdef PREPASS\nfloat writeGeometryInfo=finalColor.a>0.4 ? 1.0 : 0.0;\r#ifdef PREPASS_POSITION\ngl_FragData[PREPASS_POSITION_INDEX]=vec4(vPositionW,writeGeometryInfo);\r#endif\n#ifdef PREPASS_VELOCITY\nvec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;\rvec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;\rvec2 velocity=abs(a-b);\rvelocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;\rgl_FragData[PREPASS_VELOCITY_INDEX]=vec4(velocity,0.0,writeGeometryInfo);\r#endif\n#ifdef PREPASS_ALBEDO_SQRT\nvec3 sqAlbedo=sqrt(surfaceAlbedo); \r#endif\n#ifdef PREPASS_IRRADIANCE\nvec3 irradiance=finalDiffuse;\r#ifndef UNLIT\n#ifdef REFLECTION\nirradiance+=finalIrradiance;\r#endif\n#endif\n#ifdef SS_SCATTERING\ngl_FragData[0]=vec4(finalColor.rgb-irradiance,finalColor.a); \rirradiance/=sqAlbedo;\r#else\ngl_FragData[0]=finalColor; \rfloat scatteringDiffusionProfile=255.;\r#endif\ngl_FragData[PREPASS_IRRADIANCE_INDEX]=vec4(clamp(irradiance,vec3(0.),vec3(1.)),writeGeometryInfo*scatteringDiffusionProfile/255.); \r#else\ngl_FragData[0]=vec4(finalColor.rgb,finalColor.a);\r#endif\n#ifdef PREPASS_DEPTH\ngl_FragData[PREPASS_DEPTH_INDEX]=vec4(vViewPos.z,0.0,0.0,writeGeometryInfo); \r#endif\n#ifdef PREPASS_NORMAL\ngl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalize((view*vec4(normalW,0.0)).rgb),writeGeometryInfo); \r#endif\n#ifdef PREPASS_ALBEDO_SQRT\ngl_FragData[PREPASS_ALBEDO_SQRT_INDEX]=vec4(sqAlbedo,writeGeometryInfo); \r#endif\n#ifdef PREPASS_REFLECTIVITY\n#ifndef UNLIT\ngl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(specularEnvironmentR0,microSurface)*writeGeometryInfo;\r#else\ngl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4( 0.0,0.0,0.0,1.0 )*writeGeometryInfo;\r#endif\n#endif\n#endif\n#if !defined(PREPASS) || defined(WEBGL2)\ngl_FragColor=finalColor;\r#endif\n#include<oitFragment>\n#if ORDER_INDEPENDENT_TRANSPARENCY\nif (fragDepth==nearestDepth) {\rfrontColor.rgb+=finalColor.rgb*finalColor.a*alphaMultiplier;\rfrontColor.a=1.0-alphaMultiplier*(1.0-finalColor.a);\r} else {\rbackColor+=finalColor;\r}\r#endif\n#include<pbrDebug>\n#define CUSTOM_FRAGMENT_MAIN_END\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const pbrPixelShader = { name, shader };\n"]}
+{"version":3,"file":"pbr.fragment.js","sourceRoot":"","sources":["../../../../lts/core/generated/Shaders/pbr.fragment.ts"],"names":[],"mappings":"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","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/prePassDeclaration\";\nimport \"./ShadersInclude/oitDeclaration\";\nimport \"./ShadersInclude/pbrFragmentDeclaration\";\nimport \"./ShadersInclude/pbrUboDeclaration\";\nimport \"./ShadersInclude/pbrFragmentExtraDeclaration\";\nimport \"./ShadersInclude/lightFragmentDeclaration\";\nimport \"./ShadersInclude/lightUboDeclaration\";\nimport \"./ShadersInclude/pbrFragmentSamplersDeclaration\";\nimport \"./ShadersInclude/imageProcessingDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/logDepthDeclaration\";\nimport \"./ShadersInclude/fogFragmentDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/subSurfaceScatteringFunctions\";\nimport \"./ShadersInclude/importanceSampling\";\nimport \"./ShadersInclude/pbrHelperFunctions\";\nimport \"./ShadersInclude/imageProcessingFunctions\";\nimport \"./ShadersInclude/shadowsFragmentFunctions\";\nimport \"./ShadersInclude/harmonicsFunctions\";\nimport \"./ShadersInclude/pbrDirectLightingSetupFunctions\";\nimport \"./ShadersInclude/pbrDirectLightingFalloffFunctions\";\nimport \"./ShadersInclude/pbrBRDFFunctions\";\nimport \"./ShadersInclude/hdrFilteringFunctions\";\nimport \"./ShadersInclude/pbrDirectLightingFunctions\";\nimport \"./ShadersInclude/pbrIBLFunctions\";\nimport \"./ShadersInclude/bumpFragmentMainFunctions\";\nimport \"./ShadersInclude/bumpFragmentFunctions\";\nimport \"./ShadersInclude/reflectionFunction\";\nimport \"./ShadersInclude/pbrBlockAlbedoOpacity\";\nimport \"./ShadersInclude/pbrBlockReflectivity\";\nimport \"./ShadersInclude/pbrBlockAmbientOcclusion\";\nimport \"./ShadersInclude/pbrBlockAlphaFresnel\";\nimport \"./ShadersInclude/pbrBlockAnisotropic\";\nimport \"./ShadersInclude/pbrBlockReflection\";\nimport \"./ShadersInclude/pbrBlockSheen\";\nimport \"./ShadersInclude/pbrBlockClearcoat\";\nimport \"./ShadersInclude/pbrBlockIridescence\";\nimport \"./ShadersInclude/pbrBlockSubSurface\";\nimport \"./ShadersInclude/clipPlaneFragment\";\nimport \"./ShadersInclude/pbrBlockNormalGeometric\";\nimport \"./ShadersInclude/bumpFragment\";\nimport \"./ShadersInclude/pbrBlockNormalFinal\";\nimport \"./ShadersInclude/depthPrePass\";\nimport \"./ShadersInclude/pbrBlockLightmapInit\";\nimport \"./ShadersInclude/pbrBlockGeometryInfo\";\nimport \"./ShadersInclude/pbrBlockReflectance0\";\nimport \"./ShadersInclude/pbrBlockReflectance\";\nimport \"./ShadersInclude/pbrBlockDirectLighting\";\nimport \"./ShadersInclude/lightFragment\";\nimport \"./ShadersInclude/pbrBlockFinalLitComponents\";\nimport \"./ShadersInclude/pbrBlockFinalUnlitComponents\";\nimport \"./ShadersInclude/pbrBlockFinalColorComposition\";\nimport \"./ShadersInclude/logDepthFragment\";\nimport \"./ShadersInclude/fogFragment\";\nimport \"./ShadersInclude/pbrBlockImageProcessing\";\nimport \"./ShadersInclude/oitFragment\";\nimport \"./ShadersInclude/pbrDebug\";\n\nconst name = \"pbrPixelShader\";\nconst shader = `#if defined(BUMP) || !defined(NORMAL) || defined(FORCENORMALFORWARD) || defined(SPECULARAA) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)\n#extension GL_OES_standard_derivatives : enable\n#endif\n#ifdef LODBASEDMICROSFURACE\n#extension GL_EXT_shader_texture_lod : enable\n#endif\n#define CUSTOM_FRAGMENT_BEGIN\n#ifdef LOGARITHMICDEPTH\n#extension GL_EXT_frag_depth : enable\n#endif\n#include<prePassDeclaration>[SCENE_MRT_COUNT]\nprecision highp float;\r#include<oitDeclaration>\n#ifndef FROMLINEARSPACE\n#define FROMLINEARSPACE\n#endif\n#include<__decl__pbrFragment>\n#include<pbrFragmentExtraDeclaration>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#include<pbrFragmentSamplersDeclaration>\n#include<imageProcessingDeclaration>\n#include<clipPlaneFragmentDeclaration>\n#include<logDepthDeclaration>\n#include<fogFragmentDeclaration>\n#include<helperFunctions>\n#include<subSurfaceScatteringFunctions>\n#include<importanceSampling>\n#include<pbrHelperFunctions>\n#include<imageProcessingFunctions>\n#include<shadowsFragmentFunctions>\n#include<harmonicsFunctions>\n#include<pbrDirectLightingSetupFunctions>\n#include<pbrDirectLightingFalloffFunctions>\n#include<pbrBRDFFunctions>\n#include<hdrFilteringFunctions>\n#include<pbrDirectLightingFunctions>\n#include<pbrIBLFunctions>\n#include<bumpFragmentMainFunctions>\n#include<bumpFragmentFunctions>\n#ifdef REFLECTION\n#include<reflectionFunction>\n#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\n#include<pbrBlockAlbedoOpacity>\n#include<pbrBlockReflectivity>\n#include<pbrBlockAmbientOcclusion>\n#include<pbrBlockAlphaFresnel>\n#include<pbrBlockAnisotropic>\n#include<pbrBlockReflection>\n#include<pbrBlockSheen>\n#include<pbrBlockClearcoat>\n#include<pbrBlockIridescence>\n#include<pbrBlockSubSurface>\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\n#include<pbrBlockNormalGeometric>\n#include<bumpFragment>\n#include<pbrBlockNormalFinal>\nalbedoOpacityOutParams albedoOpacityOut;\r#ifdef ALBEDO\nvec4 albedoTexture=texture2D(albedoSampler,vAlbedoUV+uvOffset);\r#endif\n#ifdef OPACITY\nvec4 opacityMap=texture2D(opacitySampler,vOpacityUV+uvOffset);\r#endif\n#ifdef DECAL\nvec4 decalColor=texture2D(decalSampler,vDecalUV+uvOffset);\r#endif\nalbedoOpacityBlock(\rvAlbedoColor,\r#ifdef ALBEDO\nalbedoTexture,\rvAlbedoInfos,\r#endif\n#ifdef OPACITY\nopacityMap,\rvOpacityInfos,\r#endif\n#ifdef DETAIL\ndetailColor,\rvDetailInfos,\r#endif\n#ifdef DECAL\ndecalColor,\rvDecalInfos,\r#endif\nalbedoOpacityOut\r);\rvec3 surfaceAlbedo=albedoOpacityOut.surfaceAlbedo;\rfloat alpha=albedoOpacityOut.alpha;\r#define CUSTOM_FRAGMENT_UPDATE_ALPHA\n#include<depthPrePass>\n#define CUSTOM_FRAGMENT_BEFORE_LIGHTS\nambientOcclusionOutParams aoOut;\r#ifdef AMBIENT\nvec3 ambientOcclusionColorMap=texture2D(ambientSampler,vAmbientUV+uvOffset).rgb;\r#endif\nambientOcclusionBlock(\r#ifdef AMBIENT\nambientOcclusionColorMap,\rvAmbientInfos,\r#endif\naoOut\r);\r#include<pbrBlockLightmapInit>\n#ifdef UNLIT\nvec3 diffuseBase=vec3(1.,1.,1.);\r#else\nvec3 baseColor=surfaceAlbedo;\rreflectivityOutParams reflectivityOut;\r#if defined(REFLECTIVITY)\nvec4 surfaceMetallicOrReflectivityColorMap=texture2D(reflectivitySampler,vReflectivityUV+uvOffset);\rvec4 baseReflectivity=surfaceMetallicOrReflectivityColorMap;\r#ifndef METALLICWORKFLOW\n#ifdef REFLECTIVITY_GAMMA\nsurfaceMetallicOrReflectivityColorMap=toLinearSpace(surfaceMetallicOrReflectivityColorMap);\r#endif\nsurfaceMetallicOrReflectivityColorMap.rgb*=vReflectivityInfos.y;\r#endif\n#endif\n#if defined(MICROSURFACEMAP)\nvec4 microSurfaceTexel=texture2D(microSurfaceSampler,vMicroSurfaceSamplerUV+uvOffset)*vMicroSurfaceSamplerInfos.y;\r#endif\n#ifdef METALLICWORKFLOW\nvec4 metallicReflectanceFactors=vMetallicReflectanceFactors;\r#ifdef REFLECTANCE\nvec4 reflectanceFactorsMap=texture2D(reflectanceSampler,vReflectanceUV+uvOffset);\r#ifdef REFLECTANCE_GAMMA\nreflectanceFactorsMap=toLinearSpace(reflectanceFactorsMap);\r#endif\nmetallicReflectanceFactors.rgb*=reflectanceFactorsMap.rgb;\r#endif\n#ifdef METALLIC_REFLECTANCE\nvec4 metallicReflectanceFactorsMap=texture2D(metallicReflectanceSampler,vMetallicReflectanceUV+uvOffset);\r#ifdef METALLIC_REFLECTANCE_GAMMA\nmetallicReflectanceFactorsMap=toLinearSpace(metallicReflectanceFactorsMap);\r#endif\n#ifndef METALLIC_REFLECTANCE_USE_ALPHA_ONLY\nmetallicReflectanceFactors.rgb*=metallicReflectanceFactorsMap.rgb;\r#endif\nmetallicReflectanceFactors*=metallicReflectanceFactorsMap.a;\r#endif\n#endif\nreflectivityBlock(\rvReflectivityColor,\r#ifdef METALLICWORKFLOW\nsurfaceAlbedo,\rmetallicReflectanceFactors,\r#endif\n#ifdef REFLECTIVITY\nvReflectivityInfos,\rsurfaceMetallicOrReflectivityColorMap,\r#endif\n#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)\naoOut.ambientOcclusionColor,\r#endif\n#ifdef MICROSURFACEMAP\nmicroSurfaceTexel,\r#endif\n#ifdef DETAIL\ndetailColor,\rvDetailInfos,\r#endif\nreflectivityOut\r);\rfloat microSurface=reflectivityOut.microSurface;\rfloat roughness=reflectivityOut.roughness;\r#ifdef METALLICWORKFLOW\nsurfaceAlbedo=reflectivityOut.surfaceAlbedo;\r#endif\n#if defined(METALLICWORKFLOW) && defined(REFLECTIVITY) && defined(AOSTOREINMETALMAPRED)\naoOut.ambientOcclusionColor=reflectivityOut.ambientOcclusionColor;\r#endif\n#ifdef ALPHAFRESNEL\n#if defined(ALPHATEST) || defined(ALPHABLEND)\nalphaFresnelOutParams alphaFresnelOut;\ralphaFresnelBlock(\rnormalW,\rviewDirectionW,\ralpha,\rmicroSurface,\ralphaFresnelOut\r);\ralpha=alphaFresnelOut.alpha;\r#endif\n#endif\n#include<pbrBlockGeometryInfo>\n#ifdef ANISOTROPIC\nanisotropicOutParams anisotropicOut;\r#ifdef ANISOTROPIC_TEXTURE\nvec3 anisotropyMapData=texture2D(anisotropySampler,vAnisotropyUV+uvOffset).rgb*vAnisotropyInfos.y;\r#endif\nanisotropicBlock(\rvAnisotropy,\rroughness,\r#ifdef ANISOTROPIC_TEXTURE\nanisotropyMapData,\r#endif\nTBN,\rnormalW,\rviewDirectionW,\ranisotropicOut\r);\r#endif\n#ifdef REFLECTION\nreflectionOutParams reflectionOut;\r#ifndef USE_CUSTOM_REFLECTION\nreflectionBlock(\rvPositionW,\rnormalW,\ralphaG,\rvReflectionMicrosurfaceInfos,\rvReflectionInfos,\rvReflectionColor,\r#ifdef ANISOTROPIC\nanisotropicOut,\r#endif\n#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)\nNdotVUnclamped,\r#endif\n#ifdef LINEARSPECULARREFLECTION\nroughness,\r#endif\nreflectionSampler,\r#if defined(NORMAL) && defined(USESPHERICALINVERTEX)\nvEnvironmentIrradiance,\r#endif\n#ifdef USESPHERICALFROMREFLECTIONMAP\n#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)\nreflectionMatrix,\r#endif\n#endif\n#ifdef USEIRRADIANCEMAP\nirradianceSampler,\r#endif\n#ifndef LODBASEDMICROSFURACE\nreflectionSamplerLow,\rreflectionSamplerHigh,\r#endif\n#ifdef REALTIME_FILTERING\nvReflectionFilteringInfo,\r#endif\nreflectionOut\r);\r#else\n#define CUSTOM_REFLECTION\n#endif\n#endif\n#include<pbrBlockReflectance0>\n#ifdef SHEEN\nsheenOutParams sheenOut;\r#ifdef SHEEN_TEXTURE\nvec4 sheenMapData=texture2D(sheenSampler,vSheenUV+uvOffset);\r#endif\n#if defined(SHEEN_ROUGHNESS) && defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)\nvec4 sheenMapRoughnessData=texture2D(sheenRoughnessSampler,vSheenRoughnessUV+uvOffset)*vSheenInfos.w;\r#endif\nsheenBlock(\rvSheenColor,\r#ifdef SHEEN_ROUGHNESS\nvSheenRoughness,\r#if defined(SHEEN_TEXTURE_ROUGHNESS) && !defined(SHEEN_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(SHEEN_USE_ROUGHNESS_FROM_MAINTEXTURE)\nsheenMapRoughnessData,\r#endif\n#endif\nroughness,\r#ifdef SHEEN_TEXTURE\nsheenMapData,\rvSheenInfos.y,\r#endif\nreflectance,\r#ifdef SHEEN_LINKWITHALBEDO\nbaseColor,\rsurfaceAlbedo,\r#endif\n#ifdef ENVIRONMENTBRDF\nNdotV,\renvironmentBrdf,\r#endif\n#if defined(REFLECTION) && defined(ENVIRONMENTBRDF)\nAARoughnessFactors,\rvReflectionMicrosurfaceInfos,\rvReflectionInfos,\rvReflectionColor,\rvLightingIntensity,\rreflectionSampler,\rreflectionOut.reflectionCoords,\rNdotVUnclamped,\r#ifndef LODBASEDMICROSFURACE\nreflectionSamplerLow,\rreflectionSamplerHigh,\r#endif\n#ifdef REALTIME_FILTERING\nvReflectionFilteringInfo,\r#endif\n#if !defined(REFLECTIONMAP_SKYBOX) && defined(RADIANCEOCCLUSION)\nseo,\r#endif\n#if !defined(REFLECTIONMAP_SKYBOX) && defined(HORIZONOCCLUSION) && defined(BUMP) && defined(REFLECTIONMAP_3D)\neho,\r#endif\n#endif\nsheenOut\r);\r#ifdef SHEEN_LINKWITHALBEDO\nsurfaceAlbedo=sheenOut.surfaceAlbedo;\r#endif\n#endif\n#ifdef CLEARCOAT\n#ifdef CLEARCOAT_TEXTURE\nvec2 clearCoatMapData=texture2D(clearCoatSampler,vClearCoatUV+uvOffset).rg*vClearCoatInfos.y;\r#endif\n#endif\n#ifdef IRIDESCENCE\niridescenceOutParams iridescenceOut;\r#ifdef IRIDESCENCE_TEXTURE\nvec2 iridescenceMapData=texture2D(iridescenceSampler,vIridescenceUV+uvOffset).rg*vIridescenceInfos.y;\r#endif\n#ifdef IRIDESCENCE_THICKNESS_TEXTURE\nvec2 iridescenceThicknessMapData=texture2D(iridescenceThicknessSampler,vIridescenceThicknessUV+uvOffset).rg*vIridescenceInfos.w;\r#endif\niridescenceBlock(\rvIridescenceParams,\rNdotV,\rspecularEnvironmentR0,\r#ifdef IRIDESCENCE_TEXTURE\niridescenceMapData,\r#endif\n#ifdef IRIDESCENCE_THICKNESS_TEXTURE\niridescenceThicknessMapData,\r#endif\n#ifdef CLEARCOAT\nNdotVUnclamped,\r#ifdef CLEARCOAT_TEXTURE\nclearCoatMapData,\r#endif\n#endif\niridescenceOut\r);\rfloat iridescenceIntensity=iridescenceOut.iridescenceIntensity;\rspecularEnvironmentR0=iridescenceOut.specularEnvironmentR0;\r#endif\nclearcoatOutParams clearcoatOut;\r#ifdef CLEARCOAT\n#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)\nvec4 clearCoatMapRoughnessData=texture2D(clearCoatRoughnessSampler,vClearCoatRoughnessUV+uvOffset)*vClearCoatInfos.w;\r#endif\n#if defined(CLEARCOAT_TINT) && defined(CLEARCOAT_TINT_TEXTURE)\nvec4 clearCoatTintMapData=texture2D(clearCoatTintSampler,vClearCoatTintUV+uvOffset);\r#endif\n#ifdef CLEARCOAT_BUMP\nvec4 clearCoatBumpMapData=texture2D(clearCoatBumpSampler,vClearCoatBumpUV+uvOffset);\r#endif\nclearcoatBlock(\rvPositionW,\rgeometricNormalW,\rviewDirectionW,\rvClearCoatParams,\r#if defined(CLEARCOAT_TEXTURE_ROUGHNESS) && !defined(CLEARCOAT_TEXTURE_ROUGHNESS_IDENTICAL) && !defined(CLEARCOAT_USE_ROUGHNESS_FROM_MAINTEXTURE)\nclearCoatMapRoughnessData,\r#endif\nspecularEnvironmentR0,\r#ifdef CLEARCOAT_TEXTURE\nclearCoatMapData,\r#endif\n#ifdef CLEARCOAT_TINT\nvClearCoatTintParams,\rclearCoatColorAtDistance,\rvClearCoatRefractionParams,\r#ifdef CLEARCOAT_TINT_TEXTURE\nclearCoatTintMapData,\r#endif\n#endif\n#ifdef CLEARCOAT_BUMP\nvClearCoatBumpInfos,\rclearCoatBumpMapData,\rvClearCoatBumpUV,\r#if defined(TANGENT) && defined(NORMAL)\nvTBN,\r#else\nvClearCoatTangentSpaceParams,\r#endif\n#ifdef OBJECTSPACE_NORMALMAP\nnormalMatrix,\r#endif\n#endif\n#if defined(FORCENORMALFORWARD) && defined(NORMAL)\nfaceNormal,\r#endif\n#ifdef REFLECTION\nvReflectionMicrosurfaceInfos,\rvReflectionInfos,\rvReflectionColor,\rvLightingIntensity,\rreflectionSampler,\r#ifndef LODBASEDMICROSFURACE\nreflectionSamplerLow,\rreflectionSamplerHigh,\r#endif\n#ifdef REALTIME_FILTERING\nvReflectionFilteringInfo,\r#endif\n#endif\n#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)\n#ifdef RADIANCEOCCLUSION\nambientMonochrome,\r#endif\n#endif\n#if defined(CLEARCOAT_BUMP) || defined(TWOSIDEDLIGHTING)\n(gl_FrontFacing ? 1. : -1.),\r#endif\nclearcoatOut\r);\r#else\nclearcoatOut.specularEnvironmentR0=specularEnvironmentR0;\r#endif\n#include<pbrBlockReflectance>\nsubSurfaceOutParams subSurfaceOut;\r#ifdef SUBSURFACE\n#ifdef SS_THICKNESSANDMASK_TEXTURE\nvec4 thicknessMap=texture2D(thicknessSampler,vThicknessUV+uvOffset);\r#endif\n#ifdef SS_REFRACTIONINTENSITY_TEXTURE\nvec4 refractionIntensityMap=texture2D(refractionIntensitySampler,vRefractionIntensityUV+uvOffset);\r#endif\n#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE\nvec4 translucencyIntensityMap=texture2D(translucencyIntensitySampler,vTranslucencyIntensityUV+uvOffset);\r#endif\nsubSurfaceBlock(\rvSubSurfaceIntensity,\rvThicknessParam,\rvTintColor,\rnormalW,\rspecularEnvironmentReflectance,\r#ifdef SS_THICKNESSANDMASK_TEXTURE\nthicknessMap,\r#endif\n#ifdef SS_REFRACTIONINTENSITY_TEXTURE\nrefractionIntensityMap,\r#endif\n#ifdef SS_TRANSLUCENCYINTENSITY_TEXTURE\ntranslucencyIntensityMap,\r#endif\n#ifdef REFLECTION\n#ifdef SS_TRANSLUCENCY\nreflectionMatrix,\r#ifdef USESPHERICALFROMREFLECTIONMAP\n#if !defined(NORMAL) || !defined(USESPHERICALINVERTEX)\nreflectionOut.irradianceVector,\r#endif\n#if defined(REALTIME_FILTERING)\nreflectionSampler,\rvReflectionFilteringInfo,\r#endif\n#endif\n#ifdef USEIRRADIANCEMAP\nirradianceSampler,\r#endif\n#endif\n#endif\n#if defined(SS_REFRACTION) || defined(SS_TRANSLUCENCY)\nsurfaceAlbedo,\r#endif\n#ifdef SS_REFRACTION\nvPositionW,\rviewDirectionW,\rview,\rvRefractionInfos,\rrefractionMatrix,\rvRefractionMicrosurfaceInfos,\rvLightingIntensity,\r#ifdef SS_LINKREFRACTIONTOTRANSPARENCY\nalpha,\r#endif\n#ifdef SS_LODINREFRACTIONALPHA\nNdotVUnclamped,\r#endif\n#ifdef SS_LINEARSPECULARREFRACTION\nroughness,\r#endif\nalphaG,\rrefractionSampler,\r#ifndef LODBASEDMICROSFURACE\nrefractionSamplerLow,\rrefractionSamplerHigh,\r#endif\n#ifdef ANISOTROPIC\nanisotropicOut,\r#endif\n#ifdef REALTIME_FILTERING\nvRefractionFilteringInfo,\r#endif\n#ifdef SS_USE_LOCAL_REFRACTIONMAP_CUBIC\nvRefractionPosition,\rvRefractionSize,\r#endif\n#endif\n#ifdef SS_TRANSLUCENCY\nvDiffusionDistance,\r#endif\nsubSurfaceOut\r);\r#ifdef SS_REFRACTION\nsurfaceAlbedo=subSurfaceOut.surfaceAlbedo;\r#ifdef SS_LINKREFRACTIONTOTRANSPARENCY\nalpha=subSurfaceOut.alpha;\r#endif\n#endif\n#else\nsubSurfaceOut.specularEnvironmentReflectance=specularEnvironmentReflectance;\r#endif\n#include<pbrBlockDirectLighting>\n#include<lightFragment>[0..maxSimultaneousLights]\n#include<pbrBlockFinalLitComponents>\n#endif \n#include<pbrBlockFinalUnlitComponents>\n#define CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION\n#include<pbrBlockFinalColorComposition>\n#include<logDepthFragment>\n#include<fogFragment>(color,finalColor)\n#include<pbrBlockImageProcessing>\n#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR\n#ifdef PREPASS\nfloat writeGeometryInfo=finalColor.a>0.4 ? 1.0 : 0.0;\r#ifdef PREPASS_POSITION\ngl_FragData[PREPASS_POSITION_INDEX]=vec4(vPositionW,writeGeometryInfo);\r#endif\n#ifdef PREPASS_VELOCITY\nvec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;\rvec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;\rvec2 velocity=abs(a-b);\rvelocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;\rgl_FragData[PREPASS_VELOCITY_INDEX]=vec4(velocity,0.0,writeGeometryInfo);\r#endif\n#ifdef PREPASS_ALBEDO_SQRT\nvec3 sqAlbedo=sqrt(surfaceAlbedo); \r#endif\n#ifdef PREPASS_IRRADIANCE\nvec3 irradiance=finalDiffuse;\r#ifndef UNLIT\n#ifdef REFLECTION\nirradiance+=finalIrradiance;\r#endif\n#endif\n#ifdef SS_SCATTERING\ngl_FragData[0]=vec4(finalColor.rgb-irradiance,finalColor.a); \rirradiance/=sqAlbedo;\r#else\ngl_FragData[0]=finalColor; \rfloat scatteringDiffusionProfile=255.;\r#endif\ngl_FragData[PREPASS_IRRADIANCE_INDEX]=vec4(clamp(irradiance,vec3(0.),vec3(1.)),writeGeometryInfo*scatteringDiffusionProfile/255.); \r#else\ngl_FragData[0]=vec4(finalColor.rgb,finalColor.a);\r#endif\n#ifdef PREPASS_DEPTH\ngl_FragData[PREPASS_DEPTH_INDEX]=vec4(vViewPos.z,0.0,0.0,writeGeometryInfo); \r#endif\n#ifdef PREPASS_NORMAL\ngl_FragData[PREPASS_NORMAL_INDEX]=vec4(normalize((view*vec4(normalW,0.0)).rgb),writeGeometryInfo); \r#endif\n#ifdef PREPASS_ALBEDO_SQRT\ngl_FragData[PREPASS_ALBEDO_SQRT_INDEX]=vec4(sqAlbedo,writeGeometryInfo); \r#endif\n#ifdef PREPASS_REFLECTIVITY\n#ifndef UNLIT\ngl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4(specularEnvironmentR0,microSurface)*writeGeometryInfo;\r#else\ngl_FragData[PREPASS_REFLECTIVITY_INDEX]=vec4( 0.0,0.0,0.0,1.0 )*writeGeometryInfo;\r#endif\n#endif\n#endif\n#if !defined(PREPASS) || defined(WEBGL2)\ngl_FragColor=finalColor;\r#endif\n#include<oitFragment>\n#if ORDER_INDEPENDENT_TRANSPARENCY\nif (fragDepth==nearestDepth) {\rfrontColor.rgb+=finalColor.rgb*finalColor.a*alphaMultiplier;\rfrontColor.a=1.0-alphaMultiplier*(1.0-finalColor.a);\r} else {\rbackColor+=finalColor;\r}\r#endif\n#include<pbrDebug>\n#define CUSTOM_FRAGMENT_MAIN_END\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const pbrPixelShader = { name, shader };\n"]}

package/Shaders/screenSpaceReflection2.fragment.d.ts

@@ -1,4 +1,5 @@
 import "./ShadersInclude/helperFunctions";
+import "./ShadersInclude/pbrBRDFFunctions";
 import "./ShadersInclude/screenSpaceRayTrace";
 /** @internal */
 export declare const screenSpaceReflection2PixelShader: {

package/Shaders/screenSpaceReflection2.fragment.js

@@ -1,6 +1,7 @@
 // Do not edit.
 import { ShaderStore } from "../Engines/shaderStore.js";
 import "./ShadersInclude/helperFunctions.js";
+import "./ShadersInclude/pbrBRDFFunctions.js";
 import "./ShadersInclude/screenSpaceRayTrace.js";
 const name = "screenSpaceReflection2PixelShader";
 const shader = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
@@ -18,11 +19,9 @@ uniform samplerCube envCubeSampler;
 uniform vec3 vReflectionPosition;
 #endif
 uniform mat4 view;
+#include<pbrBRDFFunctions>
 #include<screenSpaceRayTrace>
-vec3 fresnelSchlick(float cosTheta,vec3 F0)
-ndc.z=-projection[2].z-projection[3].z/depth;
-ndc.z=projection[2].z+projection[3].z/depth;
-ndc.w=1.0;
+vec3 hash(vec3 a)
 vec2 dCoords=smoothstep(0.2,0.6,abs(vec2(0.5,0.5)-hitUV.xy));
 #ifdef SSR_ATTENUATE_INTERSECTION_DISTANCE
 attenuation*=1.0-clamp(distance(vsRayOrigin,vsHitPoint)/maxRayDistance,0.0,1.0);
@@ -32,12 +31,14 @@ attenuation*=1.0-(numIterations/maxSteps);
 vec3 reflectionNormal=texelFetch(normalSampler,hitPixel,0).xyz;
 return attenuation;
 void main()
-vec4 colorFull=TEXTUREFUNC(textureSampler,vUV,0.0);
+vec4 colorFull=TEXTUREFUNC(textureSampler,vUV,0.0);
+if (max(reflectivity.r,max(reflectivity.g,reflectivity.b))<=reflectivityThreshold) {
 gl_FragColor=vec4(0.);
 gl_FragColor=colorFull;
-return;
+return;
+#ifdef SSR_INPUT_IS_GAMMA_SPACE
 color=toLinearSpace(color);
-vec2 texSize=vec2(textureSize(depthSampler,0));
+vec2 texSize=vec2(textureSize(depthSampler,0));
 vec3 wReflectedVector=vec3(invView*vec4(csReflectedVector,0.0));
 vec4 worldPos=invView*vec4(csPosition,1.0);
 #ifdef SSR_INVERTCUBICMAP
@@ -61,11 +62,16 @@ thickness,
 ,debugColor
 );
 gl_FragColor=vec4(debugColor,1.);
-vec3 F0=reflectivity.rgb;
+vec3 F0=reflectivity.rgb;
 reflectedColor=toLinearSpace(reflectedColor);
-reflectionAttenuation*=computeAttenuationForIntersection(ivec2(hitPixel),hitPixel/texSize,csPosition,hitPoint,csReflectedVector,maxDistance,numIterations);
+reflectionAttenuation*=computeAttenuationForIntersection(ivec2(hitPixel),hitPixel/texSize,csPosition,hitPoint,csReflectedVector,maxDistance,numIterations);
+SSR*=fresnel;
+#ifdef SSR_USE_BLUR
 float blur_radius=0.0;
-vec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);
+#ifdef SSR_BLEND_WITH_FRESNEL
+vec3 reflectionMultiplier=clamp(pow(fresnel*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);
+vec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);
+vec3 colorMultiplier=1.0-reflectionMultiplier;
 finalColor=toGammaSpace(finalColor);
 gl_FragColor=vec4(finalColor,colorFull.a);
 #else

package/Shaders/screenSpaceReflection2.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"screenSpaceReflection2.fragment.js","sourceRoot":"","sources":["../../../../lts/core/generated/Shaders/screenSpaceReflection2.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,sCAAsC,CAAC;AAE9C,MAAM,IAAI,GAAG,mCAAmC,CAAC;AACjD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyNd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,iCAAiC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/screenSpaceRayTrace\";\n\nconst name = \"screenSpaceReflection2PixelShader\";\nconst shader = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)\n#define TEXTUREFUNC(s,c,lod) texture2DLodEXT(s,c,lod)\n#define TEXTURECUBEFUNC(s,c,lod) textureLod(s,c,lod)\n#else\n#define TEXTUREFUNC(s,c,bias) texture2D(s,c,bias)\n#define TEXTURECUBEFUNC(s,c,bias) textureCube(s,c,bias)\n#endif\nuniform sampler2D textureSampler;\rvarying vec2 vUV;\r#ifdef SSR_SUPPORTED\nuniform sampler2D reflectivitySampler;\runiform sampler2D normalSampler;\runiform sampler2D depthSampler;\r#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nuniform sampler2D backDepthSampler;\runiform float backSizeFactor;\r#endif\n#ifdef SSR_USE_ENVIRONMENT_CUBE\nuniform samplerCube envCubeSampler;\r#ifdef SSR_USE_LOCAL_REFLECTIONMAP_CUBIC\nuniform vec3 vReflectionPosition;\runiform vec3 vReflectionSize;\r#endif\n#endif\nuniform mat4 view;\runiform mat4 invView;\runiform mat4 projection;\runiform mat4 invProjectionMatrix;\runiform mat4 projectionPixel;\runiform float nearPlaneZ;\runiform float stepSize;\runiform float maxSteps;\runiform float strength;\runiform float thickness;\runiform float roughnessFactor;\runiform float reflectionSpecularFalloffExponent;\runiform float maxDistance;\runiform float selfCollisionNumSkip;\runiform float reflectivityThreshold;\r#include<helperFunctions>\n#include<screenSpaceRayTrace>\nvec3 fresnelSchlick(float cosTheta,vec3 F0)\r{\rreturn F0+(1.0-F0)*pow(1.0-cosTheta,5.0);\r}\rvec3 hash(vec3 a)\r{\ra=fract(a*0.8);\ra+=dot(a,a.yxz+19.19);\rreturn fract((a.xxy+a.yxx)*a.zyx);\r}\rvec3 computeViewPosFromUVDepth(vec2 texCoord,float depth) {\rvec4 ndc;\rndc.xy=texCoord*2.0-1.0;\r#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE\nndc.z=-projection[2].z-projection[3].z/depth;\r#else\nndc.z=projection[2].z+projection[3].z/depth;\r#endif\nndc.w=1.0;\rvec4 eyePos=invProjectionMatrix*ndc;\reyePos.xyz/=eyePos.w;\rreturn eyePos.xyz;\r}\rfloat computeAttenuationForIntersection(ivec2 hitPixel,vec2 hitUV,vec3 vsRayOrigin,vec3 vsHitPoint,vec3 reflectionVector,float maxRayDistance,float numIterations) {\rfloat attenuation=1.0;\r#ifdef SSR_ATTENUATE_SCREEN_BORDERS\nvec2 dCoords=smoothstep(0.2,0.6,abs(vec2(0.5,0.5)-hitUV.xy));\rattenuation*=clamp(1.0-(dCoords.x+dCoords.y),0.0,1.0);\r#endif\n#ifdef SSR_ATTENUATE_INTERSECTION_DISTANCE\nattenuation*=1.0-clamp(distance(vsRayOrigin,vsHitPoint)/maxRayDistance,0.0,1.0);\r#endif\n#ifdef SSR_ATTENUATE_INTERSECTION_NUMITERATIONS\nattenuation*=1.0-(numIterations/maxSteps);\r#endif\n#ifdef SSR_ATTENUATE_BACKFACE_REFLECTION\nvec3 reflectionNormal=texelFetch(normalSampler,hitPixel,0).xyz;\rfloat directionBasedAttenuation=smoothstep(-0.17,0.0,dot(reflectionNormal,-reflectionVector));\rattenuation*=directionBasedAttenuation;\r#endif\nreturn attenuation;\r}\r#endif\nvoid main()\r{\r#ifdef SSR_SUPPORTED\nvec4 colorFull=TEXTUREFUNC(textureSampler,vUV,0.0);\rvec3 color=colorFull.rgb;\rvec4 reflectivity=TEXTUREFUNC(reflectivitySampler,vUV,0.0);\rif (max(reflectivity.r,max(reflectivity.g,reflectivity.b))<=reflectivityThreshold) {\r#ifdef SSR_USE_BLUR\ngl_FragColor=vec4(0.);\r#else\ngl_FragColor=colorFull;\r#endif\nreturn;\r}\r#ifdef SSR_INPUT_IS_GAMMA_SPACE\ncolor=toLinearSpace(color);\r#endif\nvec2 texSize=vec2(textureSize(depthSampler,0));\rvec3 csNormal=texelFetch(normalSampler,ivec2(vUV*texSize),0).xyz; \rfloat depth=texelFetch(depthSampler,ivec2(vUV*texSize),0).r;\rvec3 csPosition=computeViewPosFromUVDepth(vUV,depth);\rvec3 csViewDirection=normalize(csPosition);\rvec3 csReflectedVector=reflect(csViewDirection,csNormal);\r#ifdef SSR_USE_ENVIRONMENT_CUBE\nvec3 wReflectedVector=vec3(invView*vec4(csReflectedVector,0.0));\r#ifdef SSR_USE_LOCAL_REFLECTIONMAP_CUBIC\nvec4 worldPos=invView*vec4(csPosition,1.0);\rwReflectedVector=parallaxCorrectNormal(worldPos.xyz,normalize(wReflectedVector),vReflectionSize,vReflectionPosition);\r#endif\n#ifdef SSR_INVERTCUBICMAP\nwReflectedVector.y*=-1.0;\r#endif\n#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE\nwReflectedVector.z*=-1.0;\r#endif\nvec3 envColor=TEXTURECUBEFUNC(envCubeSampler,wReflectedVector,0.0).xyz;\r#ifdef SSR_ENVIRONMENT_CUBE_IS_GAMMASPACE\nenvColor=toLinearSpace(envColor);\r#endif\n#else\nvec3 envColor=color;\r#endif\nfloat reflectionAttenuation=1.0;\rbool rayHasHit=false;\rvec2 startPixel;\rvec2 hitPixel;\rvec3 hitPoint;\rfloat numIterations;\r#ifdef SSRAYTRACE_DEBUG\nvec3 debugColor;\r#endif\n#ifdef SSR_ATTENUATE_FACING_CAMERA\nreflectionAttenuation*=1.0-smoothstep(0.25,0.5,dot(-csViewDirection,csReflectedVector));\r#endif\nif (reflectionAttenuation>0.0) {\r#ifdef SSR_USE_BLUR\nvec3 jitt=vec3(0.);\r#else\nfloat roughness=1.0-reflectivity.a;\rvec3 jitt=mix(vec3(0.0),hash(csPosition)-vec3(0.5),roughness)*roughnessFactor; \r#endif\nvec2 uv2=vUV*texSize;\rfloat c=(uv2.x+uv2.y)*0.25;\rfloat jitter=mod(c,1.0); \rrayHasHit=traceScreenSpaceRay1(\rcsPosition,\rnormalize(csReflectedVector+jitt),\rprojectionPixel,\rdepthSampler,\rtexSize,\r#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nbackDepthSampler,\rbackSizeFactor,\r#endif\nthickness,\rnearPlaneZ,\rstepSize,\rjitter,\rmaxSteps,\rmaxDistance,\rselfCollisionNumSkip,\rstartPixel,\rhitPixel,\rhitPoint,\rnumIterations\r#ifdef SSRAYTRACE_DEBUG\n,debugColor\r#endif\n);\r}\r#ifdef SSRAYTRACE_DEBUG\ngl_FragColor=vec4(debugColor,1.);\rreturn;\r#endif\nvec3 F0=reflectivity.rgb;\rvec3 fresnel=fresnelSchlick(max(dot(csNormal,-csViewDirection),0.0),F0);\rvec3 SSR=envColor;\rif (rayHasHit) {\rvec3 reflectedColor=texelFetch(textureSampler,ivec2(hitPixel),0).rgb;\r#ifdef SSR_INPUT_IS_GAMMA_SPACE\nreflectedColor=toLinearSpace(reflectedColor);\r#endif\nreflectionAttenuation*=computeAttenuationForIntersection(ivec2(hitPixel),hitPixel/texSize,csPosition,hitPoint,csReflectedVector,maxDistance,numIterations);\rSSR=reflectedColor*reflectionAttenuation+(1.0-reflectionAttenuation)*envColor;\r}\rSSR*=fresnel;\r#ifdef SSR_USE_BLUR\nfloat blur_radius=0.0;\rfloat roughness=1.0-reflectivity.a*(1.0-roughnessFactor);\rif (roughness>0.001) {\rfloat cone_angle=min(roughness,0.999)*3.14159265*0.5;\rfloat cone_len=distance(startPixel,hitPixel);\rfloat op_len=2.0*tan(cone_angle)*cone_len; \rfloat a=op_len;\rfloat h=cone_len;\rfloat a2=a*a;\rfloat fh2=4.0f*h*h;\rblur_radius=(a*(sqrt(a2+fh2)-a))/(4.0f*h);\r}\rgl_FragColor=vec4(SSR,blur_radius/255.0); \r#else\nvec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);\rvec3 colorMultiplier=1.0-reflectionMultiplier;\rvec3 finalColor=(color*colorMultiplier)+(SSR*reflectionMultiplier);\r#ifdef SSR_OUTPUT_IS_GAMMA_SPACE\nfinalColor=toGammaSpace(finalColor);\r#endif\ngl_FragColor=vec4(finalColor,colorFull.a);\r#endif\n#else\ngl_FragColor=TEXTUREFUNC(textureSampler,vUV,0.0);\r#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const screenSpaceReflection2PixelShader = { name, shader };\n"]}
+{"version":3,"file":"screenSpaceReflection2.fragment.js","sourceRoot":"","sources":["../../../../lts/core/generated/Shaders/screenSpaceReflection2.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,mCAAmC,CAAC;AAC3C,OAAO,sCAAsC,CAAC;AAE9C,MAAM,IAAI,GAAG,mCAAmC,CAAC;AACjD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiNd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,iCAAiC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/pbrBRDFFunctions\";\nimport \"./ShadersInclude/screenSpaceRayTrace\";\n\nconst name = \"screenSpaceReflection2PixelShader\";\nconst shader = `#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)\n#define TEXTUREFUNC(s,c,lod) texture2DLodEXT(s,c,lod)\n#define TEXTURECUBEFUNC(s,c,lod) textureLod(s,c,lod)\n#else\n#define TEXTUREFUNC(s,c,bias) texture2D(s,c,bias)\n#define TEXTURECUBEFUNC(s,c,bias) textureCube(s,c,bias)\n#endif\nuniform sampler2D textureSampler;\rvarying vec2 vUV;\r#ifdef SSR_SUPPORTED\nuniform sampler2D reflectivitySampler;\runiform sampler2D normalSampler;\runiform sampler2D depthSampler;\r#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nuniform sampler2D backDepthSampler;\runiform float backSizeFactor;\r#endif\n#ifdef SSR_USE_ENVIRONMENT_CUBE\nuniform samplerCube envCubeSampler;\r#ifdef SSR_USE_LOCAL_REFLECTIONMAP_CUBIC\nuniform vec3 vReflectionPosition;\runiform vec3 vReflectionSize;\r#endif\n#endif\nuniform mat4 view;\runiform mat4 invView;\runiform mat4 projection;\runiform mat4 invProjectionMatrix;\runiform mat4 projectionPixel;\runiform float nearPlaneZ;\runiform float stepSize;\runiform float maxSteps;\runiform float strength;\runiform float thickness;\runiform float roughnessFactor;\runiform float reflectionSpecularFalloffExponent;\runiform float maxDistance;\runiform float selfCollisionNumSkip;\runiform float reflectivityThreshold;\r#include<helperFunctions>\n#include<pbrBRDFFunctions>\n#include<screenSpaceRayTrace>\nvec3 hash(vec3 a)\r{\ra=fract(a*0.8);\ra+=dot(a,a.yxz+19.19);\rreturn fract((a.xxy+a.yxx)*a.zyx);\r}\rfloat computeAttenuationForIntersection(ivec2 hitPixel,vec2 hitUV,vec3 vsRayOrigin,vec3 vsHitPoint,vec3 reflectionVector,float maxRayDistance,float numIterations) {\rfloat attenuation=1.0;\r#ifdef SSR_ATTENUATE_SCREEN_BORDERS\nvec2 dCoords=smoothstep(0.2,0.6,abs(vec2(0.5,0.5)-hitUV.xy));\rattenuation*=clamp(1.0-(dCoords.x+dCoords.y),0.0,1.0);\r#endif\n#ifdef SSR_ATTENUATE_INTERSECTION_DISTANCE\nattenuation*=1.0-clamp(distance(vsRayOrigin,vsHitPoint)/maxRayDistance,0.0,1.0);\r#endif\n#ifdef SSR_ATTENUATE_INTERSECTION_NUMITERATIONS\nattenuation*=1.0-(numIterations/maxSteps);\r#endif\n#ifdef SSR_ATTENUATE_BACKFACE_REFLECTION\nvec3 reflectionNormal=texelFetch(normalSampler,hitPixel,0).xyz;\rfloat directionBasedAttenuation=smoothstep(-0.17,0.0,dot(reflectionNormal,-reflectionVector));\rattenuation*=directionBasedAttenuation;\r#endif\nreturn attenuation;\r}\r#endif\nvoid main()\r{\r#ifdef SSR_SUPPORTED\nvec4 colorFull=TEXTUREFUNC(textureSampler,vUV,0.0);\rvec3 color=colorFull.rgb;\rvec4 reflectivity=TEXTUREFUNC(reflectivitySampler,vUV,0.0);\r#ifndef SSR_DISABLE_REFLECTIVITY_TEST\nif (max(reflectivity.r,max(reflectivity.g,reflectivity.b))<=reflectivityThreshold) {\r#ifdef SSR_USE_BLUR\ngl_FragColor=vec4(0.);\r#else\ngl_FragColor=colorFull;\r#endif\nreturn;\r}\r#endif\n#ifdef SSR_INPUT_IS_GAMMA_SPACE\ncolor=toLinearSpace(color);\r#endif\nvec2 texSize=vec2(textureSize(depthSampler,0));\rvec3 csNormal=texelFetch(normalSampler,ivec2(vUV*texSize),0).xyz; \rfloat depth=texelFetch(depthSampler,ivec2(vUV*texSize),0).r;\rvec3 csPosition=computeViewPosFromUVDepth(vUV,depth,projection,invProjectionMatrix);\rvec3 csViewDirection=normalize(csPosition);\rvec3 csReflectedVector=reflect(csViewDirection,csNormal);\r#ifdef SSR_USE_ENVIRONMENT_CUBE\nvec3 wReflectedVector=vec3(invView*vec4(csReflectedVector,0.0));\r#ifdef SSR_USE_LOCAL_REFLECTIONMAP_CUBIC\nvec4 worldPos=invView*vec4(csPosition,1.0);\rwReflectedVector=parallaxCorrectNormal(worldPos.xyz,normalize(wReflectedVector),vReflectionSize,vReflectionPosition);\r#endif\n#ifdef SSR_INVERTCUBICMAP\nwReflectedVector.y*=-1.0;\r#endif\n#ifdef SSRAYTRACE_RIGHT_HANDED_SCENE\nwReflectedVector.z*=-1.0;\r#endif\nvec3 envColor=TEXTURECUBEFUNC(envCubeSampler,wReflectedVector,0.0).xyz;\r#ifdef SSR_ENVIRONMENT_CUBE_IS_GAMMASPACE\nenvColor=toLinearSpace(envColor);\r#endif\n#else\nvec3 envColor=color;\r#endif\nfloat reflectionAttenuation=1.0;\rbool rayHasHit=false;\rvec2 startPixel;\rvec2 hitPixel;\rvec3 hitPoint;\rfloat numIterations;\r#ifdef SSRAYTRACE_DEBUG\nvec3 debugColor;\r#endif\n#ifdef SSR_ATTENUATE_FACING_CAMERA\nreflectionAttenuation*=1.0-smoothstep(0.25,0.5,dot(-csViewDirection,csReflectedVector));\r#endif\nif (reflectionAttenuation>0.0) {\r#ifdef SSR_USE_BLUR\nvec3 jitt=vec3(0.);\r#else\nfloat roughness=1.0-reflectivity.a;\rvec3 jitt=mix(vec3(0.0),hash(csPosition)-vec3(0.5),roughness)*roughnessFactor; \r#endif\nvec2 uv2=vUV*texSize;\rfloat c=(uv2.x+uv2.y)*0.25;\rfloat jitter=mod(c,1.0); \rrayHasHit=traceScreenSpaceRay1(\rcsPosition,\rnormalize(csReflectedVector+jitt),\rprojectionPixel,\rdepthSampler,\rtexSize,\r#ifdef SSRAYTRACE_USE_BACK_DEPTHBUFFER\nbackDepthSampler,\rbackSizeFactor,\r#endif\nthickness,\rnearPlaneZ,\rstepSize,\rjitter,\rmaxSteps,\rmaxDistance,\rselfCollisionNumSkip,\rstartPixel,\rhitPixel,\rhitPoint,\rnumIterations\r#ifdef SSRAYTRACE_DEBUG\n,debugColor\r#endif\n);\r}\r#ifdef SSRAYTRACE_DEBUG\ngl_FragColor=vec4(debugColor,1.);\rreturn;\r#endif\nvec3 F0=reflectivity.rgb;\rvec3 fresnel=fresnelSchlickGGX(max(dot(csNormal,-csViewDirection),0.0),F0,vec3(1.));\rvec3 SSR=envColor;\rif (rayHasHit) {\rvec3 reflectedColor=texelFetch(textureSampler,ivec2(hitPixel),0).rgb;\r#ifdef SSR_INPUT_IS_GAMMA_SPACE\nreflectedColor=toLinearSpace(reflectedColor);\r#endif\nreflectionAttenuation*=computeAttenuationForIntersection(ivec2(hitPixel),hitPixel/texSize,csPosition,hitPoint,csReflectedVector,maxDistance,numIterations);\rSSR=reflectedColor*reflectionAttenuation+(1.0-reflectionAttenuation)*envColor;\r}\r#ifndef SSR_BLEND_WITH_FRESNEL\nSSR*=fresnel;\r#endif\n#ifdef SSR_USE_BLUR\nfloat blur_radius=0.0;\rfloat roughness=1.0-reflectivity.a*(1.0-roughnessFactor);\rif (roughness>0.001) {\rfloat cone_angle=min(roughness,0.999)*3.14159265*0.5;\rfloat cone_len=distance(startPixel,hitPixel);\rfloat op_len=2.0*tan(cone_angle)*cone_len; \rfloat a=op_len;\rfloat h=cone_len;\rfloat a2=a*a;\rfloat fh2=4.0f*h*h;\rblur_radius=(a*(sqrt(a2+fh2)-a))/(4.0f*h);\r}\rgl_FragColor=vec4(SSR,blur_radius/255.0); \r#else\n#ifdef SSR_BLEND_WITH_FRESNEL\nvec3 reflectionMultiplier=clamp(pow(fresnel*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);\r#else\nvec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);\r#endif\nvec3 colorMultiplier=1.0-reflectionMultiplier;\rvec3 finalColor=(color*colorMultiplier)+(SSR*reflectionMultiplier);\r#ifdef SSR_OUTPUT_IS_GAMMA_SPACE\nfinalColor=toGammaSpace(finalColor);\r#endif\ngl_FragColor=vec4(finalColor,colorFull.a);\r#endif\n#else\ngl_FragColor=TEXTUREFUNC(textureSampler,vUV,0.0);\r#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const screenSpaceReflection2PixelShader = { name, shader };\n"]}

package/Shaders/screenSpaceReflection2BlurCombiner.fragment.d.ts

@@ -1,4 +1,6 @@
 import "./ShadersInclude/helperFunctions";
+import "./ShadersInclude/pbrBRDFFunctions";
+import "./ShadersInclude/screenSpaceRayTrace";
 /** @internal */
 export declare const screenSpaceReflection2BlurCombinerPixelShader: {
     name: string;

package/Shaders/screenSpaceReflection2BlurCombiner.fragment.js

@@ -1,13 +1,24 @@
 // Do not edit.
 import { ShaderStore } from "../Engines/shaderStore.js";
 import "./ShadersInclude/helperFunctions.js";
+import "./ShadersInclude/pbrBRDFFunctions.js";
+import "./ShadersInclude/screenSpaceRayTrace.js";
 const name = "screenSpaceReflection2BlurCombinerPixelShader";
 const shader = `uniform sampler2D textureSampler; 
+#ifdef SSR_BLEND_WITH_FRESNEL
+#include<pbrBRDFFunctions>
+#include<screenSpaceRayTrace>
+uniform mat4 projection;
 void main()
 gl_FragColor=texture2D(textureSampler,vUV);
-vec3 SSR=texture2D(textureSampler,vUV).rgb;
+vec3 SSR=texture2D(textureSampler,vUV).rgb;
+if (max(reflectivity.r,max(reflectivity.g,reflectivity.b))<=reflectivityThreshold) {
+#ifdef SSR_INPUT_IS_GAMMA_SPACE
 color=toLinearSpace(color);
-vec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);
+#ifdef SSR_BLEND_WITH_FRESNEL
+vec2 texSize=vec2(textureSize(depthSampler,0));
+vec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);
+vec3 colorMultiplier=1.0-reflectionMultiplier;
 finalColor=toGammaSpace(finalColor);
 gl_FragColor=vec4(finalColor,color.a);
 }

package/Shaders/screenSpaceReflection2BlurCombiner.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"screenSpaceReflection2BlurCombiner.fragment.js","sourceRoot":"","sources":["../../../../lts/core/generated/Shaders/screenSpaceReflection2BlurCombiner.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,+CAA+C,CAAC;AAC7D,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,6CAA6C,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\n\nconst name = \"screenSpaceReflection2BlurCombinerPixelShader\";\nconst shader = `uniform sampler2D textureSampler; \runiform sampler2D mainSampler;\runiform sampler2D reflectivitySampler;\runiform float strength;\runiform float reflectionSpecularFalloffExponent;\runiform float reflectivityThreshold;\rvarying vec2 vUV;\r#include<helperFunctions>\nvoid main()\r{\r#ifdef SSRAYTRACE_DEBUG\ngl_FragColor=texture2D(textureSampler,vUV);\r#else\nvec3 SSR=texture2D(textureSampler,vUV).rgb;\rvec4 color=texture2D(mainSampler,vUV);\rvec4 reflectivity=texture2D(reflectivitySampler,vUV);\rif (max(reflectivity.r,max(reflectivity.g,reflectivity.b))<=reflectivityThreshold) {\rgl_FragColor=color;\rreturn;\r}\r#ifdef SSR_INPUT_IS_GAMMA_SPACE\ncolor=toLinearSpace(color);\r#endif\nvec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);\rvec3 colorMultiplier=1.0-reflectionMultiplier;\rvec3 finalColor=(color.rgb*colorMultiplier)+(SSR*reflectionMultiplier);\r#ifdef SSR_OUTPUT_IS_GAMMA_SPACE\nfinalColor=toGammaSpace(finalColor);\r#endif\ngl_FragColor=vec4(finalColor,color.a);\r#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const screenSpaceReflection2BlurCombinerPixelShader = { name, shader };\n"]}
+{"version":3,"file":"screenSpaceReflection2BlurCombiner.fragment.js","sourceRoot":"","sources":["../../../../lts/core/generated/Shaders/screenSpaceReflection2BlurCombiner.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,mCAAmC,CAAC;AAC3C,OAAO,sCAAsC,CAAC;AAE9C,MAAM,IAAI,GAAG,+CAA+C,CAAC;AAC7D,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,6CAA6C,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/pbrBRDFFunctions\";\nimport \"./ShadersInclude/screenSpaceRayTrace\";\n\nconst name = \"screenSpaceReflection2BlurCombinerPixelShader\";\nconst shader = `uniform sampler2D textureSampler; \runiform sampler2D mainSampler;\runiform sampler2D reflectivitySampler;\runiform float strength;\runiform float reflectionSpecularFalloffExponent;\runiform float reflectivityThreshold;\rvarying vec2 vUV;\r#include<helperFunctions>\n#ifdef SSR_BLEND_WITH_FRESNEL\n#include<pbrBRDFFunctions>\n#include<screenSpaceRayTrace>\nuniform mat4 projection;\runiform mat4 invProjectionMatrix;\runiform sampler2D normalSampler;\runiform sampler2D depthSampler;\r#endif\nvoid main()\r{\r#ifdef SSRAYTRACE_DEBUG\ngl_FragColor=texture2D(textureSampler,vUV);\r#else\nvec3 SSR=texture2D(textureSampler,vUV).rgb;\rvec4 color=texture2D(mainSampler,vUV);\rvec4 reflectivity=texture2D(reflectivitySampler,vUV);\r#ifndef SSR_DISABLE_REFLECTIVITY_TEST\nif (max(reflectivity.r,max(reflectivity.g,reflectivity.b))<=reflectivityThreshold) {\rgl_FragColor=color;\rreturn;\r}\r#endif\n#ifdef SSR_INPUT_IS_GAMMA_SPACE\ncolor=toLinearSpace(color);\r#endif\n#ifdef SSR_BLEND_WITH_FRESNEL\nvec2 texSize=vec2(textureSize(depthSampler,0));\rvec3 csNormal=texelFetch(normalSampler,ivec2(vUV*texSize),0).xyz;\rfloat depth=texelFetch(depthSampler,ivec2(vUV*texSize),0).r;\rvec3 csPosition=computeViewPosFromUVDepth(vUV,depth,projection,invProjectionMatrix);\rvec3 csViewDirection=normalize(csPosition);\rvec3 F0=reflectivity.rgb;\rvec3 fresnel=fresnelSchlickGGX(max(dot(csNormal,-csViewDirection),0.0),F0,vec3(1.));\rvec3 reflectionMultiplier=clamp(pow(fresnel*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);\r#else\nvec3 reflectionMultiplier=clamp(pow(reflectivity.rgb*strength,vec3(reflectionSpecularFalloffExponent)),0.0,1.0);\r#endif\nvec3 colorMultiplier=1.0-reflectionMultiplier;\rvec3 finalColor=(color.rgb*colorMultiplier)+(SSR*reflectionMultiplier);\r#ifdef SSR_OUTPUT_IS_GAMMA_SPACE\nfinalColor=toGammaSpace(finalColor);\r#endif\ngl_FragColor=vec4(finalColor,color.a);\r#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const screenSpaceReflection2BlurCombinerPixelShader = { name, shader };\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@babylonjs/core",
-    "version": "6.5.0",
+    "version": "6.6.0",
     "main": "index.js",
     "module": "index.js",
     "types": "index.d.ts",

package/scene.js

@@ -1517,22 +1517,12 @@ export class Scene extends AbstractScene {
                 }
             }
         }
-        if (!isReady) {
-            engine.currentRenderPassId = currentRenderPassId;
-            return false;
-        }
-        // Effects
-        if (!engine.areAllEffectsReady()) {
-            engine.currentRenderPassId = currentRenderPassId;
-            return false;
-        }
         // Render targets
         if (checkRenderTargets) {
             for (index = 0; index < this._materialsRenderTargets.length; ++index) {
                 const rtt = this._materialsRenderTargets.data[index];
                 if (!rtt.isReadyForRendering()) {
-                    engine.currentRenderPassId = currentRenderPassId;
-                    return false;
+                    isReady = false;
                 }
             }
         }
@@ -1540,34 +1530,42 @@ export class Scene extends AbstractScene {
         for (index = 0; index < this.geometries.length; index++) {
             const geometry = this.geometries[index];
             if (geometry.delayLoadState === 2) {
-                engine.currentRenderPassId = currentRenderPassId;
-                return false;
+                isReady = false;
             }
         }
         // Post-processes
         if (this.activeCameras && this.activeCameras.length > 0) {
             for (const camera of this.activeCameras) {
                 if (!camera.isReady(true)) {
-                    engine.currentRenderPassId = currentRenderPassId;
-                    return false;
+                    isReady = false;
                 }
             }
         }
         else if (this.activeCamera) {
             if (!this.activeCamera.isReady(true)) {
-                engine.currentRenderPassId = currentRenderPassId;
-                return false;
+                isReady = false;
             }
         }
         // Particles
         for (const particleSystem of this.particleSystems) {
             if (!particleSystem.isReady()) {
-                engine.currentRenderPassId = currentRenderPassId;
-                return false;
+                isReady = false;
+            }
+        }
+        // Layers
+        if (this.layers) {
+            for (const layer of this.layers) {
+                if (!layer.isReady()) {
+                    isReady = false;
+                }
             }
         }
+        // Effects
+        if (!engine.areAllEffectsReady()) {
+            isReady = false;
+        }
         engine.currentRenderPassId = currentRenderPassId;
-        return true;
+        return isReady;
     }
     /** Resets all cached information relative to material (including effect and visibility) */
     resetCachedMaterial() {