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

python_cad_tools/_viewer_static/assets/flowGraphWhileLoopBlock-C1OKQ-_F.js

@@ -0,0 +1 @@
+import{y as a,h as n,L as s,i as r}from"./index-B2zBEWsq.js";class e extends a{constructor(i){super(i),this.config=i,this.condition=this.registerDataInput("condition",n),this.executionFlow=this._registerSignalOutput("executionFlow"),this.completed=this._registerSignalOutput("completed"),this._unregisterSignalOutput("out")}_execute(i,u){let t=this.condition.getValue(i);this.config?.doWhile&&!t&&this.executionFlow._activateSignal(i);let o=0;for(;t;){if(this.executionFlow._activateSignal(i),++o,o>=e.MaxLoopCount){s.Warn("FlowGraphWhileLoopBlock: Max loop count reached. Breaking.");break}t=this.condition.getValue(i)}this.completed._activateSignal(i)}getClassName(){return"FlowGraphWhileLoopBlock"}}e.MaxLoopCount=1e3;let l=!1;function h(){l||(l=!0,r("FlowGraphWhileLoopBlock",e))}h();export{e as FlowGraphWhileLoopBlock,h as RegisterFlowGraphWhileLoopBlock};

python_cad_tools/_viewer_static/assets/fogFragment-DtDlQBnz.js

@@ -0,0 +1,25 @@
+import{S as o}from"./index-B2zBEWsq.js";const f="fogFragmentDeclaration",r=`#ifdef FOG
+#define FOGMODE_NONE 0.
+#define FOGMODE_EXP 1.
+#define FOGMODE_EXP2 2.
+#define FOGMODE_LINEAR 3.
+const E=2.71828;uniform vFogInfos: vec4f;uniform vFogColor: vec3f;varying vFogDistance: vec3f;fn CalcFogFactor()->f32
+{var fogCoeff: f32=1.0;var fogStart: f32=uniforms.vFogInfos.y;var fogEnd: f32=uniforms.vFogInfos.z;var fogDensity: f32=uniforms.vFogInfos.w;var fogDistance: f32=length(fragmentInputs.vFogDistance);if (FOGMODE_LINEAR==uniforms.vFogInfos.x)
+{fogCoeff=(fogEnd-fogDistance)/(fogEnd-fogStart);}
+else if (FOGMODE_EXP==uniforms.vFogInfos.x)
+{fogCoeff=1.0/pow(E,fogDistance*fogDensity);}
+else if (FOGMODE_EXP2==uniforms.vFogInfos.x)
+{fogCoeff=1.0/pow(E,fogDistance*fogDistance*fogDensity*fogDensity);}
+return clamp(fogCoeff,0.0,1.0);}
+#endif
+`;o.IncludesShadersStoreWGSL[f]||(o.IncludesShadersStoreWGSL[f]=r);const g={name:f,shader:r},e="logDepthFragment",a=`#ifdef LOGARITHMICDEPTH
+fragmentOutputs.fragDepth=log2(fragmentInputs.vFragmentDepth)*uniforms.logarithmicDepthConstant*0.5;
+#endif
+`;o.IncludesShadersStoreWGSL[e]||(o.IncludesShadersStoreWGSL[e]=a);const i={name:e,shader:a},n="fogFragment",s=`#ifdef FOG
+var fog: f32=CalcFogFactor();
+#ifdef PBR
+fog=toLinearSpace(fog);
+#endif
+color= vec4f(mix(uniforms.vFogColor,color.rgb,fog),color.a);
+#endif
+`;o.IncludesShadersStoreWGSL[n]||(o.IncludesShadersStoreWGSL[n]=s);const c={name:n,shader:s};export{c as a,g as f,i as l};

python_cad_tools/_viewer_static/assets/gaussianSplatting-Cfigjb15.js

