@babylonjs/lite 0.1.1

package/splat-ply-compressed-BahdBG1r.js

@@ -0,0 +1,394 @@
+const SH_C0 = 0.28209479177387814;
+const SQRT2 = Math.SQRT2;
+const ROW_OUTPUT_LENGTH = 32;
+const TYPE_SIZE = { double: 8, int: 4, uint: 4, float: 4, short: 2, ushort: 2, uchar: 1 };
+function shDegreeForIndex(i) {
+  if (i >= 71) {
+    return 4;
+  }
+  if (i >= 44) {
+    return 3;
+  }
+  if (i >= 23) {
+    return 2;
+  }
+  if (i >= 8) {
+    return 1;
+  }
+  return 0;
+}
+function parseHeader(data) {
+  const headerText = new TextDecoder().decode(new Uint8Array(data, 0, Math.min(data.byteLength, 1024 * 10)));
+  const headerEnd = "end_header\n";
+  const idx = headerText.indexOf(headerEnd);
+  if (idx < 0) {
+    return null;
+  }
+  const vmatch = /element vertex (\d+)\n/.exec(headerText);
+  if (!vmatch) {
+    return null;
+  }
+  const vertexCount = parseInt(vmatch[1], 10);
+  const cmatch = /element chunk (\d+)\n/.exec(headerText);
+  const chunkCount = cmatch ? parseInt(cmatch[1], 10) : 0;
+  let section = 1;
+  let rowVertex = 0;
+  let rowChunk = 0;
+  const vertexProps = [];
+  const chunkProps = [];
+  const shProps = [];
+  let shDegree = 0;
+  for (const line of headerText.slice(0, idx).split("\n")) {
+    if (line.startsWith("element ")) {
+      const [, kind] = line.split(" ");
+      section = kind === "chunk" ? 1 : kind === "vertex" ? 0 : kind === "sh" ? 2 : 3;
+      continue;
+    }
+    if (!line.startsWith("property ")) {
+      continue;
+    }
+    const [, type, name] = line.split(" ");
+    if (!type || !name || TYPE_SIZE[type] === void 0) {
+      return null;
+    }
+    const sz = TYPE_SIZE[type];
+    if (section === 1) {
+      chunkProps.push({ name, type, offset: rowChunk });
+      rowChunk += sz;
+    } else if (section === 0) {
+      vertexProps.push({ name, type, offset: rowVertex });
+      rowVertex += sz;
+      if (name.startsWith("f_rest_")) {
+        shDegree = Math.max(shDegree, shDegreeForIndex(parseInt(name.slice(7), 10)));
+      }
+    } else if (section === 2) {
+      shProps.push({ name, type, offset: 0 });
+      if (name.startsWith("f_rest_")) {
+        shDegree = Math.max(shDegree, shDegreeForIndex(parseInt(name.slice(7), 10)));
+      }
+    }
+  }
+  const shCoefficientCount = shDegree ? ((shDegree + 1) * (shDegree + 1) - 1) * 3 : 0;
+  return {
+    vertexCount,
+    chunkCount,
+    rowVertexLength: rowVertex,
+    rowChunkLength: rowChunk,
+    vertexProps,
+    chunkProps,
+    shProps,
+    shDegree,
+    shCoefficientCount,
+    dataStart: idx + headerEnd.length
+  };
+}
+function readChunks(header, dv, offsetRef) {
+  const out = [];
+  for (let i = 0; i < header.chunkCount; i++) {
+    const c = {
+      minX: 0,
+      minY: 0,
+      minZ: 0,
+      maxX: 0,
+      maxY: 0,
+      maxZ: 0,
+      minSX: 0,
+      minSY: 0,
+      minSZ: 0,
+      maxSX: 0,
+      maxSY: 0,
+      maxSZ: 0,
+      minR: 0,
+      minG: 0,
+      minB: 0,
+      maxR: 1,
+      maxG: 1,
+      maxB: 1
+    };
+    for (const p of header.chunkProps) {
+      if (p.type !== "float") {
+        continue;
+      }
+      const v = dv.getFloat32(offsetRef.value + p.offset, true);
+      switch (p.name) {
+        case "min_x":
+          c.minX = v;
+          break;
+        case "min_y":
+          c.minY = v;
+          break;
+        case "min_z":
+          c.minZ = v;
+          break;
+        case "max_x":
+          c.maxX = v;
+          break;
+        case "max_y":
+          c.maxY = v;
+          break;
+        case "max_z":
+          c.maxZ = v;
+          break;
+        case "min_scale_x":
+          c.minSX = v;
+          break;
+        case "min_scale_y":
+          c.minSY = v;
+          break;
+        case "min_scale_z":
+          c.minSZ = v;
+          break;
+        case "max_scale_x":
+          c.maxSX = v;
+          break;
+        case "max_scale_y":
+          c.maxSY = v;
+          break;
+        case "max_scale_z":
+          c.maxSZ = v;
+          break;
+        case "min_r":
+          c.minR = v;
+          break;
+        case "min_g":
+          c.minG = v;
+          break;
+        case "min_b":
+          c.minB = v;
+          break;
+        case "max_r":
+          c.maxR = v;
+          break;
+        case "max_g":
+          c.maxG = v;
+          break;
+        case "max_b":
+          c.maxB = v;
+          break;
+      }
+    }
+    out.push(c);
+    offsetRef.value += header.rowChunkLength;
+  }
+  return out;
+}
+const lerp = (a, b, t) => a + (b - a) * t;
+const clamp255 = (v) => v < 0 ? 0 : v > 255 ? 255 : v;
+function unpack111011(value, out) {
+  out[0] = (value >>> 21 & 2047) / 2047;
+  out[1] = (value >>> 11 & 1023) / 1023;
+  out[2] = (value & 2047) / 2047;
+}
+function unpack8888(value, out) {
+  out[0] = (value >>> 24 & 255) / 255;
+  out[1] = (value >>> 16 & 255) / 255;
+  out[2] = (value >>> 8 & 255) / 255;
+  out[3] = (value & 255) / 255;
+}
+function unpackRot(value, out) {
+  const norm = 1 / (SQRT2 * 0.5);
+  const a = ((value >>> 20 & 1023) / 1023 - 0.5) * norm;
+  const b = ((value >>> 10 & 1023) / 1023 - 0.5) * norm;
+  const c = ((value & 1023) / 1023 - 0.5) * norm;
+  const m = Math.sqrt(Math.max(0, 1 - (a * a + b * b + c * c)));
+  switch (value >>> 30) {
+    case 0:
+      out[0] = a;
+      out[1] = b;
+      out[2] = c;
+      out[3] = m;
+      break;
+    case 1:
+      out[0] = m;
+      out[1] = b;
+      out[2] = c;
+      out[3] = a;
+      break;
+    case 2:
+      out[0] = b;
+      out[1] = m;
+      out[2] = c;
+      out[3] = a;
+      break;
+    default:
+      out[0] = b;
+      out[1] = c;
+      out[2] = m;
+      out[3] = a;
+      break;
+  }
+}
+function convertCompressedPlyToParsedSplat(data) {
+  const header = parseHeader(data);
+  if (!header) {
+    return { data };
+  }
+  const isCompressed = header.chunkCount > 0;
+  const dv = new DataView(data, header.dataStart);
+  const out = new ArrayBuffer(ROW_OUTPUT_LENGTH * header.vertexCount);
+  const tmpPos = [0, 0, 0];
+  const tmpScl = [0, 0, 0];
+  const tmpRgba = [0, 0, 0, 0];
+  const tmpQuat = [0, 0, 0, 1];
+  const offsetRef = { value: 0 };
+  const chunks = isCompressed ? readChunks(header, dv, offsetRef) : null;
+  const shFlat = header.shDegree && header.shCoefficientCount ? new Uint8Array(header.shCoefficientCount * header.vertexCount) : null;
+  const shBlockBase = header.rowChunkLength * header.chunkCount + header.vertexCount * header.rowVertexLength;
+  const shDim = header.shCoefficientCount / 3;
+  for (let i = 0; i < header.vertexCount; i++) {
+    const position = new Float32Array(out, i * ROW_OUTPUT_LENGTH, 3);
+    const scale = new Float32Array(out, i * ROW_OUTPUT_LENGTH + 12, 3);
+    const rgba = new Uint8ClampedArray(out, i * ROW_OUTPUT_LENGTH + 24, 4);
+    const rot = new Uint8ClampedArray(out, i * ROW_OUTPUT_LENGTH + 28, 4);
+    const chunk = chunks ? chunks[i >> 8] : null;
+    let r0 = 255, r1 = 0, r2 = 0, r3 = 0;
+    const plySH = shFlat ? new Array(header.shCoefficientCount) : null;
+    for (const prop of header.vertexProps) {
+      let value;
+      switch (prop.type) {
+        case "float":
+          value = dv.getFloat32(offsetRef.value + prop.offset, true);
+          break;
+        case "int":
+          value = dv.getInt32(offsetRef.value + prop.offset, true);
+          break;
+        case "uint":
+          value = dv.getUint32(offsetRef.value + prop.offset, true);
+          break;
+        case "uchar":
+          value = dv.getUint8(offsetRef.value + prop.offset);
+          break;
+        case "short":
+          value = dv.getInt16(offsetRef.value + prop.offset, true);
+          break;
+        case "ushort":
+          value = dv.getUint16(offsetRef.value + prop.offset, true);
+          break;
+        case "double":
+          value = dv.getFloat64(offsetRef.value + prop.offset, true);
+          break;
+        default:
+          continue;
+      }
+      switch (prop.name) {
+        case "packed_position":
+          unpack111011(value, tmpPos);
+          position[0] = lerp(chunk.minX, chunk.maxX, tmpPos[0]);
+          position[1] = lerp(chunk.minY, chunk.maxY, tmpPos[1]);
+          position[2] = lerp(chunk.minZ, chunk.maxZ, tmpPos[2]);
+          break;
+        case "packed_rotation":
+          unpackRot(value, tmpQuat);
+          r0 = tmpQuat[3];
+          r1 = tmpQuat[0];
+          r2 = tmpQuat[1];
+          r3 = tmpQuat[2];
+          break;
+        case "packed_scale":
+          unpack111011(value, tmpScl);
+          scale[0] = Math.exp(lerp(chunk.minSX, chunk.maxSX, tmpScl[0]));
+          scale[1] = Math.exp(lerp(chunk.minSY, chunk.maxSY, tmpScl[1]));
+          scale[2] = Math.exp(lerp(chunk.minSZ, chunk.maxSZ, tmpScl[2]));
+          break;
+        case "packed_color":
+          unpack8888(value, tmpRgba);
+          rgba[0] = lerp(chunk.minR, chunk.maxR, tmpRgba[0]) * 255;
+          rgba[1] = lerp(chunk.minG, chunk.maxG, tmpRgba[1]) * 255;
+          rgba[2] = lerp(chunk.minB, chunk.maxB, tmpRgba[2]) * 255;
+          rgba[3] = tmpRgba[3] * 255;
+          break;
+        case "x":
+          position[0] = value;
+          break;
+        case "y":
+          position[1] = value;
+          break;
+        case "z":
+          position[2] = value;
+          break;
+        case "scale_0":
+          scale[0] = Math.exp(value);
+          break;
+        case "scale_1":
+          scale[1] = Math.exp(value);
+          break;
+        case "scale_2":
+          scale[2] = Math.exp(value);
+          break;
+        case "red":
+        case "diffuse_red":
+          rgba[0] = value;
+          break;
+        case "green":
+        case "diffuse_green":
+          rgba[1] = value;
+          break;
+        case "blue":
+        case "diffuse_blue":
+          rgba[2] = value;
+          break;
+        case "f_dc_0":
+          rgba[0] = (0.5 + SH_C0 * value) * 255;
+          break;
+        case "f_dc_1":
+          rgba[1] = (0.5 + SH_C0 * value) * 255;
+          break;
+        case "f_dc_2":
+          rgba[2] = (0.5 + SH_C0 * value) * 255;
+          break;
+        case "f_dc_3":
+          rgba[3] = (0.5 + SH_C0 * value) * 255;
+          break;
+        case "opacity":
+          rgba[3] = 1 / (1 + Math.exp(-value)) * 255;
+          break;
+        case "rot_0":
+          r0 = value;
+          break;
+        case "rot_1":
+          r1 = value;
+          break;
+        case "rot_2":
+          r2 = value;
+          break;
+        case "rot_3":
+          r3 = value;
+          break;
+        default:
+          if (plySH && prop.name.startsWith("f_rest_")) {
+            const shIdx = parseInt(prop.name.slice(7), 10);
+            plySH[shIdx] = clamp255(value * 127.5 + 127.5);
+          }
+          break;
+      }
+    }
+    if (plySH && header.shProps.length > 0) {
+      for (let k = 0; k < header.shCoefficientCount; k++) {
+        const b = dv.getUint8(shBlockBase + i * header.shCoefficientCount + k);
+        plySH[k] = clamp255((b * (8 / 255) - 4) * 127.5 + 127.5);
+      }
+    }
+    if (plySH && shFlat) {
+      for (let j = 0; j < shDim; j++) {
+        shFlat[i * header.shCoefficientCount + j * 3 + 0] = plySH[j];
+        shFlat[i * header.shCoefficientCount + j * 3 + 1] = plySH[j + shDim];
+        shFlat[i * header.shCoefficientCount + j * 3 + 2] = plySH[j + shDim * 2];
+      }
+    }
+    const len = Math.hypot(r0, r1, r2, r3) || 1;
+    const inv = 1 / len;
+    rot[0] = r0 * inv * 127.5 + 127.5;
+    rot[1] = r1 * inv * 127.5 + 127.5;
+    rot[2] = r2 * inv * 127.5 + 127.5;
+    rot[3] = r3 * inv * 127.5 + 127.5;
+    offsetRef.value += header.rowVertexLength;
+  }
+  if (shFlat && header.shDegree) {
+    return { data: out, sh: shFlat, shDegree: header.shDegree };
+  }
+  return { data: out };
+}
+export {
+  convertCompressedPlyToParsedSplat
+};
+//# sourceMappingURL=splat-ply-compressed-BahdBG1r.js.map

