@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/rings.es.max.js

@@ -2088,11 +2088,7 @@ function RegisterComponent(cls, key, p1, p2, p3) {
   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__"];
@@ -2106,11 +2102,7 @@ function RegisterShader(cls, key, p1, p2, p3) {
   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__"];
@@ -2121,7 +2113,7 @@ function GetShader(name) {
 }
 
 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])
@@ -2132,6 +2124,10 @@ var __decorateClass$i = (decorators, target, key, kind) => {
 const _Struct = class _Struct {
   __refection;
   __size = 0;
+  /**
+   * get reflection name
+   * @returns
+   */
   getValueType() {
     if (!this.__refection) {
       let self = this;
@@ -2149,6 +2145,11 @@ const _Struct = class _Struct {
     }
     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) {
@@ -2195,6 +2196,10 @@ const _Struct = class _Struct {
     }
     return struct;
   }
+  /**
+   * get any struct memory size
+   * @returns
+   */
   static GetSize(c) {
     let struct = this.Get(c);
     if (struct.__size == 0) {
@@ -2211,10 +2216,10 @@ const _Struct = class _Struct {
     return struct.__size;
   }
 };
-__decorateClass$i([
+__decorateClass$j([
   NonSerialize
 ], _Struct.prototype, "__refection");
-__decorateClass$i([
+__decorateClass$j([
   NonSerialize
 ], _Struct.prototype, "__size");
 let Struct = _Struct;
@@ -11821,6 +11826,21 @@ class Matrix4 {
     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
@@ -16470,9 +16490,9 @@ class Entity extends CEventDispatcher {
   }
 }
 
-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;
@@ -16737,7 +16757,7 @@ let Object3D = class extends Entity {
     super.destroy(force);
   }
 };
-Object3D = __decorateClass$h([
+Object3D = __decorateClass$i([
   DecorateObject3D
 ], Object3D);
 function DecorateObject3D(ctor, _) {
@@ -22389,7 +22409,7 @@ class Reference {
   }
   /**
    * current instance attached from parent instance
-   * @param ref reference current
+   * @param ref reference current 
    * @param target reference parent
    */
   attached(ref, target) {
@@ -22401,7 +22421,7 @@ class Reference {
   }
   /**
    * current instance detached from parent instance
-   * @param ref reference current
+   * @param ref reference current 
    * @param target reference parent
    */
   detached(ref, target) {
@@ -22411,7 +22431,7 @@ class Reference {
     }
   }
   /**
-   * current instance has reference
+   * current instance has reference 
    */
   hasReference(ref) {
     let refMap = this.reference.get(ref);
@@ -22422,8 +22442,8 @@ class Reference {
   }
   /**
    * get current instance reference count
-   * @param ref
-   * @returns
+   * @param ref 
+   * @returns 
    */
   getReferenceCount(ref) {
     let refMap = this.reference.get(ref);
@@ -22433,10 +22453,10 @@ class Reference {
     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) {
@@ -23515,9 +23535,9 @@ class OctreeEntity {
 }
 
 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;
@@ -24102,20 +24122,20 @@ class RenderNode extends ComponentBase {
     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;
@@ -24224,13 +24244,13 @@ let MeshRenderer = class extends RenderNode {
     super.destroy(force);
   }
 };
-__decorateClass$f([
+__decorateClass$g([
   EditorInspector
 ], MeshRenderer.prototype, "geometry", 1);
-__decorateClass$f([
+__decorateClass$g([
   EditorInspector
 ], MeshRenderer.prototype, "material", 1);
-MeshRenderer = __decorateClass$f([
+MeshRenderer = __decorateClass$g([
   RegisterComponent(MeshRenderer, "MeshRenderer")
 ], MeshRenderer);
 
@@ -25068,8 +25088,7 @@ class GeometryIndicesBuffer {
     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() {
@@ -25082,6 +25101,22 @@ class GeometryIndicesBuffer {
     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 {
@@ -25864,9 +25899,9 @@ class Shader {
   }
 }
 
-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;
@@ -25890,8 +25925,8 @@ let QuadShader = class extends Shader {
     this.setUniformFloat(`height`, 100);
   }
 };
-QuadShader = __decorateClass$e([
-  RegisterShader
+QuadShader = __decorateClass$f([
+  RegisterShader(QuadShader, "QuadShader")
 ], QuadShader);
 
 class ViewQuad extends Object3D {
@@ -31300,6 +31335,7 @@ class FileLoader extends LoaderBase {
             parser.userData = userData;
             parser.baseUrl = this.baseUrl;
             parser.initUrl = url;
+            parser.loaderFunctions = loaderFunctions;
             await parser.parseBuffer(data);
             if (parser.verification()) {
               succ(parser);
@@ -33163,9 +33199,9 @@ class LightBase extends ComponentBase {
   }
 }
 
-var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
-var __decorateClass$d = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
+var __getOwnPropDesc$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;
@@ -33207,13 +33243,13 @@ let DirectLight = class extends LightBase {
   debug() {
   }
 };
-DirectLight = __decorateClass$d([
+DirectLight = __decorateClass$e([
   RegisterComponent(DirectLight, "DirectLight")
 ], DirectLight);
 
-var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
-var __decorateClass$c = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
+var __getOwnPropDesc$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;
@@ -33271,13 +33307,13 @@ let PointLight = class extends LightBase {
   debugDraw(show) {
   }
 };
-PointLight = __decorateClass$c([
+PointLight = __decorateClass$d([
   RegisterComponent(PointLight, "PointLight")
 ], PointLight);
 
-var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
-var __decorateClass$b = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
+var __getOwnPropDesc$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;
@@ -33342,7 +33378,7 @@ let SpotLight = class extends LightBase {
   debugDraw(show) {
   }
 };
-SpotLight = __decorateClass$b([
+SpotLight = __decorateClass$c([
   RegisterComponent(SpotLight, "SpotLight")
 ], SpotLight);
 
@@ -37987,6 +38023,826 @@ class AtlasParser extends ParserBase {
   }
 }
 
+// DEFLATE is a complex format; to read this code, you should probably check the RFC first:
+// https://tools.ietf.org/html/rfc1951
+// You may also wish to take a look at the guide I made about this program:
+// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
+// Some of the following code is similar to that of UZIP.js:
+// https://github.com/photopea/UZIP.js
+// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
+// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
+// is better for memory in most engines (I *think*).
+
+// aliases for shorter compressed code (most minifers don't do this)
+var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+// fixed length extra bits
+var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
+// fixed distance extra bits
+var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
+// code length index map
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+// get base, reverse index map from extra bits
+var freb = function (eb, start) {
+    var b = new u16(31);
+    for (var i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
+    }
+    // numbers here are at max 18 bits
+    var r = new i32(b[30]);
+    for (var i = 1; i < 30; ++i) {
+        for (var j = b[i]; j < b[i + 1]; ++j) {
+            r[j] = ((j - b[i]) << 5) | i;
+        }
+    }
+    return { b: b, r: r };
+};
+var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
+// we can ignore the fact that the other numbers are wrong; they never happen anyway
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0), fd = _b.b;
+// map of value to reverse (assuming 16 bits)
+var rev = new u16(32768);
+for (var i = 0; i < 32768; ++i) {
+    // reverse table algorithm from SO
+    var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
+    x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
+    x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
+    rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
+}
+// create huffman tree from u8 "map": index -> code length for code index
+// mb (max bits) must be at most 15
+// TODO: optimize/split up?
+var hMap = (function (cd, mb, r) {
+    var s = cd.length;
+    // index
+    var i = 0;
+    // u16 "map": index -> # of codes with bit length = index
+    var l = new u16(mb);
+    // length of cd must be 288 (total # of codes)
+    for (; i < s; ++i) {
+        if (cd[i])
+            ++l[cd[i] - 1];
+    }
+    // u16 "map": index -> minimum code for bit length = index
+    var le = new u16(mb);
+    for (i = 1; i < mb; ++i) {
+        le[i] = (le[i - 1] + l[i - 1]) << 1;
+    }
+    var co;
+    if (r) {
+        // u16 "map": index -> number of actual bits, symbol for code
+        co = new u16(1 << mb);
+        // bits to remove for reverser
+        var rvb = 15 - mb;
+        for (i = 0; i < s; ++i) {
+            // ignore 0 lengths
+            if (cd[i]) {
+                // num encoding both symbol and bits read
+                var sv = (i << 4) | cd[i];
+                // free bits
+                var r_1 = mb - cd[i];
+                // start value
+                var v = le[cd[i] - 1]++ << r_1;
+                // m is end value
+                for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                    // every 16 bit value starting with the code yields the same result
+                    co[rev[v] >> rvb] = sv;
+                }
+            }
+        }
+    }
+    else {
+        co = new u16(s);
+        for (i = 0; i < s; ++i) {
+            if (cd[i]) {
+                co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
+            }
+        }
+    }
+    return co;
+});
+// fixed length tree
+var flt = new u8(288);
+for (var i = 0; i < 144; ++i)
+    flt[i] = 8;
+for (var i = 144; i < 256; ++i)
+    flt[i] = 9;
+for (var i = 256; i < 280; ++i)
+    flt[i] = 7;
+for (var i = 280; i < 288; ++i)
+    flt[i] = 8;
+// fixed distance tree
+var fdt = new u8(32);
+for (var i = 0; i < 32; ++i)
+    fdt[i] = 5;
+// fixed length map
+var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+// fixed distance map
+var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+// find max of array
+var max = function (a) {
+    var m = a[0];
+    for (var i = 1; i < a.length; ++i) {
+        if (a[i] > m)
+            m = a[i];
+    }
+    return m;
+};
+// read d, starting at bit p and mask with m
+var bits = function (d, p, m) {
+    var o = (p / 8) | 0;
+    return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;
+};
+// read d, starting at bit p continuing for at least 16 bits
+var bits16 = function (d, p) {
+    var o = (p / 8) | 0;
+    return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));
+};
+// get end of byte
+var shft = function (p) { return ((p + 7) / 8) | 0; };
+// typed array slice - allows garbage collector to free original reference,
+// while being more compatible than .slice
+var slc = function (v, s, e) {
+    if (s == null || s < 0)
+        s = 0;
+    if (e == null || e > v.length)
+        e = v.length;
+    // can't use .constructor in case user-supplied
+    return new u8(v.subarray(s, e));
+};
+// error codes
+var ec = [
+    'unexpected EOF',
+    'invalid block type',
+    'invalid length/literal',
+    'invalid distance',
+    'stream finished',
+    'no stream handler',
+    ,
+    'no callback',
+    'invalid UTF-8 data',
+    'extra field too long',
+    'date not in range 1980-2099',
+    'filename too long',
+    'stream finishing',
+    'invalid zip data'
+    // determined by unknown compression method
+];
+var err = function (ind, msg, nt) {
+    var e = new Error(msg || ec[ind]);
+    e.code = ind;
+    if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+    if (!nt)
+        throw e;
+    return e;
+};
+// expands raw DEFLATE data
+var inflt = function (dat, st, buf, dict) {
+    // source length       dict length
+    var sl = dat.length, dl = dict ? dict.length : 0;
+    if (!sl || st.f && !st.l)
+        return buf || new u8(0);
+    var noBuf = !buf;
+    // have to estimate size
+    var resize = noBuf || st.i != 2;
+    // no state
+    var noSt = st.i;
+    // Assumes roughly 33% compression ratio average
+    if (noBuf)
+        buf = new u8(sl * 3);
+    // ensure buffer can fit at least l elements
+    var cbuf = function (l) {
+        var bl = buf.length;
+        // need to increase size to fit
+        if (l > bl) {
+            // Double or set to necessary, whichever is greater
+            var nbuf = new u8(Math.max(bl * 2, l));
+            nbuf.set(buf);
+            buf = nbuf;
+        }
+    };
+    //  last chunk         bitpos           bytes
+    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+    // total bits
+    var tbts = sl * 8;
+    do {
+        if (!lm) {
+            // BFINAL - this is only 1 when last chunk is next
+            final = bits(dat, pos, 1);
+            // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
+            var type = bits(dat, pos + 1, 3);
+            pos += 3;
+            if (!type) {
+                // go to end of byte boundary
+                var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                if (t > sl) {
+                    if (noSt)
+                        err(0);
+                    break;
+                }
+                // ensure size
+                if (resize)
+                    cbuf(bt + l);
+                // Copy over uncompressed data
+                buf.set(dat.subarray(s, t), bt);
+                // Get new bitpos, update byte count
+                st.b = bt += l, st.p = pos = t * 8, st.f = final;
+                continue;
+            }
+            else if (type == 1)
+                lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+            else if (type == 2) {
+                //  literal                            lengths
+                var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                var tl = hLit + bits(dat, pos + 5, 31) + 1;
+                pos += 14;
+                // length+distance tree
+                var ldt = new u8(tl);
+                // code length tree
+                var clt = new u8(19);
+                for (var i = 0; i < hcLen; ++i) {
+                    // use index map to get real code
+                    clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                }
+                pos += hcLen * 3;
+                // code lengths bits
+                var clb = max(clt), clbmsk = (1 << clb) - 1;
+                // code lengths map
+                var clm = hMap(clt, clb, 1);
+                for (var i = 0; i < tl;) {
+                    var r = clm[bits(dat, pos, clbmsk)];
+                    // bits read
+                    pos += r & 15;
+                    // symbol
+                    var s = r >> 4;
+                    // code length to copy
+                    if (s < 16) {
+                        ldt[i++] = s;
+                    }
+                    else {
+                        //  copy   count
+                        var c = 0, n = 0;
+                        if (s == 16)
+                            n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                        else if (s == 17)
+                            n = 3 + bits(dat, pos, 7), pos += 3;
+                        else if (s == 18)
+                            n = 11 + bits(dat, pos, 127), pos += 7;
+                        while (n--)
+                            ldt[i++] = c;
+                    }
+                }
+                //    length tree                 distance tree
+                var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                // max length bits
+                lbt = max(lt);
+                // max dist bits
+                dbt = max(dt);
+                lm = hMap(lt, lbt, 1);
+                dm = hMap(dt, dbt, 1);
+            }
+            else
+                err(1);
+            if (pos > tbts) {
+                if (noSt)
+                    err(0);
+                break;
+            }
+        }
+        // Make sure the buffer can hold this + the largest possible addition
+        // Maximum chunk size (practically, theoretically infinite) is 2^17
+        if (resize)
+            cbuf(bt + 131072);
+        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        var lpos = pos;
+        for (;; lpos = pos) {
+            // bits read, code
+            var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+            pos += c & 15;
+            if (pos > tbts) {
+                if (noSt)
+                    err(0);
+                break;
+            }
+            if (!c)
+                err(2);
+            if (sym < 256)
+                buf[bt++] = sym;
+            else if (sym == 256) {
+                lpos = pos, lm = null;
+                break;
+            }
+            else {
+                var add = sym - 254;
+                // no extra bits needed if less
+                if (sym > 264) {
+                    // index
+                    var i = sym - 257, b = fleb[i];
+                    add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                    pos += b;
+                }
+                // dist
+                var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+                if (!d)
+                    err(3);
+                pos += d & 15;
+                var dt = fd[dsym];
+                if (dsym > 3) {
+                    var b = fdeb[dsym];
+                    dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+                }
+                if (pos > tbts) {
+                    if (noSt)
+                        err(0);
+                    break;
+                }
+                if (resize)
+                    cbuf(bt + 131072);
+                var end = bt + add;
+                if (bt < dt) {
+                    var shift = dl - dt, dend = Math.min(dt, end);
+                    if (shift + bt < 0)
+                        err(3);
+                    for (; bt < dend; ++bt)
+                        buf[bt] = dict[shift + bt];
+                }
+                for (; bt < end; ++bt)
+                    buf[bt] = buf[bt - dt];
+            }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm)
+            final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+    } while (!final);
+    // don't reallocate for streams or user buffers
+    return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+// empty
+var et = /*#__PURE__*/ new u8(0);
+// read 2 bytes
+var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };
+// read 4 bytes
+var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };
+var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };
+/**
+ * Expands DEFLATE data with no wrapper
+ * @param data The data to decompress
+ * @param opts The decompression options
+ * @returns The decompressed version of the data
+ */
+function inflateSync(data, opts) {
+    return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+// text decoder
+var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
+// text decoder stream
+var tds = 0;
+try {
+    td.decode(et, { stream: true });
+    tds = 1;
+}
+catch (e) { }
+// decode UTF8
+var dutf8 = function (d) {
+    for (var r = '', i = 0;;) {
+        var c = d[i++];
+        var eb = (c > 127) + (c > 223) + (c > 239);
+        if (i + eb > d.length)
+            return { s: r, r: slc(d, i - 1) };
+        if (!eb)
+            r += String.fromCharCode(c);
+        else if (eb == 3) {
+            c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536,
+                r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));
+        }
+        else if (eb & 1)
+            r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63));
+        else
+            r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63));
+    }
+};
+/**
+ * Converts a Uint8Array to a string
+ * @param dat The data to decode to string
+ * @param latin1 Whether or not to interpret the data as Latin-1. This should
+ *               not need to be true unless encoding to binary string.
+ * @returns The original UTF-8/Latin-1 string
+ */
+function strFromU8(dat, latin1) {
+    if (latin1) {
+        var r = '';
+        for (var i = 0; i < dat.length; i += 16384)
+            r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+        return r;
+    }
+    else if (td) {
+        return td.decode(dat);
+    }
+    else {
+        var _a = dutf8(dat), s = _a.s, r = _a.r;
+        if (r.length)
+            err(8);
+        return s;
+    }
+}
+// skip local zip header
+var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };
+// read zip header
+var zh = function (d, b, z) {
+    var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
+    var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];
+    return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
+};
+// read zip64 extra field
+var z64e = function (d, b) {
+    for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
+        ;
+    return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+};
+/**
+ * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
+ * performance with more than one file.
+ * @param data The raw compressed ZIP file
+ * @param opts The ZIP extraction options
+ * @returns The decompressed files
+ */
+function unzipSync(data, opts) {
+    var files = {};
+    var e = data.length - 22;
+    for (; b4(data, e) != 0x6054B50; --e) {
+        if (!e || data.length - e > 65558)
+            err(13);
+    }
+    var c = b2(data, e + 8);
+    if (!c)
+        return {};
+    var o = b4(data, e + 16);
+    var z = o == 4294967295 || c == 65535;
+    if (z) {
+        var ze = b4(data, e - 12);
+        z = b4(data, ze) == 0x6064B50;
+        if (z) {
+            c = b4(data, ze + 32);
+            o = b4(data, ze + 48);
+        }
+    }
+    for (var i = 0; i < c; ++i) {
+        var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
+        o = no;
+        {
+            if (!c_2)
+                files[fn] = slc(data, b, b + sc);
+            else if (c_2 == 8)
+                files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+            else
+                err(14, 'unknown compression type ' + c_2);
+        }
+    }
+    return files;
+}
+
+class UnLitMaterial extends Material {
+  /**
+   * @constructor
+   */
+  constructor() {
+    super();
+    this.shader = new 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 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 Object3D();
+      const markerRenderer = this.marker.addComponent(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 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 Object3D();
+    const lineRenderer = lineObject.addComponent(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;
@@ -38216,6 +39072,11 @@ class Res {
     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;
@@ -38409,7 +39270,7 @@ class PostProcessingComponent extends ComponentBase {
   }
 }
 
-const version = "1.0.1";
+const version = "1.0.4";
 
 class Engine3D {
   /**
@@ -41718,6 +42579,267 @@ let GIProbeShader = (
 `
 );
 
+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 */
   `
@@ -42858,14 +43980,16 @@ class AtmosphericScatteringSky extends LDRTextureCube {
   _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;
@@ -42873,6 +43997,10 @@ class AtmosphericScatteringSky extends LDRTextureCube {
   get texture2D() {
     return this._internalTexture;
   }
+  /**
+   * @internal
+   * @returns
+   */
   apply() {
     this._internalTexture.update(this.setting);
     this._faceData.uploadErpTexture(this._internalTexture);
@@ -42883,13 +44011,7 @@ class AtmosphericTexture2D extends VirtualTexture {
   _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) {
@@ -42922,9 +44044,9 @@ class AtmosphericTexture2D extends VirtualTexture {
   }
 }
 
-var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
-var __decorateClass$a = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
+var __getOwnPropDesc$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;
@@ -42948,8 +44070,8 @@ let SkyShader = class extends Shader {
     shaderState.depthCompare = GPUCompareFunction.less;
   }
 };
-SkyShader = __decorateClass$a([
-  RegisterShader
+SkyShader = __decorateClass$b([
+  RegisterShader(SkyShader, "SkyShader")
 ], SkyShader);
 
 class SkyMaterial extends Material {
@@ -42993,113 +44115,6 @@ class SkyMaterial extends Material {
   }
 }
 
-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;
@@ -43853,9 +44868,9 @@ class SkeletonAnimationClipState {
   }
 }
 
-var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
-var __decorateClass$9 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
+var __getOwnPropDesc$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;
@@ -44059,7 +45074,7 @@ let SkeletonAnimationComponent = class extends ComponentBase {
     this._currentClipState.weight = 1;
   }
 };
-SkeletonAnimationComponent = __decorateClass$9([
+SkeletonAnimationComponent = __decorateClass$a([
   RegisterComponent(SkeletonAnimationComponent, "SkeletonAnimationComponent")
 ], SkeletonAnimationComponent);
 class SkeletonAnimationCrossFadeState {
@@ -44095,9 +45110,9 @@ class SkeletonAnimationCrossFadeState {
   }
 }
 
-var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
-var __decorateClass$8 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+var __getOwnPropDesc$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;
@@ -44508,7 +45523,7 @@ let AnimatorComponent = class extends ComponentBase {
     return dst;
   }
 };
-AnimatorComponent = __decorateClass$8([
+AnimatorComponent = __decorateClass$9([
   RegisterComponent(AnimatorComponent, "AnimatorComponent")
 ], AnimatorComponent);
 class PropertyAnimationClipState {
@@ -45265,9 +46280,9 @@ class PropertyAnimation extends ComponentBase {
   }
 }
 
-var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
-var __decorateClass$7 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+var __getOwnPropDesc$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;
@@ -45416,7 +46431,7 @@ let SkinnedMeshRenderer2 = class extends MeshRenderer {
     super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
   }
 };
-SkinnedMeshRenderer2 = __decorateClass$7([
+SkinnedMeshRenderer2 = __decorateClass$8([
   RegisterComponent(SkinnedMeshRenderer2, "SkinnedMeshRenderer2")
 ], SkinnedMeshRenderer2);
 
@@ -50546,9 +51561,9 @@ class UITextField extends UIRenderAble {
   }
 }
 
-var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
-var __decorateClass$6 = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+var __getOwnPropDesc$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;
@@ -50625,10 +51640,802 @@ let Light = class extends LightBase {
   debugDraw(show) {
   }
 };
-Light = __decorateClass$6([
+Light = __decorateClass$7([
   RegisterComponent(Light, "Light")
 ], 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;
+};
+let GSplatRenderer = class 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);
+  }
+};
+GSplatRenderer = __decorateClass$6([
+  RegisterComponent(GSplatRenderer, "GSplatRenderer")
+], GSplatRenderer);
+
 class Probe extends Object3D {
   index = 0;
   drawCallFrame = -1;
@@ -55884,6 +57691,298 @@ class LoaderManager extends CEventDispatcher {
   }
 }
 
+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";
@@ -57015,7 +59114,7 @@ let LitSSSShader = class extends Shader {
   }
 };
 LitSSSShader = __decorateClass$3([
-  RegisterShader
+  RegisterShader(LitSSSShader, "LitSSSShader")
 ], LitSSSShader);
 
 var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
@@ -57117,7 +59216,7 @@ let LitShader = class extends Shader {
   }
 };
 LitShader = __decorateClass$2([
-  RegisterShader
+  RegisterShader(LitShader, "LitShader")
 ], LitShader);
 
 class ComData {
@@ -57353,7 +59452,7 @@ let UnLitShader = class extends Shader {
   }
 };
 UnLitShader = __decorateClass$1([
-  RegisterShader
+  RegisterShader(UnLitShader, "UnLitShader")
 ], UnLitShader);
 
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -57442,7 +59541,7 @@ let UnLitTexArrayShader = class extends Shader {
   }
 };
 UnLitTexArrayShader = __decorateClass([
-  RegisterShader
+  RegisterShader(UnLitTexArrayShader, "UnLitTexArrayShader")
 ], UnLitTexArrayShader);
 
 class TileSet {
@@ -57675,46 +59774,6 @@ class LambertMaterial extends Material {
 function registerMaterial(name, cls) {
 }
 
-class UnLitMaterial extends Material {
-  /**
-   * @constructor
-   */
-  constructor() {
-    super();
-    this.shader = new 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
@@ -58320,6 +60379,449 @@ class OrderMap extends Map {
   }
 }
 
+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
@@ -58568,282 +61070,6 @@ class Plane3D {
   }
 }
 
-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();
 }
@@ -61824,86 +64050,6 @@ class TriGeometry extends GeometryBase {
   }
 }
 
-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;
@@ -63343,4 +65489,4 @@ const __viteBrowserExternal = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.def
   __proto__: null
 }, Symbol.toStringTag, { value: 'Module' }));
 
-export { AccelerateDecelerateInterpolator, AccelerateInterpolator, AnimationCurve, AnimationCurveT, AnimationMonitor, AnimatorComponent, AnimatorEventKeyframe, AnticipateInterpolator, AnticipateOvershootInterpolator, ArrayHas, ArrayItemIndex, AtlasParser, AtmosphericComponent, AtmosphericScatteringSky, AtmosphericScatteringSkySetting, AtmosphericScatteringSky_shader, AttributeAnimCurve, AxisObject, B3DMLoader, B3DMLoaderBase, B3DMParseUtil, B3DMParser, BRDFLUT, BRDFLUTGenerate, BRDF_frag, BatchTable, BiMap, BillboardComponent, BillboardType, BitUtil, BitmapTexture2D, BitmapTexture2DArray, BitmapTextureCube, Blend, BlendFactor, BlendMode, BlendShapeData, BlendShapePropertyData, BloomPost, BlurEffectCreatorBlur_cs, BlurEffectCreatorSample_cs, BlurTexture2DBufferCreator, BounceInterpolator, BoundUtil, BoundingBox, BoundingSphere, BoxColliderShape, BoxGeometry, BrdfLut_frag, BsDF_frag, BxDF_frag, BxdfDebug_frag, BytesArray, CEvent, CEventDispatcher, CEventListener, CResizeEvent, CSM, Camera3D, CameraControllerBase, CameraType, CameraUtil, CapsuleColliderShape, CastPointShadowMaterialPass, CastShadowMaterialPass, Clearcoat_frag, ClusterBoundsSource_cs, ClusterConfig, ClusterDebug_frag, ClusterLight, ClusterLightingBuffer, ClusterLightingRender, ClusterLighting_cs, CollectInfo, ColliderComponent, ColliderShape, ColliderShapeType, Color, ColorGradient, ColorLitMaterial, ColorLitShader, ColorPassFragmentOutput, ColorPassRenderer, ColorUtil, ComData, Combine_cs, Common_frag, Common_vert, ComponentBase, ComponentCollect, ComputeGPUBuffer, ComputeShader, Context3D, CubeCamera, CubeMapFaceEnum, CubeSky_Shader, CubicBezierCurve, CubicBezierPath, CubicBezierType, CycleInterpolator, CylinderGeometry, DDGIIrradianceComputePass, DDGIIrradianceGPUBufferReader, DDGIIrradianceVolume, DDGIIrradiance_shader, DDGILightingPass, DDGILighting_shader, DDGIMultiBouncePass, DDGIProbeRenderer, DEGREES_TO_RADIANS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FASTFLOOR, FXAAPost, FXAAShader, FastMathShader, FeatureTable, FileLoader, FirstPersonCameraController, Float16ArrayTexture, Float32ArrayTexture, FlyCameraController, FontChar, FontInfo, FontPage, FontParser, ForwardRenderJob, FragmentOutput, FragmentVarying, FrameCache, Frustum, FrustumCSM, FrustumCulling_cs, FullQuad_vert_wgsl, GBufferFrame, GBufferPass, GBufferPost, GBufferStand, GBuffer_pass, GILighting, GIProbeMaterial, GIProbeMaterialType, GIProbeShader, GIRenderCompleteEvent, GIRenderStartEvent, GLBChunk, GLBHeader, GLBParser, GLSLLexer, GLSLLexerToken, GLSLPreprocessor, GLSLSyntax, GLTFBinaryExtension, GLTFMaterial, GLTFParser, GLTFSubParser, GLTFSubParserCamera, GLTFSubParserConverter, GLTFSubParserMaterial, GLTFSubParserMesh, GLTFSubParserSkeleton, GLTFSubParserSkin, GLTFType, GLTF_Accessors, GLTF_Info, GLTF_Light, GLTF_Mesh, GLTF_Node, GLTF_Primitives, GLTF_Scene, GPUAddressMode, GPUBlendFactor, GPUBufferBase, GPUBufferType, GPUCompareFunction, GPUContext, GPUCullMode, GPUFilterMode, GPUPrimitiveTopology, GPUTextureFormat, GPUVertexFormat, GPUVertexStepMode, GTAOPost, GTAO_cs, GUIAtlasTexture, GUICanvas, GUIConfig, GUIGeometry, GUIGeometryRebuild, GUIMaterial, GUIPassRenderer, GUIPick, GUIPickHelper, GUIQuad, GUIQuadAttrEnum, GUIRenderer, GUIShader, GUISpace, GUISprite, GUITexture, GenerayRandomDir, GeoJsonParser, GeoJsonUtil, GeoType, GeometryBase, GeometryIndicesBuffer, GeometryUtil, GeometryVertexBuffer, GeometryVertexType, GetComponentClass, GetCountInstanceID, GetRepeat, GetShader, GlassShader, GlobalBindGroup, GlobalBindGroupLayout, GlobalFog, GlobalFog_shader, GlobalIlluminationComponent, GlobalUniform, GlobalUniformGroup, GodRayPost, GodRay_cs, GridObject, HDRTexture, HDRTextureCube, Hair_frag, Hair_shader_op, Hair_shader_tr, HaltonSeq, Horizontal, HoverCameraController, I3DMLoader, I3DMLoaderBase, I3DMParser, IBLEnvMapCreator, IBLEnvMapCreator_cs, IESProfiles, IESProfiles_frag, IKDTreeUserData, ImageType, IndicesGPUBuffer, Inline_vert, InputSystem, InstanceDrawComponent, InstanceUniform, InstancedMesh, Interpolator, InterpolatorEnum, IrradianceDataReaderCompleteEvent, IrradianceVolumeData_frag, Irradiance_frag, IsEditorInspector, IsNonSerialize, Joint, JointPose, JumperInterpolator, KDTreeEntity, KDTreeNode, KDTreeRange, KDTreeSpace, KDTreeUUID, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_clearcoat, KHR_materials_emissive_strength, KHR_materials_ior, KHR_materials_unlit, KV, KelvinUtil, KeyCode, KeyEvent, Keyframe, KeyframeT, LDRTextureCube, LambertMaterial, Lambert_shader, Light, LightBase, LightData, LightEntries, LightType, LightingFunction_frag, Line, LineClassification, LinearInterpolator, LitMaterial, LitSSSShader, LitShader, Lit_shader, LoaderBase, LoaderEvent, LoaderManager, MAX_VALUE, MIN_VALUE, Material, MaterialDataUniformGPUBuffer, MaterialUtilities, MathShader, MathUtil, Matrix3, Matrix4, MatrixBindGroup, MatrixGPUBuffer, MatrixShader, MemoryDO, MemoryInfo, MergeRGBACreator, MergeRGBA_cs, MeshColliderShape, MeshFilter, MeshRenderer, MorePassParser, MorePassShader, MorphTargetBlender, MorphTargetData, MorphTargetFrame, MorphTargetTransformKey, MorphTarget_shader, MouseCode, MultiBouncePass_cs, Navi3DAstar, Navi3DConst, Navi3DEdge, Navi3DFunnel, Navi3DMaskType, Navi3DMesh, Navi3DPoint, Navi3DPoint2D, Navi3DPointFat, Navi3DRouter, Navi3DTriangle, NonSerialize, NormalMap_frag, OAnimationEvent, OBJParser, Object3D, Object3DEvent, Object3DTransformTools, Object3DUtil, ObjectAnimClip, OcclusionSystem, Octree, OctreeEntity, OrbitController, OrderMap, Orientation3D, OutLineBlendColor_cs, OutlineCalcOutline_cs, OutlinePass, OutlinePost, OutlinePostData, OutlinePostManager, OutlinePostSlot, Outline_cs, OvershootInterpolator, PBRLItShader, PBRLitSSSShader, ParserBase, ParserFormat, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PointClassification, PointLight, PointLightShadowRenderer, PointShadowCubeCamera, PointerEvent3D, Polynomial, PolynomialCurve, Polynomials, PoolNode, PostBase, PostProcessingComponent, PostRenderer, PreDepthPassRenderer, PreFilteredEnvironment_cs, PreFilteredEnvironment_cs2, PreIntegratedLut, PreIntegratedLutCompute, PrefabAvatarData, PrefabAvatarParser, PrefabBoneData, PrefabMaterialParser, PrefabMeshData, PrefabMeshParser, PrefabNode, PrefabParser, PrefabStringUtil, PrefabTextureData, PrefabTextureParser, Preprocessor, Probe, ProbeEntries, ProbeGBufferFrame, ProfilerUtil, PropertyAnimClip, PropertyAnimTag, PropertyAnimation, PropertyAnimationClip, PropertyAnimationClipState, PropertyAnimationEvent, PropertyHelp, QuadAABB, QuadGlsl_fs, QuadGlsl_vs, QuadRoot, QuadShader, QuadTree, QuadTreeCell, Quad_depth2dArray_frag_wgsl, Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, Quaternion, RADIANS_TO_DEGREES, RGBEErrorCode, RGBEHeader, RGBEParser, RTDescriptor, RTFrame, RTResourceConfig, RTResourceMap, Rand, RandomSeed, Ray, RayCastMeshDetail, Reader, Rect, Reference, Reflection, ReflectionCG, ReflectionEntries, ReflectionMaterial, ReflectionRenderer, ReflectionShader, ReflectionShader_shader, RegisterComponent, RegisterShader, RenderContext, RenderLayer, RenderLayerUtil, RenderNode, RenderShaderCollect, RenderShaderCompute, RenderShaderPass, RenderTexture, RendererBase, RendererJob, RendererMap, RendererMask, RendererMaskUtil, RendererPassState, RepeatSE, Res, RotationControlComponents, SHCommon_frag, SN_ArrayConstant, SN_BinaryOperation, SN_Break, SN_CodeBlock, SN_Constant, SN_Continue, SN_Declaration, SN_Discard, SN_DoWhileLoop, SN_Expression, SN_ForLoop, SN_Function, SN_FunctionArgs, SN_FunctionCall, SN_IFBranch, SN_Identifier, SN_IndexOperation, SN_Layout, SN_ParenExpression, SN_Precision, SN_Return, SN_SelectOperation, SN_Struct, SN_TernaryOperation, SN_UnaryOperation, SN_WhileLoop, SSAO_cs, SSGI2_cs, SSGIPost, SSRPost, SSR_BlendColor_cs, SSR_IS_Kernel, SSR_IS_cs, SSR_RayTrace_cs, ScaleControlComponents, Scene3D, Shader, ShaderAttributeInfo, ShaderConverter, ShaderConverterResult, ShaderLib, ShaderPassBase, ShaderReflection, ShaderStage, ShaderState, ShaderUniformInfo, ShaderUtil, ShadingInput, ShadowLightsCollect, ShadowMapPassRenderer, ShadowMapping_frag, Skeleton, SkeletonAnimationClip, SkeletonAnimationClipState, SkeletonAnimationComponent, SkeletonAnimationCompute, SkeletonAnimation_shader, SkeletonBlendComputeArgs, SkeletonPose, SkeletonTransformComputeArgs, SkinnedMeshRenderer, SkinnedMeshRenderer2, SkyGBufferPass, SkyGBuffer_pass, SkyMaterial, SkyRenderer, SkyShader, SolidColorSky, SphereColliderShape, SphereGeometry, SphereReflection, SpotLight, StandShader, StatementNode, StorageGPUBuffer, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, TileSet, TileSetChild, TileSetChildContent, TileSetChildContentMetaData, TileSetRoot, TilesRenderer, Time, TokenType, TorusGeometry, TouchData, TrailGeometry, Transform, TransformAxisEnum, TransformControllerBaseComponent, TransformMode, TransformSpaceMode, TranslationControlComponents, TranslatorContext, TriGeometry, Triangle, UIButton, UIButtonTransition, UIComponentBase, UIEvent, UIImage, UIImageGroup, UIInteractive, UIInteractiveStyle, UIPanel, UIRenderAble, UIShadow, UITextField, UITransform, UUID, UV, Uint8ArrayTexture, UnLit, UnLitMaterial, UnLitMaterialUniform_frag, UnLitShader, UnLitTexArrayMaterial, UnLitTexArrayShader, UnLitTextureArray, UnLit_frag, UniformGPUBuffer, UniformNode, UniformType, ValueEnumType, ValueOp, ValueParser, Vector2, Vector3, Vector3Ex, Vector4, VertexAttribute, VertexAttributeIndexShader, VertexAttributeName, VertexAttributeSize, VertexAttributeStride, VertexAttributes_vert, VertexBufferLayout, VertexFormat, VertexGPUBuffer, Vertical, VideoUniform_frag, View3D, ViewPanel, ViewQuad, VirtualTexture, WGSLTranslator, WebGPUDescriptorCreator, WorldMatrixUniform, WorldPanel, WrapMode, WrapTimeMode, ZCullingCompute, ZPassShader_cs, ZPassShader_fs, ZPassShader_vs, ZSorterUtil, append, arrayToString, blendComponent, castPointShadowMap_vert, clamp, clampRepeat, cos, crossProduct, cubicPolynomialRoot, cubicPolynomialRootsGeneric, deg2Rad, directionShadowCastMap_frag, dot, doubleIntegrateSegment, downSample, fastInvSqrt, floorfToIntPos, fonts, generateRandom, generateRandom3, getFloatFromInt, getGLTypeFromTypedArray, getGLTypeFromTypedArrayType, getGlobalRandomSeed, getTypedArray, getTypedArrayTypeFromGLType, grad1, grad2, grad3, grad4, integrateSegment, irradianceDataReader, lerp, lerpByte, lerpColor, lerpVector3, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, perm, post, quadraticPolynomialRootsGeneric, rad2Deg, random01, randomBarycentricCoord, randomPointBetweenEllipsoid, randomPointBetweenSphere, randomPointInsideCube, randomPointInsideEllipsoid, randomPointInsideUnitCircle, randomPointInsideUnitSphere, randomQuaternion, randomQuaternionUniformDistribution, randomSeed, randomUnitVector, randomUnitVector2, rangedRandomFloat, rangedRandomInt, readMagicBytes, registerMaterial, repeat, rotMatrix, rotateVectorByQuat, roundfToIntPos, scale, shadowCastMap_frag, shadowCastMap_vert, simplex, sin, snoise1, snoise2, snoise3, snoise4, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, toHalfFloat, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };
+export { AccelerateDecelerateInterpolator, AccelerateInterpolator, AnimationCurve, AnimationCurveT, AnimationMonitor, AnimatorComponent, AnimatorEventKeyframe, AnticipateInterpolator, AnticipateOvershootInterpolator, ArrayHas, ArrayItemIndex, AtlasParser, AtmosphericComponent, AtmosphericScatteringSky, AtmosphericScatteringSkySetting, AtmosphericScatteringSky_shader, AttributeAnimCurve, AxisObject, B3DMLoader, B3DMLoaderBase, B3DMParseUtil, B3DMParser, BRDFLUT, BRDFLUTGenerate, BRDF_frag, BatchTable, BiMap, BillboardComponent, BillboardType, BitUtil, BitmapTexture2D, BitmapTexture2DArray, BitmapTextureCube, Blend, BlendFactor, BlendMode, BlendShapeData, BlendShapePropertyData, BloomPost, BlurEffectCreatorBlur_cs, BlurEffectCreatorSample_cs, BlurTexture2DBufferCreator, BounceInterpolator, BoundUtil, BoundingBox, BoundingSphere, BoxColliderShape, BoxGeometry, BrdfLut_frag, BsDF_frag, BxDF_frag, BxdfDebug_frag, BytesArray, CEvent, CEventDispatcher, CEventListener, CResizeEvent, CSM, Camera3D, CameraControllerBase, CameraType, CameraUtil, CapsuleColliderShape, CastPointShadowMaterialPass, CastShadowMaterialPass, Clearcoat_frag, ClusterBoundsSource_cs, ClusterConfig, ClusterDebug_frag, ClusterLight, ClusterLightingBuffer, ClusterLightingRender, ClusterLighting_cs, CollectInfo, ColliderComponent, ColliderShape, ColliderShapeType, Color, ColorGradient, ColorLitMaterial, ColorLitShader, ColorPassFragmentOutput, ColorPassRenderer, ColorUtil, ComData, Combine_cs, Common_frag, Common_vert, ComponentBase, ComponentCollect, ComputeGPUBuffer, ComputeShader, Context3D, CubeCamera, CubeMapFaceEnum, CubeSky_Shader, CubicBezierCurve, CubicBezierPath, CubicBezierType, CycleInterpolator, CylinderGeometry, DDGIIrradianceComputePass, DDGIIrradianceGPUBufferReader, DDGIIrradianceVolume, DDGIIrradiance_shader, DDGILightingPass, DDGILighting_shader, DDGIMultiBouncePass, DDGIProbeRenderer, DEGREES_TO_RADIANS, DecelerateInterpolator, Denoising_cs, Depth2DTextureArray, DepthCubeArrayTexture, DepthMaterialPass, DepthOfFieldPost, DepthOfView_cs, DirectLight, DoubleArray, EditorInspector, Engine3D, Entity, EntityBatchCollect, EntityCollect, EnvMap_frag, ErpImage2CubeMap, ErpImage2CubeMapCreateCube_cs, ErpImage2CubeMapRgbe2rgba_cs, ExtrudeGeometry, FASTFLOOR, FXAAPost, FXAAShader, FastMathShader, FeatureTable, FileLoader, FirstPersonCameraController, Float16ArrayTexture, Float32ArrayTexture, FlyCameraController, FontChar, FontInfo, FontPage, FontParser, ForwardRenderJob, FragmentOutput, FragmentVarying, FrameCache, Frustum, FrustumCSM, FrustumCulling_cs, FullQuad_vert_wgsl, GBufferFrame, GBufferPass, GBufferPost, GBufferStand, GBuffer_pass, GILighting, GIProbeMaterial, GIProbeMaterialType, GIProbeShader, GIRenderCompleteEvent, GIRenderStartEvent, GLBChunk, GLBHeader, GLBParser, GLSLLexer, GLSLLexerToken, GLSLPreprocessor, GLSLSyntax, GLTFBinaryExtension, GLTFMaterial, GLTFParser, GLTFSubParser, GLTFSubParserCamera, GLTFSubParserConverter, GLTFSubParserMaterial, GLTFSubParserMesh, GLTFSubParserSkeleton, GLTFSubParserSkin, GLTFType, GLTF_Accessors, GLTF_Info, GLTF_Light, GLTF_Mesh, GLTF_Node, GLTF_Primitives, GLTF_Scene, GPUAddressMode, GPUBlendFactor, GPUBufferBase, GPUBufferType, GPUCompareFunction, GPUContext, GPUCullMode, GPUFilterMode, GPUPrimitiveTopology, GPUTextureFormat, GPUVertexFormat, GPUVertexStepMode, GSplatFormat, GSplatMaterial, GSplatRenderer, GSplat_FS, GSplat_VS, GTAOPost, GTAO_cs, GUIAtlasTexture, GUICanvas, GUIConfig, GUIGeometry, GUIGeometryRebuild, GUIMaterial, GUIPassRenderer, GUIPick, GUIPickHelper, GUIQuad, GUIQuadAttrEnum, GUIRenderer, GUIShader, GUISpace, GUISprite, GUITexture, GaussianSplatParser, GenerayRandomDir, GeoJsonParser, GeoJsonUtil, GeoType, GeometryBase, GeometryIndicesBuffer, GeometryUtil, GeometryVertexBuffer, GeometryVertexType, GetComponentClass, GetCountInstanceID, GetRepeat, GetShader, GlassShader, GlobalBindGroup, GlobalBindGroupLayout, GlobalFog, GlobalFog_shader, GlobalIlluminationComponent, GlobalUniform, GlobalUniformGroup, GodRayPost, GodRay_cs, GridObject, HDRTexture, HDRTextureCube, Hair_frag, Hair_shader_op, Hair_shader_tr, HaltonSeq, Horizontal, HoverCameraController, I3DMLoader, I3DMLoaderBase, I3DMParser, IBLEnvMapCreator, IBLEnvMapCreator_cs, IESProfiles, IESProfiles_frag, IKDTreeUserData, ImageType, IndicesGPUBuffer, Inline_vert, InputSystem, InstanceDrawComponent, InstanceUniform, InstancedMesh, Interpolator, InterpolatorEnum, IrradianceDataReaderCompleteEvent, IrradianceVolumeData_frag, Irradiance_frag, IsEditorInspector, IsNonSerialize, Joint, JointPose, JumperInterpolator, KDTreeEntity, KDTreeNode, KDTreeRange, KDTreeSpace, KDTreeUUID, KHR_draco_mesh_compression, KHR_lights_punctual, KHR_materials_clearcoat, KHR_materials_emissive_strength, KHR_materials_ior, KHR_materials_unlit, KMZParser, KV, KelvinUtil, KeyCode, KeyEvent, Keyframe, KeyframeT, LDRTextureCube, LambertMaterial, Lambert_shader, Light, LightBase, LightData, LightEntries, LightType, LightingFunction_frag, Line, LineClassification, LinearInterpolator, LitMaterial, LitSSSShader, LitShader, Lit_shader, LoaderBase, LoaderEvent, LoaderManager, MAX_VALUE, MIN_VALUE, Material, MaterialDataUniformGPUBuffer, MaterialUtilities, MathShader, MathUtil, Matrix3, Matrix4, MatrixBindGroup, MatrixGPUBuffer, MatrixShader, MemoryDO, MemoryInfo, MergeRGBACreator, MergeRGBA_cs, MeshColliderShape, MeshFilter, MeshRenderer, MinMaxAnimationCurves, MinMaxCurve, MinMaxCurveState, MinMaxPolyCurves, MorePassParser, MorePassShader, MorphTargetBlender, MorphTargetData, MorphTargetFrame, MorphTargetTransformKey, MorphTarget_shader, MouseCode, MultiBouncePass_cs, Navi3DAstar, Navi3DConst, Navi3DEdge, Navi3DFunnel, Navi3DMaskType, Navi3DMesh, Navi3DPoint, Navi3DPoint2D, Navi3DPointFat, Navi3DRouter, Navi3DTriangle, NonSerialize, NormalMap_frag, OAnimationEvent, OBJParser, Object3D, Object3DEvent, Object3DTransformTools, Object3DUtil, ObjectAnimClip, OcclusionSystem, Octree, OctreeEntity, OrbitController, OrderMap, Orientation3D, OutLineBlendColor_cs, OutlineCalcOutline_cs, OutlinePass, OutlinePost, OutlinePostData, OutlinePostManager, OutlinePostSlot, Outline_cs, OvershootInterpolator, PBRLItShader, PBRLitSSSShader, ParserBase, ParserFormat, ParticleSystemCurveEvalMode, ParticleSystemRandomnessIds, PassGenerate, PassShader, PassType, PhysicMaterialUniform_frag, PickCompute, PickFire, PickGUIEvent3D, PickResult, Picker_cs, PingPong, PipelinePool, Plane3D, PlaneClassification, PlaneGeometry, PointClassification, PointLight, PointLightShadowRenderer, PointShadowCubeCamera, PointerEvent3D, Polynomial, PolynomialCurve, Polynomials, PoolNode, PostBase, PostProcessingComponent, PostRenderer, PreDepthPassRenderer, PreFilteredEnvironment_cs, PreFilteredEnvironment_cs2, PreIntegratedLut, PreIntegratedLutCompute, PrefabAvatarData, PrefabAvatarParser, PrefabBoneData, PrefabMaterialParser, PrefabMeshData, PrefabMeshParser, PrefabNode, PrefabParser, PrefabStringUtil, PrefabTextureData, PrefabTextureParser, Preprocessor, Probe, ProbeEntries, ProbeGBufferFrame, ProfilerUtil, PropertyAnimClip, PropertyAnimTag, PropertyAnimation, PropertyAnimationClip, PropertyAnimationClipState, PropertyAnimationEvent, PropertyHelp, QuadAABB, QuadGlsl_fs, QuadGlsl_vs, QuadRoot, QuadShader, QuadTree, QuadTreeCell, Quad_depth2dArray_frag_wgsl, Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, Quaternion, RADIANS_TO_DEGREES, RGBEErrorCode, RGBEHeader, RGBEParser, RTDescriptor, RTFrame, RTResourceConfig, RTResourceMap, Rand, RandomSeed, Ray, RayCastMeshDetail, Reader, Rect, Reference, Reflection, ReflectionCG, ReflectionEntries, ReflectionMaterial, ReflectionRenderer, ReflectionShader, ReflectionShader_shader, RegisterComponent, RegisterShader, RenderContext, RenderLayer, RenderLayerUtil, RenderNode, RenderShaderCollect, RenderShaderCompute, RenderShaderPass, RenderTexture, RendererBase, RendererJob, RendererMap, RendererMask, RendererMaskUtil, RendererPassState, RepeatSE, Res, RotationControlComponents, SHCommon_frag, SN_ArrayConstant, SN_BinaryOperation, SN_Break, SN_CodeBlock, SN_Constant, SN_Continue, SN_Declaration, SN_Discard, SN_DoWhileLoop, SN_Expression, SN_ForLoop, SN_Function, SN_FunctionArgs, SN_FunctionCall, SN_IFBranch, SN_Identifier, SN_IndexOperation, SN_Layout, SN_ParenExpression, SN_Precision, SN_Return, SN_SelectOperation, SN_Struct, SN_TernaryOperation, SN_UnaryOperation, SN_WhileLoop, SSAO_cs, SSGI2_cs, SSGIPost, SSRPost, SSR_BlendColor_cs, SSR_IS_Kernel, SSR_IS_cs, SSR_RayTrace_cs, ScaleControlComponents, Scene3D, Shader, ShaderAttributeInfo, ShaderConverter, ShaderConverterResult, ShaderLib, ShaderPassBase, ShaderReflection, ShaderStage, ShaderState, ShaderUniformInfo, ShaderUtil, ShadingInput, ShadowLightsCollect, ShadowMapPassRenderer, ShadowMapping_frag, Skeleton, SkeletonAnimationClip, SkeletonAnimationClipState, SkeletonAnimationComponent, SkeletonAnimationCompute, SkeletonAnimation_shader, SkeletonBlendComputeArgs, SkeletonPose, SkeletonTransformComputeArgs, SkinnedMeshRenderer, SkinnedMeshRenderer2, SkyGBufferPass, SkyGBuffer_pass, SkyMaterial, SkyRenderer, SkyShader, SolidColorSky, SphereColliderShape, SphereGeometry, SphereReflection, SpotLight, StandShader, StatementNode, StorageGPUBuffer, StringUtil, Struct, StructStorageGPUBuffer, SubGeometry, TAACopyTex_cs, TAAPost, TAASharpTex_cs, TAA_cs, TestComputeLoadBuffer, TextAnchor, TextFieldLayout, TextFieldLine, Texture, TextureCube, TextureCubeFaceData, TextureCubeStdCreator, TextureCubeUtils, TextureMipmapCompute, TextureMipmapGenerator, TextureScaleCompute, ThirdPersonCameraController, TileSet, TileSetChild, TileSetChildContent, TileSetChildContentMetaData, TileSetRoot, TilesRenderer, Time, TokenType, TorusGeometry, TouchData, TrailGeometry, Transform, TransformAxisEnum, TransformControllerBaseComponent, TransformMode, TransformSpaceMode, TranslationControlComponents, TranslatorContext, TriGeometry, Triangle, UIButton, UIButtonTransition, UIComponentBase, UIEvent, UIImage, UIImageGroup, UIInteractive, UIInteractiveStyle, UIPanel, UIRenderAble, UIShadow, UITextField, UITransform, UUID, UV, Uint32ArrayTexture, Uint8ArrayTexture, UnLit, UnLitMaterial, UnLitMaterialUniform_frag, UnLitShader, UnLitTexArrayMaterial, UnLitTexArrayShader, UnLitTextureArray, UnLit_frag, UniformGPUBuffer, UniformNode, UniformType, ValueEnumType, ValueOp, ValueParser, ValueSpread, Vector2, Vector3, Vector3Ex, Vector4, VertexAttribute, VertexAttributeIndexShader, VertexAttributeName, VertexAttributeSize, VertexAttributeStride, VertexAttributes_vert, VertexBufferLayout, VertexFormat, VertexGPUBuffer, Vertical, VideoUniform_frag, View3D, ViewPanel, ViewQuad, VirtualTexture, WGSLTranslator, WayLines3D, WayPoint3D, WebGPUDescriptorCreator, WorldMatrixUniform, WorldPanel, WrapMode, WrapTimeMode, ZCullingCompute, ZPassShader_cs, ZPassShader_fs, ZPassShader_vs, ZSorterUtil, append, arrayToString, blendComponent, buildCurves, byteSizeOfType, calculateCurveRangesValue, calculateMinMax, castPointShadowMap_vert, clamp, clampRepeat, computeAABBFromPositions, cos, crossProduct, cubicPolynomialRoot, cubicPolynomialRootsGeneric, curvesSupportProcedural, deg2Rad, detectGSplatFormat, directionShadowCastMap_frag, dot, doubleIntegrateSegment, downSample, fastInvSqrt, floorfToIntPos, fonts, generateRandom, generateRandom3, getFloatFromInt, getGLTypeFromTypedArray, getGLTypeFromTypedArrayType, getGlobalRandomSeed, getTypedArray, getTypedArrayTypeFromGLType, grad1, grad2, grad3, grad4, inferSHOrder, integrateSegment, irradianceDataReader, kPI, lerp, lerpByte, lerpColor, lerpVector3, magnitude, makeAloneSprite, makeGUISprite, makeMatrix44, matrixMultiply, matrixRotate, matrixRotateY, mergeFunctions, multiplyMatrices4x4REF, normal_distribution, normalizeFast, normalizeSafe, normalizedToByte, normalizedToWord, outlinePostData, outlinePostManager, parsePlyGaussianSplat, parsePlyHeader, perm, post, quadraticPolynomialRootsGeneric, rad2Deg, random01, randomBarycentricCoord, randomPointBetweenEllipsoid, randomPointBetweenSphere, randomPointInsideCube, randomPointInsideEllipsoid, randomPointInsideUnitCircle, randomPointInsideUnitSphere, randomQuaternion, randomQuaternionUniformDistribution, randomSeed, randomUnitVector, randomUnitVector2, rangedRandomFloat, rangedRandomInt, readByType, readMagicBytes, registerMaterial, repeat, rotMatrix, rotateVectorByQuat, roundfToIntPos, scale, shadowCastMap_frag, shadowCastMap_vert, simplex, sin, snoise1, snoise2, snoise3, snoise4, sqrMagnitude, sqrtImpl, stencilStateFace, swap, textureCompress, threshold, toHalfFloat, tw, uniform_real_distribution, uniform_real_distribution2, upSample$1 as upSample, webGPUContext, zSorterUtil };