@graphty/graphty-element 1.0.1

package/dist/harmonicsFunctions-D9ZL5yLA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harmonicsFunctions-D9ZL5yLA.js","sources":["../node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrUboDeclaration.js","../node_modules/@babylonjs/core/Shaders/ShadersInclude/pbrBRDFFunctions.js","../node_modules/@babylonjs/core/Shaders/ShadersInclude/harmonicsFunctions.js"],"sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nimport \"./sceneUboDeclaration.js\";\nimport \"./meshUboDeclaration.js\";\nconst name = \"pbrUboDeclaration\";\nconst shader = `layout(std140,column_major) uniform;uniform Material {vec2 vAlbedoInfos;vec2 vBaseWeightInfos;vec2 vBaseDiffuseRoughnessInfos;vec4 vAmbientInfos;vec2 vOpacityInfos;vec2 vEmissiveInfos;vec2 vLightmapInfos;vec3 vReflectivityInfos;vec2 vMicroSurfaceSamplerInfos;vec2 vReflectionInfos;vec2 vReflectionFilteringInfo;vec3 vReflectionPosition;vec3 vReflectionSize;vec3 vBumpInfos;mat4 albedoMatrix;mat4 baseWeightMatrix;mat4 baseDiffuseRoughnessMatrix;mat4 ambientMatrix;mat4 opacityMatrix;mat4 emissiveMatrix;mat4 lightmapMatrix;mat4 reflectivityMatrix;mat4 microSurfaceSamplerMatrix;mat4 bumpMatrix;vec2 vTangentSpaceParams;mat4 reflectionMatrix;vec3 vReflectionColor;vec4 vAlbedoColor;float baseWeight;float baseDiffuseRoughness;vec4 vLightingIntensity;vec3 vReflectionMicrosurfaceInfos;vec3 vReflectionDominantDirection;float pointSize;vec4 vReflectivityColor;vec3 vEmissiveColor;vec3 vAmbientColor;vec2 vDebugMode;vec4 vMetallicReflectanceFactors;vec2 vMetallicReflectanceInfos;mat4 metallicReflectanceMatrix;vec2 vReflectanceInfos;mat4 reflectanceMatrix;vec3 vSphericalL00;vec3 vSphericalL1_1;vec3 vSphericalL10;vec3 vSphericalL11;vec3 vSphericalL2_2;vec3 vSphericalL2_1;vec3 vSphericalL20;vec3 vSphericalL21;vec3 vSphericalL22;vec3 vSphericalX;vec3 vSphericalY;vec3 vSphericalZ;vec3 vSphericalXX_ZZ;vec3 vSphericalYY_ZZ;vec3 vSphericalZZ;vec3 vSphericalXY;vec3 vSphericalYZ;vec3 vSphericalZX;vec4 cameraInfo;\n#define ADDITIONAL_UBO_DECLARATION\n};\n#include<sceneUboDeclaration>\n#include<meshUboDeclaration>\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStore[name]) {\n    ShaderStore.IncludesShadersStore[name] = shader;\n}\n/** @internal */\nexport const pbrUboDeclaration = { name, shader };\n//# sourceMappingURL=pbrUboDeclaration.js.map","// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nconst name = \"pbrBRDFFunctions\";\nconst shader = `#define FRESNEL_MAXIMUM_ON_ROUGH 0.25\n#define BRDF_DIFFUSE_MODEL_EON 0\n#define BRDF_DIFFUSE_MODEL_BURLEY 1\n#define BRDF_DIFFUSE_MODEL_LAMBERT 2\n#define BRDF_DIFFUSE_MODEL_LEGACY 3\n#define DIELECTRIC_SPECULAR_MODEL_GLTF 0\n#define DIELECTRIC_SPECULAR_MODEL_OPENPBR 1\n#define CONDUCTOR_SPECULAR_MODEL_GLTF 0\n#define CONDUCTOR_SPECULAR_MODEL_OPENPBR 1\n#ifndef PBR_VERTEX_SHADER\n#ifdef MS_BRDF_ENERGY_CONSERVATION\nvec3 getEnergyConservationFactor(const vec3 specularEnvironmentR0,const vec3 environmentBrdf) {return 1.0+specularEnvironmentR0*(1.0/environmentBrdf.y-1.0);}\n#endif\n#if CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR \nvec3 getF82Specular(float NdotV,vec3 F0,vec3 edgeTint,float roughness) {const float cos_theta_max=0.142857143; \nconst float one_minus_cos_theta_max_to_the_fifth=0.462664366; \nconst float one_minus_cos_theta_max_to_the_sixth=0.396569457; \nvec3 white_minus_F0=vec3(1.0)-F0;vec3 b_numerator=(F0+white_minus_F0*one_minus_cos_theta_max_to_the_fifth)*(vec3(1.0)-edgeTint);const float b_denominator=cos_theta_max*one_minus_cos_theta_max_to_the_sixth;const float b_denominator_reciprocal=1.0/b_denominator;vec3 b=b_numerator*b_denominator_reciprocal; \nfloat cos_theta=max(roughness,NdotV);float one_minus_cos_theta=1.0-cos_theta;vec3 offset_from_F0=(white_minus_F0-b*cos_theta*one_minus_cos_theta)*pow(one_minus_cos_theta,5.0);return clamp(F0+offset_from_F0,0.0,1.0);}\n#endif\n#ifdef ENVIRONMENTBRDF\nvec3 getBRDFLookup(float NdotV,float perceptualRoughness) {vec2 UV=vec2(NdotV,perceptualRoughness);vec4 brdfLookup=texture2D(environmentBrdfSampler,UV);\n#ifdef ENVIRONMENTBRDF_RGBD\nbrdfLookup.rgb=fromRGBD(brdfLookup.rgba);\n#endif\nreturn brdfLookup.rgb;}\nvec3 getReflectanceFromBRDFLookup(const vec3 specularEnvironmentR0,const vec3 specularEnvironmentR90,const vec3 environmentBrdf) {\n#ifdef BRDF_V_HEIGHT_CORRELATED\nvec3 reflectance=(specularEnvironmentR90-specularEnvironmentR0)*environmentBrdf.x+specularEnvironmentR0*environmentBrdf.y;\n#else\nvec3 reflectance=specularEnvironmentR0*environmentBrdf.x+specularEnvironmentR90*environmentBrdf.y;\n#endif\nreturn reflectance;}\nvec3 getReflectanceFromBRDFLookup(const vec3 specularEnvironmentR0,const vec3 environmentBrdf) {\n#ifdef BRDF_V_HEIGHT_CORRELATED\nvec3 reflectance=mix(environmentBrdf.xxx,environmentBrdf.yyy,specularEnvironmentR0);\n#else\nvec3 reflectance=specularEnvironmentR0*environmentBrdf.x+environmentBrdf.y;\n#endif\nreturn reflectance;}\n#endif\n/* NOT USED\n#if defined(SHEEN) && defined(SHEEN_SOFTER)\nfloat getBRDFLookupCharlieSheen(float NdotV,float perceptualRoughness)\n{float c=1.0-NdotV;float c3=c*c*c;return 0.65584461*c3+1.0/(4.16526551+exp(-7.97291361*perceptualRoughness+6.33516894));}\n#endif\n*/\n#if !defined(ENVIRONMENTBRDF) || defined(REFLECTIONMAP_SKYBOX) || defined(ALPHAFRESNEL)\nvec3 getReflectanceFromAnalyticalBRDFLookup_Jones(float VdotN,vec3 reflectance0,vec3 reflectance90,float smoothness)\n{float weight=mix(FRESNEL_MAXIMUM_ON_ROUGH,1.0,smoothness);return reflectance0+weight*(reflectance90-reflectance0)*pow5(saturate(1.0-VdotN));}\n#endif\n#if defined(SHEEN) && defined(ENVIRONMENTBRDF)\n/**\n* The sheen BRDF not containing F can be easily stored in the blue channel of the BRDF texture.\n* The blue channel contains DCharlie*VAshikhmin*NdotL as a lokkup table\n*/\nvec3 getSheenReflectanceFromBRDFLookup(const vec3 reflectance0,const vec3 environmentBrdf) {vec3 sheenEnvironmentReflectance=reflectance0*environmentBrdf.b;return sheenEnvironmentReflectance;}\n#endif\nvec3 fresnelSchlickGGX(float VdotH,vec3 reflectance0,vec3 reflectance90)\n{return reflectance0+(reflectance90-reflectance0)*pow5(1.0-VdotH);}\nfloat fresnelSchlickGGX(float VdotH,float reflectance0,float reflectance90)\n{return reflectance0+(reflectance90-reflectance0)*pow5(1.0-VdotH);}\n#ifdef CLEARCOAT\nvec3 getR0RemappedForClearCoat(vec3 f0) {\n#ifdef CLEARCOAT_DEFAULTIOR\n#ifdef MOBILE\nreturn saturate(f0*(f0*0.526868+0.529324)-0.0482256);\n#else\nreturn saturate(f0*(f0*(0.941892-0.263008*f0)+0.346479)-0.0285998);\n#endif\n#else\nvec3 s=sqrt(f0);vec3 t=(vClearCoatRefractionParams.z+vClearCoatRefractionParams.w*s)/(vClearCoatRefractionParams.w+vClearCoatRefractionParams.z*s);return square(t);\n#endif\n}\n#endif\n#ifdef IRIDESCENCE\nconst mat3 XYZ_TO_REC709=mat3(\n3.2404542,-0.9692660, 0.0556434,\n-1.5371385, 1.8760108,-0.2040259,\n-0.4985314, 0.0415560, 1.0572252\n);vec3 getIORTfromAirToSurfaceR0(vec3 f0) {vec3 sqrtF0=sqrt(f0);return (1.+sqrtF0)/(1.-sqrtF0);}\nvec3 getR0fromIORs(vec3 iorT,float iorI) {return square((iorT-vec3(iorI))/(iorT+vec3(iorI)));}\nfloat getR0fromIORs(float iorT,float iorI) {return square((iorT-iorI)/(iorT+iorI));}\nvec3 evalSensitivity(float opd,vec3 shift) {float phase=2.0*PI*opd*1.0e-9;const vec3 val=vec3(5.4856e-13,4.4201e-13,5.2481e-13);const vec3 pos=vec3(1.6810e+06,1.7953e+06,2.2084e+06);const vec3 var=vec3(4.3278e+09,9.3046e+09,6.6121e+09);vec3 xyz=val*sqrt(2.0*PI*var)*cos(pos*phase+shift)*exp(-square(phase)*var);xyz.x+=9.7470e-14*sqrt(2.0*PI*4.5282e+09)*cos(2.2399e+06*phase+shift[0])*exp(-4.5282e+09*square(phase));xyz/=1.0685e-7;vec3 srgb=XYZ_TO_REC709*xyz;return srgb;}\nvec3 evalIridescence(float outsideIOR,float eta2,float cosTheta1,float thinFilmThickness,vec3 baseF0) {vec3 I=vec3(1.0);float iridescenceIOR=mix(outsideIOR,eta2,smoothstep(0.0,0.03,thinFilmThickness));float sinTheta2Sq=square(outsideIOR/iridescenceIOR)*(1.0-square(cosTheta1));float cosTheta2Sq=1.0-sinTheta2Sq;if (cosTheta2Sq<0.0) {return I;}\nfloat cosTheta2=sqrt(cosTheta2Sq);float R0=getR0fromIORs(iridescenceIOR,outsideIOR);float R12=fresnelSchlickGGX(cosTheta1,R0,1.);float R21=R12;float T121=1.0-R12;float phi12=0.0;if (iridescenceIOR<outsideIOR) phi12=PI;float phi21=PI-phi12;vec3 baseIOR=getIORTfromAirToSurfaceR0(clamp(baseF0,0.0,0.9999)); \nvec3 R1=getR0fromIORs(baseIOR,iridescenceIOR);vec3 R23=fresnelSchlickGGX(cosTheta2,R1,vec3(1.));vec3 phi23=vec3(0.0);if (baseIOR[0]<iridescenceIOR) phi23[0]=PI;if (baseIOR[1]<iridescenceIOR) phi23[1]=PI;if (baseIOR[2]<iridescenceIOR) phi23[2]=PI;float opd=2.0*iridescenceIOR*thinFilmThickness*cosTheta2;vec3 phi=vec3(phi21)+phi23;vec3 R123=clamp(R12*R23,1e-5,0.9999);vec3 r123=sqrt(R123);vec3 Rs=square(T121)*R23/(vec3(1.0)-R123);vec3 C0=R12+Rs;I=C0;vec3 Cm=Rs-T121;for (int m=1; m<=2; ++m)\n{Cm*=r123;vec3 Sm=2.0*evalSensitivity(float(m)*opd,float(m)*phi);I+=Cm*Sm;}\nreturn max(I,vec3(0.0));}\n#endif\nfloat normalDistributionFunction_TrowbridgeReitzGGX(float NdotH,float alphaG)\n{float a2=square(alphaG);float d=NdotH*NdotH*(a2-1.0)+1.0;return a2/(PI*d*d);}\n#ifdef SHEEN\nfloat normalDistributionFunction_CharlieSheen(float NdotH,float alphaG)\n{float invR=1./alphaG;float cos2h=NdotH*NdotH;float sin2h=1.-cos2h;return (2.+invR)*pow(sin2h,invR*.5)/(2.*PI);}\n#endif\n#ifdef ANISOTROPIC\nfloat normalDistributionFunction_BurleyGGX_Anisotropic(float NdotH,float TdotH,float BdotH,const vec2 alphaTB) {float a2=alphaTB.x*alphaTB.y;vec3 v=vec3(alphaTB.y*TdotH,alphaTB.x *BdotH,a2*NdotH);float v2=dot(v,v);float w2=a2/v2;return a2*w2*w2*RECIPROCAL_PI;}\n#endif\n#ifdef BRDF_V_HEIGHT_CORRELATED\nfloat smithVisibility_GGXCorrelated(float NdotL,float NdotV,float alphaG) {\n#ifdef MOBILE\nfloat GGXV=NdotL*(NdotV*(1.0-alphaG)+alphaG);float GGXL=NdotV*(NdotL*(1.0-alphaG)+alphaG);return 0.5/(GGXV+GGXL);\n#else\nfloat a2=alphaG*alphaG;float GGXV=NdotL*sqrt(NdotV*(NdotV-a2*NdotV)+a2);float GGXL=NdotV*sqrt(NdotL*(NdotL-a2*NdotL)+a2);return 0.5/(GGXV+GGXL);\n#endif\n}\n#else\nfloat smithVisibilityG1_TrowbridgeReitzGGXFast(float dot,float alphaG)\n{\n#ifdef MOBILE\nreturn 1.0/(dot+alphaG+(1.0-alphaG)*dot ));\n#else\nfloat alphaSquared=alphaG*alphaG;return 1.0/(dot+sqrt(alphaSquared+(1.0-alphaSquared)*dot*dot));\n#endif\n}\nfloat smithVisibility_TrowbridgeReitzGGXFast(float NdotL,float NdotV,float alphaG)\n{float visibility=smithVisibilityG1_TrowbridgeReitzGGXFast(NdotL,alphaG)*smithVisibilityG1_TrowbridgeReitzGGXFast(NdotV,alphaG);return visibility;}\n#endif\n#ifdef ANISOTROPIC\nfloat smithVisibility_GGXCorrelated_Anisotropic(float NdotL,float NdotV,float TdotV,float BdotV,float TdotL,float BdotL,const vec2 alphaTB) {float lambdaV=NdotL*length(vec3(alphaTB.x*TdotV,alphaTB.y*BdotV,NdotV));float lambdaL=NdotV*length(vec3(alphaTB.x*TdotL,alphaTB.y*BdotL,NdotL));float v=0.5/(lambdaV+lambdaL);return v;}\n#endif\n#ifdef CLEARCOAT\nfloat visibility_Kelemen(float VdotH) {return 0.25/(VdotH*VdotH); }\n#endif\n#ifdef SHEEN\nfloat visibility_Ashikhmin(float NdotL,float NdotV)\n{return 1./(4.*(NdotL+NdotV-NdotL*NdotV));}\n/* NOT USED\n#ifdef SHEEN_SOFTER\nfloat l(float x,float alphaG)\n{float oneMinusAlphaSq=(1.0-alphaG)*(1.0-alphaG);float a=mix(21.5473,25.3245,oneMinusAlphaSq);float b=mix(3.82987,3.32435,oneMinusAlphaSq);float c=mix(0.19823,0.16801,oneMinusAlphaSq);float d=mix(-1.97760,-1.27393,oneMinusAlphaSq);float e=mix(-4.32054,-4.85967,oneMinusAlphaSq);return a/(1.0+b*pow(x,c))+d*x+e;}\nfloat lambdaSheen(float cosTheta,float alphaG)\n{return abs(cosTheta)<0.5 ? exp(l(cosTheta,alphaG)) : exp(2.0*l(0.5,alphaG)-l(1.0-cosTheta,alphaG));}\nfloat visibility_CharlieSheen(float NdotL,float NdotV,float alphaG)\n{float G=1.0/(1.0+lambdaSheen(NdotV,alphaG)+lambdaSheen(NdotL,alphaG));return G/(4.0*NdotV*NdotL);}\n#endif\n*/\n#endif\nfloat diffuseBRDF_Burley(float NdotL,float NdotV,float VdotH,float roughness) {float diffuseFresnelNV=pow5(saturateEps(1.0-NdotL));float diffuseFresnelNL=pow5(saturateEps(1.0-NdotV));float diffuseFresnel90=0.5+2.0*VdotH*VdotH*roughness;float fresnel =\n(1.0+(diffuseFresnel90-1.0)*diffuseFresnelNL) *\n(1.0+(diffuseFresnel90-1.0)*diffuseFresnelNV);return fresnel/PI;}\nconst float constant1_FON=0.5-2.0/(3.0*PI);const float constant2_FON=2.0/3.0-28.0/(15.0*PI);float E_FON_approx(float mu,float roughness)\n{float sigma=roughness; \nfloat mucomp=1.0-mu;float mucomp2=mucomp*mucomp;const mat2 Gcoeffs=mat2(0.0571085289,-0.332181442,\n0.491881867,0.0714429953);float GoverPi=dot(Gcoeffs*vec2(mucomp,mucomp2),vec2(1.0,mucomp2));return (1.0+sigma*GoverPi)/(1.0+constant1_FON*sigma);}\nvec3 diffuseBRDF_EON(vec3 albedo,float roughness,float NdotL,float NdotV,float LdotV)\n{vec3 rho=albedo;float sigma=roughness; \nfloat mu_i=NdotL; \nfloat mu_o=NdotV; \nfloat s=LdotV-mu_i*mu_o; \nfloat sovertF=s>0.0 ? s/max(mu_i,mu_o) : s; \nfloat AF=1.0/(1.0+constant1_FON*sigma); \nvec3 f_ss=(rho*RECIPROCAL_PI)*AF*(1.0+sigma*sovertF); \nfloat EFo=E_FON_approx(mu_o,sigma); \nfloat EFi=E_FON_approx(mu_i,sigma); \nfloat avgEF=AF*(1.0+constant2_FON*sigma); \nvec3 rho_ms=(rho*rho)*avgEF/(vec3(1.0)-rho*(1.0-avgEF));const float eps=1.0e-7;vec3 f_ms=(rho_ms*RECIPROCAL_PI)*max(eps,1.0-EFo) \n* max(eps,1.0-EFi)\n/ max(eps,1.0-avgEF);return (f_ss+f_ms);}\n#ifdef SS_TRANSLUCENCY\nvec3 transmittanceBRDF_Burley(const vec3 tintColor,const vec3 diffusionDistance,float thickness) {vec3 S=1./maxEps(diffusionDistance);vec3 temp=exp((-0.333333333*thickness)*S);return tintColor.rgb*0.25*(temp*temp*temp+3.0*temp);}\nfloat computeWrappedDiffuseNdotL(float NdotL,float w) {float t=1.0+w;float invt2=1.0/square(t);return saturate((NdotL+w)*invt2);}\n#endif\n#endif \n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStore[name]) {\n    ShaderStore.IncludesShadersStore[name] = shader;\n}\n/** @internal */\nexport const pbrBRDFFunctions = { name, shader };\n//# sourceMappingURL=pbrBRDFFunctions.js.map","// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nconst name = \"harmonicsFunctions\";\nconst shader = `#ifdef USESPHERICALFROMREFLECTIONMAP\n#ifdef SPHERICAL_HARMONICS\nvec3 computeEnvironmentIrradiance(vec3 normal) {return vSphericalL00\n+ vSphericalL1_1*(normal.y)\n+ vSphericalL10*(normal.z)\n+ vSphericalL11*(normal.x)\n+ vSphericalL2_2*(normal.y*normal.x)\n+ vSphericalL2_1*(normal.y*normal.z)\n+ vSphericalL20*((3.0*normal.z*normal.z)-1.0)\n+ vSphericalL21*(normal.z*normal.x)\n+ vSphericalL22*(normal.x*normal.x-(normal.y*normal.y));}\n#else\nvec3 computeEnvironmentIrradiance(vec3 normal) {float Nx=normal.x;float Ny=normal.y;float Nz=normal.z;vec3 C1=vSphericalZZ.rgb;vec3 Cx=vSphericalX.rgb;vec3 Cy=vSphericalY.rgb;vec3 Cz=vSphericalZ.rgb;vec3 Cxx_zz=vSphericalXX_ZZ.rgb;vec3 Cyy_zz=vSphericalYY_ZZ.rgb;vec3 Cxy=vSphericalXY.rgb;vec3 Cyz=vSphericalYZ.rgb;vec3 Czx=vSphericalZX.rgb;vec3 a1=Cyy_zz*Ny+Cy;vec3 a2=Cyz*Nz+a1;vec3 b1=Czx*Nz+Cx;vec3 b2=Cxy*Ny+b1;vec3 b3=Cxx_zz*Nx+b2;vec3 t1=Cz *Nz+C1;vec3 t2=a2 *Ny+t1;vec3 t3=b3 *Nx+t2;return t3;}\n#endif\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStore[name]) {\n    ShaderStore.IncludesShadersStore[name] = shader;\n}\n/** @internal */\nexport const harmonicsFunctions = { name, shader };\n//# sourceMappingURL=harmonicsFunctions.js.map"],"names":["name","shader","ShaderStore"],"mappings":";;AAIA,MAAMA,IAAO,qBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAOVC,EAAY,qBAAqBF,CAAI,MACtCE,EAAY,qBAAqBF,CAAI,IAAIC;ACX7C,MAAMD,IAAO,oBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuKVC,EAAY,qBAAqBF,CAAI,MACtCE,EAAY,qBAAqBF,CAAI,IAAIC;ACzK7C,MAAMD,IAAO,sBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBVC,EAAY,qBAAqBF,CAAI,MACtCE,EAAY,qBAAqBF,CAAI,IAAIC;","x_google_ignoreList":[0,1,2]}

