@babylonjs/core 5.23.0 → 5.25.0

package/Shaders/screenSpaceReflection.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"screenSpaceReflection.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/screenSpaceReflection.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,kCAAkC,CAAC;AAChD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,gCAAgC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"screenSpaceReflectionPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\r#ifdef SSR_SUPPORTED\nuniform sampler2D reflectivitySampler;\runiform sampler2D normalSampler;\runiform sampler2D positionSampler;\r#endif\nuniform mat4 view;\runiform mat4 projection;\runiform float stepSize;\runiform float strength;\runiform float threshold;\runiform float roughnessFactor;\runiform float reflectionSpecularFalloffExponent;\rvarying vec2 vUV;\r#ifdef SSR_SUPPORTED\nstruct ReflectionInfo {\rvec3 color;\rvec4 coords;\r};\r/**\r* According to specular,see https:\r*/\rvec3 fresnelSchlick(float cosTheta,vec3 F0)\r{\rreturn F0+(1.0-F0)*pow(1.0-cosTheta,5.0);\r}\r/**\r* Once the pixel's coordinates has been found,let's adjust (smooth) a little bit\r* by sampling multiple reflection pixels.\r*/\rReflectionInfo smoothReflectionInfo(vec3 dir,vec3 hitCoord)\r{\rReflectionInfo info;\rinfo.color=vec3(0.0);\rvec4 projectedCoord;\rfloat sampledDepth;\rfor(int i=0; i<SMOOTH_STEPS; i++)\r{\rprojectedCoord=projection*vec4(hitCoord,1.0);\rprojectedCoord.xy/=projectedCoord.w;\rprojectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);\rsampledDepth=(view*texture2D(positionSampler,projectedCoord.xy)).z;\rfloat depth=sampledDepth-hitCoord.z;\rdir*=0.5;\rif(depth>0.0)\rhitCoord-=dir;\relse\rhitCoord+=dir;\rinfo.color+=texture2D(textureSampler,projectedCoord.xy).rgb;\r}\rprojectedCoord=projection*vec4(hitCoord,1.0);\rprojectedCoord.xy/=projectedCoord.w;\rprojectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);\rinfo.coords=vec4(projectedCoord.xy,sampledDepth,1.0);\rinfo.color+=texture2D(textureSampler,projectedCoord.xy).rgb;\rinfo.color/=float(SMOOTH_STEPS+1);\rreturn info;\r}\r/**\r* Tests the given world position (hitCoord) according to the given reflection vector (dir)\r* until it finds a collision (means that depth is enough close to say \"it's the pixel to sample!\").\r*/\rReflectionInfo getReflectionInfo(vec3 dir,vec3 hitCoord)\r{\rReflectionInfo info;\rvec4 projectedCoord;\rfloat sampledDepth;\rdir*=stepSize;\rfor(int i=0; i<REFLECTION_SAMPLES; i++)\r{\rhitCoord+=dir;\rprojectedCoord=projection*vec4(hitCoord,1.0);\rprojectedCoord.xy/=projectedCoord.w;\rprojectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);\rsampledDepth=(view*texture2D(positionSampler,projectedCoord.xy)).z;\rfloat depth=sampledDepth-hitCoord.z;\r#ifdef RIGHT_HANDED_SCENE\ndepth*=-1.0;\r#endif\nif(((depth-dir.z)<threshold) && depth<=0.0)\r{\r#ifdef ENABLE_SMOOTH_REFLECTIONS\nreturn smoothReflectionInfo(dir,hitCoord);\r#else\ninfo.color=texture2D(textureSampler,projectedCoord.xy).rgb;\rinfo.coords=vec4(projectedCoord.xy,sampledDepth,0.0);\rreturn info;\r#endif\n}\r}\rinfo.color=texture2D(textureSampler,projectedCoord.xy).rgb;\rinfo.coords=vec4(projectedCoord.xy,sampledDepth,0.0);\rreturn info;\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}\r#endif\nvoid main()\r{\r#ifdef SSR_SUPPORTED\nvec4 albedoFull=texture2D(textureSampler,vUV);\rvec3 albedo=albedoFull.rgb;\rfloat spec=texture2D(reflectivitySampler,vUV).r;\rif (spec==0.0) {\rgl_FragColor=albedoFull;\rreturn;\r}\rvec3 normal=(texture2D(normalSampler,vUV)).xyz;\rvec3 position=(view*texture2D(positionSampler,vUV)).xyz;\rvec3 reflected=normalize(reflect(normalize(position),normalize(normal)));\rfloat roughness=1.0-texture2D(reflectivitySampler,vUV).a;\rvec3 jitt=mix(vec3(0.0),hash(position),roughness)*roughnessFactor;\rReflectionInfo info=getReflectionInfo(jitt+reflected,position);\rvec2 dCoords=smoothstep(0.2,0.6,abs(vec2(0.5,0.5)-info.coords.xy));\rfloat screenEdgefactor=clamp(1.0-(dCoords.x+dCoords.y),0.0,1.0);\rvec3 F0=vec3(0.04);\rF0 =mix(F0,albedo,spec);\rvec3 fresnel=fresnelSchlick(max(dot(normalize(normal),normalize(position)),0.0),F0);\r#ifdef RIGHT_HANDED_SCENE\nreflected.z*=-1.0;\r#endif\nfloat reflectionMultiplier=clamp(pow(spec*strength,reflectionSpecularFalloffExponent)*screenEdgefactor*reflected.z,0.0,0.9);\rfloat albedoMultiplier=1.0-reflectionMultiplier;\rvec3 SSR=info.color*fresnel;\rgl_FragColor=vec4((albedo*albedoMultiplier)+(SSR*reflectionMultiplier),albedoFull.a);\r#else\ngl_FragColor=texture2D(textureSampler,vUV);\r#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const screenSpaceReflectionPixelShader = { name, shader };\n"]}
+{"version":3,"file":"screenSpaceReflection.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/screenSpaceReflection.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,kCAAkC,CAAC;AAChD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,gCAAgC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"screenSpaceReflectionPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\r#ifdef SSR_SUPPORTED\nuniform sampler2D reflectivitySampler;\runiform sampler2D normalSampler;\runiform sampler2D positionSampler;\r#endif\nuniform mat4 view;\runiform mat4 projection;\runiform float stepSize;\runiform float strength;\runiform float threshold;\runiform float roughnessFactor;\runiform float reflectionSpecularFalloffExponent;\rvarying vec2 vUV;\r#ifdef SSR_SUPPORTED\nstruct ReflectionInfo {\rvec3 color;\rvec4 coords;\r};\r/**\r* According to specular,see https:\r*/\rvec3 fresnelSchlick(float cosTheta,vec3 F0)\r{\rreturn F0+(1.0-F0)*pow(1.0-cosTheta,5.0);\r}\r/**\r* Once the pixel's coordinates has been found,let's adjust (smooth) a little bit\r* by sampling multiple reflection pixels.\r*/\rReflectionInfo smoothReflectionInfo(vec3 dir,vec3 hitCoord)\r{\rReflectionInfo info;\rinfo.color=vec3(0.0);\rvec4 projectedCoord;\rfloat sampledDepth;\rfor(int i=0; i<SMOOTH_STEPS; i++)\r{\rprojectedCoord=projection*vec4(hitCoord,1.0);\rprojectedCoord.xy/=projectedCoord.w;\rprojectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);\rsampledDepth=(view*texture2D(positionSampler,projectedCoord.xy)).z;\rfloat depth=sampledDepth-hitCoord.z;\rdir*=0.5;\rif(depth>0.0)\rhitCoord-=dir;\relse\rhitCoord+=dir;\rinfo.color+=texture2D(textureSampler,projectedCoord.xy).rgb;\r}\rprojectedCoord=projection*vec4(hitCoord,1.0);\rprojectedCoord.xy/=projectedCoord.w;\rprojectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);\rinfo.coords=vec4(projectedCoord.xy,sampledDepth,1.0);\rinfo.color+=texture2D(textureSampler,projectedCoord.xy).rgb;\rinfo.color/=float(SMOOTH_STEPS+1);\rreturn info;\r}\r/**\r* Tests the given world position (hitCoord) according to the given reflection vector (dir)\r* until it finds a collision (means that depth is enough close to say \"it's the pixel to sample!\").\r*/\rReflectionInfo getReflectionInfo(vec3 dir,vec3 hitCoord)\r{\rReflectionInfo info;\rvec4 projectedCoord;\rfloat sampledDepth;\rdir*=stepSize;\rfor(int i=0; i<REFLECTION_SAMPLES; i++)\r{\rhitCoord+=dir;\rprojectedCoord=projection*vec4(hitCoord,1.0);\rprojectedCoord.xy/=projectedCoord.w;\rprojectedCoord.xy=0.5*projectedCoord.xy+vec2(0.5);\rsampledDepth=(view*texture2D(positionSampler,projectedCoord.xy)).z;\rfloat depth=sampledDepth-hitCoord.z;\r#ifdef RIGHT_HANDED_SCENE\ndepth*=-1.0;\r#endif\nif(((depth-dir.z)<threshold) && depth<=0.0)\r{\r#ifdef ENABLE_SMOOTH_REFLECTIONS\nreturn smoothReflectionInfo(dir,hitCoord);\r#else\ninfo.color=texture2D(textureSampler,projectedCoord.xy).rgb;\rinfo.coords=vec4(projectedCoord.xy,sampledDepth,0.0);\rreturn info;\r#endif\n}\r}\rinfo.color=texture2D(textureSampler,projectedCoord.xy).rgb;\rinfo.coords=vec4(projectedCoord.xy,sampledDepth,0.0);\rreturn info;\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}\r#endif\nvoid main()\r{\r#ifdef SSR_SUPPORTED\nvec4 albedoFull=texture2D(textureSampler,vUV);\rvec3 albedo=albedoFull.rgb;\rfloat spec=texture2D(reflectivitySampler,vUV).r;\rif (spec==0.0) {\rgl_FragColor=albedoFull;\rreturn;\r}\rvec3 normal=(texture2D(normalSampler,vUV)).xyz;\rvec3 position=(view*texture2D(positionSampler,vUV)).xyz;\rvec3 reflected=normalize(reflect(normalize(position),normalize(normal)));\rfloat roughness=1.0-texture2D(reflectivitySampler,vUV).a;\rvec3 jitt=mix(vec3(0.0),hash(position),roughness)*roughnessFactor;\rReflectionInfo info=getReflectionInfo(jitt+reflected,position);\rvec2 dCoords=smoothstep(0.2,0.6,abs(vec2(0.5,0.5)-info.coords.xy));\rfloat screenEdgefactor=clamp(1.0-(dCoords.x+dCoords.y),0.0,1.0);\rvec3 F0=vec3(0.04);\rF0 =mix(F0,albedo,spec);\rvec3 fresnel=fresnelSchlick(max(dot(normalize(normal),normalize(position)),0.0),F0);\r#ifdef RIGHT_HANDED_SCENE\nreflected.z*=-1.0;\r#endif\nfloat reflectionMultiplier=clamp(pow(spec*strength,reflectionSpecularFalloffExponent)*screenEdgefactor*reflected.z,0.0,0.9);\rfloat albedoMultiplier=1.0-reflectionMultiplier;\rvec3 SSR=info.color*fresnel;\rgl_FragColor=vec4((albedo*albedoMultiplier)+(SSR*reflectionMultiplier),albedoFull.a);\r#else\ngl_FragColor=texture2D(textureSampler,vUV);\r#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const screenSpaceReflectionPixelShader = { name, shader };\n"]}

package/Shaders/shadowMap.fragment.d.ts

@@ -2,7 +2,7 @@ import "./ShadersInclude/shadowMapFragmentExtraDeclaration";
 import "./ShadersInclude/clipPlaneFragmentDeclaration";
 import "./ShadersInclude/clipPlaneFragment";
 import "./ShadersInclude/shadowMapFragment";
-/** @hidden */
+/** @internal */
 export declare const shadowMapPixelShader: {
     name: string;
     shader: string;

package/Shaders/shadowMap.fragment.js

@@ -22,6 +22,6 @@ if ((bayerDither8(floor(mod(gl_FragCoord.xy,8.0))))/64.0>=softTransparentShadowS
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const shadowMapPixelShader = { name, shader };
 //# sourceMappingURL=shadowMap.fragment.js.map

package/Shaders/shadowMap.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadowMap.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/shadowMap.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,oDAAoD,CAAC;AAC5D,OAAO,+CAA+C,CAAC;AACvD,OAAO,oCAAoC,CAAC;AAC5C,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;EAuBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/shadowMapFragmentExtraDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\nimport \"./ShadersInclude/shadowMapFragment\";\n\nconst name = \"shadowMapPixelShader\";\nconst shader = `#include<shadowMapFragmentExtraDeclaration>\n#ifdef ALPHATEST\nvarying vec2 vUV;\runiform sampler2D diffuseSampler;\r#endif\n#include<clipPlaneFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\r#include<clipPlaneFragment>\n#ifdef ALPHATEST\nfloat alphaFromAlphaTexture=texture2D(diffuseSampler,vUV).a;\rif (alphaFromAlphaTexture<ALPHATESTVALUE)\rdiscard;\r#endif\n#if SM_SOFTTRANSPARENTSHADOW==1\n#ifdef ALPHATEST\nif ((bayerDither8(floor(mod(gl_FragCoord.xy,8.0))))/64.0>=softTransparentShadowSM*alphaFromAlphaTexture) discard;\r#else\nif ((bayerDither8(floor(mod(gl_FragCoord.xy,8.0))))/64.0>=softTransparentShadowSM) discard;\r#endif\n#endif\n#include<shadowMapFragment>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const shadowMapPixelShader = { name, shader };\n"]}
+{"version":3,"file":"shadowMap.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/shadowMap.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,oDAAoD,CAAC;AAC5D,OAAO,+CAA+C,CAAC;AACvD,OAAO,oCAAoC,CAAC;AAC5C,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;EAuBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/shadowMapFragmentExtraDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\nimport \"./ShadersInclude/shadowMapFragment\";\n\nconst name = \"shadowMapPixelShader\";\nconst shader = `#include<shadowMapFragmentExtraDeclaration>\n#ifdef ALPHATEST\nvarying vec2 vUV;\runiform sampler2D diffuseSampler;\r#endif\n#include<clipPlaneFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\r#include<clipPlaneFragment>\n#ifdef ALPHATEST\nfloat alphaFromAlphaTexture=texture2D(diffuseSampler,vUV).a;\rif (alphaFromAlphaTexture<ALPHATESTVALUE)\rdiscard;\r#endif\n#if SM_SOFTTRANSPARENTSHADOW==1\n#ifdef ALPHATEST\nif ((bayerDither8(floor(mod(gl_FragCoord.xy,8.0))))/64.0>=softTransparentShadowSM*alphaFromAlphaTexture) discard;\r#else\nif ((bayerDither8(floor(mod(gl_FragCoord.xy,8.0))))/64.0>=softTransparentShadowSM) discard;\r#endif\n#endif\n#include<shadowMapFragment>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const shadowMapPixelShader = { name, shader };\n"]}

