@babylonjs/core 6.14.2 → 6.16.0

package/Shaders/ShadersInclude/uvVariableDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"uvVariableDeclaration.js","sourceRoot":"","sources":["../../../../../dev/core/src/Shaders/ShadersInclude/uvVariableDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;CAMd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"uvVariableDeclaration\";\nconst shader = `#if !defined(UV{X}) && defined(MAINUV{X})\nvec2 uv{X}=vec2(0.,0.);\r#endif\n#ifdef MAINUV{X}\nvMainUV{X}=uv{X};\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const uvVariableDeclaration = { name, shader };\n"]}
+{"version":3,"file":"uvVariableDeclaration.js","sourceRoot":"","sources":["../../../../../dev/core/src/Shaders/ShadersInclude/uvVariableDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;CAMd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"uvVariableDeclaration\";\nconst shader = `#if !defined(UV{X}) && defined(MAINUV{X})\nvec2 uv{X}=vec2(0.,0.);\n#endif\n#ifdef MAINUV{X}\nvMainUV{X}=uv{X};\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const uvVariableDeclaration = { name, shader };\n"]}

package/Shaders/ShadersInclude/vertexColorMixing.js

@@ -2,13 +2,17 @@
 import { ShaderStore } from "../../Engines/shaderStore.js";
 const name = "vertexColorMixing";
 const shader = `#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
-vColor=vec4(1.0);
+vColor=vec4(1.0);
+#ifdef VERTEXCOLOR
 #ifdef VERTEXALPHA
-vColor*=color;
-vColor.rgb*=color.rgb;
+vColor*=color;
+#else
+vColor.rgb*=color.rgb;
+#endif
 #endif
 #ifdef INSTANCESCOLOR
-vColor*=instanceColor;
+vColor*=instanceColor;
+#endif
 #endif
 `;
 // Sideeffect

package/Shaders/ShadersInclude/vertexColorMixing.js.map

@@ -1 +1 @@
-{"version":3,"file":"vertexColorMixing.js","sourceRoot":"","sources":["../../../../../dev/core/src/Shaders/ShadersInclude/vertexColorMixing.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,mBAAmB,CAAC;AACjC,MAAM,MAAM,GAAG;;;;;;;;;;;;;CAad,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"vertexColorMixing\";\nconst shader = `#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvColor=vec4(1.0);\r#ifdef VERTEXCOLOR\n#ifdef VERTEXALPHA\nvColor*=color;\r#else\nvColor.rgb*=color.rgb;\r#endif\n#endif\n#ifdef INSTANCESCOLOR\nvColor*=instanceColor;\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const vertexColorMixing = { name, shader };\n"]}
+{"version":3,"file":"vertexColorMixing.js","sourceRoot":"","sources":["../../../../../dev/core/src/Shaders/ShadersInclude/vertexColorMixing.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,mBAAmB,CAAC;AACjC,MAAM,MAAM,GAAG;;;;;;;;;;;;;CAad,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"vertexColorMixing\";\nconst shader = `#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvColor=vec4(1.0);\n#ifdef VERTEXCOLOR\n#ifdef VERTEXALPHA\nvColor*=color;\n#else\nvColor.rgb*=color.rgb;\n#endif\n#endif\n#ifdef INSTANCESCOLOR\nvColor*=instanceColor;\n#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const vertexColorMixing = { name, shader };\n"]}

package/Shaders/anaglyph.fragment.js

@@ -1,8 +1,10 @@
 // Do not edit.
 import { ShaderStore } from "../Engines/shaderStore.js";
 const name = "anaglyphPixelShader";
-const shader = `varying vec2 vUV;
-void main(void)
+const shader = `varying vec2 vUV;uniform sampler2D textureSampler;uniform sampler2D leftSampler;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{vec4 leftFrag=texture2D(leftSampler,vUV);leftFrag=vec4(1.0,leftFrag.g,leftFrag.b,1.0);vec4 rightFrag=texture2D(textureSampler,vUV);rightFrag=vec4(rightFrag.r,1.0,1.0,1.0);gl_FragColor=vec4(rightFrag.rgb*leftFrag.rgb,1.0);}`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
 /** @internal */

package/Shaders/anaglyph.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"anaglyph.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/anaglyph.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;EAWb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"anaglyphPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform sampler2D leftSampler;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rvec4 leftFrag=texture2D(leftSampler,vUV);\rleftFrag=vec4(1.0,leftFrag.g,leftFrag.b,1.0);\rvec4 rightFrag=texture2D(textureSampler,vUV);\rrightFrag=vec4(rightFrag.r,1.0,1.0,1.0);\rgl_FragColor=vec4(rightFrag.rgb*leftFrag.rgb,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const anaglyphPixelShader = { name, shader };\n"]}
+{"version":3,"file":"anaglyph.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/anaglyph.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;gOAGiN,CAAC;AACjO,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"anaglyphPixelShader\";\nconst shader = `varying vec2 vUV;uniform sampler2D textureSampler;uniform sampler2D leftSampler;\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{vec4 leftFrag=texture2D(leftSampler,vUV);leftFrag=vec4(1.0,leftFrag.g,leftFrag.b,1.0);vec4 rightFrag=texture2D(textureSampler,vUV);rightFrag=vec4(rightFrag.r,1.0,1.0,1.0);gl_FragColor=vec4(rightFrag.rgb*leftFrag.rgb,1.0);}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const anaglyphPixelShader = { name, shader };\n"]}

package/Shaders/background.fragment.js