package/dist/hdrTextureLoader-DreWCvHD.js

@@ -0,0 +1,112 @@
+import "./index-ChGTkj2q.js";
+function m(t, e) {
+  return e > 1023 ? t * Math.pow(2, 1023) * Math.pow(2, e - 1023) : e < -1074 ? t * Math.pow(2, -1074) * Math.pow(2, e + 1074) : t * Math.pow(2, e);
+}
+function p(t, e, r, i, l, n) {
+  l > 0 ? (l = m(1, l - 136), t[n + 0] = e * l, t[n + 1] = r * l, t[n + 2] = i * l) : (t[n + 0] = 0, t[n + 1] = 0, t[n + 2] = 0);
+}
+function g(t, e) {
+  let r = "", i = "";
+  for (let l = e; l < t.length - e && (i = String.fromCharCode(t[l]), i != `
+`); l++)
+    r += i;
+  return r;
+}
+function D(t) {
+  let e = 0, r = 0, i = g(t, 0);
+  if (i[0] != "#" || i[1] != "?")
+    throw "Bad HDR Format.";
+  let l = !1, n = !1, o = 0;
+  do
+    o += i.length + 1, i = g(t, o), i == "FORMAT=32-bit_rle_rgbe" ? n = !0 : i.length == 0 && (l = !0);
+  while (!l);
+  if (!n)
+    throw "HDR Bad header format, unsupported FORMAT";
+  o += i.length + 1, i = g(t, o);
+  const a = /^-Y (.*) \+X (.*)$/g.exec(i);
+  if (!a || a.length < 3)
+    throw "HDR Bad header format, no size";
+  if (r = parseInt(a[2]), e = parseInt(a[1]), r < 8 || r > 32767)
+    throw "HDR Bad header format, unsupported size";
+  return o += i.length + 1, {
+    height: e,
+    width: r,
+    dataPosition: o
+  };
+}
+function b(t, e) {
+  return H(t, e);
+}
+function H(t, e) {
+  let r = e.height;
+  const i = e.width;
+  let l, n, o, c, a, s = e.dataPosition, f = 0, d = 0, h = 0;
+  const B = new ArrayBuffer(i * 4), w = new Uint8Array(B), A = new ArrayBuffer(e.width * e.height * 4 * 3), u = new Float32Array(A);
+  for (; r > 0; ) {
+    if (l = t[s++], n = t[s++], o = t[s++], c = t[s++], l != 2 || n != 2 || o & 128 || e.width < 8 || e.width > 32767)
+      return F(t, e);
+    if ((o << 8 | c) != i)
+      throw "HDR Bad header format, wrong scan line width";
+    for (f = 0, h = 0; h < 4; h++)
+      for (d = (h + 1) * i; f < d; )
+        if (l = t[s++], n = t[s++], l > 128) {
+          if (a = l - 128, a == 0 || a > d - f)
+            throw "HDR Bad Format, bad scanline data (run)";
+          for (; a-- > 0; )
+            w[f++] = n;
+        } else {
+          if (a = l, a == 0 || a > d - f)
+            throw "HDR Bad Format, bad scanline data (non-run)";
+          if (w[f++] = n, --a > 0)
+            for (let R = 0; R < a; R++)
+              w[f++] = t[s++];
+        }
+    for (h = 0; h < i; h++)
+      l = w[h], n = w[h + i], o = w[h + 2 * i], c = w[h + 3 * i], p(u, l, n, o, c, (e.height - r) * i * 3 + h * 3);
+    r--;
+  }
+  return u;
+}
+function F(t, e) {
+  let r = e.height;
+  const i = e.width;
+  let l, n, o, c, a, s = e.dataPosition;
+  const f = new ArrayBuffer(e.width * e.height * 4 * 3), d = new Float32Array(f);
+  for (; r > 0; ) {
+    for (a = 0; a < e.width; a++)
+      l = t[s++], n = t[s++], o = t[s++], c = t[s++], p(d, l, n, o, c, (e.height - r) * i * 3 + a * 3);
+    r--;
+  }
+  return d;
+}
+class L {
+  constructor() {
+    this.supportCascades = !1;
+  }
+  /**
+   * Uploads the cube texture data to the WebGL texture. It has already been bound.
+   * Cube texture are not supported by .hdr files
+   */
+  loadCubeData() {
+    throw ".hdr not supported in Cube.";
+  }
+  /**
+   * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param callback defines the method to call once ready to upload
+   */
+  loadData(e, r, i) {
+    const l = new Uint8Array(e.buffer, e.byteOffset, e.byteLength), n = D(l), o = b(l, n), c = n.width * n.height, a = new Float32Array(c * 4);
+    for (let s = 0; s < c; s += 1)
+      a[s * 4] = o[s * 3], a[s * 4 + 1] = o[s * 3 + 1], a[s * 4 + 2] = o[s * 3 + 2], a[s * 4 + 3] = 1;
+    i(n.width, n.height, r.generateMipMaps, !1, () => {
+      const s = r.getEngine();
+      r.type = 1, r.format = 5, r._gammaSpace = !1, s._uploadDataToTextureDirectly(r, a);
+    });
+  }
+}
+export {
+  L as _HDRTextureLoader
+};
+//# sourceMappingURL=hdrTextureLoader-DreWCvHD.js.map