package/Shaders/shadowMap.vertex.d.ts

@@ -15,7 +15,7 @@ import "./ShadersInclude/bakedVertexAnimation";
 import "./ShadersInclude/shadowMapVertexNormalBias";
 import "./ShadersInclude/shadowMapVertexMetric";
 import "./ShadersInclude/clipPlaneVertex";
-/** @hidden */
+/** @internal */
 export declare const shadowMapVertexShader: {
     name: string;
     shader: string;

package/Shaders/shadowMap.vertex.js

@@ -65,6 +65,6 @@ vUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const shadowMapVertexShader = { name, shader };
 //# sourceMappingURL=shadowMap.vertex.js.map

package/Shaders/shadowMap.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadowMap.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/shadowMap.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,mCAAmC,CAAC;AAC3C,OAAO,kDAAkD,CAAC;AAC1D,OAAO,sDAAsD,CAAC;AAC9D,OAAO,gDAAgD,CAAC;AACxD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,6CAA6C,CAAC;AACrD,OAAO,0CAA0C,CAAC;AAClD,OAAO,kDAAkD,CAAC;AAC1D,OAAO,6CAA6C,CAAC;AACrD,OAAO,2CAA2C,CAAC;AACnD,OAAO,qCAAqC,CAAC;AAC7C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,8BAA8B,CAAC;AACtC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,4CAA4C,CAAC;AACpD,OAAO,wCAAwC,CAAC;AAChD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoEb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/bonesDeclaration\";\nimport \"./ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobalDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/shadowMapVertexDeclaration\";\nimport \"./ShadersInclude/shadowMapUboDeclaration\";\nimport \"./ShadersInclude/shadowMapVertexExtraDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobal\";\nimport \"./ShadersInclude/morphTargetsVertex\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/bonesVertex\";\nimport \"./ShadersInclude/bakedVertexAnimation\";\nimport \"./ShadersInclude/shadowMapVertexNormalBias\";\nimport \"./ShadersInclude/shadowMapVertexMetric\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"shadowMapVertexShader\";\nconst shader = `attribute vec3 position;\r#ifdef NORMAL\nattribute vec3 normal;\r#endif\n#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<morphTargetsVertexGlobalDeclaration>\n#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]\n#ifdef INSTANCES\nattribute vec4 world0;\rattribute vec4 world1;\rattribute vec4 world2;\rattribute vec4 world3;\r#endif\n#include<helperFunctions>\n#include<__decl__shadowMapVertex>\n#ifdef ALPHATEST\nvarying vec2 vUV;\runiform mat4 diffuseMatrix;\r#ifdef UV1\nattribute vec2 uv;\r#endif\n#ifdef UV2\nattribute vec2 uv2;\r#endif\n#endif\n#include<shadowMapVertexExtraDeclaration>\n#include<clipPlaneVertexDeclaration>\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void)\r{\rvec3 positionUpdated=position;\r#ifdef UV1\nvec2 uvUpdated=uv;\r#endif\n#ifdef NORMAL\nvec3 normalUpdated=normal;\r#endif\n#include<morphTargetsVertexGlobal>\n#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 worldPos=finalWorld*vec4(positionUpdated,1.0);\r#ifdef NORMAL\nmat3 normWorldSM=mat3(finalWorld);\r#if defined(INSTANCES) && defined(THIN_INSTANCES)\nvec3 vNormalW=normalUpdated/vec3(dot(normWorldSM[0],normWorldSM[0]),dot(normWorldSM[1],normWorldSM[1]),dot(normWorldSM[2],normWorldSM[2]));\rvNormalW=normalize(normWorldSM*vNormalW);\r#else\n#ifdef NONUNIFORMSCALING\nnormWorldSM=transposeMat3(inverseMat3(normWorldSM));\r#endif\nvec3 vNormalW=normalize(normWorldSM*normalUpdated);\r#endif\n#endif\n#include<shadowMapVertexNormalBias>\ngl_Position=viewProjection*worldPos;\r#include<shadowMapVertexMetric>\n#ifdef ALPHATEST\n#ifdef UV1\nvUV=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef UV2\nvUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#include<clipPlaneVertex>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const shadowMapVertexShader = { name, shader };\n"]}
+{"version":3,"file":"shadowMap.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/shadowMap.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,mCAAmC,CAAC;AAC3C,OAAO,kDAAkD,CAAC;AAC1D,OAAO,sDAAsD,CAAC;AAC9D,OAAO,gDAAgD,CAAC;AACxD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,6CAA6C,CAAC;AACrD,OAAO,0CAA0C,CAAC;AAClD,OAAO,kDAAkD,CAAC;AAC1D,OAAO,6CAA6C,CAAC;AACrD,OAAO,2CAA2C,CAAC;AACnD,OAAO,qCAAqC,CAAC;AAC7C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,8BAA8B,CAAC;AACtC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,4CAA4C,CAAC;AACpD,OAAO,wCAAwC,CAAC;AAChD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoEb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/bonesDeclaration\";\nimport \"./ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobalDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/shadowMapVertexDeclaration\";\nimport \"./ShadersInclude/shadowMapUboDeclaration\";\nimport \"./ShadersInclude/shadowMapVertexExtraDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobal\";\nimport \"./ShadersInclude/morphTargetsVertex\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/bonesVertex\";\nimport \"./ShadersInclude/bakedVertexAnimation\";\nimport \"./ShadersInclude/shadowMapVertexNormalBias\";\nimport \"./ShadersInclude/shadowMapVertexMetric\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"shadowMapVertexShader\";\nconst shader = `attribute vec3 position;\r#ifdef NORMAL\nattribute vec3 normal;\r#endif\n#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<morphTargetsVertexGlobalDeclaration>\n#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]\n#ifdef INSTANCES\nattribute vec4 world0;\rattribute vec4 world1;\rattribute vec4 world2;\rattribute vec4 world3;\r#endif\n#include<helperFunctions>\n#include<__decl__shadowMapVertex>\n#ifdef ALPHATEST\nvarying vec2 vUV;\runiform mat4 diffuseMatrix;\r#ifdef UV1\nattribute vec2 uv;\r#endif\n#ifdef UV2\nattribute vec2 uv2;\r#endif\n#endif\n#include<shadowMapVertexExtraDeclaration>\n#include<clipPlaneVertexDeclaration>\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void)\r{\rvec3 positionUpdated=position;\r#ifdef UV1\nvec2 uvUpdated=uv;\r#endif\n#ifdef NORMAL\nvec3 normalUpdated=normal;\r#endif\n#include<morphTargetsVertexGlobal>\n#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 worldPos=finalWorld*vec4(positionUpdated,1.0);\r#ifdef NORMAL\nmat3 normWorldSM=mat3(finalWorld);\r#if defined(INSTANCES) && defined(THIN_INSTANCES)\nvec3 vNormalW=normalUpdated/vec3(dot(normWorldSM[0],normWorldSM[0]),dot(normWorldSM[1],normWorldSM[1]),dot(normWorldSM[2],normWorldSM[2]));\rvNormalW=normalize(normWorldSM*vNormalW);\r#else\n#ifdef NONUNIFORMSCALING\nnormWorldSM=transposeMat3(inverseMat3(normWorldSM));\r#endif\nvec3 vNormalW=normalize(normWorldSM*normalUpdated);\r#endif\n#endif\n#include<shadowMapVertexNormalBias>\ngl_Position=viewProjection*worldPos;\r#include<shadowMapVertexMetric>\n#ifdef ALPHATEST\n#ifdef UV1\nvUV=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef UV2\nvUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#include<clipPlaneVertex>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const shadowMapVertexShader = { name, shader };\n"]}

package/Shaders/sharpen.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const sharpenPixelShader: {
     name: string;
     shader: string;

package/Shaders/sharpen.fragment.js

@@ -5,6 +5,6 @@ const shader = `varying vec2 vUV;
 void main(void)
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const sharpenPixelShader = { name, shader };
 //# sourceMappingURL=sharpen.fragment.js.map

package/Shaders/sharpen.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"sharpen.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/sharpen.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;EAeb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"sharpenPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec2 screenSize;\runiform vec2 sharpnessAmounts;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rvec2 onePixel=vec2(1.0,1.0)/screenSize;\rvec4 color=texture2D(textureSampler,vUV);\rvec4 edgeDetection=texture2D(textureSampler,vUV+onePixel*vec2(0,-1)) +\rtexture2D(textureSampler,vUV+onePixel*vec2(-1,0)) +\rtexture2D(textureSampler,vUV+onePixel*vec2(1,0)) +\rtexture2D(textureSampler,vUV+onePixel*vec2(0,1)) -\rcolor*4.0;\rgl_FragColor=max(vec4(color.rgb*sharpnessAmounts.y,color.a)-(sharpnessAmounts.x*vec4(edgeDetection.rgb,0)),0.);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const sharpenPixelShader = { name, shader };\n"]}
+{"version":3,"file":"sharpen.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/sharpen.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;EAeb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,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 = \"sharpenPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec2 screenSize;\runiform vec2 sharpnessAmounts;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rvec2 onePixel=vec2(1.0,1.0)/screenSize;\rvec4 color=texture2D(textureSampler,vUV);\rvec4 edgeDetection=texture2D(textureSampler,vUV+onePixel*vec2(0,-1)) +\rtexture2D(textureSampler,vUV+onePixel*vec2(-1,0)) +\rtexture2D(textureSampler,vUV+onePixel*vec2(1,0)) +\rtexture2D(textureSampler,vUV+onePixel*vec2(0,1)) -\rcolor*4.0;\rgl_FragColor=max(vec4(color.rgb*sharpnessAmounts.y,color.a)-(sharpnessAmounts.x*vec4(edgeDetection.rgb,0)),0.);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const sharpenPixelShader = { name, shader };\n"]}

package/Shaders/spriteMap.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const spriteMapPixelShader: {
     name: string;
     shader: string;

package/Shaders/spriteMap.fragment.js

@@ -7,6 +7,6 @@ vec2 tileID=floor(tUV);
 vec4 animationData=texture2D(animationMap,vec2((frameID+0.5)/spriteCount,0.),0.);
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const spriteMapPixelShader = { name, shader };
 //# sourceMappingURL=spriteMap.fragment.js.map

package/Shaders/spriteMap.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"spriteMap.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/spriteMap.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoEb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"spriteMapPixelShader\";\nconst shader = `precision highp float;\rvarying vec3 vPosition;\rvarying vec2 vUV;\rvarying vec2 tUV;\runiform float time;\runiform float spriteCount;\runiform sampler2D spriteSheet;\runiform vec2 spriteMapSize;\runiform vec2 outputSize;\runiform vec2 stageSize;\runiform sampler2D frameMap;\runiform sampler2D tileMaps[LAYERS];\runiform sampler2D animationMap;\runiform vec3 colorMul;\rfloat mt;\rconst float fdStep=1./4.;\rconst float aFrameSteps=1./MAX_ANIMATION_FRAMES;\rmat4 getFrameData(float frameID){\rfloat fX=frameID/spriteCount;\rreturn mat4(\rtexture2D(frameMap,vec2(fX,0.),0.),\rtexture2D(frameMap,vec2(fX,fdStep*1.),0.),\rtexture2D(frameMap,vec2(fX,fdStep*2.),0.),\rvec4(0.)\r);\r}\rvoid main(){\rvec4 color=vec4(0.);\rvec2 tileUV=fract(tUV);\r#ifdef FLIPU\ntileUV.y=1.0-tileUV.y;\r#endif\nvec2 tileID=floor(tUV);\rvec2 sheetUnits=1./spriteMapSize;\rfloat spriteUnits=1./spriteCount;\rvec2 stageUnits=1./stageSize;\rfor(int i=0; i<LAYERS; i++) {\rfloat frameID;\r#define LAYER_ID_SWITCH\nvec4 animationData=texture2D(animationMap,vec2((frameID+0.5)/spriteCount,0.),0.);\rif(animationData.y>0.) {\rmt=mod(time*animationData.z,1.0);\rfor(float f=0.; f<MAX_ANIMATION_FRAMES; f++){\rif(animationData.y>mt){\rframeID=animationData.x;\rbreak;\r}\ranimationData=texture2D(animationMap,vec2((frameID+0.5)/spriteCount,aFrameSteps*f),0.);\r}\r}\rmat4 frameData=getFrameData(frameID+0.5);\rvec2 frameSize=(frameData[0].zw)/spriteMapSize;\rvec2 offset=frameData[0].xy*sheetUnits;\rvec2 ratio=frameData[2].xy/frameData[0].zw;\rif (frameData[2].z==1.){\rtileUV.xy=tileUV.yx;\r}\rif (i==0){\rcolor=texture2D(spriteSheet,tileUV*frameSize+offset);\r} else {\rvec4 nc=texture2D(spriteSheet,tileUV*frameSize+offset);\rfloat alpha=min(color.a+nc.a,1.0);\rvec3 mixed=mix(color.xyz,nc.xyz,nc.a);\rcolor=vec4(mixed,alpha);\r}\r}\rcolor.xyz*=colorMul;\rgl_FragColor=color;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const spriteMapPixelShader = { name, shader };\n"]}
+{"version":3,"file":"spriteMap.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/spriteMap.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoEb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"spriteMapPixelShader\";\nconst shader = `precision highp float;\rvarying vec3 vPosition;\rvarying vec2 vUV;\rvarying vec2 tUV;\runiform float time;\runiform float spriteCount;\runiform sampler2D spriteSheet;\runiform vec2 spriteMapSize;\runiform vec2 outputSize;\runiform vec2 stageSize;\runiform sampler2D frameMap;\runiform sampler2D tileMaps[LAYERS];\runiform sampler2D animationMap;\runiform vec3 colorMul;\rfloat mt;\rconst float fdStep=1./4.;\rconst float aFrameSteps=1./MAX_ANIMATION_FRAMES;\rmat4 getFrameData(float frameID){\rfloat fX=frameID/spriteCount;\rreturn mat4(\rtexture2D(frameMap,vec2(fX,0.),0.),\rtexture2D(frameMap,vec2(fX,fdStep*1.),0.),\rtexture2D(frameMap,vec2(fX,fdStep*2.),0.),\rvec4(0.)\r);\r}\rvoid main(){\rvec4 color=vec4(0.);\rvec2 tileUV=fract(tUV);\r#ifdef FLIPU\ntileUV.y=1.0-tileUV.y;\r#endif\nvec2 tileID=floor(tUV);\rvec2 sheetUnits=1./spriteMapSize;\rfloat spriteUnits=1./spriteCount;\rvec2 stageUnits=1./stageSize;\rfor(int i=0; i<LAYERS; i++) {\rfloat frameID;\r#define LAYER_ID_SWITCH\nvec4 animationData=texture2D(animationMap,vec2((frameID+0.5)/spriteCount,0.),0.);\rif(animationData.y>0.) {\rmt=mod(time*animationData.z,1.0);\rfor(float f=0.; f<MAX_ANIMATION_FRAMES; f++){\rif(animationData.y>mt){\rframeID=animationData.x;\rbreak;\r}\ranimationData=texture2D(animationMap,vec2((frameID+0.5)/spriteCount,aFrameSteps*f),0.);\r}\r}\rmat4 frameData=getFrameData(frameID+0.5);\rvec2 frameSize=(frameData[0].zw)/spriteMapSize;\rvec2 offset=frameData[0].xy*sheetUnits;\rvec2 ratio=frameData[2].xy/frameData[0].zw;\rif (frameData[2].z==1.){\rtileUV.xy=tileUV.yx;\r}\rif (i==0){\rcolor=texture2D(spriteSheet,tileUV*frameSize+offset);\r} else {\rvec4 nc=texture2D(spriteSheet,tileUV*frameSize+offset);\rfloat alpha=min(color.a+nc.a,1.0);\rvec3 mixed=mix(color.xyz,nc.xyz,nc.a);\rcolor=vec4(mixed,alpha);\r}\r}\rcolor.xyz*=colorMul;\rgl_FragColor=color;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const spriteMapPixelShader = { name, shader };\n"]}

package/Shaders/spriteMap.vertex.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const spriteMapVertexShader: {
     name: string;
     shader: string;

package/Shaders/spriteMap.vertex.js

@@ -4,6 +4,6 @@ const name = "spriteMapVertexShader";
 const shader = `precision highp float;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const spriteMapVertexShader = { name, shader };
 //# sourceMappingURL=spriteMap.vertex.js.map

package/Shaders/spriteMap.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"spriteMap.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/spriteMap.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;EAsBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"spriteMapVertexShader\";\nconst shader = `precision highp float;\rattribute vec3 position;\rattribute vec3 normal;\rattribute vec2 uv;\rvarying vec3 vPosition;\rvarying vec2 vUV;\rvarying vec2 tUV;\rvarying vec2 stageUnits;\rvarying vec2 levelUnits;\rvarying vec2 tileID;\runiform float time;\runiform mat4 worldViewProjection;\runiform vec2 outputSize;\runiform vec2 stageSize;\runiform vec2 spriteMapSize;\runiform float stageScale;\rvoid main() {\rvec4 p=vec4( position,1. );\rvPosition=p.xyz;\rvUV=uv;\rtUV=uv*stageSize; \rgl_Position=worldViewProjection*p;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const spriteMapVertexShader = { name, shader };\n"]}
+{"version":3,"file":"spriteMap.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/spriteMap.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;EAsBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"spriteMapVertexShader\";\nconst shader = `precision highp float;\rattribute vec3 position;\rattribute vec3 normal;\rattribute vec2 uv;\rvarying vec3 vPosition;\rvarying vec2 vUV;\rvarying vec2 tUV;\rvarying vec2 stageUnits;\rvarying vec2 levelUnits;\rvarying vec2 tileID;\runiform float time;\runiform mat4 worldViewProjection;\runiform vec2 outputSize;\runiform vec2 stageSize;\runiform vec2 spriteMapSize;\runiform float stageScale;\rvoid main() {\rvec4 p=vec4( position,1. );\rvPosition=p.xyz;\rvUV=uv;\rtUV=uv*stageSize; \rgl_Position=worldViewProjection*p;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const spriteMapVertexShader = { name, shader };\n"]}

package/Shaders/sprites.fragment.d.ts

@@ -1,7 +1,7 @@
 import "./ShadersInclude/fogFragmentDeclaration";
 import "./ShadersInclude/fogFragment";
 import "./ShadersInclude/imageProcessingCompatibility";
-/** @hidden */
+/** @internal */
 export declare const spritesPixelShader: {
     name: string;
     shader: string;

package/Shaders/sprites.fragment.js

@@ -13,6 +13,6 @@ gl_FragColor=color;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const spritesPixelShader = { name, shader };
 //# sourceMappingURL=sprites.fragment.js.map

package/Shaders/sprites.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"sprites.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/sprites.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,yCAAyC,CAAC;AACjD,OAAO,8BAA8B,CAAC;AACtC,OAAO,+CAA+C,CAAC;AAEvD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;EAmBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/fogFragmentDeclaration\";\nimport \"./ShadersInclude/fogFragment\";\nimport \"./ShadersInclude/imageProcessingCompatibility\";\n\nconst name = \"spritesPixelShader\";\nconst shader = `uniform bool alphaTest;\rvarying vec4 vColor;\rvarying vec2 vUV;\runiform sampler2D diffuseSampler;\r#include<fogFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 color=texture2D(diffuseSampler,vUV);\rif (float(alphaTest) != 0.)\r{\rif (color.a<0.95)\rdiscard;\r}\rcolor*=vColor;\r#include<fogFragment>\ngl_FragColor=color;\r#include<imageProcessingCompatibility>\n#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const spritesPixelShader = { name, shader };\n"]}
+{"version":3,"file":"sprites.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/sprites.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,yCAAyC,CAAC;AACjD,OAAO,8BAA8B,CAAC;AACtC,OAAO,+CAA+C,CAAC;AAEvD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;EAmBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/fogFragmentDeclaration\";\nimport \"./ShadersInclude/fogFragment\";\nimport \"./ShadersInclude/imageProcessingCompatibility\";\n\nconst name = \"spritesPixelShader\";\nconst shader = `uniform bool alphaTest;\rvarying vec4 vColor;\rvarying vec2 vUV;\runiform sampler2D diffuseSampler;\r#include<fogFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 color=texture2D(diffuseSampler,vUV);\rif (float(alphaTest) != 0.)\r{\rif (color.a<0.95)\rdiscard;\r}\rcolor*=vColor;\r#include<fogFragment>\ngl_FragColor=color;\r#include<imageProcessingCompatibility>\n#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const spritesPixelShader = { name, shader };\n"]}

