プレビューで上半身のアニメが反映されるように

Author: logue

backend/src/convert/mod.rs

@@ -33,7 +33,10 @@ use skeleton::{
     regenerate_inverse_bind_matrices, rename_bones, set_skin_skeleton_root,
     validate_bone_conversion_preconditions,
 };
-use skinning::{optimize_skinning_weights_and_joints, remap_unmapped_bone_weights};
+use skinning::{
+    collapse_secondary_head_skins_to_primary, optimize_skinning_weights_and_joints,
+    remap_unmapped_bone_weights,
+};
 use validation::{
     collect_mapped_bones, collect_missing_required_bones, collect_node_names,
     collect_parent_index_map, estimate_texture_fee, extract_author, extract_humanoid_bone_nodes,
@@ -359,6 +362,7 @@ fn transform_and_write_glb(
     // in the skin joints list after optimization.
     remap_unmapped_bone_weights(&mut json, &mut bin, humanoid_bone_nodes);
     optimize_skinning_weights_and_joints(&mut json, &mut bin)?;
+    collapse_secondary_head_skins_to_primary(&mut json, &mut bin, humanoid_bone_nodes);
     // Clean up wrapper nodes above mPelvis.  Keeps the topmost non-SL
     // ancestor as an identity-transform root so that skin.skeleton can
     // reference a node with no positional offset, preventing the SL viewer

backend/src/convert/skeleton.rs

@@ -595,7 +595,11 @@ fn collect_primitives_for_skin_with_attributes(
         .cloned()
         .unwrap_or_default();
 
-    let mut seen = HashSet::<(usize, usize)>::new();
+    // Deduplicate by full accessor tuple. Different primitives may reuse
+    // JOINTS/WEIGHTS while pointing to different POSITION/NORMAL accessors;
+    // collapsing only by (JOINTS, WEIGHTS) would skip geometry correction for
+    // those primitives and can cause detached/flickering parts (e.g. face/eyes).
+    let mut seen = HashSet::<(usize, usize, Option<usize>, Option<usize>)>::new();
     let mut bindings = Vec::new();
 
     for node in nodes {
@@ -633,9 +637,6 @@ fn collect_primitives_for_skin_with_attributes(
             else {
                 continue;
             };
-            if !seen.insert((jnt_acc, wgt_acc)) {
-                continue;
-            }
             let pos_acc = attrs
                 .get("POSITION")
                 .and_then(Value::as_u64)
@@ -644,6 +645,9 @@ fn collect_primitives_for_skin_with_attributes(
                 .get("NORMAL")
                 .and_then(Value::as_u64)
                 .map(|v| v as usize);
+            if !seen.insert((jnt_acc, wgt_acc, pos_acc, norm_acc)) {
+                continue;
+            }
             bindings.push(PrimitiveBindingWithAttributes {
                 joints_accessor: jnt_acc,
                 weights_accessor: wgt_acc,
@@ -861,21 +865,18 @@ pub(super) fn promote_pelvis_to_scene_root(
 /// skeleton root."  It does NOT require the skeleton root to be listed in the
 /// skin's `joints` array.
 ///
-/// When an identity-root node exists above mPelvis, we point every skin's
-/// `skeleton` to that node.  Because the identity root has a pure identity
-/// transform, the SL viewer (and other importers that multiply the skeleton
-/// root's transform into the skinning equation) will not inject any unwanted
-/// offset.  All joints still resolve to their correct world positions through
-/// the normal parent-chain traversal.
+/// For Second Life compatibility, prefer `mPelvis` when available even if an
+/// identity wrapper root exists. Some importers/viewers treat non-bone wrapper
+/// roots differently and can introduce offsets/flicker around head/face skins.
 ///
-/// When no identity root is available (i.e. `promote_pelvis_to_scene_root`
-/// found no wrapper ancestors) we fall back to mPelvis itself.
+/// The optional `identity_root` is kept only as a fallback for models where
+/// hips are unavailable for any reason.
 pub(super) fn set_skin_skeleton_root(
     json: &mut Value,
     humanoid_bone_nodes: &HashMap<String, usize>,
     identity_root: Option<usize>,
 ) {
-    let skeleton_index = identity_root.or_else(|| humanoid_bone_nodes.get("hips").copied());
+    let skeleton_index = humanoid_bone_nodes.get("hips").copied().or(identity_root);
 
     let skins = match json["skins"].as_array_mut() {
         Some(s) => s,

backend/src/convert/skinning.rs

@@ -226,6 +226,131 @@ pub(super) fn optimize_skinning_weights_and_joints(json: &mut Value, bin: &mut [
     Ok(())
 }
 
+/// Stabilize tiny head/eye-only secondary skins by forcing a single `mHead`
+/// bind inside each skin.
+///
+/// This avoids importer instability with tiny facial skins that include eye
+/// joints while keeping skin-index topology unchanged.
+pub(super) fn collapse_secondary_head_skins_to_primary(
+    json: &mut Value,
+    bin: &mut [u8],
+    humanoid_bone_nodes: &HashMap<String, usize>,
+) {
+    let Some(skins) = json.get("skins").and_then(Value::as_array) else {
+        return;
+    };
+    if skins.len() <= 1 {
+        return;
+    }
+
+    let primary_skin_index = skins
+        .iter()
+        .enumerate()
+        .max_by_key(|(_, skin)| {
+            skin.get("joints")
+                .and_then(Value::as_array)
+                .map(|j| j.len())
+                .unwrap_or(0)
+        })
+        .map(|(i, _)| i);
+    let Some(primary_skin_index) = primary_skin_index else {
+        return;
+    };
+
+    let Some(head_node_index) = humanoid_bone_nodes.get("head").copied() else {
+        return;
+    };
+
+    let mut used_skin_indices = HashSet::<usize>::new();
+    if let Some(nodes) = json.get("nodes").and_then(Value::as_array) {
+        for node in nodes {
+            if let Some(si) = node.get("skin").and_then(Value::as_u64).map(|v| v as usize) {
+                used_skin_indices.insert(si);
+            }
+        }
+    }
+
+    for skin_index in 0..skins.len() {
+        if skin_index == primary_skin_index || !used_skin_indices.contains(&skin_index) {
+            continue;
+        }
+
+        let joints: Vec<usize> = json["skins"][skin_index]["joints"]
+            .as_array()
+            .map(|arr| {
+                arr.iter()
+                    .filter_map(|v| v.as_u64().map(|n| n as usize))
+                    .collect()
+            })
+            .unwrap_or_default();
+        if joints.is_empty() {
+            continue;
+        }
+
+        // Limit to tiny head/eye-only skins so body limb skins are untouched.
+        let is_tiny_head_skin = joints.len() <= 4
+            && joints.iter().all(|&node_idx| {
+                let name = json["nodes"][node_idx]
+                    .get("name")
+                    .and_then(Value::as_str)
+                    .unwrap_or("");
+                matches!(name, "mHead" | "mEyeLeft" | "mEyeRight")
+            });
+        if !is_tiny_head_skin {
+            continue;
+        }
+
+        let bindings = collect_skin_primitive_bindings(json, skin_index);
+        for binding in bindings {
+            let Some(joints_meta) = accessor_meta(json, binding.joints_accessor) else {
+                continue;
+            };
+            let Some(weights_meta) = accessor_meta(json, binding.weights_accessor) else {
+                continue;
+            };
+            if joints_meta.accessor_type != "VEC4" || weights_meta.accessor_type != "VEC4" {
+                continue;
+            }
+            if !(joints_meta.component_type == 5121 || joints_meta.component_type == 5123) {
+                continue;
+            }
+            if weights_meta.component_type != 5126 {
+                continue;
+            }
+
+            let count = joints_meta.count.min(weights_meta.count);
+            for vertex_index in 0..count {
+                let _ = write_joint_slot(bin, &joints_meta, vertex_index, 0, 0);
+                let _ = write_joint_slot(bin, &joints_meta, vertex_index, 1, 0);
+                let _ = write_joint_slot(bin, &joints_meta, vertex_index, 2, 0);
+                let _ = write_joint_slot(bin, &joints_meta, vertex_index, 3, 0);
+
+                let _ = write_weight_f32(bin, &weights_meta, vertex_index, 0, 1.0);
+                let _ = write_weight_f32(bin, &weights_meta, vertex_index, 1, 0.0);
+                let _ = write_weight_f32(bin, &weights_meta, vertex_index, 2, 0.0);
+                let _ = write_weight_f32(bin, &weights_meta, vertex_index, 3, 0.0);
+            }
+        }
+
+        // Rewrite this skin to a single-joint mHead bind.
+        if let Some(skins_mut) = json.get_mut("skins").and_then(Value::as_array_mut)
+            && let Some(skin_mut) = skins_mut.get_mut(skin_index)
+        {
+            skin_mut["joints"] = Value::Array(vec![Value::from(head_node_index as u64)]);
+
+            if let Some(acc_idx) = skin_mut
+                .get("inverseBindMatrices")
+                .and_then(Value::as_u64)
+                .map(|v| v as usize)
+                && let Some(accessors) = json.get_mut("accessors").and_then(Value::as_array_mut)
+                && let Some(accessor) = accessors.get_mut(acc_idx)
+            {
+                accessor["count"] = Value::from(1u64);
+            }
+        }
+    }
+}
+
 fn collect_skin_primitive_bindings(json: &Value, skin_index: usize) -> Vec<PrimitiveSkinBinding> {
     let nodes = json
         .get("nodes")