@@ -0,0 +1,242 @@
+import{S as e}from"./index-B2zBEWsq.js";const t="gaussianSplattingVertexDeclaration",o="attribute vec3 position;attribute vec4 splatIndex0;attribute vec4 splatIndex1;attribute vec4 splatIndex2;attribute vec4 splatIndex3;uniform mat4 view;uniform mat4 projection;uniform mat4 world;uniform vec4 vEyePosition;";e.IncludesShadersStore[t]||(e.IncludesShadersStore[t]=o);const n={name:t,shader:o},a="gaussianSplattingUboDeclaration",c=`#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+attribute vec3 position;attribute vec4 splatIndex0;attribute vec4 splatIndex1;attribute vec4 splatIndex2;attribute vec4 splatIndex3;
+`;e.IncludesShadersStore[a]||(e.IncludesShadersStore[a]=c);const x={name:a,shader:c},s="gaussianSplatting",i=`#if !defined(WEBGL2) && !defined(WEBGPU) && !defined(NATIVE)
+mat3 transpose(mat3 matrix) {return mat3(matrix[0][0],matrix[1][0],matrix[2][0],
+matrix[0][1],matrix[1][1],matrix[2][1],
+matrix[0][2],matrix[1][2],matrix[2][2]);}
+#endif
+vec2 getDataUV(float index,vec2 textureSize) {float y=floor(index/textureSize.x);float x=index-y*textureSize.x;return vec2((x+0.5)/textureSize.x,(y+0.5)/textureSize.y);}
+#if SH_DEGREE>0 || IS_COMPOUND
+ivec2 getDataUVint(float index,vec2 textureSize) {float y=floor(index/textureSize.x);float x=index-y*textureSize.x;return ivec2(uint(x+0.5),uint(y+0.5));}
+#endif
+struct Splat {vec4 center;vec4 color;vec4 covA;vec4 covB;
+#if SH_DEGREE>0
+uvec4 sh0; 
+#endif
+#if SH_DEGREE>1
+uvec4 sh1;
+#endif
+#if SH_DEGREE>2
+uvec4 sh2;
+#endif
+#if SH_DEGREE>3
+uvec4 sh3;uvec4 sh4;
+#endif
+#if IS_COMPOUND
+uint partIndex;
+#endif
+#if defined(IS_FOR_VOXELIZATION)
+vec4 rotationA;vec4 rotationB;vec4 rotationScale;
+#endif
+#ifdef USE_SOG
+float splatIndex;
+#endif
+};float getSplatIndex(int localIndex)
+{float splatIndex;switch (localIndex)
+{case 0: splatIndex=splatIndex0.x; break;case 1: splatIndex=splatIndex0.y; break;case 2: splatIndex=splatIndex0.z; break;case 3: splatIndex=splatIndex0.w; break;case 4: splatIndex=splatIndex1.x; break;case 5: splatIndex=splatIndex1.y; break;case 6: splatIndex=splatIndex1.z; break;case 7: splatIndex=splatIndex1.w; break;case 8: splatIndex=splatIndex2.x; break;case 9: splatIndex=splatIndex2.y; break;case 10: splatIndex=splatIndex2.z; break;case 11: splatIndex=splatIndex2.w; break;case 12: splatIndex=splatIndex3.x; break;case 13: splatIndex=splatIndex3.y; break;case 14: splatIndex=splatIndex3.z; break;case 15: splatIndex=splatIndex3.w; break;}
+return splatIndex;}
+Splat readSplat(float splatIndex)
+{Splat splat;vec2 splatUV=getDataUV(splatIndex,dataTextureSize);
+#ifdef USE_SOG
+ivec2 sogUVi=ivec2(int(splatUV.x*dataTextureSize.x),int(splatUV.y*dataTextureSize.y));vec4 mL=texelFetch(centersTexture,sogUVi,0); 
+vec4 mU=texelFetch(covariancesATexture,sogUVi,0); 
+vec4 sRaw=texelFetch(covariancesBTexture,sogUVi,0); 
+vec4 qRaw=texelFetch(sogQuatsTexture,sogUVi,0); 
+vec4 c0=texelFetch(colorsTexture,sogUVi,0); 
+vec3 q16=(mU.xyz*256.0+mL.xyz)*(255.0/65535.0);vec3 nPos=mix(sogMeansMin,sogMeansMax,q16);vec3 center=sign(nPos)*(exp(abs(nPos))-vec3(1.0));splat.center=vec4(center,1.0);
+#ifdef USE_SOG_V2
+vec3 sIdx=floor(sRaw.xyz*255.0+0.5);vec3 splatScale;splatScale.x=exp(texelFetch(sogCodebookTexture,ivec2(int(sIdx.x),0),0).r);splatScale.y=exp(texelFetch(sogCodebookTexture,ivec2(int(sIdx.y),0),0).r);splatScale.z=exp(texelFetch(sogCodebookTexture,ivec2(int(sIdx.z),0),0).r);
+#else
+vec3 splatScale=exp(mix(sogScalesMin,sogScalesMax,sRaw.xyz));
+#endif
+const float invSqrt2=0.70710678118;vec3 qabc=(qRaw.xyz-vec3(0.5))*2.0*invSqrt2;int qMode=int(qRaw.w*255.0+0.5)-252;float qd=sqrt(max(0.0,1.0-dot(qabc,qabc)));vec4 quat;if (qMode==0) quat=vec4(qd,qabc.x,qabc.y,qabc.z);else if (qMode==1) quat=vec4(qabc.x,qd,qabc.y,qabc.z);else if (qMode==2) quat=vec4(qabc.x,qabc.y,qd,qabc.z);else quat=vec4(qabc.x,qabc.y,qabc.z,qd);float qw=quat.x,qx=quat.y,qy=quat.z,qz=quat.w;mat3 R=mat3(
+1.0-2.0*(qy*qy+qz*qz),2.0*(qx*qy+qw*qz), 2.0*(qx*qz-qw*qy),
+2.0*(qx*qy-qw*qz), 1.0-2.0*(qx*qx+qz*qz),2.0*(qy*qz+qw*qx),
+2.0*(qx*qz+qw*qy), 2.0*(qy*qz-qw*qx), 1.0-2.0*(qx*qx+qy*qy)
+);mat3 S2=mat3(4.0*splatScale.x*splatScale.x,0.0,0.0,
+0.0,4.0*splatScale.y*splatScale.y,0.0,
+0.0,0.0,4.0*splatScale.z*splatScale.z);mat3 Sigma=R*S2*transpose(R);splat.covA=vec4(Sigma[0][0],Sigma[0][1],Sigma[0][2],Sigma[1][1]);splat.covB=vec4(Sigma[1][2],Sigma[2][2],0.0,0.0);const float SH_C0=0.28209479177387814;
+#ifdef USE_SOG_V2
+vec3 c3;c3.x=texelFetch(sogCodebookTexture,ivec2(256+int(c0.x*255.0+0.5),0),0).r;c3.y=texelFetch(sogCodebookTexture,ivec2(256+int(c0.y*255.0+0.5),0),0).r;c3.z=texelFetch(sogCodebookTexture,ivec2(256+int(c0.z*255.0+0.5),0),0).r;vec3 colRgb=vec3(0.5)+c3*SH_C0;float colA=c0.w; 
+#else
+vec4 cLerp=mix(sogSh0Min,sogSh0Max,c0);vec3 colRgb=vec3(0.5)+cLerp.xyz*SH_C0;float colA=1.0/(1.0+exp(-cLerp.w));
+#endif
+splat.color=vec4(colRgb,colA);splat.splatIndex=splatIndex;
+#else
+splat.center=texture2D(centersTexture,splatUV);splat.color=texture2D(colorsTexture,splatUV);
+#if !defined(IS_FOR_VOXELIZATION)
+splat.covA=texture2D(covariancesATexture,splatUV)*splat.center.w;splat.covB=texture2D(covariancesBTexture,splatUV)*splat.center.w;
+#endif
+#endif
+#if SH_DEGREE>0 || IS_COMPOUND
+ivec2 splatUVint=getDataUVint(splatIndex,dataTextureSize);
+#endif
+#if SH_DEGREE>0 && !defined(USE_SOG)
+splat.sh0=texelFetch(shTexture0,splatUVint,0);
+#endif
+#if SH_DEGREE>1 && !defined(USE_SOG)
+splat.sh1=texelFetch(shTexture1,splatUVint,0);
+#endif
+#if SH_DEGREE>2 && !defined(USE_SOG)
+splat.sh2=texelFetch(shTexture2,splatUVint,0);
+#endif
+#if SH_DEGREE>3 && !defined(USE_SOG)
+splat.sh3=texelFetch(shTexture3,splatUVint,0);splat.sh4=texelFetch(shTexture4,splatUVint,0);
+#endif
+#if IS_COMPOUND
+splat.partIndex=uint(texture2D(partIndicesTexture,splatUV).r*255.0+0.5);
+#endif
+#if defined(IS_FOR_VOXELIZATION)
+splat.rotationA=texture2D(rotationsATexture,splatUV);splat.rotationB=texture2D(rotationsBTexture,splatUV);splat.rotationScale=texture2D(rotationScaleTexture,splatUV);
+#endif
+return splat;}
+#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+vec3 computeColorFromSHDegree(vec3 dir,const vec3 sh[25],float _so1,float _so2,float _so3,float _so4)
+{const float SH_C0=0.28209479;const float SH_C1=0.48860251;float SH_C2[5];SH_C2[0]=1.092548430;SH_C2[1]=-1.09254843;SH_C2[2]=0.315391565;SH_C2[3]=-1.09254843;SH_C2[4]=0.546274215;float SH_C3[7];SH_C3[0]=-0.59004358;SH_C3[1]=2.890611442;SH_C3[2]=-0.45704579;SH_C3[3]=0.373176332;SH_C3[4]=-0.45704579;SH_C3[5]=1.445305721;SH_C3[6]=-0.59004358;float SH_C4[9];SH_C4[0]= 2.5033429418;SH_C4[1]=-1.7701307698;SH_C4[2]= 0.9461746958;SH_C4[3]=-0.6690465436;SH_C4[4]= 0.1057855469;SH_C4[5]=-0.6690465436;SH_C4[6]= 0.4730873479;SH_C4[7]=-1.7701307698;SH_C4[8]= 0.6258357354;vec3 result=/*SH_C0**/sh[0];
+#if SH_DEGREE>0
+float x=dir.x;float y=dir.y;float z=dir.z;result+=_so1*(- SH_C1*y*sh[1]+SH_C1*z*sh[2]-SH_C1*x*sh[3]);
+#if SH_DEGREE>1
+float xx=x*x,yy=y*y,zz=z*z;float xy=x*y,yz=y*z,xz=x*z;result+=_so2*(
+SH_C2[0]*xy*sh[4] +
+SH_C2[1]*yz*sh[5] +
+SH_C2[2]*(2.0*zz-xx-yy)*sh[6] +
+SH_C2[3]*xz*sh[7] +
+SH_C2[4]*(xx-yy)*sh[8]);
+#if SH_DEGREE>2
+result+=_so3*(
+SH_C3[0]*y*(3.0*xx-yy)*sh[9] +
+SH_C3[1]*xy*z*sh[10] +
+SH_C3[2]*y*(4.0*zz-xx-yy)*sh[11] +
+SH_C3[3]*z*(2.0*zz-3.0*xx-3.0*yy)*sh[12] +
+SH_C3[4]*x*(4.0*zz-xx-yy)*sh[13] +
+SH_C3[5]*z*(xx-yy)*sh[14] +
+SH_C3[6]*x*(xx-3.0*yy)*sh[15]);
+#if SH_DEGREE>3
+result+=_so4*(
+SH_C4[0]*x*y*(xx-yy)*sh[16] +
+SH_C4[1]*y*z*(3.0*xx-yy)*sh[17] +
+SH_C4[2]*x*y*(7.0*zz-1.0)*sh[18] +
+SH_C4[3]*y*z*(7.0*zz-3.0)*sh[19] +
+SH_C4[4]*(zz*(35.0*zz-30.0)+3.0)*sh[20] +
+SH_C4[5]*x*z*(7.0*zz-3.0)*sh[21] +
+SH_C4[6]*(xx-yy)*(7.0*zz-1.0)*sh[22] +
+SH_C4[7]*x*z*(xx-3.0*yy)*sh[23] +
+SH_C4[8]*(xx*(xx-3.0*yy)-yy*(3.0*xx-yy))*sh[24]);
+#endif
+#endif
+#endif
+#endif
+return result;}
+vec4 decompose(uint value)
+{vec4 components=vec4(
+float((value ) & 255u),
+float((value>>uint( 8)) & 255u),
+float((value>>uint(16)) & 255u),
+float((value>>uint(24)) & 255u));return components*vec4(2./255.)-vec4(1.);}
+#ifdef USE_SOG
+vec3 computeSH(Splat splat,vec3 dir)
+{
+#if SH_DEGREE>0
+vec3 sh[25];sh[0]=vec3(0.,0.,0.);ivec2 labelSize=textureSize(sogShNLabelsTexture,0);int idx=int(splat.splatIndex+0.5);int lx=idx-(idx/labelSize.x)*labelSize.x;int ly=idx/labelSize.x;vec4 labelRaw=texelFetch(sogShNLabelsTexture,ivec2(lx,ly),0);int n=int(labelRaw.r*255.0+0.5)+int(labelRaw.g*255.0+0.5)*256;int coeffs=int(sogShCoeffCount+0.5);int u=(n-(n/64)*64)*coeffs;int v=n/64;for (int k=0; k<24; k++) {if (k>=coeffs) break;vec4 centroidRaw=texelFetch(sogShNCentroidsTexture,ivec2(u+k,v),0);vec3 shCoeff;
+#ifdef USE_SOG_V2
+int rIdx=int(centroidRaw.r*255.0+0.5);int gIdx=int(centroidRaw.g*255.0+0.5);int bIdx=int(centroidRaw.b*255.0+0.5);shCoeff.r=texelFetch(sogCodebookTexture,ivec2(512+rIdx,0),0).r;shCoeff.g=texelFetch(sogCodebookTexture,ivec2(512+gIdx,0),0).r;shCoeff.b=texelFetch(sogCodebookTexture,ivec2(512+bIdx,0),0).r;
+#else
+shCoeff=mix(vec3(sogShnMin),vec3(sogShnMax),centroidRaw.rgb);
+#endif
+sh[k+1]=shCoeff;}
+return computeColorFromSHDegree(dir,sh,1.,1.,1.,1.);
+#else
+return vec3(0.,0.,0.);
+#endif
+}
+#else
+vec3 computeSHWeighted(Splat splat,vec3 dir,float _so1,float _so2,float _so3,float _so4)
+{vec3 sh[25];sh[0]=vec3(0.,0.,0.);
+#if SH_DEGREE>0
+vec4 sh00=decompose(splat.sh0.x);vec4 sh01=decompose(splat.sh0.y);vec4 sh02=decompose(splat.sh0.z);sh[1]=vec3(sh00.x,sh00.y,sh00.z);sh[2]=vec3(sh00.w,sh01.x,sh01.y);sh[3]=vec3(sh01.z,sh01.w,sh02.x);
+#endif
+#if SH_DEGREE>1
+vec4 sh03=decompose(splat.sh0.w);vec4 sh04=decompose(splat.sh1.x);vec4 sh05=decompose(splat.sh1.y);sh[4]=vec3(sh02.y,sh02.z,sh02.w);sh[5]=vec3(sh03.x,sh03.y,sh03.z);sh[6]=vec3(sh03.w,sh04.x,sh04.y);sh[7]=vec3(sh04.z,sh04.w,sh05.x);sh[8]=vec3(sh05.y,sh05.z,sh05.w);
+#endif
+#if SH_DEGREE>2
+vec4 sh06=decompose(splat.sh1.z);vec4 sh07=decompose(splat.sh1.w);vec4 sh08=decompose(splat.sh2.x);vec4 sh09=decompose(splat.sh2.y);vec4 sh10=decompose(splat.sh2.z);vec4 sh11=decompose(splat.sh2.w);sh[9]=vec3(sh06.x,sh06.y,sh06.z);sh[10]=vec3(sh06.w,sh07.x,sh07.y);sh[11]=vec3(sh07.z,sh07.w,sh08.x);sh[12]=vec3(sh08.y,sh08.z,sh08.w);sh[13]=vec3(sh09.x,sh09.y,sh09.z);sh[14]=vec3(sh09.w,sh10.x,sh10.y);sh[15]=vec3(sh10.z,sh10.w,sh11.x);
+#endif
+#if SH_DEGREE>3
+vec4 sh12=decompose(splat.sh3.x);vec4 sh13=decompose(splat.sh3.y);vec4 sh14=decompose(splat.sh3.z);vec4 sh15=decompose(splat.sh3.w);vec4 sh16=decompose(splat.sh4.x);vec4 sh17=decompose(splat.sh4.y);sh[16]=vec3(sh11.y,sh11.z,sh11.w);sh[17]=vec3(sh12.x,sh12.y,sh12.z);sh[18]=vec3(sh12.w,sh13.x,sh13.y);sh[19]=vec3(sh13.z,sh13.w,sh14.x);sh[20]=vec3(sh14.y,sh14.z,sh14.w);sh[21]=vec3(sh15.x,sh15.y,sh15.z);sh[22]=vec3(sh15.w,sh16.x,sh16.y);sh[23]=vec3(sh16.z,sh16.w,sh17.x);sh[24]=vec3(sh17.y,sh17.z,sh17.w);
+#endif
+return computeColorFromSHDegree(dir,sh,_so1,_so2,_so3,_so4);}
+vec3 computeSH(Splat splat,vec3 dir)
+{
+#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER1==1
+float _w1=1.0;
+#else
+float _w1=0.0;
+#endif
+#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER2==1
+float _w2=1.0;
+#else
+float _w2=0.0;
+#endif
+#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER3==1
+float _w3=1.0;
+#else
+float _w3=0.0;
+#endif
+#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER4==1
+float _w4=1.0;
+#else
+float _w4=0.0;
+#endif
+return computeSHWeighted(splat,dir,_w1,_w2,_w3,_w4);}
+#endif
+#else
+vec3 computeSH(Splat splat,vec3 dir)
+{return vec3(0.,0.,0.);}
+#endif
+#if !defined(IS_FOR_VOXELIZATION)
+vec4 gaussianSplatting(vec2 meshPos,vec3 worldPos,vec2 scale,vec3 covA,vec3 covB,mat4 worldMatrix,mat4 viewMatrix,mat4 projectionMatrix)
+{mat4 modelView=viewMatrix*worldMatrix;vec4 camspace=viewMatrix*vec4(worldPos,1.);vec4 pos2d=projectionMatrix*camspace;float bounds=1.2*pos2d.w;if (pos2d.z<-pos2d.w || pos2d.x<-bounds || pos2d.x>bounds
+|| pos2d.y<-bounds || pos2d.y>bounds) {return vec4(0.0,0.0,2.0,1.0);}
+mat3 Vrk=mat3(
+covA.x,covA.y,covA.z,
+covA.y,covB.x,covB.y,
+covA.z,covB.y,covB.z
+);bool isOrtho=abs(projectionMatrix[3][3]-1.0)<0.001;mat3 J;if (isOrtho) {J=mat3(
+focal.x,0.,0.,
+0.,focal.y,0.,
+0.,0.,0.
+);} else {J=mat3(
+focal.x/camspace.z,0.,-(focal.x*camspace.x)/(camspace.z*camspace.z),
+0.,focal.y/camspace.z,-(focal.y*camspace.y)/(camspace.z*camspace.z),
+0.,0.,0.
+);}
+mat3 T=transpose(mat3(modelView))*J;mat3 cov2d=transpose(T)*Vrk*T;
+#if COMPENSATION
+float c00=cov2d[0][0];float c11=cov2d[1][1];float c01=cov2d[0][1];float detOrig=c00*c11-c01*c01;
+#endif
+cov2d[0][0]+=kernelSize;cov2d[1][1]+=kernelSize;
+#if COMPENSATION
+vec3 c2d=vec3(cov2d[0][0],c01,cov2d[1][1]);float detBlur=c2d.x*c2d.z-c2d.y*c2d.y;float compensation=sqrt(max(0.,detOrig/detBlur));vColor.w*=compensation;
+#endif
+float mid=(cov2d[0][0]+cov2d[1][1])/2.0;float radius=length(vec2((cov2d[0][0]-cov2d[1][1])/2.0,cov2d[0][1]));float epsilon=0.0001;float lambda1=mid+radius+epsilon,lambda2=mid-radius+epsilon;if (lambda2<0.0)
+{return vec4(0.0,0.0,2.0,1.0);}
+if (minPixelSize>0.0) {float l1=2.0*min(sqrt(2.0*lambda1),1024.0);float l2=2.0*min(sqrt(2.0*lambda2),1024.0);if (max(l1,l2)<minPixelSize) {return vec4(0.0,0.0,2.0,1.0);}}
+vec2 diagonalVector=normalize(vec2(cov2d[0][1],lambda1-cov2d[0][0]));vec2 majorAxis=min(sqrt(2.0*lambda1),1024.0)*diagonalVector;vec2 minorAxis=min(sqrt(2.0*lambda2),1024.0)*vec2(diagonalVector.y,-diagonalVector.x);vec2 vCenter=vec2(pos2d);float scaleFactor=isOrtho ? 1.0 : pos2d.w;return vec4(
+vCenter 
++ ((meshPos.x*majorAxis
++ meshPos.y*minorAxis)*invViewport*scaleFactor)*scale,pos2d.zw);}
+#endif
+#if IS_COMPOUND
+mat4 getPartWorld(uint partIndex) {return partWorld[partIndex];}
+#endif
+#if defined(IS_FOR_VOXELIZATION)
+vec4 computeVoxelSplatWorldPos(vec4 rotationA,vec4 rotationB,vec4 rotationScale,vec3 center,mat4 splatWorld,mat4 viewMatrix,mat4 invWorldScale,vec2 quadPos) {mat3 splatRotation=mat3(
+vec3(rotationA.x,rotationA.y,rotationA.z),
+vec3(rotationA.w,rotationB.x,rotationB.y),
+vec3(rotationB.z,rotationB.w,rotationScale.x)
+);vec3 splatScale=vec3(rotationScale.y,rotationScale.z,rotationScale.w);mat3 rotToView=mat3(viewMatrix)*mat3(invWorldScale)*mat3(splatWorld)*splatRotation;vec3 axisLengthInViewZ=abs(vec3(rotToView[0][2],rotToView[1][2],rotToView[2][2]));float gaussianSplatCutoffStddev=1.4142135624/2.0; 
+vec3 offsetSplatSpace;if (axisLengthInViewZ.x>axisLengthInViewZ.y && axisLengthInViewZ.x>axisLengthInViewZ.z) {offsetSplatSpace=vec3(0.0,quadPos.x,quadPos.y)*splatScale*gaussianSplatCutoffStddev;} else if (axisLengthInViewZ.y>axisLengthInViewZ.z) {offsetSplatSpace=vec3(quadPos.x,0.0,quadPos.y)*splatScale*gaussianSplatCutoffStddev;} else {offsetSplatSpace=vec3(quadPos.x,quadPos.y,0.0)*splatScale*gaussianSplatCutoffStddev;}
+vec3 vertexObjectSpace=center+splatRotation*offsetSplatSpace;return splatWorld*vec4(vertexObjectSpace,1.0);}
+#endif
+`;e.IncludesShadersStore[s]||(e.IncludesShadersStore[s]=i);const r={name:s,shader:i};export{x as a,r as b,n as g};

