@rings-webgpu/core 1.0.11 → 1.0.13

package/dist/rings.es.max.js

@@ -2113,7 +2113,7 @@ function GetShader(name) {
 }
 
 var __defProp$2 = Object.defineProperty;
-var __decorateClass$j = (decorators, target, key, kind) => {
+var __decorateClass$m = (decorators, target, key, kind) => {
   var result = void 0 ;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
@@ -2216,10 +2216,10 @@ const _Struct = class _Struct {
     return struct.__size;
   }
 };
-__decorateClass$j([
+__decorateClass$m([
   NonSerialize
 ], _Struct.prototype, "__refection");
-__decorateClass$j([
+__decorateClass$m([
   NonSerialize
 ], _Struct.prototype, "__size");
 let Struct = _Struct;
@@ -5025,18 +5025,20 @@ class SkeletonAnimation_shader {
   }
 }
 
-let VertexAttributes_vert = `
+let VertexAttributes_vert = (
+  /*wgsl*/
+  `
     var<private> PI: f32 = 3.14159265359;
     #if USE_METAHUMAN
         ${MorphTarget_shader.getMorphTargetShaderBinding(3, 0)}
-        ${SkeletonAnimation_shader.groupBindingAndFunctions(3, 2)}
+        ${SkeletonAnimation_shader.groupBindingAndFunctions(3, 2)} 
     #else
         #if USE_MORPHTARGETS
             ${MorphTarget_shader.getMorphTargetShaderBinding(3, 0)}
         #endif
 
         #if USE_SKELETON
-            ${SkeletonAnimation_shader.groupBindingAndFunctions(3, 0)}
+            ${SkeletonAnimation_shader.groupBindingAndFunctions(3, 0)} 
         #endif
     #endif
 
@@ -5071,6 +5073,10 @@ let VertexAttributes_vert = `
                 #endif
             #endif
         #else
+            #if USE_TANGENT
+                @location(auto) TANGENT: vec4<f32>,
+            #endif
+
             #if USE_SKELETON
                 #if USE_TANGENT
                     @location(auto) joints0: vec4<f32>,
@@ -5117,6 +5123,7 @@ let VertexAttributes_vert = `
     #if USE_TANGENT
         @location(auto) varying_Tangent: vec4<f32>,
     #endif
+   
 
     @builtin(position) member: vec4<f32>
     };
@@ -5166,23 +5173,24 @@ let VertexAttributes_vert = `
         clipPosition.z = log2Depth(clipPosition.w, globalUniform.near, globalUniform.far);
     #endif
 
-    ORI_CameraWorldDir = normalize(ORI_CAMERAMATRIX[3].xyz - worldPos.xyz);
+    ORI_CameraWorldDir = normalize(ORI_CAMERAMATRIX[3].xyz - worldPos.xyz) ;
 
-    ORI_VertexOut.index = f32(vertex.index);
+    ORI_VertexOut.index = f32(vertex.index) ;
 
-    ORI_VertexOut.varying_UV0 = vertex.uv.xy;
+    ORI_VertexOut.varying_UV0 = vertex.uv.xy ;
 
     ORI_VertexOut.varying_UV1 = vertex.TEXCOORD_1.xy;
 
-    ORI_VertexOut.varying_ViewPos = viewPosition;
-    ORI_VertexOut.varying_Clip = clipPosition;
-    ORI_VertexOut.varying_WPos = worldPos;
+    ORI_VertexOut.varying_ViewPos = viewPosition ;
+    ORI_VertexOut.varying_Clip = clipPosition ;
+    ORI_VertexOut.varying_WPos = worldPos ;
     ORI_VertexOut.varying_WPos.w = f32(vertex.index);
-    ORI_VertexOut.varying_WNormal = normalize(ORI_NORMALMATRIX * vertexNormal.xyz);
+    ORI_VertexOut.varying_WNormal = normalize(ORI_NORMALMATRIX * vertexNormal.xyz) ;
 
-    ORI_VertexOut.member = clipPosition;
+    ORI_VertexOut.member = clipPosition ;
     }
-`;
+`
+);
 
 let VideoUniform_frag = `
 struct MaterialUniform {
@@ -5301,68 +5309,90 @@ let Inline_vert = (
 `
 );
 
-let Common_frag = `
-    #include "GlobalUniform"
-    #include "FragmentVarying"
-    #include "FragmentOutput"
-    #include "ShadingInput"
-    #include "ColorUtil_frag"
-    #include "BitUtil"
-
-    var<private> ORI_FragmentOutput: FragmentOutput;
-    var<private> ORI_VertexVarying: FragmentVarying;
-    var<private> ORI_ShadingInput: ShadingInput;
-    var<private> viewDir:vec3<f32>;
-    var<private> modelIndex:u32;
+let Common_frag = (
+  /*wgsl*/
+  `
+  #include "GlobalUniform"
+  #include "FragmentVarying"
+  #include "FragmentOutput"
+  #include "ShadingInput"
+  #include "ColorUtil_frag"
+  #include "BitUtil"
 
-    @fragment
-    fn FragMain( vertex_varying:FragmentVarying ) -> FragmentOutput {
-        modelIndex = u32(round(vertex_varying.index));
-        ORI_VertexVarying = vertex_varying;
-        ORI_VertexVarying.vWorldNormal = normalize(vertex_varying.vWorldNormal);
+  var<private> ORI_FragmentOutput: FragmentOutput;
+  var<private> ORI_VertexVarying: FragmentVarying;
+  var<private> ORI_ShadingInput: ShadingInput;
+  var<private> viewDir:vec3<f32>;
+  var<private> modelIndex:u32;
+  
+  @fragment
+  fn FragMain( vertex_varying:FragmentVarying ) -> FragmentOutput {
         ORI_FragmentOutput.color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-        viewDir = normalize(globalUniform.CameraPos.xyz - ORI_VertexVarying.vWorldPos.xyz);
-        frag();
+    ORI_VertexVarying = vertex_varying;
+    ORI_VertexVarying.vWorldNormal = normalize(vertex_varying.vWorldNormal);
+    ORI_FragmentOutput.color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
+    viewDir = normalize(globalUniform.CameraPos.xyz - ORI_VertexVarying.vWorldPos.xyz) ;
 
-        #if USE_DEBUG
-            debugFragmentOut();
-        #endif
+    frag();
+    
+    #if USE_DEBUG
+      debugFragmentOut();
+    #endif
 
-        #if USE_OUTDEPTH
-            #if USE_LOGDEPTH
-                ORI_FragmentOutput.out_depth = log2DepthFixPersp(ORI_VertexVarying.fragPosition.w, globalUniform.near, globalUniform.far);
-            #else
-                ORI_FragmentOutput.out_depth = ORI_ShadingInput.FragDepth;
-            #endif
-        #endif
+    #if USE_DEFAULTFRAGOUT
+      // let finalMatrix = globalUniform.projMat * globalUniform.viewMat ;
+      // let nMat = mat3x3<f32>(finalMatrix[0].xyz,finalMatrix[1].xyz,finalMatrix[2].xyz) ;
+      // let ORI_NORMALMATRIX = transpose(inverse( nMat ));
+      // var vNormal = normalize(ORI_NORMALMATRIX * (ORI_VertexVarying.vWorldNormal));
+
+      // let gBuffer = packNHMDGBuffer(
+      //   ORI_VertexVarying.fragCoord.z,
+      //   ORI_ShadingInput.BaseColor.rgb,
+      //   ORI_ShadingInput.BaseColor.rgb,
+      //   vec3f(ORI_ShadingInput.Roughness,ORI_ShadingInput.Metallic,ORI_ShadingInput.AmbientOcclusion),
+      //   ORI_ShadingInput.Normal,
+      //   ORI_ShadingInput.Opacity
+      // ) ;
+    #endif
 
-        return ORI_FragmentOutput;
-    }
+    #if USE_OUTDEPTH
+      #if USE_LOGDEPTH
+        ORI_FragmentOutput.out_depth = log2DepthFixPersp(ORI_VertexVarying.fragPosition.w, globalUniform.near, globalUniform.far);
+      #else
+        ORI_FragmentOutput.out_depth = ORI_ShadingInput.FragDepth ;
+      #endif
+    #endif
 
-    fn packNHMDGBuffer(depth:f32, albedo:vec3f,hdrLighting:vec3f,rmao:vec3f,normal:vec3f,alpha:f32) -> vec4f {
-        var gBuffer : vec4f;
-        var octUVNormal = (octEncode(normalize( (normal) )) + 1.0) * 0.5;
-        var yc = f32(r11g11b9_to_float(vec3f(octUVNormal,rmao.r)));
-        #if USE_CASTREFLECTION
-            var rgbm = EncodeRGBM(hdrLighting);
-            var zc = f32(pack4x8unorm(vec4f(rgbm.rgb,0.0))) ;
-            var wc = f32(pack4x8unorm(vec4f(rmao.rg,rgbm.a,0.0)));
-        #else
-            var zc = f32(vec4fToFloat_7bits(vec4f(albedo.rgb,alpha)));
-            var wc = f32(r22g8_to_float(vec2f(f32(modelIndex)/f_r22g8.r,rmao.g)));
-        #endif
+    return ORI_FragmentOutput ;
+  }
 
-        gBuffer.x = depth ;
-        gBuffer.y = yc;
-        gBuffer.z = zc;
-        gBuffer.w = wc;
-        return gBuffer;
-    }
 
-    fn transformUV( uv:vec2f , offsetScale:vec4f ) -> vec2f{
-        return uv * offsetScale.zw + offsetScale.xy;
-    }
-`;
+  fn packNHMDGBuffer(depth:f32, albedo:vec3f,hdrLighting:vec3f,rmao:vec3f,normal:vec3f,alpha:f32) -> vec4f  {
+      var gBuffer : vec4f ;
+      var octUVNormal = (octEncode(normalize( (normal) )) + 1.0) * 0.5 ;
+      var yc = f32(r11g11b9_to_float(vec3f(octUVNormal,rmao.r))) ;
+      #if USE_CASTREFLECTION
+        var rgbm = EncodeRGBM(hdrLighting);
+        var zc = f32(pack4x8unorm(vec4f(rgbm.rgb,0.0))) ;
+        var wc = f32(pack4x8unorm(vec4f(rmao.rg,rgbm.a,0.0)));
+      #else
+        var zc = f32(vec4fToFloat_7bits(vec4f(albedo.rgb,alpha)));
+        var wc = f32(r22g8_to_float(vec2f(f32(modelIndex)/f_r22g8.r,rmao.g)));
+      #endif
+
+      gBuffer.x = depth  ;
+      gBuffer.y = yc ;
+      gBuffer.z = zc ;
+      gBuffer.w = wc ;
+      return gBuffer ;
+  }
+
+  fn transformUV( uv:vec2f , offsetScale:vec4f ) -> vec2f{
+     return uv * offsetScale.zw + offsetScale.xy ;
+  }
+
+`
+);
 
 let Common_vert = (
   /*wgsl*/
@@ -5732,6 +5762,7 @@ let FragmentVarying = `
 let FragmentOutput = `
     #if USE_CASTREFLECTION
         struct FragmentOutput {
+            @location(auto) color: vec4<f32>,
             @location(auto) gBuffer: vec4<f32>,
             #if USE_OUTDEPTH
                 @builtin(frag_depth) out_depth: f32
@@ -9525,6 +9556,186 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
 }
 `;
 
+const FatLine_VS = (
+  /* wgsl */
+  `
+    #include "GlobalUniform"
+    
+    // Instance attributes stored in storage buffer
+    // Extended with prevDir and nextDir for Line Join support
+struct InstanceData {
+    start: vec3<f32>,
+    _padding1: f32,
+    end: vec3<f32>,
+    _padding2: f32,
+    colorStart: vec3<f32>,
+    _padding3: f32,
+    colorEnd: vec3<f32>,
+    _padding4: f32,
+};
+
+    struct VertexInput {
+        @builtin(instance_index) instanceIndex: u32,
+        @location(0) position: vec3<f32>,  // Quad vertices
+        @location(1) uv: vec2<f32>,        // UV coordinates
+    };
+
+    struct VertexOutput {
+        @builtin(position) position: vec4<f32>,
+        @location(0) vUv: vec2<f32>,
+        @location(1) vColor: vec3<f32>,
+    };
+
+    struct MaterialUniform {
+        baseColor: vec4<f32>,
+        lineWidth: f32,
+        opacity: f32,
+        resolution: vec2<f32>,
+        modelMatrix: mat4x4<f32>,
+    };
+
+    @group(1) @binding(0) var<uniform> materialUniform: MaterialUniform;
+    @group(1) @binding(1) var<storage, read> instances: array<InstanceData>;
+
+    @vertex
+    fn VertMain(input: VertexInput) -> VertexOutput {
+        var output: VertexOutput;
+        
+        let instance = instances[input.instanceIndex];
+        
+        // Transform from local space to world space, then to view space
+        let start_world = materialUniform.modelMatrix * vec4<f32>(instance.start, 1.0);
+        let end_world = materialUniform.modelMatrix * vec4<f32>(instance.end, 1.0);
+        
+        let start_view = globalUniform.viewMat * start_world;
+        let end_view = globalUniform.viewMat * end_world;
+        
+        // Project to clip space
+        var clip_start = globalUniform.projMat * start_view;
+        var clip_end = globalUniform.projMat * end_view;
+        
+        // Perspective division to NDC space
+        let ndc_start = clip_start.xyz / clip_start.w;
+        let ndc_end = clip_end.xyz / clip_end.w;
+        
+        // Calculate screen-space direction
+        var dir = ndc_end.xy - ndc_start.xy;
+        
+        // Account for aspect ratio
+        let aspect = materialUniform.resolution.x / materialUniform.resolution.y;
+        dir.x *= aspect;
+        dir = normalize(dir);
+        
+        // Calculate perpendicular offset
+        var offset = vec2<f32>(dir.y, -dir.x);
+        
+        // Undo aspect ratio adjustment for both dir and offset
+        dir.x /= aspect;
+        offset.x /= aspect;
+        
+        // Flip offset direction based on position.x
+        if (input.position.x < 0.0) {
+            offset *= -1.0;
+        }
+        
+        // Handle endcaps
+        if (input.position.y < 0.0) {
+            offset += -dir;
+        } else if (input.position.y > 1.0) {
+            offset += dir;
+        }
+        
+        // Apply line width
+        offset *= materialUniform.lineWidth;
+        offset /= materialUniform.resolution.y;  // Convert to clip space
+        
+        // Select start or end point
+        var clip = select(clip_end, clip_start, input.position.y < 0.5);
+        
+        // Shift the depth of the projected points so the line segments
+        // overlap neatly and face the camera properly (billboard effect)
+        let clipPose = select(ndc_end, ndc_start, input.position.y < 0.5);
+        clip.z = clipPose.z * clip.w;
+        
+        // Perspective correction
+        offset *= clip.w;
+        clip.x += offset.x;
+        clip.y += offset.y;
+        
+        output.position = clip;
+        output.vUv = input.uv;
+        output.vColor = select(instance.colorEnd, instance.colorStart, input.position.y < 0.5);
+        
+        return output;
+    }
+`
+);
+const FatLine_FS = (
+  /* wgsl */
+  `
+    struct FragmentOutput {
+        @location(0) color: vec4<f32>,
+        @location(1) gBuffer: vec4<f32>,
+    };
+
+    struct VertexOutput {
+        @builtin(position) position: vec4<f32>,
+        @location(0) vUv: vec2<f32>,
+        @location(1) vColor: vec3<f32>,
+    };
+
+    struct MaterialUniform {
+        baseColor: vec4<f32>,
+        lineWidth: f32,
+        opacity: f32,
+        resolution: vec2<f32>,
+        modelMatrix: mat4x4<f32>,
+    };
+
+    @group(1) @binding(0) var<uniform> materialUniform: MaterialUniform;
+
+    @fragment
+    fn FragMain(input: VertexOutput) -> FragmentOutput {
+        var output: FragmentOutput;
+        
+        var alpha = materialUniform.opacity;
+        
+        // Round endcap rendering with anti-aliasing
+        let a = input.vUv.x;
+        let b = select(input.vUv.y - 1.0, input.vUv.y + 1.0, input.vUv.y > 0.0);
+        let len2 = a * a + b * b;
+        
+        // Calculate derivative (must be in uniform control flow)
+        let dlen = fwidth(len2);
+        
+        // Round endcap rendering - simple approach
+        if (abs(input.vUv.y) > 1.0) {
+            // Determine circle center: (0, 1) for top, (0, -1) for bottom
+            var basePoint = select(
+                vec2<f32>(0.0, -1.0),  // Bottom endcap
+                vec2<f32>(0.0, 1.0),   // Top endcap
+                input.vUv.y > 0.0
+            );
+            
+            // Distance from UV to circle center
+            // var dist = length(input.vUv - basePoint);
+            var dist2 = (input.vUv.x - basePoint.x) * (input.vUv.x - basePoint.x) + (input.vUv.y - basePoint.y) * (input.vUv.y - basePoint.y);
+            
+            // Discard pixels outside circle (radius = 1.0)
+            if (dist2 > 1.0) {
+                discard;
+            }
+        }
+        
+        let color = input.vColor * materialUniform.baseColor.rgb;
+        output.color = vec4<f32>(color, alpha);
+        output.gBuffer = vec4<f32>(0.0, 0.0, 0.0, 0.0); // No GBuffer data for lines
+        
+        return output;
+    }
+`
+);
+
 class ShaderLib {
   static init() {
     ShaderLib.register("MathShader", MathShader);
@@ -9594,6 +9805,8 @@ class ShaderLib {
     );
     ShaderLib.register("ZPass_shader_vs", ZPassShader_vs);
     ShaderLib.register("ZPass_shader_fs", ZPassShader_fs);
+    ShaderLib.register("FatLine_VS", FatLine_VS);
+    ShaderLib.register("FatLine_FS", FatLine_FS);
   }
   static register(keyName, code) {
     if (!ShaderLib[keyName.toLowerCase()]) {
@@ -21680,9 +21893,9 @@ class OctreeEntity {
 }
 
 var __defProp$1 = Object.defineProperty;
-var __getOwnPropDesc$i = Object.getOwnPropertyDescriptor;
-var __decorateClass$i = (decorators, target, key, kind) => {
-  var result = __getOwnPropDesc$i(target, key) ;
+var __getOwnPropDesc$l = Object.getOwnPropertyDescriptor;
+var __decorateClass$l = (decorators, target, key, kind) => {
+  var result = __getOwnPropDesc$l(target, key) ;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(target, key, result) ) || result;
@@ -22267,221 +22480,16 @@ class RenderNode extends ComponentBase {
     this._combineShaderRefection = void 0;
   }
 }
-__decorateClass$i([
+__decorateClass$l([
   EditorInspector
 ], RenderNode.prototype, "materials");
-__decorateClass$i([
+__decorateClass$l([
   EditorInspector
 ], RenderNode.prototype, "castShadow");
-__decorateClass$i([
+__decorateClass$l([
   EditorInspector
 ], RenderNode.prototype, "castGI");
 
-class Shader {
-  computes;
-  passShader;
-  constructor() {
-    this.computes = [];
-    this.passShader = /* @__PURE__ */ new Map();
-  }
-  addRenderPass(renderShader, index = -1) {
-    let subShader = this.passShader.get(renderShader.passType) || [];
-    if (index == -1) {
-      subShader.push(renderShader);
-    } else {
-      subShader.splice(index, -1, renderShader);
-    }
-    this.passShader.set(renderShader.passType, subShader);
-  }
-  removeShader(renderShader, index = -1) {
-    let subShader = this.passShader.get(
-      renderShader.passType
-    );
-    if (subShader) {
-      if (index == -1) {
-        let index2 = subShader.indexOf(renderShader);
-        if (index2 != -1) {
-          subShader.splice(index2);
-        }
-      } else {
-        subShader.splice(index, 1);
-      }
-    }
-  }
-  removeShaderByIndex(passType, index = -1) {
-    let subShader = this.passShader.get(passType);
-    if (subShader) {
-      if (index == -1) {
-        this.passShader.delete(passType);
-      } else {
-        subShader.splice(index, 1);
-      }
-    }
-  }
-  getSubShaders(passType) {
-    return this.passShader.get(passType) || [];
-  }
-  hasSubShaders(passType) {
-    let subs = this.passShader.get(passType);
-    return subs.length > 0;
-  }
-  getDefaultShaders() {
-    return this.passShader.get(PassType.COLOR);
-  }
-  getDefaultColorShader() {
-    return this.passShader.get(PassType.COLOR)[0];
-  }
-  setDefine(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setDefine(arg0, arg1);
-      }
-    }
-  }
-  hasDefine(arg0) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        let has = rd.hasDefine(arg0);
-        if (has) return has;
-      }
-    }
-    return false;
-  }
-  deleteDefine(arg0) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.deleteDefine(arg0);
-      }
-    }
-  }
-  setUniform(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setUniform(arg0, arg1);
-      }
-    }
-  }
-  setUniformFloat(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setUniformFloat(arg0, arg1);
-      }
-    }
-  }
-  setUniformVector2(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setUniformVector2(arg0, arg1);
-      }
-    }
-  }
-  setUniformVector3(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setUniformVector3(arg0, arg1);
-      }
-    }
-  }
-  setUniformVector4(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setUniformVector4(arg0, arg1);
-      }
-    }
-  }
-  setUniformColor(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setUniformColor(arg0, arg1);
-      }
-    }
-  }
-  getUniform(arg0) {
-    return this.getDefaultColorShader().getUniform(arg0);
-  }
-  getUniformFloat(arg0) {
-    return this.getDefaultColorShader().getUniformFloat(arg0);
-  }
-  getUniformVector2(arg0) {
-    return this.getDefaultColorShader().getUniformVector2(arg0);
-  }
-  getUniformVector3(arg0) {
-    return this.getDefaultColorShader().getUniformVector3(arg0);
-  }
-  getUniformVector4(arg0) {
-    return this.getDefaultColorShader().getUniformVector4(arg0);
-  }
-  getUniformColor(arg0) {
-    return this.getDefaultColorShader().getUniformColor(arg0);
-  }
-  setTexture(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setTexture(arg0, arg1);
-      }
-    }
-    this.setDefine(`USE_${arg0.toLocaleUpperCase()}`, true);
-  }
-  getTexture(arg0) {
-    return this.getDefaultColorShader().textures[arg0];
-  }
-  setUniformBuffer(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setUniformBuffer(arg0, arg1);
-      }
-    }
-  }
-  getUniformBuffer(arg0) {
-    return this.getDefaultColorShader().getBuffer(arg0);
-  }
-  setStorageBuffer(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setStorageBuffer(arg0, arg1);
-      }
-    }
-  }
-  getStorageBuffer(arg0) {
-    return this.getDefaultColorShader().getBuffer(arg0);
-  }
-  setStructStorageBuffer(arg0, arg1) {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.setStructStorageBuffer(arg0, arg1);
-      }
-    }
-  }
-  getStructStorageBuffer(arg0) {
-    return this.getDefaultColorShader().getBuffer(arg0);
-  }
-  noticeValueChange() {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.noticeValueChange();
-      }
-    }
-  }
-  destroy() {
-    this.getDefaultColorShader().destroy();
-  }
-  clone() {
-    let newShader = new Shader();
-    let sourceShaderPassList = this.getDefaultShaders();
-    for (const shadePass of sourceShaderPassList) {
-      newShader.addRenderPass(shadePass);
-    }
-    return newShader;
-  }
-  applyUniform() {
-    for (const pass of this.passShader) {
-      for (const rd of pass[1]) {
-        rd.applyUniform();
-      }
-    }
-  }
-}
-
 class Material {
   instanceID;
   name;
@@ -22670,61 +22678,35 @@ const GSplat_VS = (
   /* wgsl */
   `
     #include "GlobalUniform"
-
-    struct VSOut {
-        @location(auto) vColor : vec4f,
-        @location(auto) vTexCoord : vec2f,
-        @builtin(position) member : vec4f
-    };
-
-    // ===== SPLAT CORE VS (from PlayCanvas shader-generator-gsplat.js) =====
-    
-    // Uniforms (mapped to WebGPU bindings)
-    // matrix_model, matrix_view, matrix_projection -> GlobalUniform + MaterialUniform
-    // viewport -> calculated from globalUniform.windowWidth/Height
-    // tex_params -> materialUniform.tex_params
-    
-    @group(1) @binding(0) var splatColor : texture_2d<f32>;
-    @group(1) @binding(1) var transformA : texture_2d<u32>;
-    @group(1) @binding(2) var transformB : texture_2d<f32>;
-    @group(1) @binding(4) var splatOrder : texture_2d<u32>;
     
     struct MaterialUniform {
-        tex_params: vec4f,      // numSplats, textureWidth, validCount, visBoost
         modelMatrix: mat4x4<f32>,
-        pixelCull: vec4f,       // minPixels, maxPixels, maxPixelCullDistance, reserved
+        tex_params: vec4<f32>,      // [numSplats, texWidth, validCount, visBoost]
+        pixelCull: vec4<f32>,        // [minPixels, maxPixels, maxPixelCullDistance, batchSize]
     };
-    @group(1) @binding(3) var<uniform> materialUniform : MaterialUniform;
+    @group(1) @binding(0) var<uniform> materialUniform: MaterialUniform;
     
-    // Global variables (like PlayCanvas)
-    var<private> orderId: u32;
-    var<private> splatId: u32;
+    struct VSOut {
+        @builtin(position) member: vec4<f32>,
+        @location(0) vColor: vec4<f32>,
+        @location(1) vTexCoord: vec2<f32>,
+    };
+    
+    // Textures (like PlayCanvas)
+    @group(1) @binding(1) var splatColor: texture_2d<f32>;
+    @group(1) @binding(2) var transformA: texture_2d<u32>;
+    @group(1) @binding(3) var transformB: texture_2d<f32>;
+    @group(1) @binding(4) var splatOrder: texture_2d<u32>;
+    
+    // Global variables for texture lookups
     var<private> splatUV: vec2<i32>;
+    var<private> splatId: u32;
     var<private> tA: vec4<u32>;
     
-    // Helper: decode 16-bit half float
-    fn unpackHalf(h: u32) -> f32 {
-        let s = (h >> 15u) & 0x1u;
-        let e = (h >> 10u) & 0x1fu;
-        let m = h & 0x3ffu;
-        let sign = select(1.0, -1.0, s == 1u);
-        if (e == 0u) {
-            if (m == 0u) { return 0.0; }
-            return sign * (f32(m) * exp2(-24.0));
-        } else if (e == 31u) {
-            return sign * 65504.0;
-        } else {
-            return sign * (1.0 + f32(m) / 1024.0) * exp2(f32(i32(e) - 15));
-        }
-    }
-    
     // === calcSplatUV() - returns bool ===
-    fn calcSplatUV(instance_id: u32) -> bool {
-        let numSplats = u32(materialUniform.tex_params.x);
+    fn calcSplatUV(orderId: u32) -> bool {
         let textureWidth = u32(materialUniform.tex_params.y);
-        
-        // calculate splat index
-        orderId = instance_id;
+        let numSplats = u32(materialUniform.tex_params.x);
         
         if (orderId >= numSplats) {
             return false;
@@ -22771,6 +22753,19 @@ const GSplat_VS = (
         return result;
     }
     
+    // === getRotationMatrix() - returns mat3x3 ===
+    fn getRotationMatrix() -> mat3x3f {
+        let cov_data = getCovariance();
+        let covA = cov_data.covA;
+        let covB = cov_data.covB;
+        
+        return mat3x3f(
+            vec3f(1.0 - 2.0 * (covA.z * covA.z + covB.x * covB.x), 2.0 * (covA.y * covA.z + covB.y * covB.x), 2.0 * (covA.y * covB.x - covB.y * covA.z)),
+            vec3f(2.0 * (covA.y * covA.z - covB.y * covB.x), 1.0 - 2.0 * (covA.y * covA.y + covB.x * covB.x), 2.0 * (covA.z * covB.x + covA.y * covB.y)),
+            vec3f(2.0 * (covA.y * covB.x + covB.y * covA.z), 2.0 * (covA.z * covB.x - covA.y * covB.y), 1.0 - 2.0 * (covA.y * covA.y + covA.z * covA.z))
+        );
+    }
+    
     // === calcV1V2() - returns vec4 ===
     fn calcV1V2(splat_cam: vec3f, covA: vec3f, covB: vec3f, W: mat3x3f, viewport: vec2f, projMat: mat4x4f) -> vec4f {
         let Vrk = mat3x3f(
@@ -22814,22 +22809,25 @@ const GSplat_VS = (
     @vertex
     fn VertMain(
         @builtin(vertex_index) vid : u32,
-        @builtin(instance_index) iid : u32
+        @builtin(instance_index) iid : u32,
+        @location(0) position: vec3<f32>  // vertex_position from mesh (x, y, local_index)
     ) -> VSOut {
         var o: VSOut;
         let discardVec = vec4f(0.0, 0.0, 2.0, 1.0);
         
-        // Vertex position array (PlayCanvas uses attribute vec3 with x,y in [-1,1])
-        let vertex_position = array<vec2f, 4>(
-            vec2f(-2.0, -2.0),
-            vec2f( 2.0, -2.0),
-            vec2f(-2.0,  2.0),
-            vec2f( 2.0,  2.0)
-        );
-        let vertex_pos = vertex_position[vid & 3u];
+        // Calculate splat ID
+        // orderId = vertex_id_attrib + uint(vertex_position.z)
+        // In our case: vertex_id_attrib = iid * batchSize
+        let batchSize = u32(materialUniform.pixelCull.w);
+        let base_splat_index = iid * batchSize;
+        let local_splat_index = u32(position.z);
+        let orderId = base_splat_index + local_splat_index;
+        
+        // Use vertex position from mesh
+        let vertex_pos = position.xy;
         
         // calculate splat uv
-        if (!calcSplatUV(iid)) {
+        if (!calcSplatUV(orderId)) {
             o.member = discardVec;
             o.vColor = vec4f(0.0);
             o.vTexCoord = vec2f(0.0);
@@ -22857,9 +22855,8 @@ const GSplat_VS = (
         }
         
         // Frustum culling: cull splats outside screen bounds
-        // Add margin for splat radius (conservative: ~2x max splat size)
         let ndc = splat_proj.xyz / splat_proj.w;
-        let margin = 0.5; // Allow splats near edges to be visible
+        let margin = 0.0;
         if (ndc.x < -1.0 - margin || ndc.x > 1.0 + margin ||
             ndc.y < -1.0 - margin || ndc.y > 1.0 + margin ||
             ndc.z < 0.0 || ndc.z > 1.0) {
@@ -22877,6 +22874,12 @@ const GSplat_VS = (
         
         // get color
         let color = textureLoad(splatColor, splatUV, 0);
+        if (color.a < 1.0 / 255.0) {
+            o.member = discardVec;
+            o.vColor = vec4f(0.0);
+            o.vTexCoord = vec2f(0.0);
+            return o;
+        }
         
         // calculate scale based on alpha
         let scale = min(1.0, sqrt(-log(1.0 / 255.0 / color.a)) / 2.0);
@@ -22885,7 +22888,7 @@ const GSplat_VS = (
         let visBoost = materialUniform.tex_params.w;
         var v1v2_scaled = v1v2 * scale * visBoost;
         
-        // Pixel coverage culling (min and max thresholds)
+        // Pixel coverage culling
         let v1_len_sq = dot(v1v2_scaled.xy, v1v2_scaled.xy);
         let v2_len_sq = dot(v1v2_scaled.zw, v1v2_scaled.zw);
         
@@ -22893,7 +22896,7 @@ const GSplat_VS = (
         let maxPixels = materialUniform.pixelCull.y;
         let maxPixelCullDistance = materialUniform.pixelCull.z;
         
-        // Early out tiny splats (below minimum pixel coverage)
+        // Early out tiny splats
         if (v1_len_sq < minPixels && v2_len_sq < minPixels) {
             o.member = discardVec;
             o.vColor = vec4f(0.0);
@@ -22901,13 +22904,9 @@ const GSplat_VS = (
             return o;
         }
         
-        // Cull oversized splats (above maximum pixel coverage)
-        // Only apply to splats close to camera (distance-based condition)
+        // Cull oversized splats
         if (maxPixels > 0.0) {
-            // Calculate distance from splat to camera
             let splatDistance = length(splat_cam.xyz);
-            
-            // Only cull oversized splats if they are close to camera
             if (maxPixelCullDistance <= 0.0 || splatDistance < maxPixelCullDistance) {
                 let maxAxisSq = maxPixels * maxPixels;
                 if (v1_len_sq > maxAxisSq || v2_len_sq > maxAxisSq) {
@@ -22919,12 +22918,9 @@ const GSplat_VS = (
             }
         }
         
-        // gl_Position = splat_proj + vec4((vertex_position.x * v1v2.xy + vertex_position.y * v1v2.zw) / viewport * splat_proj.w, 0, 0);
+        // Final position
         o.member = splat_proj + vec4f((vertex_pos.x * v1v2_scaled.xy + vertex_pos.y * v1v2_scaled.zw) / viewport * splat_proj.w, 0.0, 0.0);
-        
-        // texCoord = vertex_position.xy * scale / 2.0;
         o.vTexCoord = vertex_pos * scale / 2.0;
-        
         o.vColor = color;
         
         return o;
@@ -22939,49 +22935,279 @@ const GSplat_FS = (
     // === evalSplat() - like PlayCanvas splatCoreFS ===
     fn evalSplat(texCoord: vec2f, color: vec4f) -> vec4f {
         let A = dot(texCoord, texCoord);
+        var B = exp(-A * 4.0) * color.a;
         if (A > 1.0) {
-            discard;
+            B = 0.0;
         }
         
-        let B = exp(-A * 4.0) * color.a;
         if (B < 1.0 / 255.0) {
-            discard;
+            B = 0.0;
         }
         
-        // TONEMAP_ENABLED branch not implemented (would call toneMap() and gammaCorrectOutput())
         return vec4f(color.rgb, B);
     }
-    
-    // === main() - like PlayCanvas splatMainFS ===
+
     @fragment
-    fn FragMain(@location(auto) vColor: vec4f, @location(auto) vTexCoord: vec2f) -> FragmentOutput {
-        let result = evalSplat(vTexCoord, vColor);
-        
+    fn FragMain(
+        @location(0) vColor: vec4<f32>,
+        @location(1) vTexCoord: vec2<f32>
+    ) -> FragmentOutput {
         var o: FragmentOutput;
-        o.color = result;
-        o.gBuffer = vec4f(0.0);
+        o.color = evalSplat(vTexCoord, vColor);
         return o;
     }
 `
 );
 
-class GSplatMaterial extends Material {
+class Shader {
+  computes;
+  passShader;
+  constructor() {
+    this.computes = [];
+    this.passShader = /* @__PURE__ */ new Map();
+  }
+  addRenderPass(renderShader, index = -1) {
+    let subShader = this.passShader.get(renderShader.passType) || [];
+    if (index == -1) {
+      subShader.push(renderShader);
+    } else {
+      subShader.splice(index, -1, renderShader);
+    }
+    this.passShader.set(renderShader.passType, subShader);
+  }
+  removeShader(renderShader, index = -1) {
+    let subShader = this.passShader.get(
+      renderShader.passType
+    );
+    if (subShader) {
+      if (index == -1) {
+        let index2 = subShader.indexOf(renderShader);
+        if (index2 != -1) {
+          subShader.splice(index2);
+        }
+      } else {
+        subShader.splice(index, 1);
+      }
+    }
+  }
+  removeShaderByIndex(passType, index = -1) {
+    let subShader = this.passShader.get(passType);
+    if (subShader) {
+      if (index == -1) {
+        this.passShader.delete(passType);
+      } else {
+        subShader.splice(index, 1);
+      }
+    }
+  }
+  getSubShaders(passType) {
+    return this.passShader.get(passType) || [];
+  }
+  hasSubShaders(passType) {
+    let subs = this.passShader.get(passType);
+    return subs.length > 0;
+  }
+  getDefaultShaders() {
+    return this.passShader.get(PassType.COLOR);
+  }
+  getDefaultColorShader() {
+    return this.passShader.get(PassType.COLOR)[0];
+  }
+  setDefine(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setDefine(arg0, arg1);
+      }
+    }
+  }
+  hasDefine(arg0) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        let has = rd.hasDefine(arg0);
+        if (has) return has;
+      }
+    }
+    return false;
+  }
+  deleteDefine(arg0) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.deleteDefine(arg0);
+      }
+    }
+  }
+  setUniform(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setUniform(arg0, arg1);
+      }
+    }
+  }
+  setUniformFloat(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setUniformFloat(arg0, arg1);
+      }
+    }
+  }
+  setUniformVector2(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setUniformVector2(arg0, arg1);
+      }
+    }
+  }
+  setUniformVector3(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setUniformVector3(arg0, arg1);
+      }
+    }
+  }
+  setUniformVector4(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setUniformVector4(arg0, arg1);
+      }
+    }
+  }
+  setUniformColor(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setUniformColor(arg0, arg1);
+      }
+    }
+  }
+  getUniform(arg0) {
+    return this.getDefaultColorShader().getUniform(arg0);
+  }
+  getUniformFloat(arg0) {
+    return this.getDefaultColorShader().getUniformFloat(arg0);
+  }
+  getUniformVector2(arg0) {
+    return this.getDefaultColorShader().getUniformVector2(arg0);
+  }
+  getUniformVector3(arg0) {
+    return this.getDefaultColorShader().getUniformVector3(arg0);
+  }
+  getUniformVector4(arg0) {
+    return this.getDefaultColorShader().getUniformVector4(arg0);
+  }
+  getUniformColor(arg0) {
+    return this.getDefaultColorShader().getUniformColor(arg0);
+  }
+  setTexture(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setTexture(arg0, arg1);
+      }
+    }
+    this.setDefine(`USE_${arg0.toLocaleUpperCase()}`, true);
+  }
+  getTexture(arg0) {
+    return this.getDefaultColorShader().textures[arg0];
+  }
+  setUniformBuffer(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setUniformBuffer(arg0, arg1);
+      }
+    }
+  }
+  getUniformBuffer(arg0) {
+    return this.getDefaultColorShader().getBuffer(arg0);
+  }
+  setStorageBuffer(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setStorageBuffer(arg0, arg1);
+      }
+    }
+  }
+  getStorageBuffer(arg0) {
+    return this.getDefaultColorShader().getBuffer(arg0);
+  }
+  setStructStorageBuffer(arg0, arg1) {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.setStructStorageBuffer(arg0, arg1);
+      }
+    }
+  }
+  getStructStorageBuffer(arg0) {
+    return this.getDefaultColorShader().getBuffer(arg0);
+  }
+  noticeValueChange() {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.noticeValueChange();
+      }
+    }
+  }
+  destroy() {
+    this.getDefaultColorShader().destroy();
+  }
+  clone() {
+    let newShader = new Shader();
+    let sourceShaderPassList = this.getDefaultShaders();
+    for (const shadePass of sourceShaderPassList) {
+      newShader.addRenderPass(shadePass);
+    }
+    return newShader;
+  }
+  applyUniform() {
+    for (const pass of this.passShader) {
+      for (const rd of pass[1]) {
+        rd.applyUniform();
+      }
+    }
+  }
+}
+
+var __getOwnPropDesc$k = Object.getOwnPropertyDescriptor;
+var __decorateClass$k = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$k(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+let GSplatShader = class extends Shader {
   constructor() {
     super();
-    ShaderLib.register("gsplat_vs_dc", GSplat_VS);
-    ShaderLib.register("gsplat_fs_dc", GSplat_FS);
     const pass = new RenderShaderPass("gsplat_vs_dc", "gsplat_fs_dc");
     pass.passType = PassType.COLOR;
     pass.setShaderEntry("VertMain", "FragMain");
-    pass.topology = GPUPrimitiveTopology.triangle_strip;
+    pass.topology = GPUPrimitiveTopology.triangle_list;
     pass.depthWriteEnabled = false;
-    pass.cullMode = "none";
+    pass.cullMode = GPUCullMode.none;
     pass.shaderState.transparent = true;
     pass.shaderState.blendMode = BlendMode.NORMAL;
     pass.shaderState.writeMasks = [15, 15];
-    const shader = new Shader();
-    shader.addRenderPass(pass);
-    this.shader = shader;
+    this.addRenderPass(pass);
+    this.setDefault();
+  }
+  /**
+   * Set default uniform values
+   */
+  setDefault() {
+    const pass = this.getDefaultColorShader();
+    const identityMatrix = new Matrix4();
+    pass.setUniform("modelMatrix", identityMatrix.rawData);
+    pass.setUniform("pixelCull", new Float32Array([2, 0, 0, 0]));
+  }
+};
+GSplatShader = __decorateClass$k([
+  RegisterShader(GSplatShader, "GSplatShader")
+], GSplatShader);
+
+class GSplatMaterial extends Material {
+  _pixelCullArray = new Float32Array(4);
+  constructor() {
+    super();
+    ShaderLib.register("gsplat_vs_dc", GSplat_VS);
+    ShaderLib.register("gsplat_fs_dc", GSplat_FS);
+    this.shader = new GSplatShader();
   }
   setSplatTextures(splatColor, transformA, transformB, texParams, splatOrder) {
     const pass = this.shader.getDefaultColorShader();
@@ -22992,6 +23218,7 @@ class GSplatMaterial extends Material {
     if (splatOrder) {
       pass.setTexture("splatOrder", splatOrder);
     }
+    pass.shaderState.depthCompare = GPUCompareFunction.less;
   }
   /**
    * Set the model matrix for transforming splats to world space
@@ -23006,9 +23233,13 @@ class GSplatMaterial extends Material {
    * @param maxPixels Maximum pixel coverage (cull oversized splats), default: 0 (disabled)
    * @param maxPixelCullDistance Only cull oversized splats within this distance, 0 = always cull
    */
-  setPixelCulling(minPixels, maxPixels, maxPixelCullDistance = 0) {
+  setPixelCulling(minPixels, maxPixels, maxPixelCullDistance = 0, batchSize = 128) {
+    this._pixelCullArray[0] = minPixels;
+    this._pixelCullArray[1] = maxPixels;
+    this._pixelCullArray[2] = maxPixelCullDistance;
+    this._pixelCullArray[3] = batchSize;
     const pass = this.shader.getDefaultColorShader();
-    pass.setUniform("pixelCull", new Float32Array([minPixels, maxPixels, maxPixelCullDistance, 0]));
+    pass.setUniform("pixelCull", this._pixelCullArray);
   }
 }
 
@@ -23666,108 +23897,47 @@ class GeometryBase {
   }
 }
 
-class PlaneGeometry extends GeometryBase {
-  width;
-  height;
-  segmentW;
-  segmentH;
-  up;
-  constructor(width, height, segmentW = 1, segmentH = 1, up = Vector3.Y_AXIS) {
+class GSplatGeometry extends GeometryBase {
+  batchSize;
+  constructor(batchSize = 128) {
     super();
-    this.width = width;
-    this.height = height;
-    this.segmentW = segmentW;
-    this.segmentH = segmentH;
-    this.up = up;
-    this.buildGeometry(this.up);
-  }
-  buildGeometry(axis) {
-    var x, y;
-    var numIndices;
-    var base;
-    var tw = this.segmentW + 1;
-    (this.segmentH + 1) * tw;
-    this.bounds = new BoundingBox(
-      Vector3.ZERO.clone(),
-      new Vector3(this.width, 1, this.height)
-    );
-    numIndices = this.segmentH * this.segmentW * 6;
-    let vertexCount = (this.segmentW + 1) * (this.segmentH + 1);
-    let position_arr = new Float32Array(vertexCount * 3);
-    let normal_arr = new Float32Array(vertexCount * 3);
-    let uv_arr = new Float32Array(vertexCount * 2);
-    let indices_arr;
-    let totalIndexCount = this.segmentW * this.segmentH * 2 * 3;
-    if (totalIndexCount >= Uint16Array.length) {
-      indices_arr = new Uint32Array(this.segmentW * this.segmentH * 2 * 3);
-    } else {
-      indices_arr = new Uint16Array(this.segmentW * this.segmentH * 2 * 3);
-    }
-    numIndices = 0;
-    var indexP = 0;
-    var indexN = 0;
-    var indexU = 0;
-    for (var yi = 0; yi <= this.segmentH; ++yi) {
-      for (var xi = 0; xi <= this.segmentW; ++xi) {
-        x = (xi / this.segmentW - 0.5) * this.width;
-        y = (yi / this.segmentH - 0.5) * this.height;
-        switch (axis) {
-          case Vector3.Y_AXIS:
-            position_arr[indexP++] = x;
-            position_arr[indexP++] = 0;
-            position_arr[indexP++] = y;
-            normal_arr[indexN++] = 0;
-            normal_arr[indexN++] = 1;
-            normal_arr[indexN++] = 0;
-            break;
-          case Vector3.Z_AXIS:
-            position_arr[indexP++] = x;
-            position_arr[indexP++] = -y;
-            position_arr[indexP++] = 0;
-            normal_arr[indexN++] = 0;
-            normal_arr[indexN++] = 0;
-            normal_arr[indexN++] = 1;
-            break;
-          case Vector3.X_AXIS:
-            position_arr[indexP++] = 0;
-            position_arr[indexP++] = x;
-            position_arr[indexP++] = y;
-            normal_arr[indexN++] = 1;
-            normal_arr[indexN++] = 0;
-            normal_arr[indexN++] = 0;
-            break;
-          default:
-            position_arr[indexP++] = x;
-            position_arr[indexP++] = 0;
-            position_arr[indexP++] = y;
-            normal_arr[indexN++] = 0;
-            normal_arr[indexN++] = 1;
-            normal_arr[indexN++] = 0;
-            break;
-        }
-        uv_arr[indexU++] = xi / this.segmentW;
-        uv_arr[indexU++] = yi / this.segmentH;
-        if (xi != this.segmentW && yi != this.segmentH) {
-          base = xi + yi * tw;
-          indices_arr[numIndices++] = base + 1;
-          indices_arr[numIndices++] = base;
-          indices_arr[numIndices++] = base + tw;
-          indices_arr[numIndices++] = base + 1;
-          indices_arr[numIndices++] = base + tw;
-          indices_arr[numIndices++] = base + tw + 1;
-        }
-      }
-    }
-    this.setIndices(indices_arr);
-    this.setAttribute(VertexAttributeName.position, position_arr);
-    this.setAttribute(VertexAttributeName.normal, normal_arr);
-    this.setAttribute(VertexAttributeName.uv, uv_arr);
-    this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
+    this.batchSize = batchSize;
+    const meshPositions = new Float32Array(12 * batchSize);
+    for (let i = 0; i < batchSize; ++i) {
+      meshPositions.set([
+        -2,
+        -2,
+        i,
+        2,
+        -2,
+        i,
+        2,
+        2,
+        i,
+        -2,
+        2,
+        i
+      ], i * 12);
+    }
+    const meshIndices = new Uint32Array(6 * batchSize);
+    for (let i = 0; i < batchSize; ++i) {
+      const b = i * 4;
+      meshIndices.set([
+        0 + b,
+        1 + b,
+        2 + b,
+        0 + b,
+        2 + b,
+        3 + b
+      ], i * 6);
+    }
+    this.setAttribute(VertexAttributeName.position, meshPositions);
+    this.setIndices(meshIndices);
     this.addSubGeometry({
       indexStart: 0,
-      indexCount: indices_arr.length,
+      indexCount: meshIndices.length,
       vertexStart: 0,
-      vertexCount: 0,
+      vertexCount: meshPositions.length / 3,
       firstStart: 0,
       index: 0,
       topology: 0
@@ -23871,18 +24041,49 @@ class Uint32ArrayTexture extends Texture {
   updateTexture(width, height, data) {
     let device = webGPUContext.device;
     const bytesPerRow = width * 4 * 4;
-    const staging = device.createBuffer({
+    device.queue.writeTexture(
+      { texture: this.getGPUTexture() },
+      data.buffer,
+      { bytesPerRow },
+      { width, height, depthOrArrayLayers: 1 }
+    );
+  }
+}
+
+class R32UintTexture extends Texture {
+  _dataBuffer;
+  create(width, height, data) {
+    let device = webGPUContext.device;
+    const bytesPerRow = width * 4;
+    this.format = GPUTextureFormat.r32uint;
+    const mipmapCount = 1;
+    this.createTextureDescriptor(width, height, mipmapCount, this.format);
+    const textureDataBuffer = this._dataBuffer = device.createBuffer({
       size: data.byteLength,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
     });
-    device.queue.writeBuffer(staging, 0, data.buffer);
+    device.queue.writeBuffer(textureDataBuffer, 0, data.buffer);
     const encoder = device.createCommandEncoder();
     encoder.copyBufferToTexture(
-      { buffer: staging, bytesPerRow },
+      { buffer: textureDataBuffer, bytesPerRow },
       { texture: this.getGPUTexture() },
       { width, height, depthOrArrayLayers: 1 }
     );
     device.queue.submit([encoder.finish()]);
+    this.samplerBindingLayout.type = `non-filtering`;
+    this.textureBindingLayout.sampleType = `uint`;
+    this.gpuSampler = device.createSampler({});
+    return this;
+  }
+  updateTexture(width, height, data) {
+    let device = webGPUContext.device;
+    const bytesPerRow = width * 4;
+    device.queue.writeTexture(
+      { texture: this.getGPUTexture() },
+      data.buffer,
+      { bytesPerRow },
+      { width, height, depthOrArrayLayers: 1 }
+    );
   }
 }
 
@@ -23990,9 +24191,9 @@ class Float16ArrayTexture extends Texture {
   }
 }
 
-var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
-var __decorateClass$h = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$h(target, key) : target;
+var __getOwnPropDesc$j = Object.getOwnPropertyDescriptor;
+var __decorateClass$j = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$j(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -24024,14 +24225,15 @@ let GSplatRenderer = class extends RenderNode {
   // Web Worker for sorting
   _sortWorker;
   _lastSentTime = 0;
-  _minIntervalMs = 0;
-  // No throttle for immediate sorting
+  _minIntervalMs = 16;
   _centersSent = false;
   _lastViewMatrixHash = 0;
   // Adaptive sorting optimization
   _lastCameraSpeed = 0;
   _adaptiveSorting = true;
   // Enable adaptive sorting by default
+  _lastPixelCullParams = "";
+  _texturesInitialized = false;
   // LOD (Level of Detail) system
   _lodEnabled = false;
   _lodDistances = [5, 10, 20, 40];
@@ -24053,6 +24255,11 @@ let GSplatRenderer = class extends RenderNode {
   get fullCount() {
     return this._fullCount;
   }
+  // Batched rendering
+  _batchSize = 128;
+  // Splats per draw call
+  instanceCount = 0;
+  // For InstanceDrawComponent compatibility
   constructor() {
     super();
   }
@@ -24068,24 +24275,20 @@ let GSplatRenderer = class extends RenderNode {
     this.texParams = new Float32Array([this.count, this.size.x, this.count, 1]);
     this._positions = asset.position;
     const total = this.size.x * this.size.y;
-    this._orderData = new Uint32Array(total * 4);
+    this._orderData = new Uint32Array(total);
     for (let i = 0; i < total; i++) {
-      const src = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
-      const base = i * 4;
-      this._orderData[base + 0] = src;
-      this._orderData[base + 1] = 0;
-      this._orderData[base + 2] = 0;
-      this._orderData[base + 3] = 0;
-    }
-    this.splatOrder = new Uint32ArrayTexture().create(this.size.x, this.size.y, this._orderData);
+      this._orderData[i] = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
+    }
+    this.splatOrder = new R32UintTexture().create(this.size.x, this.size.y, this._orderData);
     this.splatOrder.name = "splatOrder";
     this.splatOrder.minFilter = "nearest";
     this.splatOrder.magFilter = "nearest";
     this.splatOrder.addressModeU = "clamp-to-edge";
     this.splatOrder.addressModeV = "clamp-to-edge";
     this.gsplatMaterial = new GSplatMaterial();
-    this.geometry = new PlaneGeometry(1, 1, 1, 1);
+    this.geometry = new GSplatGeometry(this._batchSize);
     this.materials = [this.gsplatMaterial];
+    this.instanceCount = 0;
   }
   /**
    * Update splat sorting before rendering
@@ -24162,12 +24365,7 @@ let GSplatRenderer = class extends RenderNode {
     this.texParams[2] = Math.min(this.texParams[0], this.count);
     const total = this.size.x * this.size.y;
     for (let i = 0; i < total; i++) {
-      const src = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
-      const base = i * 4;
-      this._orderData[base + 0] = src;
-      this._orderData[base + 1] = 0;
-      this._orderData[base + 2] = 0;
-      this._orderData[base + 3] = 0;
+      this._orderData[i] = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
     }
     this.splatOrder.updateTexture(this.size.x, this.size.y, this._orderData);
     if (this._sortWorker) {
@@ -24194,6 +24392,7 @@ let GSplatRenderer = class extends RenderNode {
     } else {
       this._centersSent = false;
     }
+    this.instanceCount = 0;
   }
   /**
    * Set visibility boost factor (material uniform tex_params.w)
@@ -24257,6 +24456,18 @@ let GSplatRenderer = class extends RenderNode {
       distanceEnabled: this._maxPixelCullDistance > 0
     };
   }
+  /**
+   * Get batching statistics
+   */
+  getBatchingStats() {
+    return {
+      enabled: true,
+      batchSize: this._batchSize,
+      instanceCount: this.instanceCount,
+      splatCount: this.count,
+      reduction: this.count > 0 ? (1 - this.instanceCount / this.count) * 100 : 0
+    };
+  }
   /**
    * Calculate texture size for given splat count
    */
@@ -24479,18 +24690,20 @@ let GSplatRenderer = class extends RenderNode {
         const indices = new Uint32Array(newOrder);
         const total = this.size.x * this.size.y;
         const count = this.count;
-        this._orderData = new Uint32Array(total * 4);
-        for (let i = 0; i < total; i++) {
-          const src = i < count ? indices[i] : count > 0 ? count - 1 : 0;
-          const base = i * 4;
-          this._orderData[base + 0] = src;
-          this._orderData[base + 1] = 0;
-          this._orderData[base + 2] = 0;
-          this._orderData[base + 3] = 0;
+        if (!this._orderData || this._orderData.length !== total) {
+          this._orderData = new Uint32Array(total);
+        }
+        const validCount = Math.min(count, indices.length);
+        this._orderData.set(indices.subarray(0, validCount), 0);
+        if (validCount < total) {
+          const lastIndex = count > 0 ? count - 1 : 0;
+          this._orderData.fill(lastIndex, validCount, total);
         }
         this.splatOrder.updateTexture(this.size.x, this.size.y, this._orderData);
         const valid = Math.max(0, Math.min(this.count, ev.data.count | 0));
         this.texParams[2] = valid;
+        const newInstanceCount = Math.ceil(valid / this._batchSize);
+        this.instanceCount = newInstanceCount;
       };
       const worldPos = this._worldPositions || this._positions;
       const centers = this._mapping ? new Float32Array(this._mapping.length * 3) : new Float32Array(worldPos);
@@ -24693,30 +24906,22 @@ let GSplatRenderer = class extends RenderNode {
   nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
     const worldMatrix = this.object3D.transform.worldMatrix;
     this.gsplatMaterial.setTransformMatrix(worldMatrix);
-    this.gsplatMaterial.setPixelCulling(this._minPixelCoverage, this._maxPixelCoverage, this._maxPixelCullDistance);
-    this.gsplatMaterial.setSplatTextures(
-      this.splatColor,
-      this.transformA,
-      this.transformB,
-      this.texParams,
-      this.splatOrder
-    );
-    super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
-  }
-  /**
-   * Render pass
-   */
-  renderPass2(view, passType, rendererPassState, clusterLightingBuffer, encoder, useBundle = false) {
-    for (let mat of this.materials) {
-      const passes = mat.getPass(passType);
-      if (!passes || passes.length === 0) continue;
-      for (const pass of passes) {
-        if (!pass.pipeline) continue;
-        pass.apply(this.geometry, rendererPassState);
-        GPUContext.bindPipeline(encoder, pass);
-        GPUContext.draw(encoder, 4, this.count, 0, 0);
-      }
+    const currentParams = `${this._minPixelCoverage},${this._maxPixelCoverage},${this._maxPixelCullDistance},${this._batchSize}`;
+    if (currentParams !== this._lastPixelCullParams) {
+      this.gsplatMaterial.setPixelCulling(this._minPixelCoverage, this._maxPixelCoverage, this._maxPixelCullDistance, this._batchSize);
+      this._lastPixelCullParams = currentParams;
+    }
+    if (!this._texturesInitialized) {
+      this.gsplatMaterial.setSplatTextures(
+        this.splatColor,
+        this.transformA,
+        this.transformB,
+        this.texParams,
+        this.splatOrder
+      );
+      this._texturesInitialized = true;
     }
+    super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
   }
   /**
    * Render pass (fallback)
@@ -24730,7 +24935,28 @@ let GSplatRenderer = class extends RenderNode {
         if (!pass.pipeline) continue;
         pass.apply(this.geometry, renderContext.rendererPassState || renderContext);
         GPUContext.bindPipeline(encoder, pass);
-        GPUContext.draw(encoder, 4, this.count, 0, 0);
+        GPUContext.bindGeometryBuffer(encoder, this.geometry);
+        const subGeometry = this.geometry.subGeometries[0];
+        const lodInfo = subGeometry.lodLevels[0];
+        if (this.instanceCount > 0) {
+          GPUContext.drawIndexed(
+            encoder,
+            lodInfo.indexCount,
+            this.instanceCount,
+            lodInfo.indexStart,
+            0,
+            0
+          );
+        } else {
+          GPUContext.drawIndexed(
+            encoder,
+            lodInfo.indexCount,
+            1,
+            lodInfo.indexStart,
+            0,
+            0
+          );
+        }
       }
     }
   }
@@ -24745,7 +24971,7 @@ let GSplatRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-GSplatRenderer = __decorateClass$h([
+GSplatRenderer = __decorateClass$j([
   RegisterComponent(GSplatRenderer, "GSplatRenderer")
 ], GSplatRenderer);
 
@@ -25056,9 +25282,9 @@ class Entity extends CEventDispatcher {
   }
 }
 
-var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
-var __decorateClass$g = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
+var __getOwnPropDesc$i = Object.getOwnPropertyDescriptor;
+var __decorateClass$i = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$i(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -25323,7 +25549,7 @@ let Object3D = class extends Entity {
     super.destroy(force);
   }
 };
-Object3D = __decorateClass$g([
+Object3D = __decorateClass$i([
   DecorateObject3D
 ], Object3D);
 function DecorateObject3D(ctor, _) {
@@ -26652,9 +26878,9 @@ class MorphTargetData {
 }
 
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc$f = Object.getOwnPropertyDescriptor;
-var __decorateClass$f = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$f(target, key) : target;
+var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
+var __decorateClass$h = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$h(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
@@ -26763,13 +26989,13 @@ let MeshRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-__decorateClass$f([
+__decorateClass$h([
   EditorInspector
 ], MeshRenderer.prototype, "geometry", 1);
-__decorateClass$f([
+__decorateClass$h([
   EditorInspector
 ], MeshRenderer.prototype, "material", 1);
-MeshRenderer = __decorateClass$f([
+MeshRenderer = __decorateClass$h([
   RegisterComponent(MeshRenderer, "MeshRenderer")
 ], MeshRenderer);
 
@@ -27266,9 +27492,118 @@ class WebGPUDescriptorCreator {
   }
 }
 
-var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
-var __decorateClass$e = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
+class PlaneGeometry extends GeometryBase {
+  width;
+  height;
+  segmentW;
+  segmentH;
+  up;
+  constructor(width, height, segmentW = 1, segmentH = 1, up = Vector3.Y_AXIS) {
+    super();
+    this.width = width;
+    this.height = height;
+    this.segmentW = segmentW;
+    this.segmentH = segmentH;
+    this.up = up;
+    this.buildGeometry(this.up);
+  }
+  buildGeometry(axis) {
+    var x, y;
+    var numIndices;
+    var base;
+    var tw = this.segmentW + 1;
+    (this.segmentH + 1) * tw;
+    this.bounds = new BoundingBox(
+      Vector3.ZERO.clone(),
+      new Vector3(this.width, 1, this.height)
+    );
+    numIndices = this.segmentH * this.segmentW * 6;
+    let vertexCount = (this.segmentW + 1) * (this.segmentH + 1);
+    let position_arr = new Float32Array(vertexCount * 3);
+    let normal_arr = new Float32Array(vertexCount * 3);
+    let uv_arr = new Float32Array(vertexCount * 2);
+    let indices_arr;
+    let totalIndexCount = this.segmentW * this.segmentH * 2 * 3;
+    if (totalIndexCount >= Uint16Array.length) {
+      indices_arr = new Uint32Array(this.segmentW * this.segmentH * 2 * 3);
+    } else {
+      indices_arr = new Uint16Array(this.segmentW * this.segmentH * 2 * 3);
+    }
+    numIndices = 0;
+    var indexP = 0;
+    var indexN = 0;
+    var indexU = 0;
+    for (var yi = 0; yi <= this.segmentH; ++yi) {
+      for (var xi = 0; xi <= this.segmentW; ++xi) {
+        x = (xi / this.segmentW - 0.5) * this.width;
+        y = (yi / this.segmentH - 0.5) * this.height;
+        switch (axis) {
+          case Vector3.Y_AXIS:
+            position_arr[indexP++] = x;
+            position_arr[indexP++] = 0;
+            position_arr[indexP++] = y;
+            normal_arr[indexN++] = 0;
+            normal_arr[indexN++] = 1;
+            normal_arr[indexN++] = 0;
+            break;
+          case Vector3.Z_AXIS:
+            position_arr[indexP++] = x;
+            position_arr[indexP++] = -y;
+            position_arr[indexP++] = 0;
+            normal_arr[indexN++] = 0;
+            normal_arr[indexN++] = 0;
+            normal_arr[indexN++] = 1;
+            break;
+          case Vector3.X_AXIS:
+            position_arr[indexP++] = 0;
+            position_arr[indexP++] = x;
+            position_arr[indexP++] = y;
+            normal_arr[indexN++] = 1;
+            normal_arr[indexN++] = 0;
+            normal_arr[indexN++] = 0;
+            break;
+          default:
+            position_arr[indexP++] = x;
+            position_arr[indexP++] = 0;
+            position_arr[indexP++] = y;
+            normal_arr[indexN++] = 0;
+            normal_arr[indexN++] = 1;
+            normal_arr[indexN++] = 0;
+            break;
+        }
+        uv_arr[indexU++] = xi / this.segmentW;
+        uv_arr[indexU++] = yi / this.segmentH;
+        if (xi != this.segmentW && yi != this.segmentH) {
+          base = xi + yi * tw;
+          indices_arr[numIndices++] = base + 1;
+          indices_arr[numIndices++] = base;
+          indices_arr[numIndices++] = base + tw;
+          indices_arr[numIndices++] = base + 1;
+          indices_arr[numIndices++] = base + tw;
+          indices_arr[numIndices++] = base + tw + 1;
+        }
+      }
+    }
+    this.setIndices(indices_arr);
+    this.setAttribute(VertexAttributeName.position, position_arr);
+    this.setAttribute(VertexAttributeName.normal, normal_arr);
+    this.setAttribute(VertexAttributeName.uv, uv_arr);
+    this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
+    this.addSubGeometry({
+      indexStart: 0,
+      indexCount: indices_arr.length,
+      vertexStart: 0,
+      vertexCount: 0,
+      firstStart: 0,
+      index: 0,
+      topology: 0
+    });
+  }
+}
+
+var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
+var __decorateClass$g = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$g(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -27292,7 +27627,7 @@ let QuadShader = class extends Shader {
     this.setUniformFloat(`height`, 100);
   }
 };
-QuadShader = __decorateClass$e([
+QuadShader = __decorateClass$g([
   RegisterShader(QuadShader, "QuadShader")
 ], QuadShader);
 
@@ -30240,7 +30575,15 @@ class RendererJob {
   shadowMapPassRenderer;
   pointLightShadowRenderer;
   ddgiProbeRenderer;
-  postRenderer;
+  _postRenderer;
+  get postRenderer() {
+    if (!this._postRenderer) {
+      let gbufferFrame = GBufferFrame.getGBufferFrame("ColorPassGBuffer");
+      this._postRenderer = this.addRenderer(PostRenderer);
+      this._postRenderer.setRenderStates(gbufferFrame);
+    }
+    return this._postRenderer;
+  }
   clusterLightingRender;
   reflectionRenderer;
   occlusionSystem;
@@ -30264,7 +30607,9 @@ class RendererJob {
     }
     this.shadowMapPassRenderer = new ShadowMapPassRenderer();
     this.pointLightShadowRenderer = new PointLightShadowRenderer();
-    this.addPost(new FXAAPost());
+    if (Engine3D.setting.render.postProcessing.fxaa.enable) {
+      this.addPost(new FXAAPost());
+    }
   }
   addRenderer(c, param) {
     let renderer;
@@ -30294,11 +30639,6 @@ class RendererJob {
     this.pauseRender = false;
   }
   addPost(post) {
-    if (!this.postRenderer) {
-      let gbufferFrame = GBufferFrame.getGBufferFrame("ColorPassGBuffer");
-      this.postRenderer = this.addRenderer(PostRenderer);
-      this.postRenderer.setRenderStates(gbufferFrame);
-    }
     if (post instanceof PostBase) {
       this.postRenderer.attachPost(this.view, post);
     }
@@ -30316,15 +30656,21 @@ class RendererJob {
   renderFrame() {
     let view = this._view;
     ProfilerUtil.startView(view);
-    GlobalBindGroup.getLightEntries(view.scene).update(view);
-    GlobalBindGroup.getReflectionEntries(view.scene).update(view);
-    this.occlusionSystem.update(view.camera, view.scene);
-    this.clusterLightingRender.render(view, this.occlusionSystem);
-    if (this.shadowMapPassRenderer) {
+    if (this.clusterLightingRender) {
+      GlobalBindGroup.getLightEntries(view.scene).update(view);
+      GlobalBindGroup.getReflectionEntries(view.scene).update(view);
+    }
+    if (Engine3D.setting.occlusionQuery.enable && this.occlusionSystem) {
+      this.occlusionSystem.update(view.camera, view.scene);
+    }
+    if (this.clusterLightingRender) {
+      this.clusterLightingRender.render(view, this.occlusionSystem);
+    }
+    if (Engine3D.setting.shadow.enable && this.shadowMapPassRenderer) {
       ShadowLightsCollect.update(view);
       this.shadowMapPassRenderer.render(view, this.occlusionSystem);
     }
-    if (this.pointLightShadowRenderer) {
+    if (Engine3D.setting.shadow.enable && this.pointLightShadowRenderer) {
       this.pointLightShadowRenderer.render(view, this.occlusionSystem);
     }
     if (this.depthPassRenderer) {
@@ -34566,9 +34912,9 @@ class LightBase extends ComponentBase {
   }
 }
 
-var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
-var __decorateClass$d = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
+var __getOwnPropDesc$f = Object.getOwnPropertyDescriptor;
+var __decorateClass$f = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$f(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -34610,13 +34956,13 @@ let DirectLight = class extends LightBase {
   debug() {
   }
 };
-DirectLight = __decorateClass$d([
+DirectLight = __decorateClass$f([
   RegisterComponent(DirectLight, "DirectLight")
 ], DirectLight);
 
-var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
-var __decorateClass$c = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
+var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
+var __decorateClass$e = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -34674,13 +35020,13 @@ let PointLight = class extends LightBase {
   debugDraw(show) {
   }
 };
-PointLight = __decorateClass$c([
+PointLight = __decorateClass$e([
   RegisterComponent(PointLight, "PointLight")
 ], PointLight);
 
-var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
-var __decorateClass$b = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
+var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
+var __decorateClass$d = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -34745,7 +35091,7 @@ let SpotLight = class extends LightBase {
   debugDraw(show) {
   }
 };
-SpotLight = __decorateClass$b([
+SpotLight = __decorateClass$d([
   RegisterComponent(SpotLight, "SpotLight")
 ], SpotLight);
 
@@ -39298,483 +39644,483 @@ class AtlasParser extends ParserBase {
   }
 }
 
-// DEFLATE is a complex format; to read this code, you should probably check the RFC first:
-// https://tools.ietf.org/html/rfc1951
-// You may also wish to take a look at the guide I made about this program:
-// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
-// Some of the following code is similar to that of UZIP.js:
-// https://github.com/photopea/UZIP.js
-// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
-// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
-// is better for memory in most engines (I *think*).
-
-// aliases for shorter compressed code (most minifers don't do this)
-var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
-// fixed length extra bits
-var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
-// fixed distance extra bits
-var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
-// code length index map
-var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
-// get base, reverse index map from extra bits
-var freb = function (eb, start) {
-    var b = new u16(31);
-    for (var i = 0; i < 31; ++i) {
-        b[i] = start += 1 << eb[i - 1];
-    }
-    // numbers here are at max 18 bits
-    var r = new i32(b[30]);
-    for (var i = 1; i < 30; ++i) {
-        for (var j = b[i]; j < b[i + 1]; ++j) {
-            r[j] = ((j - b[i]) << 5) | i;
-        }
-    }
-    return { b: b, r: r };
-};
-var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
-// we can ignore the fact that the other numbers are wrong; they never happen anyway
-fl[28] = 258, revfl[258] = 28;
-var _b = freb(fdeb, 0), fd = _b.b;
-// map of value to reverse (assuming 16 bits)
-var rev = new u16(32768);
-for (var i = 0; i < 32768; ++i) {
-    // reverse table algorithm from SO
-    var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
-    x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
-    x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
-    rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
-}
-// create huffman tree from u8 "map": index -> code length for code index
-// mb (max bits) must be at most 15
-// TODO: optimize/split up?
-var hMap = (function (cd, mb, r) {
-    var s = cd.length;
-    // index
-    var i = 0;
-    // u16 "map": index -> # of codes with bit length = index
-    var l = new u16(mb);
-    // length of cd must be 288 (total # of codes)
-    for (; i < s; ++i) {
-        if (cd[i])
-            ++l[cd[i] - 1];
-    }
-    // u16 "map": index -> minimum code for bit length = index
-    var le = new u16(mb);
-    for (i = 1; i < mb; ++i) {
-        le[i] = (le[i - 1] + l[i - 1]) << 1;
-    }
-    var co;
-    if (r) {
-        // u16 "map": index -> number of actual bits, symbol for code
-        co = new u16(1 << mb);
-        // bits to remove for reverser
-        var rvb = 15 - mb;
-        for (i = 0; i < s; ++i) {
-            // ignore 0 lengths
-            if (cd[i]) {
-                // num encoding both symbol and bits read
-                var sv = (i << 4) | cd[i];
-                // free bits
-                var r_1 = mb - cd[i];
-                // start value
-                var v = le[cd[i] - 1]++ << r_1;
-                // m is end value
-                for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
-                    // every 16 bit value starting with the code yields the same result
-                    co[rev[v] >> rvb] = sv;
-                }
-            }
-        }
-    }
-    else {
-        co = new u16(s);
-        for (i = 0; i < s; ++i) {
-            if (cd[i]) {
-                co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
-            }
-        }
-    }
-    return co;
-});
-// fixed length tree
-var flt = new u8(288);
-for (var i = 0; i < 144; ++i)
-    flt[i] = 8;
-for (var i = 144; i < 256; ++i)
-    flt[i] = 9;
-for (var i = 256; i < 280; ++i)
-    flt[i] = 7;
-for (var i = 280; i < 288; ++i)
-    flt[i] = 8;
-// fixed distance tree
-var fdt = new u8(32);
-for (var i = 0; i < 32; ++i)
-    fdt[i] = 5;
-// fixed length map
-var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
-// fixed distance map
-var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
-// find max of array
-var max = function (a) {
-    var m = a[0];
-    for (var i = 1; i < a.length; ++i) {
-        if (a[i] > m)
-            m = a[i];
-    }
-    return m;
-};
-// read d, starting at bit p and mask with m
-var bits = function (d, p, m) {
-    var o = (p / 8) | 0;
-    return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;
-};
-// read d, starting at bit p continuing for at least 16 bits
-var bits16 = function (d, p) {
-    var o = (p / 8) | 0;
-    return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));
-};
-// get end of byte
-var shft = function (p) { return ((p + 7) / 8) | 0; };
-// typed array slice - allows garbage collector to free original reference,
-// while being more compatible than .slice
-var slc = function (v, s, e) {
-    if (s == null || s < 0)
-        s = 0;
-    if (e == null || e > v.length)
-        e = v.length;
-    // can't use .constructor in case user-supplied
-    return new u8(v.subarray(s, e));
-};
-// error codes
-var ec = [
-    'unexpected EOF',
-    'invalid block type',
-    'invalid length/literal',
-    'invalid distance',
-    'stream finished',
-    'no stream handler',
-    ,
-    'no callback',
-    'invalid UTF-8 data',
-    'extra field too long',
-    'date not in range 1980-2099',
-    'filename too long',
-    'stream finishing',
-    'invalid zip data'
-    // determined by unknown compression method
-];
-var err = function (ind, msg, nt) {
-    var e = new Error(msg || ec[ind]);
-    e.code = ind;
-    if (Error.captureStackTrace)
-        Error.captureStackTrace(e, err);
-    if (!nt)
-        throw e;
-    return e;
-};
-// expands raw DEFLATE data
-var inflt = function (dat, st, buf, dict) {
-    // source length       dict length
-    var sl = dat.length, dl = dict ? dict.length : 0;
-    if (!sl || st.f && !st.l)
-        return buf || new u8(0);
-    var noBuf = !buf;
-    // have to estimate size
-    var resize = noBuf || st.i != 2;
-    // no state
-    var noSt = st.i;
-    // Assumes roughly 33% compression ratio average
-    if (noBuf)
-        buf = new u8(sl * 3);
-    // ensure buffer can fit at least l elements
-    var cbuf = function (l) {
-        var bl = buf.length;
-        // need to increase size to fit
-        if (l > bl) {
-            // Double or set to necessary, whichever is greater
-            var nbuf = new u8(Math.max(bl * 2, l));
-            nbuf.set(buf);
-            buf = nbuf;
-        }
-    };
-    //  last chunk         bitpos           bytes
-    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
-    // total bits
-    var tbts = sl * 8;
-    do {
-        if (!lm) {
-            // BFINAL - this is only 1 when last chunk is next
-            final = bits(dat, pos, 1);
-            // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
-            var type = bits(dat, pos + 1, 3);
-            pos += 3;
-            if (!type) {
-                // go to end of byte boundary
-                var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
-                if (t > sl) {
-                    if (noSt)
-                        err(0);
-                    break;
-                }
-                // ensure size
-                if (resize)
-                    cbuf(bt + l);
-                // Copy over uncompressed data
-                buf.set(dat.subarray(s, t), bt);
-                // Get new bitpos, update byte count
-                st.b = bt += l, st.p = pos = t * 8, st.f = final;
-                continue;
-            }
-            else if (type == 1)
-                lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
-            else if (type == 2) {
-                //  literal                            lengths
-                var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
-                var tl = hLit + bits(dat, pos + 5, 31) + 1;
-                pos += 14;
-                // length+distance tree
-                var ldt = new u8(tl);
-                // code length tree
-                var clt = new u8(19);
-                for (var i = 0; i < hcLen; ++i) {
-                    // use index map to get real code
-                    clt[clim[i]] = bits(dat, pos + i * 3, 7);
-                }
-                pos += hcLen * 3;
-                // code lengths bits
-                var clb = max(clt), clbmsk = (1 << clb) - 1;
-                // code lengths map
-                var clm = hMap(clt, clb, 1);
-                for (var i = 0; i < tl;) {
-                    var r = clm[bits(dat, pos, clbmsk)];
-                    // bits read
-                    pos += r & 15;
-                    // symbol
-                    var s = r >> 4;
-                    // code length to copy
-                    if (s < 16) {
-                        ldt[i++] = s;
-                    }
-                    else {
-                        //  copy   count
-                        var c = 0, n = 0;
-                        if (s == 16)
-                            n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
-                        else if (s == 17)
-                            n = 3 + bits(dat, pos, 7), pos += 3;
-                        else if (s == 18)
-                            n = 11 + bits(dat, pos, 127), pos += 7;
-                        while (n--)
-                            ldt[i++] = c;
-                    }
-                }
-                //    length tree                 distance tree
-                var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
-                // max length bits
-                lbt = max(lt);
-                // max dist bits
-                dbt = max(dt);
-                lm = hMap(lt, lbt, 1);
-                dm = hMap(dt, dbt, 1);
-            }
-            else
-                err(1);
-            if (pos > tbts) {
-                if (noSt)
-                    err(0);
-                break;
-            }
-        }
-        // Make sure the buffer can hold this + the largest possible addition
-        // Maximum chunk size (practically, theoretically infinite) is 2^17
-        if (resize)
-            cbuf(bt + 131072);
-        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
-        var lpos = pos;
-        for (;; lpos = pos) {
-            // bits read, code
-            var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
-            pos += c & 15;
-            if (pos > tbts) {
-                if (noSt)
-                    err(0);
-                break;
-            }
-            if (!c)
-                err(2);
-            if (sym < 256)
-                buf[bt++] = sym;
-            else if (sym == 256) {
-                lpos = pos, lm = null;
-                break;
-            }
-            else {
-                var add = sym - 254;
-                // no extra bits needed if less
-                if (sym > 264) {
-                    // index
-                    var i = sym - 257, b = fleb[i];
-                    add = bits(dat, pos, (1 << b) - 1) + fl[i];
-                    pos += b;
-                }
-                // dist
-                var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
-                if (!d)
-                    err(3);
-                pos += d & 15;
-                var dt = fd[dsym];
-                if (dsym > 3) {
-                    var b = fdeb[dsym];
-                    dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
-                }
-                if (pos > tbts) {
-                    if (noSt)
-                        err(0);
-                    break;
-                }
-                if (resize)
-                    cbuf(bt + 131072);
-                var end = bt + add;
-                if (bt < dt) {
-                    var shift = dl - dt, dend = Math.min(dt, end);
-                    if (shift + bt < 0)
-                        err(3);
-                    for (; bt < dend; ++bt)
-                        buf[bt] = dict[shift + bt];
-                }
-                for (; bt < end; ++bt)
-                    buf[bt] = buf[bt - dt];
-            }
-        }
-        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
-        if (lm)
-            final = 1, st.m = lbt, st.d = dm, st.n = dbt;
-    } while (!final);
-    // don't reallocate for streams or user buffers
-    return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
-};
-// empty
-var et = /*#__PURE__*/ new u8(0);
-// read 2 bytes
-var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };
-// read 4 bytes
-var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };
-var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };
-/**
- * Expands DEFLATE data with no wrapper
- * @param data The data to decompress
- * @param opts The decompression options
- * @returns The decompressed version of the data
- */
-function inflateSync(data, opts) {
-    return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
-}
-// text decoder
-var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
-// text decoder stream
-var tds = 0;
-try {
-    td.decode(et, { stream: true });
-    tds = 1;
-}
-catch (e) { }
-// decode UTF8
-var dutf8 = function (d) {
-    for (var r = '', i = 0;;) {
-        var c = d[i++];
-        var eb = (c > 127) + (c > 223) + (c > 239);
-        if (i + eb > d.length)
-            return { s: r, r: slc(d, i - 1) };
-        if (!eb)
-            r += String.fromCharCode(c);
-        else if (eb == 3) {
-            c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536,
-                r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));
-        }
-        else if (eb & 1)
-            r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63));
-        else
-            r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63));
-    }
-};
-/**
- * Converts a Uint8Array to a string
- * @param dat The data to decode to string
- * @param latin1 Whether or not to interpret the data as Latin-1. This should
- *               not need to be true unless encoding to binary string.
- * @returns The original UTF-8/Latin-1 string
- */
-function strFromU8(dat, latin1) {
-    if (latin1) {
-        var r = '';
-        for (var i = 0; i < dat.length; i += 16384)
-            r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
-        return r;
-    }
-    else if (td) {
-        return td.decode(dat);
-    }
-    else {
-        var _a = dutf8(dat), s = _a.s, r = _a.r;
-        if (r.length)
-            err(8);
-        return s;
-    }
-}
-// skip local zip header
-var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };
-// read zip header
-var zh = function (d, b, z) {
-    var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
-    var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];
-    return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
-};
-// read zip64 extra field
-var z64e = function (d, b) {
-    for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
-        ;
-    return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
-};
-/**
- * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
- * performance with more than one file.
- * @param data The raw compressed ZIP file
- * @param opts The ZIP extraction options
- * @returns The decompressed files
- */
-function unzipSync(data, opts) {
-    var files = {};
-    var e = data.length - 22;
-    for (; b4(data, e) != 0x6054B50; --e) {
-        if (!e || data.length - e > 65558)
-            err(13);
-    }
-    var c = b2(data, e + 8);
-    if (!c)
-        return {};
-    var o = b4(data, e + 16);
-    var z = o == 4294967295 || c == 65535;
-    if (z) {
-        var ze = b4(data, e - 12);
-        z = b4(data, ze) == 0x6064B50;
-        if (z) {
-            c = b4(data, ze + 32);
-            o = b4(data, ze + 48);
-        }
-    }
-    for (var i = 0; i < c; ++i) {
-        var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
-        o = no;
-        {
-            if (!c_2)
-                files[fn] = slc(data, b, b + sc);
-            else if (c_2 == 8)
-                files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
-            else
-                err(14, 'unknown compression type ' + c_2);
-        }
-    }
-    return files;
+// DEFLATE is a complex format; to read this code, you should probably check the RFC first:
+// https://tools.ietf.org/html/rfc1951
+// You may also wish to take a look at the guide I made about this program:
+// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
+// Some of the following code is similar to that of UZIP.js:
+// https://github.com/photopea/UZIP.js
+// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
+// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
+// is better for memory in most engines (I *think*).
+
+// aliases for shorter compressed code (most minifers don't do this)
+var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+// fixed length extra bits
+var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
+// fixed distance extra bits
+var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
+// code length index map
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+// get base, reverse index map from extra bits
+var freb = function (eb, start) {
+    var b = new u16(31);
+    for (var i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
+    }
+    // numbers here are at max 18 bits
+    var r = new i32(b[30]);
+    for (var i = 1; i < 30; ++i) {
+        for (var j = b[i]; j < b[i + 1]; ++j) {
+            r[j] = ((j - b[i]) << 5) | i;
+        }
+    }
+    return { b: b, r: r };
+};
+var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
+// we can ignore the fact that the other numbers are wrong; they never happen anyway
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0), fd = _b.b;
+// map of value to reverse (assuming 16 bits)
+var rev = new u16(32768);
+for (var i = 0; i < 32768; ++i) {
+    // reverse table algorithm from SO
+    var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
+    x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
+    x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
+    rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
+}
+// create huffman tree from u8 "map": index -> code length for code index
+// mb (max bits) must be at most 15
+// TODO: optimize/split up?
+var hMap = (function (cd, mb, r) {
+    var s = cd.length;
+    // index
+    var i = 0;
+    // u16 "map": index -> # of codes with bit length = index
+    var l = new u16(mb);
+    // length of cd must be 288 (total # of codes)
+    for (; i < s; ++i) {
+        if (cd[i])
+            ++l[cd[i] - 1];
+    }
+    // u16 "map": index -> minimum code for bit length = index
+    var le = new u16(mb);
+    for (i = 1; i < mb; ++i) {
+        le[i] = (le[i - 1] + l[i - 1]) << 1;
+    }
+    var co;
+    if (r) {
+        // u16 "map": index -> number of actual bits, symbol for code
+        co = new u16(1 << mb);
+        // bits to remove for reverser
+        var rvb = 15 - mb;
+        for (i = 0; i < s; ++i) {
+            // ignore 0 lengths
+            if (cd[i]) {
+                // num encoding both symbol and bits read
+                var sv = (i << 4) | cd[i];
+                // free bits
+                var r_1 = mb - cd[i];
+                // start value
+                var v = le[cd[i] - 1]++ << r_1;
+                // m is end value
+                for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                    // every 16 bit value starting with the code yields the same result
+                    co[rev[v] >> rvb] = sv;
+                }
+            }
+        }
+    }
+    else {
+        co = new u16(s);
+        for (i = 0; i < s; ++i) {
+            if (cd[i]) {
+                co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
+            }
+        }
+    }
+    return co;
+});
+// fixed length tree
+var flt = new u8(288);
+for (var i = 0; i < 144; ++i)
+    flt[i] = 8;
+for (var i = 144; i < 256; ++i)
+    flt[i] = 9;
+for (var i = 256; i < 280; ++i)
+    flt[i] = 7;
+for (var i = 280; i < 288; ++i)
+    flt[i] = 8;
+// fixed distance tree
+var fdt = new u8(32);
+for (var i = 0; i < 32; ++i)
+    fdt[i] = 5;
+// fixed length map
+var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+// fixed distance map
+var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+// find max of array
+var max = function (a) {
+    var m = a[0];
+    for (var i = 1; i < a.length; ++i) {
+        if (a[i] > m)
+            m = a[i];
+    }
+    return m;
+};
+// read d, starting at bit p and mask with m
+var bits = function (d, p, m) {
+    var o = (p / 8) | 0;
+    return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;
+};
+// read d, starting at bit p continuing for at least 16 bits
+var bits16 = function (d, p) {
+    var o = (p / 8) | 0;
+    return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));
+};
+// get end of byte
+var shft = function (p) { return ((p + 7) / 8) | 0; };
+// typed array slice - allows garbage collector to free original reference,
+// while being more compatible than .slice
+var slc = function (v, s, e) {
+    if (s == null || s < 0)
+        s = 0;
+    if (e == null || e > v.length)
+        e = v.length;
+    // can't use .constructor in case user-supplied
+    return new u8(v.subarray(s, e));
+};
+// error codes
+var ec = [
+    'unexpected EOF',
+    'invalid block type',
+    'invalid length/literal',
+    'invalid distance',
+    'stream finished',
+    'no stream handler',
+    ,
+    'no callback',
+    'invalid UTF-8 data',
+    'extra field too long',
+    'date not in range 1980-2099',
+    'filename too long',
+    'stream finishing',
+    'invalid zip data'
+    // determined by unknown compression method
+];
+var err = function (ind, msg, nt) {
+    var e = new Error(msg || ec[ind]);
+    e.code = ind;
+    if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+    if (!nt)
+        throw e;
+    return e;
+};
+// expands raw DEFLATE data
+var inflt = function (dat, st, buf, dict) {
+    // source length       dict length
+    var sl = dat.length, dl = dict ? dict.length : 0;
+    if (!sl || st.f && !st.l)
+        return buf || new u8(0);
+    var noBuf = !buf;
+    // have to estimate size
+    var resize = noBuf || st.i != 2;
+    // no state
+    var noSt = st.i;
+    // Assumes roughly 33% compression ratio average
+    if (noBuf)
+        buf = new u8(sl * 3);
+    // ensure buffer can fit at least l elements
+    var cbuf = function (l) {
+        var bl = buf.length;
+        // need to increase size to fit
+        if (l > bl) {
+            // Double or set to necessary, whichever is greater
+            var nbuf = new u8(Math.max(bl * 2, l));
+            nbuf.set(buf);
+            buf = nbuf;
+        }
+    };
+    //  last chunk         bitpos           bytes
+    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+    // total bits
+    var tbts = sl * 8;
+    do {
+        if (!lm) {
+            // BFINAL - this is only 1 when last chunk is next
+            final = bits(dat, pos, 1);
+            // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
+            var type = bits(dat, pos + 1, 3);
+            pos += 3;
+            if (!type) {
+                // go to end of byte boundary
+                var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                if (t > sl) {
+                    if (noSt)
+                        err(0);
+                    break;
+                }
+                // ensure size
+                if (resize)
+                    cbuf(bt + l);
+                // Copy over uncompressed data
+                buf.set(dat.subarray(s, t), bt);
+                // Get new bitpos, update byte count
+                st.b = bt += l, st.p = pos = t * 8, st.f = final;
+                continue;
+            }
+            else if (type == 1)
+                lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+            else if (type == 2) {
+                //  literal                            lengths
+                var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                var tl = hLit + bits(dat, pos + 5, 31) + 1;
+                pos += 14;
+                // length+distance tree
+                var ldt = new u8(tl);
+                // code length tree
+                var clt = new u8(19);
+                for (var i = 0; i < hcLen; ++i) {
+                    // use index map to get real code
+                    clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                }
+                pos += hcLen * 3;
+                // code lengths bits
+                var clb = max(clt), clbmsk = (1 << clb) - 1;
+                // code lengths map
+                var clm = hMap(clt, clb, 1);
+                for (var i = 0; i < tl;) {
+                    var r = clm[bits(dat, pos, clbmsk)];
+                    // bits read
+                    pos += r & 15;
+                    // symbol
+                    var s = r >> 4;
+                    // code length to copy
+                    if (s < 16) {
+                        ldt[i++] = s;
+                    }
+                    else {
+                        //  copy   count
+                        var c = 0, n = 0;
+                        if (s == 16)
+                            n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                        else if (s == 17)
+                            n = 3 + bits(dat, pos, 7), pos += 3;
+                        else if (s == 18)
+                            n = 11 + bits(dat, pos, 127), pos += 7;
+                        while (n--)
+                            ldt[i++] = c;
+                    }
+                }
+                //    length tree                 distance tree
+                var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                // max length bits
+                lbt = max(lt);
+                // max dist bits
+                dbt = max(dt);
+                lm = hMap(lt, lbt, 1);
+                dm = hMap(dt, dbt, 1);
+            }
+            else
+                err(1);
+            if (pos > tbts) {
+                if (noSt)
+                    err(0);
+                break;
+            }
+        }
+        // Make sure the buffer can hold this + the largest possible addition
+        // Maximum chunk size (practically, theoretically infinite) is 2^17
+        if (resize)
+            cbuf(bt + 131072);
+        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        var lpos = pos;
+        for (;; lpos = pos) {
+            // bits read, code
+            var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+            pos += c & 15;
+            if (pos > tbts) {
+                if (noSt)
+                    err(0);
+                break;
+            }
+            if (!c)
+                err(2);
+            if (sym < 256)
+                buf[bt++] = sym;
+            else if (sym == 256) {
+                lpos = pos, lm = null;
+                break;
+            }
+            else {
+                var add = sym - 254;
+                // no extra bits needed if less
+                if (sym > 264) {
+                    // index
+                    var i = sym - 257, b = fleb[i];
+                    add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                    pos += b;
+                }
+                // dist
+                var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+                if (!d)
+                    err(3);
+                pos += d & 15;
+                var dt = fd[dsym];
+                if (dsym > 3) {
+                    var b = fdeb[dsym];
+                    dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+                }
+                if (pos > tbts) {
+                    if (noSt)
+                        err(0);
+                    break;
+                }
+                if (resize)
+                    cbuf(bt + 131072);
+                var end = bt + add;
+                if (bt < dt) {
+                    var shift = dl - dt, dend = Math.min(dt, end);
+                    if (shift + bt < 0)
+                        err(3);
+                    for (; bt < dend; ++bt)
+                        buf[bt] = dict[shift + bt];
+                }
+                for (; bt < end; ++bt)
+                    buf[bt] = buf[bt - dt];
+            }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm)
+            final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+    } while (!final);
+    // don't reallocate for streams or user buffers
+    return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+// empty
+var et = /*#__PURE__*/ new u8(0);
+// read 2 bytes
+var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };
+// read 4 bytes
+var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };
+var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };
+/**
+ * Expands DEFLATE data with no wrapper
+ * @param data The data to decompress
+ * @param opts The decompression options
+ * @returns The decompressed version of the data
+ */
+function inflateSync(data, opts) {
+    return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+// text decoder
+var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
+// text decoder stream
+var tds = 0;
+try {
+    td.decode(et, { stream: true });
+    tds = 1;
+}
+catch (e) { }
+// decode UTF8
+var dutf8 = function (d) {
+    for (var r = '', i = 0;;) {
+        var c = d[i++];
+        var eb = (c > 127) + (c > 223) + (c > 239);
+        if (i + eb > d.length)
+            return { s: r, r: slc(d, i - 1) };
+        if (!eb)
+            r += String.fromCharCode(c);
+        else if (eb == 3) {
+            c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536,
+                r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));
+        }
+        else if (eb & 1)
+            r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63));
+        else
+            r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63));
+    }
+};
+/**
+ * Converts a Uint8Array to a string
+ * @param dat The data to decode to string
+ * @param latin1 Whether or not to interpret the data as Latin-1. This should
+ *               not need to be true unless encoding to binary string.
+ * @returns The original UTF-8/Latin-1 string
+ */
+function strFromU8(dat, latin1) {
+    if (latin1) {
+        var r = '';
+        for (var i = 0; i < dat.length; i += 16384)
+            r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+        return r;
+    }
+    else if (td) {
+        return td.decode(dat);
+    }
+    else {
+        var _a = dutf8(dat), s = _a.s, r = _a.r;
+        if (r.length)
+            err(8);
+        return s;
+    }
+}
+// skip local zip header
+var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };
+// read zip header
+var zh = function (d, b, z) {
+    var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
+    var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];
+    return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
+};
+// read zip64 extra field
+var z64e = function (d, b) {
+    for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
+        ;
+    return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+};
+/**
+ * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
+ * performance with more than one file.
+ * @param data The raw compressed ZIP file
+ * @param opts The ZIP extraction options
+ * @returns The decompressed files
+ */
+function unzipSync(data, opts) {
+    var files = {};
+    var e = data.length - 22;
+    for (; b4(data, e) != 0x6054B50; --e) {
+        if (!e || data.length - e > 65558)
+            err(13);
+    }
+    var c = b2(data, e + 8);
+    if (!c)
+        return {};
+    var o = b4(data, e + 16);
+    var z = o == 4294967295 || c == 65535;
+    if (z) {
+        var ze = b4(data, e - 12);
+        z = b4(data, ze) == 0x6064B50;
+        if (z) {
+            c = b4(data, ze + 32);
+            o = b4(data, ze + 48);
+        }
+    }
+    for (var i = 0; i < c; ++i) {
+        var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
+        o = no;
+        {
+            if (!c_2)
+                files[fn] = slc(data, b, b + sc);
+            else if (c_2 == 8)
+                files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+            else
+                err(14, 'unknown compression type ' + c_2);
+        }
+    }
+    return files;
 }
 
 class UnLitMaterial extends Material {
@@ -40545,7 +40891,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.11";
+const version = "1.0.13";
 
 class Engine3D {
   /**
@@ -45058,9 +45404,9 @@ class AtmosphericTexture2D extends VirtualTexture {
   }
 }
 
-var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
-var __decorateClass$a = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
+var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
+var __decorateClass$c = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -45084,7 +45430,7 @@ let SkyShader = class extends Shader {
     shaderState.depthCompare = GPUCompareFunction.less;
   }
 };
-SkyShader = __decorateClass$a([
+SkyShader = __decorateClass$c([
   RegisterShader(SkyShader, "SkyShader")
 ], SkyShader);
 
@@ -45882,9 +46228,9 @@ class SkeletonAnimationClipState {
   }
 }
 
-var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
-var __decorateClass$9 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
+var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
+var __decorateClass$b = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -46088,7 +46434,7 @@ let SkeletonAnimationComponent = class extends ComponentBase {
     this._currentClipState.weight = 1;
   }
 };
-SkeletonAnimationComponent = __decorateClass$9([
+SkeletonAnimationComponent = __decorateClass$b([
   RegisterComponent(SkeletonAnimationComponent, "SkeletonAnimationComponent")
 ], SkeletonAnimationComponent);
 class SkeletonAnimationCrossFadeState {
@@ -46124,9 +46470,9 @@ class SkeletonAnimationCrossFadeState {
   }
 }
 
-var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
-var __decorateClass$8 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
+var __decorateClass$a = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -46537,7 +46883,7 @@ let AnimatorComponent = class extends ComponentBase {
     return dst;
   }
 };
-AnimatorComponent = __decorateClass$8([
+AnimatorComponent = __decorateClass$a([
   RegisterComponent(AnimatorComponent, "AnimatorComponent")
 ], AnimatorComponent);
 class PropertyAnimationClipState {
@@ -47294,9 +47640,9 @@ class PropertyAnimation extends ComponentBase {
   }
 }
 
-var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
-var __decorateClass$7 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
+var __decorateClass$9 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -47445,7 +47791,7 @@ let SkinnedMeshRenderer2 = class extends MeshRenderer {
     super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
   }
 };
-SkinnedMeshRenderer2 = __decorateClass$7([
+SkinnedMeshRenderer2 = __decorateClass$9([
   RegisterComponent(SkinnedMeshRenderer2, "SkinnedMeshRenderer2")
 ], SkinnedMeshRenderer2);
 
@@ -52578,9 +52924,9 @@ class UITextField extends UIRenderAble {
   }
 }
 
-var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
-var __decorateClass$6 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+var __decorateClass$8 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -52657,10 +53003,86 @@ let Light = class extends LightBase {
   debugDraw(show) {
   }
 };
-Light = __decorateClass$6([
+Light = __decorateClass$8([
   RegisterComponent(Light, "Light")
 ], Light);
 
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+let FatLineRenderer = class extends RenderNode {
+  _fatLineMaterial = null;
+  _fatLineGeometry = null;
+  constructor() {
+    super();
+  }
+  onEnable() {
+    super.onEnable();
+  }
+  onDisable() {
+    super.onDisable();
+  }
+  cloneTo(obj) {
+    const component = obj.addComponent(FatLineRenderer);
+    component.copyComponent(this);
+  }
+  copyComponent(from) {
+    super.copyComponent(from);
+    return this;
+  }
+  /**
+   * Set FatLine geometry
+   */
+  set geometry(value) {
+    super.geometry = value;
+    this._fatLineGeometry = value;
+    if (value) {
+      this.instanceCount = value.instanceCount;
+      if (this._fatLineMaterial && value.instanceBuffer) {
+        this._fatLineMaterial.setInstanceBuffer(value.instanceBuffer);
+      }
+    }
+  }
+  get geometry() {
+    return this._fatLineGeometry;
+  }
+  /**
+   * Set FatLine material
+   */
+  set material(value) {
+    this.materials = [value];
+    this._fatLineMaterial = value;
+    if (this._fatLineGeometry && this._fatLineGeometry.instanceBuffer) {
+      value.setInstanceBuffer(this._fatLineGeometry.instanceBuffer);
+    }
+  }
+  get material() {
+    return this._fatLineMaterial;
+  }
+  /**
+   * Override nodeUpdate to automatically update FatLine-specific uniforms
+   */
+  nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+    if (this._fatLineMaterial && this.object3D) {
+      this._fatLineMaterial.setModelMatrix(this.object3D.transform.worldMatrix);
+      const width = webGPUContext.presentationSize[0];
+      const height = webGPUContext.presentationSize[1];
+      if (width > 0 && height > 0) {
+        this._fatLineMaterial.resolution = new Vector2(width, height);
+      }
+    }
+    super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
+  }
+};
+FatLineRenderer = __decorateClass$7([
+  RegisterComponent(FatLineRenderer, "FatLineRenderer")
+], FatLineRenderer);
+
 class Probe extends Object3D {
   index = 0;
   drawCallFrame = -1;
@@ -52959,9 +53381,9 @@ class InstanceDrawComponent extends RenderNode {
   }
 }
 
