@babylonjs/core 5.24.0 → 5.26.0

package/Shaders/gpuRenderParticles.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"gpuRenderParticles.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuRenderParticles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,8CAA8C,CAAC;AACtD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsIb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration2\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"gpuRenderParticlesVertexShader\";\nconst shader = `precision highp float;\runiform mat4 view;\runiform mat4 projection;\runiform vec2 translationPivot;\runiform vec3 worldOffset;\r#ifdef LOCAL\nuniform mat4 emitterWM;\r#endif\nattribute vec3 position;\rattribute float age;\rattribute float life;\rattribute vec3 size;\r#ifndef BILLBOARD\nattribute vec3 initialDirection;\r#endif\n#ifdef BILLBOARDSTRETCHED\nattribute vec3 direction;\r#endif\nattribute float angle;\r#ifdef ANIMATESHEET\nattribute float cellIndex;\r#endif\nattribute vec2 offset;\rattribute vec2 uv;\rvarying vec2 vUV;\rvarying vec4 vColor;\rvarying vec3 vPositionW;\r#if defined(BILLBOARD) && !defined(BILLBOARDY) && !defined(BILLBOARDSTRETCHED)\nuniform mat4 invView;\r#endif\n#include<clipPlaneVertexDeclaration2>\n#ifdef COLORGRADIENTS\nuniform sampler2D colorGradientSampler;\r#else\nuniform vec4 colorDead;\rattribute vec4 color;\r#endif\n#ifdef ANIMATESHEET\nuniform vec3 sheetInfos;\r#endif\n#ifdef BILLBOARD\nuniform vec3 eyePosition;\r#endif\nvec3 rotate(vec3 yaxis,vec3 rotatedCorner) {\rvec3 xaxis=normalize(cross(vec3(0.,1.0,0.),yaxis));\rvec3 zaxis=normalize(cross(yaxis,xaxis));\rvec3 row0=vec3(xaxis.x,xaxis.y,xaxis.z);\rvec3 row1=vec3(yaxis.x,yaxis.y,yaxis.z);\rvec3 row2=vec3(zaxis.x,zaxis.y,zaxis.z);\rmat3 rotMatrix= mat3(row0,row1,row2);\rvec3 alignedCorner=rotMatrix*rotatedCorner;\r#ifdef LOCAL\nreturn ((emitterWM*vec4(position,1.0)).xyz+worldOffset)+alignedCorner;\r#else\nreturn (position+worldOffset)+alignedCorner;\r#endif\n}\r#ifdef BILLBOARDSTRETCHED\nvec3 rotateAlign(vec3 toCamera,vec3 rotatedCorner) {\rvec3 normalizedToCamera=normalize(toCamera);\rvec3 normalizedCrossDirToCamera=normalize(cross(normalize(direction),normalizedToCamera));\rvec3 crossProduct=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));\rvec3 row0=vec3(normalizedCrossDirToCamera.x,normalizedCrossDirToCamera.y,normalizedCrossDirToCamera.z);\rvec3 row1=vec3(crossProduct.x,crossProduct.y,crossProduct.z);\rvec3 row2=vec3(normalizedToCamera.x,normalizedToCamera.y,normalizedToCamera.z);\rmat3 rotMatrix= mat3(row0,row1,row2);\rvec3 alignedCorner=rotMatrix*rotatedCorner;\r#ifdef LOCAL\nreturn ((emitterWM*vec4(position,1.0)).xyz+worldOffset)+alignedCorner;\r#else\nreturn (position+worldOffset)+alignedCorner;\r#endif\n}\r#endif\nvoid main() {\r#ifdef ANIMATESHEET\nfloat rowOffset=floor(cellIndex/sheetInfos.z);\rfloat columnOffset=cellIndex-rowOffset*sheetInfos.z;\rvec2 uvScale=sheetInfos.xy;\rvec2 uvOffset=vec2(uv.x ,1.0-uv.y);\rvUV=(uvOffset+vec2(columnOffset,rowOffset))*uvScale;\r#else\nvUV=uv;\r#endif\nfloat ratio=age/life;\r#ifdef COLORGRADIENTS\nvColor=texture2D(colorGradientSampler,vec2(ratio,0));\r#else\nvColor=color*vec4(1.0-ratio)+colorDead*vec4(ratio);\r#endif\nvec2 cornerPos=(offset-translationPivot)*size.yz*size.x+translationPivot;\r#ifdef BILLBOARD\nvec4 rotatedCorner;\rrotatedCorner.w=0.;\r#ifdef BILLBOARDY\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.z=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.y=0.;\rvec3 yaxis=(position+worldOffset)-eyePosition;\ryaxis.y=0.;\rvPositionW=rotate(normalize(yaxis),rotatedCorner.xyz);\rvec4 viewPosition=(view*vec4(vPositionW,1.0));\r#elif defined(BILLBOARDSTRETCHED)\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\rvec3 toCamera=(position+worldOffset)-eyePosition;\rvPositionW=rotateAlign(toCamera,rotatedCorner.xyz);\rvec4 viewPosition=(view*vec4(vPositionW,1.0));\r#else\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\r#ifdef LOCAL\nvec4 viewPosition=view*vec4(((emitterWM*vec4(position,1.0)).xyz+worldOffset),1.0)+rotatedCorner;\r#else\nvec4 viewPosition=view*vec4((position+worldOffset),1.0)+rotatedCorner;\r#endif\nvPositionW=(invView*viewPosition).xyz;\r#endif\n#else\nvec3 rotatedCorner;\rrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=0.;\rrotatedCorner.z=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rvec3 yaxis=normalize(initialDirection);\rvPositionW=rotate(yaxis,rotatedCorner);\rvec4 viewPosition=view*vec4(vPositionW,1.0);\r#endif\ngl_Position=projection*viewPosition;\r#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)\nvec4 worldPos=vec4(vPositionW,1.0);\r#endif\n#include<clipPlaneVertex>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const gpuRenderParticlesVertexShader = { name, shader };\n"]}
+{"version":3,"file":"gpuRenderParticles.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuRenderParticles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,8CAA8C,CAAC;AACtD,OAAO,sCAAsC,CAAC;AAC9C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,iCAAiC,CAAC;AAEzC,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwIb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration2\";\nimport \"./ShadersInclude/logDepthDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertex\";\nimport \"./ShadersInclude/logDepthVertex\";\n\nconst name = \"gpuRenderParticlesVertexShader\";\nconst shader = `precision highp float;\runiform mat4 view;\runiform mat4 projection;\runiform vec2 translationPivot;\runiform vec3 worldOffset;\r#ifdef LOCAL\nuniform mat4 emitterWM;\r#endif\nattribute vec3 position;\rattribute float age;\rattribute float life;\rattribute vec3 size;\r#ifndef BILLBOARD\nattribute vec3 initialDirection;\r#endif\n#ifdef BILLBOARDSTRETCHED\nattribute vec3 direction;\r#endif\nattribute float angle;\r#ifdef ANIMATESHEET\nattribute float cellIndex;\r#endif\nattribute vec2 offset;\rattribute vec2 uv;\rvarying vec2 vUV;\rvarying vec4 vColor;\rvarying vec3 vPositionW;\r#if defined(BILLBOARD) && !defined(BILLBOARDY) && !defined(BILLBOARDSTRETCHED)\nuniform mat4 invView;\r#endif\n#include<clipPlaneVertexDeclaration2>\n#include<logDepthDeclaration>\n#ifdef COLORGRADIENTS\nuniform sampler2D colorGradientSampler;\r#else\nuniform vec4 colorDead;\rattribute vec4 color;\r#endif\n#ifdef ANIMATESHEET\nuniform vec3 sheetInfos;\r#endif\n#ifdef BILLBOARD\nuniform vec3 eyePosition;\r#endif\nvec3 rotate(vec3 yaxis,vec3 rotatedCorner) {\rvec3 xaxis=normalize(cross(vec3(0.,1.0,0.),yaxis));\rvec3 zaxis=normalize(cross(yaxis,xaxis));\rvec3 row0=vec3(xaxis.x,xaxis.y,xaxis.z);\rvec3 row1=vec3(yaxis.x,yaxis.y,yaxis.z);\rvec3 row2=vec3(zaxis.x,zaxis.y,zaxis.z);\rmat3 rotMatrix= mat3(row0,row1,row2);\rvec3 alignedCorner=rotMatrix*rotatedCorner;\r#ifdef LOCAL\nreturn ((emitterWM*vec4(position,1.0)).xyz+worldOffset)+alignedCorner;\r#else\nreturn (position+worldOffset)+alignedCorner;\r#endif\n}\r#ifdef BILLBOARDSTRETCHED\nvec3 rotateAlign(vec3 toCamera,vec3 rotatedCorner) {\rvec3 normalizedToCamera=normalize(toCamera);\rvec3 normalizedCrossDirToCamera=normalize(cross(normalize(direction),normalizedToCamera));\rvec3 crossProduct=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));\rvec3 row0=vec3(normalizedCrossDirToCamera.x,normalizedCrossDirToCamera.y,normalizedCrossDirToCamera.z);\rvec3 row1=vec3(crossProduct.x,crossProduct.y,crossProduct.z);\rvec3 row2=vec3(normalizedToCamera.x,normalizedToCamera.y,normalizedToCamera.z);\rmat3 rotMatrix= mat3(row0,row1,row2);\rvec3 alignedCorner=rotMatrix*rotatedCorner;\r#ifdef LOCAL\nreturn ((emitterWM*vec4(position,1.0)).xyz+worldOffset)+alignedCorner;\r#else\nreturn (position+worldOffset)+alignedCorner;\r#endif\n}\r#endif\nvoid main() {\r#ifdef ANIMATESHEET\nfloat rowOffset=floor(cellIndex/sheetInfos.z);\rfloat columnOffset=cellIndex-rowOffset*sheetInfos.z;\rvec2 uvScale=sheetInfos.xy;\rvec2 uvOffset=vec2(uv.x ,1.0-uv.y);\rvUV=(uvOffset+vec2(columnOffset,rowOffset))*uvScale;\r#else\nvUV=uv;\r#endif\nfloat ratio=age/life;\r#ifdef COLORGRADIENTS\nvColor=texture2D(colorGradientSampler,vec2(ratio,0));\r#else\nvColor=color*vec4(1.0-ratio)+colorDead*vec4(ratio);\r#endif\nvec2 cornerPos=(offset-translationPivot)*size.yz*size.x+translationPivot;\r#ifdef BILLBOARD\nvec4 rotatedCorner;\rrotatedCorner.w=0.;\r#ifdef BILLBOARDY\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.z=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.y=0.;\rvec3 yaxis=(position+worldOffset)-eyePosition;\ryaxis.y=0.;\rvPositionW=rotate(normalize(yaxis),rotatedCorner.xyz);\rvec4 viewPosition=(view*vec4(vPositionW,1.0));\r#elif defined(BILLBOARDSTRETCHED)\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\rvec3 toCamera=(position+worldOffset)-eyePosition;\rvPositionW=rotateAlign(toCamera,rotatedCorner.xyz);\rvec4 viewPosition=(view*vec4(vPositionW,1.0));\r#else\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\r#ifdef LOCAL\nvec4 viewPosition=view*vec4(((emitterWM*vec4(position,1.0)).xyz+worldOffset),1.0)+rotatedCorner;\r#else\nvec4 viewPosition=view*vec4((position+worldOffset),1.0)+rotatedCorner;\r#endif\nvPositionW=(invView*viewPosition).xyz;\r#endif\n#else\nvec3 rotatedCorner;\rrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=0.;\rrotatedCorner.z=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rvec3 yaxis=normalize(initialDirection);\rvPositionW=rotate(yaxis,rotatedCorner);\rvec4 viewPosition=view*vec4(vPositionW,1.0);\r#endif\ngl_Position=projection*viewPosition;\r#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)\nvec4 worldPos=vec4(vPositionW,1.0);\r#endif\n#include<clipPlaneVertex>\n#include<logDepthVertex>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const gpuRenderParticlesVertexShader = { name, shader };\n"]}

