@vived/component-abb-6700 1.0.0

package/dist/harmonicsFunctions-PEz6APC7.js

@@ -0,0 +1,18 @@
+import { b0 as r } from "./index-CS3Icp_r.js";
+const a = "harmonicsFunctions", e = `#ifdef USESPHERICALFROMREFLECTIONMAP
+#ifdef SPHERICAL_HARMONICS
+fn computeEnvironmentIrradiance(normal: vec3f)->vec3f {return uniforms.vSphericalL00
++ uniforms.vSphericalL1_1*(normal.y)
++ uniforms.vSphericalL10*(normal.z)
++ uniforms.vSphericalL11*(normal.x)
++ uniforms.vSphericalL2_2*(normal.y*normal.x)
++ uniforms.vSphericalL2_1*(normal.y*normal.z)
++ uniforms.vSphericalL20*((3.0*normal.z*normal.z)-1.0)
++ uniforms.vSphericalL21*(normal.z*normal.x)
++ uniforms.vSphericalL22*(normal.x*normal.x-(normal.y*normal.y));}
+#else
+fn computeEnvironmentIrradiance(normal: vec3f)->vec3f {var Nx: f32=normal.x;var Ny: f32=normal.y;var Nz: f32=normal.z;var C1: vec3f=uniforms.vSphericalZZ.rgb;var Cx: vec3f=uniforms.vSphericalX.rgb;var Cy: vec3f=uniforms.vSphericalY.rgb;var Cz: vec3f=uniforms.vSphericalZ.rgb;var Cxx_zz: vec3f=uniforms.vSphericalXX_ZZ.rgb;var Cyy_zz: vec3f=uniforms.vSphericalYY_ZZ.rgb;var Cxy: vec3f=uniforms.vSphericalXY.rgb;var Cyz: vec3f=uniforms.vSphericalYZ.rgb;var Czx: vec3f=uniforms.vSphericalZX.rgb;var a1: vec3f=Cyy_zz*Ny+Cy;var a2: vec3f=Cyz*Nz+a1;var b1: vec3f=Czx*Nz+Cx;var b2: vec3f=Cxy*Ny+b1;var b3: vec3f=Cxx_zz*Nx+b2;var t1: vec3f=Cz *Nz+C1;var t2: vec3f=a2 *Ny+t1;var t3: vec3f=b3 *Nx+t2;return t3;}
+#endif
+#endif
+`;
+r.IncludesShadersStoreWGSL[a] || (r.IncludesShadersStoreWGSL[a] = e);

package/dist/hdrTextureLoader-D9rYxJ9q.js