package/Shaders/sprites.vertex.d.ts

@@ -1,5 +1,5 @@
 import "./ShadersInclude/fogVertexDeclaration";
-/** @hidden */
+/** @internal */
 export declare const spritesVertexShader: {
     name: string;
     shader: string;

package/Shaders/sprites.vertex.js

@@ -11,6 +11,6 @@ vFogDistance=viewPos;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const spritesVertexShader = { name, shader };
 //# sourceMappingURL=sprites.vertex.js.map

package/Shaders/sprites.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"sprites.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/sprites.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,uCAAuC,CAAC;AAE/C,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/fogVertexDeclaration\";\n\nconst name = \"spritesVertexShader\";\nconst shader = `attribute vec4 position;\rattribute vec2 options;\rattribute vec2 offsets;\rattribute vec2 inverts;\rattribute vec4 cellInfo;\rattribute vec4 color;\runiform mat4 view;\runiform mat4 projection;\rvarying vec2 vUV;\rvarying vec4 vColor;\r#include<fogVertexDeclaration>\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvec3 viewPos=(view*vec4(position.xyz,1.0)).xyz; \rvec2 cornerPos;\rfloat angle=position.w;\rvec2 size=vec2(options.x,options.y);\rvec2 offset=offsets.xy;\rcornerPos=vec2(offset.x-0.5,offset.y -0.5)*size;\rvec3 rotatedCorner;\rrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\rviewPos+=rotatedCorner;\rgl_Position=projection*vec4(viewPos,1.0); \rvColor=color;\rvec2 uvOffset=vec2(abs(offset.x-inverts.x),abs(1.0-offset.y-inverts.y));\rvec2 uvPlace=cellInfo.xy;\rvec2 uvSize=cellInfo.zw;\rvUV.x=uvPlace.x+uvSize.x*uvOffset.x;\rvUV.y=uvPlace.y+uvSize.y*uvOffset.y;\r#ifdef FOG\nvFogDistance=viewPos;\r#endif\n#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const spritesVertexShader = { name, shader };\n"]}
+{"version":3,"file":"sprites.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/sprites.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,uCAAuC,CAAC;AAE/C,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/fogVertexDeclaration\";\n\nconst name = \"spritesVertexShader\";\nconst shader = `attribute vec4 position;\rattribute vec2 options;\rattribute vec2 offsets;\rattribute vec2 inverts;\rattribute vec4 cellInfo;\rattribute vec4 color;\runiform mat4 view;\runiform mat4 projection;\rvarying vec2 vUV;\rvarying vec4 vColor;\r#include<fogVertexDeclaration>\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvec3 viewPos=(view*vec4(position.xyz,1.0)).xyz; \rvec2 cornerPos;\rfloat angle=position.w;\rvec2 size=vec2(options.x,options.y);\rvec2 offset=offsets.xy;\rcornerPos=vec2(offset.x-0.5,offset.y -0.5)*size;\rvec3 rotatedCorner;\rrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\rviewPos+=rotatedCorner;\rgl_Position=projection*vec4(viewPos,1.0); \rvColor=color;\rvec2 uvOffset=vec2(abs(offset.x-inverts.x),abs(1.0-offset.y-inverts.y));\rvec2 uvPlace=cellInfo.xy;\rvec2 uvSize=cellInfo.zw;\rvUV.x=uvPlace.x+uvSize.x*uvOffset.x;\rvUV.y=uvPlace.y+uvSize.y*uvOffset.y;\r#ifdef FOG\nvFogDistance=viewPos;\r#endif\n#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const spritesVertexShader = { name, shader };\n"]}