package/dist/hdrTextureLoader-DreWCvHD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdrTextureLoader-DreWCvHD.js","sources":["../node_modules/@babylonjs/core/Misc/HighDynamicRange/hdr.js","../node_modules/@babylonjs/core/Materials/Textures/Loaders/hdrTextureLoader.js"],"sourcesContent":["import { PanoramaToCubeMapTools } from \"./panoramaToCubemap.js\";\n/* This groups tools to convert HDR texture to native colors array. */\nfunction Ldexp(mantissa, exponent) {\n    if (exponent > 1023) {\n        return mantissa * Math.pow(2, 1023) * Math.pow(2, exponent - 1023);\n    }\n    if (exponent < -1074) {\n        return mantissa * Math.pow(2, -1074) * Math.pow(2, exponent + 1074);\n    }\n    return mantissa * Math.pow(2, exponent);\n}\nfunction Rgbe2float(float32array, red, green, blue, exponent, index) {\n    if (exponent > 0) {\n        /*nonzero pixel*/\n        exponent = Ldexp(1.0, exponent - (128 + 8));\n        float32array[index + 0] = red * exponent;\n        float32array[index + 1] = green * exponent;\n        float32array[index + 2] = blue * exponent;\n    }\n    else {\n        float32array[index + 0] = 0;\n        float32array[index + 1] = 0;\n        float32array[index + 2] = 0;\n    }\n}\nfunction ReadStringLine(uint8array, startIndex) {\n    let line = \"\";\n    let character = \"\";\n    for (let i = startIndex; i < uint8array.length - startIndex; i++) {\n        character = String.fromCharCode(uint8array[i]);\n        if (character == \"\\n\") {\n            break;\n        }\n        line += character;\n    }\n    return line;\n}\n/**\n * Reads header information from an RGBE texture stored in a native array.\n * More information on this format are available here:\n * https://en.wikipedia.org/wiki/RGBE_image_format\n *\n * @param uint8array The binary file stored in  native array.\n * @returns The header information.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function RGBE_ReadHeader(uint8array) {\n    let height = 0;\n    let width = 0;\n    let line = ReadStringLine(uint8array, 0);\n    if (line[0] != \"#\" || line[1] != \"?\") {\n        // eslint-disable-next-line no-throw-literal\n        throw \"Bad HDR Format.\";\n    }\n    let endOfHeader = false;\n    let findFormat = false;\n    let lineIndex = 0;\n    do {\n        lineIndex += line.length + 1;\n        line = ReadStringLine(uint8array, lineIndex);\n        if (line == \"FORMAT=32-bit_rle_rgbe\") {\n            findFormat = true;\n        }\n        else if (line.length == 0) {\n            endOfHeader = true;\n        }\n    } while (!endOfHeader);\n    if (!findFormat) {\n        // eslint-disable-next-line no-throw-literal\n        throw \"HDR Bad header format, unsupported FORMAT\";\n    }\n    lineIndex += line.length + 1;\n    line = ReadStringLine(uint8array, lineIndex);\n    const sizeRegexp = /^-Y (.*) \\+X (.*)$/g;\n    const match = sizeRegexp.exec(line);\n    // TODO. Support +Y and -X if needed.\n    if (!match || match.length < 3) {\n        // eslint-disable-next-line no-throw-literal\n        throw \"HDR Bad header format, no size\";\n    }\n    width = parseInt(match[2]);\n    height = parseInt(match[1]);\n    if (width < 8 || width > 0x7fff) {\n        // eslint-disable-next-line no-throw-literal\n        throw \"HDR Bad header format, unsupported size\";\n    }\n    lineIndex += line.length + 1;\n    return {\n        height: height,\n        width: width,\n        dataPosition: lineIndex,\n    };\n}\n/**\n * Returns the cubemap information (each faces texture data) extracted from an RGBE texture.\n * This RGBE texture needs to store the information as a panorama.\n *\n * More information on this format are available here:\n * https://en.wikipedia.org/wiki/RGBE_image_format\n *\n * @param buffer The binary file stored in an array buffer.\n * @param size The expected size of the extracted cubemap.\n * @param supersample enable supersampling the cubemap (default: false)\n * @returns The Cube Map information.\n */\nexport function GetCubeMapTextureData(buffer, size, supersample = false) {\n    const uint8array = new Uint8Array(buffer);\n    const hdrInfo = RGBE_ReadHeader(uint8array);\n    const data = RGBE_ReadPixels(uint8array, hdrInfo);\n    const cubeMapData = PanoramaToCubeMapTools.ConvertPanoramaToCubemap(data, hdrInfo.width, hdrInfo.height, size, supersample);\n    return cubeMapData;\n}\n/**\n * Returns the pixels data extracted from an RGBE texture.\n * This pixels will be stored left to right up to down in the R G B order in one array.\n *\n * More information on this format are available here:\n * https://en.wikipedia.org/wiki/RGBE_image_format\n *\n * @param uint8array The binary file stored in an array buffer.\n * @param hdrInfo The header information of the file.\n * @returns The pixels data in RGB right to left up to down order.\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport function RGBE_ReadPixels(uint8array, hdrInfo) {\n    return ReadRGBEPixelsRLE(uint8array, hdrInfo);\n}\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction ReadRGBEPixelsRLE(uint8array, hdrInfo) {\n    let numScanlines = hdrInfo.height;\n    const scanlineWidth = hdrInfo.width;\n    let a, b, c, d, count;\n    let dataIndex = hdrInfo.dataPosition;\n    let index = 0, endIndex = 0, i = 0;\n    const scanLineArrayBuffer = new ArrayBuffer(scanlineWidth * 4); // four channel R G B E\n    const scanLineArray = new Uint8Array(scanLineArrayBuffer);\n    // 3 channels of 4 bytes per pixel in float.\n    const resultBuffer = new ArrayBuffer(hdrInfo.width * hdrInfo.height * 4 * 3);\n    const resultArray = new Float32Array(resultBuffer);\n    // read in each successive scanline\n    while (numScanlines > 0) {\n        a = uint8array[dataIndex++];\n        b = uint8array[dataIndex++];\n        c = uint8array[dataIndex++];\n        d = uint8array[dataIndex++];\n        if (a != 2 || b != 2 || c & 0x80 || hdrInfo.width < 8 || hdrInfo.width > 32767) {\n            return ReadRGBEPixelsNotRLE(uint8array, hdrInfo);\n        }\n        if (((c << 8) | d) != scanlineWidth) {\n            // eslint-disable-next-line no-throw-literal\n            throw \"HDR Bad header format, wrong scan line width\";\n        }\n        index = 0;\n        // read each of the four channels for the scanline into the buffer\n        for (i = 0; i < 4; i++) {\n            endIndex = (i + 1) * scanlineWidth;\n            while (index < endIndex) {\n                a = uint8array[dataIndex++];\n                b = uint8array[dataIndex++];\n                if (a > 128) {\n                    // a run of the same value\n                    count = a - 128;\n                    if (count == 0 || count > endIndex - index) {\n                        // eslint-disable-next-line no-throw-literal\n                        throw \"HDR Bad Format, bad scanline data (run)\";\n                    }\n                    while (count-- > 0) {\n                        scanLineArray[index++] = b;\n                    }\n                }\n                else {\n                    // a non-run\n                    count = a;\n                    if (count == 0 || count > endIndex - index) {\n                        // eslint-disable-next-line no-throw-literal\n                        throw \"HDR Bad Format, bad scanline data (non-run)\";\n                    }\n                    scanLineArray[index++] = b;\n                    if (--count > 0) {\n                        for (let j = 0; j < count; j++) {\n                            scanLineArray[index++] = uint8array[dataIndex++];\n                        }\n                    }\n                }\n            }\n        }\n        // now convert data from buffer into floats\n        for (i = 0; i < scanlineWidth; i++) {\n            a = scanLineArray[i];\n            b = scanLineArray[i + scanlineWidth];\n            c = scanLineArray[i + 2 * scanlineWidth];\n            d = scanLineArray[i + 3 * scanlineWidth];\n            Rgbe2float(resultArray, a, b, c, d, (hdrInfo.height - numScanlines) * scanlineWidth * 3 + i * 3);\n        }\n        numScanlines--;\n    }\n    return resultArray;\n}\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction ReadRGBEPixelsNotRLE(uint8array, hdrInfo) {\n    // this file is not run length encoded\n    // read values sequentially\n    let numScanlines = hdrInfo.height;\n    const scanlineWidth = hdrInfo.width;\n    let a, b, c, d, i;\n    let dataIndex = hdrInfo.dataPosition;\n    // 3 channels of 4 bytes per pixel in float.\n    const resultBuffer = new ArrayBuffer(hdrInfo.width * hdrInfo.height * 4 * 3);\n    const resultArray = new Float32Array(resultBuffer);\n    // read in each successive scanline\n    while (numScanlines > 0) {\n        for (i = 0; i < hdrInfo.width; i++) {\n            a = uint8array[dataIndex++];\n            b = uint8array[dataIndex++];\n            c = uint8array[dataIndex++];\n            d = uint8array[dataIndex++];\n            Rgbe2float(resultArray, a, b, c, d, (hdrInfo.height - numScanlines) * scanlineWidth * 3 + i * 3);\n        }\n        numScanlines--;\n    }\n    return resultArray;\n}\n/**\n * @deprecated Use functions separately\n */\nexport const HDRTools = {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    RGBE_ReadHeader,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    GetCubeMapTextureData,\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    RGBE_ReadPixels,\n};\n//# sourceMappingURL=hdr.js.map","import { RGBE_ReadHeader, RGBE_ReadPixels } from \"../../../Misc/HighDynamicRange/hdr.js\";\n\n/**\n * Implementation of the HDR Texture Loader.\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class _HDRTextureLoader {\n    constructor() {\n        /**\n         * Defines whether the loader supports cascade loading the different faces.\n         */\n        this.supportCascades = false;\n    }\n    /**\n     * Uploads the cube texture data to the WebGL texture. It has already been bound.\n     * Cube texture are not supported by .hdr files\n     */\n    loadCubeData() {\n        // eslint-disable-next-line no-throw-literal\n        throw \".hdr not supported in Cube.\";\n    }\n    /**\n     * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.\n     * @param data contains the texture data\n     * @param texture defines the BabylonJS internal texture\n     * @param callback defines the method to call once ready to upload\n     */\n    loadData(data, texture, callback) {\n        const uint8array = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n        const hdrInfo = RGBE_ReadHeader(uint8array);\n        const pixelsDataRGB32 = RGBE_ReadPixels(uint8array, hdrInfo);\n        const pixels = hdrInfo.width * hdrInfo.height;\n        const pixelsDataRGBA32 = new Float32Array(pixels * 4);\n        for (let i = 0; i < pixels; i += 1) {\n            pixelsDataRGBA32[i * 4] = pixelsDataRGB32[i * 3];\n            pixelsDataRGBA32[i * 4 + 1] = pixelsDataRGB32[i * 3 + 1];\n            pixelsDataRGBA32[i * 4 + 2] = pixelsDataRGB32[i * 3 + 2];\n            pixelsDataRGBA32[i * 4 + 3] = 1;\n        }\n        callback(hdrInfo.width, hdrInfo.height, texture.generateMipMaps, false, () => {\n            const engine = texture.getEngine();\n            texture.type = 1;\n            texture.format = 5;\n            texture._gammaSpace = false;\n            engine._uploadDataToTextureDirectly(texture, pixelsDataRGBA32);\n        });\n    }\n}\n//# sourceMappingURL=hdrTextureLoader.js.map"],"names":["Ldexp","mantissa","exponent","Rgbe2float","float32array","red","green","blue","index","ReadStringLine","uint8array","startIndex","line","character","i","RGBE_ReadHeader","height","width","endOfHeader","findFormat","lineIndex","match","RGBE_ReadPixels","hdrInfo","ReadRGBEPixelsRLE","numScanlines","scanlineWidth","a","b","c","d","count","dataIndex","endIndex","scanLineArrayBuffer","scanLineArray","resultBuffer","resultArray","ReadRGBEPixelsNotRLE","j","_HDRTextureLoader","data","texture","callback","pixelsDataRGB32","pixels","pixelsDataRGBA32","engine"],"mappings":"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","x_google_ignoreList":[0,1]}

