s3m-three 0.2.0 → 0.3.1

package/src/core/DXTTextureDecode.ts

@@ -218,8 +218,10 @@ function DecompressImage(rgba: Uint8Array, width: number, height: number, blocks
           const sx = x + px;
           const sy = y + py;
           if (sx < width && sy < height) {
-            // flip Y
-            let nBegin = 4 * (width * (height - sy) + sx);
+            // flip Y：squish 的原式是 height - 1 - sy。写成 height - sy 会让 sy = 0
+            // 落到 row = height 越界（TypedArray 越界写是静默丢弃），于是缓冲区第 0 行
+            // 永远是全 0（透明黑），其余行整体错位一行。
+            let nBegin = 4 * (width * (height - 1 - sy) + sx);
 
             for (let i = 0; i < 4; ++i) rgba[nBegin++] = targetRgba[nOffsetTarget++];
           } else {
@@ -245,11 +247,31 @@ const DXTTextureDecode = {
   decode(out: Uint8Array, width: number, height: number, block: Uint8Array, format: number): void {
     if (out == null || block == null || height === 0 || width === 0) return;
 
-    // 有 alpha 通道 → RGBA，否则走 rgb565
-    // S3MPixelFormat.BGR -> 11 / LUMINANCE_ALPHA -> 5
-    const flags = format > 11 || format === 5 ? kDxt5 : kDxt1 | krgb565;
+    // 块大小与 alpha 编码只由压缩格式决定：DXT1 = 8 B/块，DXT3/4/5 = 16 B/块。
+    //
+    // 不能再靠「format > 11」判有没有 alpha：S3MPixelFormat 里 DXT1 = 17 也 > 11，
+    // 那样会把 DXT1 当 16 字节块读——512×512 的 DXT1 实际只有 131072 B（0.5 B/px），
+    // 按 16 字节块要 262144 B，正好差一倍，越界部分解成全 0。
+    // 官方 JS 那个判断是在「无 alpha 时纹理标成 RGB(10)/BGR(11)」的前提下才成立。
+    let flags: number;
+    switch (format) {
+      case 17: // DXT1
+        flags = kDxt1;
+        break;
+      case 18:
+      case 19: // DXT3
+        flags = kDxt3;
+        break;
+      case 20: // DXT4
+      case 21: // DXT5
+        flags = kDxt5;
+        break;
+      default:
+        // 老数据只在 RGB / BGR / LUMINANCE_ALPHA 里出现：无 alpha 时走 DXT1 + rgb565 快路径
+        flags = format > 11 || format === 5 ? kDxt5 : kDxt1 | krgb565;
+    }
 
-    if (flags & kDxt1 && flags & krgb565) {
+    if ((flags & kDxt1) !== 0 && (flags & krgb565) !== 0) {
       DecompressImage565(asU16(out), width, height, asU16(block));
     } else {
       DecompressImage(out, width, height, block, flags);

package/src/core/Draco.ts

@@ -0,0 +1,409 @@
+/**
+ * S3M v3 Draco 几何压缩（Skeleton 的 Draco 分支）
+ *
+ * 与 MeshOpt 一样，这里的布局不是照规范写的 —— 规范里的 Draco 分支描述和实际数据
+ * 对不上，字段顺序是从真实瓦片逐字节标定出来的（两个瓦片 5 个骨架完全一致，
+ * 且用 payloadSize / dracoSize / "DRACO" magic / skeletonStreamSize 四重自校验）。
+ *
+ * 二进制布局（v3.01 实测，偏移以 tag 字段之后为 0）：
+ * ```
+ * u32  payloadSize          // 覆盖 [本字段之后 .. 条目末尾 OBB 之前]
+ * u32  unknown = 32         // 实测恒 32，语义未知
+ * i32  posUniqueId          // draco 属性 uid，POSITION；-1 = 无
+ * i32  normalUniqueId       // -1 = 无
+ * i32  colorUniqueId        // -1 = 无
+ * i32  secondColorUniqueId
+ * u32  texCoordCount        // 自定义属性个数，实测 3
+ * i32  texCoordUniqueIds[texCoordCount]   // 各自定义属性的 draco uid
+ * u32  vertexAttrCount      // 实测恒 0
+ * u32  dracoSize
+ * byte draco[dracoSize]     // 标准 draco 比特流，开头 5 字节是 "DRACO" magic
+ * pad4
+ * String descript           // {"PointCloudClassCode":2,"PointCloudIntensity":1,"VertexWeight":0}
+ * pad4
+ * f64  obb[12]              // ← 由调用方 parseSkeletonEntries 统一按条目末尾读
+ * ```
+ *
+ * descript 的 value 是「自定义属性在 texCoordUniqueIds 里的下标」：
+ * VertexWeight→uid2(float 高度)、PointCloudIntensity→uid3、PointCloudClassCode→uid4。
+ * uid1 没被 descript 引用（实测是 0~29 的 uint32，用途不明）。
+ *
+ * 官方 SDK 的 `parseDracoSkeleton` 字段顺序不一样（多了 materialCount，且
+ * `version === 3` 的判定对 3.01 瓦片不成立），实际解析不了这个服务，所以以实测为准。
+ */
+import type { BinaryReader } from './BinaryReader.js';
+import type { AttrDType, IndexPackage, VertexAttribute, VertexPackage } from './types.js';
+import type { DracoModule, DracoPointAttribute, DracoPointCloud } from '../vendor/draco_decoder.module.js';
+
+/* ------------------------------------------------------------ draco 枚举（本地副本） */
+
+/** draco::GeometryAttribute::Type */
+const ATTR_POSITION = 0;
+const ATTR_NORMAL = 1;
+const ATTR_COLOR = 2;
+const ATTR_GENERIC = 4;
+
+/** draco::DataType（DT_INVALID = 0 占位） */
+const DT_UINT8 = 2;
+const DT_UINT16 = 4;
+const DT_UINT32 = 6;
+const DT_FLOAT32 = 9;
+
+/** draco::EncodedGeometryType */
+const GEOM_POINT_CLOUD = 0;
+const GEOM_TRIANGULAR_MESH = 1;
+
+const DRACO_MAGIC = 'DRACO';
+
+/** primitiveType = 1：点云包（渲染层据此走 THREE.Points） */
+const POINT_PRIMITIVE = 1;
+
+/** 单个 skeleton 的点数上限，防头读错时开出天文数字的缓冲 */
+const MAX_POINTS = 64 * 1024 * 1024;
+
+/* ------------------------------------------------------------ 解码器 */
+
+let decoderPromise: Promise<DracoModule> | null = null;
+
+/**
+ * 懒加载 Draco 解码器（wasm 内联，约 266KB）。
+ * 只有真正遇到 Draco 瓦片时才会编译，标准 / MeshOpt 瓦片不受影响。
+ */
+export function loadDracoDecoder(): Promise<DracoModule> {
+  if (!decoderPromise) {
+    decoderPromise = import('../vendor/draco_decoder.module.js').then((mod) => mod.default());
+  }
+  return decoderPromise;
+}
+
+/* ------------------------------------------------------------ 属性取值 */
+
+/** embind 数组包装：只暴露逐个取值 */
+interface DracoScalarArray {
+  size(): number;
+  GetValue(index: number): number;
+}
+
+/**
+ * 把 draco 的一个属性读成 JS 数组。
+ *
+ * 不能直接把 JS TypedArray 传给 `GetAttribute*ForAllPoints`：embind 会把期望
+ * 对象的参数原样透传，TypedArray 没有 `.ptr` 就变成 undefined，wasm 侧写不进
+ * 数据，函数却照样返回 true（实测取出来全是 0）。只能逐个 GetValue ——
+ * 6 千点 × 3 分量实测 3.5ms，可以接受。
+ *
+ * 量化 / 八面体变换由 draco 解码时自动还原，这里拿到的是最终值。
+ */
+function readAttribute(
+  draco: DracoModule,
+  decoder: InstanceType<DracoModule['Decoder']>,
+  geometry: DracoPointCloud,
+  attr: DracoPointAttribute
+): Float32Array | Uint8Array | Uint16Array | Uint32Array | null {
+  const comps = Math.max(1, attr.num_components());
+  const n = geometry.num_points() * comps;
+  let src: DracoScalarArray;
+
+  switch (attr.data_type()) {
+    case DT_FLOAT32:
+      src = new draco.DracoFloat32Array();
+      if (!decoder.GetAttributeFloatForAllPoints(geometry, attr, src as never)) return null;
+      break;
+    case DT_UINT8:
+      src = new draco.DracoUInt8Array();
+      if (!decoder.GetAttributeUInt8ForAllPoints(geometry, attr, src as never)) return null;
+      break;
+    case DT_UINT16:
+      src = new draco.DracoUInt16Array();
+      if (!decoder.GetAttributeUInt16ForAllPoints(geometry, attr, src as never)) return null;
+      break;
+    case DT_UINT32:
+      src = new draco.DracoUInt32Array();
+      if (!decoder.GetAttributeUInt32ForAllPoints(geometry, attr, src as never)) return null;
+      break;
+    default:
+      // int8/int16/int32/float64：真实点云里没见过，对应取值接口也存在，
+      // 需要时按上面同款补一行即可
+      return null;
+  }
+
+  const size = src.size();
+  const isFloat = attr.data_type() === DT_FLOAT32;
+  let out: Float32Array | Uint8Array | Uint16Array | Uint32Array;
+  if (isFloat) out = new Float32Array(n);
+  else if (attr.data_type() === DT_UINT16) out = new Uint16Array(n);
+  else if (attr.data_type() === DT_UINT32) out = new Uint32Array(n);
+  else out = new Uint8Array(n);
+  for (let i = 0; i < size && i < n; i++) out[i] = src.GetValue(i);
+  // Draco*Array 是 new 出来的，占 wasm 堆；不解引用会一直涨
+  draco.destroy(src);
+  return out;
+}
+
+/* ------------------------------------------------------------ 分类着色 */
+
+/**
+ * LAS / ASPRS 标准分类色带（1~18，其余走兜底灰）。
+ *
+ * 点云分类服务（3D-PointCloudClassific 这类）本身不带顶点色，颜色全靠分类码。
+ * 渲染层的点云路径只认 `color` 属性，所以这里直接把分类码烘成 RGBA8 顶点色，
+ * 下游零改动。实测该服务的分类分布是 {5: 高植被, 14: 导线, 15: 输电塔, 18: 高噪声}。
+ */
+const CLASS_COLORS: Array<[number, number, number]> = [
+  [190, 190, 190], // 0 未分类
+  [166, 166, 166], // 1 未分类（旧）
+  [139, 119, 101], // 2 地面
+  [35, 190, 35], // 3 低植被
+  [60, 179, 60], // 4 中植被
+  [30, 160, 30], // 5 高植被
+  [255, 170, 60], // 6 建筑
+  [255, 110, 190], // 7 低噪点
+  [190, 190, 190], // 8 关键点
+  [60, 120, 255], // 9 水面
+  [255, 235, 80], // 10 铁轨
+  [255, 200, 120], // 11 路面
+  [200, 120, 255], // 12 保留
+  [255, 120, 255], // 13 线缆
+  [255, 235, 60], // 14 导线
+  [255, 200, 40], // 15 输电塔
+  [120, 200, 255], // 16 桥面
+  [200, 160, 255], // 17 桥墩
+  [255, 60, 60], // 18 高噪声
+];
+
+/* ------------------------------------------------------------ 骨架 */
+
+/**
+ * 读取一个 Draco 压缩的 Skeleton。
+ *
+ * 点云没有索引包（顶点即点），但渲染层是「有 indexPackages 才建几何」，
+ * 所以这里合成一个 primitiveType = 1 的空点包，让下游走 THREE.Points 路径。
+ *
+ * 包围盒不在这里读：调用方 parseSkeletonEntries 统一按 skeletonStreamSize
+ * 定位到条目末尾的 OBB，各分支行为保持一致。
+ */
+export async function parseDracoGeometry(r: BinaryReader, vp: VertexPackage): Promise<IndexPackage[]> {
+  const draco = await loadDracoDecoder();
+
+  /* ---- 1. 容器头 ---- */
+
+  const payloadSize = r.u32();
+  const payloadStart = r.offset;
+  r.u32(); // 实测恒 32，语义未知
+
+  const posUniqueId = r.i32();
+  const normalUniqueId = r.i32();
+  const colorUniqueId = r.i32();
+  r.i32(); // secondColorUniqueId
+
+  const texCoordCount = r.u32();
+  if (texCoordCount > 16) {
+    throw new Error(`[s3m] Draco 自定义属性个数异常：texCoordCount=${texCoordCount}`);
+  }
+  const texCoordUniqueIds: number[] = [];
+  for (let i = 0; i < texCoordCount; i++) texCoordUniqueIds.push(r.i32());
+
+  r.u32(); // vertexAttrCount，实测恒 0
+
+  const dracoSize = r.u32();
+  if (dracoSize < 16 || dracoSize > r.remaining) {
+    throw new Error(`[s3m] Draco 流长度异常：dracoSize=${dracoSize}，剩余 ${r.remaining} 字节`);
+  }
+
+  const data = r.bytes(dracoSize);
+  // 头读错时这里必然对不上，比让 wasm 报一句看不懂的错有用
+  if (String.fromCharCode(...data.subarray(0, 5)) !== DRACO_MAGIC) {
+    throw new Error('[s3m] Draco 流缺少 "DRACO" magic，容器头解析错位');
+  }
+  r.align4();
+
+  const descript = r.string();
+  r.align4();
+
+  // 自定义属性 uid → 语义名：{"PointCloudClassCode":2,...} 的 value 是 texCoordUniqueIds 下标
+  const customNames = new Map<number, string>();
+  try {
+    const map = JSON.parse(descript) as Record<string, number>;
+    for (const [name, idx] of Object.entries(map)) {
+      const uid = texCoordUniqueIds[idx];
+      if (uid !== undefined) customNames.set(uid, name);
+    }
+  } catch {
+    // descript 不是 JSON 也不影响渲染，只是自定义属性没名字
+  }
+  vp.customVertexAttribute = descript ? safeJson(descript) : undefined;
+
+  if (payloadSize > 0) {
+    const consumed = r.offset - payloadStart;
+    if (consumed !== payloadSize) {
+      // 条目末尾由 streamSize 兜着，错位不会波及后面的骨架，只提示
+      console.warn(`[s3m] Draco 载荷长度不符：声明 ${payloadSize}，实读 ${consumed}`);
+    }
+  }
+
+  /* ---- 2. 解码 ---- */
+
+  const decoder = new draco.Decoder();
+  const geometry = new draco.PointCloud();
+  try {
+    const geomType = decoder.GetEncodedGeometryType(data);
+    if (geomType !== GEOM_POINT_CLOUD) {
+      throw new Error(
+        `[s3m] Draco ${geomType === GEOM_TRIANGULAR_MESH ? '三角网格' : '未知'} 几何暂未实现（仅支持点云）`
+      );
+    }
+
+    const status = decoder.DecodeArrayToPointCloud(data, data.length, geometry);
+    if (!status.ok()) throw new Error(`[s3m] Draco 解码失败：${status.error_msg()}`);
+
+    const numPoints = geometry.num_points();
+    if (!Number.isInteger(numPoints) || numPoints < 0 || numPoints > MAX_POINTS) {
+      throw new Error(`[s3m] Draco 点数异常：${numPoints}`);
+    }
+    if (numPoints === 0) {
+      vp.verticesCount = 0;
+      return [pointPack()];
+    }
+
+    /* ---- 3. 属性装配 ---- */
+
+    let classCode: Uint8Array | null = null;
+
+    for (let i = 0; i < geometry.num_attributes(); i++) {
+      const attr = decoder.GetAttribute(geometry, i);
+      const uid = attr.unique_id();
+      const comps = Math.max(1, attr.num_components());
+
+      if (uid === posUniqueId || attr.attribute_type() === ATTR_POSITION) {
+        if (attr.data_type() !== DT_FLOAT32) {
+          throw new Error(`[s3m] Draco 位置属性不是 float32（dt=${attr.data_type()}）`);
+        }
+        const raw = readAttribute(draco, decoder, geometry, attr) as Float32Array | null;
+        if (!raw) throw new Error('[s3m] Draco 位置属性读取失败');
+        // draco 偶尔按 3 分量以上的格式存位置，取前 3 个
+        const out = new Float32Array(numPoints * 3);
+        for (let p = 0; p < numPoints; p++) {
+          out[p * 3] = raw[p * comps] ?? 0;
+          out[p * 3 + 1] = raw[p * comps + 1] ?? 0;
+          out[p * 3 + 2] = raw[p * comps + 2] ?? 0;
+        }
+        pushAttr(vp, 'position', new Uint8Array(out.buffer), 3, 12, 0, undefined, 'f32');
+        continue;
+      }
+
+      if (uid === colorUniqueId || attr.attribute_type() === ATTR_COLOR) {
+        const raw = readAttribute(draco, decoder, geometry, attr);
+        if (raw) {
+          const out = new Uint8Array(numPoints * 4);
+          const isFloat = raw instanceof Float32Array;
+          for (let p = 0; p < numPoints; p++) {
+            const o = p * comps;
+            if (isFloat) {
+              out[p * 4] = clamp255(raw[o] ?? 1);
+              out[p * 4 + 1] = clamp255(raw[o + 1] ?? 1);
+              out[p * 4 + 2] = clamp255(raw[o + 2] ?? 1);
+            } else {
+              out[p * 4] = raw[o] ?? 255;
+              out[p * 4 + 1] = raw[o + 1] ?? 255;
+              out[p * 4 + 2] = raw[o + 2] ?? 255;
+            }
+            out[p * 4 + 3] = comps >= 4 && !isFloat ? (raw[o + 3] ?? 255) : 255;
+          }
+          pushAttr(vp, 'color', out, 4, 4, 0, undefined, 'u8');
+        }
+        continue;
+      }
+
+      if (uid === normalUniqueId || attr.attribute_type() === ATTR_NORMAL) {
+        // 点云不需要法线，八面体编码由 draco 解码时自动还原，这里直接跳过
+        continue;
+      }
+
+      // 自定义属性：只挑分类码，其余（高度 / 强度）渲染层用不上
+      const name = customNames.get(uid);
+      if (name === 'PointCloudClassCode' && comps === 1) {
+        const raw = readAttribute(draco, decoder, geometry, attr);
+        if (raw && !(raw instanceof Float32Array)) {
+          classCode = new Uint8Array(numPoints);
+          for (let p = 0; p < numPoints; p++) classCode[p] = raw[p] ?? 0;
+        }
+      }
+    }
+
+    if (vp.attrLocation.position === undefined) {
+      throw new Error('[s3m] Draco 点云缺少 position 属性');
+    }
+
+    // 数据自带顶点色优先；没有色但有分类码时，用分类色带烘一份 RGBA8
+    if (vp.attrLocation.color === undefined && classCode) {
+      const out = new Uint8Array(numPoints * 4);
+      for (let p = 0; p < numPoints; p++) {
+        const c = CLASS_COLORS[classCode[p]] ?? CLASS_COLORS[0];
+        out[p * 4] = c[0];
+        out[p * 4 + 1] = c[1];
+        out[p * 4 + 2] = c[2];
+        out[p * 4 + 3] = 255;
+      }
+      pushAttr(vp, 'color', out, 4, 4, 0, undefined, 'u8');
+    }
+
+    vp.verticesCount = numPoints;
+    return [pointPack()];
+  } finally {
+    // embind 对象占的是 wasm 堆，不显式释放会一直涨
+    try {
+      draco.destroy(decoder);
+      draco.destroy(geometry);
+    } catch {
+      // 某些构建没有 destroy，忽略
+    }
+  }
+}
+
+/* ------------------------------------------------------------ 工具 */
+
+/** 点云包：索引只是点序号，交给渲染层走 drawRange */
+function pointPack(): IndexPackage {
+  return {
+    indexCount: 0,
+    indexType: 0,
+    useIndex: 0,
+    primitiveType: POINT_PRIMITIVE,
+    indices: null,
+    passNames: [],
+  };
+}
+
+function pushAttr(
+  vp: VertexPackage,
+  semantic: string,
+  data: Uint8Array,
+  components: number,
+  stride: number,
+  offset = 0,
+  divisor?: number,
+  dtype: AttrDType = 'f32'
+): void {
+  vp.attrLocation[semantic] = vp.vertexAttributes.length;
+  vp.vertexAttributes.push({
+    semantic,
+    data,
+    components,
+    stride,
+    offsetInBytes: offset,
+    divisor,
+    dtype,
+  });
+}
+
+function clamp255(v: number): number {
+  return v <= 0 ? 0 : v >= 1 ? 255 : Math.round(v * 255);
+}
+
+function safeJson(s: string): unknown {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return s;
+  }
+}

package/src/core/MeshOpt.ts

@@ -169,13 +169,57 @@ const SEMANTIC_NAME: Record<number, string> = {
   [MeshOptSemantic.GS_ROTATION]: 'gsRotation',
 };
 
+/** 单块解码出来的属性，最后按语义跨块拼成一条 */
+interface AttrSink {
+  dtype: 'f32' | 'u8';
+  components: number;
+  chunks: Array<Float32Array | Uint8Array>;
+  /** 已累计的标量个数（不是顶点数） */
+  length: number;
+}
+
+function pushSink(
+  sinks: Map<string, AttrSink>,
+  semantic: string,
+  dtype: 'f32' | 'u8',
+  components: number,
+  chunk: Float32Array | Uint8Array,
+): void {
+  let sink = sinks.get(semantic);
+  if (!sink) {
+    sink = { dtype, components, chunks: [], length: 0 };
+    sinks.set(semantic, sink);
+  }
+  sink.chunks.push(chunk);
+  sink.length += chunk.length;
+}
+
 /**
- * 读取一个 MeshOpt 压缩的 Skeleton。
+ * 索引是块内局部编号（实测 max index 恰为所在块的 vertexCount - 1），
+ * 多块合并成一份顶点缓冲后要整体加上该块的顶点基数。
+ *
+ * 用 DataView 而不是 Uint32Array：未压缩索引那段是底层 buffer 的 subarray，
+ * byteOffset 未必 4 字节对齐，直接建 Uint32Array 会抛 RangeError。
+ */
+function offsetIndices(packs: IndexPackage[], base: number): void {
+  for (const pack of packs) {
+    const buf = pack.indices;
+    if (!buf || pack.indexCount <= 0 || buf.byteLength < pack.indexCount * 4) continue;
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    for (let i = 0; i < pack.indexCount; i++) {
+      dv.setUint32(i * 4, dv.getUint32(i * 4, true) + base, true);
+    }
+  }
+}
+
+/**
+ * 读取一个 MeshOpt 压缩的 Skeleton，以及**内嵌在块之间的索引包**。
  *
  * 二进制布局（v3.01 实测）：
  * ```
  * uint32  compressOptions            // 0x13 = Position | Normal | TexCoord
- * uint32  blockCount                 // 实测恒为 1
+ * uint32  blockCount                 // 实测 1 或 2
+ *   ↑ 下面整段重复 blockCount 次：
  *   uint32  vertexCount
  *   float32 vertCompressConstant
  *   float64 minVerticesValue.xyz
@@ -191,14 +235,27 @@ const SEMANTIC_NAME: Record<number, string> = {
  *     pad4
  *   String  descript                // {"TextureCoordMatrix":1,"VertexWeight":0}
  *   pad4
+ *   IndexPackage[]                  // ← 每块各带一份，不是所有块之后再统一放
  * ```
+ *
+ * 注意最后一行：blockCount > 1 时索引包夹在块与块之间。之前按「读完所有块再读索引包」
+ * 处理，会把第一块的索引包当成第二块的块头，读出天文数字的 compressedSize。
+ *
+ * 多块是同一份几何的拆分，这里把各块属性按顺序拼成一条流，并把各块索引加上
+ * 顶点基数偏移，对外仍是一份顶点缓冲 + 多组索引包，下游无需改动。
  */
-export async function parseMeshOptSkeleton(r: BinaryReader, vp: VertexPackage): Promise<MeshOptBlockInfo> {
+export async function parseMeshOptGeometry(
+  r: BinaryReader,
+  vp: VertexPackage,
+): Promise<{ info: MeshOptBlockInfo; indexPackages: IndexPackage[] }> {
   const decoder = await loadMeshoptDecoder();
 
   const compressOptions = r.u32();
   vp.compressOptions = compressOptions;
   const blockCount = r.u32();
+  if (blockCount > 64) {
+    throw new Error(`[s3m] MeshOpt 块数异常：blockCount=${blockCount}`);
+  }
 
   const info: MeshOptBlockInfo = {
     vertexCount: 0,
@@ -216,6 +273,11 @@ export async function parseMeshOptSkeleton(r: BinaryReader, vp: VertexPackage):
     streams: [],
   };
 
+  const sinks = new Map<string, AttrSink>();
+  const indexPackages: IndexPackage[] = [];
+  let baseVertex = 0;
+  let hasCustomAttribute = false;
+
   for (let bi = 0; bi < blockCount; bi++) {
     const vertexCount = r.u32();
     const vertScale = r.f32();
@@ -234,15 +296,12 @@ export async function parseMeshOptSkeleton(r: BinaryReader, vp: VertexPackage):
     }
 
     const attrCount = r.i32();
-    const decodeThisBlock = bi === 0;
 
-    if (decodeThisBlock) {
-      info.vertexCount = vertexCount;
-      info.vertScale = vertScale;
+    if (bi === 0) {
       info.minVertices = [minX, minY, minZ];
+      info.vertScale = vertScale;
       info.texCoordScale = texCoordScale;
       info.texCoordOffset = texCoordOffset;
-      vp.verticesCount = vertexCount;
     }
 
     for (let ai = 0; ai < attrCount; ai++) {
@@ -260,8 +319,6 @@ export async function parseMeshOptSkeleton(r: BinaryReader, vp: VertexPackage):
       const data = r.bytes(compressedSize);
       r.align4();
 
-      if (!decodeThisBlock) continue;
-
       // 切线流我们不用（渲染里没有法线贴图通道），解不出来也不该拖垮整个瓦片：
       // 真实服务里带 PBR 的数据（如 SubwayStationCombined）都带这条流，之前直接抛错导致整套数据不可见
       if (semantic === MeshOptSemantic.TANGENT) {
@@ -297,18 +354,18 @@ export async function parseMeshOptSkeleton(r: BinaryReader, vp: VertexPackage):
           pos[i * 3 + 1] = minY + u16[i * 4 + 1] * vertScale;
           pos[i * 3 + 2] = minZ + u16[i * 4 + 2] * vertScale;
         }
-        vp.vertexAttributes.push(f32Attribute('position', pos, 3));
+        pushSink(sinks, 'position', 'f32', 3, pos);
       } else if (semantic === MeshOptSemantic.NORMAL) {
         const i16 = new Int16Array(out.buffer, out.byteOffset, vertexCount * 2);
         const nrm = new Float32Array(vertexCount * 3);
         for (let i = 0; i < vertexCount; i++) {
           octDecode(i16[i * 2] / 32767, i16[i * 2 + 1] / 32767, nrm, i * 3);
         }
-        vp.vertexAttributes.push(f32Attribute('normal', nrm, 3));
+        pushSink(sinks, 'normal', 'f32', 3, nrm);
       } else if (semantic === MeshOptSemantic.COLOR) {
-        vp.vertexAttributes.push(u8Attribute('color', out, 4));
+        pushSink(sinks, 'color', 'u8', 4, out);
       } else if (semantic === MeshOptSemantic.COLOR1) {
-        vp.vertexAttributes.push(u8Attribute('color2', out, 4));
+        pushSink(sinks, 'color2', 'u8', 4, out);
       } else if (semantic === MeshOptSemantic.TEXCOORD0 || semantic === MeshOptSemantic.TEXCOORD1) {
         const slot = semantic === MeshOptSemantic.TEXCOORD0 ? 0 : 1;
         const scale = texCoordScale[slot] ?? [0, 0];
@@ -325,20 +382,69 @@ export async function parseMeshOptSkeleton(r: BinaryReader, vp: VertexPackage):
             uv[i * 2 + 1] = offset[1] + u16[i * 2 + 1] * scale[1];
           }
         }
-        vp.vertexAttributes.push(f32Attribute(slot === 0 ? 'uv' : 'uv2', uv, 2));
+        pushSink(sinks, slot === 0 ? 'uv' : 'uv2', 'f32', 2, uv);
+      } else if (
+        semantic === MeshOptSemantic.CUSTOM0 ||
+        semantic === MeshOptSemantic.CUSTOM1 ||
+        semantic === MeshOptSemantic.GS_SCALE ||
+        semantic === MeshOptSemantic.GS_ROTATION
+      ) {
+        // 自定义属性流 / 高斯泼溅的逐点参数：原样保留解码结果（每点 stride 字节），
+        // 语义由 vp.customVertexAttribute 的名字→槽位映射给出。
+        // 以前这里直接丢掉，导致 3DGaussianSplatting 数据只剩「点 + 颜色」，
+        // 上层永远拿不到泼溅尺寸与朝向。
+        pushSink(sinks, SEMANTIC_NAME[semantic]!, 'u8', stride, out);
       }
-      // tangent / custom / GS 系列暂不使用
     }
 
     const descript = r.string();
     r.align4();
-    if (decodeThisBlock && descript) {
+    if (descript && !hasCustomAttribute) {
+      hasCustomAttribute = true;
       try {
         vp.customVertexAttribute = JSON.parse(descript);
       } catch {
         vp.customVertexAttribute = descript;
       }
     }
+
+    // 每块后面紧跟自己的索引包（blockCount = 1 时等价于「骨架之后读索引包」）
+    const packs = await parseMeshOptIndexPackages(r);
+    if (baseVertex > 0) offsetIndices(packs, baseVertex);
+    indexPackages.push(...packs);
+    baseVertex += vertexCount;
+  }
+
+  // blockCount = 0 的老数据：索引包仍然跟在骨架后面
+  if (blockCount === 0) {
+    indexPackages.push(...(await parseMeshOptIndexPackages(r)));
+  }
+
+  info.vertexCount = baseVertex;
+  vp.verticesCount = baseVertex;
+  // 留下原始流清单：诊断用，也是接自定义属性 / 高斯泼溅属性的入口
+  vp.meshOptInfo = info;
+
+  // 跨块拼接：属性流长度按理各块一致，缺块时补 0，宁可少一块颜色也不整块不可见
+  for (const [semantic, sink] of sinks) {
+    const expected = baseVertex * sink.components;
+    if (sink.dtype === 'f32') {
+      const out = new Float32Array(expected);
+      let off = 0;
+      for (const chunk of sink.chunks) {
+        out.set(chunk as Float32Array, off);
+        off += chunk.length;
+      }
+      vp.vertexAttributes.push(f32Attribute(semantic, out, sink.components));
+    } else {
+      const out = new Uint8Array(expected);
+      let off = 0;
+      for (const chunk of sink.chunks) {
+        out.set(chunk as Uint8Array, off);
+        off += chunk.length;
+      }
+      vp.vertexAttributes.push(u8Attribute(semantic, out, sink.components));
+    }
   }
 
   // attrLocation 供老接口按名字查索引
@@ -346,7 +452,7 @@ export async function parseMeshOptSkeleton(r: BinaryReader, vp: VertexPackage):
     vp.attrLocation[`a${vp.vertexAttributes[i].semantic}`] = i;
   }
 
-  return info;
+  return { info, indexPackages };
 }
 
 /* ------------------------------------------------------------------ 索引包 */