OgreSceneNode.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 _SceneNode_H__
#define _SceneNode_H__

#include "OgrePrerequisites.h"

#include "OgreNode.h"
#include "OgreIteratorWrappers.h"
#include "OgreAxisAlignedBox.h"

namespace Ogre {

    class _OgreExport SceneNode : public Node
    {
    public:
        typedef HashMap<String, MovableObject*> ObjectMap;
        typedef MapIterator<ObjectMap> ObjectIterator;
        typedef ConstMapIterator<ObjectMap> ConstObjectIterator;

    protected:
        ObjectMap mObjectsByName;
        mutable LightList mLightList;
        mutable bool mLightListDirty;

        WireBoundingBox *mWireBoundingBox;
        bool mShowBoundingBox;

        SceneManager* mCreator;

        AxisAlignedBox mWorldAABB;

        virtual void _updateBounds(void);

        Node* createChildImpl(void);

        Node* createChildImpl(const String& name);

        void setParent(Node* parent);

        void setInSceneGraph(bool inGraph);

        bool mYawFixed;
        Vector3 mYawFixedAxis;

        SceneNode* mAutoTrackTarget;
        Vector3 mAutoTrackOffset;
        Vector3 mAutoTrackLocalDirection;
        bool mIsInSceneGraph;
    public:
        SceneNode(SceneManager* creator);
        SceneNode(SceneManager* creator, const String& name);
        ~SceneNode();

        virtual void attachObject(MovableObject* obj);

        virtual unsigned short numAttachedObjects(void) const;

        virtual MovableObject* getAttachedObject(unsigned short index);

        virtual MovableObject* getAttachedObject(const String& name);

        virtual MovableObject* detachObject(unsigned short index);
        virtual void detachObject(MovableObject* obj);

        virtual MovableObject* detachObject(const String& name);

        virtual void detachAllObjects(void);

        virtual bool isInSceneGraph(void) const { return mIsInSceneGraph; }

        virtual void _notifyRootNode(void) { mIsInSceneGraph = true; }
            

        virtual void _update(bool updateChildren, bool parentHasChanged);

        virtual void _findVisibleObjects(Camera* cam, RenderQueue* queue, 
            bool includeChildren = true, bool displayNodes = false, bool onlyShadowCasters = false);

        virtual AxisAlignedBox _getWorldAABB(void) const;

        virtual ObjectIterator getAttachedObjectIterator(void);
        virtual ConstObjectIterator getAttachedObjectIterator(void) const;

        SceneManager* getCreator(void) const;

        virtual void removeAndDestroyChild(const String& name);

        virtual void removeAndDestroyChild(unsigned short index);

        virtual void removeAndDestroyAllChildren(void);

        virtual void showBoundingBox(bool bShow);

        virtual void _addBoundingBoxToQueue(RenderQueue* queue);

        virtual bool getShowBoundingBox() const;

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

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

        const LightList& findLights(Real radius) const;

        void setFixedYawAxis( bool useFixed, const Vector3& fixedAxis = Vector3::UNIT_Y );

        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

        void setDirection(Real x, Real y, Real z, 
            TransformSpace relativeTo = TS_LOCAL, 
            const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);

        void setDirection(const Vector3& vec, TransformSpace relativeTo = TS_LOCAL, 
            const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
        void lookAt( const Vector3& targetPoint, TransformSpace relativeTo,
            const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
        void setAutoTracking(bool enabled, SceneNode* target = 0, 
            const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z,
            const Vector3& offset = Vector3::ZERO);
        SceneNode* getAutoTrackTarget(void) { return mAutoTrackTarget; }
        const Vector3& getAutoTrackOffset(void) { return mAutoTrackOffset; }
        const Vector3& getAutoTrackLocalDirection(void) { return mAutoTrackLocalDirection; }
        void _autoTrack(void);
        SceneNode* getParentSceneNode(void) const;
        void setVisible(bool visible, bool cascade = true);
        void flipVisibility(bool cascade = true);





    };


}// 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 Feb 12 12:59:52 2006