@babylonjs/core 5.23.0 → 5.25.0

package/Shaders/ShadersInclude/fresnelFunction.d.ts

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

package/Shaders/ShadersInclude/fresnelFunction.js

@@ -6,6 +6,6 @@ float computeFresnelTerm(vec3 viewDirection,vec3 worldNormal,float bias,float po
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const fresnelFunction = { name, shader };
 //# sourceMappingURL=fresnelFunction.js.map

package/Shaders/ShadersInclude/fresnelFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"fresnelFunction.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/fresnelFunction.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;CAOd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"fresnelFunction\";\nconst shader = `#ifdef FRESNEL\nfloat computeFresnelTerm(vec3 viewDirection,vec3 worldNormal,float bias,float power)\r{\rfloat fresnelTerm=pow(bias+abs(dot(viewDirection,worldNormal)),power);\rreturn clamp(fresnelTerm,0.,1.);\r}\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const fresnelFunction = { name, shader };\n"]}
+{"version":3,"file":"fresnelFunction.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/fresnelFunction.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;CAOd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"fresnelFunction\";\nconst shader = `#ifdef FRESNEL\nfloat computeFresnelTerm(vec3 viewDirection,vec3 worldNormal,float bias,float power)\r{\rfloat fresnelTerm=pow(bias+abs(dot(viewDirection,worldNormal)),power);\rreturn clamp(fresnelTerm,0.,1.);\r}\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const fresnelFunction = { name, shader };\n"]}

package/Shaders/ShadersInclude/geometryUboDeclaration.d.ts

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

package/Shaders/ShadersInclude/geometryUboDeclaration.js

@@ -6,6 +6,6 @@ const shader = `#include<sceneUboDeclaration>
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const geometryUboDeclaration = { name, shader };
 //# sourceMappingURL=geometryUboDeclaration.js.map

package/Shaders/ShadersInclude/geometryUboDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometryUboDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/geometryUboDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,uBAAuB,CAAC;AAE/B,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;CACd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nimport \"./sceneUboDeclaration\";\n\nconst name = \"geometryUboDeclaration\";\nconst shader = `#include<sceneUboDeclaration>\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const geometryUboDeclaration = { name, shader };\n"]}
+{"version":3,"file":"geometryUboDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/geometryUboDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,uBAAuB,CAAC;AAE/B,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;CACd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nimport \"./sceneUboDeclaration\";\n\nconst name = \"geometryUboDeclaration\";\nconst shader = `#include<sceneUboDeclaration>\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const geometryUboDeclaration = { name, shader };\n"]}

package/Shaders/ShadersInclude/geometryVertexDeclaration.d.ts

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

package/Shaders/ShadersInclude/geometryVertexDeclaration.js

@@ -4,6 +4,6 @@ const name = "geometryVertexDeclaration";
 const shader = `uniform mat4 viewProjection;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const geometryVertexDeclaration = { name, shader };
 //# sourceMappingURL=geometryVertexDeclaration.js.map

package/Shaders/ShadersInclude/geometryVertexDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometryVertexDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/geometryVertexDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,2BAA2B,CAAC;AACzC,MAAM,MAAM,GAAG;mBACI,CAAC;AACpB,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"geometryVertexDeclaration\";\nconst shader = `uniform mat4 viewProjection;\runiform mat4 view;`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const geometryVertexDeclaration = { name, shader };\n"]}
+{"version":3,"file":"geometryVertexDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/geometryVertexDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,2BAA2B,CAAC;AACzC,MAAM,MAAM,GAAG;mBACI,CAAC;AACpB,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"geometryVertexDeclaration\";\nconst shader = `uniform mat4 viewProjection;\runiform mat4 view;`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const geometryVertexDeclaration = { name, shader };\n"]}

package/Shaders/ShadersInclude/harmonicsFunctions.d.ts

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

package/Shaders/ShadersInclude/harmonicsFunctions.js

@@ -9,6 +9,6 @@ vec3 computeEnvironmentIrradiance(vec3 normal) {
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const harmonicsFunctions = { name, shader };
 //# sourceMappingURL=harmonicsFunctions.js.map

package/Shaders/ShadersInclude/harmonicsFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"harmonicsFunctions.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/harmonicsFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"harmonicsFunctions\";\nconst shader = `#ifdef USESPHERICALFROMREFLECTIONMAP\n#ifdef SPHERICAL_HARMONICS\nvec3 computeEnvironmentIrradiance(vec3 normal) {\rreturn vSphericalL00\r+ vSphericalL1_1*(normal.y)\r+ vSphericalL10*(normal.z)\r+ vSphericalL11*(normal.x)\r+ vSphericalL2_2*(normal.y*normal.x)\r+ vSphericalL2_1*(normal.y*normal.z)\r+ vSphericalL20*((3.0*normal.z*normal.z)-1.0)\r+ vSphericalL21*(normal.z*normal.x)\r+ vSphericalL22*(normal.x*normal.x-(normal.y*normal.y));\r}\r#else\nvec3 computeEnvironmentIrradiance(vec3 normal) {\rfloat Nx=normal.x;\rfloat Ny=normal.y;\rfloat Nz=normal.z;\rvec3 C1=vSphericalZZ.rgb;\rvec3 Cx=vSphericalX.rgb;\rvec3 Cy=vSphericalY.rgb;\rvec3 Cz=vSphericalZ.rgb;\rvec3 Cxx_zz=vSphericalXX_ZZ.rgb;\rvec3 Cyy_zz=vSphericalYY_ZZ.rgb;\rvec3 Cxy=vSphericalXY.rgb;\rvec3 Cyz=vSphericalYZ.rgb;\rvec3 Czx=vSphericalZX.rgb;\rvec3 a1=Cyy_zz*Ny+Cy;\rvec3 a2=Cyz*Nz+a1;\rvec3 b1=Czx*Nz+Cx;\rvec3 b2=Cxy*Ny+b1;\rvec3 b3=Cxx_zz*Nx+b2;\rvec3 t1=Cz *Nz+C1;\rvec3 t2=a2 *Ny+t1;\rvec3 t3=b3 *Nx+t2;\rreturn t3;\r}\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const harmonicsFunctions = { name, shader };\n"]}
+{"version":3,"file":"harmonicsFunctions.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/harmonicsFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"harmonicsFunctions\";\nconst shader = `#ifdef USESPHERICALFROMREFLECTIONMAP\n#ifdef SPHERICAL_HARMONICS\nvec3 computeEnvironmentIrradiance(vec3 normal) {\rreturn vSphericalL00\r+ vSphericalL1_1*(normal.y)\r+ vSphericalL10*(normal.z)\r+ vSphericalL11*(normal.x)\r+ vSphericalL2_2*(normal.y*normal.x)\r+ vSphericalL2_1*(normal.y*normal.z)\r+ vSphericalL20*((3.0*normal.z*normal.z)-1.0)\r+ vSphericalL21*(normal.z*normal.x)\r+ vSphericalL22*(normal.x*normal.x-(normal.y*normal.y));\r}\r#else\nvec3 computeEnvironmentIrradiance(vec3 normal) {\rfloat Nx=normal.x;\rfloat Ny=normal.y;\rfloat Nz=normal.z;\rvec3 C1=vSphericalZZ.rgb;\rvec3 Cx=vSphericalX.rgb;\rvec3 Cy=vSphericalY.rgb;\rvec3 Cz=vSphericalZ.rgb;\rvec3 Cxx_zz=vSphericalXX_ZZ.rgb;\rvec3 Cyy_zz=vSphericalYY_ZZ.rgb;\rvec3 Cxy=vSphericalXY.rgb;\rvec3 Cyz=vSphericalYZ.rgb;\rvec3 Czx=vSphericalZX.rgb;\rvec3 a1=Cyy_zz*Ny+Cy;\rvec3 a2=Cyz*Nz+a1;\rvec3 b1=Czx*Nz+Cx;\rvec3 b2=Cxy*Ny+b1;\rvec3 b3=Cxx_zz*Nx+b2;\rvec3 t1=Cz *Nz+C1;\rvec3 t2=a2 *Ny+t1;\rvec3 t3=b3 *Nx+t2;\rreturn t3;\r}\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const harmonicsFunctions = { name, shader };\n"]}

package/Shaders/ShadersInclude/hdrFilteringFunctions.d.ts

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

package/Shaders/ShadersInclude/hdrFilteringFunctions.js

@@ -25,6 +25,6 @@ result+=c*NoL;
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const hdrFilteringFunctions = { name, shader };
 //# sourceMappingURL=hdrFilteringFunctions.js.map