package/dist/helperFunctions-Dh1WD8YN.js

@@ -0,0 +1,106 @@
+import { S as e } from "./index-ChGTkj2q.js";
+const a = "helperFunctions", o = `const float PI=3.1415926535897932384626433832795;const float TWO_PI=6.283185307179586;const float HALF_PI=1.5707963267948966;const float RECIPROCAL_PI=0.3183098861837907;const float RECIPROCAL_PI2=0.15915494309189535;const float RECIPROCAL_PI4=0.07957747154594767;const float HALF_MIN=5.96046448e-08; 
+const float LinearEncodePowerApprox=2.2;const float GammaEncodePowerApprox=1.0/LinearEncodePowerApprox;const vec3 LuminanceEncodeApprox=vec3(0.2126,0.7152,0.0722);const float Epsilon=0.0000001;
+#define saturate(x) clamp(x,0.0,1.0)
+#define absEps(x) abs(x)+Epsilon
+#define maxEps(x) max(x,Epsilon)
+#define saturateEps(x) clamp(x,Epsilon,1.0)
+mat3 transposeMat3(mat3 inMatrix) {vec3 i0=inMatrix[0];vec3 i1=inMatrix[1];vec3 i2=inMatrix[2];mat3 outMatrix=mat3(
+vec3(i0.x,i1.x,i2.x),
+vec3(i0.y,i1.y,i2.y),
+vec3(i0.z,i1.z,i2.z)
+);return outMatrix;}
+mat3 inverseMat3(mat3 inMatrix) {float a00=inMatrix[0][0],a01=inMatrix[0][1],a02=inMatrix[0][2];float a10=inMatrix[1][0],a11=inMatrix[1][1],a12=inMatrix[1][2];float a20=inMatrix[2][0],a21=inMatrix[2][1],a22=inMatrix[2][2];float b01=a22*a11-a12*a21;float b11=-a22*a10+a12*a20;float b21=a21*a10-a11*a20;float det=a00*b01+a01*b11+a02*b21;return mat3(b01,(-a22*a01+a02*a21),(a12*a01-a02*a11),
+b11,(a22*a00-a02*a20),(-a12*a00+a02*a10),
+b21,(-a21*a00+a01*a20),(a11*a00-a01*a10))/det;}
+#if USE_EXACT_SRGB_CONVERSIONS
+vec3 toLinearSpaceExact(vec3 color)
+{vec3 nearZeroSection=0.0773993808*color;vec3 remainingSection=pow(0.947867299*(color+vec3(0.055)),vec3(2.4));
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.04045)));
+#else
+return
+vec3(
+color.r<=0.04045 ? nearZeroSection.r : remainingSection.r,
+color.g<=0.04045 ? nearZeroSection.g : remainingSection.g,
+color.b<=0.04045 ? nearZeroSection.b : remainingSection.b);
+#endif
+}
+vec3 toGammaSpaceExact(vec3 color)
+{vec3 nearZeroSection=12.92*color;vec3 remainingSection=1.055*pow(color,vec3(0.41666))-vec3(0.055);
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.0031308)));
+#else
+return
+vec3(
+color.r<=0.0031308 ? nearZeroSection.r : remainingSection.r,
+color.g<=0.0031308 ? nearZeroSection.g : remainingSection.g,
+color.b<=0.0031308 ? nearZeroSection.b : remainingSection.b);
+#endif
+}
+#endif
+float toLinearSpace(float color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+float nearZeroSection=0.0773993808*color;float remainingSection=pow(0.947867299*(color+0.055),2.4);return color<=0.04045 ? nearZeroSection : remainingSection;
+#else
+return pow(color,LinearEncodePowerApprox);
+#endif
+}
+vec3 toLinearSpace(vec3 color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return toLinearSpaceExact(color);
+#else
+return pow(color,vec3(LinearEncodePowerApprox));
+#endif
+}
+vec4 toLinearSpace(vec4 color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return vec4(toLinearSpaceExact(color.rgb),color.a);
+#else
+return vec4(pow(color.rgb,vec3(LinearEncodePowerApprox)),color.a);
+#endif
+}
+float toGammaSpace(float color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+float nearZeroSection=12.92*color;float remainingSection=1.055*pow(color,0.41666)-0.055;return color<=0.0031308 ? nearZeroSection : remainingSection;
+#else
+return pow(color,GammaEncodePowerApprox);
+#endif
+}
+vec3 toGammaSpace(vec3 color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return toGammaSpaceExact(color);
+#else
+return pow(color,vec3(GammaEncodePowerApprox));
+#endif
+}
+vec4 toGammaSpace(vec4 color)
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return vec4(toGammaSpaceExact(color.rgb),color.a);
+#else
+return vec4(pow(color.rgb,vec3(GammaEncodePowerApprox)),color.a);
+#endif
+}
+float square(float value)
+{return value*value;}
+vec3 square(vec3 value)
+{return value*value;}
+float pow5(float value) {float sq=value*value;return sq*sq*value;}
+float getLuminance(vec3 color)
+{return saturate(dot(color,LuminanceEncodeApprox));}
+float getRand(vec2 seed) {return fract(sin(dot(seed.xy ,vec2(12.9898,78.233)))*43758.5453);}
+float dither(vec2 seed,float varianceAmount) {float rand=getRand(seed);float normVariance=varianceAmount/255.0;float dither=mix(-normVariance,normVariance,rand);return dither;}
+const float rgbdMaxRange=255.;vec4 toRGBD(vec3 color) {float maxRGB=maxEps(max(color.r,max(color.g,color.b)));float D =max(rgbdMaxRange/maxRGB,1.);D =saturate(floor(D)/255.);vec3 rgb=color.rgb*D;rgb=toGammaSpace(rgb);return vec4(saturate(rgb),D);}
+vec3 fromRGBD(vec4 rgbd) {rgbd.rgb=toLinearSpace(rgbd.rgb);return rgbd.rgb/rgbd.a;}
+vec3 parallaxCorrectNormal( vec3 vertexPos,vec3 origVec,vec3 cubeSize,vec3 cubePos ) {vec3 invOrigVec=vec3(1.)/origVec;vec3 halfSize=cubeSize*0.5;vec3 intersecAtMaxPlane=(cubePos+halfSize-vertexPos)*invOrigVec;vec3 intersecAtMinPlane=(cubePos-halfSize-vertexPos)*invOrigVec;vec3 largestIntersec=max(intersecAtMaxPlane,intersecAtMinPlane);float distance=min(min(largestIntersec.x,largestIntersec.y),largestIntersec.z);vec3 intersectPositionWS=vertexPos+origVec*distance;return intersectPositionWS-cubePos;}
+vec3 equirectangularToCubemapDirection(vec2 uv) {float longitude=uv.x*TWO_PI-PI;float latitude=HALF_PI-uv.y*PI;vec3 direction;direction.x=cos(latitude)*sin(longitude);direction.y=sin(latitude);direction.z=cos(latitude)*cos(longitude);return direction;}
+float sqrtClamped(float value) {return sqrt(max(value,0.));}
+float avg(vec3 value) {return dot(value,vec3(0.333333333));}`;
+e.IncludesShadersStore[a] || (e.IncludesShadersStore[a] = o);
+//# sourceMappingURL=helperFunctions-Dh1WD8YN.js.map