python_cad_tools/_viewer_static/assets/gaussianSplatting-DIn8R8oF.js

@@ -0,0 +1,296 @@
+import{S as t}from"./index-B2zBEWsq.js";const e="gaussianSplatting",s=`fn getDataUV(index: f32,dataTextureSize: vec2f)->vec2<f32> {let y: f32=floor(index/dataTextureSize.x);let x: f32=index-y*dataTextureSize.x;return vec2f((x+0.5),(y+0.5));}
+struct Splat {center: vec4f,
+color: vec4f,
+covA: vec4f,
+covB: vec4f,
+#if SH_DEGREE>0
+sh0: vec4<u32>,
+#endif
+#if SH_DEGREE>1
+sh1: vec4<u32>,
+#endif
+#if SH_DEGREE>2
+sh2: vec4<u32>,
+#endif
+#if SH_DEGREE>3
+sh3: vec4<u32>,
+sh4: vec4<u32>,
+#endif
+#if IS_COMPOUND
+partIndex: u32,
+#endif
+#if defined(IS_FOR_VOXELIZATION)
+rotationA: vec4f,
+rotationB: vec4f,
+rotationScale: vec4f,
+#endif
+#ifdef USE_SOG
+splatIndex: f32,
+#endif
+};fn getSplatIndex(localIndex: i32,splatIndex0: vec4f,splatIndex1: vec4f,splatIndex2: vec4f,splatIndex3: vec4f)->f32 {var splatIndex: f32;switch (localIndex)
+{case 0:
+{splatIndex=splatIndex0.x;break;}
+case 1:
+{splatIndex=splatIndex0.y;break;}
+case 2:
+{splatIndex=splatIndex0.z;break;}
+case 3:
+{splatIndex=splatIndex0.w;break;}
+case 4:
+{splatIndex=splatIndex1.x;break;}
+case 5:
+{splatIndex=splatIndex1.y;break;}
+case 6:
+{splatIndex=splatIndex1.z;break;}
+case 7:
+{splatIndex=splatIndex1.w;break;}
+case 8:
+{splatIndex=splatIndex2.x;break;}
+case 9:
+{splatIndex=splatIndex2.y;break;}
+case 10:
+{splatIndex=splatIndex2.z;break;}
+case 11:
+{splatIndex=splatIndex2.w;break;}
+case 12:
+{splatIndex=splatIndex3.x;break;}
+case 13:
+{splatIndex=splatIndex3.y;break;}
+case 14:
+{splatIndex=splatIndex3.z;break;}
+default:
+{splatIndex=splatIndex3.w;break;}}
+return splatIndex;}
+fn readSplat(splatIndex: f32,dataTextureSize: vec2f)->Splat {var splat: Splat;let splatUV=getDataUV(splatIndex,dataTextureSize);let splatUVi32=vec2<i32>(i32(splatUV.x),i32(splatUV.y));
+#ifdef USE_SOG
+let mL=textureLoad(centersTexture,splatUVi32,0);let mU=textureLoad(covariancesATexture,splatUVi32,0);let sRaw=textureLoad(covariancesBTexture,splatUVi32,0);let qRaw=textureLoad(sogQuatsTexture,splatUVi32,0);let c0=textureLoad(colorsTexture,splatUVi32,0);let q16=(mU.xyz*256.0+mL.xyz)*(255.0/65535.0);let nPos=mix(uniforms.sogMeansMin,uniforms.sogMeansMax,q16);let center3=sign(nPos)*(exp(abs(nPos))-vec3f(1.0));splat.center=vec4f(center3,1.0);
+#ifdef USE_SOG_V2
+let sIdx=floor(sRaw.xyz*255.0+0.5);var splatScale: vec3f;splatScale.x=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.x),0),0).r);splatScale.y=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.y),0),0).r);splatScale.z=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.z),0),0).r);
+#else
+let splatScale=exp(mix(uniforms.sogScalesMin,uniforms.sogScalesMax,sRaw.xyz));
+#endif
+let invSqrt2: f32=0.70710678118;let qabc=(qRaw.xyz-vec3f(0.5))*2.0*invSqrt2;let qMode=i32(qRaw.w*255.0+0.5)-252;let qd=sqrt(max(0.0,1.0-dot(qabc,qabc)));var quat: vec4f;if (qMode==0) { quat=vec4f(qd,qabc.x,qabc.y,qabc.z); }
+else if (qMode==1) { quat=vec4f(qabc.x,qd,qabc.y,qabc.z); }
+else if (qMode==2) { quat=vec4f(qabc.x,qabc.y,qd,qabc.z); }
+else { quat=vec4f(qabc.x,qabc.y,qabc.z,qd); }
+let qw=quat.x; let qx=quat.y; let qy=quat.z; let qz=quat.w;let R=mat3x3<f32>(
+1.0-2.0*(qy*qy+qz*qz),2.0*(qx*qy+qw*qz), 2.0*(qx*qz-qw*qy),
+2.0*(qx*qy-qw*qz), 1.0-2.0*(qx*qx+qz*qz),2.0*(qy*qz+qw*qx),
+2.0*(qx*qz+qw*qy), 2.0*(qy*qz-qw*qx), 1.0-2.0*(qx*qx+qy*qy)
+);let S2=mat3x3<f32>(
+4.0*splatScale.x*splatScale.x,0.0,0.0,
+0.0,4.0*splatScale.y*splatScale.y,0.0,
+0.0,0.0,4.0*splatScale.z*splatScale.z
+);let Sigma=R*S2*transpose(R);splat.covA=vec4f(Sigma[0][0],Sigma[0][1],Sigma[0][2],Sigma[1][1]);splat.covB=vec4f(Sigma[1][2],Sigma[2][2],0.0,0.0);let SH_C0_SOG: f32=0.28209479177387814;
+#ifdef USE_SOG_V2
+var c3: vec3f;c3.x=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.x*255.0+0.5),0),0).r;c3.y=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.y*255.0+0.5),0),0).r;c3.z=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.z*255.0+0.5),0),0).r;let colRgb=vec3f(0.5)+c3*SH_C0_SOG;let colA=c0.w;
+#else
+let cLerp=mix(uniforms.sogSh0Min,uniforms.sogSh0Max,c0);let colRgb=vec3f(0.5)+cLerp.xyz*SH_C0_SOG;let colA=1.0/(1.0+exp(-cLerp.w));
+#endif
+splat.color=vec4f(colRgb,colA);splat.splatIndex=splatIndex;
+#else
+splat.center=textureLoad(centersTexture,splatUVi32,0);splat.color=textureLoad(colorsTexture,splatUVi32,0);
+#if !defined(IS_FOR_VOXELIZATION)
+splat.covA=textureLoad(covariancesATexture,splatUVi32,0)*splat.center.w;splat.covB=textureLoad(covariancesBTexture,splatUVi32,0)*splat.center.w;
+#endif
+#endif
+#if SH_DEGREE>0 && !defined(USE_SOG)
+splat.sh0=textureLoad(shTexture0,splatUVi32,0);
+#endif
+#if SH_DEGREE>1 && !defined(USE_SOG)
+splat.sh1=textureLoad(shTexture1,splatUVi32,0);
+#endif
+#if SH_DEGREE>2 && !defined(USE_SOG)
+splat.sh2=textureLoad(shTexture2,splatUVi32,0);
+#endif
+#if SH_DEGREE>3 && !defined(USE_SOG)
+splat.sh3=textureLoad(shTexture3,splatUVi32,0);splat.sh4=textureLoad(shTexture4,splatUVi32,0);
+#endif
+#if IS_COMPOUND
+splat.partIndex=u32(textureLoad(partIndicesTexture,splatUVi32,0).r*255.0+0.5);
+#endif
+#if defined(IS_FOR_VOXELIZATION)
+splat.rotationA=textureLoad(rotationsATexture,splatUVi32,0);splat.rotationB=textureLoad(rotationsBTexture,splatUVi32,0);splat.rotationScale=textureLoad(rotationScaleTexture,splatUVi32,0);
+#endif
+return splat;}
+fn computeColorFromSHDegree(dir: vec3f,sh: array<vec3<f32>,25>,_so1: f32,_so2: f32,_so3: f32,_so4: f32)->vec3f
+{let SH_C0: f32=0.28209479;let SH_C1: f32=0.48860251;var SH_C2: array<f32,5>=array<f32,5>(
+1.092548430,
+-1.09254843,
+0.315391565,
+-1.09254843,
+0.546274215
+);var SH_C3: array<f32,7>=array<f32,7>(
+-0.59004358,
+2.890611442,
+-0.45704579,
+0.373176332,
+-0.45704579,
+1.445305721,
+-0.59004358
+);var SH_C4: array<f32,9>=array<f32,9>(
+2.5033429418,
+-1.7701307698,
+0.9461746958,
+-0.6690465436,
+0.1057855469,
+-0.6690465436,
+0.4730873479,
+-1.7701307698,
+0.6258357354
+);var result: vec3f=/*SH_C0**/sh[0];
+#if SH_DEGREE>0
+let x: f32=dir.x;let y: f32=dir.y;let z: f32=dir.z;result+=_so1*(-SH_C1*y*sh[1]+SH_C1*z*sh[2]-SH_C1*x*sh[3]);
+#if SH_DEGREE>1
+let xx: f32=x*x;let yy: f32=y*y;let zz: f32=z*z;let xy: f32=x*y;let yz: f32=y*z;let xz: f32=x*z;result+=_so2*(
+SH_C2[0]*xy*sh[4] +
+SH_C2[1]*yz*sh[5] +
+SH_C2[2]*(2.0f*zz-xx-yy)*sh[6] +
+SH_C2[3]*xz*sh[7] +
+SH_C2[4]*(xx-yy)*sh[8]);
+#if SH_DEGREE>2
+result+=_so3*(
+SH_C3[0]*y*(3.0f*xx-yy)*sh[9] +
+SH_C3[1]*xy*z*sh[10] +
+SH_C3[2]*y*(4.0f*zz-xx-yy)*sh[11] +
+SH_C3[3]*z*(2.0f*zz-3.0f*xx-3.0f*yy)*sh[12] +
+SH_C3[4]*x*(4.0f*zz-xx-yy)*sh[13] +
+SH_C3[5]*z*(xx-yy)*sh[14] +
+SH_C3[6]*x*(xx-3.0f*yy)*sh[15]);
+#if SH_DEGREE>3
+result+=_so4*(
+SH_C4[0]*x*y*(xx-yy)*sh[16] +
+SH_C4[1]*y*z*(3.0f*xx-yy)*sh[17] +
+SH_C4[2]*x*y*(7.0f*zz-1.0f)*sh[18] +
+SH_C4[3]*y*z*(7.0f*zz-3.0f)*sh[19] +
+SH_C4[4]*(zz*(35.0f*zz-30.0f)+3.0f)*sh[20] +
+SH_C4[5]*x*z*(7.0f*zz-3.0f)*sh[21] +
+SH_C4[6]*(xx-yy)*(7.0f*zz-1.0f)*sh[22] +
+SH_C4[7]*x*z*(xx-3.0f*yy)*sh[23] +
+SH_C4[8]*(xx*(xx-3.0f*yy)-yy*(3.0f*xx-yy))*sh[24]);
+#endif
+#endif
+#endif
+#endif
+return result;}
+fn decompose(value: u32)->vec4f
+{let components : vec4f=vec4f(
+f32((value ) & 255u),
+f32((value>>u32( 8)) & 255u),
+f32((value>>u32(16)) & 255u),
+f32((value>>u32(24)) & 255u));return components*vec4f(2./255.)-vec4f(1.);}
+#ifdef USE_SOG
+fn computeSH(splat: Splat,dir: vec3f)->vec3f
+{
+#if SH_DEGREE>0
+var sh: array<vec3<f32>,25>;sh[0]=vec3f(0.,0.,0.);let labelSize=textureDimensions(sogShNLabelsTexture,0);let idx=i32(splat.splatIndex+0.5);let lw=i32(labelSize.x);let lx=idx-(idx/lw)*lw;let ly=idx/lw;let labelRaw=textureLoad(sogShNLabelsTexture,vec2<i32>(lx,ly),0);let n=i32(labelRaw.r*255.0+0.5)+i32(labelRaw.g*255.0+0.5)*256;let coeffs=i32(uniforms.sogShCoeffCount+0.5);let u=(n-(n/64)*64)*coeffs;let v=n/64;for (var k: i32=0; k<24; k=k+1) {if (k>=coeffs) { break; }
+let centroidRaw=textureLoad(sogShNCentroidsTexture,vec2<i32>(u+k,v),0);var shCoeff: vec3f;
+#ifdef USE_SOG_V2
+let rIdx=i32(centroidRaw.r*255.0+0.5);let gIdx=i32(centroidRaw.g*255.0+0.5);let bIdx=i32(centroidRaw.b*255.0+0.5);shCoeff.r=textureLoad(sogCodebookTexture,vec2<i32>(512+rIdx,0),0).r;shCoeff.g=textureLoad(sogCodebookTexture,vec2<i32>(512+gIdx,0),0).r;shCoeff.b=textureLoad(sogCodebookTexture,vec2<i32>(512+bIdx,0),0).r;
+#else
+shCoeff=mix(vec3f(uniforms.sogShnMin),vec3f(uniforms.sogShnMax),centroidRaw.rgb);
+#endif
+sh[k+1]=shCoeff;}
+return computeColorFromSHDegree(dir,sh,1.,1.,1.,1.);
+#else
+return vec3f(0.,0.,0.);
+#endif
+}
+#else
+fn computeSHWeighted(splat: Splat,dir: vec3f,_so1: f32,_so2: f32,_so3: f32,_so4: f32)->vec3f
+{var sh: array<vec3<f32>,25>;sh[0]=vec3f(0.,0.,0.);
+#if SH_DEGREE>0
+let sh00: vec4f=decompose(splat.sh0.x);let sh01: vec4f=decompose(splat.sh0.y);let sh02: vec4f=decompose(splat.sh0.z);sh[1]=vec3f(sh00.x,sh00.y,sh00.z);sh[2]=vec3f(sh00.w,sh01.x,sh01.y);sh[3]=vec3f(sh01.z,sh01.w,sh02.x);
+#endif
+#if SH_DEGREE>1
+let sh03: vec4f=decompose(splat.sh0.w);let sh04: vec4f=decompose(splat.sh1.x);let sh05: vec4f=decompose(splat.sh1.y);sh[4]=vec3f(sh02.y,sh02.z,sh02.w);sh[5]=vec3f(sh03.x,sh03.y,sh03.z);sh[6]=vec3f(sh03.w,sh04.x,sh04.y);sh[7]=vec3f(sh04.z,sh04.w,sh05.x);sh[8]=vec3f(sh05.y,sh05.z,sh05.w);
+#endif
+#if SH_DEGREE>2
+let sh06: vec4f=decompose(splat.sh1.z);let sh07: vec4f=decompose(splat.sh1.w);let sh08: vec4f=decompose(splat.sh2.x);let sh09: vec4f=decompose(splat.sh2.y);let sh10: vec4f=decompose(splat.sh2.z);let sh11: vec4f=decompose(splat.sh2.w);sh[9]=vec3f(sh06.x,sh06.y,sh06.z);sh[10]=vec3f(sh06.w,sh07.x,sh07.y);sh[11]=vec3f(sh07.z,sh07.w,sh08.x);sh[12]=vec3f(sh08.y,sh08.z,sh08.w);sh[13]=vec3f(sh09.x,sh09.y,sh09.z);sh[14]=vec3f(sh09.w,sh10.x,sh10.y);sh[15]=vec3f(sh10.z,sh10.w,sh11.x);
+#endif
+#if SH_DEGREE>3
+let sh12: vec4f=decompose(splat.sh3.x);let sh13: vec4f=decompose(splat.sh3.y);let sh14: vec4f=decompose(splat.sh3.z);let sh15: vec4f=decompose(splat.sh3.w);let sh16: vec4f=decompose(splat.sh4.x);let sh17: vec4f=decompose(splat.sh4.y);sh[16]=vec3f(sh11.y,sh11.z,sh11.w);sh[17]=vec3f(sh12.x,sh12.y,sh12.z);sh[18]=vec3f(sh12.w,sh13.x,sh13.y);sh[19]=vec3f(sh13.z,sh13.w,sh14.x);sh[20]=vec3f(sh14.y,sh14.z,sh14.w);sh[21]=vec3f(sh15.x,sh15.y,sh15.z);sh[22]=vec3f(sh15.w,sh16.x,sh16.y);sh[23]=vec3f(sh16.z,sh16.w,sh17.x);sh[24]=vec3f(sh17.y,sh17.z,sh17.w);
+#endif
+return computeColorFromSHDegree(dir,sh,_so1,_so2,_so3,_so4);}
+fn computeSH(splat: Splat,dir: vec3f)->vec3f
+{
+#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER1==1
+let _w1: f32=1.0;
+#else
+let _w1: f32=0.0;
+#endif
+#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER2==1
+let _w2: f32=1.0;
+#else
+let _w2: f32=0.0;
+#endif
+#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER3==1
+let _w3: f32=1.0;
+#else
+let _w3: f32=0.0;
+#endif
+#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER4==1
+let _w4: f32=1.0;
+#else
+let _w4: f32=0.0;
+#endif
+return computeSHWeighted(splat,dir,_w1,_w2,_w3,_w4);}
+#endif
+fn gaussianSplatting(
+meshPos: vec2<f32>,
+worldPos: vec3<f32>,
+scale: vec2<f32>,
+covA: vec3<f32>,
+covB: vec3<f32>,
+worldMatrix: mat4x4<f32>,
+viewMatrix: mat4x4<f32>,
+projectionMatrix: mat4x4<f32>,
+focal: vec2f,
+invViewport: vec2f,
+kernelSize: f32,
+minPixelSize: f32
+)->vec4f {let modelView=viewMatrix*worldMatrix;let camspace=viewMatrix*vec4f(worldPos,1.0);let pos2d=projectionMatrix*camspace;let bounds=1.2*pos2d.w;if (pos2d.z<0. || pos2d.x<-bounds || pos2d.x>bounds || pos2d.y<-bounds || pos2d.y>bounds) {return vec4f(0.0,0.0,2.0,1.0);}
+let Vrk=mat3x3<f32>(
+covA.x,covA.y,covA.z,
+covA.y,covB.x,covB.y,
+covA.z,covB.y,covB.z
+);let isOrtho=abs(projectionMatrix[3][3]-1.0)<0.001;var J: mat3x3<f32>;if (isOrtho) {J=mat3x3<f32>(
+focal.x,0.0,0.0,
+0.0,focal.y,0.0,
+0.0,0.0,0.0
+);} else {J=mat3x3<f32>(
+focal.x/camspace.z,0.0,-(focal.x*camspace.x)/(camspace.z*camspace.z),
+0.0,focal.y/camspace.z,-(focal.y*camspace.y)/(camspace.z*camspace.z),
+0.0,0.0,0.0
+);}
+let T=transpose(mat3x3<f32>(
+modelView[0].xyz,
+modelView[1].xyz,
+modelView[2].xyz))*J;var cov2d=transpose(T)*Vrk*T;
+#if COMPENSATION
+let c00: f32=cov2d[0][0];let c11: f32=cov2d[1][1];let c01: f32=cov2d[0][1];let detOrig: f32=c00*c11-c01*c01;
+#endif
+cov2d[0][0]+=kernelSize;cov2d[1][1]+=kernelSize;
+#if COMPENSATION
+let c2d: vec3f=vec3f(cov2d[0][0],c01,cov2d[1][1]);let detBlur: f32=c2d.x*c2d.z-c2d.y*c2d.y;let compensation: f32=sqrt(max(0.,detOrig/detBlur));vertexOutputs.vColor.w*=compensation;
+#endif
+let mid=(cov2d[0][0]+cov2d[1][1])/2.0;let radius=length(vec2<f32>((cov2d[0][0]-cov2d[1][1])/2.0,cov2d[0][1]));let lambda1=mid+radius;let lambda2=mid-radius;if (lambda2<0.0) {return vec4f(0.0,0.0,2.0,1.0);}
+if (minPixelSize>0.0) {let l1=2.0*min(sqrt(2.0*lambda1),1024.0);let l2=2.0*min(sqrt(2.0*lambda2),1024.0);if (max(l1,l2)<minPixelSize) {return vec4f(0.0,0.0,2.0,1.0);}}
+let diagonalVector=normalize(vec2<f32>(cov2d[0][1],lambda1-cov2d[0][0]));let majorAxis=min(sqrt(2.0*lambda1),1024.0)*diagonalVector;let minorAxis=min(sqrt(2.0*lambda2),1024.0)*vec2<f32>(diagonalVector.y,-diagonalVector.x);let vCenter=vec2<f32>(pos2d.x,pos2d.y);let scaleFactor=select(pos2d.w,1.0,isOrtho);return vec4f(
+vCenter+((meshPos.x*majorAxis+meshPos.y*minorAxis)*invViewport*scaleFactor)*scale,
+pos2d.z,
+pos2d.w
+);}
+#if IS_COMPOUND
+fn getPartWorld(partIndex: u32)->mat4x4<f32> {return uniforms.partWorld[partIndex];}
+#endif
+#if defined(IS_FOR_VOXELIZATION)
+fn computeVoxelSplatWorldPos(rotationA: vec4f,rotationB: vec4f,rotationScale: vec4f,center: vec3f,splatWorld: mat4x4f,viewMatrix: mat4x4f,invWorldScale: mat4x4f,quadPos: vec2f)->vec4f {let splatRotation=mat3x3f(
+rotationA.xyz,
+vec3f(rotationA.w,rotationB.x,rotationB.y),
+vec3f(rotationB.z,rotationB.w,rotationScale.x)
+);let splatScale=rotationScale.yzw;let view3x3=mat3x3f(viewMatrix[0].xyz,viewMatrix[1].xyz,viewMatrix[2].xyz);let invWorldScale3x3=mat3x3f(invWorldScale[0].xyz,invWorldScale[1].xyz,invWorldScale[2].xyz);let splatWorld3x3=mat3x3f(splatWorld[0].xyz,splatWorld[1].xyz,splatWorld[2].xyz);let rotToView=view3x3*invWorldScale3x3*splatWorld3x3*splatRotation;let axisLengthInViewZ=abs(vec3f(rotToView[0][2],rotToView[1][2],rotToView[2][2]));let gaussianSplatCutoffStddev: f32=0.7071067812; 
+var offsetSplatSpace: vec3f;if (axisLengthInViewZ.x>axisLengthInViewZ.y && axisLengthInViewZ.x>axisLengthInViewZ.z) {offsetSplatSpace=vec3f(0.0,quadPos.x,quadPos.y)*splatScale*gaussianSplatCutoffStddev;} else if (axisLengthInViewZ.y>axisLengthInViewZ.z) {offsetSplatSpace=vec3f(quadPos.x,0.0,quadPos.y)*splatScale*gaussianSplatCutoffStddev;} else {offsetSplatSpace=vec3f(quadPos.x,quadPos.y,0.0)*splatScale*gaussianSplatCutoffStddev;}
+let vertexObjectSpace=center+splatRotation*offsetSplatSpace;return splatWorld*vec4f(vertexObjectSpace,1.0);}
+#endif
+`;t.IncludesShadersStoreWGSL[e]||(t.IncludesShadersStoreWGSL[e]=s);const l={name:e,shader:s};export{l as g};