package/Shaders/gpuUpdateParticles.fragment.d.ts

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

package/Shaders/gpuUpdateParticles.fragment.js

@@ -5,6 +5,6 @@ const shader = `#version 300 es
 void main() {
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const gpuUpdateParticlesPixelShader = { name, shader };
 //# sourceMappingURL=gpuUpdateParticles.fragment.js.map

package/Shaders/gpuUpdateParticles.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"gpuUpdateParticles.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuUpdateParticles.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,MAAM,GAAG;;;;CAId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpuUpdateParticlesPixelShader\";\nconst shader = `#version 300 es\nvoid main() {\rdiscard;\r}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const gpuUpdateParticlesPixelShader = { name, shader };\n"]}
+{"version":3,"file":"gpuUpdateParticles.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuUpdateParticles.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,MAAM,GAAG;;;;CAId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpuUpdateParticlesPixelShader\";\nconst shader = `#version 300 es\nvoid main() {\rdiscard;\r}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const gpuUpdateParticlesPixelShader = { name, shader };\n"]}

package/Shaders/gpuUpdateParticles.vertex.d.ts

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

package/Shaders/gpuUpdateParticles.vertex.js

@@ -146,6 +146,6 @@ float ratio=0.;
 }
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const gpuUpdateParticlesVertexShader = { name, shader };
 //# sourceMappingURL=gpuUpdateParticles.vertex.js.map