package/Shaders/ssao.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const ssaoPixelShader: {
     name: string;
     shader: string;

package/Shaders/ssao.fragment.js

@@ -6,6 +6,6 @@ uniform sampler2D randomSampler;
 `;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const ssaoPixelShader = { name, shader };
 //# sourceMappingURL=ssao.fragment.js.map

package/Shaders/ssao.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"ssao.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ssao.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"ssaoPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\rvarying vec2 vUV;\r#ifdef SSAO\nuniform sampler2D randomSampler;\runiform float randTextureTiles;\runiform float samplesFactor;\runiform vec3 sampleSphere[SAMPLES];\runiform float totalStrength;\runiform float radius;\runiform float area;\runiform float fallOff;\runiform float base;\rvec3 normalFromDepth(float depth,vec2 coords)\r{\rvec2 offset1=vec2(0.0,radius);\rvec2 offset2=vec2(radius,0.0);\rfloat depth1=texture2D(textureSampler,coords+offset1).r;\rfloat depth2=texture2D(textureSampler,coords+offset2).r;\rvec3 p1=vec3(offset1,depth1-depth);\rvec3 p2=vec3(offset2,depth2-depth);\rvec3 normal=cross(p1,p2);\rnormal.z=-normal.z;\rreturn normalize(normal);\r}\rvoid main()\r{\rvec3 random=normalize(texture2D(randomSampler,vUV*randTextureTiles).rgb);\rfloat depth=texture2D(textureSampler,vUV).r;\rvec3 position=vec3(vUV,depth);\rvec3 normal=normalFromDepth(depth,vUV);\rfloat radiusDepth=radius/depth;\rfloat occlusion=0.0;\rvec3 ray;\rvec3 hemiRay;\rfloat occlusionDepth;\rfloat difference;\rfor (int i=0; i<SAMPLES; i++)\r{\rray=radiusDepth*reflect(sampleSphere[i],random);\rhemiRay=position+sign(dot(ray,normal))*ray;\rocclusionDepth=texture2D(textureSampler,clamp(hemiRay.xy,vec2(0.001,0.001),vec2(0.999,0.999))).r;\rdifference=depth-occlusionDepth;\rocclusion+=step(fallOff,difference)*(1.0-smoothstep(fallOff,area,difference));\r}\rfloat ao=1.0-totalStrength*occlusion*samplesFactor;\rfloat result=clamp(ao+base,0.0,1.0);\rgl_FragColor.r=result;\rgl_FragColor.g=result;\rgl_FragColor.b=result;\rgl_FragColor.a=1.0;\r}\r#endif\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const ssaoPixelShader = { name, shader };\n"]}
+{"version":3,"file":"ssao.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ssao.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"ssaoPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\rvarying vec2 vUV;\r#ifdef SSAO\nuniform sampler2D randomSampler;\runiform float randTextureTiles;\runiform float samplesFactor;\runiform vec3 sampleSphere[SAMPLES];\runiform float totalStrength;\runiform float radius;\runiform float area;\runiform float fallOff;\runiform float base;\rvec3 normalFromDepth(float depth,vec2 coords)\r{\rvec2 offset1=vec2(0.0,radius);\rvec2 offset2=vec2(radius,0.0);\rfloat depth1=texture2D(textureSampler,coords+offset1).r;\rfloat depth2=texture2D(textureSampler,coords+offset2).r;\rvec3 p1=vec3(offset1,depth1-depth);\rvec3 p2=vec3(offset2,depth2-depth);\rvec3 normal=cross(p1,p2);\rnormal.z=-normal.z;\rreturn normalize(normal);\r}\rvoid main()\r{\rvec3 random=normalize(texture2D(randomSampler,vUV*randTextureTiles).rgb);\rfloat depth=texture2D(textureSampler,vUV).r;\rvec3 position=vec3(vUV,depth);\rvec3 normal=normalFromDepth(depth,vUV);\rfloat radiusDepth=radius/depth;\rfloat occlusion=0.0;\rvec3 ray;\rvec3 hemiRay;\rfloat occlusionDepth;\rfloat difference;\rfor (int i=0; i<SAMPLES; i++)\r{\rray=radiusDepth*reflect(sampleSphere[i],random);\rhemiRay=position+sign(dot(ray,normal))*ray;\rocclusionDepth=texture2D(textureSampler,clamp(hemiRay.xy,vec2(0.001,0.001),vec2(0.999,0.999))).r;\rdifference=depth-occlusionDepth;\rocclusion+=step(fallOff,difference)*(1.0-smoothstep(fallOff,area,difference));\r}\rfloat ao=1.0-totalStrength*occlusion*samplesFactor;\rfloat result=clamp(ao+base,0.0,1.0);\rgl_FragColor.r=result;\rgl_FragColor.g=result;\rgl_FragColor.b=result;\rgl_FragColor.a=1.0;\r}\r#endif\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const ssaoPixelShader = { name, shader };\n"]}

package/Shaders/ssao2.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const ssao2PixelShader: {
     name: string;
     shader: string;

package/Shaders/ssao2.fragment.js

@@ -17,6 +17,6 @@ gl_FragColor.rgb=vec3(color.r);
 `;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const ssao2PixelShader = { name, shader };
 //# sourceMappingURL=ssao2.fragment.js.map

package/Shaders/ssao2.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"ssao2.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ssao2.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkMd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"ssao2PixelShader\";\nconst shader = `precision highp float;\runiform sampler2D textureSampler;\runiform float near;\runiform float far;\runiform float radius;\rfloat scales[16]=float[16](\r0.1,\r0.11406250000000001,\r0.131640625,\r0.15625,\r0.187890625,\r0.2265625,\r0.272265625,\r0.325,\r0.384765625,\r0.4515625,\r0.525390625,\r0.60625,\r0.694140625,\r0.7890625,\r0.891015625,\r1.0\r);\rvarying vec2 vUV;\rfloat perspectiveDepthToViewZ(in float invClipZ,in float near,in float far ) {\rreturn ( near*far )/( ( far-near )*invClipZ-far );\r}\rfloat viewZToPerspectiveDepth( in float viewZ,in float near,in float far ) {\rreturn ( near*far/viewZ+far)/( far-near );\r}\rfloat viewZToOrthographicDepth( in float viewZ,in float near,in float far ) {\rreturn ( viewZ+near )/( near-far );\r}\r#ifdef SSAO\nuniform sampler2D randomSampler;\runiform sampler2D depthSampler;\runiform sampler2D normalSampler;\runiform float randTextureTiles;\runiform float samplesFactor;\runiform vec3 sampleSphere[SAMPLES];\runiform float totalStrength;\runiform float base;\runiform float xViewport;\runiform float yViewport;\runiform mat3 depthProjection;\runiform float maxZ;\runiform float minZAspect;\runiform vec2 texelSize;\runiform mat4 projection;\rvoid main()\r{\rvec3 random=texture2D(randomSampler,vUV*randTextureTiles).rgb;\rfloat depth=texture2D(depthSampler,vUV).r;\rfloat depthSign=depth/abs(depth);\rdepth=depth*depthSign;\rvec3 normal=texture2D(normalSampler,vUV).rgb;\rfloat occlusion=0.0;\rfloat correctedRadius=min(radius,minZAspect*depth/near);\rvec3 vViewRay=vec3((vUV.x*2.0-1.0)*xViewport,(vUV.y*2.0-1.0)*yViewport,depthSign);\rvec3 vDepthFactor=depthProjection*vec3(1.0,1.0,depth);\rvec3 origin=vViewRay*vDepthFactor;\rvec3 rvec=random*2.0-1.0;\rrvec.z=0.0;\rfloat dotProduct=dot(rvec,normal);\rrvec=1.0-abs(dotProduct)>1e-2 ? rvec : vec3(-rvec.y,0.0,rvec.x);\rvec3 tangent=normalize(rvec-normal*dot(rvec,normal));\rvec3 bitangent=cross(normal,tangent);\rmat3 tbn=mat3(tangent,bitangent,normal);\rfloat difference;\rfor (int i=0; i<SAMPLES; ++i) {\rvec3 samplePosition=scales[(i+int(random.x*16.0)) % 16]*tbn*sampleSphere[(i+int(random.y*16.0)) % 16];\rsamplePosition=samplePosition*correctedRadius+origin;\rvec4 offset=vec4(samplePosition,1.0);\roffset=projection*offset;\roffset.xyz/=offset.w;\roffset.xy=offset.xy*0.5+0.5;\rif (offset.x<0.0 || offset.y<0.0 || offset.x>1.0 || offset.y>1.0) {\rcontinue;\r}\rfloat sampleDepth=abs(texture2D(depthSampler,offset.xy).r);\rdifference=depthSign*samplePosition.z-sampleDepth;\rfloat rangeCheck=1.0-smoothstep(correctedRadius*0.5,correctedRadius,difference);\rocclusion+=(difference>=0.0 ? 1.0 : 0.0)*rangeCheck;\r}\rocclusion=occlusion*(1.0-smoothstep(maxZ*0.75,maxZ,depth));\rfloat ao=1.0-totalStrength*occlusion*samplesFactor;\rfloat result=clamp(ao+base,0.0,1.0);\rgl_FragColor=vec4(vec3(result),1.0);\r}\r#endif\n#ifdef BILATERAL_BLUR\nuniform sampler2D depthSampler;\runiform float outSize;\runiform float samplerOffsets[SAMPLES];\rvec4 blur9(sampler2D image,vec2 uv,float resolution,vec2 direction) {\rvec4 color=vec4(0.0);\rvec2 off1=vec2(1.3846153846)*direction;\rvec2 off2=vec2(3.2307692308)*direction;\rcolor+=texture2D(image,uv)*0.2270270270;\rcolor+=texture2D(image,uv+(off1/resolution))*0.3162162162;\rcolor+=texture2D(image,uv-(off1/resolution))*0.3162162162;\rcolor+=texture2D(image,uv+(off2/resolution))*0.0702702703;\rcolor+=texture2D(image,uv-(off2/resolution))*0.0702702703;\rreturn color;\r}\rvec4 blur13(sampler2D image,vec2 uv,float resolution,vec2 direction) {\rvec4 color=vec4(0.0);\rvec2 off1=vec2(1.411764705882353)*direction;\rvec2 off2=vec2(3.2941176470588234)*direction;\rvec2 off3=vec2(5.176470588235294)*direction;\rcolor+=texture2D(image,uv)*0.1964825501511404;\rcolor+=texture2D(image,uv+(off1/resolution))*0.2969069646728344;\rcolor+=texture2D(image,uv-(off1/resolution))*0.2969069646728344;\rcolor+=texture2D(image,uv+(off2/resolution))*0.09447039785044732;\rcolor+=texture2D(image,uv-(off2/resolution))*0.09447039785044732;\rcolor+=texture2D(image,uv+(off3/resolution))*0.010381362401148057;\rcolor+=texture2D(image,uv-(off3/resolution))*0.010381362401148057;\rreturn color;\r}\rvec4 blur13Bilateral(sampler2D image,vec2 uv,float resolution,vec2 direction) {\rvec4 color=vec4(0.0);\rvec2 off1=vec2(1.411764705882353)*direction;\rvec2 off2=vec2(3.2941176470588234)*direction;\rvec2 off3=vec2(5.176470588235294)*direction;\rfloat compareDepth=abs(texture2D(depthSampler,uv).r);\rfloat sampleDepth;\rfloat weight;\rfloat weightSum=30.0;\rcolor+=texture2D(image,uv)*30.0;\rsampleDepth=abs(texture2D(depthSampler,uv+(off1/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+= weight;\rcolor+=texture2D(image,uv+(off1/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv-(off1/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+= weight;\rcolor+=texture2D(image,uv-(off1/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv+(off2/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+=weight;\rcolor+=texture2D(image,uv+(off2/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv-(off2/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+=weight;\rcolor+=texture2D(image,uv-(off2/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv+(off3/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+=weight;\rcolor+=texture2D(image,uv+(off3/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv-(off3/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+=weight;\rcolor+=texture2D(image,uv-(off3/resolution))*weight;\rreturn color/weightSum;\r}\rvoid main()\r{\r#if EXPENSIVE\nfloat compareDepth=abs(texture2D(depthSampler,vUV).r);\rfloat texelsize=1.0/outSize;\rfloat result=0.0;\rfloat weightSum=0.0;\rfor (int i=0; i<SAMPLES; ++i)\r{\r#ifdef BILATERAL_BLUR_H\nvec2 direction=vec2(1.0,0.0);\rvec2 sampleOffset=vec2(texelsize*samplerOffsets[i],0.0);\r#else\nvec2 direction=vec2(0.0,1.0);\rvec2 sampleOffset=vec2(0.0,texelsize*samplerOffsets[i]);\r#endif\nvec2 samplePos=vUV+sampleOffset;\rfloat sampleDepth=abs(texture2D(depthSampler,samplePos).r);\rfloat weight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30000.0);\rresult+=texture2D(textureSampler,samplePos).r*weight;\rweightSum+=weight;\r}\rresult/=weightSum;\rgl_FragColor.rgb=vec3(result);\rgl_FragColor.a=1.0;\r#else\nvec4 color;\r#ifdef BILATERAL_BLUR_H\nvec2 direction=vec2(1.0,0.0);\rcolor=blur13Bilateral(textureSampler,vUV,outSize,direction);\r#else\nvec2 direction=vec2(0.0,1.0);\rcolor=blur13Bilateral(textureSampler,vUV,outSize,direction);\r#endif\ngl_FragColor.rgb=vec3(color.r);\rgl_FragColor.a=1.0;\r#endif\n}\r#endif\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const ssao2PixelShader = { name, shader };\n"]}
+{"version":3,"file":"ssao2.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ssao2.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkMd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"ssao2PixelShader\";\nconst shader = `precision highp float;\runiform sampler2D textureSampler;\runiform float near;\runiform float far;\runiform float radius;\rfloat scales[16]=float[16](\r0.1,\r0.11406250000000001,\r0.131640625,\r0.15625,\r0.187890625,\r0.2265625,\r0.272265625,\r0.325,\r0.384765625,\r0.4515625,\r0.525390625,\r0.60625,\r0.694140625,\r0.7890625,\r0.891015625,\r1.0\r);\rvarying vec2 vUV;\rfloat perspectiveDepthToViewZ(in float invClipZ,in float near,in float far ) {\rreturn ( near*far )/( ( far-near )*invClipZ-far );\r}\rfloat viewZToPerspectiveDepth( in float viewZ,in float near,in float far ) {\rreturn ( near*far/viewZ+far)/( far-near );\r}\rfloat viewZToOrthographicDepth( in float viewZ,in float near,in float far ) {\rreturn ( viewZ+near )/( near-far );\r}\r#ifdef SSAO\nuniform sampler2D randomSampler;\runiform sampler2D depthSampler;\runiform sampler2D normalSampler;\runiform float randTextureTiles;\runiform float samplesFactor;\runiform vec3 sampleSphere[SAMPLES];\runiform float totalStrength;\runiform float base;\runiform float xViewport;\runiform float yViewport;\runiform mat3 depthProjection;\runiform float maxZ;\runiform float minZAspect;\runiform vec2 texelSize;\runiform mat4 projection;\rvoid main()\r{\rvec3 random=texture2D(randomSampler,vUV*randTextureTiles).rgb;\rfloat depth=texture2D(depthSampler,vUV).r;\rfloat depthSign=depth/abs(depth);\rdepth=depth*depthSign;\rvec3 normal=texture2D(normalSampler,vUV).rgb;\rfloat occlusion=0.0;\rfloat correctedRadius=min(radius,minZAspect*depth/near);\rvec3 vViewRay=vec3((vUV.x*2.0-1.0)*xViewport,(vUV.y*2.0-1.0)*yViewport,depthSign);\rvec3 vDepthFactor=depthProjection*vec3(1.0,1.0,depth);\rvec3 origin=vViewRay*vDepthFactor;\rvec3 rvec=random*2.0-1.0;\rrvec.z=0.0;\rfloat dotProduct=dot(rvec,normal);\rrvec=1.0-abs(dotProduct)>1e-2 ? rvec : vec3(-rvec.y,0.0,rvec.x);\rvec3 tangent=normalize(rvec-normal*dot(rvec,normal));\rvec3 bitangent=cross(normal,tangent);\rmat3 tbn=mat3(tangent,bitangent,normal);\rfloat difference;\rfor (int i=0; i<SAMPLES; ++i) {\rvec3 samplePosition=scales[(i+int(random.x*16.0)) % 16]*tbn*sampleSphere[(i+int(random.y*16.0)) % 16];\rsamplePosition=samplePosition*correctedRadius+origin;\rvec4 offset=vec4(samplePosition,1.0);\roffset=projection*offset;\roffset.xyz/=offset.w;\roffset.xy=offset.xy*0.5+0.5;\rif (offset.x<0.0 || offset.y<0.0 || offset.x>1.0 || offset.y>1.0) {\rcontinue;\r}\rfloat sampleDepth=abs(texture2D(depthSampler,offset.xy).r);\rdifference=depthSign*samplePosition.z-sampleDepth;\rfloat rangeCheck=1.0-smoothstep(correctedRadius*0.5,correctedRadius,difference);\rocclusion+=(difference>=0.0 ? 1.0 : 0.0)*rangeCheck;\r}\rocclusion=occlusion*(1.0-smoothstep(maxZ*0.75,maxZ,depth));\rfloat ao=1.0-totalStrength*occlusion*samplesFactor;\rfloat result=clamp(ao+base,0.0,1.0);\rgl_FragColor=vec4(vec3(result),1.0);\r}\r#endif\n#ifdef BILATERAL_BLUR\nuniform sampler2D depthSampler;\runiform float outSize;\runiform float samplerOffsets[SAMPLES];\rvec4 blur9(sampler2D image,vec2 uv,float resolution,vec2 direction) {\rvec4 color=vec4(0.0);\rvec2 off1=vec2(1.3846153846)*direction;\rvec2 off2=vec2(3.2307692308)*direction;\rcolor+=texture2D(image,uv)*0.2270270270;\rcolor+=texture2D(image,uv+(off1/resolution))*0.3162162162;\rcolor+=texture2D(image,uv-(off1/resolution))*0.3162162162;\rcolor+=texture2D(image,uv+(off2/resolution))*0.0702702703;\rcolor+=texture2D(image,uv-(off2/resolution))*0.0702702703;\rreturn color;\r}\rvec4 blur13(sampler2D image,vec2 uv,float resolution,vec2 direction) {\rvec4 color=vec4(0.0);\rvec2 off1=vec2(1.411764705882353)*direction;\rvec2 off2=vec2(3.2941176470588234)*direction;\rvec2 off3=vec2(5.176470588235294)*direction;\rcolor+=texture2D(image,uv)*0.1964825501511404;\rcolor+=texture2D(image,uv+(off1/resolution))*0.2969069646728344;\rcolor+=texture2D(image,uv-(off1/resolution))*0.2969069646728344;\rcolor+=texture2D(image,uv+(off2/resolution))*0.09447039785044732;\rcolor+=texture2D(image,uv-(off2/resolution))*0.09447039785044732;\rcolor+=texture2D(image,uv+(off3/resolution))*0.010381362401148057;\rcolor+=texture2D(image,uv-(off3/resolution))*0.010381362401148057;\rreturn color;\r}\rvec4 blur13Bilateral(sampler2D image,vec2 uv,float resolution,vec2 direction) {\rvec4 color=vec4(0.0);\rvec2 off1=vec2(1.411764705882353)*direction;\rvec2 off2=vec2(3.2941176470588234)*direction;\rvec2 off3=vec2(5.176470588235294)*direction;\rfloat compareDepth=abs(texture2D(depthSampler,uv).r);\rfloat sampleDepth;\rfloat weight;\rfloat weightSum=30.0;\rcolor+=texture2D(image,uv)*30.0;\rsampleDepth=abs(texture2D(depthSampler,uv+(off1/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+= weight;\rcolor+=texture2D(image,uv+(off1/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv-(off1/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+= weight;\rcolor+=texture2D(image,uv-(off1/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv+(off2/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+=weight;\rcolor+=texture2D(image,uv+(off2/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv-(off2/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+=weight;\rcolor+=texture2D(image,uv-(off2/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv+(off3/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+=weight;\rcolor+=texture2D(image,uv+(off3/resolution))*weight;\rsampleDepth=abs(texture2D(depthSampler,uv-(off3/resolution)).r);\rweight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30.0);\rweightSum+=weight;\rcolor+=texture2D(image,uv-(off3/resolution))*weight;\rreturn color/weightSum;\r}\rvoid main()\r{\r#if EXPENSIVE\nfloat compareDepth=abs(texture2D(depthSampler,vUV).r);\rfloat texelsize=1.0/outSize;\rfloat result=0.0;\rfloat weightSum=0.0;\rfor (int i=0; i<SAMPLES; ++i)\r{\r#ifdef BILATERAL_BLUR_H\nvec2 direction=vec2(1.0,0.0);\rvec2 sampleOffset=vec2(texelsize*samplerOffsets[i],0.0);\r#else\nvec2 direction=vec2(0.0,1.0);\rvec2 sampleOffset=vec2(0.0,texelsize*samplerOffsets[i]);\r#endif\nvec2 samplePos=vUV+sampleOffset;\rfloat sampleDepth=abs(texture2D(depthSampler,samplePos).r);\rfloat weight=clamp(1.0/( 0.003+abs(compareDepth-sampleDepth)),0.0,30000.0);\rresult+=texture2D(textureSampler,samplePos).r*weight;\rweightSum+=weight;\r}\rresult/=weightSum;\rgl_FragColor.rgb=vec3(result);\rgl_FragColor.a=1.0;\r#else\nvec4 color;\r#ifdef BILATERAL_BLUR_H\nvec2 direction=vec2(1.0,0.0);\rcolor=blur13Bilateral(textureSampler,vUV,outSize,direction);\r#else\nvec2 direction=vec2(0.0,1.0);\rcolor=blur13Bilateral(textureSampler,vUV,outSize,direction);\r#endif\ngl_FragColor.rgb=vec3(color.r);\rgl_FragColor.a=1.0;\r#endif\n}\r#endif\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const ssao2PixelShader = { name, shader };\n"]}

