source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SceneEntity.h @ 3262

#ifndef __SCENEENTITY_H
#define __SCENEENTITY_H

#include "common.h"
#include "AxisAlignedBox3.h"
#include "Triangle3.h"
#include "LODInfo.h"


namespace CHCDemoEngine 
{

class Material;
class Geometry;
class RenderState;
class Transform3;
class Camera;


/** Class representing a scene entity.
    A scene entity basically consists of one or more shapes and a transformation.
*/
class SceneEntity
{
        friend class RenderQueue;

public:
        
        /** Creates a scene entity.
        */
        SceneEntity(Transform3 *trafo);
        /** Destructor.
        */
        virtual ~SceneEntity();
        /** Renders this node.
        */
        virtual void Render(RenderState *state);        
        /** Set pointer to the shape
        */
        void AddShape(Shape *shape);
        /** See set
        */
        inline Shape *GetShape(int i) const;
        /** Returns number of shapes in vector.
        */
        inline int GetNumShapes() const;
        /** Set pointer to the geometry
        */
        void SetTransform(Transform3 *trafo);
        /** set frame where we last rendered this node
        */
        void SetLastRenderedFrame(int lastRendered);
        /** returns frame where we last visited this node
        */
        int GetLastRenderedFrame() const;
        /** Returns the trafo of this scene entity.
        */
        inline Transform3 *GetTransform() const;
        /** Counts number of triangles in this entity using the specified lod level
                with 0 being the highest or the current lod level (if the argument is -1).
        */
        int CountNumTriangles(int lodLevel = -1);
        /** Returns the local bounding box.
        */
        AxisAlignedBox3 GetBoundingBox() const;
        /** Returns the transformed bounding box.
        */
        AxisAlignedBox3 GetWorldBoundingBox() const;
        /** Only the scene entities are visible that match the global id.
        */
        void SetVisibleId(int id);
        /** See set
        */
        int GetVisibleId(int id) const;
        /** Returns true if this entity is visible.
        */
        bool IsVisible() const;


        ////////////////

        
        /** Returns shapes of specified lod level
        */
        void GetLODLevel(int level, ShapeContainer::iterator &start, ShapeContainer::iterator &end);
        /** Returns shapes of current lod level
        */
        void GetCurrentLODLevel(ShapeContainer::iterator &start, ShapeContainer::iterator &end);
        /** Adds a new lod level.
        */
        void AddLODLevel(const LODLevel &lod);
        /** Returns numbers of lod levels.
        */
        int GetNumLODLevels() const;
        /** Returns center point of this shape.
        */
        Vector3 GetCenter() const;
        /** Returns transformed center point of this shape.
        */
        Vector3 GetWorldCenter() const;
        /** Prepare this scene entity for rendering, i.e., sets the state and the transform. 
                This is used with the render queue. When a shape belonging to this scene entity
                is rendered, this function is called in beforehand.
        */
        void Prepare(RenderState *state);


        /////////////
        //-- static functions

        /** If false, the highest (=most detailed) LOD level is used for all entities.
        */
        static void SetUseLODs(bool useLODs);
        /** See set
        */
        static bool GetUseLODs();
        /** Sets the global visible id. Scene entities are visible only if
                this id is -1 or their id matches this id.
        */
        static void SetCurrentVisibleId(int id);
        /** Returns the id that indicates a visible object.
        */
        static int GetCurrentVisibleId();

        static AxisAlignedBox3 ComputeBoundingBox(SceneEntity **entities, int numEntities);
        static AxisAlignedBox3 ComputeBoundingBox(const SceneEntityContainer &entities);


protected:

        /** Internally updates current lod level.
        */
        void UpdateLODs(const Vector3 &viewPoint);
        /** Returns updated index of current lod level.
        */
        int GetCurrentLODLevel();


        /////////////////////

        /// the bounding box
        AxisAlignedBox3 mBox;
        /// describes a 3D transform
        Transform3 *mTransform;
        /// Stores information about the LOD levels
        LODLevelArray mLODLevels;
        /// the renderable shapes
        ShapeContainer mShapes;
        /// when this entity was last rendered
        int mLastRenderedFrame;
        /// the LOD level currently used for rendering
        int mCurrentLODLevel;
        /// frame number in which the LODs were last updated
        int mLODLastUpdated;
        /// the center of gravity of this entity
        Vector3 mCenter;
        /// generic id
        int mId;
        /// used to find out if this scene entity is in the current pvs
        int mVisibleId;
        static int sCurrentVisibleId;
        /// if LODs are used for rendering: otherwise we always take the highest lod
        static bool sUseLODs;
};


inline void SceneEntity::AddLODLevel(const LODLevel &lod)
{ 
        mLODLevels.push_back(lod); 
}


inline int SceneEntity::GetNumLODLevels() const 
{
        return (int)mLODLevels.size(); 
}


inline Vector3 SceneEntity::GetCenter() const 
{ 
        return mCenter; 
}


inline void SceneEntity::SetUseLODs(bool useLODs) 
{
        sUseLODs = useLODs; 
}


inline bool SceneEntity::GetUseLODs() 
{ 
        return sUseLODs; 
}


inline Shape *SceneEntity::GetShape(int i) const 
{ 
        return mShapes[i]; 
}


inline int SceneEntity::GetNumShapes() const
{
        return (int)mShapes.size(); 
}


inline Transform3 *SceneEntity::GetTransform() const  
{ 
        return mTransform; 
}


inline void SceneEntity::SetVisibleId(int id)
{
        mVisibleId = id;
}


inline void SceneEntity::SetCurrentVisibleId(int id)
{
        sCurrentVisibleId = id;
}


inline int SceneEntity::GetCurrentVisibleId()
{
        return sCurrentVisibleId;
}


inline int SceneEntity::GetVisibleId(int id) const
{
        return mVisibleId;
}


inline bool SceneEntity::IsVisible() const
{
        return (sCurrentVisibleId == -1) || (mVisibleId == sCurrentVisibleId);
}


}

#endif // __SCENEENTITY_H