@@ -19,41 +19,54 @@ const name = "backgroundPixelShader";
 const shader = `#ifdef TEXTURELODSUPPORT
 #extension GL_EXT_shader_texture_lod : enable
 #endif
-precision highp float;
+precision highp float;
+#include<__decl__backgroundFragment>
 #include<helperFunctions>
 #define RECIPROCAL_PI2 0.15915494
-varying vec3 vPositionW;
-varying vec2 vMainUV1;
+varying vec3 vPositionW;
+#ifdef MAINUV1
+varying vec2 vMainUV1;
+#endif 
 #ifdef MAINUV2 
-varying vec2 vMainUV2; 
+varying vec2 vMainUV2; 
+#endif 
 #ifdef NORMAL
-varying vec3 vNormalW;
+varying vec3 vNormalW;
+#endif
 #ifdef DIFFUSE
 #if DIFFUSEDIRECTUV==1
 #define vDiffuseUV vMainUV1
 #elif DIFFUSEDIRECTUV==2
 #define vDiffuseUV vMainUV2
 #else
-varying vec2 vDiffuseUV;
-uniform sampler2D diffuseSampler;
+varying vec2 vDiffuseUV;
+#endif
+uniform sampler2D diffuseSampler;
+#endif
 #ifdef REFLECTION
 #ifdef REFLECTIONMAP_3D
 #define sampleReflection(s,c) textureCube(s,c)
-uniform samplerCube reflectionSampler;
+uniform samplerCube reflectionSampler;
+#ifdef TEXTURELODSUPPORT
 #define sampleReflectionLod(s,c,l) textureCubeLodEXT(s,c,l)
 #else
-uniform samplerCube reflectionSamplerLow;
+uniform samplerCube reflectionSamplerLow;uniform samplerCube reflectionSamplerHigh;
+#endif
 #else
 #define sampleReflection(s,c) texture2D(s,c)
-uniform sampler2D reflectionSampler;
+uniform sampler2D reflectionSampler;
+#ifdef TEXTURELODSUPPORT
 #define sampleReflectionLod(s,c,l) texture2DLodEXT(s,c,l)
 #else
-uniform samplerCube reflectionSamplerLow;
+uniform samplerCube reflectionSamplerLow;uniform samplerCube reflectionSamplerHigh;
+#endif
 #endif
 #ifdef REFLECTIONMAP_SKYBOX
-varying vec3 vPositionUVW;
+varying vec3 vPositionUVW;
+#else
 #if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
-varying vec3 vDirectionW;
+varying vec3 vDirectionW;
+#endif
 #endif
 #include<reflectionFunction>
 #endif
@@ -72,76 +85,134 @@ varying vec3 vDirectionW;
 #include<fogFragmentDeclaration>
 #ifdef REFLECTIONFRESNEL
 #define FRESNEL_MAXIMUM_ON_ROUGH 0.25
-vec3 fresnelSchlickEnvironmentGGX(float VdotN,vec3 reflectance0,vec3 reflectance90,float smoothness)
+vec3 fresnelSchlickEnvironmentGGX(float VdotN,vec3 reflectance0,vec3 reflectance90,float smoothness)
+{float weight=mix(FRESNEL_MAXIMUM_ON_ROUGH,1.0,smoothness);return reflectance0+weight*(reflectance90-reflectance0)*pow5(saturate(1.0-VdotN));}
+#endif
 #define CUSTOM_FRAGMENT_DEFINITIONS
-void main(void) {
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
 #include<clipPlaneFragment>
-vec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);
-vec3 normalW=normalize(vNormalW);
-vec3 normalW=vec3(0.0,1.0,0.0);
-float shadow=1.;
+vec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(0.0,1.0,0.0);
+#endif
+float shadow=1.;float globalShadow=0.;float shadowLightCount=0.;
+#include<lightFragment>[0..maxSimultaneousLights]
 #ifdef SHADOWINUSE
-globalShadow/=shadowLightCount;
-globalShadow=1.0;
+globalShadow/=shadowLightCount;
+#else
+globalShadow=1.0;
+#endif
 #ifndef BACKMAT_SHADOWONLY
-vec4 reflectionColor=vec4(1.,1.,1.,1.);
-vec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),normalW);
-reflectionVector.z*=-1.0;
+vec4 reflectionColor=vec4(1.,1.,1.,1.);
+#ifdef REFLECTION
+vec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),normalW);
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
 #ifdef REFLECTIONMAP_3D
-vec3 reflectionCoords=reflectionVector;
-vec2 reflectionCoords=reflectionVector.xy;
-reflectionCoords/=reflectionVector.z;
-reflectionCoords.y=1.0-reflectionCoords.y;
+vec3 reflectionCoords=reflectionVector;
+#else
+vec2 reflectionCoords=reflectionVector.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+reflectionCoords/=reflectionVector.z;
+#endif
+reflectionCoords.y=1.0-reflectionCoords.y;
+#endif
 #ifdef REFLECTIONBLUR
-float reflectionLOD=vReflectionInfos.y;
-reflectionLOD=reflectionLOD*log2(vReflectionMicrosurfaceInfos.x)*vReflectionMicrosurfaceInfos.y+vReflectionMicrosurfaceInfos.z;
-float lodReflectionNormalized=saturate(reflectionLOD);
+float reflectionLOD=vReflectionInfos.y;
+#ifdef TEXTURELODSUPPORT
+reflectionLOD=reflectionLOD*log2(vReflectionMicrosurfaceInfos.x)*vReflectionMicrosurfaceInfos.y+vReflectionMicrosurfaceInfos.z;reflectionColor=sampleReflectionLod(reflectionSampler,reflectionCoords,reflectionLOD);
 #else
-vec4 reflectionSample=sampleReflection(reflectionSampler,reflectionCoords);
+float lodReflectionNormalized=saturate(reflectionLOD);float lodReflectionNormalizedDoubled=lodReflectionNormalized*2.0;vec4 reflectionSpecularMid=sampleReflection(reflectionSampler,reflectionCoords);if(lodReflectionNormalizedDoubled<1.0){reflectionColor=mix(
+sampleReflection(reflectionSamplerHigh,reflectionCoords),
+reflectionSpecularMid,
+lodReflectionNormalizedDoubled
+);} else {reflectionColor=mix(
+reflectionSpecularMid,
+sampleReflection(reflectionSamplerLow,reflectionCoords),
+lodReflectionNormalizedDoubled-1.0
+);}
+#endif
+#else
+vec4 reflectionSample=sampleReflection(reflectionSampler,reflectionCoords);reflectionColor=reflectionSample;
+#endif
 #ifdef RGBDREFLECTION
-reflectionColor.rgb=fromRGBD(reflectionColor);
+reflectionColor.rgb=fromRGBD(reflectionColor);
+#endif
 #ifdef GAMMAREFLECTION
-reflectionColor.rgb=toLinearSpace(reflectionColor.rgb);
+reflectionColor.rgb=toLinearSpace(reflectionColor.rgb);
+#endif
 #ifdef REFLECTIONBGR
-reflectionColor.rgb=reflectionColor.bgr;
-reflectionColor.rgb*=vReflectionInfos.x;
-vec3 diffuseColor=vec3(1.,1.,1.);
-vec4 diffuseMap=texture2D(diffuseSampler,vDiffuseUV);
-diffuseMap.rgb=toLinearSpace(diffuseMap.rgb);
-diffuseMap.rgb*=vDiffuseInfos.y;
-finalAlpha*=diffuseMap.a;
-diffuseColor=diffuseMap.rgb;
+reflectionColor.rgb=reflectionColor.bgr;
+#endif
+reflectionColor.rgb*=vReflectionInfos.x;
+#endif
+vec3 diffuseColor=vec3(1.,1.,1.);float finalAlpha=alpha;
+#ifdef DIFFUSE
+vec4 diffuseMap=texture2D(diffuseSampler,vDiffuseUV);
+#ifdef GAMMADIFFUSE
+diffuseMap.rgb=toLinearSpace(diffuseMap.rgb);
+#endif
+diffuseMap.rgb*=vDiffuseInfos.y;
+#ifdef DIFFUSEHASALPHA
+finalAlpha*=diffuseMap.a;
+#endif
+diffuseColor=diffuseMap.rgb;
+#endif
 #ifdef REFLECTIONFRESNEL
-vec3 colorBase=diffuseColor;
-vec3 colorBase=reflectionColor.rgb*diffuseColor;
-colorBase=max(colorBase,0.0);
-vec3 finalColor=colorBase;
+vec3 colorBase=diffuseColor;
+#else
+vec3 colorBase=reflectionColor.rgb*diffuseColor;
+#endif
+colorBase=max(colorBase,0.0);
+#ifdef USERGBCOLOR
+vec3 finalColor=colorBase;
+#else
 #ifdef USEHIGHLIGHTANDSHADOWCOLORS
-vec3 mainColor=mix(vPrimaryColorShadow.rgb,vPrimaryColor.rgb,colorBase);
-vec3 mainColor=vPrimaryColor.rgb;
-vec3 finalColor=colorBase*mainColor;
+vec3 mainColor=mix(vPrimaryColorShadow.rgb,vPrimaryColor.rgb,colorBase);
+#else
+vec3 mainColor=vPrimaryColor.rgb;
+#endif
+vec3 finalColor=colorBase*mainColor;
+#endif
 #ifdef REFLECTIONFRESNEL
-vec3 reflectionAmount=vReflectionControl.xxx;
-float reflectionDistanceFalloff=1.0-saturate(length(vPositionW.xyz-vBackgroundCenter)*vReflectionControl.w);
-finalColor=mix(finalColor,reflectionColor.rgb,saturate(reflectionAmount));
+vec3 reflectionAmount=vReflectionControl.xxx;vec3 reflectionReflectance0=vReflectionControl.yyy;vec3 reflectionReflectance90=vReflectionControl.zzz;float VdotN=dot(normalize(vEyePosition.xyz),normalW);vec3 planarReflectionFresnel=fresnelSchlickEnvironmentGGX(saturate(VdotN),reflectionReflectance0,reflectionReflectance90,1.0);reflectionAmount*=planarReflectionFresnel;
+#ifdef REFLECTIONFALLOFF
+float reflectionDistanceFalloff=1.0-saturate(length(vPositionW.xyz-vBackgroundCenter)*vReflectionControl.w);reflectionDistanceFalloff*=reflectionDistanceFalloff;reflectionAmount*=reflectionDistanceFalloff;
+#endif
+finalColor=mix(finalColor,reflectionColor.rgb,saturate(reflectionAmount));
+#endif
 #ifdef OPACITYFRESNEL
-float viewAngleToFloor=dot(normalW,normalize(vEyePosition.xyz-vBackgroundCenter));
+float viewAngleToFloor=dot(normalW,normalize(vEyePosition.xyz-vBackgroundCenter));const float startAngle=0.1;float fadeFactor=saturate(viewAngleToFloor/startAngle);finalAlpha*=fadeFactor*fadeFactor;
+#endif
 #ifdef SHADOWINUSE
-finalColor=mix(finalColor*shadowLevel,finalColor,globalShadow);
-vec4 color=vec4(finalColor,finalAlpha);
-vec4 color=vec4(vPrimaryColor.rgb,(1.0-clamp(globalShadow,0.,1.))*alpha);
+finalColor=mix(finalColor*shadowLevel,finalColor,globalShadow);
+#endif
+vec4 color=vec4(finalColor,finalAlpha);
+#else
+vec4 color=vec4(vPrimaryColor.rgb,(1.0-clamp(globalShadow,0.,1.))*alpha);
+#endif
 #include<fogFragment>
 #ifdef IMAGEPROCESSINGPOSTPROCESS
 #if !defined(SKIPFINALCOLORCLAMP)
-color.rgb=clamp(color.rgb,0.,30.0);
+color.rgb=clamp(color.rgb,0.,30.0);
+#endif
 #else
-color=applyImageProcessing(color);
+color=applyImageProcessing(color);
+#endif
 #ifdef PREMULTIPLYALPHA
-color.rgb*=color.a;
+color.rgb*=color.a;
+#endif
 #ifdef NOISE
-color.rgb+=dither(vPositionW.xy,0.5);
-gl_FragColor=color;
-}
+color.rgb+=dither(vPositionW.xy,0.5);color=max(color,0.0);
+#endif
+gl_FragColor=color;
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
 /** @internal */

package/Shaders/background.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"background.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/background.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,gDAAgD,CAAC;AACxD,OAAO,2CAA2C,CAAC;AACnD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,6CAA6C,CAAC;AACrD,OAAO,2CAA2C,CAAC;AACnD,OAAO,sCAAsC,CAAC;AAC9C,OAAO,0CAA0C,CAAC;AAClD,OAAO,2CAA2C,CAAC;AACnD,OAAO,2CAA2C,CAAC;AACnD,OAAO,+CAA+C,CAAC;AACvD,OAAO,yCAAyC,CAAC;AACjD,OAAO,oCAAoC,CAAC;AAC5C,OAAO,gCAAgC,CAAC;AACxC,OAAO,8BAA8B,CAAC;AAEtC,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgOd,CAAC;AACF,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/backgroundFragmentDeclaration\";\nimport \"./ShadersInclude/backgroundUboDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/reflectionFunction\";\nimport \"./ShadersInclude/imageProcessingDeclaration\";\nimport \"./ShadersInclude/lightFragmentDeclaration\";\nimport \"./ShadersInclude/lightUboDeclaration\";\nimport \"./ShadersInclude/lightsFragmentFunctions\";\nimport \"./ShadersInclude/shadowsFragmentFunctions\";\nimport \"./ShadersInclude/imageProcessingFunctions\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/fogFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\nimport \"./ShadersInclude/lightFragment\";\nimport \"./ShadersInclude/fogFragment\";\n\nconst name = \"backgroundPixelShader\";\nconst shader = `#ifdef TEXTURELODSUPPORT\n#extension GL_EXT_shader_texture_lod : enable\n#endif\nprecision highp float;\r#include<__decl__backgroundFragment>\n#include<helperFunctions>\n#define RECIPROCAL_PI2 0.15915494\nvarying vec3 vPositionW;\r#ifdef MAINUV1\nvarying vec2 vMainUV1;\r#endif \n#ifdef MAINUV2 \nvarying vec2 vMainUV2; \r#endif \n#ifdef NORMAL\nvarying vec3 vNormalW;\r#endif\n#ifdef DIFFUSE\n#if DIFFUSEDIRECTUV==1\n#define vDiffuseUV vMainUV1\n#elif DIFFUSEDIRECTUV==2\n#define vDiffuseUV vMainUV2\n#else\nvarying vec2 vDiffuseUV;\r#endif\nuniform sampler2D diffuseSampler;\r#endif\n#ifdef REFLECTION\n#ifdef REFLECTIONMAP_3D\n#define sampleReflection(s,c) textureCube(s,c)\nuniform samplerCube reflectionSampler;\r#ifdef TEXTURELODSUPPORT\n#define sampleReflectionLod(s,c,l) textureCubeLodEXT(s,c,l)\n#else\nuniform samplerCube reflectionSamplerLow;\runiform samplerCube reflectionSamplerHigh;\r#endif\n#else\n#define sampleReflection(s,c) texture2D(s,c)\nuniform sampler2D reflectionSampler;\r#ifdef TEXTURELODSUPPORT\n#define sampleReflectionLod(s,c,l) texture2DLodEXT(s,c,l)\n#else\nuniform samplerCube reflectionSamplerLow;\runiform samplerCube reflectionSamplerHigh;\r#endif\n#endif\n#ifdef REFLECTIONMAP_SKYBOX\nvarying vec3 vPositionUVW;\r#else\n#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)\nvarying vec3 vDirectionW;\r#endif\n#endif\n#include<reflectionFunction>\n#endif\n#ifndef FROMLINEARSPACE\n#define FROMLINEARSPACE;\n#endif\n#ifndef SHADOWONLY\n#define SHADOWONLY;\n#endif\n#include<imageProcessingDeclaration>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#include<lightsFragmentFunctions>\n#include<shadowsFragmentFunctions>\n#include<imageProcessingFunctions>\n#include<clipPlaneFragmentDeclaration>\n#include<fogFragmentDeclaration>\n#ifdef REFLECTIONFRESNEL\n#define FRESNEL_MAXIMUM_ON_ROUGH 0.25\nvec3 fresnelSchlickEnvironmentGGX(float VdotN,vec3 reflectance0,vec3 reflectance90,float smoothness)\r{\rfloat weight=mix(FRESNEL_MAXIMUM_ON_ROUGH,1.0,smoothness);\rreturn reflectance0+weight*(reflectance90-reflectance0)*pow5(saturate(1.0-VdotN));\r}\r#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\nvec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);\r#ifdef NORMAL\nvec3 normalW=normalize(vNormalW);\r#else\nvec3 normalW=vec3(0.0,1.0,0.0);\r#endif\nfloat shadow=1.;\rfloat globalShadow=0.;\rfloat shadowLightCount=0.;\r#include<lightFragment>[0..maxSimultaneousLights]\n#ifdef SHADOWINUSE\nglobalShadow/=shadowLightCount;\r#else\nglobalShadow=1.0;\r#endif\n#ifndef BACKMAT_SHADOWONLY\nvec4 reflectionColor=vec4(1.,1.,1.,1.);\r#ifdef REFLECTION\nvec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),normalW);\r#ifdef REFLECTIONMAP_OPPOSITEZ\nreflectionVector.z*=-1.0;\r#endif\n#ifdef REFLECTIONMAP_3D\nvec3 reflectionCoords=reflectionVector;\r#else\nvec2 reflectionCoords=reflectionVector.xy;\r#ifdef REFLECTIONMAP_PROJECTION\nreflectionCoords/=reflectionVector.z;\r#endif\nreflectionCoords.y=1.0-reflectionCoords.y;\r#endif\n#ifdef REFLECTIONBLUR\nfloat reflectionLOD=vReflectionInfos.y;\r#ifdef TEXTURELODSUPPORT\nreflectionLOD=reflectionLOD*log2(vReflectionMicrosurfaceInfos.x)*vReflectionMicrosurfaceInfos.y+vReflectionMicrosurfaceInfos.z;\rreflectionColor=sampleReflectionLod(reflectionSampler,reflectionCoords,reflectionLOD);\r#else\nfloat lodReflectionNormalized=saturate(reflectionLOD);\rfloat lodReflectionNormalizedDoubled=lodReflectionNormalized*2.0;\rvec4 reflectionSpecularMid=sampleReflection(reflectionSampler,reflectionCoords);\rif(lodReflectionNormalizedDoubled<1.0){\rreflectionColor=mix(\rsampleReflection(reflectionSamplerHigh,reflectionCoords),\rreflectionSpecularMid,\rlodReflectionNormalizedDoubled\r);\r} else {\rreflectionColor=mix(\rreflectionSpecularMid,\rsampleReflection(reflectionSamplerLow,reflectionCoords),\rlodReflectionNormalizedDoubled-1.0\r);\r}\r#endif\n#else\nvec4 reflectionSample=sampleReflection(reflectionSampler,reflectionCoords);\rreflectionColor=reflectionSample;\r#endif\n#ifdef RGBDREFLECTION\nreflectionColor.rgb=fromRGBD(reflectionColor);\r#endif\n#ifdef GAMMAREFLECTION\nreflectionColor.rgb=toLinearSpace(reflectionColor.rgb);\r#endif\n#ifdef REFLECTIONBGR\nreflectionColor.rgb=reflectionColor.bgr;\r#endif\nreflectionColor.rgb*=vReflectionInfos.x;\r#endif\nvec3 diffuseColor=vec3(1.,1.,1.);\rfloat finalAlpha=alpha;\r#ifdef DIFFUSE\nvec4 diffuseMap=texture2D(diffuseSampler,vDiffuseUV);\r#ifdef GAMMADIFFUSE\ndiffuseMap.rgb=toLinearSpace(diffuseMap.rgb);\r#endif\ndiffuseMap.rgb*=vDiffuseInfos.y;\r#ifdef DIFFUSEHASALPHA\nfinalAlpha*=diffuseMap.a;\r#endif\ndiffuseColor=diffuseMap.rgb;\r#endif\n#ifdef REFLECTIONFRESNEL\nvec3 colorBase=diffuseColor;\r#else\nvec3 colorBase=reflectionColor.rgb*diffuseColor;\r#endif\ncolorBase=max(colorBase,0.0);\r#ifdef USERGBCOLOR\nvec3 finalColor=colorBase;\r#else\n#ifdef USEHIGHLIGHTANDSHADOWCOLORS\nvec3 mainColor=mix(vPrimaryColorShadow.rgb,vPrimaryColor.rgb,colorBase);\r#else\nvec3 mainColor=vPrimaryColor.rgb;\r#endif\nvec3 finalColor=colorBase*mainColor;\r#endif\n#ifdef REFLECTIONFRESNEL\nvec3 reflectionAmount=vReflectionControl.xxx;\rvec3 reflectionReflectance0=vReflectionControl.yyy;\rvec3 reflectionReflectance90=vReflectionControl.zzz;\rfloat VdotN=dot(normalize(vEyePosition.xyz),normalW);\rvec3 planarReflectionFresnel=fresnelSchlickEnvironmentGGX(saturate(VdotN),reflectionReflectance0,reflectionReflectance90,1.0);\rreflectionAmount*=planarReflectionFresnel;\r#ifdef REFLECTIONFALLOFF\nfloat reflectionDistanceFalloff=1.0-saturate(length(vPositionW.xyz-vBackgroundCenter)*vReflectionControl.w);\rreflectionDistanceFalloff*=reflectionDistanceFalloff;\rreflectionAmount*=reflectionDistanceFalloff;\r#endif\nfinalColor=mix(finalColor,reflectionColor.rgb,saturate(reflectionAmount));\r#endif\n#ifdef OPACITYFRESNEL\nfloat viewAngleToFloor=dot(normalW,normalize(vEyePosition.xyz-vBackgroundCenter));\rconst float startAngle=0.1;\rfloat fadeFactor=saturate(viewAngleToFloor/startAngle);\rfinalAlpha*=fadeFactor*fadeFactor;\r#endif\n#ifdef SHADOWINUSE\nfinalColor=mix(finalColor*shadowLevel,finalColor,globalShadow);\r#endif\nvec4 color=vec4(finalColor,finalAlpha);\r#else\nvec4 color=vec4(vPrimaryColor.rgb,(1.0-clamp(globalShadow,0.,1.))*alpha);\r#endif\n#include<fogFragment>\n#ifdef IMAGEPROCESSINGPOSTPROCESS\n#if !defined(SKIPFINALCOLORCLAMP)\ncolor.rgb=clamp(color.rgb,0.,30.0);\r#endif\n#else\ncolor=applyImageProcessing(color);\r#endif\n#ifdef PREMULTIPLYALPHA\ncolor.rgb*=color.a;\r#endif\n#ifdef NOISE\ncolor.rgb+=dither(vPositionW.xy,0.5);\rcolor=max(color,0.0);\r#endif\ngl_FragColor=color;\r#define CUSTOM_FRAGMENT_MAIN_END\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const backgroundPixelShader = { name, shader };\n"]}
+{"version":3,"file":"background.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/background.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,gDAAgD,CAAC;AACxD,OAAO,2CAA2C,CAAC;AACnD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,6CAA6C,CAAC;AACrD,OAAO,2CAA2C,CAAC;AACnD,OAAO,sCAAsC,CAAC;AAC9C,OAAO,0CAA0C,CAAC;AAClD,OAAO,2CAA2C,CAAC;AACnD,OAAO,2CAA2C,CAAC;AACnD,OAAO,+CAA+C,CAAC;AACvD,OAAO,yCAAyC,CAAC;AACjD,OAAO,oCAAoC,CAAC;AAC5C,OAAO,gCAAgC,CAAC;AACxC,OAAO,8BAA8B,CAAC;AAEtC,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoMd,CAAC;AACF,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/backgroundFragmentDeclaration\";\nimport \"./ShadersInclude/backgroundUboDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/reflectionFunction\";\nimport \"./ShadersInclude/imageProcessingDeclaration\";\nimport \"./ShadersInclude/lightFragmentDeclaration\";\nimport \"./ShadersInclude/lightUboDeclaration\";\nimport \"./ShadersInclude/lightsFragmentFunctions\";\nimport \"./ShadersInclude/shadowsFragmentFunctions\";\nimport \"./ShadersInclude/imageProcessingFunctions\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/fogFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\nimport \"./ShadersInclude/lightFragment\";\nimport \"./ShadersInclude/fogFragment\";\n\nconst name = \"backgroundPixelShader\";\nconst shader = `#ifdef TEXTURELODSUPPORT\n#extension GL_EXT_shader_texture_lod : enable\n#endif\nprecision highp float;\n#include<__decl__backgroundFragment>\n#include<helperFunctions>\n#define RECIPROCAL_PI2 0.15915494\nvarying vec3 vPositionW;\n#ifdef MAINUV1\nvarying vec2 vMainUV1;\n#endif \n#ifdef MAINUV2 \nvarying vec2 vMainUV2; \n#endif \n#ifdef NORMAL\nvarying vec3 vNormalW;\n#endif\n#ifdef DIFFUSE\n#if DIFFUSEDIRECTUV==1\n#define vDiffuseUV vMainUV1\n#elif DIFFUSEDIRECTUV==2\n#define vDiffuseUV vMainUV2\n#else\nvarying vec2 vDiffuseUV;\n#endif\nuniform sampler2D diffuseSampler;\n#endif\n#ifdef REFLECTION\n#ifdef REFLECTIONMAP_3D\n#define sampleReflection(s,c) textureCube(s,c)\nuniform samplerCube reflectionSampler;\n#ifdef TEXTURELODSUPPORT\n#define sampleReflectionLod(s,c,l) textureCubeLodEXT(s,c,l)\n#else\nuniform samplerCube reflectionSamplerLow;uniform samplerCube reflectionSamplerHigh;\n#endif\n#else\n#define sampleReflection(s,c) texture2D(s,c)\nuniform sampler2D reflectionSampler;\n#ifdef TEXTURELODSUPPORT\n#define sampleReflectionLod(s,c,l) texture2DLodEXT(s,c,l)\n#else\nuniform samplerCube reflectionSamplerLow;uniform samplerCube reflectionSamplerHigh;\n#endif\n#endif\n#ifdef REFLECTIONMAP_SKYBOX\nvarying vec3 vPositionUVW;\n#else\n#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)\nvarying vec3 vDirectionW;\n#endif\n#endif\n#include<reflectionFunction>\n#endif\n#ifndef FROMLINEARSPACE\n#define FROMLINEARSPACE;\n#endif\n#ifndef SHADOWONLY\n#define SHADOWONLY;\n#endif\n#include<imageProcessingDeclaration>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#include<lightsFragmentFunctions>\n#include<shadowsFragmentFunctions>\n#include<imageProcessingFunctions>\n#include<clipPlaneFragmentDeclaration>\n#include<fogFragmentDeclaration>\n#ifdef REFLECTIONFRESNEL\n#define FRESNEL_MAXIMUM_ON_ROUGH 0.25\nvec3 fresnelSchlickEnvironmentGGX(float VdotN,vec3 reflectance0,vec3 reflectance90,float smoothness)\n{float weight=mix(FRESNEL_MAXIMUM_ON_ROUGH,1.0,smoothness);return reflectance0+weight*(reflectance90-reflectance0)*pow5(saturate(1.0-VdotN));}\n#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\nvec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);\n#ifdef NORMAL\nvec3 normalW=normalize(vNormalW);\n#else\nvec3 normalW=vec3(0.0,1.0,0.0);\n#endif\nfloat shadow=1.;float globalShadow=0.;float shadowLightCount=0.;\n#include<lightFragment>[0..maxSimultaneousLights]\n#ifdef SHADOWINUSE\nglobalShadow/=shadowLightCount;\n#else\nglobalShadow=1.0;\n#endif\n#ifndef BACKMAT_SHADOWONLY\nvec4 reflectionColor=vec4(1.,1.,1.,1.);\n#ifdef REFLECTION\nvec3 reflectionVector=computeReflectionCoords(vec4(vPositionW,1.0),normalW);\n#ifdef REFLECTIONMAP_OPPOSITEZ\nreflectionVector.z*=-1.0;\n#endif\n#ifdef REFLECTIONMAP_3D\nvec3 reflectionCoords=reflectionVector;\n#else\nvec2 reflectionCoords=reflectionVector.xy;\n#ifdef REFLECTIONMAP_PROJECTION\nreflectionCoords/=reflectionVector.z;\n#endif\nreflectionCoords.y=1.0-reflectionCoords.y;\n#endif\n#ifdef REFLECTIONBLUR\nfloat reflectionLOD=vReflectionInfos.y;\n#ifdef TEXTURELODSUPPORT\nreflectionLOD=reflectionLOD*log2(vReflectionMicrosurfaceInfos.x)*vReflectionMicrosurfaceInfos.y+vReflectionMicrosurfaceInfos.z;reflectionColor=sampleReflectionLod(reflectionSampler,reflectionCoords,reflectionLOD);\n#else\nfloat lodReflectionNormalized=saturate(reflectionLOD);float lodReflectionNormalizedDoubled=lodReflectionNormalized*2.0;vec4 reflectionSpecularMid=sampleReflection(reflectionSampler,reflectionCoords);if(lodReflectionNormalizedDoubled<1.0){reflectionColor=mix(\nsampleReflection(reflectionSamplerHigh,reflectionCoords),\nreflectionSpecularMid,\nlodReflectionNormalizedDoubled\n);} else {reflectionColor=mix(\nreflectionSpecularMid,\nsampleReflection(reflectionSamplerLow,reflectionCoords),\nlodReflectionNormalizedDoubled-1.0\n);}\n#endif\n#else\nvec4 reflectionSample=sampleReflection(reflectionSampler,reflectionCoords);reflectionColor=reflectionSample;\n#endif\n#ifdef RGBDREFLECTION\nreflectionColor.rgb=fromRGBD(reflectionColor);\n#endif\n#ifdef GAMMAREFLECTION\nreflectionColor.rgb=toLinearSpace(reflectionColor.rgb);\n#endif\n#ifdef REFLECTIONBGR\nreflectionColor.rgb=reflectionColor.bgr;\n#endif\nreflectionColor.rgb*=vReflectionInfos.x;\n#endif\nvec3 diffuseColor=vec3(1.,1.,1.);float finalAlpha=alpha;\n#ifdef DIFFUSE\nvec4 diffuseMap=texture2D(diffuseSampler,vDiffuseUV);\n#ifdef GAMMADIFFUSE\ndiffuseMap.rgb=toLinearSpace(diffuseMap.rgb);\n#endif\ndiffuseMap.rgb*=vDiffuseInfos.y;\n#ifdef DIFFUSEHASALPHA\nfinalAlpha*=diffuseMap.a;\n#endif\ndiffuseColor=diffuseMap.rgb;\n#endif\n#ifdef REFLECTIONFRESNEL\nvec3 colorBase=diffuseColor;\n#else\nvec3 colorBase=reflectionColor.rgb*diffuseColor;\n#endif\ncolorBase=max(colorBase,0.0);\n#ifdef USERGBCOLOR\nvec3 finalColor=colorBase;\n#else\n#ifdef USEHIGHLIGHTANDSHADOWCOLORS\nvec3 mainColor=mix(vPrimaryColorShadow.rgb,vPrimaryColor.rgb,colorBase);\n#else\nvec3 mainColor=vPrimaryColor.rgb;\n#endif\nvec3 finalColor=colorBase*mainColor;\n#endif\n#ifdef REFLECTIONFRESNEL\nvec3 reflectionAmount=vReflectionControl.xxx;vec3 reflectionReflectance0=vReflectionControl.yyy;vec3 reflectionReflectance90=vReflectionControl.zzz;float VdotN=dot(normalize(vEyePosition.xyz),normalW);vec3 planarReflectionFresnel=fresnelSchlickEnvironmentGGX(saturate(VdotN),reflectionReflectance0,reflectionReflectance90,1.0);reflectionAmount*=planarReflectionFresnel;\n#ifdef REFLECTIONFALLOFF\nfloat reflectionDistanceFalloff=1.0-saturate(length(vPositionW.xyz-vBackgroundCenter)*vReflectionControl.w);reflectionDistanceFalloff*=reflectionDistanceFalloff;reflectionAmount*=reflectionDistanceFalloff;\n#endif\nfinalColor=mix(finalColor,reflectionColor.rgb,saturate(reflectionAmount));\n#endif\n#ifdef OPACITYFRESNEL\nfloat viewAngleToFloor=dot(normalW,normalize(vEyePosition.xyz-vBackgroundCenter));const float startAngle=0.1;float fadeFactor=saturate(viewAngleToFloor/startAngle);finalAlpha*=fadeFactor*fadeFactor;\n#endif\n#ifdef SHADOWINUSE\nfinalColor=mix(finalColor*shadowLevel,finalColor,globalShadow);\n#endif\nvec4 color=vec4(finalColor,finalAlpha);\n#else\nvec4 color=vec4(vPrimaryColor.rgb,(1.0-clamp(globalShadow,0.,1.))*alpha);\n#endif\n#include<fogFragment>\n#ifdef IMAGEPROCESSINGPOSTPROCESS\n#if !defined(SKIPFINALCOLORCLAMP)\ncolor.rgb=clamp(color.rgb,0.,30.0);\n#endif\n#else\ncolor=applyImageProcessing(color);\n#endif\n#ifdef PREMULTIPLYALPHA\ncolor.rgb*=color.a;\n#endif\n#ifdef NOISE\ncolor.rgb+=dither(vPositionW.xy,0.5);color=max(color,0.0);\n#endif\ngl_FragColor=color;\n#define CUSTOM_FRAGMENT_MAIN_END\n}\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const backgroundPixelShader = { name, shader };\n"]}