package/Shaders/ssaoCombine.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const ssaoCombinePixelShader: {
     name: string;
     shader: string;

package/Shaders/ssaoCombine.fragment.js

@@ -7,6 +7,6 @@ vec4 ssaoColor=texture2D(textureSampler,viewport.xy+vUV*viewport.zw);
 }
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const ssaoCombinePixelShader = { name, shader };
 //# sourceMappingURL=ssaoCombine.fragment.js.map

package/Shaders/ssaoCombine.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"ssaoCombine.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ssaoCombine.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;CAYd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"ssaoCombinePixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform sampler2D originalColor;\runiform vec4 viewport;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 ssaoColor=texture2D(textureSampler,viewport.xy+vUV*viewport.zw);\rvec4 sceneColor=texture2D(originalColor,vUV);\rgl_FragColor=sceneColor*ssaoColor;\r#define CUSTOM_FRAGMENT_MAIN_END\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const ssaoCombinePixelShader = { name, shader };\n"]}
+{"version":3,"file":"ssaoCombine.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/ssaoCombine.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;CAYd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"ssaoCombinePixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform sampler2D originalColor;\runiform vec4 viewport;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 ssaoColor=texture2D(textureSampler,viewport.xy+vUV*viewport.zw);\rvec4 sceneColor=texture2D(originalColor,vUV);\rgl_FragColor=sceneColor*ssaoColor;\r#define CUSTOM_FRAGMENT_MAIN_END\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const ssaoCombinePixelShader = { name, shader };\n"]}

package/Shaders/standard.fragment.d.ts

@@ -1,5 +1,5 @@
 import "./ShadersInclude/packingFunctions";
-/** @hidden */
+/** @internal */
 export declare const standardPixelShader: {
     name: string;
     shader: string;

package/Shaders/standard.fragment.js

@@ -50,6 +50,6 @@ uniform mat4 inverseViewProjection;
 `;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const standardPixelShader = { name, shader };
 //# sourceMappingURL=standard.fragment.js.map

package/Shaders/standard.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"standard.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/standard.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,mCAAmC,CAAC;AAE3C,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Ud,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/packingFunctions\";\n\nconst name = \"standardPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\n#if defined(PASS_POST_PROCESS)\nvoid main(void)\r{\rvec4 color=texture2D(textureSampler,vUV);\rgl_FragColor=color;\r}\r#endif\n#if defined(DOWN_SAMPLE_X4)\nuniform vec2 dsOffsets[16];\rvoid main(void)\r{\rvec4 average=vec4(0.0,0.0,0.0,0.0);\raverage=texture2D(textureSampler,vUV+dsOffsets[0]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[1]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[2]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[3]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[4]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[5]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[6]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[7]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[8]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[9]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[10]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[11]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[12]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[13]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[14]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[15]);\raverage/=16.0;\rgl_FragColor=average;\r}\r#endif\n#if defined(BRIGHT_PASS)\nuniform vec2 dsOffsets[4];\runiform float brightThreshold;\rvoid main(void)\r{\rvec4 average=vec4(0.0,0.0,0.0,0.0);\raverage=texture2D(textureSampler,vUV+vec2(dsOffsets[0].x,dsOffsets[0].y));\raverage+=texture2D(textureSampler,vUV+vec2(dsOffsets[1].x,dsOffsets[1].y));\raverage+=texture2D(textureSampler,vUV+vec2(dsOffsets[2].x,dsOffsets[2].y));\raverage+=texture2D(textureSampler,vUV+vec2(dsOffsets[3].x,dsOffsets[3].y));\raverage*=0.25;\rfloat luminance=length(average.rgb);\rif (luminance<brightThreshold) {\raverage=vec4(0.0,0.0,0.0,1.0);\r}\rgl_FragColor=average;\r}\r#endif\n#if defined(TEXTURE_ADDER)\nuniform sampler2D otherSampler;\runiform sampler2D lensSampler;\runiform float exposure;\rvoid main(void)\r{\rvec3 colour=texture2D(textureSampler,vUV).rgb;\rcolour*=exposure;\rvec3 X=max(vec3(0.0,0.0,0.0),colour-0.004);\rvec3 retColor=(X*(6.2*X+0.5))/(X*(6.2*X+1.7)+0.06);\rcolour=retColor*retColor;\rcolour+=colour*texture2D(lensSampler,vUV).rgb;\rvec4 finalColor=vec4(colour.rgb,1.0)+texture2D(otherSampler,vUV);\rgl_FragColor=finalColor;\r}\r#endif\n#if defined(VLS)\n#define PI 3.1415926535897932384626433832795\nuniform mat4 shadowViewProjection;\runiform mat4 lightWorld;\runiform vec3 cameraPosition;\runiform vec3 sunDirection;\runiform vec3 sunColor;\runiform vec2 depthValues;\runiform float scatteringCoefficient;\runiform float scatteringPower;\runiform sampler2D shadowMapSampler;\runiform sampler2D positionSampler;\rfloat computeScattering(float lightDotView)\r{\rfloat result=1.0-scatteringCoefficient*scatteringCoefficient;\rresult/=(4.0*PI*pow(1.0+scatteringCoefficient*scatteringCoefficient-(2.0*scatteringCoefficient)*lightDotView,1.5));\rreturn result;\r}\rvoid main(void)\r{\rvec3 worldPos=texture2D(positionSampler,vUV).rgb;\rvec3 startPosition=cameraPosition;\rvec3 rayVector=worldPos-startPosition;\rfloat rayLength=length(rayVector);\rvec3 rayDirection=rayVector/rayLength;\rfloat stepLength=rayLength/NB_STEPS;\rvec3 stepL=rayDirection*stepLength;\rvec3 currentPosition=startPosition;\rvec3 accumFog=vec3(0.0);\rfor (int i=0; i<int(NB_STEPS); i++)\r{\rvec4 worldInShadowCameraSpace=shadowViewProjection*vec4(currentPosition,1.0);\rfloat depthMetric= (worldInShadowCameraSpace.z+depthValues.x)/(depthValues.y);\rfloat shadowPixelDepth=clamp(depthMetric,0.0,1.0);\rworldInShadowCameraSpace.xyz/=worldInShadowCameraSpace.w;\rworldInShadowCameraSpace.xyz=0.5*worldInShadowCameraSpace.xyz+vec3(0.5);\rfloat shadowMapValue=texture2D(shadowMapSampler,worldInShadowCameraSpace.xy).r;\rif (shadowMapValue>shadowPixelDepth)\raccumFog+=sunColor*computeScattering(dot(rayDirection,sunDirection));\rcurrentPosition+=stepL;\r}\raccumFog/=NB_STEPS;\rvec3 color=accumFog*scatteringPower;\rgl_FragColor=vec4(color*exp(color) ,1.0);\r}\r#endif\n#if defined(VLSMERGE)\nuniform sampler2D originalSampler;\rvoid main(void)\r{\rgl_FragColor=texture2D(originalSampler,vUV)+texture2D(textureSampler,vUV);\r}\r#endif\n#if defined(LUMINANCE)\nuniform vec2 lumOffsets[4];\rvoid main()\r{\rfloat average=0.0;\rvec4 color=vec4(0.0);\rfloat maximum=-1e20;\rvec3 weight=vec3(0.299,0.587,0.114);\rfor (int i=0; i<4; i++)\r{\rcolor=texture2D(textureSampler,vUV+ lumOffsets[i]);\rfloat GreyValue=dot(color.rgb,vec3(0.33,0.33,0.33));\r#ifdef WEIGHTED_AVERAGE\nfloat GreyValue=dot(color.rgb,weight);\r#endif\n#ifdef BRIGHTNESS\nfloat GreyValue=max(color.r,max(color.g,color.b));\r#endif\n#ifdef HSL_COMPONENT\nfloat GreyValue=0.5*(max(color.r,max(color.g,color.b))+min(color.r,min(color.g,color.b)));\r#endif\n#ifdef MAGNITUDE\nfloat GreyValue=length(color.rgb);\r#endif\nmaximum=max(maximum,GreyValue);\raverage+=(0.25*log(1e-5+GreyValue));\r}\raverage=exp(average);\rgl_FragColor=vec4(average,maximum,0.0,1.0);\r}\r#endif\n#if defined(LUMINANCE_DOWN_SAMPLE)\nuniform vec2 dsOffsets[9];\runiform float halfDestPixelSize;\r#ifdef FINAL_DOWN_SAMPLER\n#include<packingFunctions>\n#endif\nvoid main()\r{\rvec4 color=vec4(0.0);\rfloat average=0.0;\rfor (int i=0; i<9; i++)\r{\rcolor=texture2D(textureSampler,vUV+vec2(halfDestPixelSize,halfDestPixelSize)+dsOffsets[i]);\raverage+=color.r;\r}\raverage/=9.0;\r#ifdef FINAL_DOWN_SAMPLER\ngl_FragColor=pack(average);\r#else\ngl_FragColor=vec4(average,average,0.0,1.0);\r#endif\n}\r#endif\n#if defined(HDR)\nuniform sampler2D textureAdderSampler;\runiform float averageLuminance;\rvoid main()\r{\rvec4 color=texture2D(textureAdderSampler,vUV);\r#ifndef AUTO_EXPOSURE\nvec4 adjustedColor=color/averageLuminance;\rcolor=adjustedColor;\rcolor.a=1.0;\r#endif\ngl_FragColor=color;\r}\r#endif\n#if defined(LENS_FLARE)\n#define GHOSTS 3\nuniform sampler2D lensColorSampler;\runiform float strength;\runiform float ghostDispersal;\runiform float haloWidth;\runiform vec2 resolution;\runiform float distortionStrength;\rfloat hash(vec2 p)\r{\rfloat h=dot(p,vec2(127.1,311.7));\rreturn -1.0+2.0*fract(sin(h)*43758.5453123);\r}\rfloat noise(in vec2 p)\r{\rvec2 i=floor(p);\rvec2 f=fract(p);\rvec2 u=f*f*(3.0-2.0*f);\rreturn mix(mix(hash(i+vec2(0.0,0.0)),\rhash(i+vec2(1.0,0.0)),u.x),\rmix(hash(i+vec2(0.0,1.0)),\rhash(i+vec2(1.0,1.0)),u.x),u.y);\r}\rfloat fbm(vec2 p)\r{\rfloat f=0.0;\rf+=0.5000*noise(p); p*=2.02;\rf+=0.2500*noise(p); p*=2.03;\rf+=0.1250*noise(p); p*=2.01;\rf+=0.0625*noise(p); p*=2.04;\rf/=0.9375;\rreturn f;\r}\rvec3 pattern(vec2 uv)\r{\rvec2 p=-1.0+2.0*uv;\rfloat p2=dot(p,p);\rfloat f=fbm(vec2(15.0*p2))/2.0;\rfloat r=0.2+0.6*sin(12.5*length(uv-vec2(0.5)));\rfloat g=0.2+0.6*sin(20.5*length(uv-vec2(0.5)));\rfloat b=0.2+0.6*sin(17.2*length(uv-vec2(0.5)));\rreturn (1.0-f)*vec3(r,g,b);\r}\rfloat luminance(vec3 color)\r{\rreturn dot(color.rgb,vec3(0.2126,0.7152,0.0722));\r}\rvec4 textureDistorted(sampler2D tex,vec2 texcoord,vec2 direction,vec3 distortion)\r{\rreturn vec4(\rtexture2D(tex,texcoord+direction*distortion.r).r,\rtexture2D(tex,texcoord+direction*distortion.g).g,\rtexture2D(tex,texcoord+direction*distortion.b).b,\r1.0\r);\r}\rvoid main(void)\r{\rvec2 uv=-vUV+vec2(1.0);\rvec2 ghostDir=(vec2(0.5)-uv)*ghostDispersal;\rvec2 texelSize=1.0/resolution;\rvec3 distortion=vec3(-texelSize.x*distortionStrength,0.0,texelSize.x*distortionStrength);\rvec4 result=vec4(0.0);\rfloat ghostIndice=1.0;\rfor (int i=0; i<GHOSTS; ++i)\r{\rvec2 offset=fract(uv+ghostDir*ghostIndice);\rfloat weight=length(vec2(0.5)-offset)/length(vec2(0.5));\rweight=pow(1.0-weight,10.0);\rresult+=textureDistorted(textureSampler,offset,normalize(ghostDir),distortion)*weight*strength;\rghostIndice+=1.0;\r}\rvec2 haloVec=normalize(ghostDir)*haloWidth;\rfloat weight=length(vec2(0.5)-fract(uv+haloVec))/length(vec2(0.5));\rweight=pow(1.0-weight,10.0);\rresult+=textureDistorted(textureSampler,fract(uv+haloVec),normalize(ghostDir),distortion)*weight*strength;\rresult*=texture2D(lensColorSampler,vec2(length(vec2(0.5)-uv)/length(vec2(0.5))));\rgl_FragColor=result;\r}\r#endif\n#if defined(LENS_FLARE_COMPOSE)\nuniform sampler2D otherSampler;\runiform sampler2D lensDirtSampler;\runiform sampler2D lensStarSampler;\runiform mat4 lensStarMatrix;\rvoid main(void)\r{\rvec2 lensFlareCoords=(lensStarMatrix*vec4(vUV,1.0,1.0)).xy;\rvec4 lensMod=texture2D(lensDirtSampler,vUV);\rlensMod+=texture2D(lensStarSampler,vUV/*lensFlareCoords*/);\rvec4 result=texture2D(textureSampler,vUV)*lensMod;\rgl_FragColor=texture2D(otherSampler,vUV)+result;\r}\r#endif\n#if defined(DEPTH_OF_FIELD)\nuniform sampler2D otherSampler;\runiform sampler2D depthSampler;\runiform float distance;\rvoid main(void)\r{\rvec4 sharp=texture2D(otherSampler,vUV);\rvec4 blur=texture2D(textureSampler,vUV);\rfloat dist=clamp(texture2D(depthSampler,vUV).r*distance,0.0,1.0);\rfloat factor=0.0;\rif (dist<0.05)\rfactor=1.0;\relse if (dist<0.1)\rfactor=20.0*(0.1-dist);\relse if (dist<0.5)\rfactor=0.0;\relse\rfactor=2.0*(dist-0.5);\rfactor=clamp(factor,0.0,0.90);\rgl_FragColor=mix(sharp,blur,factor);\r}\r#endif\n#if defined(MOTION_BLUR)\nuniform mat4 inverseViewProjection;\runiform mat4 prevViewProjection;\runiform vec2 screenSize;\runiform float motionScale;\runiform float motionStrength;\runiform sampler2D depthSampler;\rvoid main(void)\r{\rvec2 texelSize=1.0/screenSize;\rfloat depth=texture2D(depthSampler,vUV).r;\rvec4 cpos=vec4(vUV*2.0-1.0,depth,1.0);\rcpos=cpos*inverseViewProjection;\rvec4 ppos=cpos*prevViewProjection;\rppos.xyz/=ppos.w;\rppos.xy=ppos.xy*0.5+0.5;\rvec2 velocity=(ppos.xy-vUV)*motionScale*motionStrength;\rfloat speed=length(velocity/texelSize);\rint nSamples=int(clamp(speed,1.0,MAX_MOTION_SAMPLES));\rvec4 result=texture2D(textureSampler,vUV);\rfor (int i=1; i<int(MAX_MOTION_SAMPLES); ++i) {\rif (i>=nSamples)\rbreak;\rvec2 offset1=vUV+velocity*(float(i)/float(nSamples-1)-0.5);\rresult+=texture2D(textureSampler,offset1);\r}\rgl_FragColor=result/float(nSamples);\r}\r#endif\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const standardPixelShader = { name, shader };\n"]}
+{"version":3,"file":"standard.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/standard.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,mCAAmC,CAAC;AAE3C,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Ud,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/packingFunctions\";\n\nconst name = \"standardPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\n#if defined(PASS_POST_PROCESS)\nvoid main(void)\r{\rvec4 color=texture2D(textureSampler,vUV);\rgl_FragColor=color;\r}\r#endif\n#if defined(DOWN_SAMPLE_X4)\nuniform vec2 dsOffsets[16];\rvoid main(void)\r{\rvec4 average=vec4(0.0,0.0,0.0,0.0);\raverage=texture2D(textureSampler,vUV+dsOffsets[0]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[1]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[2]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[3]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[4]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[5]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[6]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[7]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[8]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[9]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[10]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[11]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[12]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[13]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[14]);\raverage+=texture2D(textureSampler,vUV+dsOffsets[15]);\raverage/=16.0;\rgl_FragColor=average;\r}\r#endif\n#if defined(BRIGHT_PASS)\nuniform vec2 dsOffsets[4];\runiform float brightThreshold;\rvoid main(void)\r{\rvec4 average=vec4(0.0,0.0,0.0,0.0);\raverage=texture2D(textureSampler,vUV+vec2(dsOffsets[0].x,dsOffsets[0].y));\raverage+=texture2D(textureSampler,vUV+vec2(dsOffsets[1].x,dsOffsets[1].y));\raverage+=texture2D(textureSampler,vUV+vec2(dsOffsets[2].x,dsOffsets[2].y));\raverage+=texture2D(textureSampler,vUV+vec2(dsOffsets[3].x,dsOffsets[3].y));\raverage*=0.25;\rfloat luminance=length(average.rgb);\rif (luminance<brightThreshold) {\raverage=vec4(0.0,0.0,0.0,1.0);\r}\rgl_FragColor=average;\r}\r#endif\n#if defined(TEXTURE_ADDER)\nuniform sampler2D otherSampler;\runiform sampler2D lensSampler;\runiform float exposure;\rvoid main(void)\r{\rvec3 colour=texture2D(textureSampler,vUV).rgb;\rcolour*=exposure;\rvec3 X=max(vec3(0.0,0.0,0.0),colour-0.004);\rvec3 retColor=(X*(6.2*X+0.5))/(X*(6.2*X+1.7)+0.06);\rcolour=retColor*retColor;\rcolour+=colour*texture2D(lensSampler,vUV).rgb;\rvec4 finalColor=vec4(colour.rgb,1.0)+texture2D(otherSampler,vUV);\rgl_FragColor=finalColor;\r}\r#endif\n#if defined(VLS)\n#define PI 3.1415926535897932384626433832795\nuniform mat4 shadowViewProjection;\runiform mat4 lightWorld;\runiform vec3 cameraPosition;\runiform vec3 sunDirection;\runiform vec3 sunColor;\runiform vec2 depthValues;\runiform float scatteringCoefficient;\runiform float scatteringPower;\runiform sampler2D shadowMapSampler;\runiform sampler2D positionSampler;\rfloat computeScattering(float lightDotView)\r{\rfloat result=1.0-scatteringCoefficient*scatteringCoefficient;\rresult/=(4.0*PI*pow(1.0+scatteringCoefficient*scatteringCoefficient-(2.0*scatteringCoefficient)*lightDotView,1.5));\rreturn result;\r}\rvoid main(void)\r{\rvec3 worldPos=texture2D(positionSampler,vUV).rgb;\rvec3 startPosition=cameraPosition;\rvec3 rayVector=worldPos-startPosition;\rfloat rayLength=length(rayVector);\rvec3 rayDirection=rayVector/rayLength;\rfloat stepLength=rayLength/NB_STEPS;\rvec3 stepL=rayDirection*stepLength;\rvec3 currentPosition=startPosition;\rvec3 accumFog=vec3(0.0);\rfor (int i=0; i<int(NB_STEPS); i++)\r{\rvec4 worldInShadowCameraSpace=shadowViewProjection*vec4(currentPosition,1.0);\rfloat depthMetric= (worldInShadowCameraSpace.z+depthValues.x)/(depthValues.y);\rfloat shadowPixelDepth=clamp(depthMetric,0.0,1.0);\rworldInShadowCameraSpace.xyz/=worldInShadowCameraSpace.w;\rworldInShadowCameraSpace.xyz=0.5*worldInShadowCameraSpace.xyz+vec3(0.5);\rfloat shadowMapValue=texture2D(shadowMapSampler,worldInShadowCameraSpace.xy).r;\rif (shadowMapValue>shadowPixelDepth)\raccumFog+=sunColor*computeScattering(dot(rayDirection,sunDirection));\rcurrentPosition+=stepL;\r}\raccumFog/=NB_STEPS;\rvec3 color=accumFog*scatteringPower;\rgl_FragColor=vec4(color*exp(color) ,1.0);\r}\r#endif\n#if defined(VLSMERGE)\nuniform sampler2D originalSampler;\rvoid main(void)\r{\rgl_FragColor=texture2D(originalSampler,vUV)+texture2D(textureSampler,vUV);\r}\r#endif\n#if defined(LUMINANCE)\nuniform vec2 lumOffsets[4];\rvoid main()\r{\rfloat average=0.0;\rvec4 color=vec4(0.0);\rfloat maximum=-1e20;\rvec3 weight=vec3(0.299,0.587,0.114);\rfor (int i=0; i<4; i++)\r{\rcolor=texture2D(textureSampler,vUV+ lumOffsets[i]);\rfloat GreyValue=dot(color.rgb,vec3(0.33,0.33,0.33));\r#ifdef WEIGHTED_AVERAGE\nfloat GreyValue=dot(color.rgb,weight);\r#endif\n#ifdef BRIGHTNESS\nfloat GreyValue=max(color.r,max(color.g,color.b));\r#endif\n#ifdef HSL_COMPONENT\nfloat GreyValue=0.5*(max(color.r,max(color.g,color.b))+min(color.r,min(color.g,color.b)));\r#endif\n#ifdef MAGNITUDE\nfloat GreyValue=length(color.rgb);\r#endif\nmaximum=max(maximum,GreyValue);\raverage+=(0.25*log(1e-5+GreyValue));\r}\raverage=exp(average);\rgl_FragColor=vec4(average,maximum,0.0,1.0);\r}\r#endif\n#if defined(LUMINANCE_DOWN_SAMPLE)\nuniform vec2 dsOffsets[9];\runiform float halfDestPixelSize;\r#ifdef FINAL_DOWN_SAMPLER\n#include<packingFunctions>\n#endif\nvoid main()\r{\rvec4 color=vec4(0.0);\rfloat average=0.0;\rfor (int i=0; i<9; i++)\r{\rcolor=texture2D(textureSampler,vUV+vec2(halfDestPixelSize,halfDestPixelSize)+dsOffsets[i]);\raverage+=color.r;\r}\raverage/=9.0;\r#ifdef FINAL_DOWN_SAMPLER\ngl_FragColor=pack(average);\r#else\ngl_FragColor=vec4(average,average,0.0,1.0);\r#endif\n}\r#endif\n#if defined(HDR)\nuniform sampler2D textureAdderSampler;\runiform float averageLuminance;\rvoid main()\r{\rvec4 color=texture2D(textureAdderSampler,vUV);\r#ifndef AUTO_EXPOSURE\nvec4 adjustedColor=color/averageLuminance;\rcolor=adjustedColor;\rcolor.a=1.0;\r#endif\ngl_FragColor=color;\r}\r#endif\n#if defined(LENS_FLARE)\n#define GHOSTS 3\nuniform sampler2D lensColorSampler;\runiform float strength;\runiform float ghostDispersal;\runiform float haloWidth;\runiform vec2 resolution;\runiform float distortionStrength;\rfloat hash(vec2 p)\r{\rfloat h=dot(p,vec2(127.1,311.7));\rreturn -1.0+2.0*fract(sin(h)*43758.5453123);\r}\rfloat noise(in vec2 p)\r{\rvec2 i=floor(p);\rvec2 f=fract(p);\rvec2 u=f*f*(3.0-2.0*f);\rreturn mix(mix(hash(i+vec2(0.0,0.0)),\rhash(i+vec2(1.0,0.0)),u.x),\rmix(hash(i+vec2(0.0,1.0)),\rhash(i+vec2(1.0,1.0)),u.x),u.y);\r}\rfloat fbm(vec2 p)\r{\rfloat f=0.0;\rf+=0.5000*noise(p); p*=2.02;\rf+=0.2500*noise(p); p*=2.03;\rf+=0.1250*noise(p); p*=2.01;\rf+=0.0625*noise(p); p*=2.04;\rf/=0.9375;\rreturn f;\r}\rvec3 pattern(vec2 uv)\r{\rvec2 p=-1.0+2.0*uv;\rfloat p2=dot(p,p);\rfloat f=fbm(vec2(15.0*p2))/2.0;\rfloat r=0.2+0.6*sin(12.5*length(uv-vec2(0.5)));\rfloat g=0.2+0.6*sin(20.5*length(uv-vec2(0.5)));\rfloat b=0.2+0.6*sin(17.2*length(uv-vec2(0.5)));\rreturn (1.0-f)*vec3(r,g,b);\r}\rfloat luminance(vec3 color)\r{\rreturn dot(color.rgb,vec3(0.2126,0.7152,0.0722));\r}\rvec4 textureDistorted(sampler2D tex,vec2 texcoord,vec2 direction,vec3 distortion)\r{\rreturn vec4(\rtexture2D(tex,texcoord+direction*distortion.r).r,\rtexture2D(tex,texcoord+direction*distortion.g).g,\rtexture2D(tex,texcoord+direction*distortion.b).b,\r1.0\r);\r}\rvoid main(void)\r{\rvec2 uv=-vUV+vec2(1.0);\rvec2 ghostDir=(vec2(0.5)-uv)*ghostDispersal;\rvec2 texelSize=1.0/resolution;\rvec3 distortion=vec3(-texelSize.x*distortionStrength,0.0,texelSize.x*distortionStrength);\rvec4 result=vec4(0.0);\rfloat ghostIndice=1.0;\rfor (int i=0; i<GHOSTS; ++i)\r{\rvec2 offset=fract(uv+ghostDir*ghostIndice);\rfloat weight=length(vec2(0.5)-offset)/length(vec2(0.5));\rweight=pow(1.0-weight,10.0);\rresult+=textureDistorted(textureSampler,offset,normalize(ghostDir),distortion)*weight*strength;\rghostIndice+=1.0;\r}\rvec2 haloVec=normalize(ghostDir)*haloWidth;\rfloat weight=length(vec2(0.5)-fract(uv+haloVec))/length(vec2(0.5));\rweight=pow(1.0-weight,10.0);\rresult+=textureDistorted(textureSampler,fract(uv+haloVec),normalize(ghostDir),distortion)*weight*strength;\rresult*=texture2D(lensColorSampler,vec2(length(vec2(0.5)-uv)/length(vec2(0.5))));\rgl_FragColor=result;\r}\r#endif\n#if defined(LENS_FLARE_COMPOSE)\nuniform sampler2D otherSampler;\runiform sampler2D lensDirtSampler;\runiform sampler2D lensStarSampler;\runiform mat4 lensStarMatrix;\rvoid main(void)\r{\rvec2 lensFlareCoords=(lensStarMatrix*vec4(vUV,1.0,1.0)).xy;\rvec4 lensMod=texture2D(lensDirtSampler,vUV);\rlensMod+=texture2D(lensStarSampler,vUV/*lensFlareCoords*/);\rvec4 result=texture2D(textureSampler,vUV)*lensMod;\rgl_FragColor=texture2D(otherSampler,vUV)+result;\r}\r#endif\n#if defined(DEPTH_OF_FIELD)\nuniform sampler2D otherSampler;\runiform sampler2D depthSampler;\runiform float distance;\rvoid main(void)\r{\rvec4 sharp=texture2D(otherSampler,vUV);\rvec4 blur=texture2D(textureSampler,vUV);\rfloat dist=clamp(texture2D(depthSampler,vUV).r*distance,0.0,1.0);\rfloat factor=0.0;\rif (dist<0.05)\rfactor=1.0;\relse if (dist<0.1)\rfactor=20.0*(0.1-dist);\relse if (dist<0.5)\rfactor=0.0;\relse\rfactor=2.0*(dist-0.5);\rfactor=clamp(factor,0.0,0.90);\rgl_FragColor=mix(sharp,blur,factor);\r}\r#endif\n#if defined(MOTION_BLUR)\nuniform mat4 inverseViewProjection;\runiform mat4 prevViewProjection;\runiform vec2 screenSize;\runiform float motionScale;\runiform float motionStrength;\runiform sampler2D depthSampler;\rvoid main(void)\r{\rvec2 texelSize=1.0/screenSize;\rfloat depth=texture2D(depthSampler,vUV).r;\rvec4 cpos=vec4(vUV*2.0-1.0,depth,1.0);\rcpos=cpos*inverseViewProjection;\rvec4 ppos=cpos*prevViewProjection;\rppos.xyz/=ppos.w;\rppos.xy=ppos.xy*0.5+0.5;\rvec2 velocity=(ppos.xy-vUV)*motionScale*motionStrength;\rfloat speed=length(velocity/texelSize);\rint nSamples=int(clamp(speed,1.0,MAX_MOTION_SAMPLES));\rvec4 result=texture2D(textureSampler,vUV);\rfor (int i=1; i<int(MAX_MOTION_SAMPLES); ++i) {\rif (i>=nSamples)\rbreak;\rvec2 offset1=vUV+velocity*(float(i)/float(nSamples-1)-0.5);\rresult+=texture2D(textureSampler,offset1);\r}\rgl_FragColor=result/float(nSamples);\r}\r#endif\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const standardPixelShader = { name, shader };\n"]}

package/Shaders/stereoscopicInterlace.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const stereoscopicInterlacePixelShader: {
     name: string;
     shader: string;

package/Shaders/stereoscopicInterlace.fragment.js

@@ -11,6 +11,6 @@ useCamB=vUV.y>0.5;
 if (useCamB){
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const stereoscopicInterlacePixelShader = { name, shader };
 //# sourceMappingURL=stereoscopicInterlace.fragment.js.map

package/Shaders/stereoscopicInterlace.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"stereoscopicInterlace.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/stereoscopicInterlace.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,kCAAkC,CAAC;AAChD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Cd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,gCAAgC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"stereoscopicInterlacePixelShader\";\nconst shader = `const vec3 TWO=vec3(2.0,2.0,2.0);\rvarying vec2 vUV;\runiform sampler2D camASampler;\runiform sampler2D textureSampler;\runiform vec2 stepSize;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rbool useCamA;\rbool useCamB;\rvec2 texCoord1;\rvec2 texCoord2;\rvec3 frag1;\rvec3 frag2;\r#ifdef IS_STEREOSCOPIC_HORIZ\nuseCamB=vUV.x>0.5;\ruseCamA=!useCamB;\rtexCoord1=vec2(useCamB ? (vUV.x-0.5)*2.0 : vUV.x*2.0,vUV.y);\rtexCoord2=vec2(texCoord1.x+stepSize.x,vUV.y);\r#else\n#ifdef IS_STEREOSCOPIC_INTERLACED\nfloat rowNum=floor(vUV.y/stepSize.y);\ruseCamA=mod(rowNum,2.0)==1.0;\ruseCamB=mod(rowNum,2.0)==0.0;\rtexCoord1=vec2(vUV.x,vUV.y);\rtexCoord2=vec2(vUV.x,vUV.y);\r#else\nuseCamB=vUV.y>0.5;\ruseCamA=!useCamB;\rtexCoord1=vec2(vUV.x,useCamB ? (vUV.y-0.5)*2.0 : vUV.y*2.0);\rtexCoord2=vec2(vUV.x,texCoord1.y+stepSize.y);\r#endif\n#endif\nif (useCamB){\rfrag1=texture2D(textureSampler,texCoord1).rgb;\rfrag2=texture2D(textureSampler,texCoord2).rgb;\r}else if (useCamA){\rfrag1=texture2D(camASampler ,texCoord1).rgb;\rfrag2=texture2D(camASampler ,texCoord2).rgb;\r}else {\rdiscard;\r}\rgl_FragColor=vec4((frag1+frag2)/TWO,1.0);\r}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const stereoscopicInterlacePixelShader = { name, shader };\n"]}
+{"version":3,"file":"stereoscopicInterlace.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/stereoscopicInterlace.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,kCAAkC,CAAC;AAChD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Cd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,gCAAgC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"stereoscopicInterlacePixelShader\";\nconst shader = `const vec3 TWO=vec3(2.0,2.0,2.0);\rvarying vec2 vUV;\runiform sampler2D camASampler;\runiform sampler2D textureSampler;\runiform vec2 stepSize;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rbool useCamA;\rbool useCamB;\rvec2 texCoord1;\rvec2 texCoord2;\rvec3 frag1;\rvec3 frag2;\r#ifdef IS_STEREOSCOPIC_HORIZ\nuseCamB=vUV.x>0.5;\ruseCamA=!useCamB;\rtexCoord1=vec2(useCamB ? (vUV.x-0.5)*2.0 : vUV.x*2.0,vUV.y);\rtexCoord2=vec2(texCoord1.x+stepSize.x,vUV.y);\r#else\n#ifdef IS_STEREOSCOPIC_INTERLACED\nfloat rowNum=floor(vUV.y/stepSize.y);\ruseCamA=mod(rowNum,2.0)==1.0;\ruseCamB=mod(rowNum,2.0)==0.0;\rtexCoord1=vec2(vUV.x,vUV.y);\rtexCoord2=vec2(vUV.x,vUV.y);\r#else\nuseCamB=vUV.y>0.5;\ruseCamA=!useCamB;\rtexCoord1=vec2(vUV.x,useCamB ? (vUV.y-0.5)*2.0 : vUV.y*2.0);\rtexCoord2=vec2(vUV.x,texCoord1.y+stepSize.y);\r#endif\n#endif\nif (useCamB){\rfrag1=texture2D(textureSampler,texCoord1).rgb;\rfrag2=texture2D(textureSampler,texCoord2).rgb;\r}else if (useCamA){\rfrag1=texture2D(camASampler ,texCoord1).rgb;\rfrag2=texture2D(camASampler ,texCoord2).rgb;\r}else {\rdiscard;\r}\rgl_FragColor=vec4((frag1+frag2)/TWO,1.0);\r}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const stereoscopicInterlacePixelShader = { name, shader };\n"]}

package/Shaders/subSurfaceScattering.fragment.d.ts

@@ -2,7 +2,7 @@ import "./ShadersInclude/fibonacci";
 import "./ShadersInclude/helperFunctions";
 import "./ShadersInclude/subSurfaceScatteringFunctions";
 import "./ShadersInclude/diffusionProfile";
-/** @hidden */
+/** @internal */
 export declare const subSurfaceScatteringPixelShader: {
     name: string;
     shader: string;

package/Shaders/subSurfaceScattering.fragment.js

@@ -25,6 +25,6 @@ vec3 red =vec3(1.,0.,0.);
 float phase=0.;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const subSurfaceScatteringPixelShader = { name, shader };
 //# sourceMappingURL=subSurfaceScattering.fragment.js.map

package/Shaders/subSurfaceScattering.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"subSurfaceScattering.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/subSurfaceScattering.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,4BAA4B,CAAC;AACpC,OAAO,kCAAkC,CAAC;AAC1C,OAAO,gDAAgD,CAAC;AACxD,OAAO,mCAAmC,CAAC;AAE3C,MAAM,IAAI,GAAG,iCAAiC,CAAC;AAC/C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqJb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,+BAA+B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/fibonacci\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/subSurfaceScatteringFunctions\";\nimport \"./ShadersInclude/diffusionProfile\";\n\nconst name = \"subSurfaceScatteringPixelShader\";\nconst shader = `#include<fibonacci>\n#include<helperFunctions>\n#include<subSurfaceScatteringFunctions>\n#include<diffusionProfile>\nvarying vec2 vUV;\runiform vec2 texelSize;\runiform sampler2D textureSampler;\runiform sampler2D irradianceSampler;\runiform sampler2D depthSampler;\runiform sampler2D albedoSampler;\runiform vec2 viewportSize;\runiform float metersPerUnit;\rconst float LOG2_E=1.4426950408889634;\rconst float SSS_PIXELS_PER_SAMPLE=4.;\rconst int _SssSampleBudget=40;\r#define rcp(x) 1./x\n#define Sq(x) x*x\n#define SSS_BILATERAL_FILTER true\nvec3 EvalBurleyDiffusionProfile(float r,vec3 S)\r{\rvec3 exp_13=exp2(((LOG2_E*(-1.0/3.0))*r)*S); \rvec3 expSum=exp_13*(1.+exp_13*exp_13); \rreturn (S*rcp(8.*PI))*expSum; \r}\rvec2 SampleBurleyDiffusionProfile(float u,float rcpS)\r{\ru=1.-u; \rfloat g=1.+(4.*u)*(2.*u+sqrt(1.+(4.*u)*u));\rfloat n=exp2(log2(g)*(-1.0/3.0)); \rfloat p=(g*n)*n; \rfloat c=1.+p+n; \rfloat d=(3./LOG2_E*2.)+(3./LOG2_E)*log2(u); \rfloat x=(3./LOG2_E)*log2(c)-d; \rfloat rcpExp=((c*c)*c)*rcp((4.*u)*((c*c)+(4.*u)*(4.*u)));\rfloat r=x*rcpS;\rfloat rcpPdf=(8.*PI*rcpS)*rcpExp; \rreturn vec2(r,rcpPdf);\r}\rvec3 ComputeBilateralWeight(float xy2,float z,float mmPerUnit,vec3 S,float rcpPdf)\r{\r#ifndef SSS_BILATERAL_FILTER\nz=0.;\r#endif\nfloat r=sqrt(xy2+(z*mmPerUnit)*(z*mmPerUnit));\rfloat area=rcpPdf;\r#if SSS_CLAMP_ARTIFACT\nreturn clamp(EvalBurleyDiffusionProfile(r,S)*area,0.0,1.0);\r#else\nreturn EvalBurleyDiffusionProfile(r,S)*area;\r#endif\n}\rvoid EvaluateSample(int i,int n,vec3 S,float d,vec3 centerPosVS,float mmPerUnit,float pixelsPerMm,\rfloat phase,inout vec3 totalIrradiance,inout vec3 totalWeight)\r{\rfloat scale =rcp(float(n));\rfloat offset=rcp(float(n))*0.5;\rfloat sinPhase,cosPhase;\rsinPhase=sin(phase);\rcosPhase=cos(phase);\rvec2 bdp=SampleBurleyDiffusionProfile(float(i)*scale+offset,d);\rfloat r=bdp.x;\rfloat rcpPdf=bdp.y;\rfloat phi=SampleDiskGolden(i,n).y;\rfloat sinPhi,cosPhi;\rsinPhi=sin(phi);\rcosPhi=cos(phi);\rfloat sinPsi=cosPhase*sinPhi+sinPhase*cosPhi; \rfloat cosPsi=cosPhase*cosPhi-sinPhase*sinPhi; \rvec2 vec=r*vec2(cosPsi,sinPsi);\rvec2 position; \rfloat xy2;\rposition=vUV+round((pixelsPerMm*r)*vec2(cosPsi,sinPsi))*texelSize;\rxy2 =r*r;\rvec4 textureSample=texture2D(irradianceSampler,position);\rfloat viewZ=texture2D(depthSampler,position).r;\rvec3 irradiance =textureSample.rgb;\rif (testLightingForSSS(textureSample.a))\r{\rfloat relZ=viewZ-centerPosVS.z;\rvec3 weight=ComputeBilateralWeight(xy2,relZ,mmPerUnit,S,rcpPdf);\rtotalIrradiance+=weight*irradiance;\rtotalWeight +=weight;\r}\relse\r{\r}\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rvec4 irradianceAndDiffusionProfile =texture2D(irradianceSampler,vUV);\rvec3 centerIrradiance=irradianceAndDiffusionProfile.rgb;\rint diffusionProfileIndex=int(round(irradianceAndDiffusionProfile.a*255.));\rfloat centerDepth =0.;\rvec4 inputColor=texture2D(textureSampler,vUV);\rbool passedStencilTest=testLightingForSSS(irradianceAndDiffusionProfile.a);\rif (passedStencilTest)\r{\rcenterDepth=texture2D(depthSampler,vUV).r;\r}\rif (!passedStencilTest) { \rgl_FragColor=inputColor;\rreturn;\r}\rfloat distScale =1.;\rvec3 S =diffusionS[diffusionProfileIndex];\rfloat d =diffusionD[diffusionProfileIndex];\rfloat filterRadius=filterRadii[diffusionProfileIndex];\rvec2 centerPosNDC=vUV;\rvec2 cornerPosNDC=vUV+0.5*texelSize;\rvec3 centerPosVS =vec3(centerPosNDC*viewportSize,1.0)*centerDepth; \rvec3 cornerPosVS =vec3(cornerPosNDC*viewportSize,1.0)*centerDepth; \rfloat mmPerUnit =1000.*(metersPerUnit*rcp(distScale));\rfloat unitsPerMm=rcp(mmPerUnit);\rfloat unitsPerPixel=2.*abs(cornerPosVS.x-centerPosVS.x);\rfloat pixelsPerMm =rcp(unitsPerPixel)*unitsPerMm;\rfloat filterArea =PI*Sq(filterRadius*pixelsPerMm);\rint sampleCount =int(filterArea*rcp(SSS_PIXELS_PER_SAMPLE));\rint sampleBudget=_SssSampleBudget;\rint texturingMode=0;\rvec3 albedo =texture2D(albedoSampler,vUV).rgb;\rif (distScale==0. || sampleCount<1)\r{\r#ifdef DEBUG_SSS_SAMPLES\nvec3 green=vec3(0.,1.,0.);\rgl_FragColor=vec4(green,1.0);\rreturn;\r#endif\ngl_FragColor=vec4(inputColor.rgb+albedo*centerIrradiance,1.0);\rreturn;\r}\r#ifdef DEBUG_SSS_SAMPLES\nvec3 red =vec3(1.,0.,0.);\rvec3 blue=vec3(0.,0.,1.);\rgl_FragColor=vec4(mix(blue,red,clamp(float(sampleCount)/float(sampleBudget),0.0,1.0)),1.0);\rreturn;\r#endif\nfloat phase=0.;\rint n=min(sampleCount,sampleBudget);\rvec3 centerWeight =vec3(0.); \rvec3 totalIrradiance=vec3(0.);\rvec3 totalWeight =vec3(0.);\rfor (int i=0; i<n; i++)\r{\rEvaluateSample(i,n,S,d,centerPosVS,mmPerUnit,pixelsPerMm,\rphase,totalIrradiance,totalWeight);\r}\rtotalWeight=max(totalWeight,HALF_MIN);\rgl_FragColor=vec4(inputColor.rgb+albedo*max(totalIrradiance/totalWeight,vec3(0.0)),1.);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const subSurfaceScatteringPixelShader = { name, shader };\n"]}
+{"version":3,"file":"subSurfaceScattering.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/subSurfaceScattering.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,4BAA4B,CAAC;AACpC,OAAO,kCAAkC,CAAC;AAC1C,OAAO,gDAAgD,CAAC;AACxD,OAAO,mCAAmC,CAAC;AAE3C,MAAM,IAAI,GAAG,iCAAiC,CAAC;AAC/C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqJb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,+BAA+B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/fibonacci\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/subSurfaceScatteringFunctions\";\nimport \"./ShadersInclude/diffusionProfile\";\n\nconst name = \"subSurfaceScatteringPixelShader\";\nconst shader = `#include<fibonacci>\n#include<helperFunctions>\n#include<subSurfaceScatteringFunctions>\n#include<diffusionProfile>\nvarying vec2 vUV;\runiform vec2 texelSize;\runiform sampler2D textureSampler;\runiform sampler2D irradianceSampler;\runiform sampler2D depthSampler;\runiform sampler2D albedoSampler;\runiform vec2 viewportSize;\runiform float metersPerUnit;\rconst float LOG2_E=1.4426950408889634;\rconst float SSS_PIXELS_PER_SAMPLE=4.;\rconst int _SssSampleBudget=40;\r#define rcp(x) 1./x\n#define Sq(x) x*x\n#define SSS_BILATERAL_FILTER true\nvec3 EvalBurleyDiffusionProfile(float r,vec3 S)\r{\rvec3 exp_13=exp2(((LOG2_E*(-1.0/3.0))*r)*S); \rvec3 expSum=exp_13*(1.+exp_13*exp_13); \rreturn (S*rcp(8.*PI))*expSum; \r}\rvec2 SampleBurleyDiffusionProfile(float u,float rcpS)\r{\ru=1.-u; \rfloat g=1.+(4.*u)*(2.*u+sqrt(1.+(4.*u)*u));\rfloat n=exp2(log2(g)*(-1.0/3.0)); \rfloat p=(g*n)*n; \rfloat c=1.+p+n; \rfloat d=(3./LOG2_E*2.)+(3./LOG2_E)*log2(u); \rfloat x=(3./LOG2_E)*log2(c)-d; \rfloat rcpExp=((c*c)*c)*rcp((4.*u)*((c*c)+(4.*u)*(4.*u)));\rfloat r=x*rcpS;\rfloat rcpPdf=(8.*PI*rcpS)*rcpExp; \rreturn vec2(r,rcpPdf);\r}\rvec3 ComputeBilateralWeight(float xy2,float z,float mmPerUnit,vec3 S,float rcpPdf)\r{\r#ifndef SSS_BILATERAL_FILTER\nz=0.;\r#endif\nfloat r=sqrt(xy2+(z*mmPerUnit)*(z*mmPerUnit));\rfloat area=rcpPdf;\r#if SSS_CLAMP_ARTIFACT\nreturn clamp(EvalBurleyDiffusionProfile(r,S)*area,0.0,1.0);\r#else\nreturn EvalBurleyDiffusionProfile(r,S)*area;\r#endif\n}\rvoid EvaluateSample(int i,int n,vec3 S,float d,vec3 centerPosVS,float mmPerUnit,float pixelsPerMm,\rfloat phase,inout vec3 totalIrradiance,inout vec3 totalWeight)\r{\rfloat scale =rcp(float(n));\rfloat offset=rcp(float(n))*0.5;\rfloat sinPhase,cosPhase;\rsinPhase=sin(phase);\rcosPhase=cos(phase);\rvec2 bdp=SampleBurleyDiffusionProfile(float(i)*scale+offset,d);\rfloat r=bdp.x;\rfloat rcpPdf=bdp.y;\rfloat phi=SampleDiskGolden(i,n).y;\rfloat sinPhi,cosPhi;\rsinPhi=sin(phi);\rcosPhi=cos(phi);\rfloat sinPsi=cosPhase*sinPhi+sinPhase*cosPhi; \rfloat cosPsi=cosPhase*cosPhi-sinPhase*sinPhi; \rvec2 vec=r*vec2(cosPsi,sinPsi);\rvec2 position; \rfloat xy2;\rposition=vUV+round((pixelsPerMm*r)*vec2(cosPsi,sinPsi))*texelSize;\rxy2 =r*r;\rvec4 textureSample=texture2D(irradianceSampler,position);\rfloat viewZ=texture2D(depthSampler,position).r;\rvec3 irradiance =textureSample.rgb;\rif (testLightingForSSS(textureSample.a))\r{\rfloat relZ=viewZ-centerPosVS.z;\rvec3 weight=ComputeBilateralWeight(xy2,relZ,mmPerUnit,S,rcpPdf);\rtotalIrradiance+=weight*irradiance;\rtotalWeight +=weight;\r}\relse\r{\r}\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rvec4 irradianceAndDiffusionProfile =texture2D(irradianceSampler,vUV);\rvec3 centerIrradiance=irradianceAndDiffusionProfile.rgb;\rint diffusionProfileIndex=int(round(irradianceAndDiffusionProfile.a*255.));\rfloat centerDepth =0.;\rvec4 inputColor=texture2D(textureSampler,vUV);\rbool passedStencilTest=testLightingForSSS(irradianceAndDiffusionProfile.a);\rif (passedStencilTest)\r{\rcenterDepth=texture2D(depthSampler,vUV).r;\r}\rif (!passedStencilTest) { \rgl_FragColor=inputColor;\rreturn;\r}\rfloat distScale =1.;\rvec3 S =diffusionS[diffusionProfileIndex];\rfloat d =diffusionD[diffusionProfileIndex];\rfloat filterRadius=filterRadii[diffusionProfileIndex];\rvec2 centerPosNDC=vUV;\rvec2 cornerPosNDC=vUV+0.5*texelSize;\rvec3 centerPosVS =vec3(centerPosNDC*viewportSize,1.0)*centerDepth; \rvec3 cornerPosVS =vec3(cornerPosNDC*viewportSize,1.0)*centerDepth; \rfloat mmPerUnit =1000.*(metersPerUnit*rcp(distScale));\rfloat unitsPerMm=rcp(mmPerUnit);\rfloat unitsPerPixel=2.*abs(cornerPosVS.x-centerPosVS.x);\rfloat pixelsPerMm =rcp(unitsPerPixel)*unitsPerMm;\rfloat filterArea =PI*Sq(filterRadius*pixelsPerMm);\rint sampleCount =int(filterArea*rcp(SSS_PIXELS_PER_SAMPLE));\rint sampleBudget=_SssSampleBudget;\rint texturingMode=0;\rvec3 albedo =texture2D(albedoSampler,vUV).rgb;\rif (distScale==0. || sampleCount<1)\r{\r#ifdef DEBUG_SSS_SAMPLES\nvec3 green=vec3(0.,1.,0.);\rgl_FragColor=vec4(green,1.0);\rreturn;\r#endif\ngl_FragColor=vec4(inputColor.rgb+albedo*centerIrradiance,1.0);\rreturn;\r}\r#ifdef DEBUG_SSS_SAMPLES\nvec3 red =vec3(1.,0.,0.);\rvec3 blue=vec3(0.,0.,1.);\rgl_FragColor=vec4(mix(blue,red,clamp(float(sampleCount)/float(sampleBudget),0.0,1.0)),1.0);\rreturn;\r#endif\nfloat phase=0.;\rint n=min(sampleCount,sampleBudget);\rvec3 centerWeight =vec3(0.); \rvec3 totalIrradiance=vec3(0.);\rvec3 totalWeight =vec3(0.);\rfor (int i=0; i<n; i++)\r{\rEvaluateSample(i,n,S,d,centerPosVS,mmPerUnit,pixelsPerMm,\rphase,totalIrradiance,totalWeight);\r}\rtotalWeight=max(totalWeight,HALF_MIN);\rgl_FragColor=vec4(inputColor.rgb+albedo*max(totalIrradiance/totalWeight,vec3(0.0)),1.);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const subSurfaceScatteringPixelShader = { name, shader };\n"]}

