To set the world position and rotation of bones manually in the Spine C++ runtime, especially when dealing with scenarios like flipping animations (X-scale of -1) and bones with Inherit_NoRotationOrReflection, you need to follow a structured approach. Here are the steps you can take:

1. Update Local Transforms: Modify the local transforms of the bones based on your ragdoll system. This includes setting the local position, rotation, and scale.

2. Update World Transforms: After modifying the local transforms, call Skeleton::updateWorldTransform() to recalculate the world transforms of all bones. This ensures that the changes in local transforms are propagated correctly through the bone hierarchy.

3. Handle Special Cases: For bones with Inherit_NoRotationOrReflection, you may need to manually adjust their world transforms after calling updateWorldTransform(). This can be done by calculating the correct world rotation and position based on the parent's world transform and the bone's local transform.

Here is a code snippet to illustrate the process:

// Assuming you have a pointer to the skeleton and the bone you want to modify
Skeleton* skeleton = ...;
Bone* bone = skeleton->findBone("mybone");

// Set local transforms based on your ragdoll system
bone->setX(localX);
bone->setY(localY);
bone->setRotation(localRotation);
bone->setScaleX(localScaleX);
bone->setScaleY(localScaleY);

// Update world transforms
skeleton->updateWorldTransform();

// Handle special cases for bones with Inherit_NoRotationOrReflection
if (bone->getInheritRotation() == Inherit_NoRotationOrReflection) {
    // Calculate the correct world rotation and position
    float parentWorldRotation = bone->getParent()->getWorldRotation();
    float correctedRotation = localRotation - parentWorldRotation;
    bone->setWorldRotation(correctedRotation);
    // Similarly, adjust world position if needed
}

// When turning off the ragdoll, let Spine take over the animation again
if (!ragdollActive) {
    // Apply animations and update world transforms
    state.apply(skeleton);
    skeleton->updateWorldTransform();
}

This approach ensures that the local transforms are correctly set, and the world transforms are recalculated properly, taking into account any special cases like Inherit_NoRotationOrReflection.

For more detailed information, you can refer to the spine-cpp Runtime Documentation and the Runtime Skeletons Guide.

Where are you setting scaleX? To flip the skeleton regardless of the inherit mode, set the skeleton scaleX (not a bone's scaleX).
http://esotericsoftware.com/spine-api-reference#Skeleton-scaleX

There is ambiguity in the rotation/scale components of a world transform. It can be a nightmare, and that's with normal transforms. It's worse with the inherit modes! Many times I have regretted they exist! Special cases like what you have are the way.

Is your issue with ambiguity when going world -> local? You can't know if a world transform was originally local scale -1,-1 or 180 rotation and scaleX -1.

daMuzza I had assumed that animState->apply() overwrote all bone local values and so any previous modifications I made would be undone?

Yes, but AnimationState apply only affects keyed properties. Properties not keyed in the animations being applied are not changed. You can use Skeleton setBonesToSetupPose (or setToSetupPose) to reset all bones to a known state (the setup pose).

daMuzza Previously I tried taking my two state copies of the bone positions/rotations in local space, and interpolating between them instead. This avoiding warping, but the legs that have Inherit_NoRotationOrReflection on them would always end up flipped in the wrong direction as soon as the interpolation began.

This sounds very close to what you want, just with a special case for the inherit mode(s) you use. Keeping everything in local space avoids some nasty behavior, like when interpolating world rotations.

daMuzza The side effect I'm seeing is that the top of the head on 'hero-pro' that I'm using for testing becomes slightly warped.

Hmm, hard to say why. Maybe more inherit mode pain, if the head (or neck/etc) bone doesn't inherit scale.

You might look at TransformConstraint. It has code to interpolate between local and world bone transform properties (the mix between the target bone and constrained bone(s)).

Note world rotations are by definition 0-360, because it is simply the direction the bone is pointing. When interpolating two world rotations, the challenge is there are 2 solutions: clockwise and counterclockwise. You can choose the shortest direction, but that may become the longest direction over time, as the rag doll and animation rotations change. When that happens your shortest direction interpolation flips to the other side -- a very noticeable, jarring jump. AnimationState solves this by remembering the shortest direction of the first interpolation and sticking with it. If you can stay in local space, it's much better because you won't have this problem at all.

I think you can do this in a solid way. I'm happy to add some utilities that would help, but I'm not sure what utilities would be useful in our generic runtimes, where there isn't a ragdoll physics system to integrate with. Maybe Harald has some input (on Monday) or can point to spine-unity code relevant to your use case.

daMuzza The side effect I'm seeing is that the top of the head on 'hero-pro' that I'm using for testing becomes slightly warped. I haven't dug down into exactly why this is, but I can understand how it might be happening when operating in world space.

To address such an issue, it might be the easier solution to set any bone transform values in local space. If I misunderstood what you're actually doing, please do let me know.

@daMuzza Very glad to hear you've made some good progress! Thanks for letting us know.