package/Shaders/background.vertex.js

@@ -17,69 +17,102 @@ import "./ShadersInclude/clipPlaneVertex.js";
 import "./ShadersInclude/fogVertex.js";
 import "./ShadersInclude/shadowsVertex.js";
 const name = "backgroundVertexShader";
-const shader = `precision highp float;
+const shader = `precision highp float;
+#include<__decl__backgroundVertex>
 #include<helperFunctions>
-attribute vec3 position;
-attribute vec3 normal;
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
 #include<bonesDeclaration>
 #include<bakedVertexAnimationDeclaration>
 #include<instancesDeclaration>
-varying vec3 vPositionW;
-varying vec3 vNormalW;
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
 #ifdef UV1
-attribute vec2 uv;
+attribute vec2 uv;
+#endif
 #ifdef UV2
-attribute vec2 uv2;
+attribute vec2 uv2;
+#endif
 #ifdef MAINUV1
-varying vec2 vMainUV1;
+varying vec2 vMainUV1;
+#endif
 #ifdef MAINUV2
-varying vec2 vMainUV2;
+varying vec2 vMainUV2;
+#endif
 #if defined(DIFFUSE) && DIFFUSEDIRECTUV==0
-varying vec2 vDiffuseUV;
+varying vec2 vDiffuseUV;
+#endif
 #include<clipPlaneVertexDeclaration>
 #include<fogVertexDeclaration>
 #include<__decl__lightVxFragment>[0..maxSimultaneousLights]
 #ifdef REFLECTIONMAP_SKYBOX