package/Shaders/ShadersInclude/hdrFilteringFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"hdrFilteringFunctions.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/hdrFilteringFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"hdrFilteringFunctions\";\nconst shader = `#ifdef NUM_SAMPLES\n#if NUM_SAMPLES>0\n#if defined(WEBGL2) || defined(WEBGPU)\nfloat radicalInverse_VdC(uint bits) \r{\rbits=(bits<<16u) | (bits>>16u);\rbits=((bits & 0x55555555u)<<1u) | ((bits & 0xAAAAAAAAu)>>1u);\rbits=((bits & 0x33333333u)<<2u) | ((bits & 0xCCCCCCCCu)>>2u);\rbits=((bits & 0x0F0F0F0Fu)<<4u) | ((bits & 0xF0F0F0F0u)>>4u);\rbits=((bits & 0x00FF00FFu)<<8u) | ((bits & 0xFF00FF00u)>>8u);\rreturn float(bits)*2.3283064365386963e-10; \r}\rvec2 hammersley(uint i,uint N)\r{\rreturn vec2(float(i)/float(N),radicalInverse_VdC(i));\r}\r#else\nfloat vanDerCorpus(int n,int base)\r{\rfloat invBase=1.0/float(base);\rfloat denom =1.0;\rfloat result =0.0;\rfor(int i=0; i<32; ++i)\r{\rif(n>0)\r{\rdenom =mod(float(n),2.0);\rresult+=denom*invBase;\rinvBase=invBase/2.0;\rn =int(float(n)/2.0);\r}\r}\rreturn result;\r}\rvec2 hammersley(int i,int N)\r{\rreturn vec2(float(i)/float(N),vanDerCorpus(i,2));\r}\r#endif\nfloat log4(float x) {\rreturn log2(x)/2.;\r}\rconst float NUM_SAMPLES_FLOAT=float(NUM_SAMPLES);\rconst float NUM_SAMPLES_FLOAT_INVERSED=1./NUM_SAMPLES_FLOAT;\rconst float K=4.;\r#define inline\nvec3 irradiance(samplerCube inputTexture,vec3 inputN,vec2 filteringInfo)\r{\rvec3 n=normalize(inputN);\rvec3 result=vec3(0.0);\rvec3 tangent=abs(n.z)<0.999 ? vec3(0.,0.,1.) : vec3(1.,0.,0.);\rtangent=normalize(cross(tangent,n));\rvec3 bitangent=cross(n,tangent);\rmat3 tbn=mat3(tangent,bitangent,n);\rfloat maxLevel=filteringInfo.y;\rfloat dim0=filteringInfo.x;\rfloat omegaP=(4.*PI)/(6.*dim0*dim0);\r#if defined(WEBGL2) || defined(WEBGPU)\nfor(uint i=0u; i<NUM_SAMPLES; ++i)\r#else\nfor(int i=0; i<NUM_SAMPLES; ++i)\r#endif\n{\rvec2 Xi=hammersley(i,NUM_SAMPLES);\rvec3 Ls=hemisphereCosSample(Xi);\rLs=normalize(Ls);\rvec3 Ns=vec3(0.,0.,1.);\rfloat NoL=dot(Ns,Ls);\rif (NoL>0.) {\rfloat pdf_inversed=PI/NoL;\rfloat omegaS=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;\rfloat l=log4(omegaS)-log4(omegaP)+log4(K);\rfloat mipLevel=clamp(l,0.0,maxLevel);\rvec3 c=textureCubeLodEXT(inputTexture,tbn*Ls,mipLevel).rgb;\r#ifdef GAMMA_INPUT\nc=toLinearSpace(c);\r#endif\nresult+=c;\r}\r}\rresult=result*NUM_SAMPLES_FLOAT_INVERSED;\rreturn result;\r}\r#define inline\nvec3 radiance(float alphaG,samplerCube inputTexture,vec3 inputN,vec2 filteringInfo)\r{\rvec3 n=normalize(inputN);\rif (alphaG==0.) {\rvec3 c=textureCube(inputTexture,n).rgb;\r#ifdef GAMMA_INPUT\nc=toLinearSpace(c);\r#endif\nreturn c;\r} else {\rvec3 result=vec3(0.);\rvec3 tangent=abs(n.z)<0.999 ? vec3(0.,0.,1.) : vec3(1.,0.,0.);\rtangent=normalize(cross(tangent,n));\rvec3 bitangent=cross(n,tangent);\rmat3 tbn=mat3(tangent,bitangent,n);\rfloat maxLevel=filteringInfo.y;\rfloat dim0=filteringInfo.x;\rfloat omegaP=(4.*PI)/(6.*dim0*dim0);\rfloat weight=0.;\r#if defined(WEBGL2) || defined(WEBGPU)\nfor(uint i=0u; i<NUM_SAMPLES; ++i)\r#else\nfor(int i=0; i<NUM_SAMPLES; ++i)\r#endif\n{\rvec2 Xi=hammersley(i,NUM_SAMPLES);\rvec3 H=hemisphereImportanceSampleDggx(Xi,alphaG);\rfloat NoV=1.;\rfloat NoH=H.z;\rfloat NoH2=H.z*H.z;\rfloat NoL=2.*NoH2-1.;\rvec3 L=vec3(2.*NoH*H.x,2.*NoH*H.y,NoL);\rL=normalize(L);\rif (NoL>0.) {\rfloat pdf_inversed=4./normalDistributionFunction_TrowbridgeReitzGGX(NoH,alphaG);\rfloat omegaS=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;\rfloat l=log4(omegaS)-log4(omegaP)+log4(K);\rfloat mipLevel=clamp(float(l),0.0,maxLevel);\rweight+=NoL;\rvec3 c=textureCubeLodEXT(inputTexture,tbn*L,mipLevel).rgb;\r#ifdef GAMMA_INPUT\nc=toLinearSpace(c);\r#endif\nresult+=c*NoL;\r}\r}\rresult=result/weight;\rreturn result;\r}\r}\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const hdrFilteringFunctions = { name, shader };\n"]}
+{"version":3,"file":"hdrFilteringFunctions.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/hdrFilteringFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwId,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 = \"hdrFilteringFunctions\";\nconst shader = `#ifdef NUM_SAMPLES\n#if NUM_SAMPLES>0\n#if defined(WEBGL2) || defined(WEBGPU)\nfloat radicalInverse_VdC(uint bits) \r{\rbits=(bits<<16u) | (bits>>16u);\rbits=((bits & 0x55555555u)<<1u) | ((bits & 0xAAAAAAAAu)>>1u);\rbits=((bits & 0x33333333u)<<2u) | ((bits & 0xCCCCCCCCu)>>2u);\rbits=((bits & 0x0F0F0F0Fu)<<4u) | ((bits & 0xF0F0F0F0u)>>4u);\rbits=((bits & 0x00FF00FFu)<<8u) | ((bits & 0xFF00FF00u)>>8u);\rreturn float(bits)*2.3283064365386963e-10; \r}\rvec2 hammersley(uint i,uint N)\r{\rreturn vec2(float(i)/float(N),radicalInverse_VdC(i));\r}\r#else\nfloat vanDerCorpus(int n,int base)\r{\rfloat invBase=1.0/float(base);\rfloat denom =1.0;\rfloat result =0.0;\rfor(int i=0; i<32; ++i)\r{\rif(n>0)\r{\rdenom =mod(float(n),2.0);\rresult+=denom*invBase;\rinvBase=invBase/2.0;\rn =int(float(n)/2.0);\r}\r}\rreturn result;\r}\rvec2 hammersley(int i,int N)\r{\rreturn vec2(float(i)/float(N),vanDerCorpus(i,2));\r}\r#endif\nfloat log4(float x) {\rreturn log2(x)/2.;\r}\rconst float NUM_SAMPLES_FLOAT=float(NUM_SAMPLES);\rconst float NUM_SAMPLES_FLOAT_INVERSED=1./NUM_SAMPLES_FLOAT;\rconst float K=4.;\r#define inline\nvec3 irradiance(samplerCube inputTexture,vec3 inputN,vec2 filteringInfo)\r{\rvec3 n=normalize(inputN);\rvec3 result=vec3(0.0);\rvec3 tangent=abs(n.z)<0.999 ? vec3(0.,0.,1.) : vec3(1.,0.,0.);\rtangent=normalize(cross(tangent,n));\rvec3 bitangent=cross(n,tangent);\rmat3 tbn=mat3(tangent,bitangent,n);\rfloat maxLevel=filteringInfo.y;\rfloat dim0=filteringInfo.x;\rfloat omegaP=(4.*PI)/(6.*dim0*dim0);\r#if defined(WEBGL2) || defined(WEBGPU)\nfor(uint i=0u; i<NUM_SAMPLES; ++i)\r#else\nfor(int i=0; i<NUM_SAMPLES; ++i)\r#endif\n{\rvec2 Xi=hammersley(i,NUM_SAMPLES);\rvec3 Ls=hemisphereCosSample(Xi);\rLs=normalize(Ls);\rvec3 Ns=vec3(0.,0.,1.);\rfloat NoL=dot(Ns,Ls);\rif (NoL>0.) {\rfloat pdf_inversed=PI/NoL;\rfloat omegaS=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;\rfloat l=log4(omegaS)-log4(omegaP)+log4(K);\rfloat mipLevel=clamp(l,0.0,maxLevel);\rvec3 c=textureCubeLodEXT(inputTexture,tbn*Ls,mipLevel).rgb;\r#ifdef GAMMA_INPUT\nc=toLinearSpace(c);\r#endif\nresult+=c;\r}\r}\rresult=result*NUM_SAMPLES_FLOAT_INVERSED;\rreturn result;\r}\r#define inline\nvec3 radiance(float alphaG,samplerCube inputTexture,vec3 inputN,vec2 filteringInfo)\r{\rvec3 n=normalize(inputN);\rif (alphaG==0.) {\rvec3 c=textureCube(inputTexture,n).rgb;\r#ifdef GAMMA_INPUT\nc=toLinearSpace(c);\r#endif\nreturn c;\r} else {\rvec3 result=vec3(0.);\rvec3 tangent=abs(n.z)<0.999 ? vec3(0.,0.,1.) : vec3(1.,0.,0.);\rtangent=normalize(cross(tangent,n));\rvec3 bitangent=cross(n,tangent);\rmat3 tbn=mat3(tangent,bitangent,n);\rfloat maxLevel=filteringInfo.y;\rfloat dim0=filteringInfo.x;\rfloat omegaP=(4.*PI)/(6.*dim0*dim0);\rfloat weight=0.;\r#if defined(WEBGL2) || defined(WEBGPU)\nfor(uint i=0u; i<NUM_SAMPLES; ++i)\r#else\nfor(int i=0; i<NUM_SAMPLES; ++i)\r#endif\n{\rvec2 Xi=hammersley(i,NUM_SAMPLES);\rvec3 H=hemisphereImportanceSampleDggx(Xi,alphaG);\rfloat NoV=1.;\rfloat NoH=H.z;\rfloat NoH2=H.z*H.z;\rfloat NoL=2.*NoH2-1.;\rvec3 L=vec3(2.*NoH*H.x,2.*NoH*H.y,NoL);\rL=normalize(L);\rif (NoL>0.) {\rfloat pdf_inversed=4./normalDistributionFunction_TrowbridgeReitzGGX(NoH,alphaG);\rfloat omegaS=NUM_SAMPLES_FLOAT_INVERSED*pdf_inversed;\rfloat l=log4(omegaS)-log4(omegaP)+log4(K);\rfloat mipLevel=clamp(float(l),0.0,maxLevel);\rweight+=NoL;\rvec3 c=textureCubeLodEXT(inputTexture,tbn*L,mipLevel).rgb;\r#ifdef GAMMA_INPUT\nc=toLinearSpace(c);\r#endif\nresult+=c*NoL;\r}\r}\rresult=result/weight;\rreturn result;\r}\r}\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const hdrFilteringFunctions = { name, shader };\n"]}

package/Shaders/ShadersInclude/helperFunctions.d.ts

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

package/Shaders/ShadersInclude/helperFunctions.js

@@ -34,6 +34,6 @@ return vec4(pow(color.rgb,vec3(GammaEncodePowerApprox)),color.a);
 }
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const helperFunctions = { name, shader };
 //# sourceMappingURL=helperFunctions.js.map

