@rings-webgpu/core 1.0.25 → 1.0.27

package/dist/rings.umd.max.js

@@ -16792,6 +16792,10 @@ struct InstanceData {
     name;
     url;
     gpuTexture;
+    _isDestroyed = false;
+    get isDestroyed() {
+      return this._isDestroyed;
+    }
     pid;
     view;
     // Assigned later
@@ -17020,6 +17024,14 @@ struct InstanceData {
         this.textureDescriptor = null;
         this.gpuTexture.destroy();
         this.gpuTexture = null;
+        this._isDestroyed = true;
+      }
+      if (this._sourceImageData && this._sourceImageData instanceof ImageBitmap) {
+        try {
+          this._sourceImageData.close();
+        } catch (e) {
+        }
+        this._sourceImageData = null;
       }
       this._stateChangeRef.clear();
     }
@@ -20283,9 +20295,13 @@ struct InstanceData {
      * @param target reference parent
      */
     detached(ref, target) {
+      if (!this.reference) return;
       let refMap = this.reference.get(ref);
       if (refMap) {
         refMap.delete(target);
+        if (refMap.size === 0) {
+          this.reference.delete(ref);
+        }
       }
     }
     /**
@@ -22514,23 +22530,36 @@ struct InstanceData {
       }
     }
     beforeDestroy(force) {
-      Reference.getInstance().detached(this._geometry, this);
-      if (!Reference.getInstance().hasReference(this._geometry)) {
-        this._geometry.destroy(force);
+      if (this._geometry) {
+        Reference.getInstance().detached(this._geometry, this);
+        if (!Reference.getInstance().hasReference(this._geometry)) {
+          this._geometry.destroy(force);
+        }
       }
       for (let i = 0; i < this._materials.length; i++) {
         const mat = this._materials[i];
-        Reference.getInstance().detached(mat, this);
-        if (!Reference.getInstance().hasReference(mat)) {
-          mat.destroy(force);
+        if (mat) {
+          Reference.getInstance().detached(mat, this);
+          if (!Reference.getInstance().hasReference(mat)) {
+            mat.destroy(force);
+          }
         }
       }
+      if (this._computes) {
+        this._computes.length = 0;
+      }
+      this.detachSceneOctree();
       super.beforeDestroy(force);
     }
     destroy(force) {
       super.destroy(force);
       this._geometry = void 0;
       this._materials.length = 0;
+      this._computes = null;
+      if (this._passInit) {
+        this._passInit.clear();
+        this._passInit = null;
+      }
       this._combineShaderRefection = void 0;
     }
   }
@@ -22550,6 +22579,7 @@ struct InstanceData {
     enable = true;
     _defaultSubShader;
     _shader;
+    _isDestroyed = false;
     constructor() {
       this.instanceID = UUID();
     }
@@ -22664,10 +22694,17 @@ struct InstanceData {
       return newMat;
     }
     destroy(force) {
+      if (this._isDestroyed) {
+        return;
+      }
       this.name = null;
       this.instanceID = null;
-      this._shader.destroy();
-      this._shader = null;
+      if (this._shader) {
+        this._shader.destroy(force);
+        this._shader = null;
+      }
+      this._defaultSubShader = null;
+      this._isDestroyed = true;
     }
     setDefine(define, value) {
       this.shader.setDefine(define, value);
@@ -23172,8 +23209,15 @@ struct InstanceData {
         }
       }
     }
-    destroy() {
-      this.getDefaultColorShader().destroy();
+    destroy(force) {
+      for (const pass of this.passShader) {
+        for (const rd of pass[1]) {
+          rd.destroy(force);
+        }
+      }
+      this.passShader.clear();
+      this.passShader = null;
+      this.computes = null;
     }
     clone() {
       let newShader = new Shader();
@@ -23665,6 +23709,7 @@ struct InstanceData {
     _vertexBuffer;
     _onChange = true;
     _wireframeLines;
+    _isDestroyed = false;
     constructor() {
       this.instanceID = UUID();
       this._attributeMap = /* @__PURE__ */ new Map();
@@ -23911,18 +23956,40 @@ struct InstanceData {
       return false;
     }
     destroy(force) {
+      if (this._isDestroyed) {
+        return;
+      }
       this.instanceID = null;
       this.name = null;
       this.subGeometries = null;
       this.morphTargetDictionary = null;
-      this._bounds.destroy();
-      this._bounds = null;
-      this._attributeMap = null;
+      this.skinNames = null;
+      this.bindPose = null;
+      this.blendShapeData = null;
+      this._wireframeLines = null;
+      if (this._bounds) {
+        this._bounds.destroy();
+        this._bounds = null;
+      }
+      if (this._attributeMap) {
+        this._attributeMap.forEach((vertexInfo) => {
+          if (vertexInfo && vertexInfo.data) {
+            vertexInfo.data = null;
+          }
+        });
+        this._attributeMap.clear();
+        this._attributeMap = null;
+      }
       this._attributes = null;
-      this._indicesBuffer.destroy();
-      this._vertexBuffer.destroy();
-      this._indicesBuffer = null;
-      this._vertexBuffer = null;
+      if (this._indicesBuffer) {
+        this._indicesBuffer.destroy();
+        this._indicesBuffer = null;
+      }
+      if (this._vertexBuffer) {
+        this._vertexBuffer.destroy();
+        this._vertexBuffer = null;
+      }
+      this._isDestroyed = true;
     }
   }
 
@@ -25323,10 +25390,22 @@ struct InstanceData {
           c.destroy(force);
         });
         this.components.clear();
-        this.entityChildren.forEach((c) => {
-          c.destroy(force);
-        });
-        this.removeAllChild();
+        this.components.clear();
+        if (this.entityChildren) {
+          this.entityChildren.forEach((c) => {
+            c.destroy(force);
+          });
+          this.removeAllChild();
+          this.entityChildren = [];
+        }
+        if (this._bound && this._bound.destroy) {
+          this._bound.destroy();
+          this._bound = null;
+        }
+        if (this._boundWorld && this._boundWorld.destroy) {
+          this._boundWorld.destroy();
+          this._boundWorld = null;
+        }
         this.transform.parent = null;
         this._dispose = true;
         super.destroy();
@@ -25598,6 +25677,16 @@ struct InstanceData {
         this.onTransformLocalChange,
         this
       );
+      const batchTable = this.batchTable;
+      if (batchTable && typeof batchTable.destroy === "function") {
+        batchTable.destroy();
+        this.batchTable = null;
+      }
+      const featureTable = this.featureTable;
+      if (featureTable && typeof featureTable.destroy === "function") {
+        featureTable.destroy();
+        this.featureTable = null;
+      }
       super.destroy(force);
     }
   };