-varying vec3 vPositionUVW;
+varying vec3 vPositionUVW;
+#endif
 #if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
-varying vec3 vDirectionW;
+varying vec3 vDirectionW;
+#endif
 #define CUSTOM_VERTEX_DEFINITIONS
-void main(void) {
+void main(void) {
+#define CUSTOM_VERTEX_MAIN_BEGIN
 #ifdef REFLECTIONMAP_SKYBOX
-vPositionUVW=position;
+vPositionUVW=position;
+#endif
 #include<instancesVertex>
 #include<bonesVertex>
 #include<bakedVertexAnimation>
 #ifdef MULTIVIEW
-if (gl_ViewID_OVR==0u) {
-gl_Position=viewProjection*finalWorld*vec4(position,1.0);
-vec4 worldPos=finalWorld*vec4(position,1.0);
-mat3 normalWorld=mat3(finalWorld);
-normalWorld=transposeMat3(inverseMat3(normalWorld));
-vNormalW=normalize(normalWorld*normal);
+if (gl_ViewID_OVR==0u) {gl_Position=viewProjection*finalWorld*vec4(position,1.0);} else {gl_Position=viewProjectionR*finalWorld*vec4(position,1.0);}
+#else
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+#endif
+vec4 worldPos=finalWorld*vec4(position,1.0);vPositionW=vec3(worldPos);
+#ifdef NORMAL
+mat3 normalWorld=mat3(finalWorld);
+#ifdef NONUNIFORMSCALING
+normalWorld=transposeMat3(inverseMat3(normalWorld));
+#endif
+vNormalW=normalize(normalWorld*normal);
+#endif
 #if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
-vDirectionW=normalize(vec3(finalWorld*vec4(position,0.0)));
-mat3 screenToWorld=inverseMat3(mat3(finalWorld*viewProjection));
+vDirectionW=normalize(vec3(finalWorld*vec4(position,0.0)));
+#ifdef EQUIRECTANGULAR_RELFECTION_FOV
+mat3 screenToWorld=inverseMat3(mat3(finalWorld*viewProjection));vec3 segment=mix(vDirectionW,screenToWorld*vec3(0.0,0.0,1.0),abs(fFovMultiplier-1.0));if (fFovMultiplier<=1.0) {vDirectionW=normalize(segment);} else {vDirectionW=normalize(vDirectionW+(vDirectionW-segment));}
+#endif
 #endif
 #ifndef UV1
-vec2 uv=vec2(0.,0.);
+vec2 uv=vec2(0.,0.);
+#endif
 #ifndef UV2
-vec2 uv2=vec2(0.,0.);
+vec2 uv2=vec2(0.,0.);
+#endif
 #ifdef MAINUV1
-vMainUV1=uv;
+vMainUV1=uv;
+#endif
 #ifdef MAINUV2
-vMainUV2=uv2;
+vMainUV2=uv2;
+#endif
 #if defined(DIFFUSE) && DIFFUSEDIRECTUV==0
-if (vDiffuseInfos.x==0.)
+if (vDiffuseInfos.x==0.)
+{vDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));}
+else
+{vDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));}
+#endif
 #include<clipPlaneVertex>
 #include<fogVertex>
 #include<shadowsVertex>[0..maxSimultaneousLights]
 #ifdef VERTEXCOLOR