package/Shaders/tonemap.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const tonemapPixelShader: {
     name: string;
     shader: string;

package/Shaders/tonemap.fragment.js

@@ -12,6 +12,6 @@ colour= vec3(1.0,1.0,1.0)-exp2(-_ExposureAdjustment*colour);
 gl_FragColor=vec4(colour.rgb,1.0);
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const tonemapPixelShader = { name, shader };
 //# sourceMappingURL=tonemap.fragment.js.map

package/Shaders/tonemap.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"tonemap.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/tonemap.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Cb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"tonemapPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform float _ExposureAdjustment;\r#if defined(HABLE_TONEMAPPING)\nconst float A=0.15;\rconst float B=0.50;\rconst float C=0.10;\rconst float D=0.20;\rconst float E=0.02;\rconst float F=0.30;\rconst float W=11.2;\r#endif\nfloat Luminance(vec3 c)\r{\rreturn dot(c,vec3(0.22,0.707,0.071));\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rvec3 colour=texture2D(textureSampler,vUV).rgb;\r#if defined(REINHARD_TONEMAPPING)\nfloat lum=Luminance(colour.rgb); \rfloat lumTm=lum*_ExposureAdjustment;\rfloat scale=lumTm/(1.0+lumTm); \rcolour*=scale/lum;\r#elif defined(HABLE_TONEMAPPING)\ncolour*=_ExposureAdjustment;\rconst float ExposureBias=2.0;\rvec3 x=ExposureBias*colour;\rvec3 curr=((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;\rx=vec3(W,W,W);\rvec3 whiteScale=1.0/(((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F);\rcolour=curr*whiteScale;\r#elif defined(OPTIMIZED_HEJIDAWSON_TONEMAPPING)\ncolour*=_ExposureAdjustment;\rvec3 X=max(vec3(0.0,0.0,0.0),colour-0.004);\rvec3 retColor=(X*(6.2*X+0.5))/(X*(6.2*X+1.7)+0.06);\rcolour=retColor*retColor;\r#elif defined(PHOTOGRAPHIC_TONEMAPPING)\ncolour= vec3(1.0,1.0,1.0)-exp2(-_ExposureAdjustment*colour);\r#endif\ngl_FragColor=vec4(colour.rgb,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const tonemapPixelShader = { name, shader };\n"]}
+{"version":3,"file":"tonemap.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/tonemap.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Cb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,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 = \"tonemapPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform float _ExposureAdjustment;\r#if defined(HABLE_TONEMAPPING)\nconst float A=0.15;\rconst float B=0.50;\rconst float C=0.10;\rconst float D=0.20;\rconst float E=0.02;\rconst float F=0.30;\rconst float W=11.2;\r#endif\nfloat Luminance(vec3 c)\r{\rreturn dot(c,vec3(0.22,0.707,0.071));\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rvec3 colour=texture2D(textureSampler,vUV).rgb;\r#if defined(REINHARD_TONEMAPPING)\nfloat lum=Luminance(colour.rgb); \rfloat lumTm=lum*_ExposureAdjustment;\rfloat scale=lumTm/(1.0+lumTm); \rcolour*=scale/lum;\r#elif defined(HABLE_TONEMAPPING)\ncolour*=_ExposureAdjustment;\rconst float ExposureBias=2.0;\rvec3 x=ExposureBias*colour;\rvec3 curr=((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;\rx=vec3(W,W,W);\rvec3 whiteScale=1.0/(((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F);\rcolour=curr*whiteScale;\r#elif defined(OPTIMIZED_HEJIDAWSON_TONEMAPPING)\ncolour*=_ExposureAdjustment;\rvec3 X=max(vec3(0.0,0.0,0.0),colour-0.004);\rvec3 retColor=(X*(6.2*X+0.5))/(X*(6.2*X+1.7)+0.06);\rcolour=retColor*retColor;\r#elif defined(PHOTOGRAPHIC_TONEMAPPING)\ncolour= vec3(1.0,1.0,1.0)-exp2(-_ExposureAdjustment*colour);\r#endif\ngl_FragColor=vec4(colour.rgb,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const tonemapPixelShader = { name, shader };\n"]}

