Mixamo-style arm-space post-process (#854)

.github/workflows/deploy.yml

@@ -2138,19 +2138,55 @@ jobs:
             file ${{github.workspace}}/bin/QtMeshEditor.app/Contents/MacOS/QtMeshEditor
 
     - name: Pack
-      run: | 
+      run: |
+            set -euo pipefail
             brew install create-dmg
-            sudo create-dmg \
-            --volname "QtMeshEditor Installer" \
-            --volicon "${{github.workspace}}/resources/icon.icns" \
-            --window-pos 200 120 \
-            --window-size 800 400 \
-            --icon-size 100 \
-            --icon "QtMeshEditor.app" 200 190 \
-            --app-drop-link 600 185 \
-            QtMeshEditor-${{github.ref_name}}-MacOS.dmg \
-            ${{github.workspace}}/bin/QtMeshEditor.app
-
+            # github.ref_name is "867/merge" on a PR — the slash makes
+            # create-dmg treat "QtMeshEditor-867/merge-MacOS.dmg" as a path,
+            # cd into the nonexistent "QtMeshEditor-867/" dir, and write the
+            # DMG under the wrong name (the real, deterministic cause of the
+            # macOS Pack failures on PRs, not a create-dmg flake). Sanitize
+            # any '/' out of the basename. Release tags (X.Y.Z) are unaffected.
+            REF="$(echo "${{github.ref_name}}" | tr '/' '-')"
+            DMG="QtMeshEditor-${REF}-MacOS.dmg"
+            APP="${{github.workspace}}/bin/QtMeshEditor.app"
+
+            # create-dmg also mounts a disk image + AppleScript-positions the
+            # icons, which can race on CI. Retry a few times, and if it still
+            # fails fall back to a plain hdiutil DMG so packaging never blocks
+            # the build on a transient tooling flake. The pretty layout is
+            # only cosmetic - the fallback DMG installs identically.
+            make_pretty_dmg() {
+                rm -f "$DMG"
+                sudo create-dmg \
+                    --volname "QtMeshEditor Installer" \
+                    --volicon "${{github.workspace}}/resources/icon.icns" \
+                    --window-pos 200 120 \
+                    --window-size 800 400 \
+                    --icon-size 100 \
+                    --icon "QtMeshEditor.app" 200 190 \
+                    --app-drop-link 600 185 \
+                    "$DMG" "$APP"
+            }
+            ok=0
+            for attempt in 1 2 3; do
+                echo "create-dmg attempt ${attempt}..."
+                if make_pretty_dmg; then ok=1; break; fi
+                echo "create-dmg attempt ${attempt} failed; detaching stray mounts and retrying"
+                hdiutil detach "/Volumes/QtMeshEditor Installer" -force 2>/dev/null || true
+                sleep 5
+            done
+            if [ "$ok" -ne 1 ]; then
+                echo "create-dmg failed 3x - falling back to a plain hdiutil DMG"
+                rm -f "$DMG"
+                staging="$(mktemp -d)"
+                cp -R "$APP" "$staging/"
+                ln -s /Applications "$staging/Applications"
+                hdiutil create -volname "QtMeshEditor Installer" \
+                    -srcfolder "$staging" -ov -format UDZO "$DMG"
+            fi
+            ls -la "$DMG"
+
     - if: github.event_name == 'release' && github.event.action == 'published'
       uses: actions/upload-artifact@v4
       with:

qml/PropertiesPanel.qml

@@ -7953,14 +7953,45 @@ Rectangle {
             spacing: 4
 
             property var entityGroups: PropertiesPanelController.animationData()
+            // #854: the clip the arm-space slider targets. Defaults to the last
+            // generated clip, but the per-row arm button can point it at ANY
+            // animation. Cleared on selection change.
+            property string lastGeneratedAnim: ""
+            property string armSpaceAnim: ""
+            property string armSpaceEntity: ""
 
             function refreshAnimData() {
                 entityGroups = PropertiesPanelController.animationData()
             }
 
+            // #854: point the arm-space slider at a clip. The adjustment
+            // STICKS to that clip (so it exports widened) and is independent
+            // per clip. Generation always produces a CLEAN clip (slider value
+            // never bakes into it), and the slider is seeded with the target
+            // clip's ACTUAL current angle — so switching clips shows the truth
+            // and a fresh generate shows 0. Closing the panel / reselecting
+            // just detaches the slider (no revert; the clip keeps its edit).
+            function setArmSpaceTarget(animName, entity) {
+                armSpaceAnim = animName
+                armSpaceEntity = entity
+                var cur = AnimationControlController.currentArmSpace(animName, entity)
+                armSpaceSlider.value = cur
+                armSpaceSlider.lastApplied = cur
+            }
+            function detachArmSpace() {
+                armSpaceAnim = ""
+                armSpaceEntity = ""
+                armSpaceSlider.value = 0
+                armSpaceSlider.lastApplied = 0
+            }
+
             Connections {
                 target: PropertiesPanelController
-                function onSelectionChanged() { refreshAnimData() }
+                function onSelectionChanged() {
+                    lastGeneratedAnim = ""
+                    detachArmSpace()
+                    refreshAnimData()
+                }
                 function onAnimationStateChanged() { refreshAnimData() }
             }
 
@@ -7984,6 +8015,27 @@ Rectangle {
                         verticalAlignment: TextInput.AlignVCenter
                         color: PropertiesPanelController.textColor; font.pixelSize: 11
                         clip: true
+                        // selectByMouse lets a click position the caret AND take
+                        // keyboard focus — without it a bare TextInput embedded
+                        // in a QQuickWidget stays unfocused on click (the other
+                        // working fields in this panel all set it). activeFocus-
+                        // OnPress is the default but stated for clarity.
+                        selectByMouse: true
+                        activeFocusOnPress: true
+                        // Belt-and-suspenders focus grab: after using the
+                        // arm-space slider / arm buttons (which take focus and
+                        // can leave the QQuickWidget's focus on the viewport),
+                        // a plain click here didn't always re-focus the field.
+                        // Force it on press and let the event through (accepted
+                        // = false) so selectByMouse still positions the caret.
+                        MouseArea {
+                            anchors.fill: parent
+                            cursorShape: Qt.IBeamCursor
+                            onPressed: function(mouse) {
+                                genPromptIn.forceActiveFocus()
+                                mouse.accepted = false
+                            }
+                        }
                         Text {
                             anchors.verticalCenter: parent.verticalCenter
                             visible: !genPromptIn.text && !genPromptIn.activeFocus
@@ -8008,8 +8060,19 @@ Rectangle {
                             ? "Generating (experimental model)…"
                             : "Generating… (first use downloads the motion library)"
                         genStatus.isError = false
-                        AnimationControlController.generateMotion(genPromptIn.text, 0.0,
-                                                                  useModelChk.checked)
+                        // Generate a CLEAN clip — arm-space is always an
+                        // explicit post-adjustment starting from 0, never baked
+                        // into generation (a leftover slider value silently
+                        // skewing every new clip is exactly the bug this fixes).
+                        var gr = AnimationControlController.generateMotion(
+                                     genPromptIn.text, 0.0, useModelChk.checked,
+                                     0.0)
+                        if (gr && gr.animation) {
+                            lastGeneratedAnim = gr.animation
+                            // Point the slider at the fresh clip at a neutral 0
+                            // (reverts any prior target — see setArmSpaceTarget).
+                            setArmSpaceTarget(gr.animation, gr.entity || "")
+                        }
                         genBtnBusy = false
                         // generateMotion adds an AnimationState synchronously, but
                         // it lives on AnimationControlController — the Inspector
@@ -8046,6 +8109,62 @@ Rectangle {
                     anchors.verticalCenter: parent.verticalCenter
                 }
             }
+            // ── Arm space (#854): Mixamo-style widen/tuck post-process ────────
+            // Targets `armSpaceAnim` — the last generated clip by default, or
+            // any animation the user picks via the per-row arm button below.
+            // The op is ABSOLUTE + idempotent, so dragging can re-apply live at
+            // each value (no accumulation) and the slider maps straight to the
+            // stored angle.
+            Row {
+                width: parent.width - 16; spacing: 6
+                visible: armSpaceAnim.length > 0
+                Text {
+                    text: "Arm space"
+                    color: PropertiesPanelController.textColor; font.pixelSize: 10
+                    anchors.verticalCenter: parent.verticalCenter
+                    width: 62
+                    elide: Text.ElideRight
+                }
+                Slider {
+                    id: armSpaceSlider
+                    anchors.verticalCenter: parent.verticalCenter
+                    width: parent.width - 62 - 42 - 12
+                    from: -30; to: 45; value: 0; stepSize: 1
+                    // Live update: adjustArmSpace is absolute+idempotent, so
+                    // firing it per value while dragging just re-applies (never
+                    // accumulates). Throttle to whole degrees via stepSize so we
+                    // rewrite keyframes at most ~75 times across the range.
+                    property real lastApplied: 0
+                    onValueChanged: {
+                        if (armSpaceAnim.length > 0
+                            && Math.round(value) !== Math.round(lastApplied)) {
+                            lastApplied = value
+                            AnimationControlController.adjustArmSpace(
+                                armSpaceAnim, value, armSpaceEntity)
+                        }
+                    }
+                    // Refresh the Inspector list only on release (the viewport
+                    // itself updates live inside adjustArmSpace).
+                    onPressedChanged: { if (!pressed) refreshAnimData() }
+                }
+                Text {
+                    text: (armSpaceSlider.value > 0 ? "+" : "")
+                          + Math.round(armSpaceSlider.value) + "°"
+                    color: PropertiesPanelController.textColor; font.pixelSize: 10
+                    anchors.verticalCenter: parent.verticalCenter
+                    width: 42; horizontalAlignment: Text.AlignRight
+                }
+            }
+            // Label showing which clip the slider affects (only when it's not
+            // the obvious just-generated one).
+            Text {
+                visible: armSpaceAnim.length > 0
+                width: parent.width - 16; wrapMode: Text.Wrap
+                text: "↑ adjusting \"" + armSpaceAnim + "\" (0 = no change). The "
+                      + "edit stays on this clip; click ↔ again to detach."
+                color: PropertiesPanelController.textColor; opacity: 0.5
+                font.pixelSize: 9
+            }
             Text {
                 id: genStatus
                 property bool isError: false
@@ -8554,6 +8673,49 @@ Rectangle {
                                         }
                                     }
 
+                                    // Arm space (#854) — point the arm-space
+                                    // slider (above) at THIS clip. Works on any
+                                    // skeletal animation, not just generated
+                                    // ones. Highlights when it's the active target.
+                                    Rectangle {
+                                        id: armBtn
+                                        visible: grp.hasSkeleton
+                                        width: 22; height: 18; radius: 3
+                                        anchors.verticalCenter: parent.verticalCenter
+                                        property bool active: armSpaceAnim === modelData.name
+                                                              && armSpaceEntity === grp.entity
+                                        color: active ? PropertiesPanelController.highlightColor
+                                             : armMouse.pressed ? Qt.darker(PropertiesPanelController.headerColor, 1.2)
+                                             : armMouse.containsMouse ? Qt.lighter(PropertiesPanelController.headerColor, 1.2)
+                                             : PropertiesPanelController.headerColor
+                                        border.color: PropertiesPanelController.borderColor; border.width: 1
+                                        Text {
+                                            anchors.centerIn: parent
+                                            text: "↔"  // ↔ widen/tuck
+                                            color: armBtn.active ? "white"
+                                                 : PropertiesPanelController.textColor
+                                            font.pixelSize: 12
+                                        }
+                                        ToolTip.visible: armMouse.containsMouse
+                                        ToolTip.delay: 600
+                                        ToolTip.text: "Arm space — retarget the widen/tuck slider to this animation"
+                                        MouseArea {
+                                            id: armMouse; anchors.fill: parent; hoverEnabled: true
+                                            cursorShape: Qt.PointingHandCursor
+                                            onClicked: {
+                                                // Toggle: detach if it's already
+                                                // the target (the clip keeps its
+                                                // edit), else target this clip
+                                                // (seeded with its real angle).
+                                                if (armBtn.active)
+                                                    detachArmSpace()
+                                                else
+                                                    setArmSpaceTarget(
+                                                        modelData.name, grp.entity)
+                                            }
+                                        }
+                                    }
+
                                     // Bake — resample / reduce every bone track in this
                                     // animation. Mirrors the curve editor's per-bone Bake
                                     // dropdown but applies to the whole animation in one

src/AnimationControlController.cpp

@@ -1659,8 +1659,71 @@
     return out;
 }
 
+bool AnimationControlController::adjustArmSpace(const QString& animName,
+                                                double degrees,
+                                                const QString& entityName)
+{
+    Manager* mgr = Manager::getSingletonPtr();
+    if (!mgr) return false;
+    const std::string want = entityName.isEmpty()
+        ? m_selectedEntityName : entityName.toStdString();
+    Ogre::Entity* entity = nullptr;
+    for (auto* e : mgr->getEntities()) {
+        if (!e || e->getMovableType() != "Entity" || !e->hasSkeleton()) continue;
+        if (want.empty() || e->getName() == want) { entity = e; break; }
+    }
+    if (!entity) return false;
+    Ogre::SkeletonPtr skel = entity->getMesh()->getSkeleton();
+    const std::string an = animName.toStdString();
+    if (!skel || !skel->hasAnimation(an)) return false;
+
+    SentryReporter::addBreadcrumb(QStringLiteral("ui.action"),
+        QStringLiteral("GUI arm_space %1 deg").arg(degrees));
+    if (!AnimationMerger::adjustArmSpace(skel.get(), an,
+                                         static_cast<float>(degrees)))
+        return false;
+
+    // Re-pose the mesh NOW, even when the clip is paused. Rewriting keyframes
+    // doesn't move the bones until the animation state re-applies; when
+    // playback is stopped nothing ticks it, so the viewport would stay frozen
+    // on the pre-edit pose until the user hits play. Mark the state dirty and
+    // re-stamp its current time to force an immediate re-evaluation (the same
+    // idiom as notifyOgreUpdate, but targeting THIS entity + clip so it works
+    // for any animation, not just the selected one).
+    entity->refreshAvailableAnimationState();
+    if (auto* states = entity->getAllAnimationStates()) {
+        states->_notifyDirty();
+        if (states->hasAnimationState(an)) {
+            auto* st = states->getAnimationState(an);
+            if (st->getEnabled())
+                st->setTimePosition(st->getTimePosition());
+        }
+    }
+    notifyExternalAnimationEdit();
+    return true;
+}
+
+double AnimationControlController::currentArmSpace(const QString& animName,
+                                                   const QString& entityName)
+{
+    Manager* mgr = Manager::getSingletonPtr();
+    if (!mgr) return 0.0;
+    const std::string want = entityName.isEmpty()
+        ? m_selectedEntityName : entityName.toStdString();
+    for (auto* e : mgr->getEntities()) {
+        if (!e || e->getMovableType() != "Entity" || !e->hasSkeleton()) continue;
+        if (want.empty() || e->getName() == want) {
+            Ogre::SkeletonPtr skel = e->getMesh()->getSkeleton();
+            return skel ? AnimationMerger::currentArmSpace(
+                              skel.get(), animName.toStdString()) : 0.0;
+        }
+    }
+    return 0.0;
+}
+
 QVariantMap AnimationControlController::generateMotion(const QString& prompt,
-                                                       double duration, bool useModel)
+                                                       double duration, bool useModel,
+                                                       double armSpaceDeg)
 {
     QVariantMap out;
     out["ok"] = false;
@@ -1750,15 +1813,20 @@
     const std::string animName = ("generated_" + action).toStdString();
     // Auto-rigged (no prior animation) meshes that face −Z would walk
     // backward — detect facing from the mesh's foot region.
     const bool yaw180 = AnimationMerger::detectBackwardFacing(entity);
     const auto res = AnimationMerger::applyMotionClip(skel.get(), animName, quats, fps,
                                                       worldFrame, cmuRest,
                                                       /*refineWithModel=*/false,
                                                       /*refineStride=*/8, yaw180,
                                                       clipDirs);
     if (!res.ok) return fail(res.error);
     out["source"] = clipSource;
 
+    // #854: optional Mixamo-style arm-space post-process.
+    if (std::abs(armSpaceDeg) > 1e-4)
+        AnimationMerger::adjustArmSpace(skel.get(), animName,
+                                        static_cast<float>(armSpaceDeg));
+
     entity->refreshAvailableAnimationState();
     // Make the generated clip the ONLY enabled animation. Ogre AVERAGES all
     // enabled animation states, so leaving the import's auto-enabled clip (or
@@ -1794,6 +1862,7 @@
     out["action"] = action;
     out["source"] = clipSource;
     out["animation"] = QString::fromStdString(animName);
+    out["entity"] = QString::fromStdString(entity->getName());
     out["frames"] = res.frames;
     out["length"] = res.length;
     out["tracksWritten"] = res.tracksWritten;