@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/rings.umd.max.js

@@ -2095,11 +2095,7 @@
     if (!dic) {
       dic = window["__Component__"] = {};
     }
-    if (key) {
-      dic[key] = cls;
-    } else {
-      dic[cls.name] = cls;
-    }
+    dic[key] = cls;
   }
   function GetComponentClass(name) {
     let coms = window["__Component__"];
@@ -2113,11 +2109,7 @@
     if (!dic) {
       dic = window["__shader__"] = {};
     }
-    if (key) {
-      dic[key] = cls;
-    } else {
-      dic[cls.name] = cls;
-    }
+    dic[key] = cls;
   }
   function GetShader(name) {
     let coms = window["__shader__"];
@@ -2128,7 +2120,7 @@
   }
 
   var __defProp$2 = Object.defineProperty;
-  var __decorateClass$i = (decorators, target, key, kind) => {
+  var __decorateClass$j = (decorators, target, key, kind) => {
     var result = void 0 ;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
@@ -2139,6 +2131,10 @@
   const _Struct = class _Struct {
     __refection;
     __size = 0;
+    /**
+     * get reflection name
+     * @returns
+     */
     getValueType() {
       if (!this.__refection) {
         let self = this;
@@ -2156,6 +2152,11 @@
       }
       return this.__refection;
     }
+    /**
+     * get any type value memory size
+     * @param value any type value
+     * @returns
+     */
     static getValueSize(value) {
       let type = value.constructor.name;
       switch (type) {
@@ -2202,6 +2203,10 @@
       }
       return struct;
     }
+    /**
+     * get any struct memory size
+     * @returns
+     */
     static GetSize(c) {
       let struct = this.Get(c);
       if (struct.__size == 0) {
@@ -2218,10 +2223,10 @@
       return struct.__size;
     }
   };
-  __decorateClass$i([
+  __decorateClass$j([
     NonSerialize
   ], _Struct.prototype, "__refection");
-  __decorateClass$i([
+  __decorateClass$j([
     NonSerialize
   ], _Struct.prototype, "__size");
   let Struct = _Struct;
@@ -11828,6 +11833,21 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       target.transformDir(fromDirection, toDirection);
       return target;
     }
+    /**
+     * Create a matrix from an array of 16 numbers
+     * @param array Array of 16 numbers
+     * @returns Matrix4 result
+     */
+    static fromArray(array) {
+      if (array.length !== 16) {
+        throw new Error("Array must contain exactly 16 elements");
+      }
+      const matrix = new Matrix4();
+      for (let i = 0; i < 16; i++) {
+        matrix.rawData[i] = array[i];
+      }
+      return matrix;
+    }
     /**
      * Generate a matrix (rotate degrees with x,y,z as the center axis)
      * @param x x on the central axis
@@ -16477,9 +16497,9 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
     }
   }
 
-  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$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;
@@ -16744,7 +16764,7 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       super.destroy(force);
     }
   };
-  exports.Object3D = __decorateClass$h([
+  exports.Object3D = __decorateClass$i([
     DecorateObject3D
   ], exports.Object3D);
   function DecorateObject3D(ctor, _) {
@@ -22396,7 +22416,7 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
     }
     /**
      * current instance attached from parent instance
-     * @param ref reference current
+     * @param ref reference current 
      * @param target reference parent
      */
     attached(ref, target) {
@@ -22408,7 +22428,7 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
     }
     /**
      * current instance detached from parent instance
-     * @param ref reference current
+     * @param ref reference current 
      * @param target reference parent
      */
     detached(ref, target) {
@@ -22418,7 +22438,7 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       }
     }
     /**
-     * current instance has reference
+     * current instance has reference 
      */
     hasReference(ref) {
       let refMap = this.reference.get(ref);
@@ -22429,8 +22449,8 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
     }
     /**
      * get current instance reference count
-     * @param ref
-     * @returns
+     * @param ref 
+     * @returns 
      */
     getReferenceCount(ref) {
       let refMap = this.reference.get(ref);
@@ -22440,10 +22460,10 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       return 0;
     }
     /**
-     * get current instance reference from where
-     * @param ref
-     * @returns
-     */
+    * get current instance reference from where
+    * @param ref 
+    * @returns 
+    */
     getReference(ref) {
       let refMap = this.reference.get(ref);
       if (refMap) {
@@ -23522,9 +23542,9 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
   }
 
   var __defProp$1 = Object.defineProperty;
-  var __getOwnPropDesc$g = Object.getOwnPropertyDescriptor;
-  var __decorateClass$g = (decorators, target, key, kind) => {
-    var result = __getOwnPropDesc$g(target, key) ;
+  var __getOwnPropDesc$h = Object.getOwnPropertyDescriptor;
+  var __decorateClass$h = (decorators, target, key, kind) => {
+    var result = __getOwnPropDesc$h(target, key) ;
     for (var i = decorators.length - 1, decorator; i >= 0; i--)
       if (decorator = decorators[i])
         result = (decorator(target, key, result) ) || result;
@@ -24109,20 +24129,20 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       this._combineShaderRefection = void 0;
     }
   }
-  __decorateClass$g([
+  __decorateClass$h([
     EditorInspector
   ], RenderNode.prototype, "materials");
-  __decorateClass$g([
+  __decorateClass$h([
     EditorInspector
   ], RenderNode.prototype, "castShadow");
-  __decorateClass$g([
+  __decorateClass$h([
     EditorInspector
   ], RenderNode.prototype, "castGI");
 
   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$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 = (kind ? decorator(target, key, result) : decorator(result)) || result;
@@ -24231,13 +24251,13 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       super.destroy(force);
     }
   };
-  __decorateClass$f([
+  __decorateClass$g([
     EditorInspector
   ], exports.MeshRenderer.prototype, "geometry", 1);
-  __decorateClass$f([
+  __decorateClass$g([
     EditorInspector
   ], exports.MeshRenderer.prototype, "material", 1);
-  exports.MeshRenderer = __decorateClass$f([
+  exports.MeshRenderer = __decorateClass$g([
     RegisterComponent(exports.MeshRenderer, "MeshRenderer")
   ], exports.MeshRenderer);
 
@@ -25075,8 +25095,7 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       this.indicesGPUBuffer = new IndicesGPUBuffer(indicesData.data);
     }
     upload(data) {
-      const buffer = data.buffer instanceof ArrayBuffer ? data.buffer : new Uint8Array(data.buffer).buffer;
-      this.indicesGPUBuffer.indicesNode.setArrayBuffer(0, buffer);
+      this.indicesGPUBuffer.indicesNode.setArrayBuffer(0, data);
       this.indicesGPUBuffer.apply();
     }
     compute() {
@@ -25089,6 +25108,22 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       this.indicesGPUBuffer.destroy();
       this.indicesGPUBuffer = null;
     }
+    /**
+     * Get indices from geometry data 
+     * Get position attribute from geometry data 
+     * Get normal attribute from geometry data 
+     * Get tangent attribute from geometry data 
+     * Get uv0 attribute from geometry data 
+     * Get uv1 attribute from geometry data 
+     * Get uv2 attribute from geometry data 
+     * 
+     * Change position data to GPUBuffer and apply
+     * Change normal data to GPUBuffer and apply
+     * Change tangent data to GPUBuffer and apply
+     * Change uv0 data to GPUBuffer and apply
+     * Change uv1 data to GPUBuffer and apply
+     * Change uv2 data to GPUBuffer and apply
+     */
   }
 
   class SubGeometry {
@@ -25871,9 +25906,9 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
     }
   }
 
-  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$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;
@@ -25897,8 +25932,8 @@ fn SH9(dir: vec3<f32>, coefficients: array<vec4f, 9>) -> vec4<f32> {
       this.setUniformFloat(`height`, 100);
     }
   };
-  exports.QuadShader = __decorateClass$e([
-    RegisterShader
+  exports.QuadShader = __decorateClass$f([
+    RegisterShader(exports.QuadShader, "QuadShader")
   ], exports.QuadShader);
 
   class ViewQuad extends exports.Object3D {
@@ -31307,6 +31342,7 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
               parser.userData = userData;
               parser.baseUrl = this.baseUrl;
               parser.initUrl = url;
+              parser.loaderFunctions = loaderFunctions;
               await parser.parseBuffer(data);
               if (parser.verification()) {
                 succ(parser);
@@ -33170,9 +33206,9 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
     }
   }
 
-  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$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;
@@ -33214,13 +33250,13 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
     debug() {
     }
   };
-  exports.DirectLight = __decorateClass$d([
+  exports.DirectLight = __decorateClass$e([
     RegisterComponent(exports.DirectLight, "DirectLight")
   ], exports.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$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;
@@ -33278,13 +33314,13 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
     debugDraw(show) {
     }
   };
-  exports.PointLight = __decorateClass$c([
+  exports.PointLight = __decorateClass$d([
     RegisterComponent(exports.PointLight, "PointLight")
   ], exports.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$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;
@@ -33349,7 +33385,7 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
     debugDraw(show) {
     }
   };
-  exports.SpotLight = __decorateClass$b([
+  exports.SpotLight = __decorateClass$c([
     RegisterComponent(exports.SpotLight, "SpotLight")
   ], exports.SpotLight);
 
@@ -37994,6 +38030,826 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
     }
   }
 
+  // DEFLATE is a complex format; to read this code, you should probably check the RFC first:
+  // https://tools.ietf.org/html/rfc1951
+  // You may also wish to take a look at the guide I made about this program:
+  // https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
+  // Some of the following code is similar to that of UZIP.js:
+  // https://github.com/photopea/UZIP.js
+  // However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
+  // Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
+  // is better for memory in most engines (I *think*).
+
+  // aliases for shorter compressed code (most minifers don't do this)
+  var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+  // fixed length extra bits
+  var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
+  // fixed distance extra bits
+  var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
+  // code length index map
+  var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+  // get base, reverse index map from extra bits
+  var freb = function (eb, start) {
+      var b = new u16(31);
+      for (var i = 0; i < 31; ++i) {
+          b[i] = start += 1 << eb[i - 1];
+      }
+      // numbers here are at max 18 bits
+      var r = new i32(b[30]);
+      for (var i = 1; i < 30; ++i) {
+          for (var j = b[i]; j < b[i + 1]; ++j) {
+              r[j] = ((j - b[i]) << 5) | i;
+          }
+      }
+      return { b: b, r: r };
+  };
+  var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
+  // we can ignore the fact that the other numbers are wrong; they never happen anyway
+  fl[28] = 258, revfl[258] = 28;
+  var _b = freb(fdeb, 0), fd = _b.b;
+  // map of value to reverse (assuming 16 bits)
+  var rev = new u16(32768);
+  for (var i = 0; i < 32768; ++i) {
+      // reverse table algorithm from SO
+      var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
+      x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
+      x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
+      rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
+  }
+  // create huffman tree from u8 "map": index -> code length for code index
+  // mb (max bits) must be at most 15
+  // TODO: optimize/split up?
+  var hMap = (function (cd, mb, r) {
+      var s = cd.length;
+      // index
+      var i = 0;
+      // u16 "map": index -> # of codes with bit length = index
+      var l = new u16(mb);
+      // length of cd must be 288 (total # of codes)
+      for (; i < s; ++i) {
+          if (cd[i])
+              ++l[cd[i] - 1];
+      }
+      // u16 "map": index -> minimum code for bit length = index
+      var le = new u16(mb);
+      for (i = 1; i < mb; ++i) {
+          le[i] = (le[i - 1] + l[i - 1]) << 1;
+      }
+      var co;
+      if (r) {
+          // u16 "map": index -> number of actual bits, symbol for code
+          co = new u16(1 << mb);
+          // bits to remove for reverser
+          var rvb = 15 - mb;
+          for (i = 0; i < s; ++i) {
+              // ignore 0 lengths
+              if (cd[i]) {
+                  // num encoding both symbol and bits read
+                  var sv = (i << 4) | cd[i];
+                  // free bits
+                  var r_1 = mb - cd[i];
+                  // start value
+                  var v = le[cd[i] - 1]++ << r_1;
+                  // m is end value
+                  for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                      // every 16 bit value starting with the code yields the same result
+                      co[rev[v] >> rvb] = sv;
+                  }
+              }
+          }
+      }
+      else {
+          co = new u16(s);
+          for (i = 0; i < s; ++i) {
+              if (cd[i]) {
+                  co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
+              }
+          }
+      }
+      return co;
+  });
+  // fixed length tree
+  var flt = new u8(288);
+  for (var i = 0; i < 144; ++i)
+      flt[i] = 8;
+  for (var i = 144; i < 256; ++i)
+      flt[i] = 9;
+  for (var i = 256; i < 280; ++i)
+      flt[i] = 7;
+  for (var i = 280; i < 288; ++i)
+      flt[i] = 8;
+  // fixed distance tree
+  var fdt = new u8(32);
+  for (var i = 0; i < 32; ++i)
+      fdt[i] = 5;
+  // fixed length map
+  var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+  // fixed distance map
+  var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+  // find max of array
+  var max = function (a) {
+      var m = a[0];
+      for (var i = 1; i < a.length; ++i) {
+          if (a[i] > m)
+              m = a[i];
+      }
+      return m;
+  };
+  // read d, starting at bit p and mask with m
+  var bits = function (d, p, m) {
+      var o = (p / 8) | 0;
+      return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;
+  };
+  // read d, starting at bit p continuing for at least 16 bits
+  var bits16 = function (d, p) {
+      var o = (p / 8) | 0;
+      return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));
+  };
+  // get end of byte
+  var shft = function (p) { return ((p + 7) / 8) | 0; };
+  // typed array slice - allows garbage collector to free original reference,
+  // while being more compatible than .slice
+  var slc = function (v, s, e) {
+      if (s == null || s < 0)
+          s = 0;
+      if (e == null || e > v.length)
+          e = v.length;
+      // can't use .constructor in case user-supplied
+      return new u8(v.subarray(s, e));
+  };
+  // error codes
+  var ec = [
+      'unexpected EOF',
+      'invalid block type',
+      'invalid length/literal',
+      'invalid distance',
+      'stream finished',
+      'no stream handler',
+      ,
+      'no callback',
+      'invalid UTF-8 data',
+      'extra field too long',
+      'date not in range 1980-2099',
+      'filename too long',
+      'stream finishing',
+      'invalid zip data'
+      // determined by unknown compression method
+  ];
+  var err = function (ind, msg, nt) {
+      var e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace)
+          Error.captureStackTrace(e, err);
+      if (!nt)
+          throw e;
+      return e;
+  };
+  // expands raw DEFLATE data
+  var inflt = function (dat, st, buf, dict) {
+      // source length       dict length
+      var sl = dat.length, dl = dict ? dict.length : 0;
+      if (!sl || st.f && !st.l)
+          return buf || new u8(0);
+      var noBuf = !buf;
+      // have to estimate size
+      var resize = noBuf || st.i != 2;
+      // no state
+      var noSt = st.i;
+      // Assumes roughly 33% compression ratio average
+      if (noBuf)
+          buf = new u8(sl * 3);
+      // ensure buffer can fit at least l elements
+      var cbuf = function (l) {
+          var bl = buf.length;
+          // need to increase size to fit
+          if (l > bl) {
+              // Double or set to necessary, whichever is greater
+              var nbuf = new u8(Math.max(bl * 2, l));
+              nbuf.set(buf);
+              buf = nbuf;
+          }
+      };
+      //  last chunk         bitpos           bytes
+      var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+      // total bits
+      var tbts = sl * 8;
+      do {
+          if (!lm) {
+              // BFINAL - this is only 1 when last chunk is next
+              final = bits(dat, pos, 1);
+              // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
+              var type = bits(dat, pos + 1, 3);
+              pos += 3;
+              if (!type) {
+                  // go to end of byte boundary
+                  var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                  if (t > sl) {
+                      if (noSt)
+                          err(0);
+                      break;
+                  }
+                  // ensure size
+                  if (resize)
+                      cbuf(bt + l);
+                  // Copy over uncompressed data
+                  buf.set(dat.subarray(s, t), bt);
+                  // Get new bitpos, update byte count
+                  st.b = bt += l, st.p = pos = t * 8, st.f = final;
+                  continue;
+              }
+              else if (type == 1)
+                  lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+              else if (type == 2) {
+                  //  literal                            lengths
+                  var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                  var tl = hLit + bits(dat, pos + 5, 31) + 1;
+                  pos += 14;
+                  // length+distance tree
+                  var ldt = new u8(tl);
+                  // code length tree
+                  var clt = new u8(19);
+                  for (var i = 0; i < hcLen; ++i) {
+                      // use index map to get real code
+                      clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                  }
+                  pos += hcLen * 3;
+                  // code lengths bits
+                  var clb = max(clt), clbmsk = (1 << clb) - 1;
+                  // code lengths map
+                  var clm = hMap(clt, clb, 1);
+                  for (var i = 0; i < tl;) {
+                      var r = clm[bits(dat, pos, clbmsk)];
+                      // bits read
+                      pos += r & 15;
+                      // symbol
+                      var s = r >> 4;
+                      // code length to copy
+                      if (s < 16) {
+                          ldt[i++] = s;
+                      }
+                      else {
+                          //  copy   count
+                          var c = 0, n = 0;
+                          if (s == 16)
+                              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                          else if (s == 17)
+                              n = 3 + bits(dat, pos, 7), pos += 3;
+                          else if (s == 18)
+                              n = 11 + bits(dat, pos, 127), pos += 7;
+                          while (n--)
+                              ldt[i++] = c;
+                      }
+                  }
+                  //    length tree                 distance tree
+                  var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                  // max length bits
+                  lbt = max(lt);
+                  // max dist bits
+                  dbt = max(dt);
+                  lm = hMap(lt, lbt, 1);
+                  dm = hMap(dt, dbt, 1);
+              }
+              else
+                  err(1);
+              if (pos > tbts) {
+                  if (noSt)
+                      err(0);
+                  break;
+              }
+          }
+          // Make sure the buffer can hold this + the largest possible addition
+          // Maximum chunk size (practically, theoretically infinite) is 2^17
+          if (resize)
+              cbuf(bt + 131072);
+          var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+          var lpos = pos;
+          for (;; lpos = pos) {
+              // bits read, code
+              var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+              pos += c & 15;
+              if (pos > tbts) {
+                  if (noSt)
+                      err(0);
+                  break;
+              }
+              if (!c)
+                  err(2);
+              if (sym < 256)
+                  buf[bt++] = sym;
+              else if (sym == 256) {
+                  lpos = pos, lm = null;
+                  break;
+              }
+              else {
+                  var add = sym - 254;
+                  // no extra bits needed if less
+                  if (sym > 264) {
+                      // index
+                      var i = sym - 257, b = fleb[i];
+                      add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                      pos += b;
+                  }
+                  // dist
+                  var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+                  if (!d)
+                      err(3);
+                  pos += d & 15;
+                  var dt = fd[dsym];
+                  if (dsym > 3) {
+                      var b = fdeb[dsym];
+                      dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+                  }
+                  if (pos > tbts) {
+                      if (noSt)
+                          err(0);
+                      break;
+                  }
+                  if (resize)
+                      cbuf(bt + 131072);
+                  var end = bt + add;
+                  if (bt < dt) {
+                      var shift = dl - dt, dend = Math.min(dt, end);
+                      if (shift + bt < 0)
+                          err(3);
+                      for (; bt < dend; ++bt)
+                          buf[bt] = dict[shift + bt];
+                  }
+                  for (; bt < end; ++bt)
+                      buf[bt] = buf[bt - dt];
+              }
+          }
+          st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+          if (lm)
+              final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+      } while (!final);
+      // don't reallocate for streams or user buffers
+      return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+  };
+  // empty
+  var et = /*#__PURE__*/ new u8(0);
+  // read 2 bytes
+  var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };
+  // read 4 bytes
+  var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };
+  var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };
+  /**
+   * Expands DEFLATE data with no wrapper
+   * @param data The data to decompress
+   * @param opts The decompression options
+   * @returns The decompressed version of the data
+   */
+  function inflateSync(data, opts) {
+      return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+  }
+  // text decoder
+  var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
+  // text decoder stream
+  var tds = 0;
+  try {
+      td.decode(et, { stream: true });
+      tds = 1;
+  }
+  catch (e) { }
+  // decode UTF8
+  var dutf8 = function (d) {
+      for (var r = '', i = 0;;) {
+          var c = d[i++];
+          var eb = (c > 127) + (c > 223) + (c > 239);
+          if (i + eb > d.length)
+              return { s: r, r: slc(d, i - 1) };
+          if (!eb)
+              r += String.fromCharCode(c);
+          else if (eb == 3) {
+              c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536,
+                  r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));
+          }
+          else if (eb & 1)
+              r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63));
+          else
+              r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63));
+      }
+  };
+  /**
+   * Converts a Uint8Array to a string
+   * @param dat The data to decode to string
+   * @param latin1 Whether or not to interpret the data as Latin-1. This should
+   *               not need to be true unless encoding to binary string.
+   * @returns The original UTF-8/Latin-1 string
+   */
+  function strFromU8(dat, latin1) {
+      if (latin1) {
+          var r = '';
+          for (var i = 0; i < dat.length; i += 16384)
+              r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+          return r;
+      }
+      else if (td) {
+          return td.decode(dat);
+      }
+      else {
+          var _a = dutf8(dat), s = _a.s, r = _a.r;
+          if (r.length)
+              err(8);
+          return s;
+      }
+  }
+  // skip local zip header
+  var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };
+  // read zip header
+  var zh = function (d, b, z) {
+      var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
+      var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];
+      return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
+  };
+  // read zip64 extra field
+  var z64e = function (d, b) {
+      for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
+          ;
+      return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+  };
+  /**
+   * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
+   * performance with more than one file.
+   * @param data The raw compressed ZIP file
+   * @param opts The ZIP extraction options
+   * @returns The decompressed files
+   */
+  function unzipSync(data, opts) {
+      var files = {};
+      var e = data.length - 22;
+      for (; b4(data, e) != 0x6054B50; --e) {
+          if (!e || data.length - e > 65558)
+              err(13);
+      }
+      var c = b2(data, e + 8);
+      if (!c)
+          return {};
+      var o = b4(data, e + 16);
+      var z = o == 4294967295 || c == 65535;
+      if (z) {
+          var ze = b4(data, e - 12);
+          z = b4(data, ze) == 0x6064B50;
+          if (z) {
+              c = b4(data, ze + 32);
+              o = b4(data, ze + 48);
+          }
+      }
+      for (var i = 0; i < c; ++i) {
+          var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
+          o = no;
+          {
+              if (!c_2)
+                  files[fn] = slc(data, b, b + sc);
+              else if (c_2 == 8)
+                  files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+              else
+                  err(14, 'unknown compression type ' + c_2);
+          }
+      }
+      return files;
+  }
+
+  class UnLitMaterial extends Material {
+    /**
+     * @constructor
+     */
+    constructor() {
+      super();
+      this.shader = new exports.UnLitShader();
+      this.baseMap = Engine3D.res.whiteTexture;
+    }
+    set baseMap(texture) {
+      this.shader.setTexture(`baseMap`, texture);
+    }
+    get baseMap() {
+      return this.shader.getTexture(`baseMap`);
+    }
+    /**
+     * 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 environment texture, usually referring to cubemap
+     */
+    set envMap(texture) {
+    }
+    /**
+     * @internal
+     * set shadow map
+     */
+    set shadowMap(texture) {
+    }
+  }
+
+  class SphereGeometry extends GeometryBase {
+    shape_vertices = [];
+    shape_indices = [];
+    radius;
+    widthSegments;
+    heightSegments;
+    phiStart;
+    phiLength;
+    thetaStart;
+    thetaLength;
+    /**
+     * 球体几何体
+     * @constructor
+     * @param radius 球体半径
+     * @param widthSegments 定义水平分段数
+     * @param heightSegments 定义垂直分段数
+     * @param phiStart 球体赤道线起始点的弧度
+     * @param phiLength 球体赤道线的弧长
+     * @param thetaStart 球体经线起始点的弧度
+     * @param thetaLength 球体经线的弧长
+     */
+    constructor(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength) {
+      super();
+      this.radius = radius;
+      this.widthSegments = widthSegments;
+      this.heightSegments = heightSegments;
+      this.phiStart = phiStart;
+      this.phiLength = phiLength;
+      this.thetaStart = thetaStart;
+      this.thetaLength = thetaLength;
+      this.buildGeometry();
+    }
+    buildGeometry() {
+      var i, j, triIndex = 0;
+      let _segmentsH = this.heightSegments;
+      let _segmentsW = this.widthSegments;
+      let _radius = this.radius;
+      var vertexCount = (_segmentsH + 1) * (_segmentsW + 1);
+      let position_arr = new Float32Array(vertexCount * 3);
+      let normal_arr = new Float32Array(vertexCount * 3);
+      let uv_arr = new Float32Array(vertexCount * 2);
+      let indice_arr = new Uint16Array(_segmentsW * _segmentsH * 2 * 3);
+      let pi = 0;
+      let ni = 0;
+      let ui = 0;
+      for (j = 0; j <= _segmentsH; ++j) {
+        var horAngle = Math.PI * j / _segmentsH;
+        var y = _radius * Math.cos(horAngle);
+        var ringRadius = _radius * Math.sin(horAngle);
+        for (i = 0; i <= _segmentsW; ++i) {
+          var verAngle = 2 * Math.PI * i / _segmentsW;
+          var x = ringRadius * Math.cos(verAngle);
+          var z = ringRadius * Math.sin(verAngle);
+          var normLen = 1 / Math.sqrt(x * x + y * y + z * z);
+          position_arr[pi++] = x;
+          position_arr[pi++] = y;
+          position_arr[pi++] = z;
+          normal_arr[ni++] = x * normLen;
+          normal_arr[ni++] = y * normLen;
+          normal_arr[ni++] = z * normLen;
+          uv_arr[ui++] = i / _segmentsW;
+          uv_arr[ui++] = j / _segmentsH;
+          if (i > 0 && j > 0) {
+            var a = (_segmentsW + 1) * j + i;
+            var b = (_segmentsW + 1) * j + i - 1;
+            var c = (_segmentsW + 1) * (j - 1) + i - 1;
+            var d = (_segmentsW + 1) * (j - 1) + i;
+            if (j == _segmentsH) {
+              indice_arr[triIndex++] = a;
+              indice_arr[triIndex++] = c;
+              indice_arr[triIndex++] = d;
+            } else if (j == 1) {
+              indice_arr[triIndex++] = a;
+              indice_arr[triIndex++] = b;
+              indice_arr[triIndex++] = c;
+            } else {
+              indice_arr[triIndex++] = a;
+              indice_arr[triIndex++] = b;
+              indice_arr[triIndex++] = c;
+              indice_arr[triIndex++] = a;
+              indice_arr[triIndex++] = c;
+              indice_arr[triIndex++] = d;
+            }
+          }
+        }
+      }
+      this.setIndices(indice_arr);
+      this.setAttribute(VertexAttributeName.position, position_arr);
+      this.setAttribute(VertexAttributeName.normal, normal_arr);
+      this.setAttribute(VertexAttributeName.uv, uv_arr);
+      this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
+      this.addSubGeometry({
+        indexStart: 0,
+        indexCount: indice_arr.length,
+        vertexStart: 0,
+        vertexCount: 0,
+        firstStart: 0,
+        index: 0,
+        topology: 0
+      });
+      this.bounds = new BoundingBox(
+        Vector3.ZERO,
+        new Vector3(this.radius * 2, this.radius * 2, this.radius * 2)
+      );
+    }
+  }
+
+  class WayPoint3D extends exports.Object3D {
+    static register3DRepresentation = null;
+    positionIndex = -1;
+    positionValid = false;
+    marker;
+    constructor(placemark) {
+      super();
+      this.parsePlacemark(placemark);
+      this.setup3DRepresentation();
+    }
+    parsePlacemark(placemark) {
+      if (!placemark.slamPositionInfo) {
+        console.warn("WayPoint3D: slamPositionInfo is not found");
+        return;
+      }
+      const slamPosition = placemark.slamPositionInfo.slamPosition.split(",").map(Number);
+      this.localPosition = new Vector3(slamPosition[0], slamPosition[1], slamPosition[2]);
+      this.positionIndex = Number(placemark.slamPositionInfo.slamPositionIndex);
+      this.positionValid = placemark.slamPositionInfo.slamPositionValid === "1";
+    }
+    setup3DRepresentation() {
+      if (this.marker) {
+        this.removeChild(this.marker);
+        this.marker = null;
+      }
+      if (WayPoint3D.register3DRepresentation) {
+        this.marker = WayPoint3D.register3DRepresentation(this);
+        if (this.marker) {
+          this.addChild(this.marker);
+        }
+      } else {
+        this.marker = new exports.Object3D();
+        const markerRenderer = this.marker.addComponent(exports.MeshRenderer);
+        markerRenderer.geometry = new SphereGeometry(0.1, 32, 16);
+        markerRenderer.material = new LitMaterial();
+        markerRenderer.material.baseColor = this.positionValid ? new Color(0, 1, 0, 1) : new Color(1, 0, 0, 1);
+        this.addChild(this.marker);
+        this.marker.name = "WayPoint3DMarker";
+      }
+    }
+  }
+
+  class WayLines3D extends exports.Object3D {
+    static register3DRepresentation = null;
+    line;
+    constructor(wayLineFile) {
+      super();
+      this.parseWayLineFile(wayLineFile);
+      this.setup3DRepresentation();
+    }
+    parseWayLineFile(wayLineFile) {
+      for (const placemark of wayLineFile.Folder.Placemark) {
+        const wayPoint3D = new WayPoint3D(placemark);
+        this.addChild(wayPoint3D);
+      }
+      this.entityChildren = this.entityChildren.sort((a, b) => {
+        return a.positionIndex - b.positionIndex;
+      });
+    }
+    setup3DRepresentation() {
+      if (this.line) {
+        this.removeChild(this.line);
+        this.line = null;
+      }
+      if (WayLines3D.register3DRepresentation) {
+        this.line = WayLines3D.register3DRepresentation(this);
+        if (this.line) {
+          this.addChild(this.line);
+        }
+      } else {
+        this.line = this.createMultiLine(this.entityChildren.map((child) => child.localPosition), new Color(1, 1, 1, 1));
+        this.addChild(this.line);
+        this.line.name = "WayLines3DLine";
+      }
+    }
+    createMultiLine(positions, color) {
+      if (positions.length < 2) {
+        return null;
+      }
+      const lineGeometry = new GeometryBase();
+      const vertices = new Float32Array(positions.length * 3);
+      for (let i = 0; i < positions.length; i++) {
+        vertices[i * 3] = positions[i].x;
+        vertices[i * 3 + 1] = positions[i].y;
+        vertices[i * 3 + 2] = positions[i].z;
+      }
+      const indices = new Uint16Array((positions.length - 1) * 2);
+      for (let i = 0; i < positions.length - 1; i++) {
+        indices[i * 2] = i;
+        indices[i * 2 + 1] = i + 1;
+      }
+      lineGeometry.setIndices(indices);
+      lineGeometry.setAttribute(VertexAttributeName.position, vertices);
+      lineGeometry.addSubGeometry({
+        indexStart: 0,
+        indexCount: indices.length,
+        vertexStart: 0,
+        vertexCount: 0,
+        firstStart: 0,
+        index: 0,
+        topology: 0
+      });
+      const lineObject = new exports.Object3D();
+      const lineRenderer = lineObject.addComponent(exports.MeshRenderer);
+      const material = new UnLitMaterial();
+      material.topology = "line-list";
+      material.baseColor = color;
+      material.blendMode = BlendMode.ADD;
+      material.castReflection = false;
+      lineRenderer.geometry = lineGeometry;
+      lineRenderer.material = material;
+      return lineObject;
+    }
+  }
+
+  class KMZParser extends ParserBase {
+    static format = ParserFormat.BIN;
+    parseBuffer(buffer) {
+      try {
+        const kmzObj = {
+          template: null,
+          waylines: null
+        };
+        const zip = unzipSync(new Uint8Array(buffer));
+        for (const path in zip) {
+          const fileData = zip[path];
+          const domParser = new DOMParser();
+          const xmlDoc = domParser.parseFromString(strFromU8(fileData), "application/xml");
+          const obj = {};
+          this.parseNode(xmlDoc, obj);
+          const objName = path.replace("wpmz/", "").split(".")[0];
+          Object.assign(kmzObj, {
+            [objName]: obj["#document"].kml.Document
+          });
+        }
+        const wayline3D = new WayLines3D(kmzObj.waylines);
+        this.data = wayline3D;
+      } catch (error) {
+        this.parserError(`KMZ parsing failed: ${error}`, -1);
+      }
+    }
+    parseNode(xml, obj) {
+      const arrayLikeName = ["Placemark", "actionGroup", "action"];
+      const attr = xml.nodeName.replace("wpml:", "");
+      if (!xml.childNodes.length) {
+        obj[attr] = void 0;
+      } else {
+        let textValue = null;
+        let hasElementChildren = false;
+        for (let i = 0; i < xml.childNodes.length; ++i) {
+          const childNode = xml.childNodes[i];
+          if (childNode.nodeType == Node.TEXT_NODE) {
+            const text = childNode.nodeValue?.trim();
+            if (text && text.length > 0) {
+              textValue = text;
+            }
+          } else if (childNode.nodeType == Node.ELEMENT_NODE) {
+            hasElementChildren = true;
+          }
+        }
+        if (textValue && !hasElementChildren) {
+          obj[attr] = textValue;
+        } else if (hasElementChildren) {
+          if (arrayLikeName.includes(attr)) {
+            if (obj[attr]?.length) {
+              obj[attr].push({});
+            } else {
+              obj[attr] = [{}];
+            }
+          } else {
+            obj[attr] = {};
+          }
+          for (let i = 0; i < xml.childNodes.length; ++i) {
+            const childNode = xml.childNodes[i];
+            if (childNode.nodeType == Node.ELEMENT_NODE) {
+              this.parseNode(
+                childNode,
+                !Array.isArray(obj[attr]) ? obj[attr] : obj[attr].at(-1)
+              );
+            }
+          }
+        } else {
+          obj[attr] = void 0;
+        }
+      }
+    }
+    verification() {
+      if (this.data) {
+        return true;
+      }
+      throw new Error("verify failed.");
+    }
+  }
+
   class Res {
     _texturePool;
     _materialPool;
@@ -38223,6 +39079,11 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
       let parser = await loader.load(url, AtlasParser, loaderFunctions, url);
       return parser.data;
     }
+    async loadKMZ(url, loaderFunctions) {
+      let loader = new FileLoader();
+      let parser = await loader.load(url, KMZParser, loaderFunctions);
+      return parser.data;
+    }
     normalTexture;
     maskTexture;
     whiteTexture;
@@ -38416,7 +39277,7 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
     }
   }
 