package/dist/helperFunctions-Dh1WD8YN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helperFunctions-Dh1WD8YN.js","sources":["../node_modules/@babylonjs/core/Shaders/ShadersInclude/helperFunctions.js"],"sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nconst name = \"helperFunctions\";\nconst shader = `const float PI=3.1415926535897932384626433832795;const float TWO_PI=6.283185307179586;const float HALF_PI=1.5707963267948966;const float RECIPROCAL_PI=0.3183098861837907;const float RECIPROCAL_PI2=0.15915494309189535;const float RECIPROCAL_PI4=0.07957747154594767;const float HALF_MIN=5.96046448e-08; \nconst float LinearEncodePowerApprox=2.2;const float GammaEncodePowerApprox=1.0/LinearEncodePowerApprox;const vec3 LuminanceEncodeApprox=vec3(0.2126,0.7152,0.0722);const float Epsilon=0.0000001;\n#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) {vec3 i0=inMatrix[0];vec3 i1=inMatrix[1];vec3 i2=inMatrix[2];mat3 outMatrix=mat3(\nvec3(i0.x,i1.x,i2.x),\nvec3(i0.y,i1.y,i2.y),\nvec3(i0.z,i1.z,i2.z)\n);return outMatrix;}\nmat3 inverseMat3(mat3 inMatrix) {float a00=inMatrix[0][0],a01=inMatrix[0][1],a02=inMatrix[0][2];float a10=inMatrix[1][0],a11=inMatrix[1][1],a12=inMatrix[1][2];float a20=inMatrix[2][0],a21=inMatrix[2][1],a22=inMatrix[2][2];float b01=a22*a11-a12*a21;float b11=-a22*a10+a12*a20;float b21=a21*a10-a11*a20;float det=a00*b01+a01*b11+a02*b21;return mat3(b01,(-a22*a01+a02*a21),(a12*a01-a02*a11),\nb11,(a22*a00-a02*a20),(-a12*a00+a02*a10),\nb21,(-a21*a00+a01*a20),(a11*a00-a01*a10))/det;}\n#if USE_EXACT_SRGB_CONVERSIONS\nvec3 toLinearSpaceExact(vec3 color)\n{vec3 nearZeroSection=0.0773993808*color;vec3 remainingSection=pow(0.947867299*(color+vec3(0.055)),vec3(2.4));\n#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)\nreturn mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.04045)));\n#else\nreturn\nvec3(\ncolor.r<=0.04045 ? nearZeroSection.r : remainingSection.r,\ncolor.g<=0.04045 ? nearZeroSection.g : remainingSection.g,\ncolor.b<=0.04045 ? nearZeroSection.b : remainingSection.b);\n#endif\n}\nvec3 toGammaSpaceExact(vec3 color)\n{vec3 nearZeroSection=12.92*color;vec3 remainingSection=1.055*pow(color,vec3(0.41666))-vec3(0.055);\n#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)\nreturn mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3(0.0031308)));\n#else\nreturn\nvec3(\ncolor.r<=0.0031308 ? nearZeroSection.r : remainingSection.r,\ncolor.g<=0.0031308 ? nearZeroSection.g : remainingSection.g,\ncolor.b<=0.0031308 ? nearZeroSection.b : remainingSection.b);\n#endif\n}\n#endif\nfloat toLinearSpace(float color)\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nfloat nearZeroSection=0.0773993808*color;float remainingSection=pow(0.947867299*(color+0.055),2.4);return color<=0.04045 ? nearZeroSection : remainingSection;\n#else\nreturn pow(color,LinearEncodePowerApprox);\n#endif\n}\nvec3 toLinearSpace(vec3 color)\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nreturn toLinearSpaceExact(color);\n#else\nreturn pow(color,vec3(LinearEncodePowerApprox));\n#endif\n}\nvec4 toLinearSpace(vec4 color)\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nreturn vec4(toLinearSpaceExact(color.rgb),color.a);\n#else\nreturn vec4(pow(color.rgb,vec3(LinearEncodePowerApprox)),color.a);\n#endif\n}\nfloat toGammaSpace(float color)\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nfloat nearZeroSection=12.92*color;float remainingSection=1.055*pow(color,0.41666)-0.055;return color<=0.0031308 ? nearZeroSection : remainingSection;\n#else\nreturn pow(color,GammaEncodePowerApprox);\n#endif\n}\nvec3 toGammaSpace(vec3 color)\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nreturn toGammaSpaceExact(color);\n#else\nreturn pow(color,vec3(GammaEncodePowerApprox));\n#endif\n}\nvec4 toGammaSpace(vec4 color)\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nreturn vec4(toGammaSpaceExact(color.rgb),color.a);\n#else\nreturn vec4(pow(color.rgb,vec3(GammaEncodePowerApprox)),color.a);\n#endif\n}\nfloat square(float value)\n{return value*value;}\nvec3 square(vec3 value)\n{return value*value;}\nfloat pow5(float value) {float sq=value*value;return sq*sq*value;}\nfloat getLuminance(vec3 color)\n{return saturate(dot(color,LuminanceEncodeApprox));}\nfloat getRand(vec2 seed) {return fract(sin(dot(seed.xy ,vec2(12.9898,78.233)))*43758.5453);}\nfloat dither(vec2 seed,float varianceAmount) {float rand=getRand(seed);float normVariance=varianceAmount/255.0;float dither=mix(-normVariance,normVariance,rand);return dither;}\nconst float rgbdMaxRange=255.;vec4 toRGBD(vec3 color) {float maxRGB=maxEps(max(color.r,max(color.g,color.b)));float D =max(rgbdMaxRange/maxRGB,1.);D =saturate(floor(D)/255.);vec3 rgb=color.rgb*D;rgb=toGammaSpace(rgb);return vec4(saturate(rgb),D);}\nvec3 fromRGBD(vec4 rgbd) {rgbd.rgb=toLinearSpace(rgbd.rgb);return rgbd.rgb/rgbd.a;}\nvec3 parallaxCorrectNormal( vec3 vertexPos,vec3 origVec,vec3 cubeSize,vec3 cubePos ) {vec3 invOrigVec=vec3(1.)/origVec;vec3 halfSize=cubeSize*0.5;vec3 intersecAtMaxPlane=(cubePos+halfSize-vertexPos)*invOrigVec;vec3 intersecAtMinPlane=(cubePos-halfSize-vertexPos)*invOrigVec;vec3 largestIntersec=max(intersecAtMaxPlane,intersecAtMinPlane);float distance=min(min(largestIntersec.x,largestIntersec.y),largestIntersec.z);vec3 intersectPositionWS=vertexPos+origVec*distance;return intersectPositionWS-cubePos;}\nvec3 equirectangularToCubemapDirection(vec2 uv) {float longitude=uv.x*TWO_PI-PI;float latitude=HALF_PI-uv.y*PI;vec3 direction;direction.x=cos(latitude)*sin(longitude);direction.y=sin(latitude);direction.z=cos(latitude)*cos(longitude);return direction;}\nfloat sqrtClamped(float value) {return sqrt(max(value,0.));}\nfloat avg(vec3 value) {return dot(value,vec3(0.333333333));}`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStore[name]) {\n    ShaderStore.IncludesShadersStore[name] = shader;\n}\n/** @internal */\nexport const helperFunctions = { name, shader };\n//# sourceMappingURL=helperFunctions.js.map"],"names":["name","shader","ShaderStore"],"mappings":";AAEA,MAAMA,IAAO,mBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwGVC,EAAY,qBAAqBF,CAAI,MACtCE,EAAY,qBAAqBF,CAAI,IAAIC;","x_google_ignoreList":[0]}

