OgreNode.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef _Node_H__
#define _Node_H__

#include "OgrePrerequisites.h"

#include "OgreCommon.h"
#include "OgreMatrix3.h"
#include "OgreMatrix4.h"
#include "OgreQuaternion.h"
#include "OgreString.h"
#include "OgreRenderable.h"
#include "OgreIteratorWrappers.h"
#include "OgreMesh.h"
#include "OgreUserObjectBindings.h"

namespace Ogre {


    class _OgreExport Node : public NodeAlloc
    {
    public:
        enum TransformSpace
        {
            TS_LOCAL,
            TS_PARENT,
            TS_WORLD
        };
        typedef HashMap<String, Node*> ChildNodeMap;
        typedef MapIterator<ChildNodeMap> ChildNodeIterator;
        typedef ConstMapIterator<ChildNodeMap> ConstChildNodeIterator;

        class _OgreExport Listener
        {
        public:
            Listener() {}
            virtual ~Listener() {}
            virtual void nodeUpdated(const Node*) {}
            virtual void nodeDestroyed(const Node*) {}
            virtual void nodeAttached(const Node*) {}
            virtual void nodeDetached(const Node*) {}
        };

        class DebugRenderable : public Renderable, public NodeAlloc
        {
        protected:
            Node* mParent;
            MeshPtr mMeshPtr;
            MaterialPtr mMat;
            Real mScaling;
        public:
            DebugRenderable(Node* parent);
            ~DebugRenderable();
            const MaterialPtr& getMaterial(void) const;
            void getRenderOperation(RenderOperation& op);
            void getWorldTransforms(Matrix4* xform) const;
            Real getSquaredViewDepth(const Camera* cam) const;
            const LightList& getLights(void) const;
            void setScaling(Real s) { mScaling = s; }

        };

    protected:
        Node* mParent;
        ChildNodeMap mChildren;

        typedef set<Node*>::type ChildUpdateSet;
        mutable ChildUpdateSet mChildrenToUpdate;
        mutable bool mNeedParentUpdate;
        mutable bool mNeedChildUpdate;
        mutable bool mParentNotified ;
        mutable bool mQueuedForUpdate;

        String mName;

        static NameGenerator msNameGenerator;

        Quaternion mOrientation;

        Vector3 mPosition;

        Vector3 mScale;

        bool mInheritOrientation;

        bool mInheritScale;

        virtual void setParent(Node* parent);

        mutable Quaternion mDerivedOrientation;

        mutable Vector3 mDerivedPosition;

        mutable Vector3 mDerivedScale;

        virtual void _updateFromParent(void) const;

        virtual void updateFromParentImpl(void) const;


        virtual Node* createChildImpl(void) = 0;

        virtual Node* createChildImpl(const String& name) = 0;

        Vector3 mInitialPosition;
        Quaternion mInitialOrientation;
        Vector3 mInitialScale;

        mutable Matrix4 mCachedTransform;
        mutable bool mCachedTransformOutOfDate;

        Listener* mListener;

        typedef vector<Node*>::type QueuedUpdates;
        static QueuedUpdates msQueuedUpdates;

        DebugRenderable* mDebug;

        UserObjectBindings mUserObjectBindings;

    public:
        Node();
        Node(const String& name);

        virtual ~Node();  

        const String& getName(void) const;

        virtual Node* getParent(void) const;

        virtual const Quaternion & getOrientation() const;

        virtual void setOrientation( const Quaternion& q );

        virtual void setOrientation( Real w, Real x, Real y, Real z);

        virtual void resetOrientation(void);

        virtual void setPosition(const Vector3& pos);

        virtual void setPosition(Real x, Real y, Real z);

        virtual const Vector3 & getPosition(void) const;

        virtual void setScale(const Vector3& scale);

        virtual void setScale(Real x, Real y, Real z);

        virtual const Vector3 & getScale(void) const;

        virtual void setInheritOrientation(bool inherit);

        virtual bool getInheritOrientation(void) const;

        virtual void setInheritScale(bool inherit);

