python-cad-tools 0.1.0rc1__py3-none-any.whl

python_cad_tools/_viewer_static/assets/glowMapGeneration.fragment-DcyS1cTF.js

@@ -0,0 +1,63 @@
+import{S as e}from"./index-B2zBEWsq.js";import{h as f}from"./helperFunctions-Cugfp1Fz.js";import{c as o,a as n}from"./clipPlaneFragment-BXRtt4jj.js";const i="glowMapGenerationPixelShader",r=`#if defined(DIFFUSE_ISLINEAR) || defined(EMISSIVE_ISLINEAR)
+#include<helperFunctions>
+#endif
+#ifdef DIFFUSE
+varying vUVDiffuse: vec2f;var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;
+#endif
+#ifdef OPACITY
+varying vUVOpacity: vec2f;var opacitySamplerSampler: sampler;var opacitySampler: texture_2d<f32>;uniform opacityIntensity: f32;
+#endif
+#ifdef EMISSIVE
+varying vUVEmissive: vec2f;var emissiveSamplerSampler: sampler;var emissiveSampler: texture_2d<f32>;
+#endif
+#ifdef VERTEXALPHA
+varying vColor: vec4f;
+#endif
+uniform glowColor: vec4f;uniform glowIntensity: f32;
+#include<clipPlaneFragmentDeclaration>
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {
+#include<clipPlaneFragment>
+var finalColor: vec4f=uniforms.glowColor;
+#ifdef DIFFUSE
+var albedoTexture: vec4f=textureSample(diffuseSampler,diffuseSamplerSampler,fragmentInputs.vUVDiffuse);
+#ifdef DIFFUSE_ISLINEAR
+albedoTexture=toGammaSpace(albedoTexture);
+#endif
+#ifdef GLOW
+finalColor=vec4f(finalColor.rgb,finalColor.a*albedoTexture.a);
+#endif
+#ifdef HIGHLIGHT
+finalColor=vec4f(finalColor.rgb,albedoTexture.a);
+#endif
+#endif
+#ifdef OPACITY
+var opacityMap: vec4f=textureSample(opacitySampler,opacitySamplerSampler,fragmentInputs.vUVOpacity);
+#ifdef OPACITYRGB
+finalColor=vec4f(finalColor.rgb,finalColor.a*getLuminance(opacityMap.rgb));
+#else
+finalColor=vec4f(finalColor.rgb,finalColor.a*opacityMap.a);
+#endif
+finalColor=vec4f(finalColor.rgb,finalColor.a*uniforms.opacityIntensity);
+#endif
+#ifdef VERTEXALPHA
+finalColor=vec4f(finalColor.rgb,finalColor.a*fragmentInputs.vColor.a);
+#endif
+#ifdef ALPHATEST
+if (finalColor.a<ALPHATESTVALUE) {discard;}
+#endif
+#ifdef EMISSIVE
+var emissive: vec4f=textureSample(emissiveSampler,emissiveSamplerSampler,fragmentInputs.vUVEmissive);
+#ifdef EMISSIVE_ISLINEAR
+emissive=toGammaSpace(emissive);
+#endif
+fragmentOutputs.color=emissive*finalColor*uniforms.glowIntensity;
+#else
+fragmentOutputs.color=finalColor*uniforms.glowIntensity;
+#endif
+#ifdef HIGHLIGHT
+fragmentOutputs.color=vec4f(fragmentOutputs.color.rgb,uniforms.glowColor.a);
+#endif
+}
+`;e.ShadersStoreWGSL[i]||(e.ShadersStoreWGSL[i]=r);const l=[f,o,n];for(const a of l)e.IncludesShadersStoreWGSL[a.name]||(e.IncludesShadersStoreWGSL[a.name]=a.shader);const d={name:i,shader:r};export{d as glowMapGenerationPixelShaderWGSL};

python_cad_tools/_viewer_static/assets/glowMapGeneration.vertex-BGq1Fakj.js

@@ -0,0 +1,75 @@
+import{S as e}from"./index-B2zBEWsq.js";import{b as a,a as n,m as f,c as o,i as s,d,e as u,f as v,g as c,h as p}from"./bakedVertexAnimation-Cd_pRdrn.js";import{c as x,a as l}from"./clipPlaneVertex-B_VhD1oQ.js";const t="glowMapGenerationVertexShader",r=`attribute position: vec3f;
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#include<clipPlaneVertexDeclaration>
+#include<instancesDeclaration>
+uniform viewProjection: mat4x4f;varying vPosition: vec4f;
+#ifdef UV1
+attribute uv: vec2f;
+#endif
+#ifdef UV2
+attribute uv2: vec2f;
+#endif
+#ifdef DIFFUSE
+varying vUVDiffuse: vec2f;uniform diffuseMatrix: mat4x4f;
+#endif
+#ifdef OPACITY
+varying vUVOpacity: vec2f;uniform opacityMatrix: mat4x4f;
+#endif
+#ifdef EMISSIVE
+varying vUVEmissive: vec2f;uniform emissiveMatrix: mat4x4f;
+#endif
+#ifdef VERTEXALPHA
+attribute color: vec4f;varying vColor: vec4f;
+#endif
+#define CUSTOM_VERTEX_DEFINITIONS
+@vertex
+fn main(input : VertexInputs)->FragmentInputs {var positionUpdated: vec3f=vertexInputs.position;
+#ifdef UV1
+var uvUpdated: vec2f=vertexInputs.uv;
+#endif
+#ifdef UV2
+var uv2Updated: vec2f=vertexInputs.uv2;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#include<instancesVertex>
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+var worldPos: vec4f=finalWorld* vec4f(positionUpdated,1.0);
+#ifdef CUBEMAP
+vertexOutputs.vPosition=worldPos;vertexOutputs.position=uniforms.viewProjection*finalWorld* vec4f(vertexInputs.position,1.0);
+#else
+vertexOutputs.vPosition=uniforms.viewProjection*worldPos;vertexOutputs.position=vertexOutputs.vPosition;
+#endif
+#ifdef DIFFUSE
+#ifdef DIFFUSEUV1
+vertexOutputs.vUVDiffuse= (uniforms.diffuseMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#ifdef DIFFUSEUV2
+vertexOutputs.vUVDiffuse= (uniforms.diffuseMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#endif
+#ifdef OPACITY
+#ifdef OPACITYUV1
+vertexOutputs.vUVOpacity= (uniforms.opacityMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#ifdef OPACITYUV2
+vertexOutputs.vUVOpacity= (uniforms.opacityMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#endif
+#ifdef EMISSIVE
+#ifdef EMISSIVEUV1
+vertexOutputs.vUVEmissive= (uniforms.emissiveMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#ifdef EMISSIVEUV2
+vertexOutputs.vUVEmissive= (uniforms.emissiveMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#endif
+#ifdef VERTEXALPHA
+vertexOutputs.vColor=vertexInputs.color;
+#endif
+#include<clipPlaneVertex>
+}`;e.ShadersStoreWGSL[t]||(e.ShadersStoreWGSL[t]=r);const m=[a,n,f,o,x,s,d,u,v,c,p,l];for(const i of m)e.IncludesShadersStoreWGSL[i.name]||(e.IncludesShadersStoreWGSL[i.name]=i.shader);const I={name:t,shader:r};export{I as glowMapGenerationVertexShaderWGSL};

