dsh-pet-live2d 2.3.1 → 2.3.2

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # 更新日志
 
+## 2.3.2
+
+### 修：摸尾巴又摸不到了（这次是真的）
+
+用户报的："现在又摸不到尾巴了。"（还发了一张圈出尾巴位置的截图，帮了大忙 —— 尾巴是
+**右侧那只鲸鱼尾鳍**，不是翅膀。）
+
+**真正的根因**：判定每块 drawable 时用的是**映射时算好并存下来的下标**（`entry.index`），
+而不是**调用时按 id 现查的下标**。这两者只要有一处对不上，取到的顶点就是别人的 ——
+表现是"每块单独测都能命中，聚合起来一个都不中"。
+
+单块测（`drawableProbe`）之所以一直正常，正是因为它**每次都按 id 现查下标**。
+现在聚合路径也这么做了：`hitsPartsGeometry` 在循环里用 `im.getDrawableIndex(entry.id)`
+重新解一次，解不出来才退回缓存值。
+
+修好后同一网格上的读数：`hitsTail` 从 **0 → 509** 命中（48×48），头部 1113、重叠 689
+—— 重叠仍然存在（翅膀的几何本来就伸到头顶上方），所以**摸头优先于摸尾巴**那条继续保留：
+点头部给摸头，尾巴自己的区域照样摸得到。
+
+### 一段该记下来的教训：坏掉的诊断比没有诊断更糟
+
+这轮我查了很久，很大一部分时间是被**自己写的诊断函数**骗了：`partHitCounts` 里调了
+`api.drawableProbe(...)`，而 `api` 是控制器**返回出去**的对象，控制器内部根本看不到它
+—— 每次调用都抛 `api is not defined`，被外面的 try/catch 吞掉，于是 `hitsAll`/`hitsVisible`
+**恒为 0**。外面看到的却是"这个部件完全没有几何"，一条**看起来像产品坏了**的读数。
+
+代价：我据此排除了三个正确假设（透明度过滤、下标空间、包围盒预筛），还改坏过一次
+（把顶点整条换成 core 层，连头部判定都变成 0 命中，已还原）。
+
+教训：**诊断函数自己也要先自证**（拿一个已知能命中的样本去测它），读数与事实矛盾时
+先怀疑测量工具，再怀疑被测对象。
+
 ## 2.3.1
 
 ### 修：摸头会出摸尾巴的效果

package/lib/client.js

