@babylonjs/core 5.24.0 → 5.26.0

package/Shaders/postprocess.vertex.js

@@ -7,6 +7,6 @@ vUV=(position*madd+madd)*scale;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const postprocessVertexShader = { name, shader };
 //# sourceMappingURL=postprocess.vertex.js.map

package/Shaders/postprocess.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"postprocess.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/postprocess.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;EAUb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"postprocessVertexShader\";\nconst shader = `attribute vec2 position;\runiform vec2 scale;\rvarying vec2 vUV;\rconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvUV=(position*madd+madd)*scale;\rgl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const postprocessVertexShader = { name, shader };\n"]}
+{"version":3,"file":"postprocess.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/postprocess.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;EAUb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"postprocessVertexShader\";\nconst shader = `attribute vec2 position;\runiform vec2 scale;\rvarying vec2 vUV;\rconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvUV=(position*madd+madd)*scale;\rgl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const postprocessVertexShader = { name, shader };\n"]}

package/Shaders/procedural.vertex.d.ts

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

package/Shaders/procedural.vertex.js

@@ -7,6 +7,6 @@ vPosition=position;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const proceduralVertexShader = { name, shader };
 //# sourceMappingURL=procedural.vertex.js.map

package/Shaders/procedural.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"procedural.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/procedural.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;EAWb,CAAC;AACH,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 = \"proceduralVertexShader\";\nconst shader = `attribute vec2 position;\rvarying vec2 vPosition;\rvarying vec2 vUV;\rconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvPosition=position;\rvUV=position*madd+madd;\rgl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const proceduralVertexShader = { name, shader };\n"]}
+{"version":3,"file":"procedural.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/procedural.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;EAWb,CAAC;AACH,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 = \"proceduralVertexShader\";\nconst shader = `attribute vec2 position;\rvarying vec2 vPosition;\rvarying vec2 vUV;\rconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvPosition=position;\rvUV=position*madd+madd;\rgl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const proceduralVertexShader = { name, shader };\n"]}

package/Shaders/refraction.fragment.d.ts

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

package/Shaders/refraction.fragment.js