package/Shaders/ShadersInclude/helperFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"helperFunctions.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/helperFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmKd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"helperFunctions\";\nconst shader = `const float PI=3.1415926535897932384626433832795;\rconst float HALF_MIN=5.96046448e-08; \rconst float LinearEncodePowerApprox=2.2;\rconst float GammaEncodePowerApprox=1.0/LinearEncodePowerApprox;\rconst vec3 LuminanceEncodeApprox=vec3(0.2126,0.7152,0.0722);\rconst float Epsilon=0.0000001;\r#define saturate(x) clamp(x,0.0,1.0)\n#define absEps(x) abs(x)+Epsilon\n#define maxEps(x) max(x,Epsilon)\n#define saturateEps(x) clamp(x,Epsilon,1.0)\nmat3 transposeMat3(mat3 inMatrix) {\rvec3 i0=inMatrix[0];\rvec3 i1=inMatrix[1];\rvec3 i2=inMatrix[2];\rmat3 outMatrix=mat3(\rvec3(i0.x,i1.x,i2.x),\rvec3(i0.y,i1.y,i2.y),\rvec3(i0.z,i1.z,i2.z)\r);\rreturn outMatrix;\r}\rmat3 inverseMat3(mat3 inMatrix) {\rfloat a00=inMatrix[0][0],a01=inMatrix[0][1],a02=inMatrix[0][2];\rfloat a10=inMatrix[1][0],a11=inMatrix[1][1],a12=inMatrix[1][2];\rfloat a20=inMatrix[2][0],a21=inMatrix[2][1],a22=inMatrix[2][2];\rfloat b01=a22*a11-a12*a21;\rfloat b11=-a22*a10+a12*a20;\rfloat b21=a21*a10-a11*a20;\rfloat det=a00*b01+a01*b11+a02*b21;\rreturn mat3(b01,(-a22*a01+a02*a21),(a12*a01-a02*a11),\rb11,(a22*a00-a02*a20),(-a12*a00+a02*a10),\rb21,(-a21*a00+a01*a20),(a11*a00-a01*a10))/det;\r}\r#if USE_EXACT_SRGB_CONVERSIONS\nvec3 toLinearSpaceExact(vec3 color)\r{\rvec3 nearZeroSection=0.0773993808*color;\rvec3 remainingSection=pow(0.947867299*(color+vec3(0.055)),vec3(2.4));\r#if defined(WEBGL2) || defined(WEBGPU)\nreturn mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.04045)));\r#else\nreturn\rvec3(\rcolor.r<=0.04045 ? nearZeroSection.r : remainingSection.r,\rcolor.g<=0.04045 ? nearZeroSection.g : remainingSection.g,\rcolor.b<=0.04045 ? nearZeroSection.b : remainingSection.b);\r#endif\n}\rvec3 toGammaSpaceExact(vec3 color)\r{\rvec3 nearZeroSection=12.92*color;\rvec3 remainingSection=1.055*pow(color,vec3(0.41666))-vec3(0.055);\r#if defined(WEBGL2) || defined(WEBGPU)\nreturn mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.0031308)));\r#else\nreturn\rvec3(\rcolor.r<=0.0031308 ? nearZeroSection.r : remainingSection.r,\rcolor.g<=0.0031308 ? nearZeroSection.g : remainingSection.g,\rcolor.b<=0.0031308 ? nearZeroSection.b : remainingSection.b);\r#endif\n}\r#endif\nfloat toLinearSpace(float color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nfloat nearZeroSection=0.0773993808*color;\rfloat remainingSection=pow(0.947867299*(color+0.055),2.4);\rreturn color<=0.04045 ? nearZeroSection : remainingSection;\r#else\nreturn pow(color,LinearEncodePowerApprox);\r#endif\n}\rvec3 toLinearSpace(vec3 color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nreturn toLinearSpaceExact(color);\r#else\nreturn pow(color,vec3(LinearEncodePowerApprox));\r#endif\n}\rvec4 toLinearSpace(vec4 color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nreturn vec4(toLinearSpaceExact(color.rgb),color.a);\r#else\nreturn vec4(pow(color.rgb,vec3(LinearEncodePowerApprox)),color.a);\r#endif\n}\rfloat toGammaSpace(float color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nfloat nearZeroSection=12.92*color;\rfloat remainingSection=1.055*pow(color,0.41666)-0.055;\rreturn color<=0.0031308 ? nearZeroSection : remainingSection;\r#else\nreturn pow(color,GammaEncodePowerApprox);\r#endif\n}\rvec3 toGammaSpace(vec3 color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nreturn toGammaSpaceExact(color);\r#else\nreturn pow(color,vec3(GammaEncodePowerApprox));\r#endif\n}\rvec4 toGammaSpace(vec4 color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nreturn vec4(toGammaSpaceExact(color.rgb),color.a);\r#else\nreturn vec4(pow(color.rgb,vec3(GammaEncodePowerApprox)),color.a);\r#endif\n}\rfloat square(float value)\r{\rreturn value*value;\r}\rvec3 square(vec3 value)\r{\rreturn value*value;\r}\rfloat pow5(float value) {\rfloat sq=value*value;\rreturn sq*sq*value;\r}\rfloat getLuminance(vec3 color)\r{\rreturn clamp(dot(color,LuminanceEncodeApprox),0.,1.);\r}\rfloat getRand(vec2 seed) {\rreturn fract(sin(dot(seed.xy ,vec2(12.9898,78.233)))*43758.5453);\r}\rfloat dither(vec2 seed,float varianceAmount) {\rfloat rand=getRand(seed);\rfloat normVariance=varianceAmount/255.0;\rfloat dither=mix(-normVariance,normVariance,rand);\rreturn dither;\r}\rconst float rgbdMaxRange=255.0;\rvec4 toRGBD(vec3 color) {\rfloat maxRGB=maxEps(max(color.r,max(color.g,color.b)));\rfloat D =max(rgbdMaxRange/maxRGB,1.);\rD =clamp(floor(D)/255.0,0.,1.);\rvec3 rgb=color.rgb*D;\rrgb=toGammaSpace(rgb);\rreturn vec4(clamp(rgb,0.,1.),D); \r}\rvec3 fromRGBD(vec4 rgbd) {\rrgbd.rgb=toLinearSpace(rgbd.rgb);\rreturn rgbd.rgb/rgbd.a;\r}\rvec3 parallaxCorrectNormal( vec3 vertexPos,vec3 origVec,vec3 cubeSize,vec3 cubePos ) {\rvec3 invOrigVec=vec3(1.0,1.0,1.0)/origVec;\rvec3 halfSize=cubeSize*0.5;\rvec3 intersecAtMaxPlane=(cubePos+halfSize-vertexPos)*invOrigVec;\rvec3 intersecAtMinPlane=(cubePos-halfSize-vertexPos)*invOrigVec;\rvec3 largestIntersec=max(intersecAtMaxPlane,intersecAtMinPlane);\rfloat distance=min(min(largestIntersec.x,largestIntersec.y),largestIntersec.z);\rvec3 intersectPositionWS=vertexPos+origVec*distance;\rreturn intersectPositionWS-cubePos;\r}\r`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const helperFunctions = { name, shader };\n"]}
+{"version":3,"file":"helperFunctions.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/helperFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmKd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"helperFunctions\";\nconst shader = `const float PI=3.1415926535897932384626433832795;\rconst float HALF_MIN=5.96046448e-08; \rconst float LinearEncodePowerApprox=2.2;\rconst float GammaEncodePowerApprox=1.0/LinearEncodePowerApprox;\rconst vec3 LuminanceEncodeApprox=vec3(0.2126,0.7152,0.0722);\rconst float Epsilon=0.0000001;\r#define saturate(x) clamp(x,0.0,1.0)\n#define absEps(x) abs(x)+Epsilon\n#define maxEps(x) max(x,Epsilon)\n#define saturateEps(x) clamp(x,Epsilon,1.0)\nmat3 transposeMat3(mat3 inMatrix) {\rvec3 i0=inMatrix[0];\rvec3 i1=inMatrix[1];\rvec3 i2=inMatrix[2];\rmat3 outMatrix=mat3(\rvec3(i0.x,i1.x,i2.x),\rvec3(i0.y,i1.y,i2.y),\rvec3(i0.z,i1.z,i2.z)\r);\rreturn outMatrix;\r}\rmat3 inverseMat3(mat3 inMatrix) {\rfloat a00=inMatrix[0][0],a01=inMatrix[0][1],a02=inMatrix[0][2];\rfloat a10=inMatrix[1][0],a11=inMatrix[1][1],a12=inMatrix[1][2];\rfloat a20=inMatrix[2][0],a21=inMatrix[2][1],a22=inMatrix[2][2];\rfloat b01=a22*a11-a12*a21;\rfloat b11=-a22*a10+a12*a20;\rfloat b21=a21*a10-a11*a20;\rfloat det=a00*b01+a01*b11+a02*b21;\rreturn mat3(b01,(-a22*a01+a02*a21),(a12*a01-a02*a11),\rb11,(a22*a00-a02*a20),(-a12*a00+a02*a10),\rb21,(-a21*a00+a01*a20),(a11*a00-a01*a10))/det;\r}\r#if USE_EXACT_SRGB_CONVERSIONS\nvec3 toLinearSpaceExact(vec3 color)\r{\rvec3 nearZeroSection=0.0773993808*color;\rvec3 remainingSection=pow(0.947867299*(color+vec3(0.055)),vec3(2.4));\r#if defined(WEBGL2) || defined(WEBGPU)\nreturn mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.04045)));\r#else\nreturn\rvec3(\rcolor.r<=0.04045 ? nearZeroSection.r : remainingSection.r,\rcolor.g<=0.04045 ? nearZeroSection.g : remainingSection.g,\rcolor.b<=0.04045 ? nearZeroSection.b : remainingSection.b);\r#endif\n}\rvec3 toGammaSpaceExact(vec3 color)\r{\rvec3 nearZeroSection=12.92*color;\rvec3 remainingSection=1.055*pow(color,vec3(0.41666))-vec3(0.055);\r#if defined(WEBGL2) || defined(WEBGPU)\nreturn mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.0031308)));\r#else\nreturn\rvec3(\rcolor.r<=0.0031308 ? nearZeroSection.r : remainingSection.r,\rcolor.g<=0.0031308 ? nearZeroSection.g : remainingSection.g,\rcolor.b<=0.0031308 ? nearZeroSection.b : remainingSection.b);\r#endif\n}\r#endif\nfloat toLinearSpace(float color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nfloat nearZeroSection=0.0773993808*color;\rfloat remainingSection=pow(0.947867299*(color+0.055),2.4);\rreturn color<=0.04045 ? nearZeroSection : remainingSection;\r#else\nreturn pow(color,LinearEncodePowerApprox);\r#endif\n}\rvec3 toLinearSpace(vec3 color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nreturn toLinearSpaceExact(color);\r#else\nreturn pow(color,vec3(LinearEncodePowerApprox));\r#endif\n}\rvec4 toLinearSpace(vec4 color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nreturn vec4(toLinearSpaceExact(color.rgb),color.a);\r#else\nreturn vec4(pow(color.rgb,vec3(LinearEncodePowerApprox)),color.a);\r#endif\n}\rfloat toGammaSpace(float color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nfloat nearZeroSection=12.92*color;\rfloat remainingSection=1.055*pow(color,0.41666)-0.055;\rreturn color<=0.0031308 ? nearZeroSection : remainingSection;\r#else\nreturn pow(color,GammaEncodePowerApprox);\r#endif\n}\rvec3 toGammaSpace(vec3 color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nreturn toGammaSpaceExact(color);\r#else\nreturn pow(color,vec3(GammaEncodePowerApprox));\r#endif\n}\rvec4 toGammaSpace(vec4 color)\r{\r#if USE_EXACT_SRGB_CONVERSIONS\nreturn vec4(toGammaSpaceExact(color.rgb),color.a);\r#else\nreturn vec4(pow(color.rgb,vec3(GammaEncodePowerApprox)),color.a);\r#endif\n}\rfloat square(float value)\r{\rreturn value*value;\r}\rvec3 square(vec3 value)\r{\rreturn value*value;\r}\rfloat pow5(float value) {\rfloat sq=value*value;\rreturn sq*sq*value;\r}\rfloat getLuminance(vec3 color)\r{\rreturn clamp(dot(color,LuminanceEncodeApprox),0.,1.);\r}\rfloat getRand(vec2 seed) {\rreturn fract(sin(dot(seed.xy ,vec2(12.9898,78.233)))*43758.5453);\r}\rfloat dither(vec2 seed,float varianceAmount) {\rfloat rand=getRand(seed);\rfloat normVariance=varianceAmount/255.0;\rfloat dither=mix(-normVariance,normVariance,rand);\rreturn dither;\r}\rconst float rgbdMaxRange=255.0;\rvec4 toRGBD(vec3 color) {\rfloat maxRGB=maxEps(max(color.r,max(color.g,color.b)));\rfloat D =max(rgbdMaxRange/maxRGB,1.);\rD =clamp(floor(D)/255.0,0.,1.);\rvec3 rgb=color.rgb*D;\rrgb=toGammaSpace(rgb);\rreturn vec4(clamp(rgb,0.,1.),D); \r}\rvec3 fromRGBD(vec4 rgbd) {\rrgbd.rgb=toLinearSpace(rgbd.rgb);\rreturn rgbd.rgb/rgbd.a;\r}\rvec3 parallaxCorrectNormal( vec3 vertexPos,vec3 origVec,vec3 cubeSize,vec3 cubePos ) {\rvec3 invOrigVec=vec3(1.0,1.0,1.0)/origVec;\rvec3 halfSize=cubeSize*0.5;\rvec3 intersecAtMaxPlane=(cubePos+halfSize-vertexPos)*invOrigVec;\rvec3 intersecAtMinPlane=(cubePos-halfSize-vertexPos)*invOrigVec;\rvec3 largestIntersec=max(intersecAtMaxPlane,intersecAtMinPlane);\rfloat distance=min(min(largestIntersec.x,largestIntersec.y),largestIntersec.z);\rvec3 intersectPositionWS=vertexPos+origVec*distance;\rreturn intersectPositionWS-cubePos;\r}\r`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const helperFunctions = { name, shader };\n"]}

package/Shaders/ShadersInclude/imageProcessingCompatibility.d.ts

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