@@ -307,18 +307,40 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
      */
     const drawableIndicesForParts = (parts) => {
       const raw = model?.internalModel?.coreModel?._model;
+      const im = model?.internalModel;
       const parent = raw?.drawables?.parentPartIndices;
       const partIds = raw?.parts?.ids;
-      if (parent === undefined || partIds === undefined) return null;
+      const coreIds = raw?.drawables?.ids;
+      if (parent === undefined || partIds === undefined || coreIds === undefined) return null;
       const ids = Array.from(partIds).map(String);
       if (ids.length === 0 || parts.length === 0) return null;
       const wanted = new Set(parts);
+      const coreIndexById = new Map();
+      for (let i = 0; i < coreIds.length; i += 1) coreIndexById.set(String(coreIds[i]), i);
+      // **以包装层的顺序为主**：顶点就是按 `internalModel.getDrawableIDs()` 的顺序读的
+      // （单块 `drawableProbe` 走得通的正是这条路）。反过来"遍历原始表再翻译下标"，
+      // 只要两套顺序有一处不一致，取到的顶点就是别的 drawable —— 表现就是"几何明明
+      // 又大又真，聚合判定一个都不中"。这里逐个 id 反查它属于哪个部件，不存在歧义。
+      const wrapperIds = typeof im?.getDrawableIDs === "function"
+        ? Array.from(im.getDrawableIDs()).map(String)
+        : null;
       const out = [];
-      for (let i = 0; i < parent.length; i += 1) {
-        const partIndex = parent[i];
-        if (partIndex < 0 || partIndex >= ids.length) continue;
-        if (!wanted.has(ids[partIndex])) continue;
-        out.push({ index: i, part: partIndex });
+      if (wrapperIds !== null) {
+        for (let w = 0; w < wrapperIds.length; w += 1) {
+          const coreIndex = coreIndexById.get(wrapperIds[w]);
+          if (coreIndex === undefined) continue;
+          const partIndex = parent[coreIndex];
+          if (partIndex === undefined || partIndex < 0 || partIndex >= ids.length) continue;
+          if (!wanted.has(ids[partIndex])) continue;
+          out.push({ id: wrapperIds[w], index: w, coreIndex, part: partIndex });
+        }
+      } else {
+        for (let i = 0; i < parent.length; i += 1) {
+          const partIndex = parent[i];
+          if (partIndex < 0 || partIndex >= ids.length) continue;
+          if (!wanted.has(ids[partIndex])) continue;
+          out.push({ id: String(coreIds[i]), index: i, coreIndex: i, part: partIndex });
+        }
       }
       return out.length > 0 ? out : null;
     };
@@ -359,25 +381,30 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
     const hitsPartsGeometry = (indices, x, y) => {
       const im = model?.internalModel;
       if (im === undefined || im === null) return null;
-      // 顶点在**包装层**、三角形索引在**core 层**（实测：`im` 有 getDrawableVertices，
-      // `im.coreModel` 才有 getDrawableVertexIndices）—— 只查一个就会静默返回 null、
-      // 悄悄退回方框判定。两边各取所长。
+      // 顶点用**包装层**的（core 的 `getDrawableVertices` 不在同一个坐标空间里：整条换成
+      // core 之后连头部判定都变成 0 命中）。三角形索引只有 core 有；两套按**同一个下标**
+      // 取用时是自洽的（单块 `drawableProbe` 用同一组合能命中，已实测）。
+      const core = im.coreModel;
       const verticesOf = typeof im.getDrawableVertices === "function"
         ? (index) => im.getDrawableVertices(index)
-        : (typeof im.coreModel?.getDrawableVertices === "function"
-          ? (index) => im.coreModel.getDrawableVertices(index)
-          : null);
-      const indicesOf = typeof im.getDrawableVertexIndices === "function"
-        ? (index) => im.getDrawableVertexIndices(index)
-        : (typeof im.coreModel?.getDrawableVertexIndices === "function"
-          ? (index) => im.coreModel.getDrawableVertexIndices(index)
-          : null);
+        : (typeof core?.getDrawableVertices === "function" ? (index) => core.getDrawableVertices(index) : null);
+      const indicesOf = typeof core?.getDrawableVertexIndices === "function"
+        ? (index) => core.getDrawableVertexIndices(index)
+        : (typeof im.getDrawableVertexIndices === "function" ? (index) => im.getDrawableVertexIndices(index) : null);
       if (verticesOf === null || indicesOf === null) return null;
       if (indices === null) return null;
       let read = false;
       try {
         for (const entry of indices) {
-          const verts = verticesOf(entry.index);
+          // **调用时用 id 重新解一次下标**，别信缓存的 `entry.index`：
+          // 单块 `drawableProbe` 走得通、聚合路径走不通，两者剩下的唯一差别就是这个
+          // （它每次都用 id 现查，聚合路径用映射时算好并存下来的那份）。
+          let index = entry.index;
+          if (typeof entry.id === "string" && typeof im.getDrawableIndex === "function") {
+            const fresh = im.getDrawableIndex(entry.id);
+            if (fresh >= 0) index = fresh;
+          }
+          const verts = verticesOf(index);
           if (verts === undefined || verts === null || verts.length < 6) continue;
           read = true;
           // 先用这个 drawable 的包围盒排除（绝大多数部件一眼就出局，不用扫三角形）。
@@ -2114,10 +2141,130 @@ window.__ModuleLoader__.load({ id: "dsh-pet-live2d", factory: (require) => {
             box: maxX > minX ? { minX: Math.round(minX), maxX: Math.round(maxX), minY: Math.round(minY), maxY: Math.round(maxY) } : null,
             hitsAll,
             hitsVisible,
+            // 每块报：id / 包装层下标 / 原始表下标。
+            // **别再在这里调 `api.xxx`**：`api` 是控制器返回出去的那个对象，控制器内部
+            // 看不到它 —— 调了就是 `api is not defined`，整个函数抛异常、所有读数变 0，
+            // 而外面看起来像"这个部件完全没有几何"（我为此白查了三轮）。
+            entries: entries.map((entry) => ({
+              id: entry.id ?? null,
+              index: entry.index,
+              core: entry.coreIndex,
+              part: entry.part,
+            })),
           });
         }
         return out;
       },
+      /**
+       * Diagnostic: 全部 drawable 的 id / 所属部件名 / 顶点数 / 包围盒（模型空间）。
+       *
+       * 找"她身上真正在画尾巴的那一个"用这个：作者给**部件**起了中文名（尾巴翅膀/猫尾/
+       * 大翅膀…），但 drawable 本身多半叫 `ArtMesh123`。按包围盒的位置就能认出来
+       * （尾巴在身体下后方、翅膀在两侧）。
+       */
+      drawableTable: () => {
+        const im = model?.internalModel;
+        const raw = im?.coreModel?._model;
+        const ids = typeof im?.getDrawableIDs === "function" ? Array.from(im.getDrawableIDs()).map(String) : [];
+        const partIds = raw?.parts?.ids === undefined ? [] : Array.from(raw.parts.ids).map(String);
+        const parent = raw?.drawables?.parentPartIndices;
+        const cdi3Names = MANIFEST.current?.partNames ?? {};
+        return ids.map((id, index) => {
+          const partIndex = parent === undefined ? -1 : parent[index];
+          const partId = partIndex >= 0 && partIndex < partIds.length ? partIds[partIndex] : null;
+          let minX = Infinity;
+          let minY = Infinity;
+          let maxX = -Infinity;
+          let maxY = -Infinity;
+          let vertexCount = 0;
+          try {
+            const verts = im?.getDrawableVertices?.(index);
+            if (verts !== undefined && verts !== null) {
+              vertexCount = Math.floor(verts.length / 2);
+              for (let k = 0; k < verts.length; k += 2) {
+                if (verts[k] < minX) minX = verts[k];
+                if (verts[k] > maxX) maxX = verts[k];
+                if (verts[k + 1] < minY) minY = verts[k + 1];
+                if (verts[k + 1] > maxY) maxY = verts[k + 1];
+              }
+            }
+          } catch {
+            /* 跳过 */
+          }
+          return {
+            id,
+            index,
+            partId,
+            partName: partId === null ? "(无部件)" : (cdi3Names[partId] ?? partId),
+            vertexCount,
+            box: maxX > minX ? { minX: Math.round(minX), maxX: Math.round(maxX), minY: Math.round(minY), maxY: Math.round(maxY) } : null,
+          };
+        });
+      },
+      /**
+       * Diagnostic: 单看一个 drawable 的三角面判定为什么命中/不命中。
+       *
+       * 头部判定好用、尾巴判定一个都不中（而它的几何明明又大又真）——这种"同一段代码
+       * 对不同 drawable 表现不同"的问题，只能把中间量摊开看：顶点数、索引数、索引范围、
+       * 以及用**它自己的重心**去测的结果。
+       */
+      drawableProbe: (id) => {
+        const im = model?.internalModel;
+        const index = typeof im?.getDrawableIndex === "function" ? im.getDrawableIndex(id) : -1;
+        if (index < 0) return { id, found: false };
+        const vertices = im?.getDrawableVertices?.(index);
+        const indices = (typeof im?.getDrawableVertexIndices === "function"
+          ? im.getDrawableVertexIndices(index)
+          : im?.coreModel?.getDrawableVertexIndices?.(index));
+        const verts = vertices === undefined || vertices === null ? [] : Array.from(vertices);
+        const idx = indices === undefined || indices === null ? [] : Array.from(indices);
+        let minIndex = Infinity;
+        let maxIndex = -Infinity;
+        for (const value of idx) {
+          if (value < minIndex) minIndex = value;
+          if (value > maxIndex) maxIndex = value;
+        }
+        const vertexCount = Math.floor(verts.length / 2);
+        // 用顶点的平均位置当查询点：它一定在几何内部（凸的情况下）。
+        let sumX = 0;
+        let sumY = 0;
+        for (let i = 0; i < verts.length; i += 2) {
+          sumX += verts[i];
+          sumY += verts[i + 1];
+        }
+        const cx = vertexCount === 0 ? 0 : sumX / vertexCount;
+        const cy = vertexCount === 0 ? 0 : sumY / vertexCount;
+        let triangles = 0;
+        let degenerate = 0;
+        let contains = 0;
+        for (let i = 0; i + 2 < idx.length; i += 3) {
+          triangles += 1;
+          const a = idx[i];
+          const b = idx[i + 1];
+          const c = idx[i + 2];
+          if (a * 2 + 1 >= verts.length || b * 2 + 1 >= verts.length || c * 2 + 1 >= verts.length) continue;
+          const area = (verts[b * 2] - verts[a * 2]) * (verts[c * 2 + 1] - verts[a * 2 + 1])
+            - (verts[c * 2] - verts[a * 2]) * (verts[b * 2 + 1] - verts[a * 2 + 1]);
+          if (Math.abs(area) < 1e-6) {
+            degenerate += 1;
+            continue;
+          }
+          if (pointInTriangle(cx, cy, verts, a, b, c)) contains += 1;
+        }
+        return {
+          id,
+          found: true,
+          index,
+          vertexCount,
+          indexCount: idx.length,
+          minIndex: Number.isFinite(minIndex) ? minIndex : null,
+          maxIndex: Number.isFinite(maxIndex) ? maxIndex : null,
+          triangles,
+          degenerate,
+          centroidHits: contains,
+          centroid: { x: Math.round(cx), y: Math.round(cy) },
+        };
+      },
       /**
        * Play a motion with its declared policy applied; used by the panel, the
        * tap reaction and the session-phase driver.

package/lib/index.js

@@ -356,6 +356,31 @@ function readReactionList(value) {
   return Array.isArray(value) ? value.filter((name) => typeof name === 'string' && name !== '') : []
 }
 
+/**
+ * 部件 id → 作者给的中文名（`Part46` → `脸蛋`）。
+ *
+ * 诊断用（`drawableTable()`）：把 drawable 归到有意义的部件名下，才能一眼看出
+ * "她身上真正在画尾巴的是哪个 drawable" —— 光看 `ArtMesh123` 是认不出来的。
+ */
+function readPartNames(dir, modelPath) {
+  try {
+    const base = modelPath.replace(/\.model3\.json$/i, '')
+    const file = findCdi3(dir, base)
+    if (file === undefined) return {}
+    const parts = readJson(file)?.Parts
+    if (!Array.isArray(parts)) return {}
+    const out = {}
+    for (const part of parts) {
+      if (part === null || typeof part !== 'object') continue
+      if (typeof part.Id !== 'string' || typeof part.Name !== 'string') continue
+      if (part.Name !== '') out[part.Id] = part.Name
+    }
+    return out
+  } catch {
+    return {}
+  }
+}
+
 /** Scan one pet directory into a catalog entry, or undefined when unusable. */
 export function scanPet(dir, id) {
   const manifestFile = join(dir, 'pet.json')
@@ -512,6 +537,8 @@ export function scanPet(dir, id) {
     // 空数组 = 没 cdi3 或没挑到，浏览器半区退回旧行为。
     headParts: readPartsMatching(dir, modelPath, HEAD_PART_NAME_HINTS),
     tailParts: readPartsMatching(dir, modelPath, TAIL_PART_NAME_HINTS),
+    // 部件 id → 中文名（诊断用，见客户端 drawableTable()）。
+    partNames: readPartNames(dir, modelPath),
     // 台词：宠物自己的声音（问候 / 点击 / 摸头 / 摸尾巴 / 转晕 / 归位 / 每个相位）。
     // 用户能在设置里逐条改，改过的存浏览器；这里是**默认值**。
     lines: typeof block.lines === 'object' && block.lines !== null ? block.lines : {},
@@ -719,6 +746,7 @@ function catalogRoute() {
           motionGuards: pet.motionGuards,
           headParts: pet.headParts,
           tailParts: pet.tailParts,
+          partNames: pet.partNames,
           lines: pet.lines,
           patReactions: pet.patReactions,
           tailReactions: pet.tailReactions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-pet-live2d",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "Live2D 桌宠插件：为 DSH Web GUI 挂一只可拖动、会跟随鼠标、能换动作与表情的 Live2D 宠物。",
   "type": "module",
   "main": "lib/index.js",