@@ -4,6 +4,6 @@ const name = "refractionPixelShader";
 const shader = `varying vec2 vUV;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const refractionPixelShader = { name, shader };
 //# sourceMappingURL=refraction.fragment.js.map

package/Shaders/refraction.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"refraction.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/refraction.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,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 = \"refractionPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform sampler2D refractionSampler;\runiform vec3 baseColor;\runiform float depth;\runiform float colorLevel;\rvoid main() {\rfloat ref=1.0-texture2D(refractionSampler,vUV).r;\rvec2 uv=vUV-vec2(0.5);\rvec2 offset=uv*depth*ref;\rvec3 sourceColor=texture2D(textureSampler,vUV-offset).rgb;\rgl_FragColor=vec4(sourceColor+sourceColor*ref*colorLevel,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const refractionPixelShader = { name, shader };\n"]}
+{"version":3,"file":"refraction.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/refraction.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,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 = \"refractionPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform sampler2D refractionSampler;\runiform vec3 baseColor;\runiform float depth;\runiform float colorLevel;\rvoid main() {\rfloat ref=1.0-texture2D(refractionSampler,vUV).r;\rvec2 uv=vUV-vec2(0.5);\rvec2 offset=uv*depth*ref;\rvec3 sourceColor=texture2D(textureSampler,vUV-offset).rgb;\rgl_FragColor=vec4(sourceColor+sourceColor*ref*colorLevel,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const refractionPixelShader = { name, shader };\n"]}

package/Shaders/rgbdDecode.fragment.d.ts

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

package/Shaders/rgbdDecode.fragment.js

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

package/Shaders/rgbdDecode.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"rgbdDecode.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/rgbdDecode.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;EAOb,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/helperFunctions\";\n\nconst name = \"rgbdDecodePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#include<helperFunctions>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rgl_FragColor=vec4(fromRGBD(texture2D(textureSampler,vUV)),1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const rgbdDecodePixelShader = { name, shader };\n"]}
+{"version":3,"file":"rgbdDecode.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/rgbdDecode.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;EAOb,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/helperFunctions\";\n\nconst name = \"rgbdDecodePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#include<helperFunctions>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rgl_FragColor=vec4(fromRGBD(texture2D(textureSampler,vUV)),1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const rgbdDecodePixelShader = { name, shader };\n"]}

package/Shaders/rgbdEncode.fragment.d.ts

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

package/Shaders/rgbdEncode.fragment.js

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

package/Shaders/rgbdEncode.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"rgbdEncode.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/rgbdEncode.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;EAOb,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/helperFunctions\";\n\nconst name = \"rgbdEncodePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#include<helperFunctions>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rgl_FragColor=toRGBD(texture2D(textureSampler,vUV).rgb);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const rgbdEncodePixelShader = { name, shader };\n"]}
+{"version":3,"file":"rgbdEncode.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/rgbdEncode.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;EAOb,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/helperFunctions\";\n\nconst name = \"rgbdEncodePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#include<helperFunctions>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rgl_FragColor=toRGBD(texture2D(textureSampler,vUV).rgb);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const rgbdEncodePixelShader = { name, shader };\n"]}

package/Shaders/screenSpaceCurvature.fragment.d.ts

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

package/Shaders/screenSpaceCurvature.fragment.js

@@ -8,6 +8,6 @@ float curvature_soft_clamp(float curvature,float control)
 void main(void) 
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const screenSpaceCurvaturePixelShader = { name, shader };
 //# sourceMappingURL=screenSpaceCurvature.fragment.js.map

package/Shaders/screenSpaceCurvature.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"screenSpaceCurvature.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/screenSpaceCurvature.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,iCAAiC,CAAC;AAC/C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCb,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\";\n\nconst name = \"screenSpaceCurvaturePixelShader\";\nconst shader = `precision highp float;\rvarying vec2 vUV;\runiform sampler2D textureSampler;\runiform sampler2D normalSampler;\runiform float curvature_ridge;\runiform float curvature_valley;\r#ifndef CURVATURE_OFFSET\n#define CURVATURE_OFFSET 1\n#endif\nfloat curvature_soft_clamp(float curvature,float control)\r{\rif (curvature<0.5/control)\rreturn curvature*(1.0-curvature*control);\rreturn 0.25/control;\r}\rfloat calculate_curvature(ivec2 texel,float ridge,float valley)\r{\rvec2 normal_up =texelFetch(normalSampler,texel+ivec2(0, CURVATURE_OFFSET),0).rb;\rvec2 normal_down =texelFetch(normalSampler,texel+ivec2(0,-CURVATURE_OFFSET),0).rb;\rvec2 normal_left =texelFetch(normalSampler,texel+ivec2(-CURVATURE_OFFSET,0),0).rb;\rvec2 normal_right=texelFetch(normalSampler,texel+ivec2( CURVATURE_OFFSET,0),0).rb;\rfloat normal_diff=((normal_up.g-normal_down.g)+(normal_right.r-normal_left.r));\rif (normal_diff<0.0)\rreturn -2.0*curvature_soft_clamp(-normal_diff,valley);\rreturn 2.0*curvature_soft_clamp(normal_diff,ridge);\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rivec2 texel=ivec2(gl_FragCoord.xy);\rvec4 baseColor=texture2D(textureSampler,vUV);\rfloat curvature=calculate_curvature(texel,curvature_ridge,curvature_valley);\rbaseColor.rgb*=curvature+1.0;\rgl_FragColor=baseColor;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const screenSpaceCurvaturePixelShader = { name, shader };\n"]}
+{"version":3,"file":"screenSpaceCurvature.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/screenSpaceCurvature.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,iCAAiC,CAAC;AAC/C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCb,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\";\n\nconst name = \"screenSpaceCurvaturePixelShader\";\nconst shader = `precision highp float;\rvarying vec2 vUV;\runiform sampler2D textureSampler;\runiform sampler2D normalSampler;\runiform float curvature_ridge;\runiform float curvature_valley;\r#ifndef CURVATURE_OFFSET\n#define CURVATURE_OFFSET 1\n#endif\nfloat curvature_soft_clamp(float curvature,float control)\r{\rif (curvature<0.5/control)\rreturn curvature*(1.0-curvature*control);\rreturn 0.25/control;\r}\rfloat calculate_curvature(ivec2 texel,float ridge,float valley)\r{\rvec2 normal_up =texelFetch(normalSampler,texel+ivec2(0, CURVATURE_OFFSET),0).rb;\rvec2 normal_down =texelFetch(normalSampler,texel+ivec2(0,-CURVATURE_OFFSET),0).rb;\rvec2 normal_left =texelFetch(normalSampler,texel+ivec2(-CURVATURE_OFFSET,0),0).rb;\rvec2 normal_right=texelFetch(normalSampler,texel+ivec2( CURVATURE_OFFSET,0),0).rb;\rfloat normal_diff=((normal_up.g-normal_down.g)+(normal_right.r-normal_left.r));\rif (normal_diff<0.0)\rreturn -2.0*curvature_soft_clamp(-normal_diff,valley);\rreturn 2.0*curvature_soft_clamp(normal_diff,ridge);\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rivec2 texel=ivec2(gl_FragCoord.xy);\rvec4 baseColor=texture2D(textureSampler,vUV);\rfloat curvature=calculate_curvature(texel,curvature_ridge,curvature_valley);\rbaseColor.rgb*=curvature+1.0;\rgl_FragColor=baseColor;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const screenSpaceCurvaturePixelShader = { name, shader };\n"]}

package/Shaders/screenSpaceReflection.fragment.d.ts

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

package/Shaders/screenSpaceReflection.fragment.js

@@ -18,6 +18,6 @@ gl_FragColor=texture2D(textureSampler,vUV);
 }
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const screenSpaceReflectionPixelShader = { name, shader };
 //# sourceMappingURL=screenSpaceReflection.fragment.js.map

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