@rings-webgpu/core 1.0.10 → 1.0.12

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
@@ -5804,202 +5835,219 @@ let IESProfiles_frag = `
     } 
 `;
 
-let ShadowMapping_frag = `
-    @group(1) @binding(auto) var shadowMapSampler: sampler;
+let ShadowMapping_frag = (
+  /*wgsl*/
+  `
+    @group(1) @binding(auto) var shadowMapSampler: sampler_comparison;
     @group(1) @binding(auto) var shadowMap: texture_depth_2d_array;
-    @group(1) @binding(auto) var pointShadowMapSampler: sampler;
+    @group(1) @binding(auto) var pointShadowMapSampler: sampler_comparison;
     @group(1) @binding(auto) var pointShadowMap: texture_depth_cube_array;
 
     var<private> directShadowVisibility: array<f32, 8>;
     var<private> pointShadows: array<f32, 8>;
-    var<private> shadowWeight: f32 = 1.0;
+    var<private> shadowWeight: f32 = 1.0 ;
 
     fn useShadow(){
-        directShadowVisibility = array<f32, 8>(1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0);
+        directShadowVisibility = array<f32, 8>( 1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0) ;
         pointShadows = array<f32, 8>(1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0) ;
         directShadowMaping(globalUniform.shadowBias);
         pointShadowMapCompare(globalUniform.pointShadowBias);
     }
 
     fn calcBasicBias(shadowWorldSize:f32, shadowDepthTexSize:f32, near:f32, far:f32) -> f32{
-        var bias = shadowWorldSize / shadowDepthTexSize;
-        bias = bias / (far - near);
-        return bias * 2.0;
+      var bias = shadowWorldSize / shadowDepthTexSize;
+      bias = bias / (far - near);
+      return bias * 2.0;
     }
 
-    const dirCount:i32 = 8;
-    const pointCount:i32 = 8;
-    const csmCount:i32 = ${CSM.Cascades};
+    const dirCount:i32 = 8 ;
+    const pointCount:i32 = 8 ;
+    const csmCount:i32 = ${CSM.Cascades} ;
     var<private> csmLevel:i32 = -1;