-var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
-var __decorateClass$5 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -52987,13 +53409,13 @@ let MeshFilter = class extends MeshRenderer {
     }
   }
 };
-MeshFilter = __decorateClass$5([
+MeshFilter = __decorateClass$6([
   RegisterComponent(MeshFilter, "MeshFilter")
 ], MeshFilter);
 
-var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
-var __decorateClass$4 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -53119,7 +53541,7 @@ let SkinnedMeshRenderer = class extends MeshRenderer {
     super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
   }
 };
-SkinnedMeshRenderer = __decorateClass$4([
+SkinnedMeshRenderer = __decorateClass$5([
   RegisterComponent(SkinnedMeshRenderer, "SkinnedMeshRenderer")
 ], SkinnedMeshRenderer);
 
@@ -53951,6 +54373,230 @@ class ExtrudeGeometry extends GeometryBase {
   }
 }
 
+class FatLineGeometry extends GeometryBase {
+  _instanceBuffer;
+  _instanceData;
+  _instanceCount = 0;
+  constructor() {
+    super();
+    this.initBaseGeometry();
+  }
+  /**
+   * Initialize base quad geometry (shared by all line segments)
+   * This is similar to ThreeJS LineSegmentsGeometry base geometry
+   */
+  initBaseGeometry() {
+    const positions = new Float32Array([
+      -1,
+      2,
+      0,
+      1,
+      2,
+      0,
+      // Top endcap
+      -1,
+      1,
+      0,
+      1,
+      1,
+      0,
+      // Top of line segment
+      -1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      // Bottom of line segment
+      -1,
+      -1,
+      0,
+      1,
+      -1,
+      0
+      // Bottom endcap
+    ]);
+    const uvs = new Float32Array([
+      -1,
+      2,
+      1,
+      2,
+      -1,
+      1,
+      1,
+      1,
+      -1,
+      -1,
+      1,
+      -1,
+      -1,
+      -2,
+      1,
+      -2
+    ]);
+    const indices = new Uint16Array([
+      0,
+      2,
+      1,
+      2,
+      3,
+      1,
+      // First quad
+      2,
+      4,
+      3,
+      4,
+      5,
+      3,
+      // Second quad
+      4,
+      6,
+      5,
+      6,
+      7,
+      5
+      // Third quad
+    ]);
+    this.setIndices(indices);
+    this.setAttribute(VertexAttributeName.position, positions);
+    this.setAttribute(VertexAttributeName.uv, uvs);
+    this.addSubGeometry({
+      indexStart: 0,
+      indexCount: indices.length,
+      vertexStart: 0,
+      vertexCount: positions.length / 3,
+      firstStart: 0,
+      index: 0,
+      topology: 0
+    });
+  }
+  /**
+   * Set line positions from continuous points array
+   * @param positions Array of positions [x1,y1,z1, x2,y2,z2, ...]
+   */
+  setPositions(positions) {
+    const posArray = positions instanceof Float32Array ? positions : new Float32Array(positions);
+    const numPoints = posArray.length / 3;
+    const numSegments = numPoints - 1;
+    if (numSegments <= 0) {
+      console.warn("FatLineGeometry: Need at least 2 points");
+      return this;
+    }
+    const instanceData = new Float32Array(numSegments * 16);
+    for (let i = 0; i < numSegments; i++) {
+      const i0 = i * 3;
+      const i1 = (i + 1) * 3;
+      instanceData[i * 16 + 0] = posArray[i0 + 0];
+      instanceData[i * 16 + 1] = posArray[i0 + 1];
+      instanceData[i * 16 + 2] = posArray[i0 + 2];
+      instanceData[i * 16 + 3] = 0;
+      instanceData[i * 16 + 4] = posArray[i1 + 0];
+      instanceData[i * 16 + 5] = posArray[i1 + 1];
+      instanceData[i * 16 + 6] = posArray[i1 + 2];
+      instanceData[i * 16 + 7] = 0;
+      instanceData[i * 16 + 8] = 1;
+      instanceData[i * 16 + 9] = 1;
+      instanceData[i * 16 + 10] = 1;
+      instanceData[i * 16 + 11] = 0;
+      instanceData[i * 16 + 12] = 1;
+      instanceData[i * 16 + 13] = 1;
+      instanceData[i * 16 + 14] = 1;
+      instanceData[i * 16 + 15] = 0;
+    }
+    this._instanceData = instanceData;
+    this._instanceCount = numSegments;
+    this.computeBoundingBox(posArray);
+    return this;
+  }
+  /**
+   * Set colors for line segments
+   * @param colors Array of colors [r1,g1,b1, r2,g2,b2, ...] for each point
+   */
+  setColors(colors) {
+    const colorArray = colors instanceof Float32Array ? colors : new Float32Array(colors);
+    if (!this._instanceData) {
+      console.warn(
+        "FatLineGeometry: Must call setPositions() before setColors()"
+      );
+      return this;
+    }
+    const numPoints = colorArray.length / 3;
+    const numSegments = numPoints - 1;
+    if (numSegments !== this._instanceCount) {
+      console.warn(
+        "FatLineGeometry: Color array length doesn't match segment count"
+      );
+      return this;
+    }
+    for (let i = 0; i < numSegments; i++) {
+      const i0 = i * 3;
+      const i1 = (i + 1) * 3;
+      this._instanceData[i * 16 + 8] = colorArray[i0 + 0];
+      this._instanceData[i * 16 + 9] = colorArray[i0 + 1];
+      this._instanceData[i * 16 + 10] = colorArray[i0 + 2];
+      this._instanceData[i * 16 + 12] = colorArray[i1 + 0];
+      this._instanceData[i * 16 + 13] = colorArray[i1 + 1];
+      this._instanceData[i * 16 + 14] = colorArray[i1 + 2];
+    }
+    return this;
+  }
+  /**
+   * Compute bounding box from positions
+   */
+  computeBoundingBox(positions) {
+    const min = new Vector3(Infinity, Infinity, Infinity);
+    const max = new Vector3(-Infinity, -Infinity, -Infinity);
+    for (let i = 0; i < positions.length; i += 3) {
+      const x = positions[i];
+      const y = positions[i + 1];
+      const z = positions[i + 2];
+      min.x = Math.min(min.x, x);
+      min.y = Math.min(min.y, y);
+      min.z = Math.min(min.z, z);
+      max.x = Math.max(max.x, x);
+      max.y = Math.max(max.y, y);
+      max.z = Math.max(max.z, z);
+    }
+    const size = Vector3.sub(max, min);
+    this.bounds = new BoundingBox(Vector3.ZERO.clone(), size);
+    this.bounds.setFromMinMax(min, max);
+  }
+  /**
+   * Get instance data for GPU upload
+   */
+  get instanceData() {
+    return this._instanceData;
+  }
+  /**
+   * Get number of line segments (instances)
+   */
+  get instanceCount() {
+    return this._instanceCount;
+  }
+  /**
+   * Get or create instance buffer
+   */
+  get instanceBuffer() {
+    if (!this._instanceBuffer && this._instanceData) {
+      this._instanceBuffer = new StorageGPUBuffer(
+        this._instanceData.byteLength
+      );
+      this._instanceBuffer.setFloat32Array("", this._instanceData);
+      this._instanceBuffer.apply();
+    }
+    return this._instanceBuffer;
+  }
+  /**
+   * Update instance buffer with new data
+   */
+  updateInstanceBuffer() {
+    if (this._instanceBuffer && this._instanceData) {
+      this._instanceBuffer.setFloat32Array("", this._instanceData);
+      this._instanceBuffer.apply();
+    }
+  }
+}
+
 class VertexBufferLayout {
   name;
   offset;
@@ -59221,9 +59867,9 @@ class PrefabTextureParser extends ParserBase {
   }
 }
 
-var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
-var __decorateClass$3 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -59342,13 +59988,13 @@ let LitSSSShader = class extends Shader {
     }
   }
 };