package/dist/helperFunctions-ZBnqb-in.js

@@ -0,0 +1,79 @@
+import { S as e } from "./index-ChGTkj2q.js";
+const r = "helperFunctions", a = `const PI: f32=3.1415926535897932384626433832795;const TWO_PI: f32=6.283185307179586;const HALF_PI: f32=1.5707963267948966;const RECIPROCAL_PI: f32=0.3183098861837907;const RECIPROCAL_PI2: f32=0.15915494309189535;const RECIPROCAL_PI4: f32=0.07957747154594767;const HALF_MIN: f32=5.96046448e-08; 
+const LinearEncodePowerApprox: f32=2.2;const GammaEncodePowerApprox: f32=1.0/LinearEncodePowerApprox;const LuminanceEncodeApprox: vec3f=vec3f(0.2126,0.7152,0.0722);const Epsilon:f32=0.0000001;fn square(x: f32)->f32 {return x*x;}
+fn saturate(x: f32)->f32 {return clamp(x,0.0,1.0);}
+fn saturateVec3(x: vec3f)->vec3f {return clamp(x,vec3f(),vec3f(1.0));}
+fn saturateEps(x: f32)->f32 {return clamp(x,Epsilon,1.0);}
+fn maxEps(x: f32)->f32 {return max(x,Epsilon);}
+fn maxEpsVec3(x: vec3f)->vec3f {return max(x,vec3f(Epsilon));}
+fn absEps(x: f32)->f32 {return abs(x)+Epsilon;}
+fn transposeMat3(inMatrix: mat3x3f)->mat3x3f {let i0: vec3f=inMatrix[0];let i1: vec3f=inMatrix[1];let i2: vec3f=inMatrix[2];let outMatrix:mat3x3f=mat3x3f(
+vec3(i0.x,i1.x,i2.x),
+vec3(i0.y,i1.y,i2.y),
+vec3(i0.z,i1.z,i2.z)
+);return outMatrix;}
+fn inverseMat3(inMatrix: mat3x3f)->mat3x3f {let a00: f32=inMatrix[0][0];let a01: f32=inMatrix[0][1];let a02: f32=inMatrix[0][2];let a10: f32=inMatrix[1][0];let a11: f32=inMatrix[1][1];let a12: f32=inMatrix[1][2];let a20: f32=inMatrix[2][0];let a21: f32=inMatrix[2][1];let a22: f32=inMatrix[2][2];let b01: f32=a22*a11-a12*a21;let b11: f32=-a22*a10+a12*a20;let b21: f32=a21*a10-a11*a20;let det: f32=a00*b01+a01*b11+a02*b21;return mat3x3f(b01/det,(-a22*a01+a02*a21)/det,(a12*a01-a02*a11)/det,
+b11/det,(a22*a00-a02*a20)/det,(-a12*a00+a02*a10)/det,
+b21/det,(-a21*a00+a01*a20)/det,(a11*a00-a01*a10)/det);}
+#if USE_EXACT_SRGB_CONVERSIONS
+fn toLinearSpaceExact(color: vec3f)->vec3f
+{let nearZeroSection: vec3f=0.0773993808*color;let remainingSection: vec3f=pow(0.947867299*(color+vec3f(0.055)),vec3f(2.4));return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3f(0.04045)));}
+fn toGammaSpaceExact(color: vec3f)->vec3f
+{let nearZeroSection: vec3f=12.92*color;let remainingSection: vec3f=1.055*pow(color,vec3f(0.41666))-vec3f(0.055);return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3f(0.0031308)));}
+#endif
+fn toLinearSpace(color: f32)->f32
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+var nearZeroSection=0.0773993808*color;var remainingSection=pow(0.947867299*(color+0.055),2.4);return select(remainingSection,nearZeroSection,color<=0.04045);
+#else
+return pow(color,LinearEncodePowerApprox);
+#endif
+}
+fn toLinearSpaceVec3(color: vec3f)->vec3f
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return toLinearSpaceExact(color);
+#else
+return pow(color,vec3f(LinearEncodePowerApprox));
+#endif
+}
+fn toLinearSpaceVec4(color: vec4<f32>)->vec4<f32>
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return vec4f(toLinearSpaceExact(color.rgb),color.a);
+#else
+return vec4f(pow(color.rgb,vec3f(LinearEncodePowerApprox)),color.a);
+#endif
+}
+fn toGammaSpace(color: vec4<f32>)->vec4<f32>
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return vec4<f32>(toGammaSpaceExact(color.rgb),color.a);
+#else
+return vec4<f32>(pow(color.rgb,vec3f(GammaEncodePowerApprox)),color.a);
+#endif
+}
+fn toGammaSpaceVec3(color: vec3f)->vec3f
+{
+#if USE_EXACT_SRGB_CONVERSIONS
+return toGammaSpaceExact(color);
+#else
+return pow(color,vec3f(GammaEncodePowerApprox));
+#endif
+}
+fn squareVec3(value: vec3f)->vec3f
+{return value*value;}
+fn pow5(value: f32)->f32 {let sq: f32=value*value;return sq*sq*value;}
+fn getLuminance(color: vec3f)->f32
+{return saturate(dot(color,LuminanceEncodeApprox));}
+fn getRand(seed: vec2<f32>)->f32 {return fract(sin(dot(seed.xy ,vec2<f32>(12.9898,78.233)))*43758.5453);}
+fn dither(seed: vec2<f32>,varianceAmount: f32)->f32 {let rand: f32=getRand(seed);let normVariance: f32=varianceAmount/255.0;let dither: f32=mix(-normVariance,normVariance,rand);return dither;}
+const rgbdMaxRange: f32=255.0;fn toRGBD(color: vec3f)->vec4<f32> {let maxRGB: f32=max(max(color.r,max(color.g,color.b)),Epsilon);var D: f32 =max(rgbdMaxRange/maxRGB,1.);D =clamp(floor(D)/255.0,0.,1.);var rgb: vec3f =color.rgb*D;rgb=toGammaSpaceVec3(rgb);return vec4<f32>(saturateVec3(rgb),D);}
+fn fromRGBD(rgbd: vec4<f32>)->vec3f {let rgb=toLinearSpaceVec3(rgbd.rgb);return rgb/rgbd.a;}
+fn parallaxCorrectNormal(vertexPos: vec3f,origVec: vec3f,cubeSize: vec3f,cubePos: vec3f)->vec3f {let invOrigVec: vec3f=vec3f(1.)/origVec;let halfSize: vec3f=cubeSize*0.5;let intersecAtMaxPlane: vec3f=(cubePos+halfSize-vertexPos)*invOrigVec;let intersecAtMinPlane: vec3f=(cubePos-halfSize-vertexPos)*invOrigVec;let largestIntersec: vec3f=max(intersecAtMaxPlane,intersecAtMinPlane);let distance: f32=min(min(largestIntersec.x,largestIntersec.y),largestIntersec.z);let intersectPositionWS: vec3f=vertexPos+origVec*distance;return intersectPositionWS-cubePos;}
+fn equirectangularToCubemapDirection(uv : vec2f)->vec3f {var longitude : f32=uv.x*TWO_PI-PI;var latitude : f32=HALF_PI-uv.y*PI;var direction : vec3f;direction.x=cos(latitude)*sin(longitude);direction.y=sin(latitude);direction.z=cos(latitude)*cos(longitude);return direction;}
+fn sqrtClamped(value: f32)->f32 {return sqrt(max(value,0.));}
+fn avg(value: vec3f)->f32 {return dot(value,vec3f(0.333333333));}
+`;
+e.IncludesShadersStoreWGSL[r] || (e.IncludesShadersStoreWGSL[r] = a);
+//# sourceMappingURL=helperFunctions-ZBnqb-in.js.map