+    fn directShadowMaping(shadowBias: f32)  {
 
-    fn directShadowMaping(shadowBias: f32) {
         let enableCSM:bool = globalUniform.enableCSM > 0.5;
-        for(var i:i32 = 0; i < dirCount; i = i+1){
-            if(i >= globalUniform.nDirShadowStart && i < globalUniform.nDirShadowEnd){
-                let ldx = globalUniform.shadowLights[u32(i) / 4u][u32(i) % 4u];
-                let light = lightBuffer[u32(ldx)] ;
-                var shadowIndex = i32(light.castShadow);
-                var visibility = 1.0;
-                var shadowMatrix:mat4x4<f32>;
-                #if USE_CSM
-                    if(enableCSM && shadowIndex == 0){
-                        var totalWeight = 0.0;
-                        visibility = 0.0;
-                        var validCount = 0;
-                        for(var csm:i32 = 0; csm < csmCount; csm ++){
-                            var csmShadowBias = globalUniform.csmShadowBias[csm] * shadowBias;
-                            shadowMatrix = globalUniform.csmMatrix[csm];
-                            let csmShadowResult = directShadowMapingIndex(light, shadowMatrix, csm, csmShadowBias);
-                            if(csmShadowResult.y < 0.5){
-                                validCount ++;
-                                var uv = 2.0 * csmShadowResult.zw - vec2<f32>(1.0);
-                                uv = saturate(vec2<f32>(1.0) - abs(uv));
-                                uv /= clamp(globalUniform.csmMargin, 0.01, 0.5);
-                                var weight:f32 = min(uv.x, 1.0);
-                                weight = min(weight, uv.y);
-
-                                if(validCount == 1 && csm == csmCount - 1){
-                                    visibility = 1.0 - weight + csmShadowResult.x * weight;
-                                    totalWeight = 1.0;
-                                }else{
-                                    weight *= 1.0 - totalWeight;
-                                    visibility += csmShadowResult.x * weight;
-                                    totalWeight += weight;
-                                };
-
-                                if(validCount >= 2 || totalWeight >= 0.99){
-                                    csmLevel = csm;
-                                    break;
-                                };
-                            }
-                        }
-
-                        totalWeight += 0.0001;
-                        if(validCount == 0){
-                            visibility = 1.0;
-                        }else{
-                            visibility = visibility / totalWeight ;
-                        };
-                    } else {
-                        shadowMatrix = globalUniform.shadowMatrix[shadowIndex];
-                        if(enableCSM) {
-                            shadowIndex += csmCount - 1;
-                        }
-                            visibility = directShadowMapingIndex(light, shadowMatrix, shadowIndex, shadowBias).x;
+        for (var i: i32 = 0; i < dirCount ; i = i + 1) {
+          if( i >= globalUniform.nDirShadowStart && i < globalUniform.nDirShadowEnd ){
+            let ldx = globalUniform.shadowLights[u32(i) / 4u][u32(i) % 4u];
+            let light = lightBuffer[u32(ldx)] ;
+            var shadowIndex = i32(light.castShadow);
+            var visibility = 1.0;
+            var shadowMatrix:mat4x4<f32>;
+            #if USE_CSM
+              if(enableCSM && shadowIndex == 0){
+                var totalWeight = 0.0;
+                visibility = 0.0;
+                var validCount = 0;
+                for(var csm:i32 = 0; csm < csmCount; csm ++){
+                  var csmShadowBias = globalUniform.csmShadowBias[csm] * shadowBias;
+                  shadowMatrix = globalUniform.csmMatrix[csm];
+                  let csmShadowResult = directShadowMapingIndex(light, shadowMatrix, csm, csmShadowBias);
+                  if(csmShadowResult.y < 0.5){
+                    validCount ++;
+
+                    var uv = 2.0 * csmShadowResult.zw - vec2<f32>(1.0);
+                    uv = saturate(vec2<f32>(1.0) - abs(uv));
+                    uv /= clamp(globalUniform.csmMargin, 0.01, 0.5);
+                    var weight:f32 = min(uv.x, 1.0);
+                    weight = min(weight, uv.y);
+
+                    if(validCount == 1 && csm == csmCount - 1){
+                      visibility = 1.0 - weight + csmShadowResult.x * weight;
+                      totalWeight = 1.0;
+                    }else{
+                      weight *= 1.0 - totalWeight;
+                      visibility += csmShadowResult.x * weight;
+                      totalWeight += weight;
                     }
-                #else
-                    shadowMatrix = globalUniform.shadowMatrix[shadowIndex];
-                    visibility = directShadowMapingIndex(light, shadowMatrix, shadowIndex, shadowBias).x;
-                #endif
-                    directShadowVisibility[i] = visibility;
-            }
+                    // if(weight < 1.0){
+                    //   visibility += 0.1;
+                    // }
+                    if(validCount >= 2 || totalWeight >= 0.99){
+                      csmLevel = csm;
+                      break;
+                    }
+                  }
+                }
+                totalWeight += 0.0001;
+                if(validCount == 0){
+                  visibility = 1.0;
+                }else{
+                  visibility = visibility / totalWeight ;
+                }
+              }else{
+                shadowMatrix = globalUniform.shadowMatrix[shadowIndex];
+                if(enableCSM) {
+                  shadowIndex += csmCount - 1;
+                }
+                visibility = directShadowMapingIndex(light, shadowMatrix, shadowIndex, shadowBias).x;
+              }
+            #else
+              shadowMatrix = globalUniform.shadowMatrix[shadowIndex];
+              visibility = directShadowMapingIndex(light, shadowMatrix, shadowIndex, shadowBias).x;
+            #endif 
+            directShadowVisibility[i] = visibility;
+          }
         }
+
     }
 
-    fn directShadowMapingIndex(light:LightData, matrix:mat4x4<f32>, depthTexIndex:i32, shadowBias:f32) -> vec4<f32> {
-        var visibility = 1.0;
-        var isOutSideArea:f32 = 1.0;
-        var varying_shadowUV:vec2<f32> = vec2<f32>(0.0);
-        #if USE_SHADOWMAPING
-            var shadowPosTmp = matrix * vec4<f32>(ORI_VertexVarying.vWorldPos.xyz, 1.0);
-            var shadowPos = shadowPosTmp.xyz / shadowPosTmp.w;
-            varying_shadowUV = shadowPos.xy * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5, 0.5);
-            if (varying_shadowUV.x <= 1.0
-            && varying_shadowUV.x >= 0.0
-            && varying_shadowUV.y <= 1.0
-            && varying_shadowUV.y >= 0.0
-            && shadowPosTmp.z <= 1.0
-            && shadowPosTmp.z >= 0.0){
-                visibility = 0.0;
-                isOutSideArea = 0.0;
-                var uvOnePixel = 1.0 / vec2<f32>(globalUniform.shadowMapSize) ;
-                var totalWeight = 0.0;
-                var bias = -0.005 * max(dot(fragData.N, -light.direction) , 0.0 ); 
-                bias = clamp(bias, 0, 0.01) + -shadowBias;
-                let bound = 1;
-                for (var y = -bound; y <= bound; y++) {
-                    for(var x = -bound; x <= bound; x++) {
-                        var offset = vec2<f32>(f32(x), f32(y)) ;
-                        var offsetUV = offset * uvOnePixel ;
-                        var weight = min(length(offset),1.0) ;
-                        var depth = textureSampleLevel(shadowMap, shadowMapSampler, varying_shadowUV + offsetUV , depthTexIndex, 0);
-                        if ((shadowPos.z - bias ) < depth) {
-                            visibility += weight ;
-                            totalWeight += weight;
-                        }else{
-                            totalWeight += 1.0;
-                        };
-                    }
+    fn directShadowMapingIndex(light:LightData, matrix:mat4x4<f32>, depthTexIndex:i32, shadowBias:f32) -> vec4<f32>
+    {
+      var visibility = 1.0;
+      var isOutSideArea:f32 = 1.0;
+      var varying_shadowUV:vec2<f32> = vec2<f32>(0.0);
+      #if USE_SHADOWMAPING
+        var shadowPosTmp = matrix * vec4<f32>(ORI_VertexVarying.vWorldPos.xyz, 1.0);
+        var shadowPos = shadowPosTmp.xyz / shadowPosTmp.w;
+        varying_shadowUV = shadowPos.xy * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5, 0.5);
+        if (varying_shadowUV.x <= 1.0
+          && varying_shadowUV.x >= 0.0
+          && varying_shadowUV.y <= 1.0
+          && varying_shadowUV.y >= 0.0
+          && shadowPosTmp.z <= 1.0
+          && shadowPosTmp.z >= 0.0)
+        {
+          visibility = 0.0;
+          isOutSideArea = 0.0;
+          var uvOnePixel = 1.0 / vec2<f32>(globalUniform.shadowMapSize) ;
+          var totalWeight = 0.0;
+          // var NoL = (dot(normalize(ORI_VertexVarying.vWorldNormal), normalize(-light.direction)));
+          // let v = max(NoL, 0.0) ;
+          // var bias = max(0.05 * (dot(normalize(fragData.N), normalize(-light.direction)) ), -shadowBias); 
+          var bias = -0.005 * max(dot(fragData.N, -light.direction) , 0.0 ); 
+          bias = clamp(bias, 0, 0.01) + -shadowBias;
+
+          // var bias = shadowBias / v;
+          let bound = 1 ;
+          for (var y = -bound; y <= bound; y++) {
+            for (var x = -bound; x <= bound; x++) {
+                var offset = vec2<f32>(f32(x), f32(y)) ;
+                var offsetUV = offset * uvOnePixel ;
+                var weight = min(length(offset),1.0) ;
+                var depth = textureSampleCompareLevel(shadowMap, shadowMapSampler, varying_shadowUV + offsetUV , depthTexIndex, shadowPos.z - bias);
+                if (depth < 0.5) {
+                  totalWeight += 1.0;
+                }else{
+                  visibility += weight;
+                  totalWeight += weight;
                 }
-                visibility /= totalWeight;
             }
-            #endif
-            return vec4<f32>(visibility, isOutSideArea, varying_shadowUV);
-    }
-
-    fn pointShadowMapCompare(shadowBias: f32) {
-        let worldPos = ORI_VertexVarying.vWorldPos.xyz;
-        let offset = 0.1;
-        for(var i: i32 = 0; i < pointCount ; i = i + 1){
-            if( i >= globalUniform.nPointShadowStart && i < globalUniform.nPointShadowEnd ){
-                let ldx = globalUniform.shadowLights[u32(i) / 4u][u32(i) % 4u];
-                let light = lightBuffer[u32(ldx)];
-
-                #if USE_SHADOWMAPING
-                    let lightPos = light.position.xyz;
-                    var shadow = 0.0;
-                    let frgToLight = worldPos - lightPos.xyz;
-                    var dir: vec3<f32> = normalize(frgToLight);
-                    var len = length(frgToLight);
-                    var bias = max(shadowBias * globalUniform.far * (1.0 - dot(ORI_ShadingInput.Normal, dir)), 0.005);
-
-                #if USE_PCF_SHADOW
-                    let samples = 4.0;
-                    let sampleOffset = offset / (samples * 0.5);
-                    for (var x: f32 = -offset; x < offset; x += sampleOffset) {
-                        for (var y: f32 = -offset; y < offset; y += sampleOffset) {
-                            for (var z: f32 = -offset; z < offset; z += sampleOffset) {
-                                let offsetDir = normalize(dir.xyz + vec3<f32>(x, y, z));
-                                var depth = textureSampleLevel(pointShadowMap, pointShadowMapSampler, offsetDir, light.castShadow, 0);
-                                depth *= globalUniform.far;
-                                if ((len - bias) > depth) {
-                                    shadow += 1.0 * dot(offsetDir, dir.xyz);
-                                }
-                            }
-                        }
-                    }
-                    shadow = min(max(shadow / (samples * samples * samples), 0.0), 1.0);
-                #endif
+          }
+          visibility /= totalWeight;
+      }
+      #endif
+      return vec4<f32>(visibility, isOutSideArea, varying_shadowUV);
+    }
+
+    fn pointShadowMapCompare(shadowBias: f32){
+      let worldPos = ORI_VertexVarying.vWorldPos.xyz;
+      let offset = 0.1;
 
-            #if USE_SOFT_SHADOW
-                let vDis = length(globalUniform.CameraPos.xyz - worldPos.xyz);
-                let sampleRadies = globalUniform.shadowSoft;
-                let samples = 20;
-                for (var j:i32 = 0; j < samples; j += 1) {
-                    let offsetDir = normalize(dir.xyz + sampleOffsetDir[j] * sampleRadies);
-                    var depth = textureSampleLevel(pointShadowMap, pointShadowMapSampler, offsetDir, light.castShadow, 0);
-                    depth *= globalUniform.far;
-                    if ((len - bias) > depth) {
-                        shadow += 1.0 * dot(offsetDir, dir.xyz);
+      for (var i: i32 = 0; i < pointCount ; i = i + 1) {
+        if( i >= globalUniform.nPointShadowStart && i < globalUniform.nPointShadowEnd ){
+          let ldx = globalUniform.shadowLights[u32(i) / 4u][u32(i) % 4u];
+          let light = lightBuffer[u32(ldx)] ;
+
+          #if USE_SHADOWMAPING
+              let lightPos = light.position.xyz;
+              var shadow = 0.0;
+              let frgToLight = worldPos - lightPos.xyz;
+              var dir: vec3<f32> = normalize(frgToLight);
+              var len = length(frgToLight);
+              var bias = max(shadowBias * globalUniform.far * (1.0 - dot(ORI_ShadingInput.Normal, dir)), 0.005);
+  
+          #if USE_PCF_SHADOW
+              let samples = 4.0;
+              let sampleOffset = offset / (samples * 0.5);
+              for (var x: f32 = -offset; x < offset; x += sampleOffset) {
+                for (var y: f32 = -offset; y < offset; y += sampleOffset) {
+                  for (var z: f32 = -offset; z < offset; z += sampleOffset) {
+                    let compareZ = (len - bias) / globalUniform.far;
+                    var depth = textureSampleCompareLevel(pointShadowMap, pointShadowMapSampler, dir.xyz, light.castShadow, compareZ);
+                    if (depth < 0.5) {
+                      shadow = 1.0;
+                    }
+                    for (var j = 0; j < pointCount ; j+=1 ){
+                        if(i32(light.castShadow) == j){
+                            pointShadows[j] = 1.0 - shadow;
+                        }
                     }
+                  }
                 }
-                shadow = min(max(shadow / f32(samples), 0.0), 1.0);
+              }
+              shadow = min(max(shadow / (samples * samples * samples), 0.0), 1.0);
             #endif
-
-            #if USE_HARD_SHADOW
-                var depth = textureSampleLevel(pointShadowMap, pointShadowMapSampler, dir.xyz, light.castShadow, 0);
+  
+          #if USE_SOFT_SHADOW
+              let vDis = length(globalUniform.CameraPos.xyz - worldPos.xyz);
+              let sampleRadies = globalUniform.shadowSoft;
+              let samples = 20;
+              for (var j: i32 = 0; j < samples; j += 1) {
+                let offsetDir = normalize(dir.xyz + sampleOffsetDir[j] * sampleRadies);
+                var depth = textureSampleCompareLevel(pointShadowMap, pointShadowMapSampler, offsetDir, light.castShadow, 0);
                 depth *= globalUniform.far;
                 if ((len - bias) > depth) {
-                    shadow = 1.0;
-                }
-            #endif
-                for (var j=0; j < pointCount; j+=1) {
-                    if(i32(light.castShadow) == j){
-                        pointShadows[j] = 1.0 - shadow;
-                    }
+                  shadow += 1.0 * dot(offsetDir, dir.xyz);
                 }
-            #endif
-            }
+              }
+              shadow = min(max(shadow / f32(samples), 0.0), 1.0);
+          #endif
+  
+          #if USE_HARD_SHADOW
+              var depth = textureSampleCompareLevel(pointShadowMap, pointShadowMapSampler, dir.xyz, light.castShadow, 0);
+              depth *= globalUniform.far;
+              if ((len - bias) > depth) {
+                shadow = 1.0;
+              }
+          #endif
+              for (var j = 0; j < pointCount ; j+=1 ) {
+                  if(i32(light.castShadow) == j){
+                    pointShadows[j] = 1.0 - shadow ;
+                  }
+              }
+          #endif
+        }
         }
     }
 
@@ -6012,7 +6060,8 @@ let ShadowMapping_frag = `
         vec3<f32>(0.0, 1.0, 1.0), vec3<f32>(0.0, -1.0, 1.0), vec3<f32>(0.0, -1.0, -1.0), vec3<f32>(0.0, 1.0, -1.0),
       );
     #endif
-`;
+`
+);
 
 let Irradiance_frag = `
     #include "IrradianceVolumeData_frag"
@@ -9507,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);
@@ -9576,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()]) {
@@ -21662,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;
@@ -22249,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;
@@ -22947,11 +22973,222 @@ const GSplat_FS = (
 `
 );
 
-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");
@@ -22961,9 +23198,29 @@ class GSplatMaterial extends Material {
     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 {
+  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();
@@ -23972,9 +24229,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;
@@ -24727,7 +24984,7 @@ let GSplatRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-GSplatRenderer = __decorateClass$h([
+GSplatRenderer = __decorateClass$j([
   RegisterComponent(GSplatRenderer, "GSplatRenderer")
 ], GSplatRenderer);
 
@@ -25038,9 +25295,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;
@@ -25305,7 +25562,7 @@ let Object3D = class extends Entity {
     super.destroy(force);
   }
 };
-Object3D = __decorateClass$g([
+Object3D = __decorateClass$i([
   DecorateObject3D
 ], Object3D);
 function DecorateObject3D(ctor, _) {
@@ -26634,9 +26891,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;
@@ -26745,13 +27002,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);
 
@@ -27248,9 +27505,9 @@ 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;
+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;
@@ -27274,7 +27531,7 @@ let QuadShader = class extends Shader {
     this.setUniformFloat(`height`, 100);
   }
 };
-QuadShader = __decorateClass$e([
+QuadShader = __decorateClass$g([
   RegisterShader(QuadShader, "QuadShader")
 ], QuadShader);
 
@@ -34548,9 +34805,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;
@@ -34592,13 +34849,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;
@@ -34656,13 +34913,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;
@@ -34727,7 +34984,7 @@ let SpotLight = class extends LightBase {
   debugDraw(show) {
   }
 };
-SpotLight = __decorateClass$b([
+SpotLight = __decorateClass$d([
   RegisterComponent(SpotLight, "SpotLight")
 ], SpotLight);
 
@@ -40527,7 +40784,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.10";
+const version = "1.0.12";
 
 class Engine3D {
   /**
@@ -45040,9 +45297,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;
@@ -45066,7 +45323,7 @@ let SkyShader = class extends Shader {
     shaderState.depthCompare = GPUCompareFunction.less;
   }
 };
-SkyShader = __decorateClass$a([
+SkyShader = __decorateClass$c([
   RegisterShader(SkyShader, "SkyShader")
 ], SkyShader);
 
@@ -45864,9 +46121,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;
@@ -46070,7 +46327,7 @@ let SkeletonAnimationComponent = class extends ComponentBase {
     this._currentClipState.weight = 1;
   }
 };
-SkeletonAnimationComponent = __decorateClass$9([
+SkeletonAnimationComponent = __decorateClass$b([
   RegisterComponent(SkeletonAnimationComponent, "SkeletonAnimationComponent")
 ], SkeletonAnimationComponent);
 class SkeletonAnimationCrossFadeState {
@@ -46106,9 +46363,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;
@@ -46519,7 +46776,7 @@ let AnimatorComponent = class extends ComponentBase {
     return dst;
   }
 };
-AnimatorComponent = __decorateClass$8([
+AnimatorComponent = __decorateClass$a([
   RegisterComponent(AnimatorComponent, "AnimatorComponent")
 ], AnimatorComponent);
 class PropertyAnimationClipState {
@@ -47276,9 +47533,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;
@@ -47427,7 +47684,7 @@ let SkinnedMeshRenderer2 = class extends MeshRenderer {
     super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
   }
 };
-SkinnedMeshRenderer2 = __decorateClass$7([
+SkinnedMeshRenderer2 = __decorateClass$9([
   RegisterComponent(SkinnedMeshRenderer2, "SkinnedMeshRenderer2")
 ], SkinnedMeshRenderer2);
 
@@ -52560,9 +52817,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;
@@ -52639,10 +52896,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;
@@ -52941,9 +53274,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;
@@ -52969,13 +53302,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;
@@ -53101,7 +53434,7 @@ let SkinnedMeshRenderer = class extends MeshRenderer {
     super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
   }
 };
-SkinnedMeshRenderer = __decorateClass$4([
+SkinnedMeshRenderer = __decorateClass$5([
   RegisterComponent(SkinnedMeshRenderer, "SkinnedMeshRenderer")
 ], SkinnedMeshRenderer);
 
@@ -53933,6 +54266,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;
@@ -59203,9 +59760,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;
@@ -59324,13 +59881,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;
@@ -59426,7 +59983,7 @@ let LitShader = class extends Shader {
     }
   }
 };
-LitShader = __decorateClass$2([
+LitShader = __decorateClass$3([
   RegisterShader(LitShader, "LitShader")
 ], LitShader);
 
@@ -59585,6 +60142,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;
@@ -59921,6 +60519,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
@@ -65700,4 +66370,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, 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, 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 };