OgreMovableObject.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 __MovableObject_H__
#define __MovableObject_H__

// Precompiler options
#include "OgrePrerequisites.h"
#include "OgreRenderQueue.h"
#include "OgreAxisAlignedBox.h"
#include "OgreSphere.h"
#include "OgreShadowCaster.h"
#include "OgreFactoryObj.h"
#include "OgreAnimable.h"
#include "OgreAny.h"
#include "OgreUserObjectBindings.h"

namespace Ogre {

    // Forward declaration
    class MovableObjectFactory;

    class _OgreExport MovableObject : public ShadowCaster, public AnimableObject, public MovableAlloc
    {
    public:
        class _OgreExport Listener
        {
        public:
            Listener(void) {}
            virtual ~Listener() {}
            virtual void objectDestroyed(MovableObject*) {}
            virtual void objectAttached(MovableObject*) {}
            virtual void objectDetached(MovableObject*) {}
            virtual void objectMoved(MovableObject*) {}
            virtual bool objectRendering(const MovableObject*, const Camera*) { return true; }
            virtual const LightList* objectQueryLights(const MovableObject*) { return 0; }
        };

    protected:
        String mName;
        MovableObjectFactory* mCreator;
        SceneManager* mManager;
        Node* mParentNode;
        bool mParentIsTagPoint;
        bool mVisible;
        bool mDebugDisplay;
        Real mUpperDistance;
        Real mSquaredUpperDistance;
        // Minimum pixel size to still render
        Real mMinPixelSize;
        bool mBeyondFarDistance;    
        UserObjectBindings mUserObjectBindings;
        uint8 mRenderQueueID;
        bool mRenderQueueIDSet;
        ushort mRenderQueuePriority;
        bool mRenderQueuePrioritySet;
        uint32 mQueryFlags;
        uint32 mVisibilityFlags;
        mutable AxisAlignedBox mWorldAABB;
        // Cached world bounding sphere
        mutable Sphere mWorldBoundingSphere;
        mutable AxisAlignedBox mWorldDarkCapBounds;
        bool mCastShadows;

        bool mRenderingDisabled;
        Listener* mListener;

        mutable LightList mLightList;
        mutable ulong mLightListUpdated;

        uint32 mLightMask;

        // Static members
        static uint32 msDefaultQueryFlags;
        static uint32 msDefaultVisibilityFlags;



    public:
        MovableObject();

        MovableObject(const String& name);
        virtual ~MovableObject();

        virtual void _notifyCreator(MovableObjectFactory* fact) { mCreator = fact; }
        virtual MovableObjectFactory*  _getCreator(void) const { return mCreator; }
        virtual void _notifyManager(SceneManager* man) { mManager = man; }
        virtual SceneManager* _getManager(void) const { return mManager; }

        virtual const String& getName(void) const { return mName; }

        virtual const String& getMovableType(void) const = 0;

        virtual Node* getParentNode(void) const;

        virtual SceneNode* getParentSceneNode(void) const;

        virtual bool isParentTagPoint() const { return mParentIsTagPoint; }

        virtual void _notifyAttached(Node* parent, bool isTagPoint = false);

        virtual bool isAttached(void) const;

        virtual void detachFromParent(void);

        virtual bool isInScene(void) const;

        virtual void _notifyMoved(void);

        virtual void _notifyCurrentCamera(Camera* cam);

        virtual const AxisAlignedBox& getBoundingBox(void) const = 0;

        virtual Real getBoundingRadius(void) const = 0;

        virtual const AxisAlignedBox& getWorldBoundingBox(bool derive = false) const;
        virtual const Sphere& getWorldBoundingSphere(bool derive = false) const;
        virtual void _updateRenderQueue(RenderQueue* queue) = 0;

        virtual void setVisible(bool visible);

        virtual bool getVisible(void) const;

        virtual bool isVisible(void) const;

        virtual void setRenderingDistance(Real dist) { 
            mUpperDistance = dist; 
            mSquaredUpperDistance = mUpperDistance * mUpperDistance;
        }