package/Shaders/ShadersInclude/imageProcessingCompatibility.js

@@ -6,6 +6,6 @@ gl_FragColor.rgb=pow(gl_FragColor.rgb,vec3(2.2));
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const imageProcessingCompatibility = { name, shader };
 //# sourceMappingURL=imageProcessingCompatibility.js.map

package/Shaders/ShadersInclude/imageProcessingCompatibility.js.map

@@ -1 +1 @@
-{"version":3,"file":"imageProcessingCompatibility.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/imageProcessingCompatibility.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,8BAA8B,CAAC;AAC5C,MAAM,MAAM,GAAG;;;CAGd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"imageProcessingCompatibility\";\nconst shader = `#ifdef IMAGEPROCESSINGPOSTPROCESS\ngl_FragColor.rgb=pow(gl_FragColor.rgb,vec3(2.2));\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const imageProcessingCompatibility = { name, shader };\n"]}
+{"version":3,"file":"imageProcessingCompatibility.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/imageProcessingCompatibility.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,8BAA8B,CAAC;AAC5C,MAAM,MAAM,GAAG;;;CAGd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"imageProcessingCompatibility\";\nconst shader = `#ifdef IMAGEPROCESSINGPOSTPROCESS\ngl_FragColor.rgb=pow(gl_FragColor.rgb,vec3(2.2));\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const imageProcessingCompatibility = { name, shader };\n"]}

package/Shaders/ShadersInclude/imageProcessingDeclaration.d.ts

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

package/Shaders/ShadersInclude/imageProcessingDeclaration.js

@@ -21,6 +21,6 @@ uniform float ditherIntensity;
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const imageProcessingDeclaration = { name, shader };
 //# sourceMappingURL=imageProcessingDeclaration.js.map

package/Shaders/ShadersInclude/imageProcessingDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"imageProcessingDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/imageProcessingDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAC1C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Bd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"imageProcessingDeclaration\";\nconst shader = `#ifdef EXPOSURE\nuniform float exposureLinear;\r#endif\n#ifdef CONTRAST\nuniform float contrast;\r#endif\n#if defined(VIGNETTE) || defined(DITHER)\nuniform vec2 vInverseScreenSize;\r#endif\n#ifdef VIGNETTE\nuniform vec4 vignetteSettings1;\runiform vec4 vignetteSettings2;\r#endif\n#ifdef COLORCURVES\nuniform vec4 vCameraColorCurveNegative;\runiform vec4 vCameraColorCurveNeutral;\runiform vec4 vCameraColorCurvePositive;\r#endif\n#ifdef COLORGRADING\n#ifdef COLORGRADING3D\nuniform highp sampler3D txColorTransform;\r#else\nuniform sampler2D txColorTransform;\r#endif\nuniform vec4 colorTransformSettings;\r#endif\n#ifdef DITHER\nuniform float ditherIntensity;\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const imageProcessingDeclaration = { name, shader };\n"]}
+{"version":3,"file":"imageProcessingDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/imageProcessingDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAC1C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Bd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"imageProcessingDeclaration\";\nconst shader = `#ifdef EXPOSURE\nuniform float exposureLinear;\r#endif\n#ifdef CONTRAST\nuniform float contrast;\r#endif\n#if defined(VIGNETTE) || defined(DITHER)\nuniform vec2 vInverseScreenSize;\r#endif\n#ifdef VIGNETTE\nuniform vec4 vignetteSettings1;\runiform vec4 vignetteSettings2;\r#endif\n#ifdef COLORCURVES\nuniform vec4 vCameraColorCurveNegative;\runiform vec4 vCameraColorCurveNeutral;\runiform vec4 vCameraColorCurvePositive;\r#endif\n#ifdef COLORGRADING\n#ifdef COLORGRADING3D\nuniform highp sampler3D txColorTransform;\r#else\nuniform sampler2D txColorTransform;\r#endif\nuniform vec4 colorTransformSettings;\r#endif\n#ifdef DITHER\nuniform float ditherIntensity;\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const imageProcessingDeclaration = { name, shader };\n"]}

package/Shaders/ShadersInclude/imageProcessingFunctions.d.ts

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

package/Shaders/ShadersInclude/imageProcessingFunctions.js

@@ -42,6 +42,6 @@ float rand=getRand(gl_FragCoord.xy*vInverseScreenSize);
 return result;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const imageProcessingFunctions = { name, shader };
 //# sourceMappingURL=imageProcessingFunctions.js.map

package/Shaders/ShadersInclude/imageProcessingFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"imageProcessingFunctions.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/imageProcessingFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2Hb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"imageProcessingFunctions\";\nconst shader = `#if defined(COLORGRADING) && !defined(COLORGRADING3D)\n/** \r* Polyfill for SAMPLE_TEXTURE_3D,which is unsupported in WebGL.\r* sampler3dSetting.x=textureOffset (0.5/textureSize).\r* sampler3dSetting.y=textureSize.\r*/\r#define inline\nvec3 sampleTexture3D(sampler2D colorTransform,vec3 color,vec2 sampler3dSetting)\r{\rfloat sliceSize=2.0*sampler3dSetting.x; \r#ifdef SAMPLER3DGREENDEPTH\nfloat sliceContinuous=(color.g-sampler3dSetting.x)*sampler3dSetting.y;\r#else\nfloat sliceContinuous=(color.b-sampler3dSetting.x)*sampler3dSetting.y;\r#endif\nfloat sliceInteger=floor(sliceContinuous);\rfloat sliceFraction=sliceContinuous-sliceInteger;\r#ifdef SAMPLER3DGREENDEPTH\nvec2 sliceUV=color.rb;\r#else\nvec2 sliceUV=color.rg;\r#endif\nsliceUV.x*=sliceSize;\rsliceUV.x+=sliceInteger*sliceSize;\rsliceUV=saturate(sliceUV);\rvec4 slice0Color=texture2D(colorTransform,sliceUV);\rsliceUV.x+=sliceSize;\rsliceUV=saturate(sliceUV);\rvec4 slice1Color=texture2D(colorTransform,sliceUV);\rvec3 result=mix(slice0Color.rgb,slice1Color.rgb,sliceFraction);\r#ifdef SAMPLER3DBGRMAP\ncolor.rgb=result.rgb;\r#else\ncolor.rgb=result.bgr;\r#endif\nreturn color;\r}\r#endif\n#ifdef TONEMAPPING_ACES\nconst mat3 ACESInputMat=mat3(\rvec3(0.59719,0.07600,0.02840),\rvec3(0.35458,0.90834,0.13383),\rvec3(0.04823,0.01566,0.83777)\r);\rconst mat3 ACESOutputMat=mat3(\rvec3( 1.60475,-0.10208,-0.00327),\rvec3(-0.53108, 1.10813,-0.07276),\rvec3(-0.07367,-0.00605, 1.07602)\r);\rvec3 RRTAndODTFit(vec3 v)\r{\rvec3 a=v*(v+0.0245786)-0.000090537;\rvec3 b=v*(0.983729*v+0.4329510)+0.238081;\rreturn a/b;\r}\rvec3 ACESFitted(vec3 color)\r{\rcolor=ACESInputMat*color;\rcolor=RRTAndODTFit(color);\rcolor=ACESOutputMat*color;\rcolor=saturate(color);\rreturn color;\r}\r#endif\nvec4 applyImageProcessing(vec4 result) {\r#ifdef EXPOSURE\nresult.rgb*=exposureLinear;\r#endif\n#ifdef VIGNETTE\nvec2 viewportXY=gl_FragCoord.xy*vInverseScreenSize;\rviewportXY=viewportXY*2.0-1.0;\rvec3 vignetteXY1=vec3(viewportXY*vignetteSettings1.xy+vignetteSettings1.zw,1.0);\rfloat vignetteTerm=dot(vignetteXY1,vignetteXY1);\rfloat vignette=pow(vignetteTerm,vignetteSettings2.w);\rvec3 vignetteColor=vignetteSettings2.rgb;\r#ifdef VIGNETTEBLENDMODEMULTIPLY\nvec3 vignetteColorMultiplier=mix(vignetteColor,vec3(1,1,1),vignette);\rresult.rgb*=vignetteColorMultiplier;\r#endif\n#ifdef VIGNETTEBLENDMODEOPAQUE\nresult.rgb=mix(vignetteColor,result.rgb,vignette);\r#endif\n#endif\n#ifdef TONEMAPPING\n#ifdef TONEMAPPING_ACES\nresult.rgb=ACESFitted(result.rgb);\r#else\nconst float tonemappingCalibration=1.590579;\rresult.rgb=1.0-exp2(-tonemappingCalibration*result.rgb);\r#endif\n#endif\nresult.rgb=toGammaSpace(result.rgb);\rresult.rgb=saturate(result.rgb);\r#ifdef CONTRAST\nvec3 resultHighContrast=result.rgb*result.rgb*(3.0-2.0*result.rgb);\rif (contrast<1.0) {\rresult.rgb=mix(vec3(0.5,0.5,0.5),result.rgb,contrast);\r} else {\rresult.rgb=mix(result.rgb,resultHighContrast,contrast-1.0);\r}\r#endif\n#ifdef COLORGRADING\nvec3 colorTransformInput=result.rgb*colorTransformSettings.xxx+colorTransformSettings.yyy;\r#ifdef COLORGRADING3D\nvec3 colorTransformOutput=texture(txColorTransform,colorTransformInput).rgb;\r#else\nvec3 colorTransformOutput=sampleTexture3D(txColorTransform,colorTransformInput,colorTransformSettings.yz).rgb;\r#endif\nresult.rgb=mix(result.rgb,colorTransformOutput,colorTransformSettings.www);\r#endif\n#ifdef COLORCURVES\nfloat luma=getLuminance(result.rgb);\rvec2 curveMix=clamp(vec2(luma*3.0-1.5,luma*-3.0+1.5),vec2(0.0),vec2(1.0));\rvec4 colorCurve=vCameraColorCurveNeutral+curveMix.x*vCameraColorCurvePositive-curveMix.y*vCameraColorCurveNegative;\rresult.rgb*=colorCurve.rgb;\rresult.rgb=mix(vec3(luma),result.rgb,colorCurve.a);\r#endif\n#ifdef DITHER\nfloat rand=getRand(gl_FragCoord.xy*vInverseScreenSize);\rfloat dither=mix(-ditherIntensity,ditherIntensity,rand);\rresult.rgb=saturate(result.rgb+vec3(dither));\r#endif\nreturn result;\r}`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const imageProcessingFunctions = { name, shader };\n"]}
+{"version":3,"file":"imageProcessingFunctions.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/imageProcessingFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2Hb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"imageProcessingFunctions\";\nconst shader = `#if defined(COLORGRADING) && !defined(COLORGRADING3D)\n/** \r* Polyfill for SAMPLE_TEXTURE_3D,which is unsupported in WebGL.\r* sampler3dSetting.x=textureOffset (0.5/textureSize).\r* sampler3dSetting.y=textureSize.\r*/\r#define inline\nvec3 sampleTexture3D(sampler2D colorTransform,vec3 color,vec2 sampler3dSetting)\r{\rfloat sliceSize=2.0*sampler3dSetting.x; \r#ifdef SAMPLER3DGREENDEPTH\nfloat sliceContinuous=(color.g-sampler3dSetting.x)*sampler3dSetting.y;\r#else\nfloat sliceContinuous=(color.b-sampler3dSetting.x)*sampler3dSetting.y;\r#endif\nfloat sliceInteger=floor(sliceContinuous);\rfloat sliceFraction=sliceContinuous-sliceInteger;\r#ifdef SAMPLER3DGREENDEPTH\nvec2 sliceUV=color.rb;\r#else\nvec2 sliceUV=color.rg;\r#endif\nsliceUV.x*=sliceSize;\rsliceUV.x+=sliceInteger*sliceSize;\rsliceUV=saturate(sliceUV);\rvec4 slice0Color=texture2D(colorTransform,sliceUV);\rsliceUV.x+=sliceSize;\rsliceUV=saturate(sliceUV);\rvec4 slice1Color=texture2D(colorTransform,sliceUV);\rvec3 result=mix(slice0Color.rgb,slice1Color.rgb,sliceFraction);\r#ifdef SAMPLER3DBGRMAP\ncolor.rgb=result.rgb;\r#else\ncolor.rgb=result.bgr;\r#endif\nreturn color;\r}\r#endif\n#ifdef TONEMAPPING_ACES\nconst mat3 ACESInputMat=mat3(\rvec3(0.59719,0.07600,0.02840),\rvec3(0.35458,0.90834,0.13383),\rvec3(0.04823,0.01566,0.83777)\r);\rconst mat3 ACESOutputMat=mat3(\rvec3( 1.60475,-0.10208,-0.00327),\rvec3(-0.53108, 1.10813,-0.07276),\rvec3(-0.07367,-0.00605, 1.07602)\r);\rvec3 RRTAndODTFit(vec3 v)\r{\rvec3 a=v*(v+0.0245786)-0.000090537;\rvec3 b=v*(0.983729*v+0.4329510)+0.238081;\rreturn a/b;\r}\rvec3 ACESFitted(vec3 color)\r{\rcolor=ACESInputMat*color;\rcolor=RRTAndODTFit(color);\rcolor=ACESOutputMat*color;\rcolor=saturate(color);\rreturn color;\r}\r#endif\nvec4 applyImageProcessing(vec4 result) {\r#ifdef EXPOSURE\nresult.rgb*=exposureLinear;\r#endif\n#ifdef VIGNETTE\nvec2 viewportXY=gl_FragCoord.xy*vInverseScreenSize;\rviewportXY=viewportXY*2.0-1.0;\rvec3 vignetteXY1=vec3(viewportXY*vignetteSettings1.xy+vignetteSettings1.zw,1.0);\rfloat vignetteTerm=dot(vignetteXY1,vignetteXY1);\rfloat vignette=pow(vignetteTerm,vignetteSettings2.w);\rvec3 vignetteColor=vignetteSettings2.rgb;\r#ifdef VIGNETTEBLENDMODEMULTIPLY\nvec3 vignetteColorMultiplier=mix(vignetteColor,vec3(1,1,1),vignette);\rresult.rgb*=vignetteColorMultiplier;\r#endif\n#ifdef VIGNETTEBLENDMODEOPAQUE\nresult.rgb=mix(vignetteColor,result.rgb,vignette);\r#endif\n#endif\n#ifdef TONEMAPPING\n#ifdef TONEMAPPING_ACES\nresult.rgb=ACESFitted(result.rgb);\r#else\nconst float tonemappingCalibration=1.590579;\rresult.rgb=1.0-exp2(-tonemappingCalibration*result.rgb);\r#endif\n#endif\nresult.rgb=toGammaSpace(result.rgb);\rresult.rgb=saturate(result.rgb);\r#ifdef CONTRAST\nvec3 resultHighContrast=result.rgb*result.rgb*(3.0-2.0*result.rgb);\rif (contrast<1.0) {\rresult.rgb=mix(vec3(0.5,0.5,0.5),result.rgb,contrast);\r} else {\rresult.rgb=mix(result.rgb,resultHighContrast,contrast-1.0);\r}\r#endif\n#ifdef COLORGRADING\nvec3 colorTransformInput=result.rgb*colorTransformSettings.xxx+colorTransformSettings.yyy;\r#ifdef COLORGRADING3D\nvec3 colorTransformOutput=texture(txColorTransform,colorTransformInput).rgb;\r#else\nvec3 colorTransformOutput=sampleTexture3D(txColorTransform,colorTransformInput,colorTransformSettings.yz).rgb;\r#endif\nresult.rgb=mix(result.rgb,colorTransformOutput,colorTransformSettings.www);\r#endif\n#ifdef COLORCURVES\nfloat luma=getLuminance(result.rgb);\rvec2 curveMix=clamp(vec2(luma*3.0-1.5,luma*-3.0+1.5),vec2(0.0),vec2(1.0));\rvec4 colorCurve=vCameraColorCurveNeutral+curveMix.x*vCameraColorCurvePositive-curveMix.y*vCameraColorCurveNegative;\rresult.rgb*=colorCurve.rgb;\rresult.rgb=mix(vec3(luma),result.rgb,colorCurve.a);\r#endif\n#ifdef DITHER\nfloat rand=getRand(gl_FragCoord.xy*vInverseScreenSize);\rfloat dither=mix(-ditherIntensity,ditherIntensity,rand);\rresult.rgb=saturate(result.rgb+vec3(dither));\r#endif\nreturn result;\r}`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const imageProcessingFunctions = { name, shader };\n"]}