@@ -0,0 +1,112 @@
+import "./index-CS3Icp_r.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, s, r, i, n) {
+  i > 0 ? (i = m(1, i - 136), t[n + 0] = e * i, t[n + 1] = s * i, t[n + 2] = r * i) : (t[n + 0] = 0, t[n + 1] = 0, t[n + 2] = 0);
+}
+function g(t, e) {
+  let s = "", r;
+  for (let i = e; i < t.length - e && (r = String.fromCharCode(t[i]), r != `
+`); i++)
+    s += r;
+  return s;
+}
+function D(t) {
+  let e = g(t, 0);
+  if (e[0] != "#" || e[1] != "?")
+    throw "Bad HDR Format.";
+  let s = !1, r = !1, i = 0;
+  do
+    i += e.length + 1, e = g(t, i), e == "FORMAT=32-bit_rle_rgbe" ? r = !0 : e.length == 0 && (s = !0);
+  while (!s);
+  if (!r)
+    throw "HDR Bad header format, unsupported FORMAT";
+  i += e.length + 1, e = g(t, i);
+  const o = /^-Y (.*) \+X (.*)$/g.exec(e);
+  if (!o || o.length < 3)
+    throw "HDR Bad header format, no size";
+  const h = parseInt(o[2]), l = parseInt(o[1]);
+  if (h < 8 || h > 32767)
+    throw "HDR Bad header format, unsupported size";
+  return i += e.length + 1, {
+    height: l,
+    width: h,
+    dataPosition: i
+  };
+}
+function b(t, e) {
+  return H(t, e);
+}
+function H(t, e) {
+  let s = e.height;
+  const r = e.width;
+  let i, n, o, h, l, a = e.dataPosition, f, d, c;
+  const B = new ArrayBuffer(r * 4), w = new Uint8Array(B), A = new ArrayBuffer(e.width * e.height * 4 * 3), u = new Float32Array(A);
+  for (; s > 0; ) {
+    if (i = t[a++], n = t[a++], o = t[a++], h = t[a++], i != 2 || n != 2 || o & 128 || e.width < 8 || e.width > 32767)
+      return F(t, e);
+    if ((o << 8 | h) != r)
+      throw "HDR Bad header format, wrong scan line width";
+    for (f = 0, c = 0; c < 4; c++)
+      for (d = (c + 1) * r; f < d; )
+        if (i = t[a++], n = t[a++], i > 128) {
+          if (l = i - 128, l == 0 || l > d - f)
+            throw "HDR Bad Format, bad scanline data (run)";
+          for (; l-- > 0; )
+            w[f++] = n;
+        } else {
+          if (l = i, l == 0 || l > d - f)
+            throw "HDR Bad Format, bad scanline data (non-run)";
+          if (w[f++] = n, --l > 0)
+            for (let R = 0; R < l; R++)
+              w[f++] = t[a++];
+        }
+    for (c = 0; c < r; c++)
+      i = w[c], n = w[c + r], o = w[c + 2 * r], h = w[c + 3 * r], p(u, i, n, o, h, (e.height - s) * r * 3 + c * 3);
+    s--;
+  }
+  return u;
+}
+function F(t, e) {
+  let s = e.height;
+  const r = e.width;
+  let i, n, o, h, l, a = e.dataPosition;
+  const f = new ArrayBuffer(e.width * e.height * 4 * 3), d = new Float32Array(f);
+  for (; s > 0; ) {
+    for (l = 0; l < e.width; l++)
+      i = t[a++], n = t[a++], o = t[a++], h = t[a++], p(d, i, n, o, h, (e.height - s) * r * 3 + l * 3);
+    s--;
+  }
+  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, s, r) {
+    const i = new Uint8Array(e.buffer, e.byteOffset, e.byteLength), n = D(i), o = b(i, n), h = n.width * n.height, l = new Float32Array(h * 4);
+    for (let a = 0; a < h; a += 1)
+      l[a * 4] = o[a * 3], l[a * 4 + 1] = o[a * 3 + 1], l[a * 4 + 2] = o[a * 3 + 2], l[a * 4 + 3] = 1;
+    r(n.width, n.height, s.generateMipMaps, !1, () => {
+      const a = s.getEngine();
+      s.type = 1, s.format = 5, s._gammaSpace = !1, a._uploadDataToTextureDirectly(s, l);
+    });
+  }
+}
+export {
+  L as _HDRTextureLoader
+};

package/dist/helperFunctions-Bt7Zfkrp.js

@@ -0,0 +1,89 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const r = "helperFunctions", t = `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 double_refract(I: vec3f,N: vec3f,eta: f32)->vec3f {let Tfront: vec3f=refract(I,N,1.0/eta);let Nback: vec3f=normalize(reflect(N,Tfront));return refract(Tfront,-Nback,eta);}
+fn getLuminanceUnclamped(color: vec3f)->f32
+{return dot(color,LuminanceEncodeApprox);}
+fn getLuminance(color: vec3f)->f32
+{return saturate(getLuminanceUnclamped(color));}
+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));}
+fn singleScatterToMultiScatterAlbedo(rho_ss: vec3f)->vec3f {let s: vec3f=sqrt(max(vec3f(1.0)-rho_ss,vec3f(0.0)));return (vec3f(1.0)-s)*(vec3f(1.0)-vec3f(0.139)*s)/(vec3f(1.0)+vec3f(1.17)*s);}
+fn multiScatterToSingleScatterAlbedo(rho_ms: vec3f)->vec3f {let s: vec3f=4.09712f+4.20863f*rho_ms-sqrt(9.59217f+41.6808f*rho_ms+17.7126f*rho_ms*rho_ms);return 1.0f-s*s;}
+fn multiScatterToSingleScatterAlbedoWithAniso(rho_ms: vec3f,aniso: f32)->vec3f {let s: vec3f=4.09712+4.20863f*rho_ms-sqrt(9.59217f+41.6808f*rho_ms+17.7126f*rho_ms*rho_ms);return (vec3f(1.0f)-s*s)/maxEpsVec3(vec3f(1.0f)-vec3f(aniso)*s*s);}
+fn min3(v: vec3f)->f32 {return min(v.x,min(v.y,v.z));}
+fn max3(v: vec3f)->f32 {return max(v.x,max(v.y,v.z));}
+fn uint2float(i: u32)->f32 {return bitcast<f32>(0x3F800000u | (i>>9u))-1.0;}
+fn plasticSequence(rstate: u32)->vec2f {return vec2f(uint2float(rstate*3242174889u),
+uint2float(rstate*2447445414u));}
+`;
+e.IncludesShadersStoreWGSL[r] || (e.IncludesShadersStoreWGSL[r] = t);

