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

python_cad_tools/_viewer_static/assets/vertexColorMixing-mdC9xZe1.js

@@ -0,0 +1,418 @@
+import{S as e}from"./index-B2zBEWsq.js";const t="uvAttributeDeclaration",l=`#if defined(UV{X}) && !defined(USE_VERTEX_PULLING)
+attribute uv{X}: vec2f;
+#endif
+`;e.IncludesShadersStoreWGSL[t]||(e.IncludesShadersStoreWGSL[t]=l);const O={name:t,shader:l},i="prePassVertexDeclaration",p=`#ifdef PREPASS
+#ifdef PREPASS_LOCAL_POSITION
+varying vPosition : vec3f;
+#endif
+#ifdef PREPASS_DEPTH
+varying vViewPos: vec3f;
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+varying vNormViewDepth: f32;
+#endif
+#if defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR)
+uniform previousViewProjection: mat4x4f;varying vCurrentPosition: vec4f;varying vPreviousPosition: vec4f;
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[i]||(e.IncludesShadersStoreWGSL[i]=p);const h={name:i,shader:p},a="samplerVertexDeclaration",c=`#if defined(_DEFINENAME_) && _DEFINENAME_DIRECTUV==0
+varying v_VARYINGNAME_UV: vec2f;
+#endif
+`;e.IncludesShadersStoreWGSL[a]||(e.IncludesShadersStoreWGSL[a]=c);const U={name:a,shader:c},r="lightVxUboDeclaration",_=`#ifdef LIGHT{X}
+struct Light{X}
+{vLightData: vec4f,
+vLightDiffuse: vec4f,
+vLightSpecular: vec4f,
+#ifdef SPOTLIGHT{X}
+vLightDirection: vec4f,
+vLightFalloff: vec4f,
+#elif defined(POINTLIGHT{X})
+vLightFalloff: vec4f,
+#elif defined(HEMILIGHT{X})
+vLightGround: vec3f,
+#elif defined(CLUSTLIGHT{X})
+vSliceData: vec2f,
+vSliceRanges: array<vec4f,CLUSTLIGHT_SLICES>,
+#endif
+#if defined(AREALIGHT{X}) && defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+vLightWidth: vec4f,
+vLightHeight: vec4f,
+#endif
+shadowsInfo: vec4f,
+depthValues: vec2f} ;var<uniform> light{X} : Light{X};
+#ifdef SHADOW{X}
+#ifdef SHADOWCSM{X}
+uniform lightMatrix{X}: array<mat4x4f,SHADOWCSMNUM_CASCADES{X}>;varying vPositionFromLight{X}_0: vec4f;varying vDepthMetric{X}_0: f32;varying vPositionFromLight{X}_1: vec4f;varying vDepthMetric{X}_1: f32;varying vPositionFromLight{X}_2: vec4f;varying vDepthMetric{X}_2: f32;varying vPositionFromLight{X}_3: vec4f;varying vDepthMetric{X}_3: f32;varying vPositionFromCamera{X}: vec4f;
+#elif defined(SHADOWCUBE{X})
+#else
+varying vPositionFromLight{X}: vec4f;varying vDepthMetric{X}: f32;uniform lightMatrix{X}: mat4x4f;
+#endif
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[r]||(e.IncludesShadersStoreWGSL[r]=_);const g={name:r,shader:_},f="vertexPullingDeclaration",x=`#ifdef USE_VERTEX_PULLING
+#ifdef VERTEX_PULLING_USE_INDEX_BUFFER
+var<storage,read> indices : array<u32>;
+#endif
+var<storage,read> position : array<f32>;uniform vp_position_info : vec4f;
+#ifdef NORMAL
+var<storage,read> normal : array<f32>;uniform vp_normal_info : vec4f;
+#endif
+#ifdef TANGENT
+var<storage,read> tangent : array<f32>;uniform vp_tangent_info : vec4f;
+#endif
+#ifdef UV1
+var<storage,read> uv : array<f32>;uniform vp_uv_info : vec4f;
+#define VP_UV1_SUPPORTED
+#endif
+#ifdef UV2
+var<storage,read> uv2 : array<f32>;uniform vp_uv2_info : vec4f;
+#define VP_UV2_SUPPORTED
+#endif
+#ifdef UV3
+var<storage,read> uv3 : array<f32>;uniform vp_uv3_info : vec4f;
+#define VP_UV3_SUPPORTED
+#endif
+#ifdef UV4
+var<storage,read> uv4 : array<f32>;uniform vp_uv4_info : vec4f;
+#define VP_UV4_SUPPORTED
+#endif
+#ifdef UV5
+var<storage,read> uv5 : array<f32>;uniform vp_uv5_info : vec4f;
+#define VP_UV5_SUPPORTED
+#endif
+#ifdef UV6
+var<storage,read> uv6 : array<f32>;uniform vp_uv6_info : vec4f;
+#define VP_UV6_SUPPORTED
+#endif
+#ifdef VERTEXCOLOR
+var<storage,read> color : array<f32>;uniform vp_color_info : vec4f;
+#endif
+#if NUM_BONE_INFLUENCERS>0
+var<storage,read> matricesIndices : array<u32>;var<storage,read> matricesWeights : array<f32>;uniform vp_matricesIndices_info : vec4f;uniform vp_matricesWeights_info : vec4f;
+#if NUM_BONE_INFLUENCERS>4
+var<storage,read> matricesIndicesExtra : array<u32>;var<storage,read> matricesWeightsExtra : array<f32>;uniform vp_matricesIndicesExtra_info : vec4f;uniform vp_matricesWeightsExtra_info : vec4f;
+#endif
+#endif
+fn vp_convertToFloat(word : u32,byteInWord : u32,dataType : u32,normalized : bool)->f32 {switch (dataType) {case 5120u: { 
+let shift=byteInWord*8u;let value=(word>>shift) & 0xFFu;let signedValue=f32(i32(value<<24u)>>24u);if (normalized) { return signedValue/127.0; }
+return signedValue;}
+case 5121u: { 
+let shift=byteInWord*8u;let value=(word>>shift) & 0xFFu;if (normalized) { return f32(value)/255.0; }
+return f32(value);}
+case 5122u: { 
+let shift=(byteInWord & 0xFFFFFFFEu)*8u;let value=(word>>shift) & 0xFFFFu;let signedValue=f32(i32(value<<16u)>>16u);if (normalized) { return signedValue/32767.0; }
+return signedValue;}
+case 5123u: { 
+let shift=(byteInWord & 0xFFFFFFFEu)*8u;let value=(word>>shift) & 0xFFFFu;if (normalized) { return f32(value)/65535.0; }
+return f32(value);}
+case 5126u: { 
+return bitcast<f32>(word);}
+default: { return 0.0; }}}
+fn vp_componentSize(dataType : u32)->u32 {return select(select(2u,1u,dataType==5120u || dataType==5121u),4u,dataType==5126u);}
+fn vp_readVertexIndex(index : u32)->u32 {
+#ifndef VERTEX_PULLING_USE_INDEX_BUFFER
+return index;
+#else
+#ifdef VERTEX_PULLING_INDEX_BUFFER_32BITS
+return indices[index];
+#else
+let u32_index=index/2u;let bit_offset=(index & 1u)*16u;return (indices[u32_index]>>bit_offset) & 0xFFFFu;
+#endif
+#endif
+}
+fn vp_readPositionValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(position[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readPosition(info : vec4f,vertexIndex : u32)->vec3f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec3f(
+vp_readPositionValue(offset,dataType,normalized),
+vp_readPositionValue(offset+cs,dataType,normalized),
+vp_readPositionValue(offset+cs*2u,dataType,normalized)
+);}
+#ifdef NORMAL
+fn vp_readNormalValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(normal[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readNormal(info : vec4f,vertexIndex : u32)->vec3f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec3f(
+vp_readNormalValue(offset,dataType,normalized),
+vp_readNormalValue(offset+cs,dataType,normalized),
+vp_readNormalValue(offset+cs*2u,dataType,normalized)
+);}
+#endif
+#ifdef TANGENT
+fn vp_readTangentValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(tangent[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readTangent(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readTangentValue(offset,dataType,normalized),
+vp_readTangentValue(offset+cs,dataType,normalized),
+vp_readTangentValue(offset+cs*2u,dataType,normalized),
+vp_readTangentValue(offset+cs*3u,dataType,normalized)
+);}
+#endif
+#ifdef UV1
+fn vp_readUVValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUVValue(offset,dataType,normalized),
+vp_readUVValue(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV2
+fn vp_readUV2Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv2[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV2(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV2Value(offset,dataType,normalized),
+vp_readUV2Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV3
+fn vp_readUV3Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv3[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV3(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV3Value(offset,dataType,normalized),
+vp_readUV3Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV4
+fn vp_readUV4Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv4[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV4(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV4Value(offset,dataType,normalized),
+vp_readUV4Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV5
+fn vp_readUV5Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv5[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV5(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV5Value(offset,dataType,normalized),
+vp_readUV5Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef UV6
+fn vp_readUV6Value(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(uv6[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readUV6(info : vec4f,vertexIndex : u32)->vec2f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec2f(
+vp_readUV6Value(offset,dataType,normalized),
+vp_readUV6Value(offset+cs,dataType,normalized)
+);}
+#endif
+#ifdef VERTEXCOLOR
+fn vp_readColorValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(color[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readColor(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readColorValue(offset,dataType,normalized),
+vp_readColorValue(offset+cs,dataType,normalized),
+vp_readColorValue(offset+cs*2u,dataType,normalized),
+vp_readColorValue(offset+cs*3u,dataType,normalized)
+);}
+#endif
+#if NUM_BONE_INFLUENCERS>0
+fn vp_readMatrixIndexValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(matricesIndices[byteOffset/4u],byteOffset % 4u,dataType,normalized);}
+fn vp_readBoneIndices(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readMatrixIndexValue(offset,dataType,normalized),
+vp_readMatrixIndexValue(offset+cs,dataType,normalized),
+vp_readMatrixIndexValue(offset+cs*2u,dataType,normalized),
+vp_readMatrixIndexValue(offset+cs*3u,dataType,normalized)
+);}
+fn vp_readMatrixWeightValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(matricesWeights[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readBoneWeights(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readMatrixWeightValue(offset,dataType,normalized),
+vp_readMatrixWeightValue(offset+cs,dataType,normalized),
+vp_readMatrixWeightValue(offset+cs*2u,dataType,normalized),
+vp_readMatrixWeightValue(offset+cs*3u,dataType,normalized)
+);}
+#if NUM_BONE_INFLUENCERS>4
+fn vp_readMatrixIndexExtraValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(matricesIndicesExtra[byteOffset/4u],byteOffset % 4u,dataType,normalized);}
+fn vp_readBoneIndicesExtra(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readMatrixIndexExtraValue(offset,dataType,normalized),
+vp_readMatrixIndexExtraValue(offset+cs,dataType,normalized),
+vp_readMatrixIndexExtraValue(offset+cs*2u,dataType,normalized),
+vp_readMatrixIndexExtraValue(offset+cs*3u,dataType,normalized)
+);}
+fn vp_readMatrixWeightExtraValue(byteOffset : u32,dataType : u32,normalized : bool)->f32 {return vp_convertToFloat(bitcast<u32>(matricesWeightsExtra[byteOffset/4u]),byteOffset % 4u,dataType,normalized);}
+fn vp_readBoneWeightsExtra(info : vec4f,vertexIndex : u32)->vec4f {let baseOffset=u32(info.x);let stride=u32(info.y);let dataType=u32(info.z);let normalized=info.w != 0.0;let offset=baseOffset+vertexIndex*stride;let cs=vp_componentSize(dataType);return vec4f(
+vp_readMatrixWeightExtraValue(offset,dataType,normalized),
+vp_readMatrixWeightExtraValue(offset+cs,dataType,normalized),
+vp_readMatrixWeightExtraValue(offset+cs*2u,dataType,normalized),
+vp_readMatrixWeightExtraValue(offset+cs*3u,dataType,normalized)
+);}
+#endif
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[f]||(e.IncludesShadersStoreWGSL[f]=x);const N={name:f,shader:x},n="vertexPullingVertex",m=`#ifdef USE_VERTEX_PULLING
+let vpVertexIndex: u32=vp_readVertexIndex(vertexInputs.vertexIndex);positionUpdated=vp_readPosition(uniforms.vp_position_info,vpVertexIndex);
+#ifdef NORMAL
+normalUpdated=vp_readNormal(uniforms.vp_normal_info,vpVertexIndex);
+#endif
+#ifdef TANGENT
+tangentUpdated=vp_readTangent(uniforms.vp_tangent_info,vpVertexIndex);
+#endif
+#ifdef UV1
+uvUpdated=vp_readUV(uniforms.vp_uv_info,vpVertexIndex);
+#endif
+#ifdef UV2
+uv2Updated=vp_readUV2(uniforms.vp_uv2_info,vpVertexIndex);
+#endif
+#ifdef UV3
+var uv3Updated: vec2f=vp_readUV3(uniforms.vp_uv3_info,vpVertexIndex);
+#endif
+#ifdef UV4
+var uv4Updated: vec2f=vp_readUV4(uniforms.vp_uv4_info,vpVertexIndex);
+#endif
+#ifdef UV5
+var uv5Updated: vec2f=vp_readUV5(uniforms.vp_uv5_info,vpVertexIndex);
+#endif
+#ifdef UV6
+var uv6Updated: vec2f=vp_readUV6(uniforms.vp_uv6_info,vpVertexIndex);
+#endif
+#ifdef VERTEXCOLOR
+colorUpdated=vp_readColor(uniforms.vp_color_info,vpVertexIndex);
+#endif
+#ifdef MORPHTARGETS
+let vp_basePosition: vec3f=positionUpdated;
+#ifdef NORMAL
+let vp_baseNormal: vec3f=normalUpdated;
+#endif
+#ifdef TANGENT
+let vp_baseTangent: vec4f=tangentUpdated;
+#endif
+#ifdef UV1
+let vp_baseUV: vec2f=uvUpdated;
+#endif
+#ifdef UV2
+let vp_baseUV2: vec2f=uv2Updated;
+#endif
+#ifdef VERTEXCOLOR
+let vp_baseColor: vec4f=colorUpdated;
+#endif
+#endif
+#if NUM_BONE_INFLUENCERS>0
+var vp_matricesIndices: vec4f=vp_readBoneIndices(uniforms.vp_matricesIndices_info,vpVertexIndex);var vp_matricesWeights: vec4f=vp_readBoneWeights(uniforms.vp_matricesWeights_info,vpVertexIndex);
+#if NUM_BONE_INFLUENCERS>4
+var vp_matricesIndicesExtra: vec4f=vp_readBoneIndicesExtra(uniforms.vp_matricesIndicesExtra_info,vpVertexIndex);var vp_matricesWeightsExtra: vec4f=vp_readBoneWeightsExtra(uniforms.vp_matricesWeightsExtra_info,vpVertexIndex);
+#endif
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[n]||(e.IncludesShadersStoreWGSL[n]=m);const P={name:n,shader:m},d="prePassVertex",E=`#ifdef PREPASS_DEPTH
+vertexOutputs.vViewPos=(scene.view*worldPos).rgb;
+#endif
+#ifdef PREPASS_NORMALIZED_VIEW_DEPTH
+vertexOutputs.vNormViewDepth=((scene.view*worldPos).z-uniforms.cameraInfo.x)/(uniforms.cameraInfo.y-uniforms.cameraInfo.x);
+#endif
+#ifdef PREPASS_LOCAL_POSITION
+vertexOutputs.vPosition=positionUpdated.xyz;
+#endif
+#if (defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR)) && defined(BONES_VELOCITY_ENABLED)
+vertexOutputs.vCurrentPosition=scene.viewProjection*worldPos;
+#if NUM_BONE_INFLUENCERS>0
+var previousInfluence: mat4x4f;previousInfluence=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[0])]*vertexInputs.matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[1])]*vertexInputs.matricesWeights[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>2
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[2])]*vertexInputs.matricesWeights[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>3
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[3])]*vertexInputs.matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[0])]*vertexInputs.matricesWeightsExtra[0];
+#endif 
+#if NUM_BONE_INFLUENCERS>5
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[1])]*vertexInputs.matricesWeightsExtra[1];
+#endif 
+#if NUM_BONE_INFLUENCERS>6
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[2])]*vertexInputs.matricesWeightsExtra[2];
+#endif 
+#if NUM_BONE_INFLUENCERS>7
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[3])]*vertexInputs.matricesWeightsExtra[3];
+#endif
+vertexOutputs.vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld*previousInfluence* vec4f(positionUpdated,1.0);
+#else
+vertexOutputs.vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld* vec4f(positionUpdated,1.0);
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[d]||(e.IncludesShadersStoreWGSL[d]=E);const L={name:d,shader:E},o="uvVariableDeclaration",V=`#ifdef MAINUV{X}
+#if !defined(UV{X})
+var uv{X}: vec2f=vec2f(0.,0.);
+#elif defined(USE_VERTEX_PULLING)
+var uv{X}: vec2f=uv{X}Updated;
+#else
+var uv{X}: vec2f=vertexInputs.uv{X};
+#endif
+vertexOutputs.vMainUV{X}=uv{X};
+#endif
+`;e.IncludesShadersStoreWGSL[o]||(e.IncludesShadersStoreWGSL[o]=V);const z={name:o,shader:V},s="samplerVertexImplementation",I=`#if defined(_DEFINENAME_) && _DEFINENAME_DIRECTUV==0
+if (uniforms.v_INFONAME_==0.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(uvUpdated,1.0,0.0)).xy;}
+#ifdef UV2
+else if (uniforms.v_INFONAME_==1.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(uv2Updated,1.0,0.0)).xy;}
+#endif
+#ifdef UV3
+else if (uniforms.v_INFONAME_==2.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(vertexInputs.uv3,1.0,0.0)).xy;}
+#endif
+#ifdef UV4
+else if (uniforms.v_INFONAME_==3.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(vertexInputs.uv4,1.0,0.0)).xy;}
+#endif
+#ifdef UV5
+else if (uniforms.v_INFONAME_==4.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(vertexInputs.uv5,1.0,0.0)).xy;}
+#endif
+#ifdef UV6
+else if (uniforms.v_INFONAME_==5.)
+{vertexOutputs.v_VARYINGNAME_UV= (uniforms._MATRIXNAME_Matrix* vec4f(vertexInputs.uv6,1.0,0.0)).xy;}
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[s]||(e.IncludesShadersStoreWGSL[s]=I);const b={name:s,shader:I},u="shadowsVertex",y=`#ifdef SHADOWS
+#if defined(SHADOWCSM{X})
+#ifdef SCENE_UBO
+vertexOutputs.vPositionFromCamera{X}=scene.view*worldPos;
+#else
+vertexOutputs.vPositionFromCamera{X}=uniforms.view*worldPos;
+#endif
+#if SHADOWCSMNUM_CASCADES{X}>0
+vertexOutputs.vPositionFromLight{X}_0=uniforms.lightMatrix{X}[0]*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}_0=(-vertexOutputs.vPositionFromLight{X}_0.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}_0= (vertexOutputs.vPositionFromLight{X}_0.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif
+#if SHADOWCSMNUM_CASCADES{X}>1
+vertexOutputs.vPositionFromLight{X}_1=uniforms.lightMatrix{X}[1]*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}_1=(-vertexOutputs.vPositionFromLight{X}_1.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}_1= (vertexOutputs.vPositionFromLight{X}_1.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif 
+#if SHADOWCSMNUM_CASCADES{X}>2
+vertexOutputs.vPositionFromLight{X}_2=uniforms.lightMatrix{X}[2]*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}_2=(-vertexOutputs.vPositionFromLight{X}_2.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}_2= (vertexOutputs.vPositionFromLight{X}_2.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif 
+#if SHADOWCSMNUM_CASCADES{X}>3
+vertexOutputs.vPositionFromLight{X}_3=uniforms.lightMatrix{X}[3]*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}_3=(-vertexOutputs.vPositionFromLight{X}_3.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}_3= (vertexOutputs.vPositionFromLight{X}_3.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif 
+#elif defined(SHADOW{X}) && !defined(SHADOWCUBE{X})
+vertexOutputs.vPositionFromLight{X}=uniforms.lightMatrix{X}*worldPos;
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric{X}=(-vertexOutputs.vPositionFromLight{X}.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#else
+vertexOutputs.vDepthMetric{X}=(vertexOutputs.vPositionFromLight{X}.z+light{X}.depthValues.x)/light{X}.depthValues.y;
+#endif
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[u]||(e.IncludesShadersStoreWGSL[u]=y);const X={name:u,shader:y},v="vertexColorMixing",S=`#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+vertexOutputs.vColor=vec4f(1.0);
+#ifdef VERTEXCOLOR
+#ifdef VERTEXALPHA
+vertexOutputs.vColor*=colorUpdated;
+#else
+vertexOutputs.vColor=vec4f(vertexOutputs.vColor.rgb*colorUpdated.rgb,vertexOutputs.vColor.a);
+#endif
+#endif
+#ifdef INSTANCESCOLOR
+vertexOutputs.vColor*=vertexInputs.instanceColor;
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[v]||(e.IncludesShadersStoreWGSL[v]=S);const M={name:v,shader:S};export{P as a,L as b,z as c,b as d,X as e,M as f,g as l,h as p,U as s,O as u,N as v};