-vColor=color;
+vColor=color;
+#endif
 #if defined(POINTSIZE) && !defined(WEBGPU)
-gl_PointSize=pointSize;
+gl_PointSize=pointSize;
+#endif
 #define CUSTOM_VERTEX_MAIN_END
-}
+}
+`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
 /** @internal */

package/Shaders/background.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"background.vertex.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/background.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,8CAA8C,CAAC;AACtD,OAAO,2CAA2C,CAAC;AACnD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,mCAAmC,CAAC;AAC3C,OAAO,kDAAkD,CAAC;AAC1D,OAAO,uCAAuC,CAAC;AAC/C,OAAO,6CAA6C,CAAC;AACrD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,6CAA6C,CAAC;AACrD,OAAO,wCAAwC,CAAC;AAChD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,8BAA8B,CAAC;AACtC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,4BAA4B,CAAC;AACpC,OAAO,gCAAgC,CAAC;AAExC,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Gd,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\";\nimport \"./ShadersInclude/backgroundVertexDeclaration\";\nimport \"./ShadersInclude/backgroundUboDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/bonesDeclaration\";\nimport \"./ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"./ShadersInclude/instancesDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"./ShadersInclude/fogVertexDeclaration\";\nimport \"./ShadersInclude/lightVxFragmentDeclaration\";\nimport \"./ShadersInclude/lightVxUboDeclaration\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/bonesVertex\";\nimport \"./ShadersInclude/bakedVertexAnimation\";\nimport \"./ShadersInclude/clipPlaneVertex\";\nimport \"./ShadersInclude/fogVertex\";\nimport \"./ShadersInclude/shadowsVertex\";\n\nconst name = \"backgroundVertexShader\";\nconst shader = `precision highp float;\r#include<__decl__backgroundVertex>\n#include<helperFunctions>\nattribute vec3 position;\r#ifdef NORMAL\nattribute vec3 normal;\r#endif\n#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<instancesDeclaration>\nvarying vec3 vPositionW;\r#ifdef NORMAL\nvarying vec3 vNormalW;\r#endif\n#ifdef UV1\nattribute vec2 uv;\r#endif\n#ifdef UV2\nattribute vec2 uv2;\r#endif\n#ifdef MAINUV1\nvarying vec2 vMainUV1;\r#endif\n#ifdef MAINUV2\nvarying vec2 vMainUV2;\r#endif\n#if defined(DIFFUSE) && DIFFUSEDIRECTUV==0\nvarying vec2 vDiffuseUV;\r#endif\n#include<clipPlaneVertexDeclaration>\n#include<fogVertexDeclaration>\n#include<__decl__lightVxFragment>[0..maxSimultaneousLights]\n#ifdef REFLECTIONMAP_SKYBOX\nvarying vec3 vPositionUVW;\r#endif\n#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)\nvarying vec3 vDirectionW;\r#endif\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\n#ifdef REFLECTIONMAP_SKYBOX\nvPositionUVW=position;\r#endif\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\n#ifdef MULTIVIEW\nif (gl_ViewID_OVR==0u) {\rgl_Position=viewProjection*finalWorld*vec4(position,1.0);\r} else {\rgl_Position=viewProjectionR*finalWorld*vec4(position,1.0);\r}\r#else\ngl_Position=viewProjection*finalWorld*vec4(position,1.0);\r#endif\nvec4 worldPos=finalWorld*vec4(position,1.0);\rvPositionW=vec3(worldPos);\r#ifdef NORMAL\nmat3 normalWorld=mat3(finalWorld);\r#ifdef NONUNIFORMSCALING\nnormalWorld=transposeMat3(inverseMat3(normalWorld));\r#endif\nvNormalW=normalize(normalWorld*normal);\r#endif\n#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)\nvDirectionW=normalize(vec3(finalWorld*vec4(position,0.0)));\r#ifdef EQUIRECTANGULAR_RELFECTION_FOV\nmat3 screenToWorld=inverseMat3(mat3(finalWorld*viewProjection));\rvec3 segment=mix(vDirectionW,screenToWorld*vec3(0.0,0.0,1.0),abs(fFovMultiplier-1.0));\rif (fFovMultiplier<=1.0) {\rvDirectionW=normalize(segment);\r} else {\rvDirectionW=normalize(vDirectionW+(vDirectionW-segment));\r}\r#endif\n#endif\n#ifndef UV1\nvec2 uv=vec2(0.,0.);\r#endif\n#ifndef UV2\nvec2 uv2=vec2(0.,0.);\r#endif\n#ifdef MAINUV1\nvMainUV1=uv;\r#endif\n#ifdef MAINUV2\nvMainUV2=uv2;\r#endif\n#if defined(DIFFUSE) && DIFFUSEDIRECTUV==0\nif (vDiffuseInfos.x==0.)\r{\rvDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));\r}\relse\r{\rvDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));\r}\r#endif\n#include<clipPlaneVertex>\n#include<fogVertex>\n#include<shadowsVertex>[0..maxSimultaneousLights]\n#ifdef VERTEXCOLOR\nvColor=color;\r#endif\n#if defined(POINTSIZE) && !defined(WEBGPU)\ngl_PointSize=pointSize;\r#endif\n#define CUSTOM_VERTEX_MAIN_END\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const backgroundVertexShader = { name, shader };\n"]}
+{"version":3,"file":"background.vertex.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/background.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,8CAA8C,CAAC;AACtD,OAAO,2CAA2C,CAAC;AACnD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,mCAAmC,CAAC;AAC3C,OAAO,kDAAkD,CAAC;AAC1D,OAAO,uCAAuC,CAAC;AAC/C,OAAO,6CAA6C,CAAC;AACrD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,6CAA6C,CAAC;AACrD,OAAO,wCAAwC,CAAC;AAChD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,8BAA8B,CAAC;AACtC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,4BAA4B,CAAC;AACpC,OAAO,gCAAgC,CAAC;AAExC,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Fd,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\";\nimport \"./ShadersInclude/backgroundVertexDeclaration\";\nimport \"./ShadersInclude/backgroundUboDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/bonesDeclaration\";\nimport \"./ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"./ShadersInclude/instancesDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"./ShadersInclude/fogVertexDeclaration\";\nimport \"./ShadersInclude/lightVxFragmentDeclaration\";\nimport \"./ShadersInclude/lightVxUboDeclaration\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/bonesVertex\";\nimport \"./ShadersInclude/bakedVertexAnimation\";\nimport \"./ShadersInclude/clipPlaneVertex\";\nimport \"./ShadersInclude/fogVertex\";\nimport \"./ShadersInclude/shadowsVertex\";\n\nconst name = \"backgroundVertexShader\";\nconst shader = `precision highp float;\n#include<__decl__backgroundVertex>\n#include<helperFunctions>\nattribute vec3 position;\n#ifdef NORMAL\nattribute vec3 normal;\n#endif\n#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<instancesDeclaration>\nvarying vec3 vPositionW;\n#ifdef NORMAL\nvarying vec3 vNormalW;\n#endif\n#ifdef UV1\nattribute vec2 uv;\n#endif\n#ifdef UV2\nattribute vec2 uv2;\n#endif\n#ifdef MAINUV1\nvarying vec2 vMainUV1;\n#endif\n#ifdef MAINUV2\nvarying vec2 vMainUV2;\n#endif\n#if defined(DIFFUSE) && DIFFUSEDIRECTUV==0\nvarying vec2 vDiffuseUV;\n#endif\n#include<clipPlaneVertexDeclaration>\n#include<fogVertexDeclaration>\n#include<__decl__lightVxFragment>[0..maxSimultaneousLights]\n#ifdef REFLECTIONMAP_SKYBOX\nvarying vec3 vPositionUVW;\n#endif\n#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)\nvarying vec3 vDirectionW;\n#endif\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_VERTEX_MAIN_BEGIN\n#ifdef REFLECTIONMAP_SKYBOX\nvPositionUVW=position;\n#endif\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\n#ifdef MULTIVIEW\nif (gl_ViewID_OVR==0u) {gl_Position=viewProjection*finalWorld*vec4(position,1.0);} else {gl_Position=viewProjectionR*finalWorld*vec4(position,1.0);}\n#else\ngl_Position=viewProjection*finalWorld*vec4(position,1.0);\n#endif\nvec4 worldPos=finalWorld*vec4(position,1.0);vPositionW=vec3(worldPos);\n#ifdef NORMAL\nmat3 normalWorld=mat3(finalWorld);\n#ifdef NONUNIFORMSCALING\nnormalWorld=transposeMat3(inverseMat3(normalWorld));\n#endif\nvNormalW=normalize(normalWorld*normal);\n#endif\n#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)\nvDirectionW=normalize(vec3(finalWorld*vec4(position,0.0)));\n#ifdef EQUIRECTANGULAR_RELFECTION_FOV\nmat3 screenToWorld=inverseMat3(mat3(finalWorld*viewProjection));vec3 segment=mix(vDirectionW,screenToWorld*vec3(0.0,0.0,1.0),abs(fFovMultiplier-1.0));if (fFovMultiplier<=1.0) {vDirectionW=normalize(segment);} else {vDirectionW=normalize(vDirectionW+(vDirectionW-segment));}\n#endif\n#endif\n#ifndef UV1\nvec2 uv=vec2(0.,0.);\n#endif\n#ifndef UV2\nvec2 uv2=vec2(0.,0.);\n#endif\n#ifdef MAINUV1\nvMainUV1=uv;\n#endif\n#ifdef MAINUV2\nvMainUV2=uv2;\n#endif\n#if defined(DIFFUSE) && DIFFUSEDIRECTUV==0\nif (vDiffuseInfos.x==0.)\n{vDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));}\nelse\n{vDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));}\n#endif\n#include<clipPlaneVertex>\n#include<fogVertex>\n#include<shadowsVertex>[0..maxSimultaneousLights]\n#ifdef VERTEXCOLOR\nvColor=color;\n#endif\n#if defined(POINTSIZE) && !defined(WEBGPU)\ngl_PointSize=pointSize;\n#endif\n#define CUSTOM_VERTEX_MAIN_END\n}\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const backgroundVertexShader = { name, shader };\n"]}

