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-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef _Node_H__
#define _Node_H__

#include "OgrePrerequisites.h"

#include "OgreMatrix3.h"
#include "OgreMatrix4.h"
#include "OgreQuaternion.h"
#include "OgreString.h"
#include "OgreRenderable.h"
#include "OgreIteratorWrappers.h"

namespace Ogre {


    class _OgreExport Node : public Renderable
    {
    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* node) {}
            virtual void nodeDestroyed(const Node* node) {};
            virtual void nodeAttached(const Node* node) {};
            virtual void nodeDetached(const Node* node) {};
        };

    protected:
        Node* mParent;
        ChildNodeMap mChildren;

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

        String mName;

        static unsigned long msNextGeneratedNameExt;

        Quaternion mOrientation;

        Vector3 mPosition;

        Vector3 mScale;

        bool mInheritOrientation;

        bool mInheritScale;

        mutable MaterialPtr mpMaterial;

        virtual void setParent(Node* parent);

        mutable Quaternion mDerivedOrientation;

        mutable Vector3 mDerivedPosition;

        mutable Vector3 mDerivedScale;

        virtual void _updateFromParent(void) const;

        virtual Node* createChildImpl(void) = 0;

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

        Vector3 mInitialPosition;
        Quaternion mInitialOrientation;
        Vector3 mInitialScale;

        // Weight of applied animations so far, used for blending
        Real mAccumAnimWeight;
        // The total weighted translation from the initial state so far
        Vector3 mTransFromInitial;
        // The total weighted rotation from the initial state so far
        Quaternion mRotFromInitial;
        // The total weighted scale from the initial state so far
        Vector3 mScaleFromInitial;

        mutable Matrix4 mCachedTransform;
        mutable bool mCachedTransformOutOfDate;

        Listener* mListener;

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


    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);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void roll(Real degrees, TransformSpace relativeTo = TS_LOCAL) {
            roll ( Angle(degrees), relativeTo );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        virtual void pitch(const Radian& angle, TransformSpace relativeTo = TS_LOCAL);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void pitch(Real degrees, TransformSpace relativeTo = TS_LOCAL) {
            pitch ( Angle(degrees), relativeTo );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        virtual void yaw(const Radian& angle, TransformSpace relativeTo = TS_LOCAL);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void yaw(Real degrees, TransformSpace relativeTo = TS_LOCAL) {
            yaw ( Angle(degrees), relativeTo );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        virtual void rotate(const Vector3& axis, const Radian& angle, TransformSpace relativeTo = TS_LOCAL);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void rotate(const Vector3& axis, Real degrees, TransformSpace relativeTo = TS_LOCAL) {
            rotate ( axis, Angle(degrees), relativeTo );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        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 const Quaternion & _getDerivedOrientation(void) const;

        virtual const Vector3 & _getDerivedPosition(void) const;

        virtual const Vector3 & _getDerivedScale(void) const;

        virtual 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; }
        
        const MaterialPtr& getMaterial(void) const;
        void getRenderOperation(RenderOperation& op);
        void getWorldTransforms(Matrix4* xform) const;
        const Quaternion& getWorldOrientation(void) const;
        const Vector3& getWorldPosition(void) const;

        virtual void setInitialState(void);

        virtual void resetToInitialState(void);

        virtual const Vector3& getInitialPosition(void) const;

        virtual const Quaternion& getInitialOrientation(void) const;

        virtual const Vector3& getInitialScale(void) const;

        virtual void _weightedTransform(Real weight, const Vector3& translate, 
            const Quaternion& rotate, const Vector3& scale);

        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);

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

        const LightList& getLights(void) const;



    };

} //namespace

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:44 2006