-  const version = "1.0.1";
+  const version = "1.0.4";
 
   class Engine3D {
     /**
@@ -41725,6 +42586,267 @@ fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(global_invoca
 `
   );
 
+  const GSplat_VS = (
+    /* wgsl */
+    `
+    #include "GlobalUniform"
+
+    struct VSOut {
+        @location(auto) vColor : vec4f,
+        @location(auto) vTexCoord : vec2f,
+        @builtin(position) member : vec4f
+    };
+
+    // ===== SPLAT CORE VS (from PlayCanvas shader-generator-gsplat.js) =====
+    
+    // Uniforms (mapped to WebGPU bindings)
+    // matrix_model, matrix_view, matrix_projection -> GlobalUniform + MaterialUniform
+    // viewport -> calculated from globalUniform.windowWidth/Height
+    // tex_params -> materialUniform.tex_params
+    
+    @group(1) @binding(0) var splatColor : texture_2d<f32>;
+    @group(1) @binding(1) var transformA : texture_2d<u32>;
+    @group(1) @binding(2) var transformB : texture_2d<f32>;
+    @group(1) @binding(4) var splatOrder : texture_2d<u32>;
+    
+    struct MaterialUniform {
+        tex_params: vec4f,      // numSplats, textureWidth, validCount, visBoost
+        modelMatrix: mat4x4<f32>,
+    };
+    @group(1) @binding(3) var<uniform> materialUniform : MaterialUniform;
+    
+    // Global variables (like PlayCanvas)
+    var<private> orderId: u32;
+    var<private> splatId: u32;
+    var<private> splatUV: vec2<i32>;
+    var<private> tA: vec4<u32>;
+    
+    // Helper: decode 16-bit half float
+    fn unpackHalf(h: u32) -> f32 {
+        let s = (h >> 15u) & 0x1u;
+        let e = (h >> 10u) & 0x1fu;
+        let m = h & 0x3ffu;
+        let sign = select(1.0, -1.0, s == 1u);
+        if (e == 0u) {
+            if (m == 0u) { return 0.0; }
+            return sign * (f32(m) * exp2(-24.0));
+        } else if (e == 31u) {
+            return sign * 65504.0;
+        } else {
+            return sign * (1.0 + f32(m) / 1024.0) * exp2(f32(i32(e) - 15));
+        }
+    }
+    
+    // === calcSplatUV() - returns bool ===
+    fn calcSplatUV(instance_id: u32) -> bool {
+        let numSplats = u32(materialUniform.tex_params.x);
+        let textureWidth = u32(materialUniform.tex_params.y);
+        
+        // calculate splat index
+        orderId = instance_id;
+        
+        if (orderId >= numSplats) {
+            return false;
+        }
+        
+        let orderUV = vec2<i32>(
+            i32(orderId % textureWidth),
+            i32(orderId / textureWidth)
+        );
+        
+        // calculate splatUV
+        splatId = textureLoad(splatOrder, orderUV, 0).r;
+        splatUV = vec2<i32>(
+            i32(splatId % textureWidth),
+            i32(splatId / textureWidth)
+        );
+        
+        return true;
+    }
+    
+    // === getCenter() - returns vec3 ===
+    fn getCenter() -> vec3f {
+        tA = textureLoad(transformA, splatUV, 0);
+        return vec3f(bitcast<f32>(tA.x), bitcast<f32>(tA.y), bitcast<f32>(tA.z));
+    }
+    
+    // Struct to return covA and covB
+    struct CovarianceData {
+        covA: vec3f,
+        covB: vec3f,
+    };
+    
+    // === getCovariance() - returns struct ===
+    fn getCovariance() -> CovarianceData {
+        let tB = textureLoad(transformB, splatUV, 0);
+        
+        // unpackHalf2x16 equivalent
+        let h1 = tA.w & 0xFFFFu;
+        let h2 = (tA.w >> 16u) & 0xFFFFu;
+        let tCx = unpackHalf(h1);
+        let tCy = unpackHalf(h2);
+        
+        var result: CovarianceData;
+        result.covA = tB.xyz;
+        result.covB = vec3f(tCx, tCy, tB.w);
+        
+        return result;
+    }
+    
+    // === calcV1V2() - returns vec4 ===
+    fn calcV1V2(splat_cam: vec3f, covA: vec3f, covB: vec3f, W: mat3x3f, viewport: vec2f, projMat: mat4x4f) -> vec4f {
+        let Vrk = mat3x3f(
+            vec3f(covA.x, covA.y, covA.z),
+            vec3f(covA.y, covB.x, covB.y),
+            vec3f(covA.z, covB.y, covB.z)
+        );
+        
+        let focal = viewport.x * abs(projMat[0][0]);
+        
+        let J1 = focal / abs(splat_cam.z);
+        let J2 = -J1 / abs(splat_cam.z) * splat_cam.xy;
+        let J = mat3x3f(
+            vec3f(J1, 0.0, J2.x),
+            vec3f(0.0, J1, J2.y),
+            vec3f(0.0, 0.0, 0.0)
+        );
+        
+        let T = W * J;
+        let cov = transpose(T) * Vrk * T;
+        
+        let diagonal1 = cov[0][0] + 0.3;
+        let offDiagonal = cov[0][1];
+        let diagonal2 = cov[1][1] + 0.3;
+        
+        let mid = 0.5 * (diagonal1 + diagonal2);
+        let radius = length(vec2f((diagonal1 - diagonal2) / 2.0, offDiagonal));
+        let lambda1 = mid + radius;
+        let lambda2 = max(mid - radius, 0.1);
+        let diagonalVector = normalize(vec2f(offDiagonal, lambda1 - diagonal1));
+        
+        let v1 = min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector;
+        let v2 = min(sqrt(2.0 * lambda2), 1024.0) * vec2f(diagonalVector.y, -diagonalVector.x);
+        
+        return vec4f(v1, v2);
+    }
+    
+    // ===== SPLAT MAIN VS (from PlayCanvas gsplat-material.js) =====
+    
+    @vertex
+    fn VertMain(
+        @builtin(vertex_index) vid : u32,
+        @builtin(instance_index) iid : u32
+    ) -> VSOut {
+        var o: VSOut;
+        let discardVec = vec4f(0.0, 0.0, 2.0, 1.0);
+        
+        // Vertex position array (PlayCanvas uses attribute vec3 with x,y in [-1,1])
+        let vertex_position = array<vec2f, 4>(
+            vec2f(-2.0, -2.0),
+            vec2f( 2.0, -2.0),
+            vec2f(-2.0,  2.0),
+            vec2f( 2.0,  2.0)
+        );
+        let vertex_pos = vertex_position[vid & 3u];
+        
+        // calculate splat uv
+        if (!calcSplatUV(iid)) {
+            o.member = discardVec;
+            o.vColor = vec4f(0.0);
+            o.vTexCoord = vec2f(0.0);
+            return o;
+        }
+        
+        // get center
+        let center = getCenter();
+        
+        // handle transforms
+        let matrix_view = globalUniform.viewMat;
+        let matrix_projection = globalUniform.projMat;
+        let matrix_model = materialUniform.modelMatrix;
+        
+        let model_view = matrix_view * matrix_model;
+        let splat_cam = model_view * vec4f(center, 1.0);
+        let splat_proj = matrix_projection * splat_cam;
+        
+        // cull behind camera (WebGPU: NDC z in [0,1], cull if z/w < 0)
+        if (splat_proj.z < 0.0) {
+            o.member = discardVec;
+            o.vColor = vec4f(0.0);
+            o.vTexCoord = vec2f(0.0);
+            return o;
+        }
+        
+        // get covariance
+        let cov_data = getCovariance();
+        
+        let viewport = vec2f(globalUniform.windowWidth, globalUniform.windowHeight);
+        let v1v2 = calcV1V2(splat_cam.xyz, cov_data.covA, cov_data.covB, transpose(mat3x3f(model_view[0].xyz, model_view[1].xyz, model_view[2].xyz)), viewport, matrix_projection);
+        
+        // get color
+        let color = textureLoad(splatColor, splatUV, 0);
+        
+        // calculate scale based on alpha
+        let scale = min(1.0, sqrt(-log(1.0 / 255.0 / color.a)) / 2.0);
+        
+        // apply visBoost (size multiplier)
+        let visBoost = materialUniform.tex_params.w;
+        var v1v2_scaled = v1v2 * scale * visBoost;
+        
+        // early out tiny splats
+        if (dot(v1v2_scaled.xy, v1v2_scaled.xy) < 4.0 && dot(v1v2_scaled.zw, v1v2_scaled.zw) < 4.0) {
+            o.member = discardVec;
+            o.vColor = vec4f(0.0);
+            o.vTexCoord = vec2f(0.0);
+            return o;
+        }
+        
+        // gl_Position = splat_proj + vec4((vertex_position.x * v1v2.xy + vertex_position.y * v1v2.zw) / viewport * splat_proj.w, 0, 0);
+        o.member = splat_proj + vec4f((vertex_pos.x * v1v2_scaled.xy + vertex_pos.y * v1v2_scaled.zw) / viewport * splat_proj.w, 0.0, 0.0);
+        
+        // texCoord = vertex_position.xy * scale / 2.0;
+        o.vTexCoord = vertex_pos * scale / 2.0;
+        
+        o.vColor = color;
+        
+        return o;
+    }
+`
+  );
+  const GSplat_FS = (
+    /* wgsl */
+    `
+    #include "FragmentOutput"
+
+    // === evalSplat() - like PlayCanvas splatCoreFS ===
+    fn evalSplat(texCoord: vec2f, color: vec4f) -> vec4f {
+        let A = dot(texCoord, texCoord);
+        if (A > 1.0) {
+            discard;
+        }
+        
+        let B = exp(-A * 4.0) * color.a;
+        if (B < 1.0 / 255.0) {
+            discard;
+        }
+        
+        // TONEMAP_ENABLED branch not implemented (would call toneMap() and gammaCorrectOutput())
+        return vec4f(color.rgb, B);
+    }
+    
+    // === main() - like PlayCanvas splatMainFS ===
+    @fragment
+    fn FragMain(@location(auto) vColor: vec4f, @location(auto) vTexCoord: vec2f) -> FragmentOutput {
+        let result = evalSplat(vTexCoord, vColor);
+        
+        var o: FragmentOutput;
+        o.color = result;
+        o.gBuffer = vec4f(0.0);
+        return o;
+    }
+`
+  );
+
   let GlassShader = (
     /*wgsl */
     `
@@ -42865,14 +43987,16 @@ fn frag(){
     _internalTexture;
     _cubeSize;
     setting;
+    /**
+     * @constructor
+     * @param setting AtmosphericScatteringSkySetting
+     * @returns
+     */
     constructor(setting) {
       super();
       this.setting = setting;
       this._cubeSize = setting.defaultTextureCubeSize;
-      this._internalTexture = new AtmosphericTexture2D(
-        setting.defaultTexture2DSize,
-        setting.defaultTexture2DSize * 0.5
-      );
+      this._internalTexture = new AtmosphericTexture2D(setting.defaultTexture2DSize, setting.defaultTexture2DSize * 0.5);
       this._internalTexture.update(this.setting);
       this.createFromTexture(this._cubeSize, this._internalTexture);
       return this;
@@ -42880,6 +44004,10 @@ fn frag(){
     get texture2D() {
       return this._internalTexture;
     }
+    /**
+     * @internal
+     * @returns
+     */
     apply() {
       this._internalTexture.update(this.setting);
       this._faceData.uploadErpTexture(this._internalTexture);
@@ -42890,13 +44018,7 @@ fn frag(){
     _computeShader;
     _uniformBuffer;
     constructor(width, height) {
-      super(
-        width,
-        height,
-        GPUTextureFormat.rgba16float,
-        false,
-        GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
-      );
+      super(width, height, GPUTextureFormat.rgba16float, false, GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING);
       this.initCompute(width, height);
     }
     initCompute(w, h) {
@@ -42929,9 +44051,9 @@ fn frag(){
     }
   }
 
-  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$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;
@@ -42955,8 +44077,8 @@ fn frag(){
       shaderState.depthCompare = GPUCompareFunction.less;
     }
   };
-  exports.SkyShader = __decorateClass$a([
-    RegisterShader
+  exports.SkyShader = __decorateClass$b([
+    RegisterShader(exports.SkyShader, "SkyShader")
   ], exports.SkyShader);
 
   class SkyMaterial extends Material {
@@ -43000,113 +44122,6 @@ fn frag(){
     }
   }
 
-  class SphereGeometry extends GeometryBase {
-    shape_vertices = [];
-    shape_indices = [];
-    radius;
-    widthSegments;
-    heightSegments;
-    phiStart;
-    phiLength;
-    thetaStart;
-    thetaLength;
-    /**
-     * 球体几何体
-     * @constructor
-     * @param radius 球体半径
-     * @param widthSegments 定义水平分段数
-     * @param heightSegments 定义垂直分段数
-     * @param phiStart 球体赤道线起始点的弧度
-     * @param phiLength 球体赤道线的弧长
-     * @param thetaStart 球体经线起始点的弧度
-     * @param thetaLength 球体经线的弧长
-     */
-    constructor(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength) {
-      super();
-      this.radius = radius;
-      this.widthSegments = widthSegments;
-      this.heightSegments = heightSegments;
-      this.phiStart = phiStart;
-      this.phiLength = phiLength;
-      this.thetaStart = thetaStart;
-      this.thetaLength = thetaLength;
-      this.buildGeometry();
-    }
-    buildGeometry() {
-      var i, j, triIndex = 0;
-      let _segmentsH = this.heightSegments;
-      let _segmentsW = this.widthSegments;
-      let _radius = this.radius;
-      var vertexCount = (_segmentsH + 1) * (_segmentsW + 1);
-      let position_arr = new Float32Array(vertexCount * 3);
-      let normal_arr = new Float32Array(vertexCount * 3);
-      let uv_arr = new Float32Array(vertexCount * 2);
-      let indice_arr = new Uint16Array(_segmentsW * _segmentsH * 2 * 3);
-      let pi = 0;
-      let ni = 0;
-      let ui = 0;
-      for (j = 0; j <= _segmentsH; ++j) {
-        var horAngle = Math.PI * j / _segmentsH;
-        var y = _radius * Math.cos(horAngle);
-        var ringRadius = _radius * Math.sin(horAngle);
-        for (i = 0; i <= _segmentsW; ++i) {
-          var verAngle = 2 * Math.PI * i / _segmentsW;
-          var x = ringRadius * Math.cos(verAngle);
-          var z = ringRadius * Math.sin(verAngle);
-          var normLen = 1 / Math.sqrt(x * x + y * y + z * z);
-          position_arr[pi++] = x;
-          position_arr[pi++] = y;
-          position_arr[pi++] = z;
-          normal_arr[ni++] = x * normLen;
-          normal_arr[ni++] = y * normLen;
-          normal_arr[ni++] = z * normLen;
-          uv_arr[ui++] = i / _segmentsW;
-          uv_arr[ui++] = j / _segmentsH;
-          if (i > 0 && j > 0) {
-            var a = (_segmentsW + 1) * j + i;
-            var b = (_segmentsW + 1) * j + i - 1;
-            var c = (_segmentsW + 1) * (j - 1) + i - 1;
-            var d = (_segmentsW + 1) * (j - 1) + i;
-            if (j == _segmentsH) {
-              indice_arr[triIndex++] = a;
-              indice_arr[triIndex++] = c;
-              indice_arr[triIndex++] = d;
-            } else if (j == 1) {
-              indice_arr[triIndex++] = a;
-              indice_arr[triIndex++] = b;
-              indice_arr[triIndex++] = c;
-            } else {
-              indice_arr[triIndex++] = a;
-              indice_arr[triIndex++] = b;
-              indice_arr[triIndex++] = c;
-              indice_arr[triIndex++] = a;
-              indice_arr[triIndex++] = c;
-              indice_arr[triIndex++] = d;
-            }
-          }
-        }
-      }
-      this.setIndices(indice_arr);
-      this.setAttribute(VertexAttributeName.position, position_arr);
-      this.setAttribute(VertexAttributeName.normal, normal_arr);
-      this.setAttribute(VertexAttributeName.uv, uv_arr);
-      this.setAttribute(VertexAttributeName.TEXCOORD_1, uv_arr);
-      this.addSubGeometry({
-        indexStart: 0,
-        indexCount: indice_arr.length,
-        vertexStart: 0,
-        vertexCount: 0,
-        firstStart: 0,
-        index: 0,
-        topology: 0
-      });
-      this.bounds = new BoundingBox(
-        Vector3.ZERO,
-        new Vector3(this.radius * 2, this.radius * 2, this.radius * 2)
-      );
-    }
-  }
-
   class Reflection extends RenderNode {
     gid = 0;
     needUpdate = true;
@@ -43860,9 +44875,9 @@ fn frag(){
     }
   }
 
-  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$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;
@@ -44066,7 +45081,7 @@ fn frag(){
       this._currentClipState.weight = 1;
     }
   };
-  exports.SkeletonAnimationComponent = __decorateClass$9([
+  exports.SkeletonAnimationComponent = __decorateClass$a([
     RegisterComponent(exports.SkeletonAnimationComponent, "SkeletonAnimationComponent")
   ], exports.SkeletonAnimationComponent);
   class SkeletonAnimationCrossFadeState {
@@ -44102,9 +45117,9 @@ fn frag(){
     }
   }
 
-  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$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;
@@ -44515,7 +45530,7 @@ fn frag(){
       return dst;
     }
   };
-  exports.AnimatorComponent = __decorateClass$8([
+  exports.AnimatorComponent = __decorateClass$9([
     RegisterComponent(exports.AnimatorComponent, "AnimatorComponent")
   ], exports.AnimatorComponent);
   class PropertyAnimationClipState {
@@ -45272,9 +46287,9 @@ fn frag(){
     }
   }
 
-  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$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;
@@ -45423,7 +46438,7 @@ fn frag(){
       super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
     }
   };
-  exports.SkinnedMeshRenderer2 = __decorateClass$7([
+  exports.SkinnedMeshRenderer2 = __decorateClass$8([
     RegisterComponent(exports.SkinnedMeshRenderer2, "SkinnedMeshRenderer2")
   ], exports.SkinnedMeshRenderer2);
 
@@ -50553,9 +51568,9 @@ fn frag(){
     }
   }
 
-  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$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;
@@ -50632,10 +51647,802 @@ fn frag(){
     debugDraw(show) {
     }
   };
-  exports.Light = __decorateClass$6([
+  exports.Light = __decorateClass$7([
     RegisterComponent(exports.Light, "Light")
   ], exports.Light);
 
+  class GSplatMaterial extends Material {
+    constructor() {
+      super();
+      ShaderLib.register("gsplat_vs_dc", GSplat_VS);
+      ShaderLib.register("gsplat_fs_dc", GSplat_FS);
+      const pass = new RenderShaderPass("gsplat_vs_dc", "gsplat_fs_dc");
+      pass.passType = PassType.COLOR;
+      pass.setShaderEntry("VertMain", "FragMain");
+      pass.topology = GPUPrimitiveTopology.triangle_strip;
+      pass.depthWriteEnabled = false;
+      pass.cullMode = "none";
+      pass.shaderState.transparent = true;
+      pass.shaderState.blendMode = BlendMode.NORMAL;
+      pass.shaderState.writeMasks = [15, 15];
+      const shader = new Shader();
+      shader.addRenderPass(pass);
+      this.shader = shader;
+    }
+    setSplatTextures(splatColor, transformA, transformB, texParams, splatOrder) {
+      const pass = this.shader.getDefaultColorShader();
+      pass.setTexture("splatColor", splatColor);
+      pass.setTexture("transformA", transformA);
+      pass.setTexture("transformB", transformB);
+      pass.setUniformArray("tex_params", texParams);
+      if (splatOrder) {
+        pass.setTexture("splatOrder", splatOrder);
+      }
+    }
+    /**
+     * Set the model matrix for transforming splats to world space
+     */
+    setTransformMatrix(matrix) {
+      const pass = this.shader.getDefaultColorShader();
+      pass.setUniform("modelMatrix", matrix.rawData);
+    }
+  }
+
+  class Uint32ArrayTexture extends Texture {
+    _dataBuffer;
+    create(width, height, data) {
+      let device = webGPUContext.device;
+      const bytesPerRow = width * 4 * 4;
+      this.format = GPUTextureFormat.rgba32uint;
+      const mipmapCount = 1;
+      this.createTextureDescriptor(width, height, mipmapCount, this.format);
+      const textureDataBuffer = this._dataBuffer = device.createBuffer({
+        size: data.byteLength,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+      });
+      device.queue.writeBuffer(textureDataBuffer, 0, data.buffer);
+      const encoder = device.createCommandEncoder();
+      encoder.copyBufferToTexture(
+        { buffer: textureDataBuffer, bytesPerRow },
+        { texture: this.getGPUTexture() },
+        { width, height, depthOrArrayLayers: 1 }
+      );
+      device.queue.submit([encoder.finish()]);
+      this.samplerBindingLayout.type = `non-filtering`;
+      this.textureBindingLayout.sampleType = `uint`;
+      this.gpuSampler = device.createSampler({});
+      return this;
+    }
+    updateTexture(width, height, data) {
+      let device = webGPUContext.device;
+      const bytesPerRow = width * 4 * 4;
+      const staging = device.createBuffer({
+        size: data.byteLength,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+      });
+      device.queue.writeBuffer(staging, 0, data.buffer);
+      const encoder = device.createCommandEncoder();
+      encoder.copyBufferToTexture(
+        { buffer: staging, bytesPerRow },
+        { texture: this.getGPUTexture() },
+        { width, height, depthOrArrayLayers: 1 }
+      );
+      device.queue.submit([encoder.finish()]);
+    }
+  }
+
+  class Float16ArrayTexture extends Texture {
+    uint16Array;
+    floatArray;
+    _dataBuffer;
+    /**
+     * 使用数字数组填充纹理，格式为[红0, 绿0, 蓝0, 透明度0, 红1, 绿1, 蓝1, 透明度1...]
+     * @param width 纹理宽度
+     * @param height 纹理高度
+     * @param numbers 每个像素的颜色值数组
+     * @param useMipmap 是否生成Mipmap
+     * @returns 返回纹理实例
+     */
+    create(width, height, numbers = null, mipmap = true) {
+      if (numbers == null) {
+        numbers = [];
+        for (let i = 0, c = width * height * 4; i < c; i++) {
+          numbers[i] = 0;
+        }
+      }
+      this.updateTexture(width, height, numbers, mipmap);
+      return this;
+    }
+    /**
+     * 更新纹理内容
+     * @param width 纹理宽度
+     * @param height 纹理高度
+     * @param numbers 像素数据数组
+     * @param mipmap 是否生成Mipmap
+     */
+    updateTexture(width, height, numbers, mipmap = true) {
+      if (width != this.width || height != this.height) {
+        this._dataBuffer && this._dataBuffer.destroy();
+        this._dataBuffer = null;
+        this.gpuTexture && this.gpuTexture.destroy();
+        this.gpuTexture = null;
+      }
+      this.floatArray = numbers;
+      let device = webGPUContext.device;
+      const bytesPerRow = width * 4 * 2;
+      this.format = GPUTextureFormat.rgba16float;
+      this.mipmapCount = Math.floor(mipmap ? Math.log2(width) : 1);
+      this.createTextureDescriptor(width, height, this.mipmapCount, this.format);
+      if (!this.uint16Array || this.uint16Array.length != numbers.length) {
+        this.uint16Array = new Uint16Array(numbers.length);
+      }
+      let uint16Array = this.uint16Array;
+      for (let i = 0, c = uint16Array.length; i < c; i++) {
+        uint16Array[i] = toHalfFloat(numbers[i]);
+      }
+      const textureDataBuffer = this._dataBuffer = device.createBuffer({
+        size: uint16Array.byteLength,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+      });
+      device.queue.writeBuffer(textureDataBuffer, 0, uint16Array);
+      const commandEncoder = GPUContext.beginCommandEncoder();
+      commandEncoder.copyBufferToTexture(
+        {
+          buffer: textureDataBuffer,
+          bytesPerRow
+        },
+        {
+          texture: this.getGPUTexture()
+        },
+        {
+          width,
+          height,
+          depthOrArrayLayers: 1
+        }
+      );
+      if (!this.useMipmap) {
+        this.samplerBindingLayout.type = `filtering`;
+        this.textureBindingLayout.sampleType = `float`;
+      }
+      GPUContext.endCommandEncoder(commandEncoder);
+      this.gpuSampler = device.createSampler(this);
+      this.gpuTexture = this.getGPUTexture();
+      if (this.mipmapCount > 1) TextureMipmapGenerator.webGPUGenerateMipmap(this);
+    }
+  }
+
+  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;
+    return result;
+  };
+  exports.GSplatRenderer = class GSplatRenderer extends RenderNode {
+    // Splat count and texture dimensions
+    count = 0;
+    size = new Vector2();
+    // GPU textures for splat data
+    splatColor;
+    transformA;
+    transformB;
+    texParams;
+    // [numSplats, texWidth, validCount, visBoost]
+    splatOrder;
+    // Material and geometry
+    gsplatMaterial;
+    // CPU-side data for sorting
+    _positions;
+    // xyz per splat (local space)
+    _worldPositions;
+    // xyz per splat (world space, cached)
+    _orderData;
+    // RGBA32U backing: size.x * size.y * 4
+    // Web Worker for sorting
+    _sortWorker;
+    _lastSentTime = 0;
+    _minIntervalMs = 0;
+    // No throttle for immediate sorting
+    _centersSent = false;
+    _lastViewMatrixHash = 0;
+    // Mapping support (optional subset rendering)
+    _mapping = null;
+    _fullCount = 0;
+    // Original total count
+    constructor() {
+      super();
+    }
+    /**
+     * Initialize from Gaussian Splat asset
+     */
+    initAsset(asset) {
+      this.count = asset.count;
+      this._fullCount = asset.count;
+      this.size = this.evalTextureSize(asset.count);
+      this.buildColor(asset);
+      this.buildTransform(asset);
+      this.texParams = new Float32Array([this.count, this.size.x, this.count, 1]);
+      this._positions = asset.position;
+      const total = this.size.x * this.size.y;
+      this._orderData = new Uint32Array(total * 4);
+      for (let i = 0; i < total; i++) {
+        const src = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
+        const base = i * 4;
+        this._orderData[base + 0] = src;
+        this._orderData[base + 1] = 0;
+        this._orderData[base + 2] = 0;
+        this._orderData[base + 3] = 0;
+      }
+      this.splatOrder = new Uint32ArrayTexture().create(this.size.x, this.size.y, this._orderData);
+      this.splatOrder.name = "splatOrder";
+      this.splatOrder.minFilter = "nearest";
+      this.splatOrder.magFilter = "nearest";
+      this.splatOrder.addressModeU = "clamp-to-edge";
+      this.splatOrder.addressModeV = "clamp-to-edge";
+      this.gsplatMaterial = new GSplatMaterial();
+      this.geometry = new PlaneGeometry(1, 1, 1, 1);
+      this.materials = [this.gsplatMaterial];
+    }
+    /**
+     * Update splat sorting before rendering
+     * This runs every frame to ensure correct depth ordering for alpha blending
+     */
+    onBeforeUpdate(view) {
+      if (this.count > 0 && view?.camera?.viewMatrix) {
+        this.scheduleOrder(view.camera.viewMatrix);
+      }
+    }
+    /**
+     * Set rendering subset mapping
+     * Pass null/undefined to cancel mapping
+     */
+    setMapping(mapping) {
+      this._mapping = mapping && mapping.length > 0 ? mapping : null;
+      this.count = this._mapping ? this._mapping.length : this._fullCount;
+      this.texParams[0] = this.count;
+      this.texParams[2] = Math.min(this.texParams[0], this.count);
+      const total = this.size.x * this.size.y;
+      for (let i = 0; i < total; i++) {
+        const src = i < this.count ? i : this.count > 0 ? this.count - 1 : 0;
+        const base = i * 4;
+        this._orderData[base + 0] = src;
+        this._orderData[base + 1] = 0;
+        this._orderData[base + 2] = 0;
+        this._orderData[base + 3] = 0;
+      }
+      this.splatOrder.updateTexture(this.size.x, this.size.y, this._orderData);
+      if (this._sortWorker) {
+        const worldPos = this._worldPositions || this._positions;
+        const centers = this._mapping ? new Float32Array(this._mapping.length * 3) : new Float32Array(worldPos);
+        if (this._mapping) {
+          for (let i = 0; i < this._mapping.length; ++i) {
+            const src = this._mapping[i] * 3;
+            const dst = i * 3;
+            centers[dst + 0] = worldPos[src + 0];
+            centers[dst + 1] = worldPos[src + 1];
+            centers[dst + 2] = worldPos[src + 2];
+          }
+        }
+        this._sortWorker.postMessage(
+          {
+            type: "centers",
+            centers: centers.buffer,
+            mapping: this._mapping ? this._mapping : null
+          },
+          [centers.buffer]
+        );
+        this._centersSent = true;
+      } else {
+        this._centersSent = false;
+      }
+    }
+    /**
+     * Set visibility boost factor (material uniform tex_params.w)
+     */
+    setVisBoost(v) {
+      this.texParams[3] = Math.max(0, v);
+    }
+    /**
+     * Set sort throttle interval (milliseconds)
+     */
+    setSortThrottle(ms) {
+      this._minIntervalMs = Math.max(0, ms | 0);
+    }
+    /**
+     * Calculate texture size for given splat count
+     */
+    evalTextureSize(count) {
+      let w = Math.ceil(Math.sqrt(count));
+      const align = 64;
+      w = Math.ceil(w / align) * align;
+      const h = Math.ceil(count / w);
+      return new Vector2(w, h);
+    }
+    /**
+     * Build color texture from asset
+     */
+    buildColor(asset) {
+      const w = this.size.x | 0;
+      const h = this.size.y | 0;
+      const data = new Uint8Array(w * h * 4);
+      const SH_C0 = 0.28209479177387814;
+      const count = asset.count;
+      const coeffs = asset.sh?.coeffs;
+      const coeffsPerColor = coeffs ? coeffs.length / (3 * count) : 1;
+      for (let i = 0; i < count; i++) {
+        let r = 0.5, g = 0.5, b = 0.5;
+        if (coeffs && coeffsPerColor >= 1) {
+          const baseIndex = i * coeffsPerColor * 3;
+          r = 0.5 + coeffs[baseIndex + 0] * SH_C0;
+          g = 0.5 + coeffs[baseIndex + coeffsPerColor + 0] * SH_C0;
+          b = 0.5 + coeffs[baseIndex + 2 * coeffsPerColor + 0] * SH_C0;
+        }
+        const a = asset.opacity ? 1 / (1 + Math.exp(-asset.opacity[i])) : 1;
+        const idx = i * 4;
+        data[idx + 0] = Math.max(0, Math.min(255, Math.floor(r * 255)));
+        data[idx + 1] = Math.max(0, Math.min(255, Math.floor(g * 255)));
+        data[idx + 2] = Math.max(0, Math.min(255, Math.floor(b * 255)));
+        data[idx + 3] = Math.max(0, Math.min(255, Math.floor(a * 255)));
+      }
+      this.splatColor = new Uint8ArrayTexture().create(w, h, data, false);
+      this.splatColor.name = "splatColor";
+      this.splatColor.minFilter = "nearest";
+      this.splatColor.magFilter = "nearest";
+      this.splatColor.mipmapFilter = "nearest";
+      this.splatColor.addressModeU = "clamp-to-edge";
+      this.splatColor.addressModeV = "clamp-to-edge";
+    }
+    /**
+     * Build transform textures from asset
+     */
+    buildTransform(asset) {
+      const w = this.size.x | 0;
+      const h = this.size.y | 0;
+      const count = asset.count;
+      const tA = new Uint32Array(w * h * 4);
+      const tB = new Array(w * h * 4).fill(0);
+      const fb = new ArrayBuffer(4);
+      const f32 = new Float32Array(fb);
+      const u32 = new Uint32Array(fb);
+      const setFloatBits = (v) => {
+        f32[0] = v;
+        return u32[0];
+      };
+      const pos = asset.position;
+      const rot = asset.rotation;
+      const scl = asset.scale;
+      let maxScale = 0;
+      let minScale = Infinity;
+      let maxCov = 0;
+      for (let i = 0; i < count; i++) {
+        const idx = i * 4;
+        const x = pos[i * 3 + 0];
+        const y = pos[i * 3 + 1];
+        const z = pos[i * 3 + 2];
+        tA[idx + 0] = setFloatBits(x);
+        tA[idx + 1] = setFloatBits(y);
+        tA[idx + 2] = setFloatBits(z);
+        let qx = 0, qy = 0, qz = 0, qw = 1;
+        if (rot) {
+          qx = rot[i * 4 + 0];
+          qy = rot[i * 4 + 1];
+          qz = rot[i * 4 + 2];
+          qw = rot[i * 4 + 3];
+          const inv = 1 / Math.hypot(qx, qy, qz, qw);
+          qx *= inv;
+          qy *= inv;
+          qz *= inv;
+          qw *= inv;
+        }
+        let sx = 1, sy = 1, sz = 1;
+        if (scl) {
+          sx = Math.exp(scl[i * 3 + 0]);
+          sy = Math.exp(scl[i * 3 + 1]);
+          sz = Math.exp(scl[i * 3 + 2]);
+          maxScale = Math.max(maxScale, sx, sy, sz);
+          minScale = Math.min(minScale, sx, sy, sz);
+        }
+        const xx = qx * qx, yy = qy * qy, zz = qz * qz;
+        const xy = qx * qy, xz = qx * qz, yz = qy * qz;
+        const wx = qw * qx, wy = qw * qy, wz = qw * qz;
+        const m00 = 1 - 2 * (yy + zz);
+        const m01 = 2 * (xy + wz);
+        const m02 = 2 * (xz - wy);
+        const m10 = 2 * (xy - wz);
+        const m11 = 1 - 2 * (xx + zz);
+        const m12 = 2 * (yz + wx);
+        const m20 = 2 * (xz + wy);
+        const m21 = 2 * (yz - wx);
+        const m22 = 1 - 2 * (xx + yy);
+        const r00 = m00 * sx, r01 = m01 * sx, r02 = m02 * sx;
+        const r10 = m10 * sy, r11 = m11 * sy, r12 = m12 * sy;
+        const r20 = m20 * sz, r21 = m21 * sz, r22 = m22 * sz;
+        const cAx = r00 * r00 + r10 * r10 + r20 * r20;
+        const cAy = r00 * r01 + r10 * r11 + r20 * r21;
+        const cAz = r00 * r02 + r10 * r12 + r20 * r22;
+        const cBx = r01 * r01 + r11 * r11 + r21 * r21;
+        const cBy = r01 * r02 + r11 * r12 + r21 * r22;
+        const cBz = r02 * r02 + r12 * r12 + r22 * r22;
+        maxCov = Math.max(
+          maxCov,
+          Math.abs(cAx),
+          Math.abs(cAy),
+          Math.abs(cAz),
+          Math.abs(cBx),
+          Math.abs(cBy),
+          Math.abs(cBz)
+        );
+        const bidx = idx;
+        tB[bidx + 0] = cAx;
+        tB[bidx + 1] = cAy;
+        tB[bidx + 2] = cAz;
+        tB[bidx + 3] = cBz;
+        const hx = toHalfFloat(cBx) & 65535;
+        const hy = toHalfFloat(cBy) & 65535;
+        tA[idx + 3] = hx | hy << 16;
+      }
+      console.group("🔍 GSplat Data Statistics");
+      console.log("Splat count:", count);
+      console.log("Scale range:", minScale.toFixed(4), "~", maxScale.toFixed(4));
+      console.log("Max covariance:", maxCov.toFixed(4));
+      if (maxScale > 50) {
+        console.error("❌ CRITICAL: Scale values are too large! This causes spikes.");
+        console.log("💡 Try reducing visBoost or clamping scale values");
+      } else if (maxScale > 20) {
+        console.warn("⚠️ WARNING: Scale values are large. May cause rendering issues.");
+      } else {
+        console.log("✅ Scale values look normal");
+      }
+      if (maxCov > 100) {
+        console.error("❌ CRITICAL: Covariance values are too large!");
+      } else if (maxCov > 50) {
+        console.warn("⚠️ WARNING: Covariance values are large.");
+      } else {
+        console.log("✅ Covariance values look normal");
+      }
+      console.groupEnd();
+      this.transformA = new Uint32ArrayTexture().create(w, h, tA);
+      this.transformA.name = "transformA";
+      this.transformA.minFilter = "nearest";
+      this.transformA.magFilter = "nearest";
+      this.transformA.addressModeU = "clamp-to-edge";
+      this.transformA.addressModeV = "clamp-to-edge";
+      this.transformB = new Float16ArrayTexture().create(w, h, tB, false);
+      this.transformB.name = "transformB";
+      this.transformB.minFilter = "nearest";
+      this.transformB.magFilter = "nearest";
+      this.transformB.mipmapFilter = "nearest";
+      this.transformB.addressModeU = "clamp-to-edge";
+      this.transformB.addressModeV = "clamp-to-edge";
+    }
+    /**
+     * Update world space positions when transform changes
+     */
+    updateWorldPositions() {
+      if (!this._positions) return;
+      const worldMatrix = this.object3D.transform.worldMatrix;
+      const localPos = this._positions;
+      const count = this._fullCount;
+      if (!this._worldPositions) {
+        this._worldPositions = new Float32Array(localPos.length);
+      }
+      const m = worldMatrix.rawData;
+      for (let i = 0; i < count; i++) {
+        const idx = i * 3;
+        const x = localPos[idx + 0];
+        const y = localPos[idx + 1];
+        const z = localPos[idx + 2];
+        this._worldPositions[idx + 0] = m[0] * x + m[4] * y + m[8] * z + m[12];
+        this._worldPositions[idx + 1] = m[1] * x + m[5] * y + m[9] * z + m[13];
+        this._worldPositions[idx + 2] = m[2] * x + m[6] * y + m[10] * z + m[14];
+      }
+      this._centersSent = false;
+    }
+    /**
+     * Schedule Web Worker-based sorting task
+     */
+    scheduleOrder(viewMatrix) {
+      if (this.count === 0) return;
+      const transformChanged = this.object3D.transform.localChange;
+      if (transformChanged || !this._worldPositions) {
+        this.updateWorldPositions();
+      }
+      const r = viewMatrix.rawData;
+      const vx = r[2], vy = r[6], vz = r[10];
+      const px = -(r[0] * r[12] + r[1] * r[13] + r[2] * r[14]);
+      const py = -(r[4] * r[12] + r[5] * r[13] + r[6] * r[14]);
+      const pz = -(r[8] * r[12] + r[9] * r[13] + r[10] * r[14]);
+      const posHash = Math.floor(px * 1e3) ^ Math.floor(py * 1e3) ^ Math.floor(pz * 1e3);
+      const dirHash = Math.floor(vx * 1e3) ^ Math.floor(vy * 1e3) ^ Math.floor(vz * 1e3);
+      const hash = posHash ^ dirHash;
+      if (hash === this._lastViewMatrixHash && !transformChanged) {
+        return;
+      }
+      this._lastViewMatrixHash = hash;
+      const now = performance.now();
+      if (now - this._lastSentTime < this._minIntervalMs) return;
+      this._lastSentTime = now;
+      if (!this._sortWorker) {
+        this._sortWorker = this.createSortWorker();
+        this._sortWorker.onmessage = (ev) => {
+          const newOrder = ev.data.order;
+          const oldOrder = this._orderData.buffer;
+          this._sortWorker.postMessage({
+            order: oldOrder
+          }, [oldOrder]);
+          const indices = new Uint32Array(newOrder);
+          const total = this.size.x * this.size.y;
+          const count = this.count;
+          this._orderData = new Uint32Array(total * 4);
+          for (let i = 0; i < total; i++) {
+            const src = i < count ? indices[i] : count > 0 ? count - 1 : 0;
+            const base = i * 4;
+            this._orderData[base + 0] = src;
+            this._orderData[base + 1] = 0;
+            this._orderData[base + 2] = 0;
+            this._orderData[base + 3] = 0;
+          }
+          this.splatOrder.updateTexture(this.size.x, this.size.y, this._orderData);
+          const valid = Math.max(0, Math.min(this.count, ev.data.count | 0));
+          this.texParams[2] = valid;
+        };
+        const worldPos = this._worldPositions || this._positions;
+        const centers = this._mapping ? new Float32Array(this._mapping.length * 3) : new Float32Array(worldPos);
+        if (this._mapping) {
+          for (let i = 0; i < this._mapping.length; ++i) {
+            const src = this._mapping[i] * 3;
+            const dst = i * 3;
+            centers[dst + 0] = worldPos[src + 0];
+            centers[dst + 1] = worldPos[src + 1];
+            centers[dst + 2] = worldPos[src + 2];
+          }
+        }
+        const orderBuffer = new Uint32Array(this.count);
+        for (let i = 0; i < this.count; i++) {
+          orderBuffer[i] = i;
+        }
+        this._sortWorker.postMessage({
+          order: orderBuffer.buffer,
+          centers: centers.buffer,
+          mapping: this._mapping
+        }, [orderBuffer.buffer, centers.buffer]);
+        this._centersSent = true;
+      }
+      if (!this._centersSent && this._sortWorker) {
+        const worldPos = this._worldPositions || this._positions;
+        const centers = this._mapping ? new Float32Array(this._mapping.length * 3) : new Float32Array(worldPos);
+        if (this._mapping) {
+          for (let i = 0; i < this._mapping.length; ++i) {
+            const src = this._mapping[i] * 3;
+            const dst = i * 3;
+            centers[dst + 0] = worldPos[src + 0];
+            centers[dst + 1] = worldPos[src + 1];
+            centers[dst + 2] = worldPos[src + 2];
+          }
+        }
+        this._sortWorker.postMessage({
+          type: "centers",
+          centers: centers.buffer,
+          mapping: this._mapping ? this._mapping : null
+        }, [centers.buffer]);
+        this._centersSent = true;
+      }
+      this._sortWorker.postMessage({
+        cameraPosition: { x: px, y: py, z: pz },
+        cameraDirection: { x: -vx, y: -vy, z: -vz }
+      });
+    }
+    /**
+     * Create Web Worker for sorting
+     */
+    createSortWorker() {
+      function SortWorker() {
+        const compareBits = 16;
+        const bucketCount = 2 ** compareBits + 1;
+        let order;
+        let centers;
+        let mapping;
+        let cameraPosition;
+        let cameraDirection;
+        let forceUpdate = false;
+        const lastCameraPosition = { x: 0, y: 0, z: 0 };
+        const lastCameraDirection = { x: 0, y: 0, z: 0 };
+        const boundMin = { x: 0, y: 0, z: 0 };
+        const boundMax = { x: 0, y: 0, z: 0 };
+        let distances;
+        let countBuffer;
+        const binarySearch = (m, n, compare_fn) => {
+          while (m <= n) {
+            const k = n + m >> 1;
+            const cmp = compare_fn(k);
+            if (cmp > 0) {
+              m = k + 1;
+            } else if (cmp < 0) {
+              n = k - 1;
+            } else {
+              return k;
+            }
+          }
+          return ~m;
+        };
+        const update = () => {
+          if (!order || !centers || !cameraPosition || !cameraDirection) return;
+          const px = cameraPosition.x;
+          const py = cameraPosition.y;
+          const pz = cameraPosition.z;
+          const dx = cameraDirection.x;
+          const dy = cameraDirection.y;
+          const dz = cameraDirection.z;
+          const epsilon = 1e-3;
+          if (!forceUpdate && Math.abs(px - lastCameraPosition.x) < epsilon && Math.abs(py - lastCameraPosition.y) < epsilon && Math.abs(pz - lastCameraPosition.z) < epsilon && Math.abs(dx - lastCameraDirection.x) < epsilon && Math.abs(dy - lastCameraDirection.y) < epsilon && Math.abs(dz - lastCameraDirection.z) < epsilon) {
+            return;
+          }
+          forceUpdate = false;
+          lastCameraPosition.x = px;
+          lastCameraPosition.y = py;
+          lastCameraPosition.z = pz;
+          lastCameraDirection.x = dx;
+          lastCameraDirection.y = dy;
+          lastCameraDirection.z = dz;
+          const numVertices = centers.length / 3;
+          if (distances?.length !== numVertices) {
+            distances = new Uint32Array(numVertices);
+          }
+          let minDist;
+          let maxDist;
+          for (let i = 0; i < 8; ++i) {
+            const x = (i & 1 ? boundMin.x : boundMax.x) - px;
+            const y = (i & 2 ? boundMin.y : boundMax.y) - py;
+            const z = (i & 4 ? boundMin.z : boundMax.z) - pz;
+            const d = x * dx + y * dy + z * dz;
+            if (i === 0) {
+              minDist = maxDist = d;
+            } else {
+              minDist = Math.min(minDist, d);
+              maxDist = Math.max(maxDist, d);
+            }
+          }
+          if (!countBuffer) {
+            countBuffer = new Uint32Array(bucketCount);
+          } else {
+            countBuffer.fill(0);
+          }
+          const range = maxDist - minDist;
+          const divider = range < 1e-6 ? 0 : 1 / range * 2 ** compareBits;
+          for (let i = 0; i < numVertices; ++i) {
+            const istride = i * 3;
+            const x = centers[istride + 0] - px;
+            const y = centers[istride + 1] - py;
+            const z = centers[istride + 2] - pz;
+            const d = x * dx + y * dy + z * dz;
+            const sortKey = Math.floor((d - minDist) * divider);
+            distances[i] = sortKey;
+            countBuffer[sortKey]++;
+          }
+          for (let i = 1; i < bucketCount; i++) {
+            countBuffer[i] += countBuffer[i - 1];
+          }
+          for (let i = 0; i < numVertices; i++) {
+            const distance = distances[i];
+            const destIndex = --countBuffer[distance];
+            order[destIndex] = i;
+          }
+          const dist = (i) => distances[order[i]] / divider + minDist;
+          const findZero = () => {
+            const result = binarySearch(0, numVertices - 1, (i) => -dist(i));
+            return Math.min(numVertices, Math.abs(result));
+          };
+          const count = dist(numVertices - 1) >= 0 ? findZero() : numVertices;
+          if (mapping) {
+            for (let i = 0; i < numVertices; ++i) {
+              order[i] = mapping[order[i]];
+            }
+          }
+          self.postMessage({
+            order: order.buffer,
+            count
+          }, [order.buffer]);
+          order = null;
+        };
+        self.onmessage = (message) => {
+          if (message.data.order) {
+            order = new Uint32Array(message.data.order);
+          }
+          if (message.data.centers) {
+            centers = new Float32Array(message.data.centers);
+            boundMin.x = boundMax.x = centers[0];
+            boundMin.y = boundMax.y = centers[1];
+            boundMin.z = boundMax.z = centers[2];
+            const numVertices = centers.length / 3;
+            for (let i = 1; i < numVertices; ++i) {
+              const x = centers[i * 3 + 0];
+              const y = centers[i * 3 + 1];
+              const z = centers[i * 3 + 2];
+              boundMin.x = Math.min(boundMin.x, x);
+              boundMin.y = Math.min(boundMin.y, y);
+              boundMin.z = Math.min(boundMin.z, z);
+              boundMax.x = Math.max(boundMax.x, x);
+              boundMax.y = Math.max(boundMax.y, y);
+              boundMax.z = Math.max(boundMax.z, z);
+            }
+            forceUpdate = true;
+          }
+          if (message.data.hasOwnProperty("mapping")) {
+            mapping = message.data.mapping ? new Uint32Array(message.data.mapping) : null;
+            forceUpdate = true;
+          }
+          if (message.data.cameraPosition) cameraPosition = message.data.cameraPosition;
+          if (message.data.cameraDirection) cameraDirection = message.data.cameraDirection;
+          update();
+        };
+      }
+      const code = `(${SortWorker.toString()})()`;
+      const blob = new Blob([code], { type: "application/javascript" });
+      const url = URL.createObjectURL(blob);
+      return new Worker(url);
+    }
+    /**
+     * Update node before rendering
+     */
+    nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+      const worldMatrix = this.object3D.transform.worldMatrix;
+      this.gsplatMaterial.setTransformMatrix(worldMatrix);
+      this.gsplatMaterial.setSplatTextures(
+        this.splatColor,
+        this.transformA,
+        this.transformB,
+        this.texParams,
+        this.splatOrder
+      );
+      super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
+    }
+    /**
+     * Render pass
+     */
+    renderPass2(view, passType, rendererPassState, clusterLightingBuffer, encoder, useBundle = false) {
+      for (let mat of this.materials) {
+        const passes = mat.getPass(passType);
+        if (!passes || passes.length === 0) continue;
+        for (const pass of passes) {
+          if (!pass.pipeline) continue;
+          pass.apply(this.geometry, rendererPassState);
+          GPUContext.bindPipeline(encoder, pass);
+          GPUContext.draw(encoder, 4, this.count, 0, 0);
+        }
+      }
+    }
+    /**
+     * Render pass (fallback)
+     */
+    renderPass(view, passType, renderContext) {
+      const encoder = renderContext.encoder;
+      for (let mat of this.materials) {
+        const passes = mat.getPass(passType);
+        if (!passes || passes.length === 0) continue;
+        for (const pass of passes) {
+          if (!pass.pipeline) continue;
+          pass.apply(this.geometry, renderContext.rendererPassState || renderContext);
+          GPUContext.bindPipeline(encoder, pass);
+          GPUContext.draw(encoder, 4, this.count, 0, 0);
+        }
+      }
+    }
+    /**
+     * Clean up resources
+     */
+    destroy(force) {
+      if (this._sortWorker) {
+        this._sortWorker.terminate();
+        this._sortWorker = null;
+      }
+      super.destroy(force);
+    }
+  };
+  exports.GSplatRenderer = __decorateClass$6([
+    RegisterComponent(exports.GSplatRenderer, "GSplatRenderer")
+  ], exports.GSplatRenderer);
+
   class Probe extends exports.Object3D {
     index = 0;
     drawCallFrame = -1;
@@ -55891,6 +57698,298 @@ fn frag(){
     }
   }
 
+  function computeAABBFromPositions(position) {
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < position.length; i += 3) {
+      const x = position[i + 0];
+      const y = position[i + 1];
+      const z = position[i + 2];
+      if (x < min[0]) min[0] = x;
+      if (y < min[1]) min[1] = y;
+      if (z < min[2]) min[2] = z;
+      if (x > max[0]) max[0] = x;
+      if (y > max[1]) max[1] = y;
+      if (z > max[2]) max[2] = z;
+    }
+    return { min, max };
+  }
+
+  var GSplatFormat = /* @__PURE__ */ ((GSplatFormat2) => {
+    GSplatFormat2["PLY"] = "ply";
+    GSplatFormat2["SPLAT"] = "splat";
+    GSplatFormat2["KSPLAT"] = "ksplat";
+    GSplatFormat2["UNKNOWN"] = "unknown";
+    return GSplatFormat2;
+  })(GSplatFormat || {});
+  function detectGSplatFormat(buffer) {
+    if (buffer.byteLength < 16) {
+      return "unknown" /* UNKNOWN */;
+    }
+    const headerBytes = new Uint8Array(buffer, 0, Math.min(512, buffer.byteLength));
+    const headerText = new TextDecoder("utf-8").decode(headerBytes);
+    if (headerText.startsWith("ply")) {
+      return "ply" /* PLY */;
+    }
+    return "unknown" /* UNKNOWN */;
+  }
+
+  function byteSizeOfType(t) {
+    switch (t) {
+      case "char":
+      case "uchar":
+      case "uint8":
+      case "int8":
+        return 1;
+      case "short":
+      case "ushort":
+      case "int16":
+      case "uint16":
+        return 2;
+      case "int":
+      case "uint":
+      case "int32":
+      case "uint32":
+      case "float":
+      case "float32":
+        return 4;
+      case "double":
+      case "float64":
+        return 8;
+      default:
+        return 4;
+    }
+  }
+  function readByType(view, offset, type) {
+    switch (type) {
+      case "char":
+      case "int8":
+        return view.getInt8(offset);
+      case "uchar":
+      case "uint8":
+        return view.getUint8(offset);
+      case "short":
+      case "int16":
+        return view.getInt16(offset, true);
+      case "ushort":
+      case "uint16":
+        return view.getUint16(offset, true);
+      case "int":
+      case "int32":
+        return view.getInt32(offset, true);
+      case "uint":
+      case "uint32":
+        return view.getUint32(offset, true);
+      case "double":
+      case "float64":
+        return view.getFloat64(offset, true);
+      case "float":
+      case "float32":
+      default:
+        return view.getFloat32(offset, true);
+    }
+  }
+  function inferSHOrder(coeffsPerColor) {
+    const root = Math.round(Math.sqrt(coeffsPerColor));
+    return Math.max(0, root - 1);
+  }
+
+  function parsePlyHeader(buffer) {
+    const ascii = new TextDecoder("utf-8").decode(
+      new Uint8Array(buffer, 0, Math.min(4096, buffer.byteLength))
+    );
+    if (!ascii.startsWith("ply")) {
+      throw new Error("PLY: Unsupported format. Expecting PLY file.");
+    }
+    const headerEnd = ascii.indexOf("end_header\n");
+    if (headerEnd < 0) {
+      throw new Error("PLY: Invalid PLY header");
+    }
+    const headerText = ascii.substring(0, headerEnd + "end_header\n".length);
+    const lines = headerText.split(/\r?\n/);
+    let format = "";
+    let vertexCount = 0;
+    const properties = [];
+    let inVertexElement = false;
+    for (const line of lines) {
+      if (line.startsWith("format ")) {
+        format = line.split(/\s+/)[1];
+      } else if (line.startsWith("element ")) {
+        const toks = line.split(/\s+/);
+        inVertexElement = toks[1] === "vertex";
+        if (inVertexElement) vertexCount = parseInt(toks[2]);
+      } else if (inVertexElement && line.startsWith("property ")) {
+        const toks = line.split(/\s+/);
+        const type = toks[1];
+        const name = toks[2];
+        properties.push({ name, type });
+      }
+    }
+    if (format !== "binary_little_endian") {
+      throw new Error("PLY: Only binary_little_endian PLY is supported");
+    }
+    return {
+      format,
+      vertexCount,
+      properties,
+      headerByteLength: headerText.length
+    };
+  }
+  function parsePlyGaussianSplat(buffer) {
+    const header = parsePlyHeader(buffer);
+    const { vertexCount, properties, headerByteLength } = header;
+    const payload = new DataView(buffer, headerByteLength);
+    const has = (n) => properties.find((p) => p.name === n) != null;
+    const propIndex = (n) => properties.findIndex((p) => p.name === n);
+    const position = new Float32Array(vertexCount * 3);
+    const scale = has("scale_0") ? new Float32Array(vertexCount * 3) : void 0;
+    const rotation = has("rot_0") ? new Float32Array(vertexCount * 4) : void 0;
+    const opacity = has("opacity") ? new Float32Array(vertexCount) : void 0;
+    const dcIdx = [propIndex("f_dc_0"), propIndex("f_dc_1"), propIndex("f_dc_2")];
+    const restIndices = [];
+    for (let i = 0; i < properties.length; i++) {
+      if (properties[i].name.startsWith("f_rest_")) restIndices.push(i);
+    }
+    const hasSH = dcIdx[0] >= 0 && dcIdx[1] >= 0 && dcIdx[2] >= 0;
+    let shCoeffs = void 0;
+    let shOrder = 0;
+    if (hasSH) {
+      const coeffsPerColor = 1 + restIndices.length / 3;
+      shOrder = inferSHOrder(coeffsPerColor);
+      shCoeffs = new Float32Array(vertexCount * coeffsPerColor * 3);
+    }
+    const propOffsets = [];
+    let stride = 0;
+    for (const p of properties) {
+      propOffsets.push(stride);
+      stride += byteSizeOfType(p.type);
+    }
+    let base = 0;
+    for (let v = 0; v < vertexCount; v++) {
+      const vOffset = base;
+      const ix = propIndex("x");
+      const iy = propIndex("y");
+      const iz = propIndex("z");
+      if (ix < 0 || iy < 0 || iz < 0) {
+        throw new Error("PLY: Missing x/y/z for vertex");
+      }
+      position[v * 3 + 0] = readByType(payload, vOffset + propOffsets[ix], properties[ix].type);
+      position[v * 3 + 1] = readByType(payload, vOffset + propOffsets[iy], properties[iy].type);
+      position[v * 3 + 2] = readByType(payload, vOffset + propOffsets[iz], properties[iz].type);
+      if (scale) {
+        const s0 = propIndex("scale_0");
+        const s1 = propIndex("scale_1");
+        const s2 = propIndex("scale_2");
+        scale[v * 3 + 0] = readByType(payload, vOffset + propOffsets[s0], properties[s0].type);
+        scale[v * 3 + 1] = readByType(payload, vOffset + propOffsets[s1], properties[s1].type);
+        scale[v * 3 + 2] = readByType(payload, vOffset + propOffsets[s2], properties[s2].type);
+      }
+      if (rotation) {
+        const r0 = propIndex("rot_0");
+        const r1 = propIndex("rot_1");
+        const r2 = propIndex("rot_2");
+        const r3 = propIndex("rot_3");
+        rotation[v * 4 + 0] = readByType(payload, vOffset + propOffsets[r0], properties[r0].type);
+        rotation[v * 4 + 1] = readByType(payload, vOffset + propOffsets[r1], properties[r1].type);
+        rotation[v * 4 + 2] = readByType(payload, vOffset + propOffsets[r2], properties[r2].type);
+        rotation[v * 4 + 3] = readByType(payload, vOffset + propOffsets[r3], properties[r3].type);
+      }
+      if (opacity) {
+        const oi = propIndex("opacity");
+        opacity[v] = readByType(payload, vOffset + propOffsets[oi], properties[oi].type);
+      }
+      if (hasSH && shCoeffs) {
+        const coeffsPerColor = 1 + restIndices.length / 3;
+        const baseIndex = v * coeffsPerColor * 3;
+        shCoeffs[baseIndex + 0] = readByType(
+          payload,
+          vOffset + propOffsets[dcIdx[0]],
+          properties[dcIdx[0]].type
+        );
+        shCoeffs[baseIndex + coeffsPerColor + 0] = readByType(
+          payload,
+          vOffset + propOffsets[dcIdx[1]],
+          properties[dcIdx[1]].type
+        );
+        shCoeffs[baseIndex + 2 * coeffsPerColor + 0] = readByType(
+          payload,
+          vOffset + propOffsets[dcIdx[2]],
+          properties[dcIdx[2]].type
+        );
+        let rPtr = 1;
+        let gPtr = 1;
+        let bPtr = 1;
+        for (let i = 0; i < restIndices.length; i += 3) {
+          const ri = restIndices[i + 0];
+          const gi = restIndices[i + 1];
+          const bi = restIndices[i + 2];
+          shCoeffs[baseIndex + rPtr] = readByType(
+            payload,
+            vOffset + propOffsets[ri],
+            properties[ri].type
+          );
+          shCoeffs[baseIndex + coeffsPerColor + gPtr] = readByType(
+            payload,
+            vOffset + propOffsets[gi],
+            properties[gi].type
+          );
+          shCoeffs[baseIndex + 2 * coeffsPerColor + bPtr] = readByType(
+            payload,
+            vOffset + propOffsets[bi],
+            properties[bi].type
+          );
+          rPtr++;
+          gPtr++;
+          bPtr++;
+        }
+      }
+      base += stride;
+    }
+    return {
+      vertexCount,
+      position,
+      scale,
+      rotation,
+      opacity,
+      sh: hasSH && shCoeffs ? { order: shOrder, coeffs: shCoeffs } : void 0
+    };
+  }
+
+  class GaussianSplatParser extends ParserBase {
+    static format = ParserFormat.BIN;
+    async parseBuffer(buffer) {
+      const format = detectGSplatFormat(buffer);
+      let asset;
+      switch (format) {
+        case GSplatFormat.PLY: {
+          const plyData = parsePlyGaussianSplat(buffer);
+          asset = {
+            count: plyData.vertexCount,
+            position: plyData.position,
+            rotation: plyData.rotation,
+            scale: plyData.scale,
+            opacity: plyData.opacity,
+            sh: plyData.sh
+          };
+          asset.bbox = computeAABBFromPositions(plyData.position);
+          break;
+        }
+        case GSplatFormat.SPLAT:
+          throw new Error("SPLAT format is not yet supported");
+        case GSplatFormat.KSPLAT:
+          throw new Error("KSPLAT format is not yet supported");
+        case GSplatFormat.UNKNOWN:
+        default:
+          throw new Error("Unknown or unsupported Gaussian Splatting file format");
+      }
+      this.data = asset;
+      return asset;
+    }
+    verification() {
+      return !!this.data && this.data.count > 0;
+    }
+  }
+
   var GeoType = /* @__PURE__ */ ((GeoType2) => {
     GeoType2["Point"] = "Point";
     GeoType2["LineString"] = "LineString";
@@ -57022,7 +59121,7 @@ fn frag(){
     }
   };
   exports.LitSSSShader = __decorateClass$3([
-    RegisterShader
+    RegisterShader(exports.LitSSSShader, "LitSSSShader")
   ], exports.LitSSSShader);
 
   var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
@@ -57124,7 +59223,7 @@ fn frag(){
     }
   };
   exports.LitShader = __decorateClass$2([
-    RegisterShader
+    RegisterShader(exports.LitShader, "LitShader")
   ], exports.LitShader);
 
   class ComData {
@@ -57360,7 +59459,7 @@ fn frag(){
     }
   };
   exports.UnLitShader = __decorateClass$1([
-    RegisterShader
+    RegisterShader(exports.UnLitShader, "UnLitShader")
   ], exports.UnLitShader);
 
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -57449,7 +59548,7 @@ fn frag(){
     }
   };
   exports.UnLitTexArrayShader = __decorateClass([
-    RegisterShader
+    RegisterShader(exports.UnLitTexArrayShader, "UnLitTexArrayShader")
   ], exports.UnLitTexArrayShader);
 
   class TileSet {
@@ -57682,46 +59781,6 @@ fn frag(){
   function registerMaterial(name, cls) {
   }
 
-  class UnLitMaterial extends Material {
-    /**
-     * @constructor
-     */
-    constructor() {
-      super();
-      this.shader = new exports.UnLitShader();
-      this.baseMap = Engine3D.res.whiteTexture;
-    }
-    set baseMap(texture) {
-      this.shader.setTexture(`baseMap`, texture);
-    }
-    get baseMap() {
-      return this.shader.getTexture(`baseMap`);
-    }
-    /**
-     * 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 environment texture, usually referring to cubemap
-     */
-    set envMap(texture) {
-    }
-    /**
-     * @internal
-     * set shadow map
-     */
-    set shadowMap(texture) {
-    }
-  }
-
   class UnLitTexArrayMaterial extends Material {
     /**
      * @constructor
@@ -58327,6 +60386,449 @@ fn frag(){
     }
   }
 
+  var ParticleSystemRandomnessIds = /* @__PURE__ */ ((ParticleSystemRandomnessIds2) => {
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemClampVelocityCurveId"] = 322376503] = "kParticleSystemClampVelocityCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemForceCurveId"] = 306581307] = "kParticleSystemForceCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemRotationCurveId"] = 1793934638] = "kParticleSystemRotationCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemRotationBySpeedCurveId"] = 3737431713] = "kParticleSystemRotationBySpeedCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemStartSpeedCurveId"] = 2527743459] = "kParticleSystemStartSpeedCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemSizeCurveId"] = 2368504881] = "kParticleSystemSizeCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemSizeBySpeedCurveId"] = 4085612399] = "kParticleSystemSizeBySpeedCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemVelocityCurveId"] = 3774601268] = "kParticleSystemVelocityCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemUVCurveId"] = 326370691] = "kParticleSystemUVCurveId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemColorGradientId"] = 1494990940] = "kParticleSystemColorGradientId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemColorByVelocityGradientId"] = 1089181156] = "kParticleSystemColorByVelocityGradientId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemMeshSelectionId"] = 3159510623] = "kParticleSystemMeshSelectionId";
+    ParticleSystemRandomnessIds2[ParticleSystemRandomnessIds2["kParticleSystemUVRowSelectionId"] = 2941263940] = "kParticleSystemUVRowSelectionId";
+    return ParticleSystemRandomnessIds2;
+  })(ParticleSystemRandomnessIds || {});
+  const kPI = 3.141592653589793;
+
+  class Polynomials {
+  }
+  function cubicPolynomialRoot(p, q, r) {
+    let rcp3 = 1 / 3;
+    let half = 0.5;
+    let po3 = p * rcp3;
+    let po3_2 = po3 * po3;
+    let po3_3 = po3_2 * po3;
+    let b = po3_3 - po3 * q * half + r * half;
+    let a = -po3_2 + q * rcp3;
+    let a3 = a * a * a;
+    let det = a3 + b * b;
+    if (det >= 0) {
+      let r0 = Math.sqrt(det) - b;
+      r0 = r0 > 0 ? Math.pow(r0, rcp3) : -Math.pow(-r0, rcp3);
+      return -po3 - a / r0 + r0;
+    }
+    let abs = Math.sqrt(-a3);
+    let arg = Math.acos(-b / abs);
+    abs = Math.pow(abs, rcp3);
+    abs = abs - a / abs;
+    arg = -po3 + abs * Math.cos(arg * rcp3);
+    return arg;
+  }
+  function quadraticPolynomialRootsGeneric(a, b, c, out) {
+    let eps = 1e-5;
+    if (Math.abs(a) < eps) {
+      if (Math.abs(b) > eps) {
+        out.r0 = -c / b;
+        return 1;
+      } else {
+        return 0;
+      }
+    }
+    let disc = b * b - 4 * a * c;
+    if (disc < 0) {
+      return 0;
+    }
+    let halfRcpA = 0.5 / a;
+    let sqrtDisc = Math.sqrt(disc);
+    out.r0 = (sqrtDisc - b) * halfRcpA;
+    out.r1 = (-sqrtDisc - b) * halfRcpA;
+    return 2;
+  }
+  function cubicPolynomialRootsGeneric(roots, a, b, c, d) {
+    let numRoots = 0;
+    if (Math.abs(a) >= 1e-4) {
+      let p = b / a;
+      let q = c / a;
+      let r = d / a;
+      roots[0] = cubicPolynomialRoot(p, q, r);
+      numRoots++;
+      let la = a;
+      let lb = b + a * roots[0];
+      let lc = c + b * roots[0] + a * roots[0] * roots[0];
+      numRoots += quadraticPolynomialRootsGeneric(la, lb, lc, {
+        r0: roots[1],
+        r1: roots[2]
+      });
+    } else {
+      numRoots += quadraticPolynomialRootsGeneric(b, c, d, {
+        r0: roots[1],
+        r1: roots[2]
+      });
+    }
+    return numRoots;
+  }
+
+  class Polynomial {
+    coeff = [];
+    static EvalSegment(t, coeff) {
+      return t * (t * (t * coeff[0] + coeff[1]) + coeff[2]) + coeff[3];
+    }
+  }
+  class PolynomialCurve {
+    static kMaxNumSegments = 8;
+    segments = [];
+    integrationCache = [];
+    doubleIntegrationCache = [];
+    times = [];
+    segmentCount;
+    constructor() {
+      this.segments[PolynomialCurve.kMaxNumSegments] = new Polynomial();
+      this.integrationCache[PolynomialCurve.kMaxNumSegments] = 0;
+      this.doubleIntegrationCache[PolynomialCurve.kMaxNumSegments] = 0;
+      this.times[PolynomialCurve.kMaxNumSegments] = 0;
+    }
+    calculateMinMax(minmax, value) {
+      minmax.x = Math.min(minmax.x, value);
+      minmax.y = Math.max(minmax.y, value);
+    }
+    findMinMaxDoubleIntegrated() {
+      let result = Vector2.ZERO.clone();
+      let numSteps = 20;
+      let delta = 1 / numSteps;
+      let acc = delta;
+      for (let i = 0; i < numSteps; i++) {
+        this.calculateMinMax(result, this.evaluateDoubleIntegrated(acc));
+        acc += delta;
+      }
+      return result;
+    }
+    // Find the maximum of the integrated curve (x: min, y: max)
+    findMinMaxIntegrated() {
+      let result = Vector2.ZERO.clone();
+      let start = [];
+      let end = [];
+      for (let i = 0; i < this.segmentCount; i++) {
+        let a = 4 * this.segments[i].coeff[0];
+        let b = 3 * this.segments[i].coeff[1];
+        let c = 2 * this.segments[i].coeff[2];
+        let d = 1 * this.segments[i].coeff[3];
+        let roots = [];
+        let numRoots = cubicPolynomialRootsGeneric(roots, a, b, c, d);
+        for (let r = 0; r < numRoots; r++) {
+          let root = roots[r] + start[i];
+          if (root >= start[i] && root < end[i]) {
+            this.calculateMinMax(result, this.evaluateIntegrated(root));
+          }
+        }
+        this.calculateMinMax(result, this.evaluateIntegrated(end[i]));
+        this.times[i];
+      }
+      return result;
+    }
+    generateIntegrationCache(curve) {
+      curve.integrationCache[0] = 0;
+      let prevTimeValue0 = curve.times[0];
+      let prevTimeValue1 = 0;
+      for (let i = 1; i < curve.segmentCount; i++) {
+        let coeff = curve.segments[i - 1].coeff;
+        integrateSegment(coeff);
+        let time = prevTimeValue0 - prevTimeValue1;
+        curve.integrationCache[i] = curve.integrationCache[i - 1] + Polynomial.EvalSegment(time, coeff) * time;
+        prevTimeValue1 = prevTimeValue0;
+        prevTimeValue0 = curve.times[i];
+      }
+    }
+    generateDoubleIntegrationCache(curve) {
+      let sum = 0;
+      let prevTimeValue = 0;
+      for (let i = 0; i < curve.segmentCount; i++) {
+        curve.doubleIntegrationCache[i] = sum;
+        let time = curve.times[i] - prevTimeValue;
+        time = Math.max(time, 0);
+        sum += Polynomial.EvalSegment(time, curve.segments[i].coeff) * time * time + curve.integrationCache[i] * time;
+        prevTimeValue = curve.times[i];
+      }
+    }
+    // Integrates a velocity curve to be a position curve.
+    // You have to call EvaluateIntegrated to evaluate the curve
+    integrate() {
+      this.generateIntegrationCache(this);
+      for (let i = 0; i < this.segmentCount; i++) {
+        integrateSegment(this.segments[i].coeff);
+      }
+    }
+    // Integrates a velocity curve to be a position curve.
+    // You have to call EvaluateDoubleIntegrated to evaluate the curve
+    doubleIntegrate() {
+      this.generateIntegrationCache(this);
+      for (let i = 0; i < this.segmentCount; i++) {
+        doubleIntegrateSegment(this.segments[i].coeff);
+      }
+      this.generateDoubleIntegrationCache(this);
+    }
+    // Evaluates if it is possible to represent animation curve as PolynomialCurve
+    static isValidCurve(editorCurve) {
+      let keyCount = editorCurve.getKeyCount();
+      let segmentCount = keyCount - 1;
+      if (editorCurve.getKey(0).time != 0) {
+        segmentCount++;
+      }
+      if (editorCurve.getKey(keyCount - 1).time != 1) {
+        segmentCount++;
+      }
+      return segmentCount <= PolynomialCurve.kMaxNumSegments;
+    }
+    evaluateDoubleIntegrated(t) {
+      let prevTimeValue = 0;
+      for (let i = 0; i < this.segmentCount; i++) {
+        if (t <= this.times[i]) {
+          let time = t - prevTimeValue;
+          return this.doubleIntegrationCache[i] + this.integrationCache[i] * time + Polynomial.EvalSegment(time, this.segments[i].coeff) * time * time;
+        }
+        prevTimeValue = this.times[i];
+      }
+      return 1;
+    }
+    // Evaluate integrated Polynomial curve.
+    // Example: position = EvaluateIntegrated (normalizedTime) * startEnergy
+    // Use Integrate function to for example turn a velocity curve into a position curve.
+    // Expects that t is in the 0...1 range.
+    evaluateIntegrated(t) {
+      let prevTimeValue = 0;
+      for (let i = 0; i < this.segmentCount; i++) {
+        if (t <= this.times[i]) {
+          let time = t - prevTimeValue;
+          return this.integrationCache[i] + Polynomial.EvalSegment(time, this.segments[i].coeff) * time;
+        }
+        prevTimeValue = this.times[i];
+      }
+      return 1;
+    }
+    // Evaluate the curve
+    // extects that t is in the 0...1 range
+    evaluate(t) {
+      let prevTimeValue = 0;
+      for (let i = 0; i < this.segmentCount; i++) {
+        if (t <= this.times[i]) {
+          return Polynomial.EvalSegment(
+            t - prevTimeValue,
+            this.segments[i].coeff
+          );
+        }
+        prevTimeValue = this.times[i];
+      }
+      return 1;
+    }
+    buildCurve(editorCurve, scale) {
+      let keyCount = editorCurve.getKeyCount();
+      this.segmentCount = 1;
+      let kMaxTime = 1.01;
+      this.segments.length = 0;
+      this.integrationCache.length = 0;
+      this.doubleIntegrationCache.length = 0;
+      this.times.length = 0;
+      this.times[0] = kMaxTime;
+      if (keyCount == 0) ; else if (keyCount == 1) {
+        this.segments[0] = new Polynomial();
+        this.segments[0].coeff[3] = editorCurve.getKey(0).value * scale;
+      } else {
+        this.segmentCount = keyCount - 1;
+        let segmentOffset = 0;
+        if (editorCurve.getKey(0).time != 0) {
+          this.segments[0].coeff[3] = editorCurve.getKey(0).value;
+          this.times[0] = editorCurve.getKey(0).time;
+          segmentOffset = 1;
+        }
+        for (let i = 0; i < this.segmentCount; i++) {
+          let cache;
+          editorCurve.calculateCacheData(cache, i, i + 1, 0);
+          this.segments[i + segmentOffset].coeff = cache.coeff.concat();
+          this.times[i + segmentOffset] = editorCurve.getKey(i + 1).time;
+        }
+        this.segmentCount += segmentOffset;
+        if (editorCurve.getKey(keyCount - 1).time != 1) {
+          this.segments[this.segmentCount].coeff[3] = editorCurve.getKey(
+            keyCount - 1
+          ).value;
+          this.segmentCount++;
+        }
+        this.times[this.segmentCount - 1] = kMaxTime;
+        for (let i = 0; i < this.segmentCount; i++) {
+          this.segments[i].coeff[0] *= scale;
+          this.segments[i].coeff[1] *= scale;
+          this.segments[i].coeff[2] *= scale;
+          this.segments[i].coeff[3] *= scale;
+        }
+      }
+      return true;
+    }
+  }
+  function doubleIntegrateSegment(coeff) {
+    coeff[0] /= 20;
+    coeff[1] /= 12;
+    coeff[2] /= 6;
+    coeff[3] /= 2;
+  }
+  function integrateSegment(coeff) {
+    coeff[0] /= 4;
+    coeff[1] /= 3;
+    coeff[2] /= 2;
+    coeff[3] /= 1;
+  }
+
+  var ParticleSystemCurveEvalMode = /* @__PURE__ */ ((ParticleSystemCurveEvalMode2) => {
+    ParticleSystemCurveEvalMode2[ParticleSystemCurveEvalMode2["kEMScalar"] = 0] = "kEMScalar";
+    ParticleSystemCurveEvalMode2[ParticleSystemCurveEvalMode2["kEMOptimized"] = 1] = "kEMOptimized";
+    ParticleSystemCurveEvalMode2[ParticleSystemCurveEvalMode2["kEMOptimizedMinMax"] = 2] = "kEMOptimizedMinMax";
+    ParticleSystemCurveEvalMode2[ParticleSystemCurveEvalMode2["kEMSlow"] = 3] = "kEMSlow";
+    return ParticleSystemCurveEvalMode2;
+  })(ParticleSystemCurveEvalMode || {});
+  var MinMaxCurveState = /* @__PURE__ */ ((MinMaxCurveState2) => {
+    MinMaxCurveState2[MinMaxCurveState2["kMMCScalar"] = 0] = "kMMCScalar";
+    MinMaxCurveState2[MinMaxCurveState2["kMMCCurve"] = 1] = "kMMCCurve";
+    MinMaxCurveState2[MinMaxCurveState2["kMMCTwoCurves"] = 2] = "kMMCTwoCurves";
+    MinMaxCurveState2[MinMaxCurveState2["kMMCTwoConstants"] = 3] = "kMMCTwoConstants";
+    return MinMaxCurveState2;
+  })(MinMaxCurveState || {});
+  class MinMaxAnimationCurves {
+    // public SupportsProcedural ();
+    max;
+    min;
+  }
+  class MinMaxPolyCurves {
+    max;
+    min;
+    integrate() {
+      this.max.integrate();
+      this.min.integrate();
+    }
+    doubleIntegrate() {
+      this.max.doubleIntegrate();
+      this.min.doubleIntegrate();
+    }
+    findMinMaxIntegrated() {
+      return null;
+    }
+    findMinMaxDoubleIntegrated() {
+      return null;
+    }
+  }
+  class MinMaxCurve {
+    minMaxState;
+    // see enum MinMaxCurveState
+    minCurve;
+    maxCurve;
+    _scalar = 1;
+    // Since scalar is baked into the optimized curve we use the setter function to modify it.
+    _minScalar;
+    constructor(scalarValue = 1) {
+      this._scalar = scalarValue;
+      this.minMaxState = 0 /* kMMCScalar */;
+      this.minCurve = new AnimationCurve();
+      this.maxCurve = new AnimationCurve();
+    }
+    setScalar(value) {
+      this._scalar = value;
+    }
+    getScalar() {
+      return this._scalar;
+    }
+    static evaluateSlow(curve, t, factor) {
+      let v = curve.maxCurve.getValue(t) * curve.getScalar();
+      if (curve.minMaxState == 2 /* kMMCTwoCurves */) {
+        return lerp(curve.minCurve.getValue(t) * curve.getScalar(), v, factor);
+      } else return v;
+    }
+    static evaluate(curve, t, randomValue = 1) {
+      if (curve.minMaxState == 0 /* kMMCScalar */) {
+        return curve.getScalar();
+      }
+      let v = curve.maxCurve.getValue(t) * curve.getScalar();
+      if (curve.minMaxState == 1 /* kMMCCurve */) {
+        return lerp(curve.minCurve.getValue(t) * curve.getScalar(), v, randomValue);
+      }
+      if (curve.minMaxState == 3 /* kMMCTwoConstants */) {
+        return lerp(curve._minScalar, curve._scalar, randomValue);
+      }
+      if (curve.minMaxState == 2 /* kMMCTwoCurves */) {
+        return lerp(curve.minCurve.getValue(t) * curve.getScalar(), v, 1 * Math.random());
+      }
+      return this.evaluateSlow(curve, t, 1);
+    }
+    unSerialized(data) {
+      this.minMaxState = data["minMaxState"];
+      this._scalar = data["scalar"];
+      this._minScalar = data["minScalar"];
+      this.maxCurve.unSerialized(data["maxCurve"]);
+      this.minCurve.unSerialized(data["minCurve"]);
+    }
+  }
+  class ValueSpread {
+    value = 0;
+    mode = 0;
+    spread = 0;
+    speed = new MinMaxCurve();
+    unSerialized(data) {
+      this.value = data["value"];
+      this.mode = data["mode"];
+      this.spread = data["spread"];
+      this.speed.unSerialized(data["speed"]);
+    }
+  }
+  function curvesSupportProcedural(editorCurves, minMaxState) {
+    let isValid = PolynomialCurve.isValidCurve(editorCurves.max);
+    if (minMaxState != 2 /* kMMCTwoCurves */ && minMaxState != 3 /* kMMCTwoConstants */) {
+      return isValid;
+    } else {
+      return isValid && PolynomialCurve.isValidCurve(editorCurves.min);
+    }
+  }
+  function buildCurves(polyCurves, editorCurves, scalar, minMaxState) {
+    polyCurves.max.buildCurve(editorCurves.max, scalar);
+    if (minMaxState != 2 /* kMMCTwoCurves */ && minMaxState != 3 /* kMMCTwoConstants */) {
+      polyCurves.min.buildCurve(editorCurves.max, scalar);
+    } else {
+      polyCurves.min.buildCurve(editorCurves.min, scalar);
+    }
+  }
+  function calculateCurveRangesValue(minMaxValue, curve) {
+    let keyCount = curve.getKeyCount();
+    if (keyCount == 0) {
+      return;
+    }
+    if (keyCount == 1) {
+      calculateMinMax(minMaxValue, curve.getKey(0).value);
+    } else {
+      let segmentCount = keyCount - 1;
+      calculateMinMax(minMaxValue, curve.getKey(0).value);
+      for (let i = 0; i < segmentCount; i++) {
+        let cache = new FrameCache();
+        curve.calculateCacheData(cache, i, i + 1, 0);
+        let a = 3 * cache.coeff[0];
+        let b = 2 * cache.coeff[1];
+        let c = 1 * cache.coeff[2];
+        let start = curve.getKey(i).time;
+        let end = curve.getKey(i + 1).time;
+        let roots = [];
+        let numRoots = quadraticPolynomialRootsGeneric(a, b, c, { r0: roots[0], r1: roots[1] });
+        for (let r = 0; r < numRoots; r++) {
+          if (roots[r] >= 0 && roots[r] + start < end) {
+            calculateMinMax(minMaxValue, Polynomial.EvalSegment(roots[r], cache.coeff));
+          }
+        }
+        calculateMinMax(minMaxValue, Polynomial.EvalSegment(end - start, cache.coeff));
+      }
+    }
+  }
+  function calculateMinMax(minmax, value) {
+    minmax.x = Math.min(minmax.x, value);
+    minmax.y = Math.max(minmax.y, value);
+  }
+
   class PlaneClassification {
     /**
      * @language zh_CN
@@ -58575,282 +61077,6 @@ fn frag(){
     }
   }
 
-  class Polynomials {
-  }
-  function cubicPolynomialRoot(p, q, r) {
-    let rcp3 = 1 / 3;
-    let half = 0.5;
-    let po3 = p * rcp3;
-    let po3_2 = po3 * po3;
-    let po3_3 = po3_2 * po3;
-    let b = po3_3 - po3 * q * half + r * half;
-    let a = -po3_2 + q * rcp3;
-    let a3 = a * a * a;
-    let det = a3 + b * b;
-    if (det >= 0) {
-      let r0 = Math.sqrt(det) - b;
-      r0 = r0 > 0 ? Math.pow(r0, rcp3) : -Math.pow(-r0, rcp3);
-      return -po3 - a / r0 + r0;
-    }
-    let abs = Math.sqrt(-a3);
-    let arg = Math.acos(-b / abs);
-    abs = Math.pow(abs, rcp3);
-    abs = abs - a / abs;
-    arg = -po3 + abs * Math.cos(arg * rcp3);
-    return arg;
-  }
-  function quadraticPolynomialRootsGeneric(a, b, c, out) {
-    let eps = 1e-5;
-    if (Math.abs(a) < eps) {
-      if (Math.abs(b) > eps) {
-        out.r0 = -c / b;
-        return 1;
-      } else {
-        return 0;
-      }
-    }
-    let disc = b * b - 4 * a * c;
-    if (disc < 0) {
-      return 0;
-    }
-    let halfRcpA = 0.5 / a;
-    let sqrtDisc = Math.sqrt(disc);
-    out.r0 = (sqrtDisc - b) * halfRcpA;
-    out.r1 = (-sqrtDisc - b) * halfRcpA;
-    return 2;
-  }
-  function cubicPolynomialRootsGeneric(roots, a, b, c, d) {
-    let numRoots = 0;
-    if (Math.abs(a) >= 1e-4) {
-      let p = b / a;
-      let q = c / a;
-      let r = d / a;
-      roots[0] = cubicPolynomialRoot(p, q, r);
-      numRoots++;
-      let la = a;
-      let lb = b + a * roots[0];
-      let lc = c + b * roots[0] + a * roots[0] * roots[0];
-      numRoots += quadraticPolynomialRootsGeneric(la, lb, lc, {
-        r0: roots[1],
-        r1: roots[2]
-      });
-    } else {
-      numRoots += quadraticPolynomialRootsGeneric(b, c, d, {
-        r0: roots[1],
-        r1: roots[2]
-      });
-    }
-    return numRoots;
-  }
-
-  class Polynomial {
-    coeff = [];
-    static EvalSegment(t, coeff) {
-      return t * (t * (t * coeff[0] + coeff[1]) + coeff[2]) + coeff[3];
-    }
-  }
-  class PolynomialCurve {
-    static kMaxNumSegments = 8;
-    segments = [];
-    integrationCache = [];
-    doubleIntegrationCache = [];
-    times = [];
-    segmentCount;
-    constructor() {
-      this.segments[PolynomialCurve.kMaxNumSegments] = new Polynomial();
-      this.integrationCache[PolynomialCurve.kMaxNumSegments] = 0;
-      this.doubleIntegrationCache[PolynomialCurve.kMaxNumSegments] = 0;
-      this.times[PolynomialCurve.kMaxNumSegments] = 0;
-    }
-    calculateMinMax(minmax, value) {
-      minmax.x = Math.min(minmax.x, value);
-      minmax.y = Math.max(minmax.y, value);
-    }
-    findMinMaxDoubleIntegrated() {
-      let result = Vector2.ZERO.clone();
-      let numSteps = 20;
-      let delta = 1 / numSteps;
-      let acc = delta;
-      for (let i = 0; i < numSteps; i++) {
-        this.calculateMinMax(result, this.evaluateDoubleIntegrated(acc));
-        acc += delta;
-      }
-      return result;
-    }
-    // Find the maximum of the integrated curve (x: min, y: max)
-    findMinMaxIntegrated() {
-      let result = Vector2.ZERO.clone();
-      let start = [];
-      let end = [];
-      for (let i = 0; i < this.segmentCount; i++) {
-        let a = 4 * this.segments[i].coeff[0];
-        let b = 3 * this.segments[i].coeff[1];
-        let c = 2 * this.segments[i].coeff[2];
-        let d = 1 * this.segments[i].coeff[3];
-        let roots = [];
-        let numRoots = cubicPolynomialRootsGeneric(roots, a, b, c, d);
-        for (let r = 0; r < numRoots; r++) {
-          let root = roots[r] + start[i];
-          if (root >= start[i] && root < end[i]) {
-            this.calculateMinMax(result, this.evaluateIntegrated(root));
-          }
-        }
-        this.calculateMinMax(result, this.evaluateIntegrated(end[i]));
-        this.times[i];
-      }
-      return result;
-    }
-    generateIntegrationCache(curve) {
-      curve.integrationCache[0] = 0;
-      let prevTimeValue0 = curve.times[0];
-      let prevTimeValue1 = 0;
-      for (let i = 1; i < curve.segmentCount; i++) {
-        let coeff = curve.segments[i - 1].coeff;
-        integrateSegment(coeff);
-        let time = prevTimeValue0 - prevTimeValue1;
-        curve.integrationCache[i] = curve.integrationCache[i - 1] + Polynomial.EvalSegment(time, coeff) * time;
-        prevTimeValue1 = prevTimeValue0;
-        prevTimeValue0 = curve.times[i];
-      }
-    }
-    generateDoubleIntegrationCache(curve) {
-      let sum = 0;
-      let prevTimeValue = 0;
-      for (let i = 0; i < curve.segmentCount; i++) {
-        curve.doubleIntegrationCache[i] = sum;
-        let time = curve.times[i] - prevTimeValue;
-        time = Math.max(time, 0);
-        sum += Polynomial.EvalSegment(time, curve.segments[i].coeff) * time * time + curve.integrationCache[i] * time;
-        prevTimeValue = curve.times[i];
-      }
-    }
-    // Integrates a velocity curve to be a position curve.
-    // You have to call EvaluateIntegrated to evaluate the curve
-    integrate() {
-      this.generateIntegrationCache(this);
-      for (let i = 0; i < this.segmentCount; i++) {
-        integrateSegment(this.segments[i].coeff);
-      }
-    }
-    // Integrates a velocity curve to be a position curve.
-    // You have to call EvaluateDoubleIntegrated to evaluate the curve
-    doubleIntegrate() {
-      this.generateIntegrationCache(this);
-      for (let i = 0; i < this.segmentCount; i++) {
-        doubleIntegrateSegment(this.segments[i].coeff);
-      }
-      this.generateDoubleIntegrationCache(this);
-    }
-    // Evaluates if it is possible to represent animation curve as PolynomialCurve
-    static isValidCurve(editorCurve) {
-      let keyCount = editorCurve.getKeyCount();
-      let segmentCount = keyCount - 1;
-      if (editorCurve.getKey(0).time != 0) {
-        segmentCount++;
-      }
-      if (editorCurve.getKey(keyCount - 1).time != 1) {
-        segmentCount++;
-      }
-      return segmentCount <= PolynomialCurve.kMaxNumSegments;
-    }
-    evaluateDoubleIntegrated(t) {
-      let prevTimeValue = 0;
-      for (let i = 0; i < this.segmentCount; i++) {
-        if (t <= this.times[i]) {
-          let time = t - prevTimeValue;
-          return this.doubleIntegrationCache[i] + this.integrationCache[i] * time + Polynomial.EvalSegment(time, this.segments[i].coeff) * time * time;
-        }
-        prevTimeValue = this.times[i];
-      }
-      return 1;
-    }
-    // Evaluate integrated Polynomial curve.
-    // Example: position = EvaluateIntegrated (normalizedTime) * startEnergy
-    // Use Integrate function to for example turn a velocity curve into a position curve.
-    // Expects that t is in the 0...1 range.
-    evaluateIntegrated(t) {
-      let prevTimeValue = 0;
-      for (let i = 0; i < this.segmentCount; i++) {
-        if (t <= this.times[i]) {
-          let time = t - prevTimeValue;
-          return this.integrationCache[i] + Polynomial.EvalSegment(time, this.segments[i].coeff) * time;
-        }
-        prevTimeValue = this.times[i];
-      }
-      return 1;
-    }
-    // Evaluate the curve
-    // extects that t is in the 0...1 range
-    evaluate(t) {
-      let prevTimeValue = 0;
-      for (let i = 0; i < this.segmentCount; i++) {
-        if (t <= this.times[i]) {
-          return Polynomial.EvalSegment(
-            t - prevTimeValue,
-            this.segments[i].coeff
-          );
-        }
-        prevTimeValue = this.times[i];
-      }
-      return 1;
-    }
-    buildCurve(editorCurve, scale) {
-      let keyCount = editorCurve.getKeyCount();
-      this.segmentCount = 1;
-      let kMaxTime = 1.01;
-      this.segments.length = 0;
-      this.integrationCache.length = 0;
-      this.doubleIntegrationCache.length = 0;
-      this.times.length = 0;
-      this.times[0] = kMaxTime;
-      if (keyCount == 0) ; else if (keyCount == 1) {
-        this.segments[0] = new Polynomial();
-        this.segments[0].coeff[3] = editorCurve.getKey(0).value * scale;
-      } else {
-        this.segmentCount = keyCount - 1;
-        let segmentOffset = 0;
-        if (editorCurve.getKey(0).time != 0) {
-          this.segments[0].coeff[3] = editorCurve.getKey(0).value;
-          this.times[0] = editorCurve.getKey(0).time;
-          segmentOffset = 1;
-        }
-        for (let i = 0; i < this.segmentCount; i++) {
-          let cache;
-          editorCurve.calculateCacheData(cache, i, i + 1, 0);
-          this.segments[i + segmentOffset].coeff = cache.coeff.concat();
-          this.times[i + segmentOffset] = editorCurve.getKey(i + 1).time;
-        }
-        this.segmentCount += segmentOffset;
-        if (editorCurve.getKey(keyCount - 1).time != 1) {
-          this.segments[this.segmentCount].coeff[3] = editorCurve.getKey(
-            keyCount - 1
-          ).value;
-          this.segmentCount++;
-        }
-        this.times[this.segmentCount - 1] = kMaxTime;
-        for (let i = 0; i < this.segmentCount; i++) {
-          this.segments[i].coeff[0] *= scale;
-          this.segments[i].coeff[1] *= scale;
-          this.segments[i].coeff[2] *= scale;
-          this.segments[i].coeff[3] *= scale;
-        }
-      }
-      return true;
-    }
-  }
-  function doubleIntegrateSegment(coeff) {
-    coeff[0] /= 20;
-    coeff[1] /= 12;
-    coeff[2] /= 6;
-    coeff[3] /= 2;
-  }
-  function integrateSegment(coeff) {
-    coeff[0] /= 4;
-    coeff[1] /= 3;
-    coeff[2] /= 2;
-    coeff[3] /= 1;
-  }
-
   function uniform_real_distribution(min, max) {
     return Math.random() * max + Math.random() * min + (max - min) * Math.random();
   }
@@ -61831,86 +64057,6 @@ fn frag(){
     }
   }
 
-  class Float16ArrayTexture extends Texture {
-    uint16Array;
-    floatArray;
-    _dataBuffer;
-    /**
-     * 使用数字数组填充纹理，格式为[红0, 绿0, 蓝0, 透明度0, 红1, 绿1, 蓝1, 透明度1...]
-     * @param width 纹理宽度
-     * @param height 纹理高度
-     * @param numbers 每个像素的颜色值数组
-     * @param useMipmap 是否生成Mipmap
-     * @returns 返回纹理实例
-     */
-    create(width, height, numbers = null, mipmap = true) {
-      if (numbers == null) {
-        numbers = [];
-        for (let i = 0, c = width * height * 4; i < c; i++) {
-          numbers[i] = 0;
-        }
-      }
-      this.updateTexture(width, height, numbers, mipmap);
-      return this;
-    }
-    /**
-     * 更新纹理内容
-     * @param width 纹理宽度
-     * @param height 纹理高度
-     * @param numbers 像素数据数组
-     * @param mipmap 是否生成Mipmap
-     */
-    updateTexture(width, height, numbers, mipmap = true) {
-      if (width != this.width || height != this.height) {
-        this._dataBuffer && this._dataBuffer.destroy();
-        this._dataBuffer = null;
-        this.gpuTexture && this.gpuTexture.destroy();
-        this.gpuTexture = null;
-      }
-      this.floatArray = numbers;
-      let device = webGPUContext.device;
-      const bytesPerRow = width * 4 * 2;
-      this.format = GPUTextureFormat.rgba16float;
-      this.mipmapCount = Math.floor(mipmap ? Math.log2(width) : 1);
-      this.createTextureDescriptor(width, height, this.mipmapCount, this.format);
-      if (!this.uint16Array || this.uint16Array.length != numbers.length) {
-        this.uint16Array = new Uint16Array(numbers.length);
-      }
-      let uint16Array = this.uint16Array;
-      for (let i = 0, c = uint16Array.length; i < c; i++) {
-        uint16Array[i] = toHalfFloat(numbers[i]);
-      }
-      const textureDataBuffer = this._dataBuffer = device.createBuffer({
-        size: uint16Array.byteLength,
-        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
-      });
-      device.queue.writeBuffer(textureDataBuffer, 0, uint16Array);
-      const commandEncoder = GPUContext.beginCommandEncoder();
-      commandEncoder.copyBufferToTexture(
-        {
-          buffer: textureDataBuffer,
-          bytesPerRow
-        },
-        {
-          texture: this.getGPUTexture()
-        },
-        {
-          width,
-          height,
-          depthOrArrayLayers: 1
-        }
-      );
-      if (!this.useMipmap) {
-        this.samplerBindingLayout.type = `filtering`;
-        this.textureBindingLayout.sampleType = `float`;
-      }
-      GPUContext.endCommandEncoder(commandEncoder);
-      this.gpuSampler = device.createSampler(this);
-      this.gpuTexture = this.getGPUTexture();
-      if (this.mipmapCount > 1) TextureMipmapGenerator.webGPUGenerateMipmap(this);
-    }
-  }
-
   class Float32ArrayTexture extends Texture {
     create(width, height, data, filtering = true) {
       let device = webGPUContext.device;
@@ -63547,6 +65693,10 @@ fn frag(){
   exports.GPUTextureFormat = GPUTextureFormat;
   exports.GPUVertexFormat = GPUVertexFormat;
   exports.GPUVertexStepMode = GPUVertexStepMode;
+  exports.GSplatFormat = GSplatFormat;
+  exports.GSplatMaterial = GSplatMaterial;
+  exports.GSplat_FS = GSplat_FS;
+  exports.GSplat_VS = GSplat_VS;
   exports.GTAOPost = GTAOPost;
   exports.GTAO_cs = GTAO_cs;
   exports.GUIAtlasTexture = GUIAtlasTexture;
@@ -63565,6 +65715,7 @@ fn frag(){
   exports.GUISpace = GUISpace;
   exports.GUISprite = GUISprite;
   exports.GUITexture = GUITexture;
+  exports.GaussianSplatParser = GaussianSplatParser;
   exports.GenerayRandomDir = GenerayRandomDir;
   exports.GeoJsonParser = GeoJsonParser;
   exports.GeoJsonUtil = GeoJsonUtil;
@@ -63633,6 +65784,7 @@ fn frag(){
   exports.KHR_materials_emissive_strength = KHR_materials_emissive_strength;
   exports.KHR_materials_ior = KHR_materials_ior;
   exports.KHR_materials_unlit = KHR_materials_unlit;
+  exports.KMZParser = KMZParser;
   exports.KV = KV;
   exports.KelvinUtil = KelvinUtil;
   exports.KeyCode = KeyCode;
@@ -63672,6 +65824,10 @@ fn frag(){
   exports.MergeRGBACreator = MergeRGBACreator;
   exports.MergeRGBA_cs = MergeRGBA_cs;
   exports.MeshColliderShape = MeshColliderShape;
+  exports.MinMaxAnimationCurves = MinMaxAnimationCurves;
+  exports.MinMaxCurve = MinMaxCurve;
+  exports.MinMaxCurveState = MinMaxCurveState;
+  exports.MinMaxPolyCurves = MinMaxPolyCurves;
   exports.MorePassParser = MorePassParser;
   exports.MorePassShader = MorePassShader;
   exports.MorphTargetBlender = MorphTargetBlender;
@@ -63719,6 +65875,8 @@ fn frag(){
   exports.PBRLitSSSShader = PBRLitSSSShader;
   exports.ParserBase = ParserBase;
   exports.ParserFormat = ParserFormat;
+  exports.ParticleSystemCurveEvalMode = ParticleSystemCurveEvalMode;
+  exports.ParticleSystemRandomnessIds = ParticleSystemRandomnessIds;
   exports.PassGenerate = PassGenerate;
   exports.PassShader = PassShader;
   exports.PassType = PassType;
@@ -63952,6 +66110,7 @@ fn frag(){
   exports.UITransform = UITransform;
   exports.UUID = UUID;
   exports.UV = UV;
+  exports.Uint32ArrayTexture = Uint32ArrayTexture;
   exports.Uint8ArrayTexture = Uint8ArrayTexture;
   exports.UnLit = UnLit;
   exports.UnLitMaterial = UnLitMaterial;
@@ -63965,6 +66124,7 @@ fn frag(){
   exports.ValueEnumType = ValueEnumType;
   exports.ValueOp = ValueOp;
   exports.ValueParser = ValueParser;
+  exports.ValueSpread = ValueSpread;
   exports.Vector2 = Vector2;
   exports.Vector3 = Vector3;
   exports.Vector3Ex = Vector3Ex;
@@ -63985,6 +66145,8 @@ fn frag(){
   exports.ViewQuad = ViewQuad;
   exports.VirtualTexture = VirtualTexture;
   exports.WGSLTranslator = WGSLTranslator;
+  exports.WayLines3D = WayLines3D;
+  exports.WayPoint3D = WayPoint3D;
   exports.WebGPUDescriptorCreator = WebGPUDescriptorCreator;
   exports.WorldMatrixUniform = WorldMatrixUniform;
   exports.WorldPanel = WorldPanel;
@@ -63998,14 +66160,21 @@ fn frag(){
   exports.append = append;
   exports.arrayToString = arrayToString;
   exports.blendComponent = blendComponent;
+  exports.buildCurves = buildCurves;
+  exports.byteSizeOfType = byteSizeOfType;
+  exports.calculateCurveRangesValue = calculateCurveRangesValue;
+  exports.calculateMinMax = calculateMinMax;
   exports.castPointShadowMap_vert = castPointShadowMap_vert;
   exports.clamp = clamp;
   exports.clampRepeat = clampRepeat;
+  exports.computeAABBFromPositions = computeAABBFromPositions;
   exports.cos = cos;
   exports.crossProduct = crossProduct;
   exports.cubicPolynomialRoot = cubicPolynomialRoot;
   exports.cubicPolynomialRootsGeneric = cubicPolynomialRootsGeneric;
+  exports.curvesSupportProcedural = curvesSupportProcedural;
   exports.deg2Rad = deg2Rad;
+  exports.detectGSplatFormat = detectGSplatFormat;
   exports.directionShadowCastMap_frag = directionShadowCastMap_frag;
   exports.dot = dot;
   exports.doubleIntegrateSegment = doubleIntegrateSegment;
@@ -64025,8 +66194,10 @@ fn frag(){
   exports.grad2 = grad2;
   exports.grad3 = grad3;
   exports.grad4 = grad4;
+  exports.inferSHOrder = inferSHOrder;
   exports.integrateSegment = integrateSegment;
   exports.irradianceDataReader = irradianceDataReader;
+  exports.kPI = kPI;
   exports.lerp = lerp;
   exports.lerpByte = lerpByte;
   exports.lerpColor = lerpColor;
@@ -64047,6 +66218,8 @@ fn frag(){
   exports.normalizedToWord = normalizedToWord;
   exports.outlinePostData = outlinePostData;
   exports.outlinePostManager = outlinePostManager;
+  exports.parsePlyGaussianSplat = parsePlyGaussianSplat;
+  exports.parsePlyHeader = parsePlyHeader;
   exports.perm = perm;
   exports.post = post;
   exports.quadraticPolynomialRootsGeneric = quadraticPolynomialRootsGeneric;
@@ -64065,6 +66238,7 @@ fn frag(){
   exports.randomUnitVector2 = randomUnitVector2;
   exports.rangedRandomFloat = rangedRandomFloat;
   exports.rangedRandomInt = rangedRandomInt;
+  exports.readByType = readByType;
   exports.readMagicBytes = readMagicBytes;
   exports.registerMaterial = registerMaterial;
   exports.repeat = repeat;