package/dist/helperFunctions-ZBnqb-in.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helperFunctions-ZBnqb-in.js","sources":["../node_modules/@babylonjs/core/ShadersWGSL/ShadersInclude/helperFunctions.js"],"sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore.js\";\nconst name = \"helperFunctions\";\nconst shader = `const PI: f32=3.1415926535897932384626433832795;const TWO_PI: f32=6.283185307179586;const HALF_PI: f32=1.5707963267948966;const RECIPROCAL_PI: f32=0.3183098861837907;const RECIPROCAL_PI2: f32=0.15915494309189535;const RECIPROCAL_PI4: f32=0.07957747154594767;const HALF_MIN: f32=5.96046448e-08; \nconst LinearEncodePowerApprox: f32=2.2;const GammaEncodePowerApprox: f32=1.0/LinearEncodePowerApprox;const LuminanceEncodeApprox: vec3f=vec3f(0.2126,0.7152,0.0722);const Epsilon:f32=0.0000001;fn square(x: f32)->f32 {return x*x;}\nfn saturate(x: f32)->f32 {return clamp(x,0.0,1.0);}\nfn saturateVec3(x: vec3f)->vec3f {return clamp(x,vec3f(),vec3f(1.0));}\nfn saturateEps(x: f32)->f32 {return clamp(x,Epsilon,1.0);}\nfn maxEps(x: f32)->f32 {return max(x,Epsilon);}\nfn maxEpsVec3(x: vec3f)->vec3f {return max(x,vec3f(Epsilon));}\nfn absEps(x: f32)->f32 {return abs(x)+Epsilon;}\nfn transposeMat3(inMatrix: mat3x3f)->mat3x3f {let i0: vec3f=inMatrix[0];let i1: vec3f=inMatrix[1];let i2: vec3f=inMatrix[2];let outMatrix:mat3x3f=mat3x3f(\nvec3(i0.x,i1.x,i2.x),\nvec3(i0.y,i1.y,i2.y),\nvec3(i0.z,i1.z,i2.z)\n);return outMatrix;}\nfn inverseMat3(inMatrix: mat3x3f)->mat3x3f {let a00: f32=inMatrix[0][0];let a01: f32=inMatrix[0][1];let a02: f32=inMatrix[0][2];let a10: f32=inMatrix[1][0];let a11: f32=inMatrix[1][1];let a12: f32=inMatrix[1][2];let a20: f32=inMatrix[2][0];let a21: f32=inMatrix[2][1];let a22: f32=inMatrix[2][2];let b01: f32=a22*a11-a12*a21;let b11: f32=-a22*a10+a12*a20;let b21: f32=a21*a10-a11*a20;let det: f32=a00*b01+a01*b11+a02*b21;return mat3x3f(b01/det,(-a22*a01+a02*a21)/det,(a12*a01-a02*a11)/det,\nb11/det,(a22*a00-a02*a20)/det,(-a12*a00+a02*a10)/det,\nb21/det,(-a21*a00+a01*a20)/det,(a11*a00-a01*a10)/det);}\n#if USE_EXACT_SRGB_CONVERSIONS\nfn toLinearSpaceExact(color: vec3f)->vec3f\n{let nearZeroSection: vec3f=0.0773993808*color;let remainingSection: vec3f=pow(0.947867299*(color+vec3f(0.055)),vec3f(2.4));return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3f(0.04045)));}\nfn toGammaSpaceExact(color: vec3f)->vec3f\n{let nearZeroSection: vec3f=12.92*color;let remainingSection: vec3f=1.055*pow(color,vec3f(0.41666))-vec3f(0.055);return mix(remainingSection,nearZeroSection,lessThanEqual(color,vec3f(0.0031308)));}\n#endif\nfn toLinearSpace(color: f32)->f32\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nvar nearZeroSection=0.0773993808*color;var remainingSection=pow(0.947867299*(color+0.055),2.4);return select(remainingSection,nearZeroSection,color<=0.04045);\n#else\nreturn pow(color,LinearEncodePowerApprox);\n#endif\n}\nfn toLinearSpaceVec3(color: vec3f)->vec3f\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nreturn toLinearSpaceExact(color);\n#else\nreturn pow(color,vec3f(LinearEncodePowerApprox));\n#endif\n}\nfn toLinearSpaceVec4(color: vec4<f32>)->vec4<f32>\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nreturn vec4f(toLinearSpaceExact(color.rgb),color.a);\n#else\nreturn vec4f(pow(color.rgb,vec3f(LinearEncodePowerApprox)),color.a);\n#endif\n}\nfn toGammaSpace(color: vec4<f32>)->vec4<f32>\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nreturn vec4<f32>(toGammaSpaceExact(color.rgb),color.a);\n#else\nreturn vec4<f32>(pow(color.rgb,vec3f(GammaEncodePowerApprox)),color.a);\n#endif\n}\nfn toGammaSpaceVec3(color: vec3f)->vec3f\n{\n#if USE_EXACT_SRGB_CONVERSIONS\nreturn toGammaSpaceExact(color);\n#else\nreturn pow(color,vec3f(GammaEncodePowerApprox));\n#endif\n}\nfn squareVec3(value: vec3f)->vec3f\n{return value*value;}\nfn pow5(value: f32)->f32 {let sq: f32=value*value;return sq*sq*value;}\nfn getLuminance(color: vec3f)->f32\n{return saturate(dot(color,LuminanceEncodeApprox));}\nfn getRand(seed: vec2<f32>)->f32 {return fract(sin(dot(seed.xy ,vec2<f32>(12.9898,78.233)))*43758.5453);}\nfn dither(seed: vec2<f32>,varianceAmount: f32)->f32 {let rand: f32=getRand(seed);let normVariance: f32=varianceAmount/255.0;let dither: f32=mix(-normVariance,normVariance,rand);return dither;}\nconst rgbdMaxRange: f32=255.0;fn toRGBD(color: vec3f)->vec4<f32> {let maxRGB: f32=max(max(color.r,max(color.g,color.b)),Epsilon);var D: f32 =max(rgbdMaxRange/maxRGB,1.);D =clamp(floor(D)/255.0,0.,1.);var rgb: vec3f =color.rgb*D;rgb=toGammaSpaceVec3(rgb);return vec4<f32>(saturateVec3(rgb),D);}\nfn fromRGBD(rgbd: vec4<f32>)->vec3f {let rgb=toLinearSpaceVec3(rgbd.rgb);return rgb/rgbd.a;}\nfn parallaxCorrectNormal(vertexPos: vec3f,origVec: vec3f,cubeSize: vec3f,cubePos: vec3f)->vec3f {let invOrigVec: vec3f=vec3f(1.)/origVec;let halfSize: vec3f=cubeSize*0.5;let intersecAtMaxPlane: vec3f=(cubePos+halfSize-vertexPos)*invOrigVec;let intersecAtMinPlane: vec3f=(cubePos-halfSize-vertexPos)*invOrigVec;let largestIntersec: vec3f=max(intersecAtMaxPlane,intersecAtMinPlane);let distance: f32=min(min(largestIntersec.x,largestIntersec.y),largestIntersec.z);let intersectPositionWS: vec3f=vertexPos+origVec*distance;return intersectPositionWS-cubePos;}\nfn equirectangularToCubemapDirection(uv : vec2f)->vec3f {var longitude : f32=uv.x*TWO_PI-PI;var latitude : f32=HALF_PI-uv.y*PI;var direction : vec3f;direction.x=cos(latitude)*sin(longitude);direction.y=sin(latitude);direction.z=cos(latitude)*cos(longitude);return direction;}\nfn sqrtClamped(value: f32)->f32 {return sqrt(max(value,0.));}\nfn avg(value: vec3f)->f32 {return dot(value,vec3f(0.333333333));}\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const helperFunctionsWGSL = { name, shader };\n//# sourceMappingURL=helperFunctions.js.map"],"names":["name","shader","ShaderStore"],"mappings":";AAEA,MAAMA,IAAO,mBACPC,IAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6EVC,EAAY,yBAAyBF,CAAI,MAC1CE,EAAY,yBAAyBF,CAAI,IAAIC;","x_google_ignoreList":[0]}

package/dist/iesTextureLoader-JdfAyRK-.js

@@ -0,0 +1,94 @@
+import { L as p } from "./index-ChGTkj2q.js";
+function O(t) {
+  return t.split(" ").filter((s) => s !== "").map((s) => parseFloat(s));
+}
+function x(t, s, o) {
+  for (; o.length !== s; ) {
+    const n = O(t.lines[t.index++]);
+    o.push(...n);
+  }
+}
+function V(t, s, o) {
+  let n = 0, e = 0, r = 0, u = 0, f = 0, h = 0;
+  for (let i = 0; i < t.numberOfHorizontalAngles - 1; i++)
+    if (o < t.horizontalAngles[i + 1] || i === t.numberOfHorizontalAngles - 2) {
+      e = i, r = t.horizontalAngles[i], u = t.horizontalAngles[i + 1];
+      break;
+    }
+  for (let i = 0; i < t.numberOfVerticalAngles - 1; i++)
+    if (s < t.verticalAngles[i + 1] || i === t.numberOfVerticalAngles - 2) {
+      n = i, f = t.verticalAngles[i], h = t.verticalAngles[i + 1];
+      break;
+    }
+  const c = u - r, A = h - f;
+  if (A === 0)
+    return 0;
+  const g = c === 0 ? 0 : (o - r) / c, b = (s - f) / A, d = c === 0 ? e : e + 1, l = p(t.candelaValues[e][n], t.candelaValues[d][n], g), a = p(t.candelaValues[e][n + 1], t.candelaValues[d][n + 1], g);
+  return p(l, a, b);
+}
+function z(t) {
+  const n = {
+    lines: new TextDecoder("utf-8").decode(t).split(`
+`),
+    index: 0
+  }, e = { version: n.lines[0], candelaValues: [], horizontalAngles: [], verticalAngles: [], numberOfHorizontalAngles: 0, numberOfVerticalAngles: 0 };
+  for (n.index = 1; n.lines.length > 0 && !n.lines[n.index].includes("TILT="); )
+    n.index++;
+  n.lines[n.index].includes("INCLUDE"), n.index++;
+  const r = O(n.lines[n.index++]);
+  e.numberOfLights = r[0], e.lumensPerLamp = r[1], e.candelaMultiplier = r[2], e.numberOfVerticalAngles = r[3], e.numberOfHorizontalAngles = r[4], e.photometricType = r[5], e.unitsType = r[6], e.width = r[7], e.length = r[8], e.height = r[9];
+  const u = O(n.lines[n.index++]);
+  e.ballastFactor = u[0], e.fileGenerationType = u[1], e.inputWatts = u[2];
+  for (let l = 0; l < e.numberOfHorizontalAngles; l++)
+    e.candelaValues[l] = [];
+  x(n, e.numberOfVerticalAngles, e.verticalAngles), x(n, e.numberOfHorizontalAngles, e.horizontalAngles);
+  for (let l = 0; l < e.numberOfHorizontalAngles; l++)
+    x(n, e.numberOfVerticalAngles, e.candelaValues[l]);
+  let f = -1;
+  for (let l = 0; l < e.numberOfHorizontalAngles; l++)
+    for (let a = 0; a < e.numberOfVerticalAngles; a++)
+      e.candelaValues[l][a] *= e.candelaValues[l][a] * e.candelaMultiplier * e.ballastFactor * e.fileGenerationType, f = Math.max(f, e.candelaValues[l][a]);
+  if (f > 0)
+    for (let l = 0; l < e.numberOfHorizontalAngles; l++)
+      for (let a = 0; a < e.numberOfVerticalAngles; a++)
+        e.candelaValues[l][a] /= f;
+  const h = 180, c = h * 2, A = c * h, g = new Float32Array(c * h), b = e.horizontalAngles[0], d = e.horizontalAngles[e.numberOfHorizontalAngles - 1];
+  for (let l = 0; l < A; l++) {
+    let a = l % c;
+    const m = Math.floor(l / c);
+    d - b !== 0 && (a < b || a >= d) && (a %= d * 2, a > d && (a = d * 2 - a)), g[m + a * h] = V(e, m, a);
+  }
+  return {
+    width: c / 2,
+    height: 1,
+    data: g
+  };
+}
+class y {
+  constructor() {
+    this.supportCascades = !1;
+  }
+  /**
+   * Uploads the cube texture data to the WebGL texture. It has already been bound.
+   */
+  loadCubeData() {
+    throw ".ies not supported in Cube.";
+  }
+  /**
+   * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.
+   * @param data contains the texture data
+   * @param texture defines the BabylonJS internal texture
+   * @param callback defines the method to call once ready to upload
+   */
+  loadData(s, o, n) {
+    const e = new Uint8Array(s.buffer, s.byteOffset, s.byteLength), r = z(e);
+    n(r.width, r.height, !1, !1, () => {
+      const u = o.getEngine();
+      o.type = 1, o.format = 6, o._gammaSpace = !1, u._uploadDataToTextureDirectly(o, r.data);
+    });
+  }
+}
+export {
+  y as _IESTextureLoader
+};
+//# sourceMappingURL=iesTextureLoader-JdfAyRK-.js.map

