Main: Node - move intial state to Bone/ AnimationTrack

since most normal nodes are not animated

Author: paroj

OgreMain/include/OgreAnimationTrack.h

@@ -365,7 +365,18 @@ namespace Ogre
         NodeAnimationTrack* _clone(Animation* newParent) const;
 
         void _applyBaseKeyFrame(const KeyFrame* base) override;
-        
+
+        /** Sets the transform of the current node to be the 'initial state' ie that
+            position / orientation / scale to be used as a basis for delta values used
+            in keyframe animation.
+
+            If you never call this method, the initial state is the identity transform, ie do nothing.
+        */
+        void setInitialState(void);
+
+        /** Resets the position / orientation / scale of the node to it's initial state, see setInitialState for more info. */
+        void resetToInitialState(void) const;
+
     private:
         /// Specialised keyframe creation
         KeyFrame* createKeyFrameImpl(Real time) override;
@@ -386,6 +397,13 @@ namespace Ogre
         Node* mTargetNode;
         // Prebuilt splines, must be mutable since lazy-update in const method
         mutable Splines* mSplines;
+
+        /// The position to use as a base for keyframe animation
+        Vector3 mInitialPosition;
+        /// The orientation to use as a base for keyframe animation
+        Quaternion mInitialOrientation;
+        /// The scale to use as a base for keyframe animation
+        Vector3 mInitialScale;
     };
 
     /** Type of vertex animation.

OgreMain/include/OgreBone.h

@@ -92,6 +92,26 @@ namespace Ogre
         */
         void reset(void);
 
+        /** Sets the current transform of this Bone to be the 'initial state' ie that
+            position / orientation / scale to be used as a basis for delta values used
+            in keyframe animation.
+
+            If you never call this method, the initial state is the identity transform, ie do nothing.
+        */
+        void setInitialState(void);
+
+        /** Gets the initial position of this Bone, see setInitialState for more info. 
+
+            Also resets the cumulative animation weight used for blending.
+        */
+        const Vector3& getInitialPosition(void) const { return mInitialPosition; }
+
+        /** Gets the initial orientation of this Bone, see setInitialState for more info. */
+        const Quaternion& getInitialOrientation(void) const { return mInitialOrientation; }
+
+        /** Gets the initial position of this Bone, see setInitialState for more info. */
+        const Vector3& getInitialScale(void) const { return mInitialScale; }
+
         /** Sets whether or not this bone is manually controlled. 
 
             Manually controlled bones can be altered by the application at runtime, 
@@ -133,9 +153,18 @@ namespace Ogre
         /** See Node. */
         Node* createChildImpl(const String& name) override;
 
+        void resetToInitialState(void);
+
         /// Pointer back to creator, for child creation (not smart ptr so child does not preserve parent)
         Skeleton* mCreator;
 
+        /// The position to use as a base for keyframe animation
+        Vector3 mInitialPosition;
+        /// The orientation to use as a base for keyframe animation
+        Quaternion mInitialOrientation;
+        /// The scale to use as a base for keyframe animation
+        Vector3 mInitialScale;
+
         /// The inversed derived scale of the bone in the binding pose
         Vector3 mBindDerivedInverseScale;
         /// The inversed derived orientation of the bone in the binding pose

OgreMain/include/OgreNode.h