package/Shaders/gpuUpdateParticles.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"gpuUpdateParticles.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuUpdateParticles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Wb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpuUpdateParticlesVertexShader\";\nconst shader = `#version 300 es\n#define PI 3.14159\nuniform float currentCount;\runiform float timeDelta;\runiform float stopFactor;\r#ifndef LOCAL\nuniform mat4 emitterWM;\r#endif\nuniform vec2 lifeTime;\runiform vec2 emitPower;\runiform vec2 sizeRange;\runiform vec4 scaleRange;\r#ifndef COLORGRADIENTS\nuniform vec4 color1;\runiform vec4 color2;\r#endif\nuniform vec3 gravity;\runiform sampler2D randomSampler;\runiform sampler2D randomSampler2;\runiform vec4 angleRange;\r#ifdef BOXEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\runiform vec3 minEmitBox;\runiform vec3 maxEmitBox;\r#endif\n#ifdef POINTEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#endif\n#ifdef HEMISPHERICEMITTER\nuniform float radius;\runiform float radiusRange;\runiform float directionRandomizer;\r#endif\n#ifdef SPHEREEMITTER\nuniform float radius;\runiform float radiusRange;\r#ifdef DIRECTEDSPHEREEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#else\nuniform float directionRandomizer;\r#endif\n#endif\n#ifdef CYLINDEREMITTER\nuniform float radius;\runiform float height;\runiform float radiusRange;\r#ifdef DIRECTEDCYLINDEREMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#else\nuniform float directionRandomizer;\r#endif\n#endif\n#ifdef CONEEMITTER\nuniform vec2 radius;\runiform float coneAngle;\runiform vec2 height;\runiform float directionRandomizer;\r#endif\nin vec3 position;\r#ifdef CUSTOMEMITTER\nin vec3 initialPosition;\r#endif\nin float age;\rin float life;\rin vec4 seed;\rin vec3 size;\r#ifndef COLORGRADIENTS\nin vec4 color;\r#endif\nin vec3 direction;\r#ifndef BILLBOARD\nin vec3 initialDirection;\r#endif\n#ifdef ANGULARSPEEDGRADIENTS\nin float angle;\r#else\nin vec2 angle;\r#endif\n#ifdef ANIMATESHEET\nin float cellIndex;\r#ifdef ANIMATESHEETRANDOMSTART\nin float cellStartOffset;\r#endif\n#endif\n#ifdef NOISE\nin vec3 noiseCoordinates1;\rin vec3 noiseCoordinates2;\r#endif\nout vec3 outPosition;\r#ifdef CUSTOMEMITTER\nout vec3 outInitialPosition;\r#endif\nout float outAge;\rout float outLife;\rout vec4 outSeed;\rout vec3 outSize;\r#ifndef COLORGRADIENTS\nout vec4 outColor;\r#endif\nout vec3 outDirection;\r#ifndef BILLBOARD\nout vec3 outInitialDirection;\r#endif\n#ifdef ANGULARSPEEDGRADIENTS\nout float outAngle;\r#else\nout vec2 outAngle;\r#endif\n#ifdef ANIMATESHEET\nout float outCellIndex;\r#ifdef ANIMATESHEETRANDOMSTART\nout float outCellStartOffset;\r#endif\n#endif\n#ifdef NOISE\nout vec3 outNoiseCoordinates1;\rout vec3 outNoiseCoordinates2;\r#endif\n#ifdef SIZEGRADIENTS\nuniform sampler2D sizeGradientSampler;\r#endif \n#ifdef ANGULARSPEEDGRADIENTS\nuniform sampler2D angularSpeedGradientSampler;\r#endif \n#ifdef VELOCITYGRADIENTS\nuniform sampler2D velocityGradientSampler;\r#endif\n#ifdef LIMITVELOCITYGRADIENTS\nuniform sampler2D limitVelocityGradientSampler;\runiform float limitVelocityDamping;\r#endif\n#ifdef DRAGGRADIENTS\nuniform sampler2D dragGradientSampler;\r#endif\n#ifdef NOISE\nuniform vec3 noiseStrength;\runiform sampler2D noiseSampler;\r#endif\n#ifdef ANIMATESHEET\nuniform vec4 cellInfos;\r#endif\nvec3 getRandomVec3(float offset) {\rreturn texture(randomSampler2,vec2(float(gl_VertexID)*offset/currentCount,0)).rgb;\r}\rvec4 getRandomVec4(float offset) {\rreturn texture(randomSampler,vec2(float(gl_VertexID)*offset/currentCount,0));\r}\rvoid main() {\rfloat newAge=age+timeDelta; \rif (newAge>=life && stopFactor != 0.) {\rvec3 newPosition;\rvec3 newDirection;\rvec4 randoms=getRandomVec4(seed.x);\routLife=lifeTime.x+(lifeTime.y-lifeTime.x)*randoms.r;\routAge=newAge-life;\routSeed=seed;\r#ifdef SIZEGRADIENTS \noutSize.x=texture(sizeGradientSampler,vec2(0,0)).r;\r#else\noutSize.x=sizeRange.x+(sizeRange.y-sizeRange.x)*randoms.g;\r#endif\noutSize.y=scaleRange.x+(scaleRange.y-scaleRange.x)*randoms.b;\routSize.z=scaleRange.z+(scaleRange.w-scaleRange.z)*randoms.a; \r#ifndef COLORGRADIENTS\noutColor=color1+(color2-color1)*randoms.b;\r#endif\n#ifndef ANGULARSPEEDGRADIENTS \noutAngle.y=angleRange.x+(angleRange.y-angleRange.x)*randoms.a;\routAngle.x=angleRange.z+(angleRange.w-angleRange.z)*randoms.r;\r#else\noutAngle=angleRange.z+(angleRange.w-angleRange.z)*randoms.r;\r#endif \n#ifdef POINTEMITTER\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rnewPosition=vec3(0,0,0);\rnewDirection=direction1+(direction2-direction1)*randoms3;\r#elif defined(BOXEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rnewPosition=minEmitBox+(maxEmitBox-minEmitBox)*randoms2;\rnewDirection=direction1+(direction2-direction1)*randoms3; \r#elif defined(HEMISPHERICEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat phi=2.0*PI*randoms2.x;\rfloat theta=acos(2.0*randoms2.y-1.0);\rfloat randX=cos(phi)*sin(theta);\rfloat randY=cos(theta);\rfloat randZ=sin(phi)*sin(theta);\rnewPosition=(radius-(radius*radiusRange*randoms2.z))*vec3(randX,abs(randY),randZ);\rnewDirection=newPosition+directionRandomizer*randoms3; \r#elif defined(SPHEREEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat phi=2.0*PI*randoms2.x;\rfloat theta=acos(2.0*randoms2.y-1.0);\rfloat randX=cos(phi)*sin(theta);\rfloat randY=cos(theta);\rfloat randZ=sin(phi)*sin(theta);\rnewPosition=(radius-(radius*radiusRange*randoms2.z))*vec3(randX,randY,randZ);\r#ifdef DIRECTEDSPHEREEMITTER\nnewDirection=normalize(direction1+(direction2-direction1)*randoms3);\r#else\nnewDirection=normalize(newPosition+directionRandomizer*randoms3);\r#endif\n#elif defined(CYLINDEREMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat yPos=(randoms2.x-0.5)*height;\rfloat angle=randoms2.y*PI*2.;\rfloat inverseRadiusRangeSquared=((1.-radiusRange)*(1.-radiusRange));\rfloat positionRadius=radius*sqrt(inverseRadiusRangeSquared+(randoms2.z*(1.-inverseRadiusRangeSquared)));\rfloat xPos=positionRadius*cos(angle);\rfloat zPos=positionRadius*sin(angle);\rnewPosition=vec3(xPos,yPos,zPos);\r#ifdef DIRECTEDCYLINDEREMITTER\nnewDirection=direction1+(direction2-direction1)*randoms3;\r#else\nangle=angle+((randoms3.x-0.5)*PI)*directionRandomizer;\rnewDirection=vec3(cos(angle),(randoms3.y-0.5)*directionRandomizer,sin(angle));\rnewDirection=normalize(newDirection);\r#endif\n#elif defined(CONEEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rfloat s=2.0*PI*randoms2.x;\r#ifdef CONEEMITTERSPAWNPOINT\nfloat h=0.0001;\r#else\nfloat h=randoms2.y*height.y;\rh=1.-h*h; \r#endif\nfloat lRadius=radius.x-radius.x*randoms2.z*radius.y;\rlRadius=lRadius*h;\rfloat randX=lRadius*sin(s);\rfloat randZ=lRadius*cos(s);\rfloat randY=h *height.x;\rnewPosition=vec3(randX,randY,randZ); \rif (abs(cos(coneAngle))==1.0) {\rnewDirection=vec3(0.,1.0,0.);\r} else {\rvec3 randoms3=getRandomVec3(seed.z);\rnewDirection=normalize(newPosition+directionRandomizer*randoms3); \r}\r#elif defined(CUSTOMEMITTER)\nnewPosition=initialPosition;\routInitialPosition=initialPosition;\r#else \nnewPosition=vec3(0.,0.,0.);\rnewDirection=2.0*(getRandomVec3(seed.w)-vec3(0.5,0.5,0.5));\r#endif\nfloat power=emitPower.x+(emitPower.y-emitPower.x)*randoms.a;\r#ifdef LOCAL\noutPosition=newPosition;\r#else\noutPosition=(emitterWM*vec4(newPosition,1.)).xyz;\r#endif\n#ifdef CUSTOMEMITTER\noutDirection=direction;\r#ifndef BILLBOARD \noutInitialDirection=direction;\r#endif\n#else\n#ifdef LOCAL\nvec3 initial=newDirection;\r#else \nvec3 initial=(emitterWM*vec4(newDirection,0.)).xyz;\r#endif\noutDirection=initial*power;\r#ifndef BILLBOARD \noutInitialDirection=initial;\r#endif\n#endif\n#ifdef ANIMATESHEET \noutCellIndex=cellInfos.x;\r#ifdef ANIMATESHEETRANDOMSTART\noutCellStartOffset=randoms.a*outLife;\r#endif \n#endif\n#ifdef NOISE\noutNoiseCoordinates1=noiseCoordinates1;\routNoiseCoordinates2=noiseCoordinates2;\r#endif\n} else {\rfloat directionScale=timeDelta;\routAge=newAge;\rfloat ageGradient=newAge/life;\r#ifdef VELOCITYGRADIENTS\ndirectionScale*=texture(velocityGradientSampler,vec2(ageGradient,0)).r;\r#endif\n#ifdef DRAGGRADIENTS\ndirectionScale*=1.0-texture(dragGradientSampler,vec2(ageGradient,0)).r;\r#endif\n#if defined(CUSTOMEMITTER)\noutPosition=position+(direction-position)*ageGradient; \routInitialPosition=initialPosition;\r#else\noutPosition=position+direction*directionScale;\r#endif\noutLife=life;\routSeed=seed;\r#ifndef COLORGRADIENTS \noutColor=color;\r#endif\n#ifdef SIZEGRADIENTS\noutSize.x=texture(sizeGradientSampler,vec2(ageGradient,0)).r;\routSize.yz=size.yz;\r#else\noutSize=size;\r#endif \n#ifndef BILLBOARD \noutInitialDirection=initialDirection;\r#endif\n#ifdef CUSTOMEMITTER\noutDirection=direction;\r#else\nvec3 updatedDirection=direction+gravity*timeDelta;\r#ifdef LIMITVELOCITYGRADIENTS\nfloat limitVelocity=texture(limitVelocityGradientSampler,vec2(ageGradient,0)).r;\rfloat currentVelocity=length(updatedDirection);\rif (currentVelocity>limitVelocity) {\rupdatedDirection=updatedDirection*limitVelocityDamping;\r}\r#endif\noutDirection=updatedDirection;\r#ifdef NOISE\nfloat fetchedR=texture(noiseSampler,vec2(noiseCoordinates1.x,noiseCoordinates1.y)*vec2(0.5)+vec2(0.5)).r;\rfloat fetchedG=texture(noiseSampler,vec2(noiseCoordinates1.z,noiseCoordinates2.x)*vec2(0.5)+vec2(0.5)).r;\rfloat fetchedB=texture(noiseSampler,vec2(noiseCoordinates2.y,noiseCoordinates2.z)*vec2(0.5)+vec2(0.5)).r;\rvec3 force=vec3(2.*fetchedR-1.,2.*fetchedG-1.,2.*fetchedB-1.)*noiseStrength;\routDirection=outDirection+force*timeDelta;\routNoiseCoordinates1=noiseCoordinates1;\routNoiseCoordinates2=noiseCoordinates2;\r#endif \n#endif \n#ifdef ANGULARSPEEDGRADIENTS\nfloat angularSpeed=texture(angularSpeedGradientSampler,vec2(ageGradient,0)).r;\routAngle=angle+angularSpeed*timeDelta;\r#else\noutAngle=vec2(angle.x+angle.y*timeDelta,angle.y);\r#endif\n#ifdef ANIMATESHEET \nfloat offsetAge=outAge;\rfloat dist=cellInfos.y-cellInfos.x;\r#ifdef ANIMATESHEETRANDOMSTART\noutCellStartOffset=cellStartOffset;\roffsetAge+=cellStartOffset;\r#else\nfloat cellStartOffset=0.;\r#endif \nfloat ratio=0.;\rif (cellInfos.w==1.0) {\rratio=clamp(mod(cellStartOffset+cellInfos.z*offsetAge,life)/life,0.,1.0);\r}\relse {\rratio=clamp(cellStartOffset+cellInfos.z*offsetAge/life,0.,1.0);\r}\routCellIndex=float(int(cellInfos.x+ratio*dist));\r#endif\n}\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const gpuUpdateParticlesVertexShader = { name, shader };\n"]}
+{"version":3,"file":"gpuUpdateParticles.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuUpdateParticles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Wb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpuUpdateParticlesVertexShader\";\nconst shader = `#version 300 es\n#define PI 3.14159\nuniform float currentCount;\runiform float timeDelta;\runiform float stopFactor;\r#ifndef LOCAL\nuniform mat4 emitterWM;\r#endif\nuniform vec2 lifeTime;\runiform vec2 emitPower;\runiform vec2 sizeRange;\runiform vec4 scaleRange;\r#ifndef COLORGRADIENTS\nuniform vec4 color1;\runiform vec4 color2;\r#endif\nuniform vec3 gravity;\runiform sampler2D randomSampler;\runiform sampler2D randomSampler2;\runiform vec4 angleRange;\r#ifdef BOXEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\runiform vec3 minEmitBox;\runiform vec3 maxEmitBox;\r#endif\n#ifdef POINTEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#endif\n#ifdef HEMISPHERICEMITTER\nuniform float radius;\runiform float radiusRange;\runiform float directionRandomizer;\r#endif\n#ifdef SPHEREEMITTER\nuniform float radius;\runiform float radiusRange;\r#ifdef DIRECTEDSPHEREEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#else\nuniform float directionRandomizer;\r#endif\n#endif\n#ifdef CYLINDEREMITTER\nuniform float radius;\runiform float height;\runiform float radiusRange;\r#ifdef DIRECTEDCYLINDEREMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#else\nuniform float directionRandomizer;\r#endif\n#endif\n#ifdef CONEEMITTER\nuniform vec2 radius;\runiform float coneAngle;\runiform vec2 height;\runiform float directionRandomizer;\r#endif\nin vec3 position;\r#ifdef CUSTOMEMITTER\nin vec3 initialPosition;\r#endif\nin float age;\rin float life;\rin vec4 seed;\rin vec3 size;\r#ifndef COLORGRADIENTS\nin vec4 color;\r#endif\nin vec3 direction;\r#ifndef BILLBOARD\nin vec3 initialDirection;\r#endif\n#ifdef ANGULARSPEEDGRADIENTS\nin float angle;\r#else\nin vec2 angle;\r#endif\n#ifdef ANIMATESHEET\nin float cellIndex;\r#ifdef ANIMATESHEETRANDOMSTART\nin float cellStartOffset;\r#endif\n#endif\n#ifdef NOISE\nin vec3 noiseCoordinates1;\rin vec3 noiseCoordinates2;\r#endif\nout vec3 outPosition;\r#ifdef CUSTOMEMITTER\nout vec3 outInitialPosition;\r#endif\nout float outAge;\rout float outLife;\rout vec4 outSeed;\rout vec3 outSize;\r#ifndef COLORGRADIENTS\nout vec4 outColor;\r#endif\nout vec3 outDirection;\r#ifndef BILLBOARD\nout vec3 outInitialDirection;\r#endif\n#ifdef ANGULARSPEEDGRADIENTS\nout float outAngle;\r#else\nout vec2 outAngle;\r#endif\n#ifdef ANIMATESHEET\nout float outCellIndex;\r#ifdef ANIMATESHEETRANDOMSTART\nout float outCellStartOffset;\r#endif\n#endif\n#ifdef NOISE\nout vec3 outNoiseCoordinates1;\rout vec3 outNoiseCoordinates2;\r#endif\n#ifdef SIZEGRADIENTS\nuniform sampler2D sizeGradientSampler;\r#endif \n#ifdef ANGULARSPEEDGRADIENTS\nuniform sampler2D angularSpeedGradientSampler;\r#endif \n#ifdef VELOCITYGRADIENTS\nuniform sampler2D velocityGradientSampler;\r#endif\n#ifdef LIMITVELOCITYGRADIENTS\nuniform sampler2D limitVelocityGradientSampler;\runiform float limitVelocityDamping;\r#endif\n#ifdef DRAGGRADIENTS\nuniform sampler2D dragGradientSampler;\r#endif\n#ifdef NOISE\nuniform vec3 noiseStrength;\runiform sampler2D noiseSampler;\r#endif\n#ifdef ANIMATESHEET\nuniform vec4 cellInfos;\r#endif\nvec3 getRandomVec3(float offset) {\rreturn texture(randomSampler2,vec2(float(gl_VertexID)*offset/currentCount,0)).rgb;\r}\rvec4 getRandomVec4(float offset) {\rreturn texture(randomSampler,vec2(float(gl_VertexID)*offset/currentCount,0));\r}\rvoid main() {\rfloat newAge=age+timeDelta; \rif (newAge>=life && stopFactor != 0.) {\rvec3 newPosition;\rvec3 newDirection;\rvec4 randoms=getRandomVec4(seed.x);\routLife=lifeTime.x+(lifeTime.y-lifeTime.x)*randoms.r;\routAge=newAge-life;\routSeed=seed;\r#ifdef SIZEGRADIENTS \noutSize.x=texture(sizeGradientSampler,vec2(0,0)).r;\r#else\noutSize.x=sizeRange.x+(sizeRange.y-sizeRange.x)*randoms.g;\r#endif\noutSize.y=scaleRange.x+(scaleRange.y-scaleRange.x)*randoms.b;\routSize.z=scaleRange.z+(scaleRange.w-scaleRange.z)*randoms.a; \r#ifndef COLORGRADIENTS\noutColor=color1+(color2-color1)*randoms.b;\r#endif\n#ifndef ANGULARSPEEDGRADIENTS \noutAngle.y=angleRange.x+(angleRange.y-angleRange.x)*randoms.a;\routAngle.x=angleRange.z+(angleRange.w-angleRange.z)*randoms.r;\r#else\noutAngle=angleRange.z+(angleRange.w-angleRange.z)*randoms.r;\r#endif \n#ifdef POINTEMITTER\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rnewPosition=vec3(0,0,0);\rnewDirection=direction1+(direction2-direction1)*randoms3;\r#elif defined(BOXEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rnewPosition=minEmitBox+(maxEmitBox-minEmitBox)*randoms2;\rnewDirection=direction1+(direction2-direction1)*randoms3; \r#elif defined(HEMISPHERICEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat phi=2.0*PI*randoms2.x;\rfloat theta=acos(2.0*randoms2.y-1.0);\rfloat randX=cos(phi)*sin(theta);\rfloat randY=cos(theta);\rfloat randZ=sin(phi)*sin(theta);\rnewPosition=(radius-(radius*radiusRange*randoms2.z))*vec3(randX,abs(randY),randZ);\rnewDirection=newPosition+directionRandomizer*randoms3; \r#elif defined(SPHEREEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat phi=2.0*PI*randoms2.x;\rfloat theta=acos(2.0*randoms2.y-1.0);\rfloat randX=cos(phi)*sin(theta);\rfloat randY=cos(theta);\rfloat randZ=sin(phi)*sin(theta);\rnewPosition=(radius-(radius*radiusRange*randoms2.z))*vec3(randX,randY,randZ);\r#ifdef DIRECTEDSPHEREEMITTER\nnewDirection=normalize(direction1+(direction2-direction1)*randoms3);\r#else\nnewDirection=normalize(newPosition+directionRandomizer*randoms3);\r#endif\n#elif defined(CYLINDEREMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat yPos=(randoms2.x-0.5)*height;\rfloat angle=randoms2.y*PI*2.;\rfloat inverseRadiusRangeSquared=((1.-radiusRange)*(1.-radiusRange));\rfloat positionRadius=radius*sqrt(inverseRadiusRangeSquared+(randoms2.z*(1.-inverseRadiusRangeSquared)));\rfloat xPos=positionRadius*cos(angle);\rfloat zPos=positionRadius*sin(angle);\rnewPosition=vec3(xPos,yPos,zPos);\r#ifdef DIRECTEDCYLINDEREMITTER\nnewDirection=direction1+(direction2-direction1)*randoms3;\r#else\nangle=angle+((randoms3.x-0.5)*PI)*directionRandomizer;\rnewDirection=vec3(cos(angle),(randoms3.y-0.5)*directionRandomizer,sin(angle));\rnewDirection=normalize(newDirection);\r#endif\n#elif defined(CONEEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rfloat s=2.0*PI*randoms2.x;\r#ifdef CONEEMITTERSPAWNPOINT\nfloat h=0.0001;\r#else\nfloat h=randoms2.y*height.y;\rh=1.-h*h; \r#endif\nfloat lRadius=radius.x-radius.x*randoms2.z*radius.y;\rlRadius=lRadius*h;\rfloat randX=lRadius*sin(s);\rfloat randZ=lRadius*cos(s);\rfloat randY=h *height.x;\rnewPosition=vec3(randX,randY,randZ); \rif (abs(cos(coneAngle))==1.0) {\rnewDirection=vec3(0.,1.0,0.);\r} else {\rvec3 randoms3=getRandomVec3(seed.z);\rnewDirection=normalize(newPosition+directionRandomizer*randoms3); \r}\r#elif defined(CUSTOMEMITTER)\nnewPosition=initialPosition;\routInitialPosition=initialPosition;\r#else \nnewPosition=vec3(0.,0.,0.);\rnewDirection=2.0*(getRandomVec3(seed.w)-vec3(0.5,0.5,0.5));\r#endif\nfloat power=emitPower.x+(emitPower.y-emitPower.x)*randoms.a;\r#ifdef LOCAL\noutPosition=newPosition;\r#else\noutPosition=(emitterWM*vec4(newPosition,1.)).xyz;\r#endif\n#ifdef CUSTOMEMITTER\noutDirection=direction;\r#ifndef BILLBOARD \noutInitialDirection=direction;\r#endif\n#else\n#ifdef LOCAL\nvec3 initial=newDirection;\r#else \nvec3 initial=(emitterWM*vec4(newDirection,0.)).xyz;\r#endif\noutDirection=initial*power;\r#ifndef BILLBOARD \noutInitialDirection=initial;\r#endif\n#endif\n#ifdef ANIMATESHEET \noutCellIndex=cellInfos.x;\r#ifdef ANIMATESHEETRANDOMSTART\noutCellStartOffset=randoms.a*outLife;\r#endif \n#endif\n#ifdef NOISE\noutNoiseCoordinates1=noiseCoordinates1;\routNoiseCoordinates2=noiseCoordinates2;\r#endif\n} else {\rfloat directionScale=timeDelta;\routAge=newAge;\rfloat ageGradient=newAge/life;\r#ifdef VELOCITYGRADIENTS\ndirectionScale*=texture(velocityGradientSampler,vec2(ageGradient,0)).r;\r#endif\n#ifdef DRAGGRADIENTS\ndirectionScale*=1.0-texture(dragGradientSampler,vec2(ageGradient,0)).r;\r#endif\n#if defined(CUSTOMEMITTER)\noutPosition=position+(direction-position)*ageGradient; \routInitialPosition=initialPosition;\r#else\noutPosition=position+direction*directionScale;\r#endif\noutLife=life;\routSeed=seed;\r#ifndef COLORGRADIENTS \noutColor=color;\r#endif\n#ifdef SIZEGRADIENTS\noutSize.x=texture(sizeGradientSampler,vec2(ageGradient,0)).r;\routSize.yz=size.yz;\r#else\noutSize=size;\r#endif \n#ifndef BILLBOARD \noutInitialDirection=initialDirection;\r#endif\n#ifdef CUSTOMEMITTER\noutDirection=direction;\r#else\nvec3 updatedDirection=direction+gravity*timeDelta;\r#ifdef LIMITVELOCITYGRADIENTS\nfloat limitVelocity=texture(limitVelocityGradientSampler,vec2(ageGradient,0)).r;\rfloat currentVelocity=length(updatedDirection);\rif (currentVelocity>limitVelocity) {\rupdatedDirection=updatedDirection*limitVelocityDamping;\r}\r#endif\noutDirection=updatedDirection;\r#ifdef NOISE\nfloat fetchedR=texture(noiseSampler,vec2(noiseCoordinates1.x,noiseCoordinates1.y)*vec2(0.5)+vec2(0.5)).r;\rfloat fetchedG=texture(noiseSampler,vec2(noiseCoordinates1.z,noiseCoordinates2.x)*vec2(0.5)+vec2(0.5)).r;\rfloat fetchedB=texture(noiseSampler,vec2(noiseCoordinates2.y,noiseCoordinates2.z)*vec2(0.5)+vec2(0.5)).r;\rvec3 force=vec3(2.*fetchedR-1.,2.*fetchedG-1.,2.*fetchedB-1.)*noiseStrength;\routDirection=outDirection+force*timeDelta;\routNoiseCoordinates1=noiseCoordinates1;\routNoiseCoordinates2=noiseCoordinates2;\r#endif \n#endif \n#ifdef ANGULARSPEEDGRADIENTS\nfloat angularSpeed=texture(angularSpeedGradientSampler,vec2(ageGradient,0)).r;\routAngle=angle+angularSpeed*timeDelta;\r#else\noutAngle=vec2(angle.x+angle.y*timeDelta,angle.y);\r#endif\n#ifdef ANIMATESHEET \nfloat offsetAge=outAge;\rfloat dist=cellInfos.y-cellInfos.x;\r#ifdef ANIMATESHEETRANDOMSTART\noutCellStartOffset=cellStartOffset;\roffsetAge+=cellStartOffset;\r#else\nfloat cellStartOffset=0.;\r#endif \nfloat ratio=0.;\rif (cellInfos.w==1.0) {\rratio=clamp(mod(cellStartOffset+cellInfos.z*offsetAge,life)/life,0.,1.0);\r}\relse {\rratio=clamp(cellStartOffset+cellInfos.z*offsetAge/life,0.,1.0);\r}\routCellIndex=float(int(cellInfos.x+ratio*dist));\r#endif\n}\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const gpuUpdateParticlesVertexShader = { name, shader };\n"]}