package/Shaders/blackAndWhite.fragment.js

@@ -1,8 +1,11 @@
 // Do not edit.
 import { ShaderStore } from "../Engines/shaderStore.js";
 const name = "blackAndWhitePixelShader";
-const shader = `varying vec2 vUV;
-void main(void) 
+const shader = `varying vec2 vUV;uniform sampler2D textureSampler;uniform float degree;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) 
+{vec3 color=texture2D(textureSampler,vUV).rgb;float luminance=dot(color,vec3(0.3,0.59,0.11)); 
+vec3 blackAndWhite=vec3(luminance,luminance,luminance);gl_FragColor=vec4(color-((color-blackAndWhite)*degree),1.0);}`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
 /** @internal */

package/Shaders/blackAndWhite.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"blackAndWhite.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/blackAndWhite.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;;;;;;EAUb,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 = \"blackAndWhitePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform float degree;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \r{\rvec3 color=texture2D(textureSampler,vUV).rgb;\rfloat luminance=dot(color,vec3(0.3,0.59,0.11)); \rvec3 blackAndWhite=vec3(luminance,luminance,luminance);\rgl_FragColor=vec4(color-((color-blackAndWhite)*degree),1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const blackAndWhitePixelShader = { name, shader };\n"]}
+{"version":3,"file":"blackAndWhite.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/blackAndWhite.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;qHAIsG,CAAC;AACtH,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 = \"blackAndWhitePixelShader\";\nconst shader = `varying vec2 vUV;uniform sampler2D textureSampler;uniform float degree;\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \n{vec3 color=texture2D(textureSampler,vUV).rgb;float luminance=dot(color,vec3(0.3,0.59,0.11)); \nvec3 blackAndWhite=vec3(luminance,luminance,luminance);gl_FragColor=vec4(color-((color-blackAndWhite)*degree),1.0);}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const blackAndWhitePixelShader = { name, shader };\n"]}