python_cad_tools/_viewer_static/favicon.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Python CAD Tools Viewer">
+  <defs>
+    <linearGradient id="brand" x1="8" y1="4" x2="56" y2="60" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#0b8db6"/>
+      <stop offset="1" stop-color="#075e7c"/>
+    </linearGradient>
+  </defs>
+  <rect width="64" height="64" rx="16" fill="url(#brand)"/>
+  <path fill="#fff" d="M20 14h14.8c8.6 0 13.4 4 13.4 10.4 0 4.1-2 7.1-5.6 8.7 4.7 1.5 7.4 4.8 7.4 9.6C50 50 44.5 54 35 54H20V14Zm14 16c4.3 0 6.5-1.7 6.5-5s-2.2-4.8-6.5-4.8h-6.2V30H34Zm.9 17.7c4.8 0 7.3-1.9 7.3-5.7s-2.5-5.8-7.3-5.8h-7.1v11.5h7.1Z"/>
+</svg>

python_cad_tools/_viewer_static/index.html

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
+    <meta name="theme-color" content="#101820" />
+    <meta name="description" content="Python CAD Tools artifact viewer" />
+    <link rel="icon" href="./favicon.svg" type="image/svg+xml" />
+    <link rel="manifest" href="./app.webmanifest" />
+    <title>Python CAD Tools Viewer</title>
+    <script type="module" crossorigin src="./assets/index-B2zBEWsq.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-DcTTrc-8.css">
+  </head>
+  <body>
+    <a class="skip-link" href="#viewer-canvas">Skip to 3D viewer</a>
+    <div id="app"></div>
+  </body>
+</html>

