@aura3d/engine 1.1.0 → 1.3.0

package/dist/assets/GLTFLoader.js

@@ -86,13 +86,15 @@ export class GLTFLoader {
                 const typedTangents = tangents.map((tangent) => [tangent[0] ?? 0, tangent[1] ?? 0, tangent[2] ?? 0, tangent[3] ?? 1]);
                 const typedColors = colors.map((color) => [color[0] ?? 1, color[1] ?? 1, color[2] ?? 1, color[3] ?? 1]);
                 const typedJoints = joints.map((joint) => [joint[0] ?? 0, joint[1] ?? 0, joint[2] ?? 0, joint[3] ?? 0]);
+                const weightNormalization = { degenerate: 0, rescaled: 0 };
                 const typedWeights = weights.map((weight) => normalizeSkinWeights([
                     weight[0] ?? 0,
                     weight[1] ?? 0,
                     weight[2] ?? 0,
                     weight[3] ?? 0
-                ], meshIndex, primitiveIndex));
-                const morphTargets = readMorphTargets(json, buffers, primitive, positions.length, meshIndex, primitiveIndex, accessorCache);
+                ], weightNormalization));
+                reportSkinWeightNormalization(meshIndex, primitiveIndex, weightNormalization);
+                const morphTargets = readMorphTargets(json, buffers, primitive, positions.length, meshIndex, primitiveIndex, accessorCache, readMorphTargetNames(mesh));
                 const resolvedPrimitive = resolvePrimitiveMode(primitive, indices?.map((index) => index[0] ?? 0), positions.length, meshIndex, primitiveIndex);
                 const geometry = createGeometryAsset(typedPositions, resolvedPrimitive.indices);
                 return {
@@ -616,7 +618,7 @@ function expandTriangleFan(indices) {
     }
     return expanded;
 }
-function readMorphTargets(json, buffers, primitive, vertexCount, meshIndex, primitiveIndex, accessorCache) {
+function readMorphTargets(json, buffers, primitive, vertexCount, meshIndex, primitiveIndex, accessorCache, targetNames = []) {
     if (primitive.targets === undefined) {
         return [];
     }
@@ -637,13 +639,25 @@ function readMorphTargets(json, buffers, primitive, vertexCount, meshIndex, prim
         if (tangents.length > 0 && tangents.length !== vertexCount) {
             throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} morph target ${targetIndex} TANGENT count mismatch`);
         }
+        const name = targetNames[targetIndex];
         return {
+            ...(typeof name === "string" && name.length > 0 ? { name } : {}),
             positions: positions.map((position) => [position[0] ?? 0, position[1] ?? 0, position[2] ?? 0]),
             normals: normals.map((normal) => [normal[0] ?? 0, normal[1] ?? 0, normal[2] ?? 0]),
             tangents: tangents.map((tangent) => [tangent[0] ?? 0, tangent[1] ?? 0, tangent[2] ?? 0])
         };
     });
 }
+// glTF stores morph-target names in `mesh.extras.targetNames` (a parallel array). Read them so the
+// runtime can expose named morph influences instead of bare indices.
+function readMorphTargetNames(mesh) {
+    const extras = mesh.extras;
+    const names = extras?.targetNames;
+    if (Array.isArray(names) && names.every((n) => typeof n === "string")) {
+        return names;
+    }
+    return [];
+}
 function validateMorphTargetDescriptor(target, meshIndex, primitiveIndex, targetIndex) {
     if (!isObjectRecord(target) || Array.isArray(target)) {
         throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} morph target ${targetIndex} must be an object`);
@@ -968,23 +982,54 @@ function validateQuantizedAttributeComponentType(componentType, semantic, meshQu
     }
     throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} ${semantic} accessor componentType ${componentType} is unsupported for KHR_mesh_quantization`);
 }
-function normalizeSkinWeights(weights, meshIndex, primitiveIndex) {
-    if (weights.some((weight) => !Number.isFinite(weight) || weight < 0)) {
-        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} WEIGHTS_0 must contain finite non-negative values`);
+const SKIN_WEIGHT_DEGENERATE_EPSILON = 1e-6;
+/**
+ * Normalize a single vertex's 4 skin weights so they sum to 1.
+ *
+ * Real-world catalog GLBs (Objaverse/Sketchfab) frequently ship denormalized,
+ * negative, or all-zero WEIGHTS_0 values. Rather than hard-failing the whole
+ * asset, sanitize per vertex: negative/non-finite components are clamped to 0,
+ * a degenerate (near-zero) sum collapses to a rigid binding `[1, 0, 0, 0]`, and
+ * any other sum is rescaled to 1. The optional `stats` accumulator lets callers
+ * surface a single diagnostic per primitive instead of one per vertex.
+ *
+ * Component proportions are preserved regardless of the source accessor
+ * componentType (FLOAT 5126, or normalized UNSIGNED_BYTE 5121 / UNSIGNED_SHORT
+ * 5123), so integer-encoded weights normalize correctly without extra handling.
+ */
+export function normalizeSkinWeights(weights, stats) {
+    const sanitized = [
+        Number.isFinite(weights[0]) && weights[0] > 0 ? weights[0] : 0,
+        Number.isFinite(weights[1]) && weights[1] > 0 ? weights[1] : 0,
+        Number.isFinite(weights[2]) && weights[2] > 0 ? weights[2] : 0,
+        Number.isFinite(weights[3]) && weights[3] > 0 ? weights[3] : 0
+    ];
+    const sum = sanitized[0] + sanitized[1] + sanitized[2] + sanitized[3];
+    if (sum < SKIN_WEIGHT_DEGENERATE_EPSILON) {
+        if (stats)
+            stats.degenerate += 1;
+        return [1, 0, 0, 0];
     }
-    const sum = weights[0] + weights[1] + weights[2] + weights[3];
-    if (sum <= 0) {
-        throw new Error(`glTF mesh ${meshIndex} primitive ${primitiveIndex} WEIGHTS_0 must sum to a positive value`);
+    if (Math.abs(sum - 1) <= 1e-5) {
+        return sanitized;
     }
-    if (Math.abs(sum - 1) <= 1e-5)
-        return weights;
+    if (stats)
+        stats.rescaled += 1;
     return [
-        weights[0] / sum,
-        weights[1] / sum,
-        weights[2] / sum,
-        weights[3] / sum
+        sanitized[0] / sum,
+        sanitized[1] / sum,
+        sanitized[2] / sum,
+        sanitized[3] / sum
     ];
 }
+function reportSkinWeightNormalization(meshIndex, primitiveIndex, stats) {
+    if (stats.degenerate === 0 && stats.rescaled === 0)
+        return;
+    if (typeof console === "undefined" || typeof console.warn !== "function")
+        return;
+    console.warn(`glTF mesh ${meshIndex} primitive ${primitiveIndex} WEIGHTS_0 normalized: ` +
+        `${stats.degenerate} degenerate vertex(es) set to [1,0,0,0], ${stats.rescaled} rescaled to sum 1`);
+}
 function createCameraAssets(json) {
     return (json.cameras ?? []).map((camera, index) => {
         if (camera.type === "perspective") {