python_cad_tools/_viewer_static/assets/glowMapMerge.fragment-DxcneU_F.js

@@ -0,0 +1,25 @@
+import{S as r}from"./index-B2zBEWsq.js";const e="glowMapMergePixelShader",a=`varying vUV: vec2f;var textureSamplerSampler: sampler;var textureSampler: texture_2d<f32>;
+#ifdef EMISSIVE
+var textureSampler2Sampler: sampler;var textureSampler2: texture_2d<f32>;
+#endif
+uniform offset: f32;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+var baseColor: vec4f=textureSample(textureSampler,textureSamplerSampler,input.vUV);
+#ifdef EMISSIVE
+baseColor+=textureSample(textureSampler2,textureSampler2Sampler,input.vUV);baseColor*=uniforms.offset;
+#else
+baseColor=vec4f(baseColor.rgb,abs(uniforms.offset-baseColor.a));
+#ifdef STROKE
+var alpha: f32=smoothstep(.0,.1,baseColor.a);baseColor=vec4f(baseColor.rgb*alpha,alpha);
+#endif
+#endif
+#if LDR
+baseColor=clamp(baseColor,vec4f(0.),vec4f(1.0));
+#endif
+fragmentOutputs.color=baseColor;
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;r.ShadersStoreWGSL[e]||(r.ShadersStoreWGSL[e]=a);const o={name:e,shader:a};export{o as glowMapMergePixelShaderWGSL};

python_cad_tools/_viewer_static/assets/glowMapMerge.vertex-DaJJKqMV.js

@@ -0,0 +1,8 @@
+import{S as t}from"./index-B2zBEWsq.js";const e="glowMapMergeVertexShader",r=`attribute position: vec2f;varying vUV: vec2f;
+#define CUSTOM_VERTEX_DEFINITIONS
+@vertex
+fn main(input : VertexInputs)->FragmentInputs {const madd: vec2f= vec2f(0.5,0.5);
+#define CUSTOM_VERTEX_MAIN_BEGIN
+vertexOutputs.vUV=vertexInputs.position*madd+madd;vertexOutputs.position= vec4f(vertexInputs.position,0.0,1.0);
+#define CUSTOM_VERTEX_MAIN_END
+}`;t.ShadersStoreWGSL[e]||(t.ShadersStoreWGSL[e]=r);const o={name:e,shader:r};export{o as glowMapMergeVertexShaderWGSL};

python_cad_tools/_viewer_static/assets/harmonicsFunctions-DzJcvNWG.js

@@ -0,0 +1,16 @@
+import{S as a}from"./index-B2zBEWsq.js";const r="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
+`;a.IncludesShadersStoreWGSL[r]||(a.IncludesShadersStoreWGSL[r]=e);const v={name:r,shader:e};export{v as h};

python_cad_tools/_viewer_static/assets/hdrTextureLoader-BGQvgh0h.js

@@ -0,0 +1,2 @@
+function D(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 B(t,e,s,r,i,n){i>0?(i=D(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 b(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 m(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 p=new ArrayBuffer(r*4),w=new Uint8Array(p),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],B(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++],B(d,i,n,o,h,(e.height-s)*r*3+l*3);s--}return d}class M{constructor(){this.supportCascades=!1}loadCubeData(){throw".hdr not supported in Cube."}loadData(e,s,r){const i=new Uint8Array(e.buffer,e.byteOffset,e.byteLength),n=b(i),o=m(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{M as _HDRTextureLoader};

python_cad_tools/_viewer_static/assets/helperFunctions-Cugfp1Fz.js

@@ -0,0 +1,87 @@
+import{S as r}from"./index-B2zBEWsq.js";const e="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 select(remainingSection,nearZeroSection,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 select(remainingSection,nearZeroSection,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));}
+`;r.IncludesShadersStoreWGSL[e]||(r.IncludesShadersStoreWGSL[e]=t);const a={name:e,shader:t};export{a as h};

python_cad_tools/_viewer_static/assets/iesTextureLoader-CO4G0p2M.js

@@ -0,0 +1,2 @@
+import{u as p}from"./index-B2zBEWsq.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}loadCubeData(){throw".ies not supported in Cube."}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};