@vived/component-abb-6700 1.0.0

package/dist/logDepthVertex-CXkmZels.js

@@ -0,0 +1,459 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const t = "uvAttributeDeclaration", _ = `#if defined(UV{X}) && !defined(USE_VERTEX_PULLING)
+attribute uv{X}: vec2f;
+#endif
+`;
+e.IncludesShadersStoreWGSL[t] || (e.IncludesShadersStoreWGSL[t] = _);
+const i = "prePassVertexDeclaration", x = `#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] = x);
+const f = "samplerVertexDeclaration", m = `#if defined(_DEFINENAME_) && _DEFINENAME_DIRECTUV==0
+varying v_VARYINGNAME_UV: vec2f;
+#endif
+`;
+e.IncludesShadersStoreWGSL[f] || (e.IncludesShadersStoreWGSL[f] = m);
+const r = "fogVertexDeclaration", E = `#ifdef FOG
+varying vFogDistance: vec3f;
+#endif
+`;
+e.IncludesShadersStoreWGSL[r] || (e.IncludesShadersStoreWGSL[r] = E);
+const a = "lightVxUboDeclaration", V = `#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[a] || (e.IncludesShadersStoreWGSL[a] = V);
+const n = "vertexPullingDeclaration", I = `#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[n] || (e.IncludesShadersStoreWGSL[n] = I);
+const d = "vertexPullingVertex", y = `#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[d] || (e.IncludesShadersStoreWGSL[d] = y);
+const o = "prePassVertex", S = `#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[o] || (e.IncludesShadersStoreWGSL[o] = S);
+const s = "uvVariableDeclaration", O = `#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[s] || (e.IncludesShadersStoreWGSL[s] = O);
+const u = "samplerVertexImplementation", T = `#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[u] || (e.IncludesShadersStoreWGSL[u] = T);
+const v = "fogVertex", h = `#ifdef FOG
+#ifdef SCENE_UBO
+vertexOutputs.vFogDistance=(scene.view*worldPos).xyz;
+#else
+vertexOutputs.vFogDistance=(uniforms.view*worldPos).xyz;
+#endif
+#endif
+`;
+e.IncludesShadersStoreWGSL[v] || (e.IncludesShadersStoreWGSL[v] = h);
+const l = "shadowsVertex", U = `#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[l] || (e.IncludesShadersStoreWGSL[l] = U);
+const p = "vertexColorMixing", g = `#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[p] || (e.IncludesShadersStoreWGSL[p] = g);
+const c = "logDepthVertex", N = `#ifdef LOGARITHMICDEPTH
+vertexOutputs.vFragmentDepth=1.0+vertexOutputs.position.w;vertexOutputs.position.z=log2(max(0.000001,vertexOutputs.vFragmentDepth))*uniforms.logarithmicDepthConstant;
+#endif
+`;
+e.IncludesShadersStoreWGSL[c] || (e.IncludesShadersStoreWGSL[c] = N);

package/dist/mesh.vertexData.functions-Bc9lJlrU.js

@@ -0,0 +1,74 @@
+function l(o) {
+  return Math.floor(o / 8);
+}
+function y(o) {
+  return 1 << o % 8;
+}
+class x {
+  /**
+   * Creates a new bit array with a fixed size.
+   * @param size The number of bits to store.
+   */
+  constructor(e) {
+    this.size = e, this._byteArray = new Uint8Array(Math.ceil(this.size / 8));
+  }
+  /**
+   * Gets the current value at the specified index.
+   * @param bitIndex The index to get the value from.
+   * @returns The value at the specified index.
+   */
+  get(e) {
+    if (e >= this.size)
+      throw new RangeError("Bit index out of range");
+    const n = l(e), r = y(e);
+    return (this._byteArray[n] & r) !== 0;
+  }
+  /**
+   * Sets the value at the specified index.
+   * @param bitIndex The index to set the value at.
+   * @param value The value to set.
+   */
+  set(e, n) {
+    if (e >= this.size)
+      throw new RangeError("Bit index out of range");
+    const r = l(e), s = y(e);
+    n ? this._byteArray[r] |= s : this._byteArray[r] &= ~s;
+  }
+}
+function w(o) {
+  const e = [], n = o.length / 3;
+  for (let t = 0; t < n; t++)
+    e.push([o[t * 3], o[t * 3 + 1], o[t * 3 + 2]]);
+  const r = /* @__PURE__ */ new Map();
+  for (let t = 0; t < e.length; t++) {
+    const a = e[t];
+    for (const c of a) {
+      let f = r.get(c);
+      f || r.set(c, f = []), f.push(t);
+    }
+  }
+  const s = new x(n), h = [], p = (t) => {
+    const a = [t];
+    for (; a.length > 0; ) {
+      const c = a.pop();
+      if (!s.get(c)) {
+        s.set(c, !0), h.push(e[c]);
+        for (const f of e[c]) {
+          const u = r.get(f);
+          if (!u)
+            return;
+          for (const g of u)
+            s.get(g) || a.push(g);
+        }
+      }
+    }
+  };
+  for (let t = 0; t < n; t++)
+    s.get(t) || p(t);
+  let i = 0;
+  for (const t of h)
+    o[i++] = t[0], o[i++] = t[1], o[i++] = t[2];
+}
+export {
+  w as OptimizeIndices
+};