package/Shaders/ShadersInclude/importanceSampling.d.ts

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

package/Shaders/ShadersInclude/importanceSampling.js

@@ -4,6 +4,6 @@ const name = "importanceSampling";
 const shader = `vec3 hemisphereCosSample(vec2 u) {
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const importanceSampling = { name, shader };
 //# sourceMappingURL=importanceSampling.js.map

package/Shaders/ShadersInclude/importanceSampling.js.map

@@ -1 +1 @@
-{"version":3,"file":"importanceSampling.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/importanceSampling.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;EAmBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"importanceSampling\";\nconst shader = `vec3 hemisphereCosSample(vec2 u) {\rfloat phi=2.*PI*u.x;\rfloat cosTheta2=1.-u.y;\rfloat cosTheta=sqrt(cosTheta2);\rfloat sinTheta=sqrt(1.-cosTheta2);\rreturn vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);\r}\rvec3 hemisphereImportanceSampleDggx(vec2 u,float a) {\rfloat phi=2.*PI*u.x;\rfloat cosTheta2=(1.-u.y)/(1.+(a+1.)*((a-1.)*u.y));\rfloat cosTheta=sqrt(cosTheta2);\rfloat sinTheta=sqrt(1.-cosTheta2);\rreturn vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);\r}\rvec3 hemisphereImportanceSampleDCharlie(vec2 u,float a) { \rfloat phi=2.*PI*u.x;\rfloat sinTheta=pow(u.y,a/(2.*a+1.));\rfloat cosTheta=sqrt(1.-sinTheta*sinTheta);\rreturn vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);\r}`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const importanceSampling = { name, shader };\n"]}
+{"version":3,"file":"importanceSampling.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/importanceSampling.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;EAmBb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"importanceSampling\";\nconst shader = `vec3 hemisphereCosSample(vec2 u) {\rfloat phi=2.*PI*u.x;\rfloat cosTheta2=1.-u.y;\rfloat cosTheta=sqrt(cosTheta2);\rfloat sinTheta=sqrt(1.-cosTheta2);\rreturn vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);\r}\rvec3 hemisphereImportanceSampleDggx(vec2 u,float a) {\rfloat phi=2.*PI*u.x;\rfloat cosTheta2=(1.-u.y)/(1.+(a+1.)*((a-1.)*u.y));\rfloat cosTheta=sqrt(cosTheta2);\rfloat sinTheta=sqrt(1.-cosTheta2);\rreturn vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);\r}\rvec3 hemisphereImportanceSampleDCharlie(vec2 u,float a) { \rfloat phi=2.*PI*u.x;\rfloat sinTheta=pow(u.y,a/(2.*a+1.));\rfloat cosTheta=sqrt(1.-sinTheta*sinTheta);\rreturn vec3(sinTheta*cos(phi),sinTheta*sin(phi),cosTheta);\r}`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const importanceSampling = { name, shader };\n"]}

package/Shaders/ShadersInclude/instancesDeclaration.d.ts

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

package/Shaders/ShadersInclude/instancesDeclaration.js

@@ -19,6 +19,6 @@ uniform mat4 previousWorld;
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const instancesDeclaration = { name, shader };
 //# sourceMappingURL=instancesDeclaration.js.map

package/Shaders/ShadersInclude/instancesDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"instancesDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/instancesDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Bd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"instancesDeclaration\";\nconst shader = `#ifdef INSTANCES\nattribute vec4 world0;\rattribute vec4 world1;\rattribute vec4 world2;\rattribute vec4 world3;\r#ifdef INSTANCESCOLOR\nattribute vec4 instanceColor;\r#endif\n#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)\nuniform mat4 world;\r#endif\n#if defined(VELOCITY) || defined(PREPASS_VELOCITY)\nattribute vec4 previousWorld0;\rattribute vec4 previousWorld1;\rattribute vec4 previousWorld2;\rattribute vec4 previousWorld3;\r#ifdef THIN_INSTANCES\nuniform mat4 previousWorld;\r#endif\n#endif\n#else\n#if !defined(WORLD_UBO)\nuniform mat4 world;\r#endif\n#if defined(VELOCITY) || defined(PREPASS_VELOCITY)\nuniform mat4 previousWorld;\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const instancesDeclaration = { name, shader };\n"]}
+{"version":3,"file":"instancesDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/instancesDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Bd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"instancesDeclaration\";\nconst shader = `#ifdef INSTANCES\nattribute vec4 world0;\rattribute vec4 world1;\rattribute vec4 world2;\rattribute vec4 world3;\r#ifdef INSTANCESCOLOR\nattribute vec4 instanceColor;\r#endif\n#if defined(THIN_INSTANCES) && !defined(WORLD_UBO)\nuniform mat4 world;\r#endif\n#if defined(VELOCITY) || defined(PREPASS_VELOCITY)\nattribute vec4 previousWorld0;\rattribute vec4 previousWorld1;\rattribute vec4 previousWorld2;\rattribute vec4 previousWorld3;\r#ifdef THIN_INSTANCES\nuniform mat4 previousWorld;\r#endif\n#endif\n#else\n#if !defined(WORLD_UBO)\nuniform mat4 world;\r#endif\n#if defined(VELOCITY) || defined(PREPASS_VELOCITY)\nuniform mat4 previousWorld;\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const instancesDeclaration = { name, shader };\n"]}

package/Shaders/ShadersInclude/instancesVertex.d.ts

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

package/Shaders/ShadersInclude/instancesVertex.js

@@ -15,6 +15,6 @@ mat4 finalPreviousWorld=previousWorld;
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const instancesVertex = { name, shader };
 //# sourceMappingURL=instancesVertex.js.map

package/Shaders/ShadersInclude/instancesVertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"instancesVertex.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/instancesVertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;CAiBd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"instancesVertex\";\nconst shader = `#ifdef INSTANCES\nmat4 finalWorld=mat4(world0,world1,world2,world3);\r#if defined(PREPASS_VELOCITY) || defined(VELOCITY)\nmat4 finalPreviousWorld=mat4(previousWorld0,previousWorld1,previousWorld2,previousWorld3);\r#endif\n#ifdef THIN_INSTANCES\nfinalWorld=world*finalWorld;\r#if defined(PREPASS_VELOCITY) || defined(VELOCITY)\nfinalPreviousWorld=previousWorld*finalPreviousWorld;\r#endif\n#endif\n#else\nmat4 finalWorld=world;\r#if defined(PREPASS_VELOCITY) || defined(VELOCITY)\nmat4 finalPreviousWorld=previousWorld;\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const instancesVertex = { name, shader };\n"]}
+{"version":3,"file":"instancesVertex.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/instancesVertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;CAiBd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,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 = \"instancesVertex\";\nconst shader = `#ifdef INSTANCES\nmat4 finalWorld=mat4(world0,world1,world2,world3);\r#if defined(PREPASS_VELOCITY) || defined(VELOCITY)\nmat4 finalPreviousWorld=mat4(previousWorld0,previousWorld1,previousWorld2,previousWorld3);\r#endif\n#ifdef THIN_INSTANCES\nfinalWorld=world*finalWorld;\r#if defined(PREPASS_VELOCITY) || defined(VELOCITY)\nfinalPreviousWorld=previousWorld*finalPreviousWorld;\r#endif\n#endif\n#else\nmat4 finalWorld=world;\r#if defined(PREPASS_VELOCITY) || defined(VELOCITY)\nmat4 finalPreviousWorld=previousWorld;\r#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const instancesVertex = { name, shader };\n"]}