package/dist/iesTextureLoader-JdfAyRK-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iesTextureLoader-JdfAyRK-.js","sources":["../node_modules/@babylonjs/core/Lights/IES/iesLoader.js","../node_modules/@babylonjs/core/Materials/Textures/Loaders/iesTextureLoader.js"],"sourcesContent":["import { Lerp } from \"../../Maths/math.scalar.functions.js\";\nfunction LineToArray(line) {\n    return line\n        .split(\" \")\n        .filter((x) => x !== \"\")\n        .map((x) => parseFloat(x));\n}\nfunction ReadArray(dataPointer, count, targetArray) {\n    while (targetArray.length !== count) {\n        const line = LineToArray(dataPointer.lines[dataPointer.index++]);\n        targetArray.push(...line);\n    }\n}\nfunction InterpolateCandelaValues(data, phi, theta) {\n    let phiIndex = 0;\n    let thetaIndex = 0;\n    let startTheta = 0;\n    let endTheta = 0;\n    let startPhi = 0;\n    let endPhi = 0;\n    // Check if the angle is outside the range\n    for (let index = 0; index < data.numberOfHorizontalAngles - 1; index++) {\n        if (theta < data.horizontalAngles[index + 1] || index === data.numberOfHorizontalAngles - 2) {\n            thetaIndex = index;\n            startTheta = data.horizontalAngles[index];\n            endTheta = data.horizontalAngles[index + 1];\n            break;\n        }\n    }\n    for (let index = 0; index < data.numberOfVerticalAngles - 1; index++) {\n        if (phi < data.verticalAngles[index + 1] || index === data.numberOfVerticalAngles - 2) {\n            phiIndex = index;\n            startPhi = data.verticalAngles[index];\n            endPhi = data.verticalAngles[index + 1];\n            break;\n        }\n    }\n    const deltaTheta = endTheta - startTheta;\n    const deltaPhi = endPhi - startPhi;\n    if (deltaPhi === 0) {\n        return 0;\n    }\n    // Interpolate\n    const t1 = deltaTheta === 0 ? 0 : (theta - startTheta) / deltaTheta;\n    const t2 = (phi - startPhi) / deltaPhi;\n    const nextThetaIndex = deltaTheta === 0 ? thetaIndex : thetaIndex + 1;\n    const v1 = Lerp(data.candelaValues[thetaIndex][phiIndex], data.candelaValues[nextThetaIndex][phiIndex], t1);\n    const v2 = Lerp(data.candelaValues[thetaIndex][phiIndex + 1], data.candelaValues[nextThetaIndex][phiIndex + 1], t1);\n    const v = Lerp(v1, v2, t2);\n    return v;\n}\n/**\n * Generates IES data buffer from a string representing the IES data.\n * @param uint8Array defines the IES data\n * @returns the IES data buffer\n * @see https://ieslibrary.com/browse\n * @see https://playground.babylonjs.com/#UQGPDT#1\n */\nexport function LoadIESData(uint8Array) {\n    const decoder = new TextDecoder(\"utf-8\");\n    const source = decoder.decode(uint8Array);\n    // Read data\n    const dataPointer = {\n        lines: source.split(\"\\n\"),\n        index: 0,\n    };\n    const data = { version: dataPointer.lines[0], candelaValues: [], horizontalAngles: [], verticalAngles: [], numberOfHorizontalAngles: 0, numberOfVerticalAngles: 0 };\n    // Skip metadata\n    dataPointer.index = 1;\n    while (dataPointer.lines.length > 0 && !dataPointer.lines[dataPointer.index].includes(\"TILT=\")) {\n        dataPointer.index++;\n    }\n    // Process tilt data?\n    if (dataPointer.lines[dataPointer.index].includes(\"INCLUDE\")) {\n        // Not supported yet as I did not manage to find an example :)\n    }\n    dataPointer.index++;\n    // Header\n    const header = LineToArray(dataPointer.lines[dataPointer.index++]);\n    data.numberOfLights = header[0];\n    data.lumensPerLamp = header[1];\n    data.candelaMultiplier = header[2];\n    data.numberOfVerticalAngles = header[3];\n    data.numberOfHorizontalAngles = header[4];\n    data.photometricType = header[5]; // We ignore cylindrical type for now. Will add support later if needed\n    data.unitsType = header[6];\n    data.width = header[7];\n    data.length = header[8];\n    data.height = header[9];\n    // Additional data\n    const additionalData = LineToArray(dataPointer.lines[dataPointer.index++]);\n    data.ballastFactor = additionalData[0];\n    data.fileGenerationType = additionalData[1];\n    data.inputWatts = additionalData[2];\n    // Prepare arrays\n    for (let index = 0; index < data.numberOfHorizontalAngles; index++) {\n        data.candelaValues[index] = [];\n    }\n    // Vertical angles\n    ReadArray(dataPointer, data.numberOfVerticalAngles, data.verticalAngles);\n    // Horizontal angles\n    ReadArray(dataPointer, data.numberOfHorizontalAngles, data.horizontalAngles);\n    // Candela values\n    for (let index = 0; index < data.numberOfHorizontalAngles; index++) {\n        ReadArray(dataPointer, data.numberOfVerticalAngles, data.candelaValues[index]);\n    }\n    // Evaluate candela values\n    let maxCandela = -1;\n    for (let index = 0; index < data.numberOfHorizontalAngles; index++) {\n        for (let subIndex = 0; subIndex < data.numberOfVerticalAngles; subIndex++) {\n            data.candelaValues[index][subIndex] *= data.candelaValues[index][subIndex] * data.candelaMultiplier * data.ballastFactor * data.fileGenerationType;\n            maxCandela = Math.max(maxCandela, data.candelaValues[index][subIndex]);\n        }\n    }\n    // Normalize candela values\n    if (maxCandela > 0) {\n        for (let index = 0; index < data.numberOfHorizontalAngles; index++) {\n            for (let subIndex = 0; subIndex < data.numberOfVerticalAngles; subIndex++) {\n                data.candelaValues[index][subIndex] /= maxCandela;\n            }\n        }\n    }\n    // Create the cylindrical texture\n    const height = 180;\n    const width = height * 2;\n    const size = width * height;\n    const arrayBuffer = new Float32Array(width * height);\n    // Fill the texture\n    const startTheta = data.horizontalAngles[0];\n    const endTheta = data.horizontalAngles[data.numberOfHorizontalAngles - 1];\n    for (let index = 0; index < size; index++) {\n        let theta = index % width;\n        const phi = Math.floor(index / width);\n        // Symmetry\n        if (endTheta - startTheta !== 0 && (theta < startTheta || theta >= endTheta)) {\n            theta %= endTheta * 2;\n            if (theta > endTheta) {\n                theta = endTheta * 2 - theta;\n            }\n        }\n        arrayBuffer[phi + theta * height] = InterpolateCandelaValues(data, phi, theta);\n    }\n    // So far we only need the first half of the first row of the texture as we only support IES for spot light. We can add support for other types later.\n    return {\n        width: width / 2,\n        height: 1,\n        data: arrayBuffer,\n    };\n}\n//# sourceMappingURL=iesLoader.js.map","\nimport { LoadIESData } from \"../../../Lights/IES/iesLoader.js\";\n/**\n * Implementation of the IES Texture Loader.\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport class _IESTextureLoader {\n    constructor() {\n        /**\n         * Defines whether the loader supports cascade loading the different faces.\n         */\n        this.supportCascades = false;\n    }\n    /**\n     * Uploads the cube texture data to the WebGL texture. It has already been bound.\n     */\n    loadCubeData() {\n        // eslint-disable-next-line no-throw-literal\n        throw \".ies not supported in Cube.\";\n    }\n    /**\n     * Uploads the 2D texture data to the WebGL texture. It has already been bound once in the callback.\n     * @param data contains the texture data\n     * @param texture defines the BabylonJS internal texture\n     * @param callback defines the method to call once ready to upload\n     */\n    loadData(data, texture, callback) {\n        const uint8array = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n        const textureData = LoadIESData(uint8array);\n        callback(textureData.width, textureData.height, false, false, () => {\n            const engine = texture.getEngine();\n            texture.type = 1;\n            texture.format = 6;\n            texture._gammaSpace = false;\n            engine._uploadDataToTextureDirectly(texture, textureData.data);\n        });\n    }\n}\n//# sourceMappingURL=iesTextureLoader.js.map"],"names":["LineToArray","line","x","ReadArray","dataPointer","count","targetArray","InterpolateCandelaValues","data","phi","theta","phiIndex","thetaIndex","startTheta","endTheta","startPhi","endPhi","index","deltaTheta","deltaPhi","t1","t2","nextThetaIndex","v1","Lerp","v2","LoadIESData","uint8Array","header","additionalData","maxCandela","subIndex","height","width","size","arrayBuffer","_IESTextureLoader","texture","callback","uint8array","textureData","engine"],"mappings":"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","x_google_ignoreList":[0,1]}