package/Shaders/grain.fragment.d.ts

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

package/Shaders/grain.fragment.js

@@ -7,6 +7,6 @@ uniform sampler2D textureSampler;
 void main(void)
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const grainPixelShader = { name, shader };
 //# sourceMappingURL=grain.fragment.js.map

package/Shaders/grain.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"grain.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/grain.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;EAeb,CAAC;AACH,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\";\nimport \"./ShadersInclude/helperFunctions\";\n\nconst name = \"grainPixelShader\";\nconst shader = `#include<helperFunctions>\nuniform sampler2D textureSampler; \runiform float intensity;\runiform float animatedSeed;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rgl_FragColor=texture2D(textureSampler,vUV);\rvec2 seed=vUV*(animatedSeed);\rfloat grain=dither(seed,intensity);\rfloat lum=getLuminance(gl_FragColor.rgb);\rfloat grainAmount=(cos(-PI+(lum*PI*2.))+1.)/2.;\rgl_FragColor.rgb+=grain*grainAmount;\rgl_FragColor.rgb=max(gl_FragColor.rgb,0.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const grainPixelShader = { name, shader };\n"]}
+{"version":3,"file":"grain.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/grain.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;EAeb,CAAC;AACH,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\";\nimport \"./ShadersInclude/helperFunctions\";\n\nconst name = \"grainPixelShader\";\nconst shader = `#include<helperFunctions>\nuniform sampler2D textureSampler; \runiform float intensity;\runiform float animatedSeed;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rgl_FragColor=texture2D(textureSampler,vUV);\rvec2 seed=vUV*(animatedSeed);\rfloat grain=dither(seed,intensity);\rfloat lum=getLuminance(gl_FragColor.rgb);\rfloat grainAmount=(cos(-PI+(lum*PI*2.))+1.)/2.;\rgl_FragColor.rgb+=grain*grainAmount;\rgl_FragColor.rgb=max(gl_FragColor.rgb,0.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const grainPixelShader = { name, shader };\n"]}