        virtual bool getInheritScale(void) const;

        virtual void scale(const Vector3& scale);

        virtual void scale(Real x, Real y, Real z);

        virtual void translate(const Vector3& d, TransformSpace relativeTo = TS_PARENT);
        virtual void translate(Real x, Real y, Real z, TransformSpace relativeTo = TS_PARENT);
        virtual void translate(const Matrix3& axes, const Vector3& move, TransformSpace relativeTo = TS_PARENT);
        virtual void translate(const Matrix3& axes, Real x, Real y, Real z, TransformSpace relativeTo = TS_PARENT);

        virtual void roll(const Radian& angle, TransformSpace relativeTo = TS_LOCAL);

        virtual void pitch(const Radian& angle, TransformSpace relativeTo = TS_LOCAL);

        virtual void yaw(const Radian& angle, TransformSpace relativeTo = TS_LOCAL);

        virtual void rotate(const Vector3& axis, const Radian& angle, TransformSpace relativeTo = TS_LOCAL);

        virtual void rotate(const Quaternion& q, TransformSpace relativeTo = TS_LOCAL);

        virtual Matrix3 getLocalAxes(void) const;

        virtual Node* createChild(
            const Vector3& translate = Vector3::ZERO, 
            const Quaternion& rotate = Quaternion::IDENTITY );

        virtual Node* createChild(const String& name, const Vector3& translate = Vector3::ZERO, const Quaternion& rotate = Quaternion::IDENTITY);

        virtual void addChild(Node* child);

        virtual unsigned short numChildren(void) const;

        virtual Node* getChild(unsigned short index) const;    

        virtual Node* getChild(const String& name) const;

        virtual ChildNodeIterator getChildIterator(void);

        virtual ConstChildNodeIterator getChildIterator(void) const;

        virtual Node* removeChild(unsigned short index);
        virtual Node* removeChild(Node* child);

        virtual Node* removeChild(const String& name);
        virtual void removeAllChildren(void);
        
        virtual void _setDerivedPosition(const Vector3& pos);

        virtual void _setDerivedOrientation(const Quaternion& q);

        virtual const Quaternion & _getDerivedOrientation(void) const;

        virtual const Vector3 & _getDerivedPosition(void) const;

        virtual const Vector3 & _getDerivedScale(void) const;

        virtual const Matrix4& _getFullTransform(void) const;

        virtual void _update(bool updateChildren, bool parentHasChanged);

        virtual void setListener(Listener* listener) { mListener = listener; }
        
        virtual Listener* getListener(void) const { return mListener; }
        

        virtual void setInitialState(void);

        virtual void resetToInitialState(void);

        virtual const Vector3& getInitialPosition(void) const;
        
        virtual Vector3 convertWorldToLocalPosition( const Vector3 &worldPos );

        virtual Vector3 convertLocalToWorldPosition( const Vector3 &localPos );

        virtual Quaternion convertWorldToLocalOrientation( const Quaternion &worldOrientation );

        virtual Quaternion convertLocalToWorldOrientation( const Quaternion &localOrientation );

        virtual const Quaternion& getInitialOrientation(void) const;

        virtual const Vector3& getInitialScale(void) const;

        virtual Real getSquaredViewDepth(const Camera* cam) const;

        virtual void needUpdate(bool forceParentUpdate = false);
        virtual void requestUpdate(Node* child, bool forceParentUpdate = false);
        virtual void cancelUpdate(Node* child);

        virtual DebugRenderable* getDebugRenderable(Real scaling);

        static void queueNeedUpdate(Node* n);
        static void processQueuedUpdates(void);


        virtual void setUserAny(const Any& anything) { getUserObjectBindings().setUserAny(anything); }

        virtual const Any& getUserAny(void) const { return getUserObjectBindings().getUserAny(); }

        UserObjectBindings& getUserObjectBindings() { return mUserObjectBindings; }

        const UserObjectBindings& getUserObjectBindings() const { return mUserObjectBindings; }

    };
} //namespace

#endif