package/Shaders/ShadersInclude/kernelBlurFragment.d.ts

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

package/Shaders/ShadersInclude/kernelBlurFragment.js

@@ -10,6 +10,6 @@ blend+=texture2D(textureSampler,sampleCoord{X})*computedWeight;
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const kernelBlurFragment = { name, shader };
 //# sourceMappingURL=kernelBlurFragment.js.map

package/Shaders/ShadersInclude/kernelBlurFragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"kernelBlurFragment.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/kernelBlurFragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;CAYd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"kernelBlurFragment\";\nconst shader = `#ifdef DOF\nfactor=sampleCoC(sampleCoord{X}); \rcomputedWeight=KERNEL_WEIGHT{X}*factor;\rsumOfWeights+=computedWeight;\r#else\ncomputedWeight=KERNEL_WEIGHT{X};\r#endif\n#ifdef PACKEDFLOAT\nblend+=unpack(texture2D(textureSampler,sampleCoord{X}))*computedWeight;\r#else\nblend+=texture2D(textureSampler,sampleCoord{X})*computedWeight;\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const kernelBlurFragment = { name, shader };\n"]}
+{"version":3,"file":"kernelBlurFragment.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/kernelBlurFragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,oBAAoB,CAAC;AAClC,MAAM,MAAM,GAAG;;;;;;;;;;;;CAYd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"kernelBlurFragment\";\nconst shader = `#ifdef DOF\nfactor=sampleCoC(sampleCoord{X}); \rcomputedWeight=KERNEL_WEIGHT{X}*factor;\rsumOfWeights+=computedWeight;\r#else\ncomputedWeight=KERNEL_WEIGHT{X};\r#endif\n#ifdef PACKEDFLOAT\nblend+=unpack(texture2D(textureSampler,sampleCoord{X}))*computedWeight;\r#else\nblend+=texture2D(textureSampler,sampleCoord{X})*computedWeight;\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const kernelBlurFragment = { name, shader };\n"]}

package/Shaders/ShadersInclude/kernelBlurFragment2.d.ts

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

package/Shaders/ShadersInclude/kernelBlurFragment2.js

@@ -10,6 +10,6 @@ blend+=texture2D(textureSampler,sampleCenter+delta*KERNEL_DEP_OFFSET{X})*compute
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const kernelBlurFragment2 = { name, shader };
 //# sourceMappingURL=kernelBlurFragment2.js.map

package/Shaders/ShadersInclude/kernelBlurFragment2.js.map

@@ -1 +1 @@
-{"version":3,"file":"kernelBlurFragment2.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/kernelBlurFragment2.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;CAYd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"kernelBlurFragment2\";\nconst shader = `#ifdef DOF\nfactor=sampleCoC(sampleCenter+delta*KERNEL_DEP_OFFSET{X});\rcomputedWeight=KERNEL_DEP_WEIGHT{X}*factor;\rsumOfWeights+=computedWeight;\r#else\ncomputedWeight=KERNEL_DEP_WEIGHT{X};\r#endif\n#ifdef PACKEDFLOAT\nblend+=unpack(texture2D(textureSampler,sampleCenter+delta*KERNEL_DEP_OFFSET{X}))*computedWeight;\r#else\nblend+=texture2D(textureSampler,sampleCenter+delta*KERNEL_DEP_OFFSET{X})*computedWeight;\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const kernelBlurFragment2 = { name, shader };\n"]}
+{"version":3,"file":"kernelBlurFragment2.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/kernelBlurFragment2.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;CAYd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"kernelBlurFragment2\";\nconst shader = `#ifdef DOF\nfactor=sampleCoC(sampleCenter+delta*KERNEL_DEP_OFFSET{X});\rcomputedWeight=KERNEL_DEP_WEIGHT{X}*factor;\rsumOfWeights+=computedWeight;\r#else\ncomputedWeight=KERNEL_DEP_WEIGHT{X};\r#endif\n#ifdef PACKEDFLOAT\nblend+=unpack(texture2D(textureSampler,sampleCenter+delta*KERNEL_DEP_OFFSET{X}))*computedWeight;\r#else\nblend+=texture2D(textureSampler,sampleCenter+delta*KERNEL_DEP_OFFSET{X})*computedWeight;\r#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const kernelBlurFragment2 = { name, shader };\n"]}

package/Shaders/ShadersInclude/kernelBlurVaryingDeclaration.d.ts

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

package/Shaders/ShadersInclude/kernelBlurVaryingDeclaration.js

@@ -4,6 +4,6 @@ const name = "kernelBlurVaryingDeclaration";
 const shader = `varying vec2 sampleCoord{X};`;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const kernelBlurVaryingDeclaration = { name, shader };
 //# sourceMappingURL=kernelBlurVaryingDeclaration.js.map

package/Shaders/ShadersInclude/kernelBlurVaryingDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"kernelBlurVaryingDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/kernelBlurVaryingDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,8BAA8B,CAAC;AAC5C,MAAM,MAAM,GAAG,8BAA8B,CAAC;AAC9C,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"kernelBlurVaryingDeclaration\";\nconst shader = `varying vec2 sampleCoord{X};`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const kernelBlurVaryingDeclaration = { name, shader };\n"]}
+{"version":3,"file":"kernelBlurVaryingDeclaration.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/kernelBlurVaryingDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,8BAA8B,CAAC;AAC5C,MAAM,MAAM,GAAG,8BAA8B,CAAC;AAC9C,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"kernelBlurVaryingDeclaration\";\nconst shader = `varying vec2 sampleCoord{X};`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const kernelBlurVaryingDeclaration = { name, shader };\n"]}

package/Shaders/ShadersInclude/kernelBlurVertex.d.ts

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

package/Shaders/ShadersInclude/kernelBlurVertex.js

@@ -4,6 +4,6 @@ const name = "kernelBlurVertex";
 const shader = `sampleCoord{X}=sampleCenter+delta*KERNEL_OFFSET{X};`;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const kernelBlurVertex = { name, shader };
 //# sourceMappingURL=kernelBlurVertex.js.map

package/Shaders/ShadersInclude/kernelBlurVertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"kernelBlurVertex.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/kernelBlurVertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG,qDAAqD,CAAC;AACrE,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"kernelBlurVertex\";\nconst shader = `sampleCoord{X}=sampleCenter+delta*KERNEL_OFFSET{X};`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const kernelBlurVertex = { name, shader };\n"]}
+{"version":3,"file":"kernelBlurVertex.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/kernelBlurVertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG,qDAAqD,CAAC;AACrE,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"kernelBlurVertex\";\nconst shader = `sampleCoord{X}=sampleCenter+delta*KERNEL_OFFSET{X};`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const kernelBlurVertex = { name, shader };\n"]}

package/Shaders/ShadersInclude/lightFragment.d.ts

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

package/Shaders/ShadersInclude/lightFragment.js

@@ -172,6 +172,6 @@ sheenBase+=info.sheen.rgb*shadow;
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const lightFragment = { name, shader };
 //# sourceMappingURL=lightFragment.js.map