package/dist/helperFunctions-CPmRxd37.js

@@ -0,0 +1,121 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const o = "helperFunctions", r = `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;}
+vec3 double_refract(vec3 I,vec3 N,float eta) {vec3 Tfront=refract(I,N,1.0/eta);vec3 Nback=normalize(reflect(N,Tfront));return refract(Tfront,-Nback,eta);}
+float getLuminanceUnclamped(vec3 color)
+{return dot(color,LuminanceEncodeApprox);}
+float getLuminance(vec3 color)
+{return saturate(getLuminanceUnclamped(color));}
+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));}
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE) 
+uint extractBits(uint value,int offset,int width) {return (value>>offset) & ((1u<<width)-1u);}
+int onlyBitPosition(uint value) {return (floatBitsToInt(float(value))>>23)-0x7f;}
+vec3 singleScatterToMultiScatterAlbedo(vec3 rho_ss) {vec3 s=sqrt(max(vec3(1.0)-rho_ss,vec3(0.0)));return (vec3(1.0)-s)*(vec3(1.0)-vec3(0.139)*s)/(vec3(1.0)+vec3(1.17)*s);}
+vec3 multiScatterToSingleScatterAlbedo(vec3 rho_ms) {vec3 s=4.09712+4.20863*rho_ms-sqrt(9.59217+41.6808*rho_ms+17.7126*rho_ms*rho_ms);return 1.0-s*s;}
+vec3 multiScatterToSingleScatterAlbedo(vec3 rho_ms,float aniso) {vec3 s=4.09712+4.20863*rho_ms-sqrt(9.59217+41.6808*rho_ms+17.7126*rho_ms*rho_ms);return (1.0-s*s)/maxEps(1.0-aniso*s*s);}
+float min3(vec3 v) {return min(v.x,min(v.y,v.z));}
+float max3(vec3 v) {return max(v.x,max(v.y,v.z));}
+float uint2float(uint i) {return uintBitsToFloat(0x3F800000u | (i>>9u))-1.0;}
+vec2 plasticSequence(const uint rstate) {return vec2(uint2float(rstate*3242174889u),
+uint2float(rstate*2447445414u));}
+#endif
+`;
+e.IncludesShadersStore[o] || (e.IncludesShadersStore[o] = r);

package/dist/iesTextureLoader-BGUFjVhI.js

@@ -0,0 +1,93 @@
+import { a5 as p } from "./index-CS3Icp_r.js";
+function O(t) {
+  return t.split(" ").filter((r) => r !== "").map((r) => parseFloat(r));
+}
+function x(t, r, o) {
+  for (; o.length !== r; ) {
+    const n = O(t.lines[t.index++]);
+    o.push(...n);
+  }
+}
+function V(t, r, o) {
+  let n = 0, e = 0, i = 0, u = 0, f = 0, h = 0;
+  for (let s = 0; s < t.numberOfHorizontalAngles - 1; s++)
+    if (o < t.horizontalAngles[s + 1] || s === t.numberOfHorizontalAngles - 2) {
+      e = s, i = t.horizontalAngles[s], u = t.horizontalAngles[s + 1];
+      break;
+    }
+  for (let s = 0; s < t.numberOfVerticalAngles - 1; s++)
+    if (r < t.verticalAngles[s + 1] || s === t.numberOfVerticalAngles - 2) {
+      n = s, f = t.verticalAngles[s], h = t.verticalAngles[s + 1];
+      break;
+    }
+  const c = u - i, A = h - f;
+  if (A === 0)
+    return 0;
+  const g = c === 0 ? 0 : (o - i) / c, b = (r - 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 i = O(n.lines[n.index++]);
+  e.numberOfLights = i[0], e.lumensPerLamp = i[1], e.candelaMultiplier = i[2], e.numberOfVerticalAngles = i[3], e.numberOfHorizontalAngles = i[4], e.photometricType = i[5], e.unitsType = i[6], e.width = i[7], e.length = i[8], e.height = i[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(r, o, n) {
+    const e = new Uint8Array(r.buffer, r.byteOffset, r.byteLength), i = z(e);
+    n(i.width, i.height, !!o.useMipMaps, !1, () => {
+      const u = o.getEngine();
+      o.type = 1, o.format = 6, o._gammaSpace = !1, u._uploadDataToTextureDirectly(o, i.data);
+    });
+  }
+}
+export {
+  y as _IESTextureLoader
+};