        virtual Real getRenderingDistance(void) const { return mUpperDistance; }        

        virtual void setRenderingMinPixelSize(Real pixelSize) { 
            mMinPixelSize = pixelSize; 
        }

        virtual Real getRenderingMinPixelSize() const { 
            return mMinPixelSize; 
        }

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

        virtual void setRenderQueueGroup(uint8 queueID);

        virtual void setRenderQueueGroupAndPriority(uint8 queueID, ushort priority);

        virtual uint8 getRenderQueueGroup(void) const;

        virtual const Matrix4& _getParentNodeFullTransform(void) const;

        virtual void setQueryFlags(uint32 flags) { mQueryFlags = flags; }

        virtual void addQueryFlags(uint32 flags) { mQueryFlags |= flags; }
            
        virtual void removeQueryFlags(uint32 flags) { mQueryFlags &= ~flags; }
        
        virtual uint32 getQueryFlags(void) const { return mQueryFlags; }

        static void setDefaultQueryFlags(uint32 flags) { msDefaultQueryFlags = flags; }

        static uint32 getDefaultQueryFlags() { return msDefaultQueryFlags; }

        
        virtual void setVisibilityFlags(uint32 flags) { mVisibilityFlags = flags; }

        virtual void addVisibilityFlags(uint32 flags) { mVisibilityFlags |= flags; }
            
        virtual void removeVisibilityFlags(uint32 flags) { mVisibilityFlags &= ~flags; }
        
        virtual uint32 getVisibilityFlags(void) const { return mVisibilityFlags; }

        static void setDefaultVisibilityFlags(uint32 flags) { msDefaultVisibilityFlags = flags; }
        
        static uint32 getDefaultVisibilityFlags() { return msDefaultVisibilityFlags; }

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

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

        virtual const LightList& queryLights(void) const;

        virtual uint32 getLightMask()const { return mLightMask; }
        virtual void setLightMask(uint32 lightMask);

        virtual LightList* _getLightList() { return &mLightList; }

        EdgeData* getEdgeList(void) { return NULL; }
        bool hasEdgeList(void) { return false; }
        ShadowRenderableListIterator getShadowVolumeRenderableIterator(
            ShadowTechnique shadowTechnique, const Light* light, 
            HardwareIndexBufferSharedPtr* indexBuffer, 
            bool extrudeVertices, Real extrusionDist, unsigned long flags = 0);
        
        const AxisAlignedBox& getLightCapBounds(void) const;
        const AxisAlignedBox& getDarkCapBounds(const Light& light, Real dirLightExtrusionDist) const;
        void setCastShadows(bool enabled) { mCastShadows = enabled; }
        bool getCastShadows(void) const { return mCastShadows; }
        bool getReceivesShadows();
            
        Real getPointExtrusionDistance(const Light* l) const;
        virtual uint32 getTypeFlags(void) const;

        virtual void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false) = 0;

        virtual void setDebugDisplayEnabled(bool enabled) { mDebugDisplay = enabled; }
        virtual bool isDebugDisplayEnabled(void) const { return mDebugDisplay; }





    };

    class _OgreExport MovableObjectFactory : public MovableAlloc
    {
    protected:
        unsigned long mTypeFlag;

        virtual MovableObject* createInstanceImpl(
            const String& name, const NameValuePairList* params = 0) = 0;
    public:
        MovableObjectFactory() : mTypeFlag(0xFFFFFFFF) {}
        virtual ~MovableObjectFactory() {}
        virtual const String& getType(void) const = 0;

        virtual MovableObject* createInstance(
            const String& name, SceneManager* manager, 
            const NameValuePairList* params = 0);
        virtual void destroyInstance(MovableObject* obj) = 0;

        virtual bool requestTypeFlags(void) const { return false; }
        void _notifyTypeFlags(unsigned long flag) { mTypeFlag = flag; }

        uint32 getTypeFlags(void) const { return mTypeFlag; }

    };
}
#endif