python_cad_tools/_viewer_static/sw.js

@@ -0,0 +1,61 @@
+const CACHE_PREFIX = "python-cad-tools-viewer";
+
+function scopeIdentity() {
+  return new URL(self.registration.scope).pathname;
+}
+
+function cacheName(toolVersion, designBuildHash) {
+  return `${CACHE_PREFIX}|${scopeIdentity()}|${toolVersion}|${designBuildHash}`;
+}
+
+self.addEventListener("install", (event) => {
+  event.waitUntil(caches.open(`${CACHE_PREFIX}|bootstrap|${scopeIdentity()}`).then((cache) => cache.addAll(["./", "./index.html"])));
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("message", (event) => {
+  if (event.data?.type !== "CACHE_SITE") return;
+  event.waitUntil((async () => {
+    const port = event.ports[0];
+    try {
+      const { toolVersion, designBuildHash } = event.data;
+      if (typeof toolVersion !== "string" || !/^[0-9a-f]{64}$/.test(designBuildHash)) throw new Error("Invalid cache identity");
+      const name = cacheName(toolVersion, designBuildHash);
+      const cache = await caches.open(name);
+      const urls = [...new Set(event.data.urls || [])].map((url) => new URL(url, self.registration.scope));
+      for (const url of urls) {
+        if (url.origin !== self.location.origin || !url.href.startsWith(self.registration.scope)) throw new Error(`Unsafe cache URL: ${url}`);
+        const response = await fetch(url, { cache: "reload" });
+        if (!response.ok) throw new Error(`Unable to cache ${url.pathname}: ${response.status}`);
+        await cache.put(url, response);
+      }
+      const prefix = `${CACHE_PREFIX}|${scopeIdentity()}|`;
+      await Promise.all((await caches.keys()).filter((key) => key.startsWith(prefix) && key !== name).map((key) => caches.delete(key)));
+      port?.postMessage({ ok: true, cache: name });
+    } catch (error) {
+      port?.postMessage({ ok: false, error: error instanceof Error ? error.message : String(error) });
+    }
+  })());
+});
+
+self.addEventListener("fetch", (event) => {
+  if (event.request.method !== "GET" || new URL(event.request.url).origin !== self.location.origin) return;
+  event.respondWith((async () => {
+    try {
+      const response = await fetch(event.request);
+      if (response.ok) {
+        const names = (await caches.keys()).filter((key) => key.startsWith(`${CACHE_PREFIX}|${scopeIdentity()}|`));
+        await Promise.all(names.map(async (name) => (await caches.open(name)).put(event.request, response.clone())));
+      }
+      return response;
+    } catch (error) {
+      const cached = await caches.match(event.request, { ignoreSearch: false });
+      if (cached) return cached;
+      throw error;
+    }
+  })());
+});