-LitSSSShader = __decorateClass$3([
+LitSSSShader = __decorateClass$4([
   RegisterShader(LitSSSShader, "LitSSSShader")
 ], LitSSSShader);
 
-var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
-var __decorateClass$2 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (decorator(result)) || result;
@@ -59444,7 +60090,7 @@ let LitShader = class extends Shader {
     }
   }
 };
-LitShader = __decorateClass$2([
+LitShader = __decorateClass$3([
   RegisterShader(LitShader, "LitShader")
 ], LitShader);
 
@@ -59603,6 +60249,47 @@ class PrefabStringUtil {
   }
 }
 
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+let FatLineShader = class extends Shader {
+  constructor() {
+    super();
+    const colorShader = new RenderShaderPass("FatLine_VS", "FatLine_FS");
+    colorShader.setShaderEntry(`VertMain`, `FragMain`);
+    this.addRenderPass(colorShader);
+    const shaderState = colorShader.shaderState;
+    shaderState.acceptShadow = false;
+    shaderState.castShadow = false;
+    shaderState.receiveEnv = false;
+    shaderState.acceptGI = false;
+    shaderState.useLight = false;
+    shaderState.cullMode = GPUCullMode.none;
+    shaderState.depthWriteEnabled = true;
+    this.setDefault();
+  }
+  /**
+   * Set default uniform values
+   */
+  setDefault() {
+    this.setUniformColor(`baseColor`, new Color(1, 1, 1, 1));
+    this.setUniformFloat(`lineWidth`, 1);
+    this.setUniformFloat(`opacity`, 1);
+    this.setUniformVector2(`resolution`, new Vector2(1920, 1080));
+    const identityMatrix = new Matrix4();
+    const pass = this.getDefaultColorShader();
+    pass.setUniform(`modelMatrix`, identityMatrix.rawData);
+  }
+};
+FatLineShader = __decorateClass$2([
+  RegisterShader(FatLineShader, "FatLineShader")
+], FatLineShader);
+
 var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
 var __decorateClass$1 = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
@@ -59939,6 +60626,78 @@ class ColorLitMaterial extends Material {
   }
 }
 