package/Shaders/hdrFiltering.fragment.d.ts

@@ -2,7 +2,7 @@ import "./ShadersInclude/helperFunctions";
 import "./ShadersInclude/importanceSampling";
 import "./ShadersInclude/pbrBRDFFunctions";
 import "./ShadersInclude/hdrFilteringFunctions";
-/** @hidden */
+/** @internal */
 export declare const hdrFilteringPixelShader: {
     name: string;
     shader: string;

package/Shaders/hdrFiltering.fragment.js

@@ -12,6 +12,6 @@ const shader = `#include<helperFunctions>
 uniform float alphaG;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const hdrFilteringPixelShader = { name, shader };
 //# sourceMappingURL=hdrFiltering.fragment.js.map

package/Shaders/hdrFiltering.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"hdrFiltering.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/hdrFiltering.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,mCAAmC,CAAC;AAC3C,OAAO,wCAAwC,CAAC;AAEhD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,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\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/importanceSampling\";\nimport \"./ShadersInclude/pbrBRDFFunctions\";\nimport \"./ShadersInclude/hdrFilteringFunctions\";\n\nconst name = \"hdrFilteringPixelShader\";\nconst shader = `#include<helperFunctions>\n#include<importanceSampling>\n#include<pbrBRDFFunctions>\n#include<hdrFilteringFunctions>\nuniform float alphaG;\runiform samplerCube inputTexture;\runiform vec2 vFilteringInfo;\runiform float hdrScale;\rvarying vec3 direction;\rvoid main() {\rvec3 color=radiance(alphaG,inputTexture,direction,vFilteringInfo);\rgl_FragColor=vec4(color*hdrScale,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const hdrFilteringPixelShader = { name, shader };\n"]}
+{"version":3,"file":"hdrFiltering.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/hdrFiltering.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,mCAAmC,CAAC;AAC3C,OAAO,wCAAwC,CAAC;AAEhD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,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\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/importanceSampling\";\nimport \"./ShadersInclude/pbrBRDFFunctions\";\nimport \"./ShadersInclude/hdrFilteringFunctions\";\n\nconst name = \"hdrFilteringPixelShader\";\nconst shader = `#include<helperFunctions>\n#include<importanceSampling>\n#include<pbrBRDFFunctions>\n#include<hdrFilteringFunctions>\nuniform float alphaG;\runiform samplerCube inputTexture;\runiform vec2 vFilteringInfo;\runiform float hdrScale;\rvarying vec3 direction;\rvoid main() {\rvec3 color=radiance(alphaG,inputTexture,direction,vFilteringInfo);\rgl_FragColor=vec4(color*hdrScale,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const hdrFilteringPixelShader = { name, shader };\n"]}

package/Shaders/hdrFiltering.vertex.d.ts

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

package/Shaders/hdrFiltering.vertex.js

@@ -7,6 +7,6 @@ mat3 view=mat3(up,right,front);
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const hdrFilteringVertexShader = { name, shader };
 //# sourceMappingURL=hdrFiltering.vertex.js.map

package/Shaders/hdrFiltering.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"hdrFiltering.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/hdrFiltering.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"hdrFilteringVertexShader\";\nconst shader = `attribute vec2 position;\rvarying vec3 direction;\runiform vec3 up;\runiform vec3 right;\runiform vec3 front;\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nmat3 view=mat3(up,right,front);\rdirection=view*vec3(position,1.0);\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 hdrFilteringVertexShader = { name, shader };\n"]}
+{"version":3,"file":"hdrFiltering.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/hdrFiltering.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"hdrFilteringVertexShader\";\nconst shader = `attribute vec2 position;\rvarying vec3 direction;\runiform vec3 up;\runiform vec3 right;\runiform vec3 front;\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nmat3 view=mat3(up,right,front);\rdirection=view*vec3(position,1.0);\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 hdrFilteringVertexShader = { name, shader };\n"]}

package/Shaders/highlights.fragment.d.ts

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

package/Shaders/highlights.fragment.js

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

package/Shaders/highlights.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"highlights.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/highlights.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;EAUb,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 = \"highlightsPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\rconst vec3 RGBLuminanceCoefficients=vec3(0.2126,0.7152,0.0722);\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rvec4 tex=texture2D(textureSampler,vUV);\rvec3 c=tex.rgb;\rfloat luma=dot(c.rgb,RGBLuminanceCoefficients);\rgl_FragColor=vec4(pow(c,vec3(25.0-luma*15.0)),tex.a); \r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const highlightsPixelShader = { name, shader };\n"]}
+{"version":3,"file":"highlights.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/highlights.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;EAUb,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 = \"highlightsPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\rconst vec3 RGBLuminanceCoefficients=vec3(0.2126,0.7152,0.0722);\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rvec4 tex=texture2D(textureSampler,vUV);\rvec3 c=tex.rgb;\rfloat luma=dot(c.rgb,RGBLuminanceCoefficients);\rgl_FragColor=vec4(pow(c,vec3(25.0-luma*15.0)),tex.a); \r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const highlightsPixelShader = { name, shader };\n"]}

package/Shaders/imageProcessing.fragment.d.ts

@@ -1,7 +1,7 @@
 import "./ShadersInclude/imageProcessingDeclaration";
 import "./ShadersInclude/helperFunctions";
 import "./ShadersInclude/imageProcessingFunctions";
-/** @hidden */
+/** @internal */
 export declare const imageProcessingPixelShader: {
     name: string;
     shader: string;

package/Shaders/imageProcessing.fragment.js

@@ -18,6 +18,6 @@ result=applyImageProcessing(result);
 gl_FragColor=result;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const imageProcessingPixelShader = { name, shader };
 //# sourceMappingURL=imageProcessing.fragment.js.map

package/Shaders/imageProcessing.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"imageProcessing.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/imageProcessing.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,6CAA6C,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,2CAA2C,CAAC;AAEnD,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAC1C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;EAoBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/imageProcessingDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/imageProcessingFunctions\";\n\nconst name = \"imageProcessingPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#include<imageProcessingDeclaration>\n#include<helperFunctions>\n#include<imageProcessingFunctions>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rvec4 result=texture2D(textureSampler,vUV);\r#ifdef IMAGEPROCESSING\n#ifndef FROMLINEARSPACE\nresult.rgb=toLinearSpace(result.rgb);\r#endif\nresult=applyImageProcessing(result);\r#else\n#ifdef FROMLINEARSPACE\nresult=applyImageProcessing(result);\r#endif\n#endif\ngl_FragColor=result;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const imageProcessingPixelShader = { name, shader };\n"]}
+{"version":3,"file":"imageProcessing.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/imageProcessing.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,6CAA6C,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,2CAA2C,CAAC;AAEnD,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAC1C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;EAoBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/imageProcessingDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/imageProcessingFunctions\";\n\nconst name = \"imageProcessingPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#include<imageProcessingDeclaration>\n#include<helperFunctions>\n#include<imageProcessingFunctions>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rvec4 result=texture2D(textureSampler,vUV);\r#ifdef IMAGEPROCESSING\n#ifndef FROMLINEARSPACE\nresult.rgb=toLinearSpace(result.rgb);\r#endif\nresult=applyImageProcessing(result);\r#else\n#ifdef FROMLINEARSPACE\nresult=applyImageProcessing(result);\r#endif\n#endif\ngl_FragColor=result;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const imageProcessingPixelShader = { name, shader };\n"]}