package/splat-ply-compressed-BahdBG1r.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splat-ply-compressed-BahdBG1r.js","sources":["../src/loader-splat/splat-ply-compressed.ts"],"sourcesContent":["/** Compressed-PLY + SH parser (separate from `splat-ply-parser.ts` so the\n *  standard PLY path stays small enough to fit scene 120's bundle ceiling).\n *\n *  Compressed PLY layout (BJS / PlayCanvas convention):\n *    • `element chunk K`     — K records of 12 floats:\n *        min_x..z, max_x..z, min_scale_*, max_scale_*, min_r..b, max_r..b\n *    • `element vertex N`    — N rows of `packed_position`/`_rotation`/`_scale`/\n *      `_color` (uint32 each); chunkIndex = `vertexIndex >> 8`.\n *    • `element sh M`        — properties define SH bytes laid out in a\n *      *trailing* block (absolute offset `chunkBytes + vertexBytes`).\n *\n *  Standard PLY with per-vertex `f_rest_*` properties also routes through\n *  this parser so SH evaluation stays paired with the rest of the SH\n *  pipeline.\n *\n *  Returns the same `ParsedSplat` contract as `convertPlyToSplat` (flat SH\n *  byte layout — see `splat-data.ts` for the exact convention). */\n\nimport type { ParsedSplat } from \"./splat-data.js\";\n\nconst SH_C0 = 0.28209479177387814;\nconst SQRT2 = Math.SQRT2;\nconst ROW_OUTPUT_LENGTH = 32;\n\nconst TYPE_SIZE: Record<string, number> = { double: 8, int: 4, uint: 4, float: 4, short: 2, ushort: 2, uchar: 1 };\n\nconst enum Section {\n    Vertex = 0,\n    Chunk = 1,\n    SH = 2,\n    Unused = 3,\n}\n\ninterface PlyProp {\n    name: string;\n    type: string;\n    offset: number;\n}\n\ninterface PlyHeader {\n    vertexCount: number;\n    chunkCount: number;\n    rowVertexLength: number;\n    rowChunkLength: number;\n    vertexProps: PlyProp[];\n    chunkProps: PlyProp[];\n    shProps: PlyProp[];\n    shDegree: number;\n    shCoefficientCount: number;\n    dataStart: number;\n}\n\nfunction shDegreeForIndex(i: number): number {\n    if (i >= 71) {\n        return 4;\n    }\n    if (i >= 44) {\n        return 3;\n    }\n    if (i >= 23) {\n        return 2;\n    }\n    if (i >= 8) {\n        return 1;\n    }\n    return 0;\n}\n\nfunction parseHeader(data: ArrayBuffer): PlyHeader | null {\n    const headerText = new TextDecoder().decode(new Uint8Array(data, 0, Math.min(data.byteLength, 1024 * 10)));\n    const headerEnd = \"end_header\\n\";\n    const idx = headerText.indexOf(headerEnd);\n    if (idx < 0) {\n        return null;\n    }\n    const vmatch = /element vertex (\\d+)\\n/.exec(headerText);\n    if (!vmatch) {\n        return null;\n    }\n    const vertexCount = parseInt(vmatch[1]!, 10);\n    const cmatch = /element chunk (\\d+)\\n/.exec(headerText);\n    const chunkCount = cmatch ? parseInt(cmatch[1]!, 10) : 0;\n    let section: Section = Section.Chunk;\n    let rowVertex = 0;\n    let rowChunk = 0;\n    const vertexProps: PlyProp[] = [];\n    const chunkProps: PlyProp[] = [];\n    const shProps: PlyProp[] = [];\n    let shDegree = 0;\n    for (const line of headerText.slice(0, idx).split(\"\\n\")) {\n        if (line.startsWith(\"element \")) {\n            const [, kind] = line.split(\" \");\n            section = kind === \"chunk\" ? Section.Chunk : kind === \"vertex\" ? Section.Vertex : kind === \"sh\" ? Section.SH : Section.Unused;\n            continue;\n        }\n        if (!line.startsWith(\"property \")) {\n            continue;\n        }\n        const [, type, name] = line.split(\" \");\n        if (!type || !name || TYPE_SIZE[type] === undefined) {\n            return null;\n        }\n        const sz = TYPE_SIZE[type]!;\n        if (section === Section.Chunk) {\n            chunkProps.push({ name, type, offset: rowChunk });\n            rowChunk += sz;\n        } else if (section === Section.Vertex) {\n            vertexProps.push({ name, type, offset: rowVertex });\n            rowVertex += sz;\n            if (name.startsWith(\"f_rest_\")) {\n                shDegree = Math.max(shDegree, shDegreeForIndex(parseInt(name.slice(7), 10)));\n            }\n        } else if (section === Section.SH) {\n            shProps.push({ name, type, offset: 0 });\n            if (name.startsWith(\"f_rest_\")) {\n                shDegree = Math.max(shDegree, shDegreeForIndex(parseInt(name.slice(7), 10)));\n            }\n        }\n    }\n    const shCoefficientCount = shDegree ? ((shDegree + 1) * (shDegree + 1) - 1) * 3 : 0;\n    return {\n        vertexCount,\n        chunkCount,\n        rowVertexLength: rowVertex,\n        rowChunkLength: rowChunk,\n        vertexProps,\n        chunkProps,\n        shProps,\n        shDegree,\n        shCoefficientCount,\n        dataStart: idx + headerEnd.length,\n    };\n}\n\ninterface CompressedChunk {\n    minX: number;\n    minY: number;\n    minZ: number;\n    maxX: number;\n    maxY: number;\n    maxZ: number;\n    minSX: number;\n    minSY: number;\n    minSZ: number;\n    maxSX: number;\n    maxSY: number;\n    maxSZ: number;\n    minR: number;\n    minG: number;\n    minB: number;\n    maxR: number;\n    maxG: number;\n    maxB: number;\n}\n\nfunction readChunks(header: PlyHeader, dv: DataView, offsetRef: { value: number }): CompressedChunk[] {\n    const out: CompressedChunk[] = [];\n    for (let i = 0; i < header.chunkCount; i++) {\n        const c: CompressedChunk = {\n            minX: 0,\n            minY: 0,\n            minZ: 0,\n            maxX: 0,\n            maxY: 0,\n            maxZ: 0,\n            minSX: 0,\n            minSY: 0,\n            minSZ: 0,\n            maxSX: 0,\n            maxSY: 0,\n            maxSZ: 0,\n            minR: 0,\n            minG: 0,\n            minB: 0,\n            maxR: 1,\n            maxG: 1,\n            maxB: 1,\n        };\n        for (const p of header.chunkProps) {\n            if (p.type !== \"float\") {\n                continue;\n            }\n            const v = dv.getFloat32(offsetRef.value + p.offset, true);\n            switch (p.name) {\n                case \"min_x\":\n                    c.minX = v;\n                    break;\n                case \"min_y\":\n                    c.minY = v;\n                    break;\n                case \"min_z\":\n                    c.minZ = v;\n                    break;\n                case \"max_x\":\n                    c.maxX = v;\n                    break;\n                case \"max_y\":\n                    c.maxY = v;\n                    break;\n                case \"max_z\":\n                    c.maxZ = v;\n                    break;\n                case \"min_scale_x\":\n                    c.minSX = v;\n                    break;\n                case \"min_scale_y\":\n                    c.minSY = v;\n                    break;\n                case \"min_scale_z\":\n                    c.minSZ = v;\n                    break;\n                case \"max_scale_x\":\n                    c.maxSX = v;\n                    break;\n                case \"max_scale_y\":\n                    c.maxSY = v;\n                    break;\n                case \"max_scale_z\":\n                    c.maxSZ = v;\n                    break;\n                case \"min_r\":\n                    c.minR = v;\n                    break;\n                case \"min_g\":\n                    c.minG = v;\n                    break;\n                case \"min_b\":\n                    c.minB = v;\n                    break;\n                case \"max_r\":\n                    c.maxR = v;\n                    break;\n                case \"max_g\":\n                    c.maxG = v;\n                    break;\n                case \"max_b\":\n                    c.maxB = v;\n                    break;\n            }\n        }\n        out.push(c);\n        offsetRef.value += header.rowChunkLength;\n    }\n    return out;\n}\n\nconst lerp = (a: number, b: number, t: number): number => a + (b - a) * t;\nconst clamp255 = (v: number): number => (v < 0 ? 0 : v > 255 ? 255 : v);\n\n/** Unpack a uint32 as 11-10-11 bits → three normalized floats in [0,1]. */\nfunction unpack111011(value: number, out: [number, number, number]): void {\n    out[0] = ((value >>> 21) & 0x7ff) / 0x7ff;\n    out[1] = ((value >>> 11) & 0x3ff) / 0x3ff;\n    out[2] = (value & 0x7ff) / 0x7ff;\n}\n\n/** Unpack a uint32 as 4 bytes (R,G,B,A normalized to [0,1]). */\nfunction unpack8888(value: number, out: [number, number, number, number]): void {\n    out[0] = ((value >>> 24) & 0xff) / 0xff;\n    out[1] = ((value >>> 16) & 0xff) / 0xff;\n    out[2] = ((value >>> 8) & 0xff) / 0xff;\n    out[3] = (value & 0xff) / 0xff;\n}\n\n/** Unpack a uint32 as (2-bit largest index, 3×10-bit components). Returns\n *  quaternion as [x, y, z, w] matching BJS `Quaternion.set(x, y, z, w)`. */\nfunction unpackRot(value: number, out: [number, number, number, number]): void {\n    const norm = 1.0 / (SQRT2 * 0.5);\n    const a = (((value >>> 20) & 0x3ff) / 0x3ff - 0.5) * norm;\n    const b = (((value >>> 10) & 0x3ff) / 0x3ff - 0.5) * norm;\n    const c = ((value & 0x3ff) / 0x3ff - 0.5) * norm;\n    const m = Math.sqrt(Math.max(0, 1.0 - (a * a + b * b + c * c)));\n    switch (value >>> 30) {\n        case 0:\n            out[0] = a;\n            out[1] = b;\n            out[2] = c;\n            out[3] = m;\n            break;\n        case 1:\n            out[0] = m;\n            out[1] = b;\n            out[2] = c;\n            out[3] = a;\n            break;\n        case 2:\n            out[0] = b;\n            out[1] = m;\n            out[2] = c;\n            out[3] = a;\n            break;\n        default:\n            out[0] = b;\n            out[1] = c;\n            out[2] = m;\n            out[3] = a;\n            break;\n    }\n}\n\n/** Decode a compressed PLY (or a standard PLY with `f_rest_*` SH properties)\n *  into a `ParsedSplat`. Dynamic-imported from `load-splat.ts` when\n *  `isPlyCompressedOrSH(data)` is true, so the standard-PLY path remains\n *  bundle-lean. */\nexport function convertCompressedPlyToParsedSplat(data: ArrayBuffer): ParsedSplat {\n    const header = parseHeader(data);\n    if (!header) {\n        return { data };\n    }\n\n    const isCompressed = header.chunkCount > 0;\n    const dv = new DataView(data, header.dataStart);\n    const out = new ArrayBuffer(ROW_OUTPUT_LENGTH * header.vertexCount);\n\n    const tmpPos: [number, number, number] = [0, 0, 0];\n    const tmpScl: [number, number, number] = [0, 0, 0];\n    const tmpRgba: [number, number, number, number] = [0, 0, 0, 0];\n    const tmpQuat: [number, number, number, number] = [0, 0, 0, 1];\n\n    const offsetRef = { value: 0 };\n    const chunks = isCompressed ? readChunks(header, dv, offsetRef) : null;\n\n    const shFlat = header.shDegree && header.shCoefficientCount ? new Uint8Array(header.shCoefficientCount * header.vertexCount) : null;\n    const shBlockBase = header.rowChunkLength * header.chunkCount + header.vertexCount * header.rowVertexLength;\n    const shDim = header.shCoefficientCount / 3;\n\n    for (let i = 0; i < header.vertexCount; i++) {\n        const position = new Float32Array(out, i * ROW_OUTPUT_LENGTH, 3);\n        const scale = new Float32Array(out, i * ROW_OUTPUT_LENGTH + 12, 3);\n        const rgba = new Uint8ClampedArray(out, i * ROW_OUTPUT_LENGTH + 24, 4);\n        const rot = new Uint8ClampedArray(out, i * ROW_OUTPUT_LENGTH + 28, 4);\n        const chunk = chunks ? chunks[i >> 8] : null;\n\n        let r0 = 255,\n            r1 = 0,\n            r2 = 0,\n            r3 = 0;\n        const plySH = shFlat ? new Array<number>(header.shCoefficientCount) : null;\n\n        for (const prop of header.vertexProps) {\n            let value: number;\n            switch (prop.type) {\n                case \"float\":\n                    value = dv.getFloat32(offsetRef.value + prop.offset, true);\n                    break;\n                case \"int\":\n                    value = dv.getInt32(offsetRef.value + prop.offset, true);\n                    break;\n                case \"uint\":\n                    value = dv.getUint32(offsetRef.value + prop.offset, true);\n                    break;\n                case \"uchar\":\n                    value = dv.getUint8(offsetRef.value + prop.offset);\n                    break;\n                case \"short\":\n                    value = dv.getInt16(offsetRef.value + prop.offset, true);\n                    break;\n                case \"ushort\":\n                    value = dv.getUint16(offsetRef.value + prop.offset, true);\n                    break;\n                case \"double\":\n                    value = dv.getFloat64(offsetRef.value + prop.offset, true);\n                    break;\n                default:\n                    continue;\n            }\n            switch (prop.name) {\n                case \"packed_position\":\n                    unpack111011(value, tmpPos);\n                    position[0] = lerp(chunk!.minX, chunk!.maxX, tmpPos[0]);\n                    position[1] = lerp(chunk!.minY, chunk!.maxY, tmpPos[1]);\n                    position[2] = lerp(chunk!.minZ, chunk!.maxZ, tmpPos[2]);\n                    break;\n                case \"packed_rotation\":\n                    unpackRot(value, tmpQuat);\n                    r0 = tmpQuat[3];\n                    r1 = tmpQuat[0];\n                    r2 = tmpQuat[1];\n                    r3 = tmpQuat[2];\n                    break;\n                case \"packed_scale\":\n                    unpack111011(value, tmpScl);\n                    scale[0] = Math.exp(lerp(chunk!.minSX, chunk!.maxSX, tmpScl[0]));\n                    scale[1] = Math.exp(lerp(chunk!.minSY, chunk!.maxSY, tmpScl[1]));\n                    scale[2] = Math.exp(lerp(chunk!.minSZ, chunk!.maxSZ, tmpScl[2]));\n                    break;\n                case \"packed_color\":\n                    unpack8888(value, tmpRgba);\n                    rgba[0] = lerp(chunk!.minR, chunk!.maxR, tmpRgba[0]) * 255;\n                    rgba[1] = lerp(chunk!.minG, chunk!.maxG, tmpRgba[1]) * 255;\n                    rgba[2] = lerp(chunk!.minB, chunk!.maxB, tmpRgba[2]) * 255;\n                    rgba[3] = tmpRgba[3] * 255;\n                    break;\n                case \"x\":\n                    position[0] = value;\n                    break;\n                case \"y\":\n                    position[1] = value;\n                    break;\n                case \"z\":\n                    position[2] = value;\n                    break;\n                case \"scale_0\":\n                    scale[0] = Math.exp(value);\n                    break;\n                case \"scale_1\":\n                    scale[1] = Math.exp(value);\n                    break;\n                case \"scale_2\":\n                    scale[2] = Math.exp(value);\n                    break;\n                case \"red\":\n                case \"diffuse_red\":\n                    rgba[0] = value;\n                    break;\n                case \"green\":\n                case \"diffuse_green\":\n                    rgba[1] = value;\n                    break;\n                case \"blue\":\n                case \"diffuse_blue\":\n                    rgba[2] = value;\n                    break;\n                case \"f_dc_0\":\n                    rgba[0] = (0.5 + SH_C0 * value) * 255;\n                    break;\n                case \"f_dc_1\":\n                    rgba[1] = (0.5 + SH_C0 * value) * 255;\n                    break;\n                case \"f_dc_2\":\n                    rgba[2] = (0.5 + SH_C0 * value) * 255;\n                    break;\n                case \"f_dc_3\":\n                    rgba[3] = (0.5 + SH_C0 * value) * 255;\n                    break;\n                case \"opacity\":\n                    rgba[3] = (1 / (1 + Math.exp(-value))) * 255;\n                    break;\n                case \"rot_0\":\n                    r0 = value;\n                    break;\n                case \"rot_1\":\n                    r1 = value;\n                    break;\n                case \"rot_2\":\n                    r2 = value;\n                    break;\n                case \"rot_3\":\n                    r3 = value;\n                    break;\n                default:\n                    if (plySH && prop.name.startsWith(\"f_rest_\")) {\n                        const shIdx = parseInt(prop.name.slice(7), 10);\n                        plySH[shIdx] = clamp255(value * 127.5 + 127.5);\n                    }\n                    break;\n            }\n        }\n\n        // Compressed PLY: SH bytes live in a trailing block keyed by splat\n        // index. Uchar dequant uses BJS's `(v * 8/255 - 4) * 127.5 + 127.5`\n        // (different from the standard f_rest float path).\n        if (plySH && header.shProps.length > 0) {\n            for (let k = 0; k < header.shCoefficientCount; k++) {\n                const b = dv.getUint8(shBlockBase + i * header.shCoefficientCount + k);\n                plySH[k] = clamp255((b * (8 / 255) - 4) * 127.5 + 127.5);\n            }\n        }\n\n        // PLY stores SH as [R0..R(d-1), G0..G(d-1), B0..B(d-1)]; transpose to\n        // the BJS-coefficient layout `[R0,G0,B0, R1,G1,B1, …]`.\n        if (plySH && shFlat) {\n            for (let j = 0; j < shDim; j++) {\n                shFlat[i * header.shCoefficientCount + j * 3 + 0] = plySH[j]!;\n                shFlat[i * header.shCoefficientCount + j * 3 + 1] = plySH[j + shDim]!;\n                shFlat[i * header.shCoefficientCount + j * 3 + 2] = plySH[j + shDim * 2]!;\n            }\n        }\n\n        const len = Math.hypot(r0, r1, r2, r3) || 1;\n        const inv = 1 / len;\n        rot[0] = r0 * inv * 127.5 + 127.5;\n        rot[1] = r1 * inv * 127.5 + 127.5;\n        rot[2] = r2 * inv * 127.5 + 127.5;\n        rot[3] = r3 * inv * 127.5 + 127.5;\n\n        offsetRef.value += header.rowVertexLength;\n    }\n\n    if (shFlat && header.shDegree) {\n        return { data: out, sh: shFlat, shDegree: header.shDegree };\n    }\n    return { data: out };\n}\n"],"names":[],"mappings":"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"}