@@ -32912,6 +33001,12 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
       return this._source;
     }
     set source(value) {
+      if (this._source && this._source instanceof ImageBitmap) {
+        try {
+          this._source.close();
+        } catch (e) {
+        }
+      }
       this._source = value;
       if (this._source instanceof HTMLImageElement) {
         this._source.decode().then(async () => {
@@ -32979,17 +33074,32 @@ fn CsMain( @builtin(workgroup_id) workgroup_id : vec3<u32> , @builtin(global_inv
       if (imageBitmap.width < 32 || imageBitmap.height < 32) {
         let width = Math.max(imageBitmap.width, 32);
         let height = Math.max(imageBitmap.height, 32);
+        const oldImageBitmap = imageBitmap;
         imageBitmap = await createImageBitmap(imageBitmap, {
           resizeWidth: width,
           resizeHeight: height,
           imageOrientation: this.flipY ? "flipY" : "from-image",
           premultiplyAlpha: "none"
         });
+        try {
+          oldImageBitmap.close();
+        } catch (e) {
+        }
       }
       this.format = GPUTextureFormat.rgba8unorm;
       this.generate(imageBitmap);
       return true;
     }
+    destroy(force) {
+      if (this._source && this._source instanceof ImageBitmap) {
+        try {
+          this._source.close();
+        } catch (e) {
+        }
+        this._source = null;
+      }
+      super.destroy(force);
+    }
   }
 
   class LoaderBase {
@@ -36237,6 +36347,7 @@ else if (typeof exports === 'object')
         this._gltf,
         this._gltf.scene
       );
+      subParser.destroy();
       if (nodes) {
         this.data = nodes.rootNode;
         return nodes.rootNode;
@@ -36274,6 +36385,7 @@ else if (typeof exports === 'object')
         this._gltf,
         this._gltf.scene
       );
+      subParser.destroy();
       if (nodes) {
         this.data = nodes.rootNode;
         return nodes.rootNode;
@@ -39074,6 +39186,12 @@ else if (typeof exports === 'object')
         return data;
       }
     }
+    destroy() {
+      this.buffer = null;
+      this.header = null;
+      this.binOffset = null;
+      this.binLength = null;
+    }
   }
   class BatchTable extends FeatureTable {
     batchSize;
@@ -40999,6 +41117,25 @@ else if (typeof exports === 'object')
       this._texturePool.set(url, texture);
       return texture;
     }
+    destroyTexture(url) {
+      const texture = this._texturePool.get(url);
+      if (texture) {
+        if (!Reference.getInstance().hasReference(texture)) {
+          if (!texture.isDestroyed) {
+            texture.destroy();
+          }
+          this._texturePool.delete(url);
+          return true;
+        }
+        return false;
+      }
+      return false;
+    }
+    destroyTextureAllUnUsed() {
+      for (const [url, texture] of this._texturePool.entries()) {
+        this.destroyTexture(url);
+      }
+    }
     async loadTextureCount(urls, count, loaderFunctions, flipY) {
       return new Promise(async (suc, fail) => {
         let total = 0;
@@ -41295,7 +41432,7 @@ else if (typeof exports === 'object')
     }
   }
 
-  const version = "1.0.24";
+  const version = "1.0.26";
 
   class Engine3D {
     /**
@@ -59007,6 +59144,15 @@ fn frag(){
     return "unknown" /* UNKNOWN */;
   }
 
+  var PlyMode = /* @__PURE__ */ ((PlyMode2) => {
+    PlyMode2[PlyMode2["Splat"] = 0] = "Splat";
+    PlyMode2[PlyMode2["PointCloud"] = 1] = "PointCloud";
+    PlyMode2[PlyMode2["Mesh"] = 2] = "Mesh";
+    return PlyMode2;
+  })(PlyMode || {});
+  const splatProperties = ["x", "y", "z", "scale_0", "scale_1", "scale_2", "opacity", "rot_0", "rot_1", "rot_2", "rot_3"];
+  const splatColorProperties = ["red", "green", "blue", "f_dc_0", "f_dc_1", "f_dc_2"];
+
   function byteSizeOfType(t) {
     switch (t) {
       case "char":
@@ -59082,34 +59228,85 @@ fn frag(){
     const lines = headerText.split(/\r?\n/);
     let format = "";
     let vertexCount = 0;
+    let faceCount = 0;
     const properties = [];
+    const faceProperties = [];
+    const textureFiles = [];
     let inVertexElement = false;
+    let inFaceElement = false;
     for (const line of lines) {
       if (line.startsWith("format ")) {
         format = line.split(/\s+/)[1];
+      } else if (line.startsWith("comment TextureFile ")) {
+        const texturePath = line.substring("comment TextureFile ".length).trim();
+        if (texturePath) {
+          textureFiles.push(texturePath);
+        }
       } else if (line.startsWith("element ")) {
         const toks = line.split(/\s+/);
         inVertexElement = toks[1] === "vertex";
-        if (inVertexElement) vertexCount = parseInt(toks[2]);
+        inFaceElement = toks[1] === "face";
+        if (inVertexElement) {
+          vertexCount = parseInt(toks[2]);
+          inFaceElement = false;
+        }
+        if (inFaceElement) {
+          faceCount = parseInt(toks[2]);
+          inVertexElement = false;
+        }
       } else if (inVertexElement && line.startsWith("property ")) {
         const toks = line.split(/\s+/);
         const type = toks[1];
         const name = toks[2];
         properties.push({ name, type });
+      } else if (inFaceElement && line.startsWith("property ")) {
+        const toks = line.split(/\s+/);
+        if (toks[1] === "list") {
+          const countType = toks[2];
+          const itemType = toks[3];
+          const name = toks[4];
+          faceProperties.push({ name, type: `list ${countType} ${itemType}` });
+        } else {
+          const type = toks[1];
+          const name = toks[2];
+          faceProperties.push({ name, type });
+        }
       }
     }
-    if (format !== "binary_little_endian") {
-      throw new Error("PLY: Only binary_little_endian PLY is supported");
+    if (format !== "binary_little_endian" && format !== "ascii") {
+      throw new Error(`PLY: Unsupported format: ${format}. Only binary_little_endian and ascii are supported.`);
+    }
+    let splatPropertyCount = 0;
+    let splatPropertyColorCount = 0;
+    for (const property of properties) {
+      if (splatProperties.includes(property.name)) {
+        splatPropertyCount++;
+      }
+      if (splatColorProperties.includes(property.name)) {
+        splatPropertyColorCount++;
+      }
     }
     return {
       format,
       vertexCount,
+      faceCount,
       properties,
-      headerByteLength: headerText.length
+      faceProperties: faceProperties.length > 0 ? faceProperties : void 0,
+      textureFiles,
+      headerByteLength: headerText.length,
+      mode: faceCount ? PlyMode.Mesh : splatPropertyCount === splatProperties.length && splatPropertyColorCount === 3 ? PlyMode.Splat : PlyMode.PointCloud
     };
   }
   function parsePlyGaussianSplat(buffer) {
     const header = parsePlyHeader(buffer);
+    const { format } = header;
+    if (format === "ascii") {
+      return parsePlyGaussianSplatASCII(buffer, header);
+    } else {
+      return parsePlyGaussianSplatBinary(buffer, header);
+    }
+  }
+  function parsePlyGaussianSplatBinary(buffer, header) {
     const { vertexCount, properties, headerByteLength } = header;
     const payload = new DataView(buffer, headerByteLength);
     const has = (n) => properties.find((p) => p.name === n) != null;
@@ -59231,6 +59428,743 @@ fn frag(){
       sh: hasSH && shCoeffs ? { order: shOrder, coeffs: shCoeffs } : void 0
     };
   }
+  function parsePlyGaussianSplatASCII(buffer, header) {
+    const { vertexCount, properties } = header;
+    const text = new TextDecoder("utf-8").decode(buffer);
+    const headerEnd = text.indexOf("end_header");
+    if (headerEnd < 0) {
+      throw new Error("PLY: Invalid PLY header");
+    }
+    let bodyStart = headerEnd + "end_header".length;
+    while (bodyStart < text.length && (text[bodyStart] === " " || text[bodyStart] === "\n" || text[bodyStart] === "\r")) {
+      bodyStart++;
+    }
+    const bodyText = text.substring(bodyStart);
+    const tokens = bodyText.split(/\s+/).filter((token) => token.length > 0);
+    let tokenIndex = 0;
+    const has = (n) => properties.find((p) => p.name === n) != null;
+    const propIndex = (n) => properties.findIndex((p) => p.name === n);
+    const parseASCIINumber = (type) => {
+      if (tokenIndex >= tokens.length) {
+        throw new Error("PLY: Unexpected end of file");
+      }
+      const value = tokens[tokenIndex++];
+      switch (type) {
+        case "char":
+        case "uchar":
+        case "short":
+        case "ushort":
+        case "int":
+        case "uint":
+        case "int8":
+        case "uint8":
+        case "int16":
+        case "uint16":
+        case "int32":
+        case "uint32":
+          return parseInt(value);
+        case "float":
+        case "double":
+        case "float32":
+        case "float64":
+          return parseFloat(value);
+        default:
+          return parseFloat(value);
+      }
+    };
+    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 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");
+    }
+    const s0 = scale ? propIndex("scale_0") : -1;
+    const s1 = scale ? propIndex("scale_1") : -1;
+    const s2 = scale ? propIndex("scale_2") : -1;
+    const r0 = rotation ? propIndex("rot_0") : -1;
+    const r1 = rotation ? propIndex("rot_1") : -1;
+    const r2 = rotation ? propIndex("rot_2") : -1;
+    const r3 = rotation ? propIndex("rot_3") : -1;
+    const oi = opacity ? propIndex("opacity") : -1;
+    for (let v = 0; v < vertexCount; v++) {
+      for (let pIdx = 0; pIdx < properties.length; pIdx++) {
+        const prop = properties[pIdx];
+        const value = parseASCIINumber(prop.type);
+        if (pIdx === ix) {
+          position[v * 3 + 0] = value;
+        } else if (pIdx === iy) {
+          position[v * 3 + 1] = value;
+        } else if (pIdx === iz) {
+          position[v * 3 + 2] = value;
+        }
+        if (scale && pIdx === s0) {
+          scale[v * 3 + 0] = value;
+        } else if (scale && pIdx === s1) {
+          scale[v * 3 + 1] = value;
+        } else if (scale && pIdx === s2) {
+          scale[v * 3 + 2] = value;
+        }
+        if (rotation && pIdx === r0) {
+          rotation[v * 4 + 3] = value;
+        } else if (rotation && pIdx === r1) {
+          rotation[v * 4 + 0] = value;
+        } else if (rotation && pIdx === r2) {
+          rotation[v * 4 + 1] = value;
+        } else if (rotation && pIdx === r3) {
+          rotation[v * 4 + 2] = value;
+        }
+        if (opacity && pIdx === oi) {
+          opacity[v] = value;
+        }
+        if (hasSH && shCoeffs) {
+          const coeffsPerColor = 1 + restIndices.length / 3;
+          const baseIndex = v * coeffsPerColor * 3;
+          if (pIdx === dcIdx[0]) {
+            shCoeffs[baseIndex + 0] = value;
+          } else if (pIdx === dcIdx[1]) {
+            shCoeffs[baseIndex + coeffsPerColor + 0] = value;
+          } else if (pIdx === dcIdx[2]) {
+            shCoeffs[baseIndex + 2 * coeffsPerColor + 0] = value;
+          }
+          for (let i = 0; i < restIndices.length; i += 3) {
+            const ri = restIndices[i + 0];
+            const gi = restIndices[i + 1];
+            const bi = restIndices[i + 2];
+            if (pIdx === ri) {
+              shCoeffs[baseIndex + (i / 3 + 1)] = value;
+            } else if (pIdx === gi) {
+              shCoeffs[baseIndex + coeffsPerColor + (i / 3 + 1)] = value;
+            } else if (pIdx === bi) {
+              shCoeffs[baseIndex + 2 * coeffsPerColor + (i / 3 + 1)] = value;
+            }
+          }
+        }
+      }
+    }
+    return {
+      vertexCount,
+      position,
+      scale,
+      rotation,
+      opacity,
+      sh: hasSH && shCoeffs ? { order: shOrder, coeffs: shCoeffs } : void 0
+    };
+  }
+  function parsePlyMesh(buffer) {
+    const header = parsePlyHeader(buffer);
+    const { format, vertexCount, faceCount, properties, faceProperties, textureFiles, headerByteLength } = header;
+    if (format === "ascii") {
+      return parsePlyMeshASCII(buffer, header);
+    } else {
+      return parsePlyMeshBinary(buffer, header);
+    }
+  }
+  function parsePlyMeshBinary(buffer, header) {
+    const { vertexCount, faceCount, properties, faceProperties, textureFiles, 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 hasTexcoord = faceProperties?.some((p) => p.name === "texcoord") || false;
+    const hasTexnumber = faceProperties?.some((p) => p.name === "texnumber") || false;
+    faceProperties?.find((p) => p.name === "texcoord");
+    faceProperties?.find((p) => p.name === "texnumber");
+    const position = new Float32Array(vertexCount * 3);
+    const hasNormalData = has("nx") && has("ny") && has("nz");
+    const normal = hasNormalData ? new Float32Array(vertexCount * 3) : new Float32Array(vertexCount * 3);
+    const color = (has("red") || has("r")) && (has("green") || has("g")) && (has("blue") || has("b")) ? new Float32Array(vertexCount * 3) : void 0;
+    const hasVertexUV = (has("u") || has("s")) && (has("v") || has("t"));
+    const uv = hasVertexUV || hasTexcoord ? new Float32Array(vertexCount * 2) : void 0;
+    const faceTexcoords = /* @__PURE__ */ new Map();
+    const faceTexnumbers = hasTexnumber ? new Array(faceCount) : [];
+    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 (hasNormalData) {
+        const nx = propIndex("nx");
+        const ny = propIndex("ny");
+        const nz = propIndex("nz");
+        normal[v * 3 + 0] = readByType(payload, vOffset + propOffsets[nx], properties[nx].type);
+        normal[v * 3 + 1] = readByType(payload, vOffset + propOffsets[ny], properties[ny].type);
+        normal[v * 3 + 2] = readByType(payload, vOffset + propOffsets[nz], properties[nz].type);
+      }
+      if (color) {
+        const rIdx = propIndex("red") >= 0 ? propIndex("red") : propIndex("r");
+        const gIdx = propIndex("green") >= 0 ? propIndex("green") : propIndex("g");
+        const bIdx = propIndex("blue") >= 0 ? propIndex("blue") : propIndex("b");
+        if (rIdx >= 0 && gIdx >= 0 && bIdx >= 0) {
+          let r = readByType(payload, vOffset + propOffsets[rIdx], properties[rIdx].type);
+          let g = readByType(payload, vOffset + propOffsets[gIdx], properties[gIdx].type);
+          let b = readByType(payload, vOffset + propOffsets[bIdx], properties[bIdx].type);
+          if (properties[rIdx].type === "uchar" || properties[rIdx].type === "uint8") {
+            r /= 255;
+            g /= 255;
+            b /= 255;
+          }
+          color[v * 3 + 0] = r;
+          color[v * 3 + 1] = g;
+          color[v * 3 + 2] = b;
+        }
+      }
+      if (uv) {
+        const uIdx = propIndex("u") >= 0 ? propIndex("u") : propIndex("s");
+        const vIdx = propIndex("v") >= 0 ? propIndex("v") : propIndex("t");
+        if (uIdx >= 0 && vIdx >= 0) {
+          uv[v * 2 + 0] = readByType(payload, vOffset + propOffsets[uIdx], properties[uIdx].type);
+          uv[v * 2 + 1] = readByType(payload, vOffset + propOffsets[vIdx], properties[vIdx].type);
+        }
+      }
+      base += stride;
+    }
+    const indices = [];
+    const triangleTexnumbers = [];
+    const faceVertexUvs = [];
+    let faceBase = base;
+    uv && !hasVertexUV && !hasTexcoord ? new Array(vertexCount).fill(false) : null;
+    for (let f = 0; f < faceCount; f++) {
+      let currentOffset = faceBase;
+      let faceIndices = [];
+      let faceTexcoordArray = void 0;
+      let faceTexnum = 0;
+      let vertexCountInFace = 0;
+      if (!faceProperties || faceProperties.length === 0) {
+        throw new Error("PLY: Face element must have properties");
+      }
+      for (const prop of faceProperties) {
+        if (prop.name === "vertex_indices") {
+          const parts = prop.type.split(" ");
+          if (parts.length !== 3 || parts[0] !== "list") {
+            throw new Error(`PLY: Invalid vertex_indices property type: ${prop.type}`);
+          }
+          const countType = parts[1];
+          const itemType = parts[2];
+          vertexCountInFace = readByType(payload, currentOffset, countType);
+          currentOffset += byteSizeOfType(countType);
+          if (vertexCountInFace < 3) {
+            throw new Error(`PLY: Face ${f} has less than 3 vertices`);
+          }
+          const indexSize = byteSizeOfType(itemType);
+          faceIndices = [];
+          for (let i = 0; i < vertexCountInFace; i++) {
+            const idx = readByType(payload, currentOffset, itemType);
+            faceIndices.push(idx);
+            currentOffset += indexSize;
+          }
+        } else if (prop.name === "texcoord") {
+          const parts = prop.type.split(" ");
+          if (parts.length !== 3 || parts[0] !== "list") {
+            throw new Error(`PLY: Invalid texcoord property type: ${prop.type}`);
+          }
+          const countType = parts[1];
+          const itemType = parts[2];
+          const texcoordCount = readByType(payload, currentOffset, countType);
+          currentOffset += byteSizeOfType(countType);
+          const itemSize = byteSizeOfType(itemType);
+          faceTexcoordArray = new Float32Array(texcoordCount);
+          for (let i = 0; i < texcoordCount; i++) {
+            faceTexcoordArray[i] = readByType(payload, currentOffset, itemType);
+            currentOffset += itemSize;
+          }
+          faceTexcoords.set(f, faceTexcoordArray);
+        } else if (prop.name === "texnumber") {
+          faceTexnum = readByType(payload, currentOffset, prop.type);
+          currentOffset += byteSizeOfType(prop.type);
+          faceTexnumbers[f] = faceTexnum;
+        } else {
+          if (prop.type.startsWith("list ")) {
+            const parts = prop.type.split(" ");
+            if (parts.length === 3) {
+              const countType = parts[1];
+              const itemType = parts[2];
+              const count = readByType(payload, currentOffset, countType);
+              currentOffset += byteSizeOfType(countType);
+              const itemSize = byteSizeOfType(itemType);
+              currentOffset += count * itemSize;
+            }
+          } else {
+            currentOffset += byteSizeOfType(prop.type);
+          }
+        }
+      }
+      faceBase = currentOffset;
+      const texnum = hasTexnumber ? faceTexnumbers[f] ?? 0 : 0;
+      if (vertexCountInFace === 3) {
+        indices.push(faceIndices[0], faceIndices[1], faceIndices[2]);
+        if (hasTexnumber) {
+          triangleTexnumbers.push(texnum);
+        }
+        if (hasTexcoord && faceTexcoordArray && faceTexcoordArray.length >= 6) {
+          faceVertexUvs.push(
+            faceTexcoordArray[0],
+            1 - faceTexcoordArray[1],
+            // vertex 0
+            faceTexcoordArray[2],
+            1 - faceTexcoordArray[3],
+            // vertex 1
+            faceTexcoordArray[4],
+            1 - faceTexcoordArray[5]
+            // vertex 2
+          );
+        }
+      } else {
+        for (let i = 1; i < vertexCountInFace - 1; i++) {
+          indices.push(faceIndices[0], faceIndices[i], faceIndices[i + 1]);
+          if (hasTexnumber) {
+            triangleTexnumbers.push(texnum);
+          }
+          if (hasTexcoord && faceTexcoordArray && faceTexcoordArray.length >= vertexCountInFace * 2) {
+            faceVertexUvs.push(
+              faceTexcoordArray[0],
+              1 - faceTexcoordArray[1],
+              // vertex 0 (center of fan)
+              faceTexcoordArray[i * 2 + 0],
+              1 - faceTexcoordArray[i * 2 + 1],
+              // vertex i
+              faceTexcoordArray[(i + 1) * 2 + 0],
+              1 - faceTexcoordArray[(i + 1) * 2 + 1]
+              // vertex i+1
+            );
+          }
+        }
+      }
+    }
+    if (!hasNormalData) {
+      for (let i = 0; i < vertexCount * 3; i++) {
+        normal[i] = 0;
+      }
+      for (let i = 0; i < indices.length; i += 3) {
+        const i0 = indices[i];
+        const i1 = indices[i + 1];
+        const i2 = indices[i + 2];
+        const v0x = position[i0 * 3 + 0];
+        const v0y = position[i0 * 3 + 1];
+        const v0z = position[i0 * 3 + 2];
+        const v1x = position[i1 * 3 + 0];
+        const v1y = position[i1 * 3 + 1];
+        const v1z = position[i1 * 3 + 2];
+        const v2x = position[i2 * 3 + 0];
+        const v2y = position[i2 * 3 + 1];
+        const v2z = position[i2 * 3 + 2];
+        const edge1x = v1x - v0x;
+        const edge1y = v1y - v0y;
+        const edge1z = v1z - v0z;
+        const edge2x = v2x - v0x;
+        const edge2y = v2y - v0y;
+        const edge2z = v2z - v0z;
+        const nx = edge1y * edge2z - edge1z * edge2y;
+        const ny = edge1z * edge2x - edge1x * edge2z;
+        const nz = edge1x * edge2y - edge1y * edge2x;
+        normal[i0 * 3 + 0] += nx;
+        normal[i0 * 3 + 1] += ny;
+        normal[i0 * 3 + 2] += nz;
+        normal[i1 * 3 + 0] += nx;
+        normal[i1 * 3 + 1] += ny;
+        normal[i1 * 3 + 2] += nz;
+        normal[i2 * 3 + 0] += nx;
+        normal[i2 * 3 + 1] += ny;
+        normal[i2 * 3 + 2] += nz;
+      }
+      for (let v = 0; v < vertexCount; v++) {
+        const nx = normal[v * 3 + 0];
+        const ny = normal[v * 3 + 1];
+        const nz = normal[v * 3 + 2];
+        const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+        if (length > 1e-5) {
+          normal[v * 3 + 0] = nx / length;
+          normal[v * 3 + 1] = ny / length;
+          normal[v * 3 + 2] = nz / length;
+        } else {
+          normal[v * 3 + 0] = 0;
+          normal[v * 3 + 1] = 1;
+          normal[v * 3 + 2] = 0;
+        }
+      }
+    }
+    let finalPosition = position;
+    let finalNormal = normal;
+    let finalColor = color;
+    let finalUv = void 0;
+    let finalIndices = void 0;
+    if (hasTexcoord && faceVertexUvs.length > 0) {
+      const triangleCount = indices.length / 3;
+      const expandedPosition = new Float32Array(triangleCount * 3 * 3);
+      const expandedNormal = new Float32Array(triangleCount * 3 * 3);
+      const expandedColor = color ? new Float32Array(triangleCount * 3 * 3) : void 0;
+      finalUv = new Float32Array(faceVertexUvs);
+      for (let i = 0; i < triangleCount; i++) {
+        const baseIdx = i * 3;
+        const i0 = indices[baseIdx + 0];
+        const i1 = indices[baseIdx + 1];
+        const i2 = indices[baseIdx + 2];
+        expandedPosition[i * 9 + 0] = position[i0 * 3 + 0];
+        expandedPosition[i * 9 + 1] = position[i0 * 3 + 1];
+        expandedPosition[i * 9 + 2] = position[i0 * 3 + 2];
+        expandedPosition[i * 9 + 3] = position[i1 * 3 + 0];
+        expandedPosition[i * 9 + 4] = position[i1 * 3 + 1];
+        expandedPosition[i * 9 + 5] = position[i1 * 3 + 2];
+        expandedPosition[i * 9 + 6] = position[i2 * 3 + 0];
+        expandedPosition[i * 9 + 7] = position[i2 * 3 + 1];
+        expandedPosition[i * 9 + 8] = position[i2 * 3 + 2];
+        expandedNormal[i * 9 + 0] = normal[i0 * 3 + 0];
+        expandedNormal[i * 9 + 1] = normal[i0 * 3 + 1];
+        expandedNormal[i * 9 + 2] = normal[i0 * 3 + 2];
+        expandedNormal[i * 9 + 3] = normal[i1 * 3 + 0];
+        expandedNormal[i * 9 + 4] = normal[i1 * 3 + 1];
+        expandedNormal[i * 9 + 5] = normal[i1 * 3 + 2];
+        expandedNormal[i * 9 + 6] = normal[i2 * 3 + 0];
+        expandedNormal[i * 9 + 7] = normal[i2 * 3 + 1];
+        expandedNormal[i * 9 + 8] = normal[i2 * 3 + 2];
+        if (expandedColor && color) {
+          expandedColor[i * 9 + 0] = color[i0 * 3 + 0];
+          expandedColor[i * 9 + 1] = color[i0 * 3 + 1];
+          expandedColor[i * 9 + 2] = color[i0 * 3 + 2];
+          expandedColor[i * 9 + 3] = color[i1 * 3 + 0];
+          expandedColor[i * 9 + 4] = color[i1 * 3 + 1];
+          expandedColor[i * 9 + 5] = color[i1 * 3 + 2];
+          expandedColor[i * 9 + 6] = color[i2 * 3 + 0];
+          expandedColor[i * 9 + 7] = color[i2 * 3 + 1];
+          expandedColor[i * 9 + 8] = color[i2 * 3 + 2];
+        }
+      }
+      finalPosition = expandedPosition;
+      finalNormal = expandedNormal;
+      finalColor = expandedColor;
+      const sequentialIndices = new Uint32Array(triangleCount * 3);
+      for (let i = 0; i < triangleCount * 3; i++) {
+        sequentialIndices[i] = i;
+      }
+      finalIndices = sequentialIndices;
+    } else {
+      finalIndices = new Uint32Array(indices);
+      finalUv = uv;
+    }
+    return {
+      vertexCount: hasTexcoord && faceVertexUvs.length > 0 ? finalPosition.length / 3 : vertexCount,
+      faceCount,
+      position: finalPosition,
+      normal: finalNormal,
+      color: finalColor,
+      uv: finalUv,
+      indices: finalIndices,
+      textureFiles: textureFiles.length > 0 ? textureFiles : void 0,
+      triangleTexnumbers: triangleTexnumbers.length > 0 ? triangleTexnumbers : void 0
+    };
+  }
+  function parsePlyMeshASCII(buffer, header) {
+    const { vertexCount, faceCount, properties, faceProperties, textureFiles, headerByteLength } = header;
+    const text = new TextDecoder("utf-8").decode(buffer);
+    const headerEnd = text.indexOf("end_header");
+    if (headerEnd < 0) {
+      throw new Error("PLY: Invalid PLY header");
+    }
+    let bodyStart = headerEnd + "end_header".length;
+    while (bodyStart < text.length && (text[bodyStart] === " " || text[bodyStart] === "\n" || text[bodyStart] === "\r")) {
+      bodyStart++;
+    }
+    const bodyText = text.substring(bodyStart);
+    const tokens = bodyText.split(/\s+/).filter((token) => token.length > 0);
+    let tokenIndex = 0;
+    const has = (n) => properties.find((p) => p.name === n) != null;
+    const parseASCIINumber = (type) => {
+      if (tokenIndex >= tokens.length) {
+        throw new Error("PLY: Unexpected end of file");
+      }
+      const value = tokens[tokenIndex++];
+      switch (type) {
+        case "char":
+        case "uchar":
+        case "short":
+        case "ushort":
+        case "int":
+        case "uint":
+        case "int8":
+        case "uint8":
+        case "int16":
+        case "uint16":
+        case "int32":
+        case "uint32":
+          return parseInt(value);
+        case "float":
+        case "double":
+        case "float32":
+        case "float64":
+          return parseFloat(value);
+        default:
+          return parseFloat(value);
+      }
+    };
+    const position = new Float32Array(vertexCount * 3);
+    const hasNormalData = has("nx") && has("ny") && has("nz");
+    const normal = hasNormalData ? new Float32Array(vertexCount * 3) : new Float32Array(vertexCount * 3);
+    const color = (has("red") || has("r")) && (has("green") || has("g")) && (has("blue") || has("b")) ? new Float32Array(vertexCount * 3) : void 0;
+    const hasVertexUV = (has("u") || has("s")) && (has("v") || has("t"));
+    const hasTexcoord = faceProperties?.some((p) => p.name === "texcoord") || false;
+    const uv = hasVertexUV || hasTexcoord ? new Float32Array(vertexCount * 2) : void 0;
+    const faceTexcoords = /* @__PURE__ */ new Map();
+    const hasTexnumber = faceProperties?.some((p) => p.name === "texnumber") || false;
+    const faceTexnumbers = hasTexnumber ? new Array(faceCount) : [];
+    const indices = [];
+    const triangleTexnumbers = [];
+    const faceVertexUvs = [];
+    const propIndex = (n) => properties.findIndex((p) => p.name === n);
+    const xIdx = propIndex("x");
+    const yIdx = propIndex("y");
+    const zIdx = propIndex("z");
+    const nxIdx = hasNormalData ? propIndex("nx") : -1;
+    const nyIdx = hasNormalData ? propIndex("ny") : -1;
+    const nzIdx = hasNormalData ? propIndex("nz") : -1;
+    const rIdx = color ? propIndex("red") >= 0 ? propIndex("red") : propIndex("r") : -1;
+    const gIdx = color ? propIndex("green") >= 0 ? propIndex("green") : propIndex("g") : -1;
+    const bIdx = color ? propIndex("blue") >= 0 ? propIndex("blue") : propIndex("b") : -1;
+    const uIdx = uv && hasVertexUV ? propIndex("u") >= 0 ? propIndex("u") : propIndex("s") : -1;
+    const vIdx = uv && hasVertexUV ? propIndex("v") >= 0 ? propIndex("v") : propIndex("t") : -1;
+    for (let v = 0; v < vertexCount; v++) {
+      for (let pIdx = 0; pIdx < properties.length; pIdx++) {
+        const prop = properties[pIdx];
+        const value = parseASCIINumber(prop.type);
+        if (pIdx === xIdx) {
+          position[v * 3 + 0] = value;
+        } else if (pIdx === yIdx) {
+          position[v * 3 + 1] = value;
+        } else if (pIdx === zIdx) {
+          position[v * 3 + 2] = value;
+        } else if (pIdx === nxIdx) {
+          normal[v * 3 + 0] = value;
+        } else if (pIdx === nyIdx) {
+          normal[v * 3 + 1] = value;
+        } else if (pIdx === nzIdx) {
+          normal[v * 3 + 2] = value;
+        } else if (pIdx === rIdx && color) {
+          color[v * 3 + 0] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
+        } else if (pIdx === gIdx && color) {
+          color[v * 3 + 1] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
+        } else if (pIdx === bIdx && color) {
+          color[v * 3 + 2] = prop.type === "uchar" || prop.type === "uint8" ? value / 255 : value;
+        } else if (pIdx === uIdx && uv) {
+          uv[v * 2 + 0] = value;
+        } else if (pIdx === vIdx && uv) {
+          uv[v * 2 + 1] = value;
+        }
+      }
+    }
+    for (let f = 0; f < faceCount; f++) {
+      let faceIndices = [];
+      let faceTexcoordArray = void 0;
+      let faceTexnum = 0;
+      for (const prop of faceProperties || []) {
+        if (prop.name === "vertex_indices") {
+          const parts = prop.type.split(" ");
+          const countType = parts[1];
+          const itemType = parts[2];
+          const vertexCountInFace2 = parseASCIINumber(countType);
+          faceIndices = [];
+          for (let i = 0; i < vertexCountInFace2; i++) {
+            faceIndices.push(parseASCIINumber(itemType));
+          }
+        } else if (prop.name === "texcoord") {
+          const parts = prop.type.split(" ");
+          const countType = parts[1];
+          const itemType = parts[2];
+          const texcoordCount = parseASCIINumber(countType);
+          faceTexcoordArray = new Float32Array(texcoordCount);
+          for (let i = 0; i < texcoordCount; i++) {
+            faceTexcoordArray[i] = parseASCIINumber(itemType);
+          }
+          faceTexcoords.set(f, faceTexcoordArray);
+        } else if (prop.name === "texnumber") {
+          faceTexnum = parseASCIINumber(prop.type);
+          faceTexnumbers[f] = faceTexnum;
+        }
+      }
+      const vertexCountInFace = faceIndices.length;
+      const texnum = hasTexnumber ? faceTexnumbers[f] ?? 0 : 0;
+      if (vertexCountInFace === 3) {
+        indices.push(faceIndices[0], faceIndices[1], faceIndices[2]);
+        if (hasTexnumber) {
+          triangleTexnumbers.push(texnum);
+        }
+        if (hasTexcoord && faceTexcoordArray && faceTexcoordArray.length >= 6) {
+          faceVertexUvs.push(
+            faceTexcoordArray[0],
+            1 - faceTexcoordArray[1],
+            faceTexcoordArray[2],
+            1 - faceTexcoordArray[3],
+            faceTexcoordArray[4],
+            1 - faceTexcoordArray[5]
+          );
+        }
+      } else {
+        for (let i = 1; i < vertexCountInFace - 1; i++) {
+          indices.push(faceIndices[0], faceIndices[i], faceIndices[i + 1]);
+          if (hasTexnumber) {
+            triangleTexnumbers.push(texnum);
+          }
+          if (hasTexcoord && faceTexcoordArray && faceTexcoordArray.length >= vertexCountInFace * 2) {
+            faceVertexUvs.push(
+              faceTexcoordArray[0],
+              1 - faceTexcoordArray[1],
+              faceTexcoordArray[i * 2 + 0],
+              1 - faceTexcoordArray[i * 2 + 1],
+              faceTexcoordArray[(i + 1) * 2 + 0],
+              1 - faceTexcoordArray[(i + 1) * 2 + 1]
+            );
+          }
+        }
+      }
+    }
+    if (!hasNormalData) {
+      for (let i = 0; i < vertexCount * 3; i++) {
+        normal[i] = 0;
+      }
+      for (let i = 0; i < indices.length; i += 3) {
+        const i0 = indices[i];
+        const i1 = indices[i + 1];
+        const i2 = indices[i + 2];
+        const v0x = position[i0 * 3 + 0];
+        const v0y = position[i0 * 3 + 1];
+        const v0z = position[i0 * 3 + 2];
+        const v1x = position[i1 * 3 + 0];
+        const v1y = position[i1 * 3 + 1];
+        const v1z = position[i1 * 3 + 2];
+        const v2x = position[i2 * 3 + 0];
+        const v2y = position[i2 * 3 + 1];
+        const v2z = position[i2 * 3 + 2];
+        const edge1x = v1x - v0x;
+        const edge1y = v1y - v0y;
+        const edge1z = v1z - v0z;
+        const edge2x = v2x - v0x;
+        const edge2y = v2y - v0y;
+        const edge2z = v2z - v0z;
+        const nx = edge1y * edge2z - edge1z * edge2y;
+        const ny = edge1z * edge2x - edge1x * edge2z;
+        const nz = edge1x * edge2y - edge1y * edge2x;
+        normal[i0 * 3 + 0] += nx;
+        normal[i0 * 3 + 1] += ny;
+        normal[i0 * 3 + 2] += nz;
+        normal[i1 * 3 + 0] += nx;
+        normal[i1 * 3 + 1] += ny;
+        normal[i1 * 3 + 2] += nz;
+        normal[i2 * 3 + 0] += nx;
+        normal[i2 * 3 + 1] += ny;
+        normal[i2 * 3 + 2] += nz;
+      }
+      for (let v = 0; v < vertexCount; v++) {
+        const nx = normal[v * 3 + 0];
+        const ny = normal[v * 3 + 1];
+        const nz = normal[v * 3 + 2];
+        const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+        if (length > 1e-5) {
+          normal[v * 3 + 0] = nx / length;
+          normal[v * 3 + 1] = ny / length;
+          normal[v * 3 + 2] = nz / length;
+        } else {
+          normal[v * 3 + 0] = 0;
+          normal[v * 3 + 1] = 1;
+          normal[v * 3 + 2] = 0;
+        }
+      }
+    }
+    let finalPosition = position;
+    let finalNormal = normal;
+    let finalColor = color;
+    let finalUv = void 0;
+    let finalIndices = void 0;
+    if (hasTexcoord && faceVertexUvs.length > 0) {
+      const triangleCount = indices.length / 3;
+      const expandedPosition = new Float32Array(triangleCount * 3 * 3);
+      const expandedNormal = new Float32Array(triangleCount * 3 * 3);
+      const expandedColor = color ? new Float32Array(triangleCount * 3 * 3) : void 0;
+      finalUv = new Float32Array(faceVertexUvs);
+      for (let i = 0; i < triangleCount; i++) {
+        const baseIdx = i * 3;
+        const i0 = indices[baseIdx + 0];
+        const i1 = indices[baseIdx + 1];
+        const i2 = indices[baseIdx + 2];
+        expandedPosition[i * 9 + 0] = position[i0 * 3 + 0];
+        expandedPosition[i * 9 + 1] = position[i0 * 3 + 1];
+        expandedPosition[i * 9 + 2] = position[i0 * 3 + 2];
+        expandedPosition[i * 9 + 3] = position[i1 * 3 + 0];
+        expandedPosition[i * 9 + 4] = position[i1 * 3 + 1];
+        expandedPosition[i * 9 + 5] = position[i1 * 3 + 2];
+        expandedPosition[i * 9 + 6] = position[i2 * 3 + 0];
+        expandedPosition[i * 9 + 7] = position[i2 * 3 + 1];
+        expandedPosition[i * 9 + 8] = position[i2 * 3 + 2];
+        expandedNormal[i * 9 + 0] = normal[i0 * 3 + 0];
+        expandedNormal[i * 9 + 1] = normal[i0 * 3 + 1];
+        expandedNormal[i * 9 + 2] = normal[i0 * 3 + 2];
+        expandedNormal[i * 9 + 3] = normal[i1 * 3 + 0];
+        expandedNormal[i * 9 + 4] = normal[i1 * 3 + 1];
+        expandedNormal[i * 9 + 5] = normal[i1 * 3 + 2];
+        expandedNormal[i * 9 + 6] = normal[i2 * 3 + 0];
+        expandedNormal[i * 9 + 7] = normal[i2 * 3 + 1];
+        expandedNormal[i * 9 + 8] = normal[i2 * 3 + 2];
+        if (expandedColor && color) {
+          expandedColor[i * 9 + 0] = color[i0 * 3 + 0];
+          expandedColor[i * 9 + 1] = color[i0 * 3 + 1];
+          expandedColor[i * 9 + 2] = color[i0 * 3 + 2];
+          expandedColor[i * 9 + 3] = color[i1 * 3 + 0];
+          expandedColor[i * 9 + 4] = color[i1 * 3 + 1];
+          expandedColor[i * 9 + 5] = color[i1 * 3 + 2];
+          expandedColor[i * 9 + 6] = color[i2 * 3 + 0];
+          expandedColor[i * 9 + 7] = color[i2 * 3 + 1];
+          expandedColor[i * 9 + 8] = color[i2 * 3 + 2];
+        }
+      }
+      finalPosition = expandedPosition;
+      finalNormal = expandedNormal;
+      finalColor = expandedColor;
+      const sequentialIndices = new Uint32Array(triangleCount * 3);
+      for (let i = 0; i < triangleCount * 3; i++) {
+        sequentialIndices[i] = i;
+      }
+      finalIndices = sequentialIndices;
+    } else {
+      finalIndices = new Uint32Array(indices);
+      finalUv = uv;
+    }
+    return {
+      vertexCount: hasTexcoord && faceVertexUvs.length > 0 ? finalPosition.length / 3 : vertexCount,
+      faceCount,
+      position: finalPosition,
+      normal: finalNormal,
+      color: finalColor,
+      uv: finalUv,
+      indices: finalIndices,
+      textureFiles: textureFiles.length > 0 ? textureFiles : void 0,
+      triangleTexnumbers: triangleTexnumbers.length > 0 ? triangleTexnumbers : void 0
+    };
+  }
 
   class GaussianSplatParser extends ParserBase {
     static format = ParserFormat.BIN;
@@ -59339,6 +60273,133 @@ fn frag(){
   class KHR_materials_ior {
   }
 
+  class PlyParser extends ParserBase {
+    static format = ParserFormat.BIN;
+    async parseBuffer(buffer) {
+      const header = parsePlyHeader(buffer);
+      switch (header.mode) {
+        case PlyMode.Splat: {
+          const plyData = parsePlyGaussianSplat(buffer);
+          const asset = {
+            count: plyData.vertexCount,
+            position: plyData.position,
+            rotation: plyData.rotation,
+            scale: plyData.scale,
+            opacity: plyData.opacity,
+            sh: plyData.sh
+          };
+          asset.bbox = computeAABBFromPositions(plyData.position);
+          const gsplatObj = new exports.Object3D();
+          gsplatObj.name = "GaussianSplat";
+          const renderer = gsplatObj.addComponent(exports.GSplatRenderer);
+          renderer.initAsset(asset);
+          this.data = gsplatObj;
+          break;
+        }
+        case PlyMode.PointCloud: {
+          break;
+        }
+        case PlyMode.Mesh: {
+          const plyData = parsePlyMesh(buffer);
+          const rootObj = new exports.Object3D();
+          rootObj.name = "PLYMesh";
+          const textureGroups = /* @__PURE__ */ new Map();
+          if (plyData.triangleTexnumbers && plyData.triangleTexnumbers.length > 0) {
+            for (let i = 0; i < plyData.triangleTexnumbers.length; i++) {
+              const texnum = plyData.triangleTexnumbers[i];
+              if (!textureGroups.has(texnum)) {
+                textureGroups.set(texnum, []);
+              }
+              textureGroups.get(texnum).push(i);
+            }
+          } else {
+            const triangleCount = plyData.indices.length / 3;
+            const allTriangles = [];
+            for (let i = 0; i < triangleCount; i++) {
+              allTriangles.push(i);
+            }
+            textureGroups.set(0, allTriangles);
+          }
+          const materials = /* @__PURE__ */ new Map();
+          if (plyData.textureFiles && plyData.textureFiles.length > 0) {
+            const promiseList = [];
+            for (let texnum = 0; texnum < plyData.textureFiles.length; texnum++) {
+              const material = new LitMaterial();
+              const texturePath = StringUtil.normalizePath(
+                this.baseUrl + plyData.textureFiles[texnum]
+              );
+              promiseList.push(Engine3D.res.loadTexture(texturePath).then((texture) => {
+                material.baseMap = texture;
+                materials.set(texnum, material);
+              }));
+            }
+            await Promise.all(promiseList);
+          }
+          if (materials.size === 0) {
+            materials.set(0, new LitMaterial());
+          }
+          for (const [texnum, triangleIndices] of textureGroups) {
+            const groupIndices = [];
+            for (const triIdx of triangleIndices) {
+              const baseIdx = triIdx * 3;
+              groupIndices.push(
+                plyData.indices[baseIdx + 0],
+                plyData.indices[baseIdx + 1],
+                plyData.indices[baseIdx + 2]
+              );
+            }
+            const geometry = new GeometryBase();
+            geometry.setAttribute(
+              VertexAttributeName.position,
+              plyData.position
+            );
+            geometry.setAttribute(
+              VertexAttributeName.normal,
+              plyData.normal
+            );
+            if (plyData.uv) {
+              geometry.setAttribute(
+                VertexAttributeName.uv,
+                plyData.uv
+              );
+            }
+            if (plyData.color) {
+              geometry.setAttribute(
+                VertexAttributeName.color,
+                plyData.color
+              );
+            }
+            geometry.setIndices(new Uint32Array(groupIndices));
+            geometry.addSubGeometry({
+              indexStart: 0,
+              indexCount: groupIndices.length,
+              vertexStart: 0,
+              vertexCount: 0,
+              firstStart: 0,
+              index: 0,
+              topology: 0
+            });
+            let material = materials.get(texnum);
+            if (!material) {
+              material = materials.values().next().value || new LitMaterial();
+            }
+            const meshObj = new exports.Object3D();
+            meshObj.name = `PLYMesh_Texture_${texnum}`;
+            const renderer = meshObj.addComponent(exports.MeshRenderer);
+            renderer.geometry = geometry;
+            renderer.material = material;
+            rootObj.addChild(meshObj);
+          }
+          this.data = rootObj;
+          break;
+        }
+      }
+    }
+    verification() {
+      return !!this.data;
+    }
+  }
+
   class PrefabBoneData {
     boneName;
     bonePath;
@@ -62527,7 +63588,7 @@ fn frag(){
               if (sceneObj.parent) {
                 sceneObj.parent.object3D.removeChild(sceneObj);
               }
-              sceneObj.destroy();
+              sceneObj.destroy(true);
               tileItem.cached.scene = null;
             }
             tileItem.loadingState = UNLOADED;
@@ -62841,7 +63902,7 @@ fn frag(){
     /**
      * Clean up resources
      */
-    dispose() {
+    dispose(force) {
       const plugins = [...this.plugins];
       plugins.forEach((plugin) => this.unregisterPlugin(plugin));
       this.lruCache.clear();
@@ -62853,7 +63914,7 @@ fn frag(){
       this.frameCount = 0;
       this.isLoading = false;
       this.resetCacheStats();
-      this.group.destroy();
+      this.group.destroy(force);
     }
     /**
      * Rings-specific: Add camera
@@ -69322,6 +70383,8 @@ fn frag(){
   exports.Plane3D = Plane3D;
   exports.PlaneClassification = PlaneClassification;
   exports.PlaneGeometry = PlaneGeometry;
+  exports.PlyMode = PlyMode;
+  exports.PlyParser = PlyParser;
   exports.PointClassification = PointClassification;
   exports.PointLightShadowRenderer = PointLightShadowRenderer;
   exports.PointShadowCubeCamera = PointShadowCubeCamera;
@@ -69662,6 +70725,7 @@ fn frag(){
   exports.outlinePostManager = outlinePostManager;
   exports.parsePlyGaussianSplat = parsePlyGaussianSplat;
   exports.parsePlyHeader = parsePlyHeader;
+  exports.parsePlyMesh = parsePlyMesh;
   exports.perm = perm;
   exports.post = post;
   exports.priorityCallback = priorityCallback;
@@ -69697,6 +70761,8 @@ fn frag(){
   exports.snoise2 = snoise2;
   exports.snoise3 = snoise3;
   exports.snoise4 = snoise4;
+  exports.splatColorProperties = splatColorProperties;
+  exports.splatProperties = splatProperties;
   exports.sqrMagnitude = sqrMagnitude;
   exports.sqrtImpl = sqrtImpl;
   exports.stencilStateFace = stencilStateFace;