package/Shaders/kernelBlur.fragment.d.ts

@@ -2,7 +2,7 @@ import "./ShadersInclude/kernelBlurVaryingDeclaration";
 import "./ShadersInclude/packingFunctions";
 import "./ShadersInclude/kernelBlurFragment";
 import "./ShadersInclude/kernelBlurFragment2";
-/** @hidden */
+/** @internal */
 export declare const kernelBlurPixelShader: {
     name: string;
     shader: string;

package/Shaders/kernelBlur.fragment.js

@@ -30,6 +30,6 @@ gl_FragColor/=sumOfWeights;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const kernelBlurPixelShader = { name, shader };
 //# sourceMappingURL=kernelBlur.fragment.js.map

package/Shaders/kernelBlur.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"kernelBlur.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/kernelBlur.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,+CAA+C,CAAC;AACvD,OAAO,mCAAmC,CAAC;AAC3C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,sCAAsC,CAAC;AAE9C,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+Cb,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/kernelBlurVaryingDeclaration\";\nimport \"./ShadersInclude/packingFunctions\";\nimport \"./ShadersInclude/kernelBlurFragment\";\nimport \"./ShadersInclude/kernelBlurFragment2\";\n\nconst name = \"kernelBlurPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform vec2 delta;\rvarying vec2 sampleCenter;\r#ifdef DOF\nuniform sampler2D circleOfConfusionSampler;\runiform vec2 cameraMinMaxZ;\rfloat sampleDistance(in vec2 offset) {\rfloat depth=texture2D(circleOfConfusionSampler,offset).g; \rreturn cameraMinMaxZ.x+(cameraMinMaxZ.y-cameraMinMaxZ.x)*depth; \r}\rfloat sampleCoC(in vec2 offset) {\rfloat coc=texture2D(circleOfConfusionSampler,offset).r; \rreturn coc; \r}\r#endif\n#include<kernelBlurVaryingDeclaration>[0..varyingCount]\n#ifdef PACKEDFLOAT\n#include<packingFunctions>\n#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rfloat computedWeight=0.0;\r#ifdef PACKEDFLOAT \nfloat blend=0.;\r#else\nvec4 blend=vec4(0.);\r#endif\n#ifdef DOF\nfloat sumOfWeights=CENTER_WEIGHT; \rfloat factor=0.0;\r#ifdef PACKEDFLOAT\nblend+=unpack(texture2D(textureSampler,sampleCenter))*CENTER_WEIGHT;\r#else\nblend+=texture2D(textureSampler,sampleCenter)*CENTER_WEIGHT;\r#endif\n#endif\n#include<kernelBlurFragment>[0..varyingCount]\n#include<kernelBlurFragment2>[0..depCount]\n#ifdef PACKEDFLOAT\ngl_FragColor=pack(blend);\r#else\ngl_FragColor=blend;\r#endif\n#ifdef DOF\ngl_FragColor/=sumOfWeights;\r#endif\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const kernelBlurPixelShader = { name, shader };\n"]}
+{"version":3,"file":"kernelBlur.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/kernelBlur.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,+CAA+C,CAAC;AACvD,OAAO,mCAAmC,CAAC;AAC3C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,sCAAsC,CAAC;AAE9C,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+Cb,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/kernelBlurVaryingDeclaration\";\nimport \"./ShadersInclude/packingFunctions\";\nimport \"./ShadersInclude/kernelBlurFragment\";\nimport \"./ShadersInclude/kernelBlurFragment2\";\n\nconst name = \"kernelBlurPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform vec2 delta;\rvarying vec2 sampleCenter;\r#ifdef DOF\nuniform sampler2D circleOfConfusionSampler;\runiform vec2 cameraMinMaxZ;\rfloat sampleDistance(in vec2 offset) {\rfloat depth=texture2D(circleOfConfusionSampler,offset).g; \rreturn cameraMinMaxZ.x+(cameraMinMaxZ.y-cameraMinMaxZ.x)*depth; \r}\rfloat sampleCoC(in vec2 offset) {\rfloat coc=texture2D(circleOfConfusionSampler,offset).r; \rreturn coc; \r}\r#endif\n#include<kernelBlurVaryingDeclaration>[0..varyingCount]\n#ifdef PACKEDFLOAT\n#include<packingFunctions>\n#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rfloat computedWeight=0.0;\r#ifdef PACKEDFLOAT \nfloat blend=0.;\r#else\nvec4 blend=vec4(0.);\r#endif\n#ifdef DOF\nfloat sumOfWeights=CENTER_WEIGHT; \rfloat factor=0.0;\r#ifdef PACKEDFLOAT\nblend+=unpack(texture2D(textureSampler,sampleCenter))*CENTER_WEIGHT;\r#else\nblend+=texture2D(textureSampler,sampleCenter)*CENTER_WEIGHT;\r#endif\n#endif\n#include<kernelBlurFragment>[0..varyingCount]\n#include<kernelBlurFragment2>[0..depCount]\n#ifdef PACKEDFLOAT\ngl_FragColor=pack(blend);\r#else\ngl_FragColor=blend;\r#endif\n#ifdef DOF\ngl_FragColor/=sumOfWeights;\r#endif\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const kernelBlurPixelShader = { name, shader };\n"]}

package/Shaders/kernelBlur.vertex.d.ts

@@ -1,6 +1,6 @@
 import "./ShadersInclude/kernelBlurVaryingDeclaration";
 import "./ShadersInclude/kernelBlurVertex";
-/** @hidden */
+/** @internal */
 export declare const kernelBlurVertexShader: {
     name: string;
     shader: string;

package/Shaders/kernelBlur.vertex.js

@@ -11,6 +11,6 @@ gl_Position=vec4(position,0.0,1.0);
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const kernelBlurVertexShader = { name, shader };
 //# sourceMappingURL=kernelBlur.vertex.js.map

package/Shaders/kernelBlur.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"kernelBlur.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/kernelBlur.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,+CAA+C,CAAC;AACvD,OAAO,mCAAmC,CAAC;AAE3C,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,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\";\nimport \"./ShadersInclude/kernelBlurVaryingDeclaration\";\nimport \"./ShadersInclude/kernelBlurVertex\";\n\nconst name = \"kernelBlurVertexShader\";\nconst shader = `attribute vec2 position;\runiform vec2 delta;\rvarying vec2 sampleCenter;\r#include<kernelBlurVaryingDeclaration>[0..varyingCount]\nconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nsampleCenter=(position*madd+madd);\r#include<kernelBlurVertex>[0..varyingCount]\ngl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const kernelBlurVertexShader = { name, shader };\n"]}
+{"version":3,"file":"kernelBlur.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/kernelBlur.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,+CAA+C,CAAC;AACvD,OAAO,mCAAmC,CAAC;AAE3C,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,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\";\nimport \"./ShadersInclude/kernelBlurVaryingDeclaration\";\nimport \"./ShadersInclude/kernelBlurVertex\";\n\nconst name = \"kernelBlurVertexShader\";\nconst shader = `attribute vec2 position;\runiform vec2 delta;\rvarying vec2 sampleCenter;\r#include<kernelBlurVaryingDeclaration>[0..varyingCount]\nconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nsampleCenter=(position*madd+madd);\r#include<kernelBlurVertex>[0..varyingCount]\ngl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const kernelBlurVertexShader = { name, shader };\n"]}

package/Shaders/layer.fragment.d.ts

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

package/Shaders/layer.fragment.js

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

package/Shaders/layer.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"layer.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/layer.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;EAiBb,CAAC;AACH,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\";\nimport \"./ShadersInclude/helperFunctions\";\n\nconst name = \"layerPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec4 color;\r#include<helperFunctions>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 baseColor=texture2D(textureSampler,vUV);\r#ifdef LINEAR\nbaseColor.rgb=toGammaSpace(baseColor.rgb);\r#endif\n#ifdef ALPHATEST\nif (baseColor.a<0.4)\rdiscard;\r#endif\ngl_FragColor=baseColor*color;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const layerPixelShader = { name, shader };\n"]}
+{"version":3,"file":"layer.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/layer.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;EAiBb,CAAC;AACH,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\";\nimport \"./ShadersInclude/helperFunctions\";\n\nconst name = \"layerPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec4 color;\r#include<helperFunctions>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 baseColor=texture2D(textureSampler,vUV);\r#ifdef LINEAR\nbaseColor.rgb=toGammaSpace(baseColor.rgb);\r#endif\n#ifdef ALPHATEST\nif (baseColor.a<0.4)\rdiscard;\r#endif\ngl_FragColor=baseColor*color;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const layerPixelShader = { name, shader };\n"]}

package/Shaders/layer.vertex.d.ts

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

package/Shaders/layer.vertex.js

@@ -7,6 +7,6 @@ vec2 shiftedPosition=position*scale+offset;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const layerVertexShader = { name, shader };
 //# sourceMappingURL=layer.vertex.js.map

package/Shaders/layer.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"layer.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/layer.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,mBAAmB,CAAC;AACjC,MAAM,MAAM,GAAG;;;;;;;;;;;;;EAab,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"layerVertexShader\";\nconst shader = `attribute vec2 position;\runiform vec2 scale;\runiform vec2 offset;\runiform mat4 textureMatrix;\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\nvec2 shiftedPosition=position*scale+offset;\rvUV=vec2(textureMatrix*vec4(shiftedPosition*madd+madd,1.0,0.0));\rgl_Position=vec4(shiftedPosition,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const layerVertexShader = { name, shader };\n"]}
+{"version":3,"file":"layer.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/layer.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,mBAAmB,CAAC;AACjC,MAAM,MAAM,GAAG;;;;;;;;;;;;;EAab,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"layerVertexShader\";\nconst shader = `attribute vec2 position;\runiform vec2 scale;\runiform vec2 offset;\runiform mat4 textureMatrix;\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\nvec2 shiftedPosition=position*scale+offset;\rvUV=vec2(textureMatrix*vec4(shiftedPosition*madd+madd,1.0,0.0));\rgl_Position=vec4(shiftedPosition,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const layerVertexShader = { name, shader };\n"]}