package/Shaders/ShadersInclude/lightFragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"lightFragment.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/lightFragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,eAAe,CAAC;AAC7B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmRd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,cAAc;AACd,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"lightFragment\";\nconst shader = `#ifdef LIGHT{X}\n#if defined(SHADOWONLY) || defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X}) && defined(LIGHTMAPNOSPECULAR{X})\n#else\n#ifdef PBR\n#ifdef SPOTLIGHT{X}\npreInfo=computePointAndSpotPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);\r#elif defined(POINTLIGHT{X})\npreInfo=computePointAndSpotPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);\r#elif defined(HEMILIGHT{X})\npreInfo=computeHemisphericPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);\r#elif defined(DIRLIGHT{X})\npreInfo=computeDirectionalPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);\r#endif\npreInfo.NdotV=NdotV;\r#ifdef SPOTLIGHT{X}\n#ifdef LIGHT_FALLOFF_GLTF{X}\npreInfo.attenuation=computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared,light{X}.vLightFalloff.y);\rpreInfo.attenuation*=computeDirectionalLightFalloff_GLTF(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightFalloff.z,light{X}.vLightFalloff.w);\r#elif defined(LIGHT_FALLOFF_PHYSICAL{X})\npreInfo.attenuation=computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);\rpreInfo.attenuation*=computeDirectionalLightFalloff_Physical(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w);\r#elif defined(LIGHT_FALLOFF_STANDARD{X})\npreInfo.attenuation=computeDistanceLightFalloff_Standard(preInfo.lightOffset,light{X}.vLightFalloff.x);\rpreInfo.attenuation*=computeDirectionalLightFalloff_Standard(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w,light{X}.vLightData.w);\r#else\npreInfo.attenuation=computeDistanceLightFalloff(preInfo.lightOffset,preInfo.lightDistanceSquared,light{X}.vLightFalloff.x,light{X}.vLightFalloff.y);\rpreInfo.attenuation*=computeDirectionalLightFalloff(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w,light{X}.vLightData.w,light{X}.vLightFalloff.z,light{X}.vLightFalloff.w);\r#endif\n#elif defined(POINTLIGHT{X})\n#ifdef LIGHT_FALLOFF_GLTF{X}\npreInfo.attenuation=computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared,light{X}.vLightFalloff.y);\r#elif defined(LIGHT_FALLOFF_PHYSICAL{X})\npreInfo.attenuation=computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);\r#elif defined(LIGHT_FALLOFF_STANDARD{X})\npreInfo.attenuation=computeDistanceLightFalloff_Standard(preInfo.lightOffset,light{X}.vLightFalloff.x);\r#else\npreInfo.attenuation=computeDistanceLightFalloff(preInfo.lightOffset,preInfo.lightDistanceSquared,light{X}.vLightFalloff.x,light{X}.vLightFalloff.y);\r#endif\n#else\npreInfo.attenuation=1.0;\r#endif\n#ifdef HEMILIGHT{X}\npreInfo.roughness=roughness;\r#else\npreInfo.roughness=adjustRoughnessFromLightProperties(roughness,light{X}.vLightSpecular.a,preInfo.lightDistance);\r#endif\n#ifdef IRIDESCENCE\npreInfo.iridescenceIntensity=iridescenceIntensity;\r#endif\n#ifdef HEMILIGHT{X}\ninfo.diffuse=computeHemisphericDiffuseLighting(preInfo,light{X}.vLightDiffuse.rgb,light{X}.vLightGround);\r#elif defined(SS_TRANSLUCENCY)\ninfo.diffuse=computeDiffuseAndTransmittedLighting(preInfo,light{X}.vLightDiffuse.rgb,subSurfaceOut.transmittance);\r#else\ninfo.diffuse=computeDiffuseLighting(preInfo,light{X}.vLightDiffuse.rgb);\r#endif\n#ifdef SPECULARTERM\n#ifdef ANISOTROPIC\ninfo.specular=computeAnisotropicSpecularLighting(preInfo,viewDirectionW,normalW,anisotropicOut.anisotropicTangent,anisotropicOut.anisotropicBitangent,anisotropicOut.anisotropy,clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);\r#else\ninfo.specular=computeSpecularLighting(preInfo,normalW,clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);\r#endif\n#endif\n#ifdef SHEEN\n#ifdef SHEEN_LINKWITHALBEDO\npreInfo.roughness=sheenOut.sheenIntensity;\r#else\n#ifdef HEMILIGHT{X}\npreInfo.roughness=sheenOut.sheenRoughness;\r#else\npreInfo.roughness=adjustRoughnessFromLightProperties(sheenOut.sheenRoughness,light{X}.vLightSpecular.a,preInfo.lightDistance);\r#endif\n#endif\ninfo.sheen=computeSheenLighting(preInfo,normalW,sheenOut.sheenColor,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);\r#endif\n#ifdef CLEARCOAT\n#ifdef HEMILIGHT{X}\npreInfo.roughness=clearcoatOut.clearCoatRoughness;\r#else\npreInfo.roughness=adjustRoughnessFromLightProperties(clearcoatOut.clearCoatRoughness,light{X}.vLightSpecular.a,preInfo.lightDistance);\r#endif\ninfo.clearCoat=computeClearCoatLighting(preInfo,clearcoatOut.clearCoatNormalW,clearcoatOut.clearCoatAARoughnessFactors.x,clearcoatOut.clearCoatIntensity,light{X}.vLightDiffuse.rgb);\r#ifdef CLEARCOAT_TINT\nabsorption=computeClearCoatLightingAbsorption(clearcoatOut.clearCoatNdotVRefract,preInfo.L,clearcoatOut.clearCoatNormalW,clearcoatOut.clearCoatColor,clearcoatOut.clearCoatThickness,clearcoatOut.clearCoatIntensity);\rinfo.diffuse*=absorption;\r#ifdef SPECULARTERM\ninfo.specular*=absorption;\r#endif\n#endif\ninfo.diffuse*=info.clearCoat.w;\r#ifdef SPECULARTERM\ninfo.specular*=info.clearCoat.w;\r#endif\n#ifdef SHEEN\ninfo.sheen*=info.clearCoat.w;\r#endif\n#endif\n#else\n#ifdef SPOTLIGHT{X}\ninfo=computeSpotLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDirection,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightDiffuse.a,glossiness);\r#elif defined(HEMILIGHT{X})\ninfo=computeHemisphericLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightGround,glossiness);\r#elif defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})\ninfo=computeLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightDiffuse.a,glossiness);\r#endif\n#endif\n#ifdef PROJECTEDLIGHTTEXTURE{X}\ninfo.diffuse*=computeProjectionTextureDiffuseLighting(projectionLightSampler{X},textureProjectionMatrix{X});\r#endif\n#endif\n#ifdef SHADOW{X}\n#ifdef SHADOWCSM{X}\nfor (int i=0; i<SHADOWCSMNUM_CASCADES{X}; i++) \r{\r#ifdef SHADOWCSM_RIGHTHANDED{X}\ndiff{X}=viewFrustumZ{X}[i]+vPositionFromCamera{X}.z;\r#else\ndiff{X}=viewFrustumZ{X}[i]-vPositionFromCamera{X}.z;\r#endif\nif (diff{X}>=0.) {\rindex{X}=i;\rbreak;\r}\r}\r#ifdef SHADOWCSMUSESHADOWMAXZ{X}\nif (index{X}>=0)\r#endif\n{\r#if defined(SHADOWPCF{X})\n#if defined(SHADOWLOWQUALITY{X})\nshadow=computeShadowWithCSMPCF1(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#elif defined(SHADOWMEDIUMQUALITY{X})\nshadow=computeShadowWithCSMPCF3(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#else\nshadow=computeShadowWithCSMPCF5(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPCSS{X})\n#if defined(SHADOWLOWQUALITY{X})\nshadow=computeShadowWithCSMPCSS16(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#elif defined(SHADOWMEDIUMQUALITY{X})\nshadow=computeShadowWithCSMPCSS32(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#else\nshadow=computeShadowWithCSMPCSS64(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#endif\n#else\nshadow=computeShadowCSM(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#ifdef SHADOWCSMDEBUG{X}\nshadowDebug{X}=vec3(shadow)*vCascadeColorsMultiplier{X}[index{X}];\r#endif\n#ifndef SHADOWCSMNOBLEND{X}\nfloat frustumLength=frustumLengths{X}[index{X}];\rfloat diffRatio=clamp(diff{X}/frustumLength,0.,1.)*cascadeBlendFactor{X};\rif (index{X}<(SHADOWCSMNUM_CASCADES{X}-1) && diffRatio<1.)\r{\rindex{X}+=1;\rfloat nextShadow=0.;\r#if defined(SHADOWPCF{X})\n#if defined(SHADOWLOWQUALITY{X})\nnextShadow=computeShadowWithCSMPCF1(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#elif defined(SHADOWMEDIUMQUALITY{X})\nnextShadow=computeShadowWithCSMPCF3(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#else\nnextShadow=computeShadowWithCSMPCF5(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPCSS{X})\n#if defined(SHADOWLOWQUALITY{X})\nnextShadow=computeShadowWithCSMPCSS16(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#elif defined(SHADOWMEDIUMQUALITY{X})\nnextShadow=computeShadowWithCSMPCSS32(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#else\nnextShadow=computeShadowWithCSMPCSS64(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#endif\n#else\nnextShadow=computeShadowCSM(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\nshadow=mix(nextShadow,shadow,diffRatio);\r#ifdef SHADOWCSMDEBUG{X}\nshadowDebug{X}=mix(vec3(nextShadow)*vCascadeColorsMultiplier{X}[index{X}],shadowDebug{X},diffRatio);\r#endif\n}\r#endif\n}\r#elif defined(SHADOWCLOSEESM{X})\n#if defined(SHADOWCUBE{X})\nshadow=computeShadowWithCloseESMCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.depthValues);\r#else\nshadow=computeShadowWithCloseESM(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWESM{X})\n#if defined(SHADOWCUBE{X})\nshadow=computeShadowWithESMCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.depthValues);\r#else\nshadow=computeShadowWithESM(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPOISSON{X})\n#if defined(SHADOWCUBE{X})\nshadow=computeShadowWithPoissonSamplingCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.x,light{X}.depthValues);\r#else\nshadow=computeShadowWithPoissonSampling(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPCF{X})\n#if defined(SHADOWLOWQUALITY{X})\nshadow=computeShadowWithPCF1(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#elif defined(SHADOWMEDIUMQUALITY{X})\nshadow=computeShadowWithPCF3(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#else\nshadow=computeShadowWithPCF5(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPCSS{X})\n#if defined(SHADOWLOWQUALITY{X})\nshadow=computeShadowWithPCSS16(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#elif defined(SHADOWMEDIUMQUALITY{X})\nshadow=computeShadowWithPCSS32(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#else\nshadow=computeShadowWithPCSS64(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#else\n#if defined(SHADOWCUBE{X})\nshadow=computeShadowCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.depthValues);\r#else\nshadow=computeShadow(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#endif\n#ifdef SHADOWONLY\n#ifndef SHADOWINUSE\n#define SHADOWINUSE\n#endif\nglobalShadow+=shadow;\rshadowLightCount+=1.0;\r#endif\n#else\nshadow=1.;\r#endif\n#ifndef SHADOWONLY\n#ifdef CUSTOMUSERLIGHTING\ndiffuseBase+=computeCustomDiffuseLighting(info,diffuseBase,shadow);\r#ifdef SPECULARTERM\nspecularBase+=computeCustomSpecularLighting(info,specularBase,shadow);\r#endif\n#elif defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X})\ndiffuseBase+=lightmapColor.rgb*shadow;\r#ifdef SPECULARTERM\n#ifndef LIGHTMAPNOSPECULAR{X}\nspecularBase+=info.specular*shadow*lightmapColor.rgb;\r#endif\n#endif\n#ifdef CLEARCOAT\n#ifndef LIGHTMAPNOSPECULAR{X}\nclearCoatBase+=info.clearCoat.rgb*shadow*lightmapColor.rgb;\r#endif\n#endif\n#ifdef SHEEN\n#ifndef LIGHTMAPNOSPECULAR{X}\nsheenBase+=info.sheen.rgb*shadow;\r#endif\n#endif\n#else\n#ifdef SHADOWCSMDEBUG{X}\ndiffuseBase+=info.diffuse*shadowDebug{X};\r#else \ndiffuseBase+=info.diffuse*shadow;\r#endif\n#ifdef SPECULARTERM\nspecularBase+=info.specular*shadow;\r#endif\n#ifdef CLEARCOAT\nclearCoatBase+=info.clearCoat.rgb*shadow;\r#endif\n#ifdef SHEEN\nsheenBase+=info.sheen.rgb*shadow;\r#endif\n#endif\n#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @hidden */\nexport const lightFragment = { name, shader };\n"]}
+{"version":3,"file":"lightFragment.js","sourceRoot":"","sources":["../../../../../../lts/core/generated/Shaders/ShadersInclude/lightFragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD,MAAM,IAAI,GAAG,eAAe,CAAC;AAC7B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmRd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,gBAAgB;AAChB,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\n\nconst name = \"lightFragment\";\nconst shader = `#ifdef LIGHT{X}\n#if defined(SHADOWONLY) || defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X}) && defined(LIGHTMAPNOSPECULAR{X})\n#else\n#ifdef PBR\n#ifdef SPOTLIGHT{X}\npreInfo=computePointAndSpotPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);\r#elif defined(POINTLIGHT{X})\npreInfo=computePointAndSpotPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);\r#elif defined(HEMILIGHT{X})\npreInfo=computeHemisphericPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);\r#elif defined(DIRLIGHT{X})\npreInfo=computeDirectionalPreLightingInfo(light{X}.vLightData,viewDirectionW,normalW);\r#endif\npreInfo.NdotV=NdotV;\r#ifdef SPOTLIGHT{X}\n#ifdef LIGHT_FALLOFF_GLTF{X}\npreInfo.attenuation=computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared,light{X}.vLightFalloff.y);\rpreInfo.attenuation*=computeDirectionalLightFalloff_GLTF(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightFalloff.z,light{X}.vLightFalloff.w);\r#elif defined(LIGHT_FALLOFF_PHYSICAL{X})\npreInfo.attenuation=computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);\rpreInfo.attenuation*=computeDirectionalLightFalloff_Physical(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w);\r#elif defined(LIGHT_FALLOFF_STANDARD{X})\npreInfo.attenuation=computeDistanceLightFalloff_Standard(preInfo.lightOffset,light{X}.vLightFalloff.x);\rpreInfo.attenuation*=computeDirectionalLightFalloff_Standard(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w,light{X}.vLightData.w);\r#else\npreInfo.attenuation=computeDistanceLightFalloff(preInfo.lightOffset,preInfo.lightDistanceSquared,light{X}.vLightFalloff.x,light{X}.vLightFalloff.y);\rpreInfo.attenuation*=computeDirectionalLightFalloff(light{X}.vLightDirection.xyz,preInfo.L,light{X}.vLightDirection.w,light{X}.vLightData.w,light{X}.vLightFalloff.z,light{X}.vLightFalloff.w);\r#endif\n#elif defined(POINTLIGHT{X})\n#ifdef LIGHT_FALLOFF_GLTF{X}\npreInfo.attenuation=computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared,light{X}.vLightFalloff.y);\r#elif defined(LIGHT_FALLOFF_PHYSICAL{X})\npreInfo.attenuation=computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);\r#elif defined(LIGHT_FALLOFF_STANDARD{X})\npreInfo.attenuation=computeDistanceLightFalloff_Standard(preInfo.lightOffset,light{X}.vLightFalloff.x);\r#else\npreInfo.attenuation=computeDistanceLightFalloff(preInfo.lightOffset,preInfo.lightDistanceSquared,light{X}.vLightFalloff.x,light{X}.vLightFalloff.y);\r#endif\n#else\npreInfo.attenuation=1.0;\r#endif\n#ifdef HEMILIGHT{X}\npreInfo.roughness=roughness;\r#else\npreInfo.roughness=adjustRoughnessFromLightProperties(roughness,light{X}.vLightSpecular.a,preInfo.lightDistance);\r#endif\n#ifdef IRIDESCENCE\npreInfo.iridescenceIntensity=iridescenceIntensity;\r#endif\n#ifdef HEMILIGHT{X}\ninfo.diffuse=computeHemisphericDiffuseLighting(preInfo,light{X}.vLightDiffuse.rgb,light{X}.vLightGround);\r#elif defined(SS_TRANSLUCENCY)\ninfo.diffuse=computeDiffuseAndTransmittedLighting(preInfo,light{X}.vLightDiffuse.rgb,subSurfaceOut.transmittance);\r#else\ninfo.diffuse=computeDiffuseLighting(preInfo,light{X}.vLightDiffuse.rgb);\r#endif\n#ifdef SPECULARTERM\n#ifdef ANISOTROPIC\ninfo.specular=computeAnisotropicSpecularLighting(preInfo,viewDirectionW,normalW,anisotropicOut.anisotropicTangent,anisotropicOut.anisotropicBitangent,anisotropicOut.anisotropy,clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);\r#else\ninfo.specular=computeSpecularLighting(preInfo,normalW,clearcoatOut.specularEnvironmentR0,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);\r#endif\n#endif\n#ifdef SHEEN\n#ifdef SHEEN_LINKWITHALBEDO\npreInfo.roughness=sheenOut.sheenIntensity;\r#else\n#ifdef HEMILIGHT{X}\npreInfo.roughness=sheenOut.sheenRoughness;\r#else\npreInfo.roughness=adjustRoughnessFromLightProperties(sheenOut.sheenRoughness,light{X}.vLightSpecular.a,preInfo.lightDistance);\r#endif\n#endif\ninfo.sheen=computeSheenLighting(preInfo,normalW,sheenOut.sheenColor,specularEnvironmentR90,AARoughnessFactors.x,light{X}.vLightDiffuse.rgb);\r#endif\n#ifdef CLEARCOAT\n#ifdef HEMILIGHT{X}\npreInfo.roughness=clearcoatOut.clearCoatRoughness;\r#else\npreInfo.roughness=adjustRoughnessFromLightProperties(clearcoatOut.clearCoatRoughness,light{X}.vLightSpecular.a,preInfo.lightDistance);\r#endif\ninfo.clearCoat=computeClearCoatLighting(preInfo,clearcoatOut.clearCoatNormalW,clearcoatOut.clearCoatAARoughnessFactors.x,clearcoatOut.clearCoatIntensity,light{X}.vLightDiffuse.rgb);\r#ifdef CLEARCOAT_TINT\nabsorption=computeClearCoatLightingAbsorption(clearcoatOut.clearCoatNdotVRefract,preInfo.L,clearcoatOut.clearCoatNormalW,clearcoatOut.clearCoatColor,clearcoatOut.clearCoatThickness,clearcoatOut.clearCoatIntensity);\rinfo.diffuse*=absorption;\r#ifdef SPECULARTERM\ninfo.specular*=absorption;\r#endif\n#endif\ninfo.diffuse*=info.clearCoat.w;\r#ifdef SPECULARTERM\ninfo.specular*=info.clearCoat.w;\r#endif\n#ifdef SHEEN\ninfo.sheen*=info.clearCoat.w;\r#endif\n#endif\n#else\n#ifdef SPOTLIGHT{X}\ninfo=computeSpotLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDirection,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightDiffuse.a,glossiness);\r#elif defined(HEMILIGHT{X})\ninfo=computeHemisphericLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightGround,glossiness);\r#elif defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})\ninfo=computeLighting(viewDirectionW,normalW,light{X}.vLightData,light{X}.vLightDiffuse.rgb,light{X}.vLightSpecular.rgb,light{X}.vLightDiffuse.a,glossiness);\r#endif\n#endif\n#ifdef PROJECTEDLIGHTTEXTURE{X}\ninfo.diffuse*=computeProjectionTextureDiffuseLighting(projectionLightSampler{X},textureProjectionMatrix{X});\r#endif\n#endif\n#ifdef SHADOW{X}\n#ifdef SHADOWCSM{X}\nfor (int i=0; i<SHADOWCSMNUM_CASCADES{X}; i++) \r{\r#ifdef SHADOWCSM_RIGHTHANDED{X}\ndiff{X}=viewFrustumZ{X}[i]+vPositionFromCamera{X}.z;\r#else\ndiff{X}=viewFrustumZ{X}[i]-vPositionFromCamera{X}.z;\r#endif\nif (diff{X}>=0.) {\rindex{X}=i;\rbreak;\r}\r}\r#ifdef SHADOWCSMUSESHADOWMAXZ{X}\nif (index{X}>=0)\r#endif\n{\r#if defined(SHADOWPCF{X})\n#if defined(SHADOWLOWQUALITY{X})\nshadow=computeShadowWithCSMPCF1(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#elif defined(SHADOWMEDIUMQUALITY{X})\nshadow=computeShadowWithCSMPCF3(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#else\nshadow=computeShadowWithCSMPCF5(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPCSS{X})\n#if defined(SHADOWLOWQUALITY{X})\nshadow=computeShadowWithCSMPCSS16(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#elif defined(SHADOWMEDIUMQUALITY{X})\nshadow=computeShadowWithCSMPCSS32(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#else\nshadow=computeShadowWithCSMPCSS64(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#endif\n#else\nshadow=computeShadowCSM(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#ifdef SHADOWCSMDEBUG{X}\nshadowDebug{X}=vec3(shadow)*vCascadeColorsMultiplier{X}[index{X}];\r#endif\n#ifndef SHADOWCSMNOBLEND{X}\nfloat frustumLength=frustumLengths{X}[index{X}];\rfloat diffRatio=clamp(diff{X}/frustumLength,0.,1.)*cascadeBlendFactor{X};\rif (index{X}<(SHADOWCSMNUM_CASCADES{X}-1) && diffRatio<1.)\r{\rindex{X}+=1;\rfloat nextShadow=0.;\r#if defined(SHADOWPCF{X})\n#if defined(SHADOWLOWQUALITY{X})\nnextShadow=computeShadowWithCSMPCF1(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#elif defined(SHADOWMEDIUMQUALITY{X})\nnextShadow=computeShadowWithCSMPCF3(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#else\nnextShadow=computeShadowWithCSMPCF5(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPCSS{X})\n#if defined(SHADOWLOWQUALITY{X})\nnextShadow=computeShadowWithCSMPCSS16(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#elif defined(SHADOWMEDIUMQUALITY{X})\nnextShadow=computeShadowWithCSMPCSS32(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#else\nnextShadow=computeShadowWithCSMPCSS64(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w,lightSizeUVCorrection{X}[index{X}],depthCorrection{X}[index{X}],penumbraDarkness{X});\r#endif\n#else\nnextShadow=computeShadowCSM(float(index{X}),vPositionFromLight{X}[index{X}],vDepthMetric{X}[index{X}],shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\nshadow=mix(nextShadow,shadow,diffRatio);\r#ifdef SHADOWCSMDEBUG{X}\nshadowDebug{X}=mix(vec3(nextShadow)*vCascadeColorsMultiplier{X}[index{X}],shadowDebug{X},diffRatio);\r#endif\n}\r#endif\n}\r#elif defined(SHADOWCLOSEESM{X})\n#if defined(SHADOWCUBE{X})\nshadow=computeShadowWithCloseESMCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.depthValues);\r#else\nshadow=computeShadowWithCloseESM(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWESM{X})\n#if defined(SHADOWCUBE{X})\nshadow=computeShadowWithESMCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.depthValues);\r#else\nshadow=computeShadowWithESM(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.z,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPOISSON{X})\n#if defined(SHADOWCUBE{X})\nshadow=computeShadowWithPoissonSamplingCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.x,light{X}.depthValues);\r#else\nshadow=computeShadowWithPoissonSampling(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPCF{X})\n#if defined(SHADOWLOWQUALITY{X})\nshadow=computeShadowWithPCF1(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#elif defined(SHADOWMEDIUMQUALITY{X})\nshadow=computeShadowWithPCF3(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#else\nshadow=computeShadowWithPCF5(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.yz,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#elif defined(SHADOWPCSS{X})\n#if defined(SHADOWLOWQUALITY{X})\nshadow=computeShadowWithPCSS16(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#elif defined(SHADOWMEDIUMQUALITY{X})\nshadow=computeShadowWithPCSS32(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#else\nshadow=computeShadowWithPCSS64(vPositionFromLight{X},vDepthMetric{X},depthSampler{X},shadowSampler{X},light{X}.shadowsInfo.y,light{X}.shadowsInfo.z,light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#else\n#if defined(SHADOWCUBE{X})\nshadow=computeShadowCube(light{X}.vLightData.xyz,shadowSampler{X},light{X}.shadowsInfo.x,light{X}.depthValues);\r#else\nshadow=computeShadow(vPositionFromLight{X},vDepthMetric{X},shadowSampler{X},light{X}.shadowsInfo.x,light{X}.shadowsInfo.w);\r#endif\n#endif\n#ifdef SHADOWONLY\n#ifndef SHADOWINUSE\n#define SHADOWINUSE\n#endif\nglobalShadow+=shadow;\rshadowLightCount+=1.0;\r#endif\n#else\nshadow=1.;\r#endif\n#ifndef SHADOWONLY\n#ifdef CUSTOMUSERLIGHTING\ndiffuseBase+=computeCustomDiffuseLighting(info,diffuseBase,shadow);\r#ifdef SPECULARTERM\nspecularBase+=computeCustomSpecularLighting(info,specularBase,shadow);\r#endif\n#elif defined(LIGHTMAP) && defined(LIGHTMAPEXCLUDED{X})\ndiffuseBase+=lightmapColor.rgb*shadow;\r#ifdef SPECULARTERM\n#ifndef LIGHTMAPNOSPECULAR{X}\nspecularBase+=info.specular*shadow*lightmapColor.rgb;\r#endif\n#endif\n#ifdef CLEARCOAT\n#ifndef LIGHTMAPNOSPECULAR{X}\nclearCoatBase+=info.clearCoat.rgb*shadow*lightmapColor.rgb;\r#endif\n#endif\n#ifdef SHEEN\n#ifndef LIGHTMAPNOSPECULAR{X}\nsheenBase+=info.sheen.rgb*shadow;\r#endif\n#endif\n#else\n#ifdef SHADOWCSMDEBUG{X}\ndiffuseBase+=info.diffuse*shadowDebug{X};\r#else \ndiffuseBase+=info.diffuse*shadow;\r#endif\n#ifdef SPECULARTERM\nspecularBase+=info.specular*shadow;\r#endif\n#ifdef CLEARCOAT\nclearCoatBase+=info.clearCoat.rgb*shadow;\r#endif\n#ifdef SHEEN\nsheenBase+=info.sheen.rgb*shadow;\r#endif\n#endif\n#endif\n#endif\n`;\n// Sideeffect\nShaderStore.IncludesShadersStore[name] = shader;\n/** @internal */\nexport const lightFragment = { name, shader };\n"]}

package/Shaders/ShadersInclude/lightFragmentDeclaration.d.ts

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

package/Shaders/ShadersInclude/lightFragmentDeclaration.js

@@ -34,6 +34,6 @@ uniform mat4 textureProjectionMatrix{X};
 `;
 // Sideeffect
 ShaderStore.IncludesShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const lightFragmentDeclaration = { name, shader };
 //# sourceMappingURL=lightFragmentDeclaration.js.map