{

delete m_pSingleton;

m_pSingleton = nullptr;

: QObject(nullptr)

{

connect(SelectionSet::getSingleton(), &SelectionSet::selectionChanged,

this, &AnimationControlController::updateAnimationTree);

connect(qApp, &QApplication::paletteChanged, this, [this]() {

emit themeChanged();

});

m_pollTimer = new QTimer(this);

connect(m_pollTimer, &QTimer::timeout, this, [this]() {

if (!m_selectedEntity || m_selectedAnimation.empty()) return;

if (!m_selectedEntity->hasAnimationState(m_selectedAnimation)) return;

Ogre::AnimationState* state = m_selectedEntity->getAnimationState(m_selectedAnimation);

int newMs = static_cast<int>(state->getTimePosition() * 1000);

if (newMs != m_sliderValue) {

m_sliderValue = newMs;

emit sliderValueChanged();

setAnimationFrame(newMs);

}

});

m_pollTimer->start(16);

{

// Save current selection to restore after rebuild

QString prevEntity = QString::fromStdString(m_selectedEntityName);

QString prevAnim = QString::fromStdString(m_selectedAnimation);

QVariantList newTree;

for (Ogre::Entity* entity : SelectionSet::getSingleton()->getResolvedEntities()) {

Ogre::AnimationStateSet* set = entity->getAllAnimationStates();

if (!set) continue;

QStringList animNames;

for (const auto& pair : set->getAnimationStates())

animNames << QString::fromStdString(pair.first);

if (animNames.isEmpty()) continue;

QVariantMap group;

group["entity"] = QString::fromStdString(entity->getName());

group["animations"] = animNames;

newTree.append(group);

}

// Early-out when the tree hasn't actually changed AFTER it's been

// built once: the connected signal (SelectionSet::selectionChanged)

// also fires whenever undo commands are pushed (mainwindow re-emits

// it on QUndoStack indexChanged). Without this guard, every

// BoneTransformCommand push would call selectAnimation() and reset

// slider+bone selection. We always run the first call so QML

// listeners get an initial signal, even if the tree is empty.

if (m_animationTreeBuilt && newTree == m_animationTree) return;

m_animationTree = newTree;

m_animationTreeBuilt = true;

emit animationTreeChanged();

// Try to restore selection

if (!prevEntity.isEmpty() && !prevAnim.isEmpty()) {

selectAnimation(prevEntity, prevAnim);

} else if (!m_animationTree.isEmpty()) {

// Auto-select first animation

auto first = m_animationTree.first().toMap();

auto anims = first["animations"].toStringList();

if (!anims.isEmpty())

selectAnimation(first["entity"].toString(), anims.first());

else

selectAnimation("", "");

} else {

selectAnimation("", "");

}

{

// Reset state

m_selectedEntity = nullptr;

m_selectedSkeleton = nullptr;

m_selectedTrack = nullptr;

m_currentKeyframe = nullptr;

m_selectedEntityName.clear();

m_selectedAnimation.clear();

m_selectedBone.clear();

m_sliderValue = 0;

m_sliderMaximum = 0;

m_selectedTick = -1;

m_boneNames.clear();

m_keyframeTicks.clear();

if (entityName.isEmpty() || animName.isEmpty()) {

emit selectionChanged();

emit boneListChanged();

emit sliderValueChanged();

emit animationLengthChanged();

emit keyframeTicksChanged();

emit currentKeyframeChanged();

return;

}

// Find the entity

for (Ogre::Entity* entity : SelectionSet::getSingleton()->getResolvedEntities()) {

if (entity->getName() == entityName.toStdString()) {

m_selectedEntity = entity;

break;

}

}

if (!m_selectedEntity) {

emit selectionChanged();

return;

}

m_selectedEntityName = entityName.toStdString();

m_selectedAnimation = animName.toStdString();

m_selectedSkeleton = m_selectedEntity->getSkeleton();

if (m_selectedSkeleton && m_selectedSkeleton->hasAnimation(m_selectedAnimation)) {

Ogre::Animation* anim = m_selectedSkeleton->getAnimation(m_selectedAnimation);

m_sliderMaximum = static_cast<int>(anim->getLength() * 1000);

}

// Reset loop region to span the whole animation whenever a new clip is

// selected — users typically want fresh in/out points per clip.

m_loopStart = 0.0;

m_loopEnd = m_sliderMaximum / 1000.0;

m_loopRegionActive = false;

emit loopRegionChanged();

emit selectionChanged();

emit animationLengthChanged();

emit sliderValueChanged();

refreshBoneList();

{

m_boneNames.clear();

m_selectedTrack = nullptr;

m_currentKeyframe = nullptr;

m_selectedBone.clear();

if (!m_selectedSkeleton || m_selectedAnimation.empty()) {

emit boneListChanged();

emit keyframeTicksChanged();

emit currentKeyframeChanged();

return;

}

if (!m_selectedSkeleton->hasAnimation(m_selectedAnimation)) {

emit boneListChanged();

emit keyframeTicksChanged();

emit currentKeyframeChanged();

return;

}

// Show every bone in the skeleton — not just the ones that already

// have a track in this animation. Tracks for picked-but-untracked

// bones get created lazily when the user adds a keyframe. Order:

// tracked bones first (so users see what's already animated at the

// top), then the rest in skeleton index order.

Ogre::Animation* anim = m_selectedSkeleton->getAnimation(m_selectedAnimation);

QSet<QString> trackedNames;

for (const auto& pair : anim->_getNodeTrackList()) {

QString name = QString::fromStdString(pair.second->getAssociatedNode()->getName());

m_boneNames << name;

trackedNames.insert(name);

}

for (unsigned short i = 0; i < m_selectedSkeleton->getNumBones(); ++i) {

QString name = QString::fromStdString(m_selectedSkeleton->getBone(i)->getName());

if (!trackedNames.contains(name))

m_boneNames << name;

}

emit boneListChanged();

if (!m_boneNames.isEmpty())

selectBone(m_boneNames.first());

else {

emit keyframeTicksChanged();

emit currentKeyframeChanged();

}

{

if (!bone) return true;

// Skeleton roots → always translatable (these are the "this is the

// character" bones that move the whole rig around — Hips, Pelvis,

// Armature, etc. — and may also have skin weights). Some importers

// wrap the actual root in an additional parent bone, so we check

// both: parentless OR present in Skeleton::getRootBones().

if (!bone->getParent()) return true;

if (m_selectedSkeleton) {

for (Ogre::Bone* root : m_selectedSkeleton->getRootBones())

if (root == bone) return true;

}

if (!m_selectedEntity) return true;

Ogre::MeshPtr mesh = m_selectedEntity->getMesh();

if (!mesh) return true;

// Walk every submesh's vertex-bone-assignment list. If any vertex

// is weighted to this bone's handle, translating it would tear the

// mesh away from the rig.

const auto handle = bone->getHandle();

auto referencesBone = [&](const Ogre::SubMesh::VertexBoneAssignmentList& list) {

for (auto it = list.begin(); it != list.end(); ++it)

if (it->second.boneIndex == handle) return true;

return false;

};

if (referencesBone(mesh->getBoneAssignments())) return false;

for (unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i) {

Ogre::SubMesh* sub = mesh->getSubMesh(i);

if (!sub) continue;

if (referencesBone(sub->getBoneAssignments())) return false;

}

return true;

{

m_selectedTrack = nullptr;

m_currentKeyframe = nullptr;

m_selectedBone = boneName.toStdString();

// Clear all bone selection highlights

if (m_selectedSkeleton) {

for (unsigned short i = 0; i < m_selectedSkeleton->getNumBones(); ++i)

m_selectedSkeleton->getBone(i)->getUserObjectBindings()

.setUserAny("selected", Ogre::Any(false));

}

// Highlight the picked bone first — independent of whether a track

// exists for it in the current animation. Bones that aren't yet

// rigged into the active clip (no NodeAnimationTrack) should still

// visually select; the keyframe-editing path then no-ops cleanly

// since m_selectedTrack stays null until the user actually adds a

// keyframe (which lazily creates the track).

if (m_selectedSkeleton && !m_selectedBone.empty()

&& m_selectedSkeleton->hasBone(m_selectedBone))

{

m_selectedSkeleton->getBone(m_selectedBone)

->getUserObjectBindings().setUserAny("selected", Ogre::Any(true));

}

// Bind the existing track for this bone, if the animation has one.

if (m_selectedSkeleton && !m_selectedAnimation.empty()

&& m_selectedSkeleton->hasAnimation(m_selectedAnimation))

{

Ogre::Animation* anim = m_selectedSkeleton->getAnimation(m_selectedAnimation);

for (const auto& pair : anim->_getNodeTrackList()) {

if (pair.second->getAssociatedNode()->getName() == m_selectedBone) {

m_selectedTrack = pair.second;

break;

}

}

}

emit boneListChanged();

refreshSliderTicks();

setAnimationFrame(m_sliderValue);

{

if (ms == m_sliderValue && m_selectedEntity) {

// Still call setAnimationFrame to keep Ogre in sync on explicit user drags

}

m_sliderValue = ms;

emit sliderValueChanged();

setAnimationFrame(ms);

{

if (!m_selectedSkeleton || m_selectedAnimation.empty()) return;

if (!m_selectedSkeleton->hasAnimation(m_selectedAnimation)) return;

Ogre::Animation* anim = m_selectedSkeleton->getAnimation(m_selectedAnimation);

anim->setLength(static_cast<float>(length));

m_sliderMaximum = static_cast<int>(length * 1000);

if (m_sliderValue > m_sliderMaximum) {

m_sliderValue = m_sliderMaximum;

emit sliderValueChanged();

}

if (m_selectedEntity && m_selectedEntity->hasAnimationState(m_selectedAnimation)) {

Ogre::AnimationState* state = m_selectedEntity->getAnimationState(m_selectedAnimation);

state->setLength(static_cast<float>(length));

state->setTimePosition(std::min(state->getTimePosition(), static_cast<float>(length)));

m_selectedEntity->getAllAnimationStates()->_notifyDirty();

}

refreshSliderTicks();

emit animationLengthChanged();

{

if (s < 0.0) s = 0.0;

if (qFuzzyCompare(s, m_playbackSpeed)) return;

m_playbackSpeed = s;

emit playbackSpeedChanged();

{

if (s < 0.0) s = 0.0;

// Clamp first, then bail out if nothing actually changed — avoids

// emitting loopRegionChanged when the request collapses to the

// existing value after clamping.

if (m_loopEnd > 0.0 && s > m_loopEnd) {

s = m_loopEnd;

}

if (qFuzzyCompare(s, m_loopStart)) return;

m_loopStart = s;

emit loopRegionChanged();

{

if (s < 0.0) s = 0.0;

if (qFuzzyCompare(s, m_loopEnd)) return;

m_loopEnd = s;

if (m_loopEnd > 0.0 && m_loopStart > m_loopEnd) {

m_loopStart = m_loopEnd;

}

emit loopRegionChanged();

{

if (on == m_loopRegionActive) return;

m_loopRegionActive = on;

emit loopRegionChanged();

{

if (on == m_autoKey) return;

m_autoKey = on;

SentryReporter::addBreadcrumb("ui.action",

QString("AutoKey toggled %1").arg(on ? "on" : "off"));

emit autoKeyChanged();

{

if (!m_autoKey) return;

// Don't require m_selectedTrack here — addKeyframe lazily creates

// the track for non-rigged bones. Just ensure the bone-level

// identity is set so addKeyframe has something to write into.

if (!m_selectedEntity || m_selectedAnimation.empty()) return;

if (!m_selectedSkeleton || m_selectedBone.empty()) return;

SentryReporter::addBreadcrumb("ui.action", "AutoKey applied keyframe");

addKeyframe();

{

double next = currentTime + dt * m_playbackSpeed;

// Apply loop region only when active and the region is well-formed.

if (m_loopRegionActive && m_loopEnd > m_loopStart) {

if (next > m_loopEnd) {

const double span = m_loopEnd - m_loopStart;

double over = next - m_loopEnd;

// Wrap any number of full passes back into the region.

if (span > 0.0) over = std::fmod(over, span);

next = m_loopStart + over;

} else if (next < m_loopStart) {

// Reverse wrap (negative speed); not exposed via UI today but kept

// symmetrical so callers don't trip if they ever get here.

const double span = m_loopEnd - m_loopStart;

double under = m_loopStart - next;

if (span > 0.0) under = std::fmod(under, span);

next = m_loopEnd - under;

}

}

return next;

{

if (!m_selectedEntity || m_selectedAnimation.empty()) return;

if (!m_selectedEntity->hasAnimationState(m_selectedAnimation)) return;

Ogre::AnimationState* state = m_selectedEntity->getAnimationState(m_selectedAnimation);

state->setTimePosition(ms / 1000.0f);

if (!m_selectedTrack || m_selectedTrack->getNumKeyFrames() == 0) {

if (m_currentKeyframe) {

m_updatingValues = true;

m_currentKeyframe = nullptr;

m_selectedTick = -1;

m_updatingValues = false;

emit keyframeTicksChanged();

emit currentKeyframeChanged();

}

return;

}

Ogre::KeyFrame* kf1 = nullptr;

Ogre::KeyFrame* kf2 = nullptr;

m_selectedTrack->getKeyFramesAtTime(ms / 1000.0f, &kf1, &kf2);

Ogre::TransformKeyFrame* closest = nullptr;

if (kf1 && kf2) {

float d1 = std::fabs(kf1->getTime() - ms / 1000.0f);

float d2 = std::fabs(kf2->getTime() - ms / 1000.0f);

closest = static_cast<Ogre::TransformKeyFrame*>(d1 <= d2 ? kf1 : kf2);

} else if (kf1) {

closest = static_cast<Ogre::TransformKeyFrame*>(kf1);

} else if (kf2) {

closest = static_cast<Ogre::TransformKeyFrame*>(kf2);

}

bool tickChanged = (closest != m_currentKeyframe);

m_currentKeyframe = closest;

if (m_currentKeyframe) {

int newTick = static_cast<int>(m_currentKeyframe->getTime() * 1000);

if (newTick != m_selectedTick) {

m_selectedTick = newTick;

tickChanged = true;

}

} else {

m_selectedTick = -1;

tickChanged = true;

}

if (tickChanged) emit keyframeTicksChanged();

if (m_currentKeyframe) pushKeyframeValues();

{

m_keyframeTicks.clear();

m_selectedTick = -1;

if (m_selectedTrack) {

for (unsigned short i = 0; i < m_selectedTrack->getNumKeyFrames(); ++i)

m_keyframeTicks.append(static_cast<int>(m_selectedTrack->getKeyFrame(i)->getTime() * 1000));

if (m_currentKeyframe)

m_selectedTick = static_cast<int>(m_currentKeyframe->getTime() * 1000);

}

emit keyframeTicksChanged();

// Dope-sheet view re-queries rows on the same signals as track-level

// changes (add/delete/move/select).

emit boneRowsChanged();

{

// Structural undo/redo (track destroy, keyframe add/remove) can

// invalidate cached pointers we hold. Drop them and re-resolve

// against the current skeleton state — but preserve the user's

// current bone selection (refreshBoneList would reset to the

// first bone, which is jarring).

m_selectedTrack = nullptr;

m_currentKeyframe = nullptr;

m_selectedTick = -1;

// Re-resolve m_selectedTrack from the active animation + bone, if

// both are still valid (the track may have been destroyed by an

// AddKeyframeCommand undo on a lazy-created track).

if (m_selectedSkeleton && !m_selectedAnimation.empty()

&& m_selectedSkeleton->hasAnimation(m_selectedAnimation)

&& !m_selectedBone.empty()

&& m_selectedSkeleton->hasBone(m_selectedBone))

{

Ogre::Animation* anim = m_selectedSkeleton->getAnimation(m_selectedAnimation);

for (const auto& pair : anim->_getNodeTrackList()) {

if (pair.second->getAssociatedNode()->getName() == m_selectedBone) {

m_selectedTrack = pair.second;

break;

}

}

}

refreshSliderTicks();

setAnimationFrame(m_sliderValue);

// The dope sheet + curve editor read keyTimes from allBoneRows(),

// which they refresh on boneRowsChanged. Without this emit, undo

// of a Bake leaves the QML views showing stale dense keyframes

// even though the underlying track has been reverted.

emit boneRowsChanged();

{

if (!m_selectedTrack || m_selectedTrack->getNumKeyFrames() == 0) return false;

float time = m_sliderValue / 1000.0f;

for (int i = static_cast<int>(m_selectedTrack->getNumKeyFrames()) - 1; i >= 0; --i) {

if (m_selectedTrack->getKeyFrame(i)->getTime() < time - 0.001f) return true;

}

return false;

{

if (!m_selectedTrack || m_selectedTrack->getNumKeyFrames() == 0) return false;

float time = m_sliderValue / 1000.0f;

for (unsigned short i = 0; i < m_selectedTrack->getNumKeyFrames(); ++i) {

if (m_selectedTrack->getKeyFrame(i)->getTime() > time + 0.001f) return true;

}

return false;

{

if (!m_selectedTrack || m_selectedTrack->getNumKeyFrames() == 0) return;

float time = m_sliderValue / 1000.0f;

Ogre::TransformKeyFrame* target = nullptr;

for (int i = static_cast<int>(m_selectedTrack->getNumKeyFrames()) - 1; i >= 0; --i) {

auto* kf = static_cast<Ogre::TransformKeyFrame*>(m_selectedTrack->getKeyFrame(i));

if (kf->getTime() < time - 0.001f) { target = kf; break; }

}

if (!target)

target = static_cast<Ogre::TransformKeyFrame*>(m_selectedTrack->getKeyFrame(0));

setSliderValue(static_cast<int>(target->getTime() * 1000));

{

if (!m_selectedTrack || m_selectedTrack->getNumKeyFrames() == 0) return;

float time = m_sliderValue / 1000.0f;

Ogre::TransformKeyFrame* target = nullptr;

for (unsigned short i = 0; i < m_selectedTrack->getNumKeyFrames(); ++i) {

auto* kf = static_cast<Ogre::TransformKeyFrame*>(m_selectedTrack->getKeyFrame(i));

if (kf->getTime() > time + 0.001f) { target = kf; break; }

}

if (!target)

target = static_cast<Ogre::TransformKeyFrame*>(

m_selectedTrack->getKeyFrame(m_selectedTrack->getNumKeyFrames() - 1));

setSliderValue(static_cast<int>(target->getTime() * 1000));

{

if (!m_selectedEntity || m_selectedAnimation.empty()) return;

if (!m_selectedSkeleton || m_selectedBone.empty()) return;

if (!m_selectedSkeleton->hasBone(m_selectedBone)) return;

if (!m_selectedSkeleton->hasAnimation(m_selectedAnimation)) return;

// Determine the operation mode for undo: track-create vs.

// keyframe-create vs. keyframe-update.

const bool trackExisted = (m_selectedTrack != nullptr);

AddKeyframeCommand::Mode mode = AddKeyframeCommand::Mode::TrackCreated;

// Lazily create an animation track for this bone if it doesn't have

// one yet (non-rigged bones, or bones the imported animation didn't

// touch). Without this, the user's edit would be a runtime-only

// pose that vanishes on export.

if (!m_selectedTrack) {

Ogre::Animation* anim = m_selectedSkeleton->getAnimation(m_selectedAnimation);

Ogre::Bone* bone = m_selectedSkeleton->getBone(m_selectedBone);

m_selectedTrack = anim->createNodeTrack(bone->getHandle(), bone);

// Re-include this bone in the bone-list and rebuild the panel

// so subsequent +KF / dope-sheet operations see the new track.

QString boneNameStr = QString::fromStdString(m_selectedBone);

if (!m_boneNames.contains(boneNameStr))

m_boneNames << boneNameStr;

emit boneListChanged();

}

if (!m_selectedTrack) return;

const float time = m_sliderValue / 1000.0f;

// Reuse a keyframe at the same time if one already exists — the rest of

// this controller treats same-time collisions as invalid, and auto-key

// would otherwise stack duplicates on every drag-end at the same scrub

// time. Match the same epsilon used by deleteKeyframe (1 ms).

Ogre::TransformKeyFrame* existingKf = nullptr;

constexpr float kKeyframeEpsilon = 0.001f;

for (unsigned short i = 0; i < m_selectedTrack->getNumKeyFrames(); ++i) {

auto* existing = static_cast<Ogre::TransformKeyFrame*>(m_selectedTrack->getKeyFrame(i));

if (std::fabs(existing->getTime() - time) <= kKeyframeEpsilon) {

existingKf = existing;

break;

}

}

// Capture before-TRS so undo restores the keyframe's pre-edit state.

// Defaults are identity for the create paths (the keyframe didn't

// exist; undo will remove it instead of restoring values).

Ogre::Vector3 beforeT = Ogre::Vector3::ZERO;

Ogre::Quaternion beforeR = Ogre::Quaternion::IDENTITY;

Ogre::Vector3 beforeS = Ogre::Vector3::UNIT_SCALE;

if (existingKf) {

beforeT = existingKf->getTranslate();

beforeR = existingKf->getRotation();

beforeS = existingKf->getScale();

mode = AddKeyframeCommand::Mode::KeyframeUpdated;

} else if (trackExisted) {

mode = AddKeyframeCommand::Mode::KeyframeCreated;

}

// else: trackExisted == false → Mode::TrackCreated (already set above).

// Compute the after-TRS from the bone's current local pose

// (relative to its initial bind pose, the format

// TransformKeyFrame stores). Previously this used

// getInterpolatedKeyFrame, which samples the existing animation

// curve at `time` and produces an identity-ish keyframe whenever

// the curve is flat there — the user-visible "blank registry"

// bug. With this change, hitting +KF after dragging the scene

// node (or, via the bone gizmo, the bone directly) captures the

// actual pose under the cursor at that scrub time.

const Ogre::Bone* bone = m_selectedSkeleton->getBone(m_selectedBone);

const Ogre::Vector3 afterT = bone->getPosition() - bone->getInitialPosition();

const Ogre::Quaternion afterR = bone->getInitialOrientation().Inverse() * bone->getOrientation();

const Ogre::Vector3 afterS = bone->getScale() / bone->getInitialScale();

// QUndoStack::push() executes redo() immediately, which performs the

// actual write. Pushing the command both creates the keyframe and

// makes it undoable.

auto* cmd = new AddKeyframeCommand( // NOSONAR — QUndoStack owns

m_selectedEntityName,

m_selectedAnimation,

m_selectedBone,

time,

mode,

beforeT, beforeR, beforeS,

afterT, afterR, afterS);

UndoManager::getSingleton()->push(cmd);

refreshSliderTicks();

setAnimationFrame(m_sliderValue);

{

if (!m_selectedTrack || !m_currentKeyframe) return;

// Capture the keyframe's TRS so the undo path can restore it.

const float t = m_currentKeyframe->getTime();

const Ogre::Vector3 keyT = m_currentKeyframe->getTranslate();

const Ogre::Quaternion keyR = m_currentKeyframe->getRotation();

const Ogre::Vector3 keyS = m_currentKeyframe->getScale();

// Push the command — its redo() removes the keyframe. Drop our

// cached pointer first since the command will invalidate it.

m_currentKeyframe = nullptr;

m_selectedTick = -1;

auto* cmd = new DeleteKeyframeCommand( // NOSONAR — QUndoStack owns

m_selectedEntityName,

m_selectedAnimation,

m_selectedBone,

t, keyT, keyR, keyS);

UndoManager::getSingleton()->push(cmd);

refreshSliderTicks();

setAnimationFrame(m_sliderValue);

{

if (!m_currentKeyframe) return;

m_updatingValues = true;

Ogre::Vector3 t = m_currentKeyframe->getTranslate();

Ogre::Vector3 s = m_currentKeyframe->getScale();

Ogre::Quaternion r = m_currentKeyframe->getRotation();

m_kfTransX = t.x; m_kfTransY = t.y; m_kfTransZ = t.z;

m_kfScaleX = s.x; m_kfScaleY = s.y; m_kfScaleZ = s.z;

m_kfRotW = r.w; m_kfRotX = r.x; m_kfRotY = r.y; m_kfRotZ = r.z;

m_updatingValues = false;

emit currentKeyframeChanged();

{

if (!m_selectedEntity || m_selectedAnimation.empty()) return;

m_selectedEntity->getAllAnimationStates()->_notifyDirty();

auto* state = m_selectedEntity->getAnimationState(m_selectedAnimation);

state->setTimePosition(state->getTimePosition());

{

bool tx = false, ty = false, tz = false;

bool rw = false, rx = false, ry = false, rz = false;

bool sx = false, sy = false, sz = false;

for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i) {

const auto* kf = static_cast<const Ogre::TransformKeyFrame*>(track->getKeyFrame(i));

const Ogre::Vector3 t = kf->getTranslate();

const Ogre::Quaternion r = kf->getRotation();

const Ogre::Vector3 s = kf->getScale();

if (std::fabs(t.x) > kChannelEpsilon) tx = true;

if (std::fabs(t.y) > kChannelEpsilon) ty = true;

if (std::fabs(t.z) > kChannelEpsilon) tz = true;

// Sign-agnostic rotation identity check — see header comment.

if (std::fabs(std::fabs(r.w) - 1.0f) > kChannelEpsilon) rw = true;

if (std::fabs(r.x) > kChannelEpsilon) rx = true;

if (std::fabs(r.y) > kChannelEpsilon) ry = true;

if (std::fabs(r.z) > kChannelEpsilon) rz = true;

// Scale identity = (1, 1, 1).

if (std::fabs(s.x - 1.0f) > kChannelEpsilon) sx = true;

if (std::fabs(s.y - 1.0f) > kChannelEpsilon) sy = true;

if (std::fabs(s.z - 1.0f) > kChannelEpsilon) sz = true;

}

QVariantMap m;

m[QStringLiteral("tx")] = tx; m[QStringLiteral("ty")] = ty; m[QStringLiteral("tz")] = tz;

m[QStringLiteral("rw")] = rw; m[QStringLiteral("rx")] = rx;

m[QStringLiteral("ry")] = ry; m[QStringLiteral("rz")] = rz;

m[QStringLiteral("sx")] = sx; m[QStringLiteral("sy")] = sy; m[QStringLiteral("sz")] = sz;

return m;

{

QVariantList rows;

if (!m_selectedSkeleton || m_selectedAnimation.empty()) return rows;

if (!m_selectedSkeleton->hasAnimation(m_selectedAnimation)) return rows;

Ogre::Animation* anim = m_selectedSkeleton->getAnimation(m_selectedAnimation);

for (const auto& [handle, track] : anim->_getNodeTrackList()) {

Ogre::Node* node = track->getAssociatedNode();

if (!node) continue;

QVariantList keyTimes;

keyTimes.reserve(static_cast<int>(track->getNumKeyFrames()));

for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i) {

keyTimes.append(static_cast<double>(track->getKeyFrame(i)->getTime()));

}

QVariantMap row;

row[QStringLiteral("bone")] = QString::fromStdString(node->getName());

row[QStringLiteral("keyTimes")] = keyTimes;

row[QStringLiteral("channels")] = collectActiveChannels(track);

rows.append(row);

}

return rows;

{

QVariantList rows;

auto* sel = SelectionSet::getSingleton();

if (!sel) return rows;

const auto entities = sel->getResolvedEntities();

if (entities.isEmpty() || !entities.first()) return rows;

Ogre::Entity* entity = entities.first();

if (!entity) return rows;

Ogre::MeshPtr mesh = entity->getMesh();

if (!mesh) return rows;

const Ogre::PoseList& poseList = mesh->getPoseList();

if (poseList.empty()) return rows;

// Each pose has a matching `Ogre::Animation` (see MeshProcessor:

// import-time one-animation-per-pose pattern). Read the keyframe

// times off the animation's VAT_POSE track; in A1 every animation

// carries a single t=0 keyframe, but future slices may add more.

for (const Ogre::Pose* pose : poseList) {

if (!pose) continue;

const Ogre::String poseName = pose->getName();

if (poseName.empty()) continue;

QVariantList keyTimes;

if (mesh->hasAnimation(poseName)) {

// The importer (MeshProcessor) groups same-named poses

// across submeshes into a single Animation with one

// VAT_POSE track per submesh. Pull only the track

// matching this pose's target handle — otherwise a

// shape that appears on body + head would show its

// diamonds twice in the dope sheet.

Ogre::Animation* anim = mesh->getAnimation(poseName);

const unsigned short handle = pose->getTarget();

if (anim->hasVertexTrack(handle)) {

Ogre::VertexAnimationTrack* track = anim->getVertexTrack(handle);

if (track && track->getAnimationType() == Ogre::VAT_POSE) {

for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i)

keyTimes.append(static_cast<double>(track->getKeyFrame(i)->getTime()));

}

}

}

QVariantMap row;

row[QStringLiteral("name")] = QString::fromStdString(poseName);

row[QStringLiteral("keyTimes")] = keyTimes;

rows.append(row);

}

return rows;

double oldTime, double newTime)

{

if (boneName.isEmpty()) return false;

if (!m_selectedSkeleton || m_selectedAnimation.empty()) return false;

if (!m_selectedSkeleton->hasAnimation(m_selectedAnimation)) return false;

if (qFuzzyCompare(oldTime + 1.0, newTime + 1.0)) return false;

// Validate up-front so we never push a no-op onto the undo stack.

// The command's internal validation is the source of truth, but

// duplicating the find-source-keyframe + collision-check here lets

// us return false without polluting the undo history.

Ogre::Animation* anim = m_selectedSkeleton->getAnimation(m_selectedAnimation);

const std::string boneStd = boneName.toStdString();

if (!m_selectedSkeleton->hasBone(boneStd)) return false;

Ogre::Bone* bone = m_selectedSkeleton->getBone(boneStd);

if (!bone || !anim->hasNodeTrack(bone->getHandle())) return false;

Ogre::NodeAnimationTrack* track = anim->getNodeTrack(bone->getHandle());

constexpr float kEpsilon = 0.001f;

int sourceIdx = -1;

for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i) {

if (std::fabs(track->getKeyFrame(i)->getTime() - static_cast<float>(oldTime)) <= kEpsilon) {

sourceIdx = static_cast<int>(i);

break;

}

}

if (sourceIdx < 0) return false; // no keyframe at oldTime

for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i) {

if (static_cast<int>(i) == sourceIdx) continue;

if (std::fabs(track->getKeyFrame(i)->getTime() - static_cast<float>(newTime)) <= kEpsilon) {

return false; // collision with another existing keyframe

}

}

// QUndoStack::push() takes ownership of the command — this raw new is

// the standard QUndoCommand idiom (mirrors TransformCommands callers).

auto* cmd = new MoveKeyframeCommand(m_selectedEntityName, // NOSONAR — QUndoStack owns

m_selectedAnimation,

boneStd,

static_cast<float>(oldTime),

static_cast<float>(newTime));

UndoManager::getSingleton()->push(cmd);

// The command's redo() ran inside push(); refresh the slider ticks for

// the currently-edited bone and signal QML views to re-read rows.

refreshSliderTicks();

emit boneRowsChanged();

return true;