package/Shaders/lensFlare.fragment.d.ts

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

package/Shaders/lensFlare.fragment.js

@@ -7,6 +7,6 @@ vec4 baseColor=texture2D(textureSampler,vUV);
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const lensFlarePixelShader = { name, shader };
 //# sourceMappingURL=lensFlare.fragment.js.map

package/Shaders/lensFlare.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"lensFlare.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/lensFlare.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;EASb,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 = \"lensFlarePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec4 color;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 baseColor=texture2D(textureSampler,vUV);\rgl_FragColor=baseColor*color;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const lensFlarePixelShader = { name, shader };\n"]}
+{"version":3,"file":"lensFlare.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/lensFlare.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;EASb,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 = \"lensFlarePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec4 color;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 baseColor=texture2D(textureSampler,vUV);\rgl_FragColor=baseColor*color;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const lensFlarePixelShader = { name, shader };\n"]}

package/Shaders/lensFlare.vertex.d.ts

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

package/Shaders/lensFlare.vertex.js

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

package/Shaders/lensFlare.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"lensFlare.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/lensFlare.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;EAUb,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 = \"lensFlareVertexShader\";\nconst shader = `attribute vec2 position;\runiform mat4 viewportMatrix;\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;\rgl_Position=viewportMatrix*vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const lensFlareVertexShader = { name, shader };\n"]}
+{"version":3,"file":"lensFlare.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/lensFlare.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;EAUb,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 = \"lensFlareVertexShader\";\nconst shader = `attribute vec2 position;\runiform mat4 viewportMatrix;\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;\rgl_Position=viewportMatrix*vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const lensFlareVertexShader = { name, shader };\n"]}

package/Shaders/lensHighlights.fragment.d.ts

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

package/Shaders/lensHighlights.fragment.js

@@ -8,6 +8,6 @@ blurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.85*w,0.36*h)));
 blurred/=39.0;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const lensHighlightsPixelShader = { name, shader };
 //# sourceMappingURL=lensHighlights.fragment.js.map

package/Shaders/lensHighlights.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"lensHighlights.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/lensHighlights.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,2BAA2B,CAAC;AACzC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"lensHighlightsPixelShader\";\nconst shader = `uniform sampler2D textureSampler; \runiform float gain;\runiform float threshold;\runiform float screen_width;\runiform float screen_height;\rvarying vec2 vUV;\rvec4 highlightColor(vec4 color) {\rvec4 highlight=color;\rfloat luminance=dot(highlight.rgb,vec3(0.2125,0.7154,0.0721));\rfloat lum_threshold;\rif (threshold>1.0) { lum_threshold=0.94+0.01*threshold; }\relse { lum_threshold=0.5+0.44*threshold; }\rluminance=clamp((luminance-lum_threshold)*(1.0/(1.0-lum_threshold)),0.0,1.0);\rhighlight*=luminance*gain;\rhighlight.a=1.0;\rreturn highlight;\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rvec4 original=texture2D(textureSampler,vUV);\rif (gain==-1.0) {\rgl_FragColor=vec4(0.0,0.0,0.0,1.0);\rreturn;\r}\rfloat w=2.0/screen_width;\rfloat h=2.0/screen_height;\rfloat weight=1.0;\rvec4 blurred=vec4(0.0,0.0,0.0,0.0);\r#ifdef PENTAGON\nblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.84*w,0.43*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.48*w,-1.29*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.61*w,1.51*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.55*w,-0.74*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.71*w,-0.52*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.94*w,1.59*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.40*w,-1.87*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.62*w,1.16*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.09*w,0.25*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.46*w,-1.71*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.08*w,2.42*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.85*w,-1.89*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.89*w,0.16*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.29*w,1.88*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.40*w,-2.81*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.54*w,2.26*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.60*w,-0.61*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.31*w,-1.30*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.83*w,2.53*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.12*w,-2.48*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.60*w,1.11*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.82*w,0.99*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.50*w,-2.81*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.85*w,3.33*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.94*w,-1.92*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.27*w,-0.53*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.95*w,2.48*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.23*w,-3.04*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.17*w,2.05*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.97*w,-0.04*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.25*w,-2.00*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.31*w,3.08*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.94*w,-2.59*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.37*w,0.64*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.13*w,1.93*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.03*w,-3.65*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.60*w,3.17*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.14*w,-1.19*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.00*w,-1.19*h)));\r#else\nblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.85*w,0.36*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.52*w,-1.14*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.46*w,1.42*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.46*w,-0.83*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.79*w,-0.42*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.11*w,1.62*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.29*w,-2.07*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.69*w,1.39*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.28*w,0.12*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.65*w,-1.69*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.08*w,2.44*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.63*w,-1.90*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.55*w,0.31*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.13*w,1.52*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.56*w,-2.61*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.38*w,2.34*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.64*w,-0.81*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.53*w,-1.21*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.06*w,2.63*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.00*w,-2.69*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.59*w,1.32*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.82*w,0.78*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.57*w,-2.50*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.54*w,2.93*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.39*w,-1.81*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.01*w,-0.28*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.04*w,2.25*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.02*w,-3.05*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.09*w,2.25*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.07*w,-0.25*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.44*w,-1.90*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.52*w,3.05*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.68*w,-2.61*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.01*w,0.79*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.76*w,1.46*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.05*w,-2.94*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.21*w,2.88*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.84*w,-1.30*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.98*w,-0.96*h)));\r#endif\nblurred/=39.0;\rgl_FragColor=blurred;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const lensHighlightsPixelShader = { name, shader };\n"]}
+{"version":3,"file":"lensHighlights.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/lensHighlights.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,2BAA2B,CAAC;AACzC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"lensHighlightsPixelShader\";\nconst shader = `uniform sampler2D textureSampler; \runiform float gain;\runiform float threshold;\runiform float screen_width;\runiform float screen_height;\rvarying vec2 vUV;\rvec4 highlightColor(vec4 color) {\rvec4 highlight=color;\rfloat luminance=dot(highlight.rgb,vec3(0.2125,0.7154,0.0721));\rfloat lum_threshold;\rif (threshold>1.0) { lum_threshold=0.94+0.01*threshold; }\relse { lum_threshold=0.5+0.44*threshold; }\rluminance=clamp((luminance-lum_threshold)*(1.0/(1.0-lum_threshold)),0.0,1.0);\rhighlight*=luminance*gain;\rhighlight.a=1.0;\rreturn highlight;\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rvec4 original=texture2D(textureSampler,vUV);\rif (gain==-1.0) {\rgl_FragColor=vec4(0.0,0.0,0.0,1.0);\rreturn;\r}\rfloat w=2.0/screen_width;\rfloat h=2.0/screen_height;\rfloat weight=1.0;\rvec4 blurred=vec4(0.0,0.0,0.0,0.0);\r#ifdef PENTAGON\nblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.84*w,0.43*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.48*w,-1.29*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.61*w,1.51*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.55*w,-0.74*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.71*w,-0.52*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.94*w,1.59*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.40*w,-1.87*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.62*w,1.16*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.09*w,0.25*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.46*w,-1.71*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.08*w,2.42*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.85*w,-1.89*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.89*w,0.16*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.29*w,1.88*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.40*w,-2.81*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.54*w,2.26*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.60*w,-0.61*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.31*w,-1.30*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.83*w,2.53*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.12*w,-2.48*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.60*w,1.11*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.82*w,0.99*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.50*w,-2.81*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.85*w,3.33*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.94*w,-1.92*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.27*w,-0.53*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.95*w,2.48*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.23*w,-3.04*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.17*w,2.05*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.97*w,-0.04*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.25*w,-2.00*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.31*w,3.08*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.94*w,-2.59*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.37*w,0.64*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.13*w,1.93*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.03*w,-3.65*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.60*w,3.17*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.14*w,-1.19*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.00*w,-1.19*h)));\r#else\nblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.85*w,0.36*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.52*w,-1.14*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.46*w,1.42*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.46*w,-0.83*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.79*w,-0.42*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.11*w,1.62*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.29*w,-2.07*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.69*w,1.39*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.28*w,0.12*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.65*w,-1.69*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.08*w,2.44*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.63*w,-1.90*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.55*w,0.31*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.13*w,1.52*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.56*w,-2.61*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.38*w,2.34*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.64*w,-0.81*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.53*w,-1.21*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.06*w,2.63*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.00*w,-2.69*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.59*w,1.32*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.82*w,0.78*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.57*w,-2.50*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(0.54*w,2.93*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.39*w,-1.81*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.01*w,-0.28*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.04*w,2.25*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.02*w,-3.05*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.09*w,2.25*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-3.07*w,-0.25*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.44*w,-1.90*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-0.52*w,3.05*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-1.68*w,-2.61*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(3.01*w,0.79*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.76*w,1.46*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.05*w,-2.94*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(1.21*w,2.88*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(-2.84*w,-1.30*h)));\rblurred+=highlightColor(texture2D(textureSampler,vUV+vec2(2.98*w,-0.96*h)));\r#endif\nblurred/=39.0;\rgl_FragColor=blurred;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const lensHighlightsPixelShader = { name, shader };\n"]}

package/Shaders/line.fragment.d.ts

@@ -1,6 +1,6 @@
 import "./ShadersInclude/clipPlaneFragmentDeclaration";
 import "./ShadersInclude/clipPlaneFragment";
-/** @hidden */
+/** @internal */
 export declare const linePixelShader: {
     name: string;
     shader: string;

package/Shaders/line.fragment.js

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

package/Shaders/line.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"line.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/line.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,+CAA+C,CAAC;AACvD,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;EAQb,CAAC;AACH,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\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\n\nconst name = \"linePixelShader\";\nconst shader = `#include<clipPlaneFragmentDeclaration>\nuniform vec4 color;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\ngl_FragColor=color;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const linePixelShader = { name, shader };\n"]}
+{"version":3,"file":"line.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/line.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,+CAA+C,CAAC;AACvD,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;EAQb,CAAC;AACH,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\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\n\nconst name = \"linePixelShader\";\nconst shader = `#include<clipPlaneFragmentDeclaration>\nuniform vec4 color;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\ngl_FragColor=color;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const linePixelShader = { name, shader };\n"]}