package/Shaders/bloomMerge.fragment.js

@@ -1,8 +1,11 @@
 // Do not edit.
 import { ShaderStore } from "../Engines/shaderStore.js";
 const name = "bloomMergePixelShader";
-const shader = `uniform sampler2D textureSampler;
-void main(void)
+const shader = `uniform sampler2D textureSampler;uniform sampler2D bloomBlur;varying vec2 vUV;uniform float bloomWeight;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{gl_FragColor=texture2D(textureSampler,vUV);vec3 blurred=texture2D(bloomBlur,vUV).rgb;gl_FragColor.rgb=gl_FragColor.rgb+(blurred.rgb*bloomWeight); }
+`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
 /** @internal */

package/Shaders/bloomMerge.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"bloomMerge.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/bloomMerge.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;CAWd,CAAC;AACF,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 = \"bloomMergePixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform sampler2D bloomBlur;\rvarying vec2 vUV;\runiform float bloomWeight;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rgl_FragColor=texture2D(textureSampler,vUV);\rvec3 blurred=texture2D(bloomBlur,vUV).rgb;\rgl_FragColor.rgb=gl_FragColor.rgb+(blurred.rgb*bloomWeight); \r}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const bloomMergePixelShader = { name, shader };\n"]}
+{"version":3,"file":"bloomMerge.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/bloomMerge.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;CAId,CAAC;AACF,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 = \"bloomMergePixelShader\";\nconst shader = `uniform sampler2D textureSampler;uniform sampler2D bloomBlur;varying vec2 vUV;uniform float bloomWeight;\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{gl_FragColor=texture2D(textureSampler,vUV);vec3 blurred=texture2D(bloomBlur,vUV).rgb;gl_FragColor.rgb=gl_FragColor.rgb+(blurred.rgb*bloomWeight); }\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const bloomMergePixelShader = { name, shader };\n"]}