python_cad_tools/_viewer_static/assets/gaussianSplatting.fragment-BxeRJ2k-.js

@@ -0,0 +1,38 @@
+import{S as a,ah as l,o as t,ai as c,aj as g,ak as s,al as d}from"./index-B2zBEWsq.js";import{p as f}from"./packingFunctions-DTwzBRBx.js";const n="gaussianSplattingFragmentDeclaration",i=`vec4 gaussianColor(vec4 inColor)
+{float A=-dot(vPosition,vPosition);if (A<-4.0) discard;float B=exp(A)*inColor.a;
+#include<logDepthFragment>
+vec3 color=inColor.rgb;
+#ifdef FOG
+#include<fogFragment>
+#endif
+return vec4(color,B);}
+`;a.IncludesShadersStore[n]||(a.IncludesShadersStore[n]=i);const F={name:n,shader:i},o="gaussianSplattingPixelShader",r=`#include<clipPlaneFragmentDeclaration>
+#include<logDepthDeclaration>
+#include<fogFragmentDeclaration>
+#ifdef GPUPICKER_DEPTH
+layout(location=0) out highp vec4 glFragData[2];
+#endif
+#ifdef GPUPICKER_PACK_DEPTH
+#include<packingFunctions>
+#endif
+varying vec4 vColor;varying vec2 vPosition;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+#include<gaussianSplattingFragmentDeclaration>
+void main () {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+#include<clipPlaneFragment>
+vec4 finalColor=gaussianColor(vColor);
+#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR
+#ifdef GPUPICKER_DEPTH
+glFragData[0]=finalColor;
+#ifdef GPUPICKER_PACK_DEPTH
+glFragData[1]=pack(gl_FragCoord.z);
+#else
+glFragData[1]=vec4(gl_FragCoord.z,0.0,0.0,1.0);
+#endif
+#else
+gl_FragColor=finalColor;
+#endif
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;a.ShadersStore[o]||(a.ShadersStore[o]=r);const S=[l,t,c,f,g,s,F,d];for(const e of S)a.IncludesShadersStore[e.name]||(a.IncludesShadersStore[e.name]=e.shader);const m={name:o,shader:r};export{m as gaussianSplattingPixelShader};

python_cad_tools/_viewer_static/assets/gaussianSplatting.fragment-DNDmvRs-.js

@@ -0,0 +1,37 @@
+import{S as n}from"./index-B2zBEWsq.js";import{c as o,a as s}from"./clipPlaneFragment-BXRtt4jj.js";import{l}from"./logDepthDeclaration-BR8XRz9F.js";import{f,l as c,a as g}from"./fogFragment-DtDlQBnz.js";import{p as S}from"./packingFunctions-BHPwcGG2.js";const a="gaussianSplattingFragmentDeclaration",i=`fn gaussianColor(inColor: vec4f,inPosition: vec2f)->vec4f
+{var A : f32=-dot(inPosition,inPosition);if (A>-4.0)
+{var B: f32=exp(A)*inColor.a;
+#include<logDepthFragment>
+var color: vec3f=inColor.rgb;
+#ifdef FOG
+#include<fogFragment>
+#endif
+return vec4f(color,B);} else {return vec4f(0.0);}}
+`;n.IncludesShadersStoreWGSL[a]||(n.IncludesShadersStoreWGSL[a]=i);const u={name:a,shader:i},t="gaussianSplattingPixelShader",r=`#include<clipPlaneFragmentDeclaration>
+#include<logDepthDeclaration>
+#include<fogFragmentDeclaration>
+#ifdef GPUPICKER_PACK_DEPTH
+#include<packingFunctions>
+#endif
+varying vColor: vec4f;varying vPosition: vec2f;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+#include<gaussianSplattingFragmentDeclaration>
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+#include<clipPlaneFragment>
+var finalColor: vec4f=gaussianColor(input.vColor,input.vPosition);
+#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR
+#ifdef GPUPICKER_DEPTH
+fragmentOutputs.fragData0=finalColor;
+#ifdef GPUPICKER_PACK_DEPTH
+fragmentOutputs.fragData1=pack(fragmentInputs.position.z);
+#else
+fragmentOutputs.fragData1=vec4f(fragmentInputs.position.z,0.0,0.0,1.0);
+#endif
+#else
+fragmentOutputs.color=finalColor;
+#endif
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;n.ShadersStoreWGSL[t]||(n.ShadersStoreWGSL[t]=r);const d=[o,l,f,S,c,g,u,s];for(const e of d)n.IncludesShadersStoreWGSL[e.name]||(n.IncludesShadersStoreWGSL[e.name]=e.shader);const D={name:t,shader:r};export{D as gaussianSplattingPixelShaderWGSL};