package/Shaders/volumetricLightScattering.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const volumetricLightScatteringPixelShader: {
     name: string;
     shader: string;

package/Shaders/volumetricLightScattering.fragment.js

@@ -7,6 +7,6 @@ vec2 tc=vUV;
 }
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const volumetricLightScatteringPixelShader = { name, shader };
 //# sourceMappingURL=volumetricLightScattering.fragment.js.map

package/Shaders/volumetricLightScattering.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"volumetricLightScattering.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/volumetricLightScattering.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,sCAAsC,CAAC;AACpD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Bd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,oCAAoC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"volumetricLightScatteringPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform sampler2D lightScatteringSampler;\runiform float decay;\runiform float exposure;\runiform float weight;\runiform float density;\runiform vec2 meshPositionOnScreen;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec2 tc=vUV;\rvec2 deltaTexCoord=(tc-meshPositionOnScreen.xy);\rdeltaTexCoord*=1.0/float(NUM_SAMPLES)*density;\rfloat illuminationDecay=1.0;\rvec4 color=texture2D(lightScatteringSampler,tc)*0.4;\rfor(int i=0; i<NUM_SAMPLES; i++) {\rtc-=deltaTexCoord;\rvec4 dataSample=texture2D(lightScatteringSampler,tc)*0.4;\rdataSample*=illuminationDecay*weight;\rcolor+=dataSample;\rilluminationDecay*=decay;\r}\rvec4 realColor=texture2D(textureSampler,vUV);\rgl_FragColor=((vec4((vec3(color.r,color.g,color.b)*exposure),1))+(realColor*(1.5-0.4)));\r#define CUSTOM_FRAGMENT_MAIN_END\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const volumetricLightScatteringPixelShader = { name, shader };\n"]}
+{"version":3,"file":"volumetricLightScattering.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/volumetricLightScattering.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,sCAAsC,CAAC;AACpD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Bd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,oCAAoC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"volumetricLightScatteringPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform sampler2D lightScatteringSampler;\runiform float decay;\runiform float exposure;\runiform float weight;\runiform float density;\runiform vec2 meshPositionOnScreen;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec2 tc=vUV;\rvec2 deltaTexCoord=(tc-meshPositionOnScreen.xy);\rdeltaTexCoord*=1.0/float(NUM_SAMPLES)*density;\rfloat illuminationDecay=1.0;\rvec4 color=texture2D(lightScatteringSampler,tc)*0.4;\rfor(int i=0; i<NUM_SAMPLES; i++) {\rtc-=deltaTexCoord;\rvec4 dataSample=texture2D(lightScatteringSampler,tc)*0.4;\rdataSample*=illuminationDecay*weight;\rcolor+=dataSample;\rilluminationDecay*=decay;\r}\rvec4 realColor=texture2D(textureSampler,vUV);\rgl_FragColor=((vec4((vec3(color.r,color.g,color.b)*exposure),1))+(realColor*(1.5-0.4)));\r#define CUSTOM_FRAGMENT_MAIN_END\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const volumetricLightScatteringPixelShader = { name, shader };\n"]}

package/Shaders/volumetricLightScatteringPass.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const volumetricLightScatteringPassPixelShader: {
     name: string;
     shader: string;

package/Shaders/volumetricLightScatteringPass.fragment.js

@@ -11,6 +11,6 @@ vec4 diffuseColor=texture2D(diffuseSampler,vUV);
 gl_FragColor=vec4(0.0,0.0,0.0,1.0);
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const volumetricLightScatteringPassPixelShader = { name, shader };
 //# sourceMappingURL=volumetricLightScatteringPass.fragment.js.map