package/Shaders/blur.fragment.js

@@ -1,8 +1,12 @@
 // Do not edit.
 import { ShaderStore } from "../Engines/shaderStore.js";
 const name = "blurPixelShader";
-const shader = `varying vec2 vUV;
-void main(void)
+const shader = `varying vec2 vUV;uniform sampler2D textureSampler;uniform vec2 screenSize;uniform vec2 direction;uniform float blurWidth;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{float weights[7];weights[0]=0.05;weights[1]=0.1;weights[2]=0.2;weights[3]=0.3;weights[4]=0.2;weights[5]=0.1;weights[6]=0.05;vec2 texelSize=vec2(1.0/screenSize.x,1.0/screenSize.y);vec2 texelStep=texelSize*direction*blurWidth;vec2 start=vUV-3.0*texelStep;vec4 baseColor=vec4(0.,0.,0.,0.);vec2 texelOffset=vec2(0.,0.);for (int i=0; i<7; i++)
+{baseColor+=texture2D(textureSampler,start+texelOffset)*weights[i];texelOffset+=texelStep;}
+gl_FragColor=baseColor;}`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
 /** @internal */

package/Shaders/blur.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"blur.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/blur.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2Bb,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\";\n\nconst name = \"blurPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec2 screenSize;\runiform vec2 direction;\runiform float blurWidth;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rfloat weights[7];\rweights[0]=0.05;\rweights[1]=0.1;\rweights[2]=0.2;\rweights[3]=0.3;\rweights[4]=0.2;\rweights[5]=0.1;\rweights[6]=0.05;\rvec2 texelSize=vec2(1.0/screenSize.x,1.0/screenSize.y);\rvec2 texelStep=texelSize*direction*blurWidth;\rvec2 start=vUV-3.0*texelStep;\rvec4 baseColor=vec4(0.,0.,0.,0.);\rvec2 texelOffset=vec2(0.,0.);\rfor (int i=0; i<7; i++)\r{\rbaseColor+=texture2D(textureSampler,start+texelOffset)*weights[i];\rtexelOffset+=texelStep;\r}\rgl_FragColor=baseColor;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const blurPixelShader = { name, shader };\n"]}
+{"version":3,"file":"blur.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/blur.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;yBAKU,CAAC;AAC1B,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"blurPixelShader\";\nconst shader = `varying vec2 vUV;uniform sampler2D textureSampler;uniform vec2 screenSize;uniform vec2 direction;uniform float blurWidth;\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{float weights[7];weights[0]=0.05;weights[1]=0.1;weights[2]=0.2;weights[3]=0.3;weights[4]=0.2;weights[5]=0.1;weights[6]=0.05;vec2 texelSize=vec2(1.0/screenSize.x,1.0/screenSize.y);vec2 texelStep=texelSize*direction*blurWidth;vec2 start=vUV-3.0*texelStep;vec4 baseColor=vec4(0.,0.,0.,0.);vec2 texelOffset=vec2(0.,0.);for (int i=0; i<7; i++)\n{baseColor+=texture2D(textureSampler,start+texelOffset)*weights[i];texelOffset+=texelStep;}\ngl_FragColor=baseColor;}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const blurPixelShader = { name, shader };\n"]}

package/Shaders/boundingBoxRenderer.fragment.js

@@ -5,8 +5,10 @@ import "./ShadersInclude/boundingBoxRendererUboDeclaration.js";
 const name = "boundingBoxRendererPixelShader";
 const shader = `#include<__decl__boundingBoxRendererFragment>
 #define CUSTOM_FRAGMENT_DEFINITIONS
-void main(void) {
-gl_FragColor=color;
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+gl_FragColor=color;
+#define CUSTOM_FRAGMENT_MAIN_END
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;

package/Shaders/boundingBoxRenderer.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"boundingBoxRenderer.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/boundingBoxRenderer.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,yDAAyD,CAAC;AACjE,OAAO,oDAAoD,CAAC;AAE5D,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;EAMb,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/boundingBoxRendererFragmentDeclaration\";\nimport \"./ShadersInclude/boundingBoxRendererUboDeclaration\";\n\nconst name = \"boundingBoxRendererPixelShader\";\nconst shader = `#include<__decl__boundingBoxRendererFragment>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\ngl_FragColor=color;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const boundingBoxRendererPixelShader = { name, shader };\n"]}
+{"version":3,"file":"boundingBoxRenderer.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/Shaders/boundingBoxRenderer.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,yDAAyD,CAAC;AACjE,OAAO,oDAAoD,CAAC;AAE5D,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;EAMb,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/boundingBoxRendererFragmentDeclaration\";\nimport \"./ShadersInclude/boundingBoxRendererUboDeclaration\";\n\nconst name = \"boundingBoxRendererPixelShader\";\nconst shader = `#include<__decl__boundingBoxRendererFragment>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\ngl_FragColor=color;\n#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const boundingBoxRendererPixelShader = { name, shader };\n"]}