@@ -177,13 +177,6 @@ namespace Ogre {
         */
         virtual void updateFromParentImpl(void) const;
     private:
-        /// The position to use as a base for keyframe animation
-        Vector3 mInitialPosition;
-        /// The orientation to use as a base for keyframe animation
-        Quaternion mInitialOrientation;
-        /// The scale to use as a base for keyframe animation
-        Vector3 mInitialScale;
-
         /** Node listener - only one allowed (no list) for size & performance reasons. */
         Listener* mListener;
 
@@ -560,28 +553,6 @@ namespace Ogre {
         */
         Listener* getListener(void) const { return mListener; }
 
-
-        /** Sets the current transform of this node to be the 'initial state' ie that
-            position / orientation / scale to be used as a basis for delta values used
-            in keyframe animation.
-
-            You never need to call this method unless you plan to animate this node. If you do
-            plan to animate it, call this method once you've loaded the node with it's base state,
-            ie the state on which all keyframes are based.
-        @par
-            If you never call this method, the initial state is the identity transform, ie do nothing.
-        */
-        void setInitialState(void);
-
-        /** Resets the position / orientation / scale of this node to it's initial state, see setInitialState for more info. */
-        void resetToInitialState(void);
-
-        /** Gets the initial position of this node, see setInitialState for more info. 
-
-            Also resets the cumulative animation weight used for blending.
-        */
-        const Vector3& getInitialPosition(void) const { return mInitialPosition; }
-        
         /** Gets the local position, relative to this node, of the given world-space position */
         Vector3 convertWorldToLocalPosition( const Vector3 &worldPos );
 
@@ -603,12 +574,6 @@ namespace Ogre {
             useful for simple transforms that don't require a child node.*/
         Quaternion convertLocalToWorldOrientation( const Quaternion &localOrientation );
 
-        /** Gets the initial orientation of this node, see setInitialState for more info. */
-        const Quaternion& getInitialOrientation(void) const { return mInitialOrientation; }
-
-        /** Gets the initial position of this node, see setInitialState for more info. */
-        const Vector3& getInitialScale(void) const { return mInitialScale; }
-
         /** Helper function, get the squared view depth.  */
         Real getSquaredViewDepth(const Camera* cam) const;
 

OgreMain/src/OgreAnimationTrack.cpp

@@ -360,8 +360,8 @@ namespace Ogre {
     //---------------------------------------------------------------------
     NodeAnimationTrack::NodeAnimationTrack(Animation* parent, unsigned short handle, Node* targetNode)
         : AnimationTrack(parent, handle), mSplineBuildNeeded(false), mUseShortestRotationPath(true),
-          mTargetNode(targetNode), mSplines(0)
-
+          mTargetNode(targetNode), mSplines(0), mInitialPosition(Vector3::ZERO),
+          mInitialOrientation(Quaternion::IDENTITY), mInitialScale(Vector3::UNIT_SCALE)
     {
     }
     //---------------------------------------------------------------------
@@ -681,6 +681,23 @@ namespace Ogre {
         }
 
     }
+    void NodeAnimationTrack::setInitialState(void)
+    {
+        OgreAssert(mTargetNode, "Target node must be set before calling setInitialState");
+        mInitialPosition = mTargetNode->getPosition();
+        mInitialOrientation = mTargetNode->getOrientation();
+        mInitialScale = mTargetNode->getScale();
+    }
+    //-----------------------------------------------------------------------
+    void NodeAnimationTrack::resetToInitialState(void) const
+    {
+        if (!mTargetNode)
+            return;
+
+        mTargetNode->setPosition(mInitialPosition);
+        mTargetNode->setOrientation(mInitialOrientation);
+        mTargetNode->setScale(mInitialScale);
+    }
     //--------------------------------------------------------------------------
     VertexAnimationTrack::VertexAnimationTrack(Animation* parent,
         unsigned short handle, VertexAnimationType animType)

OgreMain/src/OgreBone.cpp

@@ -33,11 +33,13 @@ namespace Ogre {
     Bone::Bone(unsigned short handle, Skeleton* creator) 
         : Node(), mCreator(creator), mHandle(handle), mManuallyControlled(false)
     {
+        setInitialState();
     }
     //---------------------------------------------------------------------
     Bone::Bone(const String& name, unsigned short handle, Skeleton* creator) 
         : Node(name), mCreator(creator), mHandle(handle), mManuallyControlled(false)
     {
+        setInitialState();
     }
     //---------------------------------------------------------------------
     Bone::~Bone()
@@ -78,6 +80,22 @@ namespace Ogre {
     {
         resetToInitialState();
     }
+    //-----------------------------------------------------------------------
+    void Bone::setInitialState(void)
+    {
+        mInitialPosition = mPosition;
+        mInitialOrientation = mOrientation;
+        mInitialScale = mScale;
+    }
+    //-----------------------------------------------------------------------
+    void Bone::resetToInitialState(void)
+    {
+        mPosition = mInitialPosition;
+        mOrientation = mInitialOrientation;
+        mScale = mInitialScale;
+
+        needUpdate();
+    }
     //---------------------------------------------------------------------
     void Bone::setManuallyControlled(bool manuallyControlled) 
     {

OgreMain/src/OgreNode.cpp

@@ -47,9 +47,6 @@ namespace Ogre {
         mDerivedOrientation(Quaternion::IDENTITY),
         mDerivedPosition(Vector3::ZERO),
         mDerivedScale(Vector3::UNIT_SCALE),
-        mInitialPosition(Vector3::ZERO),
-        mInitialOrientation(Quaternion::IDENTITY),
-        mInitialScale(Vector3::UNIT_SCALE),
         mListener(0)
     {
         needUpdate();
@@ -591,22 +588,6 @@ namespace Ogre {
 
     }
     //-----------------------------------------------------------------------
-    void Node::setInitialState(void)
-    {
-        mInitialPosition = mPosition;
-        mInitialOrientation = mOrientation;
-        mInitialScale = mScale;
-    }
-    //-----------------------------------------------------------------------
-    void Node::resetToInitialState(void)
-    {
-        mPosition = mInitialPosition;
-        mOrientation = mInitialOrientation;
-        mScale = mInitialScale;
-
-        needUpdate();
-    }
-    //-----------------------------------------------------------------------
     struct NodeNameExists {
         const String& name;
         bool operator()(const Node* mo) {

OgreMain/src/OgreSceneManager.cpp

@@ -2198,8 +2198,7 @@ void SceneManager::_applySceneAnimations(void)
         // Reset any nodes involved
         for (const auto& it : anim->_getNodeTrackList())
         {
-            if (Node* nd = it.second->getAssociatedNode())
-                nd->resetToInitialState();
+            it.second->resetToInitialState();
         }
 
         for (const auto& it : anim->_getNumericTrackList())

PlugIns/DotScene/src/DotSceneLoader.cpp

@@ -928,7 +928,7 @@ void DotSceneLoader::processNodeAnimation(pugi::xml_node& XMLNode, SceneNode* pP
 
     // create a track to animate the camera's node
     NodeAnimationTrack* track = anim->createNodeTrack(0, pParent);
-    pParent->setInitialState();
+    track->setInitialState();
 
     // Process keyframes (*)
     for (auto pElement : XMLNode.children("keyframe"))