package/Shaders/line.vertex.d.ts

@@ -2,7 +2,7 @@ import "./ShadersInclude/instancesDeclaration";
 import "./ShadersInclude/clipPlaneVertexDeclaration";
 import "./ShadersInclude/instancesVertex";
 import "./ShadersInclude/clipPlaneVertex";
-/** @hidden */
+/** @internal */
 export declare const lineVertexShader: {
     name: string;
     shader: string;

package/Shaders/line.vertex.js

@@ -17,6 +17,6 @@ vec4 worldPos=finalWorld*vec4(position,1.0);
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const lineVertexShader = { name, shader };
 //# sourceMappingURL=line.vertex.js.map

package/Shaders/line.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"line.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/line.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,6CAA6C,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6Bb,CAAC;AACH,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\";\nimport \"./ShadersInclude/instancesDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"lineVertexShader\";\nconst shader = `#include<instancesDeclaration>\n#include<clipPlaneVertexDeclaration>\nattribute vec3 position;\rattribute vec4 normal;\runiform mat4 viewProjection;\runiform float width;\runiform float aspectRatio;\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\n#include<instancesVertex>\nmat4 worldViewProjection=viewProjection*finalWorld;\rvec4 viewPosition=worldViewProjection*vec4(position,1.0);\rvec4 viewPositionNext=worldViewProjection*vec4(normal.xyz,1.0);\rvec2 currentScreen=viewPosition.xy/viewPosition.w;\rvec2 nextScreen=viewPositionNext.xy/viewPositionNext.w;\rcurrentScreen.x*=aspectRatio;\rnextScreen.x*=aspectRatio;\rvec2 dir=normalize(nextScreen-currentScreen);\rvec2 normalDir=vec2(-dir.y,dir.x);\rnormalDir*=width/2.0;\rnormalDir.x/=aspectRatio;\rvec4 offset=vec4(normalDir*normal.w,0.0,0.0);\rgl_Position=viewPosition+offset;\r#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)\nvec4 worldPos=finalWorld*vec4(position,1.0);\r#include<clipPlaneVertex>\n#endif\n#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const lineVertexShader = { name, shader };\n"]}
+{"version":3,"file":"line.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/line.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,6CAA6C,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6Bb,CAAC;AACH,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\";\nimport \"./ShadersInclude/instancesDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"lineVertexShader\";\nconst shader = `#include<instancesDeclaration>\n#include<clipPlaneVertexDeclaration>\nattribute vec3 position;\rattribute vec4 normal;\runiform mat4 viewProjection;\runiform float width;\runiform float aspectRatio;\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\n#include<instancesVertex>\nmat4 worldViewProjection=viewProjection*finalWorld;\rvec4 viewPosition=worldViewProjection*vec4(position,1.0);\rvec4 viewPositionNext=worldViewProjection*vec4(normal.xyz,1.0);\rvec2 currentScreen=viewPosition.xy/viewPosition.w;\rvec2 nextScreen=viewPositionNext.xy/viewPositionNext.w;\rcurrentScreen.x*=aspectRatio;\rnextScreen.x*=aspectRatio;\rvec2 dir=normalize(nextScreen-currentScreen);\rvec2 normalDir=vec2(-dir.y,dir.x);\rnormalDir*=width/2.0;\rnormalDir.x/=aspectRatio;\rvec4 offset=vec4(normalDir*normal.w,0.0,0.0);\rgl_Position=viewPosition+offset;\r#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)\nvec4 worldPos=finalWorld*vec4(position,1.0);\r#include<clipPlaneVertex>\n#endif\n#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const lineVertexShader = { name, shader };\n"]}

package/Shaders/minmaxRedux.fragment.d.ts

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

package/Shaders/minmaxRedux.fragment.js

@@ -12,6 +12,6 @@ void main(void)
 `;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const minmaxReduxPixelShader = { name, shader };
 //# sourceMappingURL=minmaxRedux.fragment.js.map

package/Shaders/minmaxRedux.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"minmaxRedux.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/minmaxRedux.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDd,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 = \"minmaxReduxPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#if defined(INITIAL)\nuniform sampler2D sourceTexture;\runiform vec2 texSize;\rvoid main(void)\r{\rivec2 coord=ivec2(vUV*(texSize-1.0));\rfloat f1=texelFetch(sourceTexture,coord,0).r;\rfloat f2=texelFetch(sourceTexture,coord+ivec2(1,0),0).r;\rfloat f3=texelFetch(sourceTexture,coord+ivec2(1,1),0).r;\rfloat f4=texelFetch(sourceTexture,coord+ivec2(0,1),0).r;\rfloat minz=min(min(min(f1,f2),f3),f4);\r#ifdef DEPTH_REDUX\nfloat maxz=max(max(max(sign(1.0-f1)*f1,sign(1.0-f2)*f2),sign(1.0-f3)*f3),sign(1.0-f4)*f4);\r#else\nfloat maxz=max(max(max(f1,f2),f3),f4);\r#endif\nglFragColor=vec4(minz,maxz,0.,0.);\r}\r#elif defined(MAIN)\nuniform vec2 texSize;\rvoid main(void)\r{\rivec2 coord=ivec2(vUV*(texSize-1.0));\rvec2 f1=texelFetch(textureSampler,coord,0).rg;\rvec2 f2=texelFetch(textureSampler,coord+ivec2(1,0),0).rg;\rvec2 f3=texelFetch(textureSampler,coord+ivec2(1,1),0).rg;\rvec2 f4=texelFetch(textureSampler,coord+ivec2(0,1),0).rg;\rfloat minz=min(min(min(f1.x,f2.x),f3.x),f4.x);\rfloat maxz=max(max(max(f1.y,f2.y),f3.y),f4.y);\rglFragColor=vec4(minz,maxz,0.,0.);\r}\r#elif defined(ONEBEFORELAST)\nuniform ivec2 texSize;\rvoid main(void)\r{\rivec2 coord=ivec2(vUV*vec2(texSize-1));\rvec2 f1=texelFetch(textureSampler,coord % texSize,0).rg;\rvec2 f2=texelFetch(textureSampler,(coord+ivec2(1,0)) % texSize,0).rg;\rvec2 f3=texelFetch(textureSampler,(coord+ivec2(1,1)) % texSize,0).rg;\rvec2 f4=texelFetch(textureSampler,(coord+ivec2(0,1)) % texSize,0).rg;\rfloat minz=min(f1.x,f2.x);\rfloat maxz=max(f1.y,f2.y);\rglFragColor=vec4(minz,maxz,0.,0.);\r}\r#elif defined(LAST)\nvoid main(void)\r{\rglFragColor=vec4(0.);\rif (true) { \rdiscard;\r}\r}\r#endif\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const minmaxReduxPixelShader = { name, shader };\n"]}
+{"version":3,"file":"minmaxRedux.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/minmaxRedux.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDd,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 = \"minmaxReduxPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#if defined(INITIAL)\nuniform sampler2D sourceTexture;\runiform vec2 texSize;\rvoid main(void)\r{\rivec2 coord=ivec2(vUV*(texSize-1.0));\rfloat f1=texelFetch(sourceTexture,coord,0).r;\rfloat f2=texelFetch(sourceTexture,coord+ivec2(1,0),0).r;\rfloat f3=texelFetch(sourceTexture,coord+ivec2(1,1),0).r;\rfloat f4=texelFetch(sourceTexture,coord+ivec2(0,1),0).r;\rfloat minz=min(min(min(f1,f2),f3),f4);\r#ifdef DEPTH_REDUX\nfloat maxz=max(max(max(sign(1.0-f1)*f1,sign(1.0-f2)*f2),sign(1.0-f3)*f3),sign(1.0-f4)*f4);\r#else\nfloat maxz=max(max(max(f1,f2),f3),f4);\r#endif\nglFragColor=vec4(minz,maxz,0.,0.);\r}\r#elif defined(MAIN)\nuniform vec2 texSize;\rvoid main(void)\r{\rivec2 coord=ivec2(vUV*(texSize-1.0));\rvec2 f1=texelFetch(textureSampler,coord,0).rg;\rvec2 f2=texelFetch(textureSampler,coord+ivec2(1,0),0).rg;\rvec2 f3=texelFetch(textureSampler,coord+ivec2(1,1),0).rg;\rvec2 f4=texelFetch(textureSampler,coord+ivec2(0,1),0).rg;\rfloat minz=min(min(min(f1.x,f2.x),f3.x),f4.x);\rfloat maxz=max(max(max(f1.y,f2.y),f3.y),f4.y);\rglFragColor=vec4(minz,maxz,0.,0.);\r}\r#elif defined(ONEBEFORELAST)\nuniform ivec2 texSize;\rvoid main(void)\r{\rivec2 coord=ivec2(vUV*vec2(texSize-1));\rvec2 f1=texelFetch(textureSampler,coord % texSize,0).rg;\rvec2 f2=texelFetch(textureSampler,(coord+ivec2(1,0)) % texSize,0).rg;\rvec2 f3=texelFetch(textureSampler,(coord+ivec2(1,1)) % texSize,0).rg;\rvec2 f4=texelFetch(textureSampler,(coord+ivec2(0,1)) % texSize,0).rg;\rfloat minz=min(f1.x,f2.x);\rfloat maxz=max(f1.y,f2.y);\rglFragColor=vec4(minz,maxz,0.,0.);\r}\r#elif defined(LAST)\nvoid main(void)\r{\rglFragColor=vec4(0.);\rif (true) { \rdiscard;\r}\r}\r#endif\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const minmaxReduxPixelShader = { name, shader };\n"]}

package/Shaders/motionBlur.fragment.d.ts

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