+class FatLineMaterial extends Material {
+  constructor() {
+    super();
+    this.shader = new FatLineShader();
+    this.transparent = true;
+  }
+  /**
+   * Set instance buffer for line segments
+   * This should be called after setting the geometry
+   */
+  setInstanceBuffer(buffer) {
+    this.shader.setStorageBuffer("instances", buffer);
+  }
+  /**
+   * Set model matrix for transforming line segments
+   * This should be updated each frame if the object moves
+   */
+  setModelMatrix(matrix) {
+    const pass = this.shader.getDefaultColorShader();
+    pass.setUniform("modelMatrix", matrix.rawData);
+  }
+  /**
+   * Set base color (tint color)
+   */
+  set baseColor(color) {
+    this.shader.setUniformColor(`baseColor`, color);
+  }
+  /**
+   * Get base color (tint color)
+   */
+  get baseColor() {
+    return this.shader.getUniformColor("baseColor");
+  }
+  /**
+   * Set line width in pixels
+   */
+  set lineWidth(value) {
+    this.shader.setUniformFloat(`lineWidth`, value);
+  }
+  /**
+   * Get line width in pixels
+   */
+  get lineWidth() {
+    return this.shader.getUniformFloat("lineWidth");
+  }
+  /**
+   * Set opacity (0-1)
+   */
+  set opacity(value) {
+    this.shader.setUniformFloat(`opacity`, value);
+  }
+  /**
+   * Get opacity (0-1)
+   */
+  get opacity() {
+    return this.shader.getUniformFloat("opacity");
+  }
+  /**
+   * Set viewport resolution for correct pixel-space calculations
+   * This should be set automatically by the renderer
+   */
+  set resolution(value) {
+    this.shader.setUniformVector2(`resolution`, value);
+  }
+  /**
+   * Get viewport resolution
+   */
+  get resolution() {
+    return this.shader.getUniformVector2("resolution");
+  }
+}
+
 class LambertMaterial extends Material {
   /**
    * @constructor
@@ -65718,4 +66477,4 @@ const __viteBrowserExternal = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.def
   __proto__: null
 }, Symbol.toStringTag, { value: 'Module' }));
 
-export { AccelerateDecelerateInterpolator, AccelerateInterpolator, AnimationCurve, AnimationCurveT, AnimationMonitor, AnimatorComponent, AnimatorEventKeyframe, AnticipateInterpolator, AnticipateOvershootInterpolator, ArrayHas, ArrayItemIndex, AtlasParser, AtmosphericComponent, AtmosphericScatteringSky, AtmosphericScatteringSkySetting, AtmosphericScatteringSky_shader, AttributeAnimCurve, AxisObject, B3DMLoader, B3DMLoaderBase, B3DMParseUtil, B3DMParser, BRDFLUT, BRDFLUTGenerate, BRDF_frag, BatchTable, BiMap, BillboardComponent, BillboardType, BitUtil, BitmapTexture2D, BitmapTexture2DArray, BitmapTextureCube, Blend, BlendFactor, BlendMode, BlendShapeData, BlendShapePropertyData, BloomPost, BlurEffectCreatorBlur_cs, BlurEffectCreatorSample_cs, BlurTexture2DBufferCreator, BounceInterpolator, BoundUtil, BoundingBox, BoundingSphere, BoxColliderShape, BoxGeometry, BrdfLut_frag, BsDF_frag, BxDF_frag, BxdfDebug_frag, BytesArray, CEvent, CEventDispatcher, CEventListener, CResizeEvent, CSM, Camera3D, CameraControllerBase, CameraType, CameraUtil, CapsuleColliderShape, CastPointShadowMaterialPass, CastShadowMaterialPass, Clearcoat_frag, ClusterBoundsSource_cs, ClusterConfig, ClusterDebug_frag, ClusterLight, ClusterLightingBuffer, ClusterLightingRender, ClusterLighting_cs, CollectInfo, ColliderComponent, ColliderShape, ColliderShapeType, Color, ColorGradient, ColorLitMaterial, ColorLitShader, ColorPassFragmentOutput, ColorPassRenderer, ColorUtil, ComData, Combine_cs, Common_frag, Common_vert, ComponentBase, ComponentCollect, ComputeGPUBuffer, ComputeShader, Context3D, CubeCamera, CubeMapFaceEnum, CubeSky_Shader, CubicBezierCurve, CubicBezierPath, CubicBezierType, CycleInterpolator, CylinderGeometry, DDGIIrradianceComputePass, DDGIIrradianceGPUBufferReader, DDGIIrradianceVolume, DDGIIrradiance_shader, DDGILightingPass, DDGILighting_shader, DDGIMultiBouncePass, DDGIProbeRenderer, DEGREES_TO_RADIANS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FASTFLOOR, FXAAPost, FXAAShader, FastMathShader, FeatureTable, FileLoader, FirstPersonCameraController, Float16ArrayTexture, Float32ArrayTexture, FlyCameraController, FontChar, FontInfo, FontPage, FontParser, ForwardRenderJob, FragmentOutput, FragmentVarying, FrameCache, Frustum, FrustumCSM, FrustumCulling_cs, FullQuad_vert_wgsl, GBufferFrame, GBufferPass, GBufferPost, GBufferStand, GBuffer_pass, GILighting, GIProbeMaterial, GIProbeMaterialType, GIProbeShader, GIRenderCompleteEvent, GIRenderStartEvent, GLBChunk, GLBHeader, GLBParser, GLSLLexer, GLSLLexerToken, GLSLPreprocessor, GLSLSyntax, GLTFBinaryExtension, GLTFMaterial, GLTFParser, GLTFSubParser, GLTFSubParserCamera, GLTFSubParserConverter, GLTFSubParserMaterial, GLTFSubParserMesh, GLTFSubParserSkeleton, GLTFSubParserSkin, GLTFType, GLTF_Accessors, GLTF_Info, GLTF_Light, GLTF_Mesh, GLTF_Node, GLTF_Primitives, GLTF_Scene, GPUAddressMode, GPUBlendFactor, GPUBufferBase, GPUBufferType, GPUCompareFunction, GPUContext, GPUCullMode, GPUFilterMode, GPUPrimitiveTopology, GPUTextureFormat, GPUVertexFormat, GPUVertexStepMode, GSplatFormat, GSplatMaterial, GSplatRenderer, GSplat_FS, GSplat_VS, GTAOPost, GTAO_cs, GUIAtlasTexture, GUICanvas, GUIConfig, GUIGeometry, GUIGeometryRebuild, GUIMaterial, GUIPassRenderer, GUIPick, GUIPickHelper, GUIQuad, GUIQuadAttrEnum, GUIRenderer, GUIShader, GUISpace, GUISprite, GUITexture, GaussianSplatParser, GenerayRandomDir, GeoJsonParser, GeoJsonUtil, GeoType, GeometryBase, GeometryIndicesBuffer, GeometryUtil, GeometryVertexBuffer, GeometryVertexType, GetComponentClass, GetCountInstanceID, GetRepeat, GetShader, GlassShader, GlobalBindGroup, GlobalBindGroupLayout, GlobalFog, GlobalFog_shader, GlobalIlluminationComponent, GlobalUniform, GlobalUniformGroup, GodRayPost, GodRay_cs, GridObject, HDRTexture, HDRTextureCube, Hair_frag, Hair_shader_op, Hair_shader_tr, HaltonSeq, Horizontal, HoverCameraController, I3DMLoader, I3DMLoaderBase, I3DMParser, IBLEnvMapCreator, IBLEnvMapCreator_cs, IESProfiles, IESProfiles_frag, IKDTreeUserData, ImageType, IndicesGPUBuffer, Inline_vert, InputSystem, InstanceDrawComponent, InstanceUniform, InstancedMesh, Interpolator, InterpolatorEnum, IrradianceDataReaderCompleteEvent, IrradianceVolumeData_frag, Irradiance_frag, IsEditorInspector, IsNonSerialize, Joint, JointPose, JumperInterpolator, KDTreeEntity, KDTreeNode, KDTreeRange, KDTreeSpace, KDTreeUUID, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_clearcoat, KHR_materials_emissive_strength, KHR_materials_ior, KHR_materials_unlit, KMZParser, KV, KelvinUtil, KeyCode, KeyEvent, Keyframe, KeyframeT, LDRTextureCube, LambertMaterial, Lambert_shader, Light, LightBase, LightData, LightEntries, LightType, LightingFunction_frag, Line, LineClassification, LinearInterpolator, LitMaterial, LitSSSShader, LitShader, Lit_shader, LoaderBase, LoaderEvent, LoaderManager, MAX_VALUE, MIN_VALUE, Material, MaterialDataUniformGPUBuffer, MaterialUtilities, MathShader, MathUtil, Matrix3, Matrix4, MatrixBindGroup, MatrixGPUBuffer, MatrixShader, MemoryDO, MemoryInfo, MergeRGBACreator, MergeRGBA_cs, MeshColliderShape, MeshFilter, MeshRenderer, MinMaxAnimationCurves, MinMaxCurve, MinMaxCurveState, MinMaxPolyCurves, MorePassParser, MorePassShader, MorphTargetBlender, MorphTargetData, MorphTargetFrame, MorphTargetTransformKey, MorphTarget_shader, MouseCode, MultiBouncePass_cs, Navi3DAstar, Navi3DConst, Navi3DEdge, Navi3DFunnel, Navi3DMaskType, Navi3DMesh, Navi3DPoint, Navi3DPoint2D, Navi3DPointFat, Navi3DRouter, Navi3DTriangle, NonSerialize, NormalMap_frag, OAnimationEvent, OBJParser, Object3D, Object3DEvent, Object3DTransformTools, Object3DUtil, ObjectAnimClip, OcclusionSystem, Octree, OctreeEntity, OrbitController, OrderMap, Orientation3D, OutLineBlendColor_cs, OutlineCalcOutline_cs, OutlinePass, OutlinePost, OutlinePostData, OutlinePostManager, OutlinePostSlot, Outline_cs, OvershootInterpolator, PBRLItShader, PBRLitSSSShader, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PointClassification, PointLight, PointLightShadowRenderer, PointShadowCubeCamera, PointerEvent3D, Polynomial, PolynomialCurve, Polynomials, PoolNode, PostBase, PostProcessingComponent, PostRenderer, PreDepthPassRenderer, PreFilteredEnvironment_cs, PreFilteredEnvironment_cs2, PreIntegratedLut, PreIntegratedLutCompute, PrefabAvatarData, PrefabAvatarParser, PrefabBoneData, PrefabMaterialParser, PrefabMeshData, PrefabMeshParser, PrefabNode, PrefabParser, PrefabStringUtil, PrefabTextureData, PrefabTextureParser, Preprocessor, Probe, ProbeEntries, ProbeGBufferFrame, ProfilerUtil, PropertyAnimClip, PropertyAnimTag, PropertyAnimation, PropertyAnimationClip, PropertyAnimationClipState, PropertyAnimationEvent, PropertyHelp, QuadAABB, QuadGlsl_fs, QuadGlsl_vs, QuadRoot, QuadShader, QuadTree, QuadTreeCell, Quad_depth2dArray_frag_wgsl, Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, Quaternion, RADIANS_TO_DEGREES, RGBEErrorCode, RGBEHeader, RGBEParser, RTDescriptor, RTFrame, RTResourceConfig, RTResourceMap, Rand, RandomSeed, Ray, RayCastMeshDetail, Reader, Rect, Reference, Reflection, ReflectionCG, ReflectionEntries, ReflectionMaterial, ReflectionRenderer, ReflectionShader, ReflectionShader_shader, RegisterComponent, RegisterShader, RenderContext, RenderLayer, RenderLayerUtil, RenderNode, RenderShaderCollect, RenderShaderCompute, RenderShaderPass, RenderTexture, RendererBase, RendererJob, RendererMap, RendererMask, RendererMaskUtil, RendererPassState, RepeatSE, Res, RotationControlComponents, SHCommon_frag, SN_ArrayConstant, SN_BinaryOperation, SN_Break, SN_CodeBlock, SN_Constant, SN_Continue, SN_Declaration, SN_Discard, SN_DoWhileLoop, SN_Expression, SN_ForLoop, SN_Function, SN_FunctionArgs, SN_FunctionCall, SN_IFBranch, SN_Identifier, SN_IndexOperation, SN_Layout, SN_ParenExpression, SN_Precision, SN_Return, SN_SelectOperation, SN_Struct, SN_TernaryOperation, SN_UnaryOperation, SN_WhileLoop, SSAO_cs, SSGI2_cs, SSGIPost, SSRPost, SSR_BlendColor_cs, SSR_IS_Kernel, SSR_IS_cs, SSR_RayTrace_cs, ScaleControlComponents, Scene3D, Shader, ShaderAttributeInfo, ShaderConverter, ShaderConverterResult, ShaderLib, ShaderPassBase, ShaderReflection, ShaderStage, ShaderState, ShaderUniformInfo, ShaderUtil, ShadingInput, ShadowLightsCollect, ShadowMapPassRenderer, ShadowMapping_frag, Skeleton, SkeletonAnimationClip, SkeletonAnimationClipState, SkeletonAnimationComponent, SkeletonAnimationCompute, SkeletonAnimation_shader, SkeletonBlendComputeArgs, SkeletonPose, SkeletonTransformComputeArgs, SkinnedMeshRenderer, SkinnedMeshRenderer2, SkyGBufferPass, SkyGBuffer_pass, SkyMaterial, SkyRenderer, SkyShader, SolidColorSky, SphereColliderShape, SphereGeometry, SphereReflection, SpotLight, StandShader, StatementNode, StorageGPUBuffer, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, TileSet, TileSetChild, TileSetChildContent, TileSetChildContentMetaData, TileSetRoot, TilesRenderer, Time, TokenType, TorusGeometry, TouchData, TrailGeometry, Transform, TransformAxisEnum, TransformControllerBaseComponent, TransformMode, TransformSpaceMode, TranslationControlComponents, TranslatorContext, TriGeometry, Triangle, UIButton, UIButtonTransition, UIComponentBase, UIEvent, UIImage, UIImageGroup, UIInteractive, UIInteractiveStyle, UIPanel, UIRenderAble, UIShadow, UITextField, UITransform, UUID, UV, Uint32ArrayTexture, Uint8ArrayTexture, UnLit, UnLitMaterial, UnLitMaterialUniform_frag, UnLitShader, UnLitTexArrayMaterial, UnLitTexArrayShader, UnLitTextureArray, UnLit_frag, UniformGPUBuffer, UniformNode, UniformType, ValueEnumType, ValueOp, ValueParser, ValueSpread, Vector2, Vector3, Vector3Ex, Vector4, VertexAttribute, VertexAttributeIndexShader, VertexAttributeName, VertexAttributeSize, VertexAttributeStride, VertexAttributes_vert, VertexBufferLayout, VertexFormat, VertexGPUBuffer, Vertical, VideoUniform_frag, View3D, ViewPanel, ViewQuad, VirtualTexture, WGSLTranslator, WayLines3D, WayPoint3D, WebGPUDescriptorCreator, WorldMatrixUniform, WorldPanel, WrapMode, WrapTimeMode, ZCullingCompute, ZPassShader_cs, ZPassShader_fs, ZPassShader_vs, ZSorterUtil, append, arrayToString, blendComponent, buildCurves, byteSizeOfType, calculateCurveRangesValue, calculateMinMax, castPointShadowMap_vert, clamp, clampRepeat, computeAABBFromPositions, cos, crossProduct, cubicPolynomialRoot, cubicPolynomialRootsGeneric, curvesSupportProcedural, deg2Rad, detectGSplatFormat, directionShadowCastMap_frag, dot, doubleIntegrateSegment, downSample, fastInvSqrt, floorfToIntPos, fonts, generateRandom, generateRandom3, getFloatFromInt, getGLTypeFromTypedArray, getGLTypeFromTypedArrayType, getGlobalRandomSeed, getTypedArray, getTypedArrayTypeFromGLType, grad1, grad2, grad3, grad4, inferSHOrder, integrateSegment, irradianceDataReader, kPI, lerp, lerpByte, lerpColor, lerpVector3, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, perm, post, quadraticPolynomialRootsGeneric, rad2Deg, random01, randomBarycentricCoord, randomPointBetweenEllipsoid, randomPointBetweenSphere, randomPointInsideCube, randomPointInsideEllipsoid, randomPointInsideUnitCircle, randomPointInsideUnitSphere, randomQuaternion, randomQuaternionUniformDistribution, randomSeed, randomUnitVector, randomUnitVector2, rangedRandomFloat, rangedRandomInt, readByType, readMagicBytes, registerMaterial, repeat, rotMatrix, rotateVectorByQuat, roundfToIntPos, scale, shadowCastMap_frag, shadowCastMap_vert, simplex, sin, snoise1, snoise2, snoise3, snoise4, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, toHalfFloat, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };
+export { AccelerateDecelerateInterpolator, AccelerateInterpolator, AnimationCurve, AnimationCurveT, AnimationMonitor, AnimatorComponent, AnimatorEventKeyframe, AnticipateInterpolator, AnticipateOvershootInterpolator, ArrayHas, ArrayItemIndex, AtlasParser, AtmosphericComponent, AtmosphericScatteringSky, AtmosphericScatteringSkySetting, AtmosphericScatteringSky_shader, AttributeAnimCurve, AxisObject, B3DMLoader, B3DMLoaderBase, B3DMParseUtil, B3DMParser, BRDFLUT, BRDFLUTGenerate, BRDF_frag, BatchTable, BiMap, BillboardComponent, BillboardType, BitUtil, BitmapTexture2D, BitmapTexture2DArray, BitmapTextureCube, Blend, BlendFactor, BlendMode, BlendShapeData, BlendShapePropertyData, BloomPost, BlurEffectCreatorBlur_cs, BlurEffectCreatorSample_cs, BlurTexture2DBufferCreator, BounceInterpolator, BoundUtil, BoundingBox, BoundingSphere, BoxColliderShape, BoxGeometry, BrdfLut_frag, BsDF_frag, BxDF_frag, BxdfDebug_frag, BytesArray, CEvent, CEventDispatcher, CEventListener, CResizeEvent, CSM, Camera3D, CameraControllerBase, CameraType, CameraUtil, CapsuleColliderShape, CastPointShadowMaterialPass, CastShadowMaterialPass, Clearcoat_frag, ClusterBoundsSource_cs, ClusterConfig, ClusterDebug_frag, ClusterLight, ClusterLightingBuffer, ClusterLightingRender, ClusterLighting_cs, CollectInfo, ColliderComponent, ColliderShape, ColliderShapeType, Color, ColorGradient, ColorLitMaterial, ColorLitShader, ColorPassFragmentOutput, ColorPassRenderer, ColorUtil, ComData, Combine_cs, Common_frag, Common_vert, ComponentBase, ComponentCollect, ComputeGPUBuffer, ComputeShader, Context3D, CubeCamera, CubeMapFaceEnum, CubeSky_Shader, CubicBezierCurve, CubicBezierPath, CubicBezierType, CycleInterpolator, CylinderGeometry, DDGIIrradianceComputePass, DDGIIrradianceGPUBufferReader, DDGIIrradianceVolume, DDGIIrradiance_shader, DDGILightingPass, DDGILighting_shader, DDGIMultiBouncePass, DDGIProbeRenderer, DEGREES_TO_RADIANS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FASTFLOOR, FXAAPost, FXAAShader, FastMathShader, FatLineGeometry, FatLineMaterial, FatLineRenderer, FatLineShader, FatLine_FS, FatLine_VS, FeatureTable, FileLoader, FirstPersonCameraController, Float16ArrayTexture, Float32ArrayTexture, FlyCameraController, FontChar, FontInfo, FontPage, FontParser, ForwardRenderJob, FragmentOutput, FragmentVarying, FrameCache, Frustum, FrustumCSM, FrustumCulling_cs, FullQuad_vert_wgsl, GBufferFrame, GBufferPass, GBufferPost, GBufferStand, GBuffer_pass, GILighting, GIProbeMaterial, GIProbeMaterialType, GIProbeShader, GIRenderCompleteEvent, GIRenderStartEvent, GLBChunk, GLBHeader, GLBParser, GLSLLexer, GLSLLexerToken, GLSLPreprocessor, GLSLSyntax, GLTFBinaryExtension, GLTFMaterial, GLTFParser, GLTFSubParser, GLTFSubParserCamera, GLTFSubParserConverter, GLTFSubParserMaterial, GLTFSubParserMesh, GLTFSubParserSkeleton, GLTFSubParserSkin, GLTFType, GLTF_Accessors, GLTF_Info, GLTF_Light, GLTF_Mesh, GLTF_Node, GLTF_Primitives, GLTF_Scene, GPUAddressMode, GPUBlendFactor, GPUBufferBase, GPUBufferType, GPUCompareFunction, GPUContext, GPUCullMode, GPUFilterMode, GPUPrimitiveTopology, GPUTextureFormat, GPUVertexFormat, GPUVertexStepMode, GSplatFormat, GSplatGeometry, GSplatMaterial, GSplatRenderer, GSplatShader, GSplat_FS, GSplat_VS, GTAOPost, GTAO_cs, GUIAtlasTexture, GUICanvas, GUIConfig, GUIGeometry, GUIGeometryRebuild, GUIMaterial, GUIPassRenderer, GUIPick, GUIPickHelper, GUIQuad, GUIQuadAttrEnum, GUIRenderer, GUIShader, GUISpace, GUISprite, GUITexture, GaussianSplatParser, GenerayRandomDir, GeoJsonParser, GeoJsonUtil, GeoType, GeometryBase, GeometryIndicesBuffer, GeometryUtil, GeometryVertexBuffer, GeometryVertexType, GetComponentClass, GetCountInstanceID, GetRepeat, GetShader, GlassShader, GlobalBindGroup, GlobalBindGroupLayout, GlobalFog, GlobalFog_shader, GlobalIlluminationComponent, GlobalUniform, GlobalUniformGroup, GodRayPost, GodRay_cs, GridObject, HDRTexture, HDRTextureCube, Hair_frag, Hair_shader_op, Hair_shader_tr, HaltonSeq, Horizontal, HoverCameraController, I3DMLoader, I3DMLoaderBase, I3DMParser, IBLEnvMapCreator, IBLEnvMapCreator_cs, IESProfiles, IESProfiles_frag, IKDTreeUserData, ImageType, IndicesGPUBuffer, Inline_vert, InputSystem, InstanceDrawComponent, InstanceUniform, InstancedMesh, Interpolator, InterpolatorEnum, IrradianceDataReaderCompleteEvent, IrradianceVolumeData_frag, Irradiance_frag, IsEditorInspector, IsNonSerialize, Joint, JointPose, JumperInterpolator, KDTreeEntity, KDTreeNode, KDTreeRange, KDTreeSpace, KDTreeUUID, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_clearcoat, KHR_materials_emissive_strength, KHR_materials_ior, KHR_materials_unlit, KMZParser, KV, KelvinUtil, KeyCode, KeyEvent, Keyframe, KeyframeT, LDRTextureCube, LambertMaterial, Lambert_shader, Light, LightBase, LightData, LightEntries, LightType, LightingFunction_frag, Line, LineClassification, LinearInterpolator, LitMaterial, LitSSSShader, LitShader, Lit_shader, LoaderBase, LoaderEvent, LoaderManager, MAX_VALUE, MIN_VALUE, Material, MaterialDataUniformGPUBuffer, MaterialUtilities, MathShader, MathUtil, Matrix3, Matrix4, MatrixBindGroup, MatrixGPUBuffer, MatrixShader, MemoryDO, MemoryInfo, MergeRGBACreator, MergeRGBA_cs, MeshColliderShape, MeshFilter, MeshRenderer, MinMaxAnimationCurves, MinMaxCurve, MinMaxCurveState, MinMaxPolyCurves, MorePassParser, MorePassShader, MorphTargetBlender, MorphTargetData, MorphTargetFrame, MorphTargetTransformKey, MorphTarget_shader, MouseCode, MultiBouncePass_cs, Navi3DAstar, Navi3DConst, Navi3DEdge, Navi3DFunnel, Navi3DMaskType, Navi3DMesh, Navi3DPoint, Navi3DPoint2D, Navi3DPointFat, Navi3DRouter, Navi3DTriangle, NonSerialize, NormalMap_frag, OAnimationEvent, OBJParser, Object3D, Object3DEvent, Object3DTransformTools, Object3DUtil, ObjectAnimClip, OcclusionSystem, Octree, OctreeEntity, OrbitController, OrderMap, Orientation3D, OutLineBlendColor_cs, OutlineCalcOutline_cs, OutlinePass, OutlinePost, OutlinePostData, OutlinePostManager, OutlinePostSlot, Outline_cs, OvershootInterpolator, PBRLItShader, PBRLitSSSShader, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PointClassification, PointLight, PointLightShadowRenderer, PointShadowCubeCamera, PointerEvent3D, Polynomial, PolynomialCurve, Polynomials, PoolNode, PostBase, PostProcessingComponent, PostRenderer, PreDepthPassRenderer, PreFilteredEnvironment_cs, PreFilteredEnvironment_cs2, PreIntegratedLut, PreIntegratedLutCompute, PrefabAvatarData, PrefabAvatarParser, PrefabBoneData, PrefabMaterialParser, PrefabMeshData, PrefabMeshParser, PrefabNode, PrefabParser, PrefabStringUtil, PrefabTextureData, PrefabTextureParser, Preprocessor, Probe, ProbeEntries, ProbeGBufferFrame, ProfilerUtil, PropertyAnimClip, PropertyAnimTag, PropertyAnimation, PropertyAnimationClip, PropertyAnimationClipState, PropertyAnimationEvent, PropertyHelp, QuadAABB, QuadGlsl_fs, QuadGlsl_vs, QuadRoot, QuadShader, QuadTree, QuadTreeCell, Quad_depth2dArray_frag_wgsl, Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, Quaternion, R32UintTexture, RADIANS_TO_DEGREES, RGBEErrorCode, RGBEHeader, RGBEParser, RTDescriptor, RTFrame, RTResourceConfig, RTResourceMap, Rand, RandomSeed, Ray, RayCastMeshDetail, Reader, Rect, Reference, Reflection, ReflectionCG, ReflectionEntries, ReflectionMaterial, ReflectionRenderer, ReflectionShader, ReflectionShader_shader, RegisterComponent, RegisterShader, RenderContext, RenderLayer, RenderLayerUtil, RenderNode, RenderShaderCollect, RenderShaderCompute, RenderShaderPass, RenderTexture, RendererBase, RendererJob, RendererMap, RendererMask, RendererMaskUtil, RendererPassState, RepeatSE, Res, RotationControlComponents, SHCommon_frag, SN_ArrayConstant, SN_BinaryOperation, SN_Break, SN_CodeBlock, SN_Constant, SN_Continue, SN_Declaration, SN_Discard, SN_DoWhileLoop, SN_Expression, SN_ForLoop, SN_Function, SN_FunctionArgs, SN_FunctionCall, SN_IFBranch, SN_Identifier, SN_IndexOperation, SN_Layout, SN_ParenExpression, SN_Precision, SN_Return, SN_SelectOperation, SN_Struct, SN_TernaryOperation, SN_UnaryOperation, SN_WhileLoop, SSAO_cs, SSGI2_cs, SSGIPost, SSRPost, SSR_BlendColor_cs, SSR_IS_Kernel, SSR_IS_cs, SSR_RayTrace_cs, ScaleControlComponents, Scene3D, Shader, ShaderAttributeInfo, ShaderConverter, ShaderConverterResult, ShaderLib, ShaderPassBase, ShaderReflection, ShaderStage, ShaderState, ShaderUniformInfo, ShaderUtil, ShadingInput, ShadowLightsCollect, ShadowMapPassRenderer, ShadowMapping_frag, Skeleton, SkeletonAnimationClip, SkeletonAnimationClipState, SkeletonAnimationComponent, SkeletonAnimationCompute, SkeletonAnimation_shader, SkeletonBlendComputeArgs, SkeletonPose, SkeletonTransformComputeArgs, SkinnedMeshRenderer, SkinnedMeshRenderer2, SkyGBufferPass, SkyGBuffer_pass, SkyMaterial, SkyRenderer, SkyShader, SolidColorSky, SphereColliderShape, SphereGeometry, SphereReflection, SpotLight, StandShader, StatementNode, StorageGPUBuffer, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, TileSet, TileSetChild, TileSetChildContent, TileSetChildContentMetaData, TileSetRoot, TilesRenderer, Time, TokenType, TorusGeometry, TouchData, TrailGeometry, Transform, TransformAxisEnum, TransformControllerBaseComponent, TransformMode, TransformSpaceMode, TranslationControlComponents, TranslatorContext, TriGeometry, Triangle, UIButton, UIButtonTransition, UIComponentBase, UIEvent, UIImage, UIImageGroup, UIInteractive, UIInteractiveStyle, UIPanel, UIRenderAble, UIShadow, UITextField, UITransform, UUID, UV, Uint32ArrayTexture, Uint8ArrayTexture, UnLit, UnLitMaterial, UnLitMaterialUniform_frag, UnLitShader, UnLitTexArrayMaterial, UnLitTexArrayShader, UnLitTextureArray, UnLit_frag, UniformGPUBuffer, UniformNode, UniformType, ValueEnumType, ValueOp, ValueParser, ValueSpread, Vector2, Vector3, Vector3Ex, Vector4, VertexAttribute, VertexAttributeIndexShader, VertexAttributeName, VertexAttributeSize, VertexAttributeStride, VertexAttributes_vert, VertexBufferLayout, VertexFormat, VertexGPUBuffer, Vertical, VideoUniform_frag, View3D, ViewPanel, ViewQuad, VirtualTexture, WGSLTranslator, WayLines3D, WayPoint3D, WebGPUDescriptorCreator, WorldMatrixUniform, WorldPanel, WrapMode, WrapTimeMode, ZCullingCompute, ZPassShader_cs, ZPassShader_fs, ZPassShader_vs, ZSorterUtil, append, arrayToString, blendComponent, buildCurves, byteSizeOfType, calculateCurveRangesValue, calculateMinMax, castPointShadowMap_vert, clamp, clampRepeat, computeAABBFromPositions, cos, crossProduct, cubicPolynomialRoot, cubicPolynomialRootsGeneric, curvesSupportProcedural, deg2Rad, detectGSplatFormat, directionShadowCastMap_frag, dot, doubleIntegrateSegment, downSample, fastInvSqrt, floorfToIntPos, fonts, generateRandom, generateRandom3, getFloatFromInt, getGLTypeFromTypedArray, getGLTypeFromTypedArrayType, getGlobalRandomSeed, getTypedArray, getTypedArrayTypeFromGLType, grad1, grad2, grad3, grad4, inferSHOrder, integrateSegment, irradianceDataReader, kPI, lerp, lerpByte, lerpColor, lerpVector3, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, perm, post, quadraticPolynomialRootsGeneric, rad2Deg, random01, randomBarycentricCoord, randomPointBetweenEllipsoid, randomPointBetweenSphere, randomPointInsideCube, randomPointInsideEllipsoid, randomPointInsideUnitCircle, randomPointInsideUnitSphere, randomQuaternion, randomQuaternionUniformDistribution, randomSeed, randomUnitVector, randomUnitVector2, rangedRandomFloat, rangedRandomInt, readByType, readMagicBytes, registerMaterial, repeat, rotMatrix, rotateVectorByQuat, roundfToIntPos, scale, shadowCastMap_frag, shadowCastMap_vert, simplex, sin, snoise1, snoise2, snoise3, snoise4, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, toHalfFloat, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };