source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgrePlatformHierarchyInterface.h @ 2558

#ifndef _PlatformHierarchyInterface_H__
#define _PlatformHierarchyInterface_H__

#include <OgreSceneManager.h>
#include <OgrePrerequisites.h>
#include <OgreCamera.h>
#include <OgreRenderSystem.h>
#include "OgreSolidBoundingBox.h"
#include "HierarchyInterface.h"
#include "VisibilityInfo.h"
#include "OgrePlatformOcclusionQuery.h"
#include "VisibilityMesh.h"



/** This namespace contains the Ogre dependent classes.
*/
namespace Ogre {

/**     Class which implements a hierarchy interface for a specific type of hierarchy.
        @remark also provides methods for using occlusion queries on the hierarchy nodes
*/
typedef std::vector<PlatformOcclusionQuery *> OcclusionQueryContainer;

class PlatformHierarchyInterface: public GtpVisibility::HierarchyInterface
{
public:

        /** Construction taking the current scene manager and the 
                current rendersystem as argument
                @param sm current scene manager
                @param rsys current render system 
        */
        PlatformHierarchyInterface(SceneManager *sm, RenderSystem *rsys);
        ~PlatformHierarchyInterface();
        /** Returns next available occlusion query or creates new one.
                @return the next occlusion query
        */
        virtual GtpVisibility::OcclusionQuery *GetNextOcclusionQuery();
                
        /** Sets the current camera used for the rendering.
                @param cam the current camera
        */
        void SetCamera(Camera *cam);
        /** Sets the current camera used for culling.
                @param cam the current camera
                @remark the default is the camera used for rendering
        */
        void SetCullCamera(Camera *cullCam);
        /** Initialises this scene traverser for the current frame.
                @remark This is a convenience method which resets the stats, 
                                sets the current camera, and initialises the distance queue.
                @param cam the actual camera definding the view frustum
                @param cullCam the camera used for culling. 
                @remark If cullCam is null, the actual camera is used for both viewing and culling              
        */
        void InitTraversal(Camera *cam, Camera *cullCam = NULL, int leavePassesInQueue = 0);
        /** Checks if the node is visible from the current view frustum.
                @param node the current node
                @param intersects returns true if the current node intersects the near plane
        */
        bool CheckFrustumVisible(GtpVisibility::HierarchyNode *node, bool &intersects);
        /** Sets pointer to the current scene manager.
                @param sm the scene manager 
        */
        void SetSceneManager(SceneManager *sm);
        /** Sets pointer to the current render system .
                @param rsys the rendersystem 
        */
        void SetRenderSystem(RenderSystem *rsys);
        /** Returns pointer to bounding box of node.
                @param node current hierarchy node
                @returns bounding box of current node
        */
        virtual AxisAlignedBox *GetBoundingBox(GtpVisibility::HierarchyNode *node) = 0;
        /** Issue a occlusion query for this node. 
                @param node the current hierarchy node
                @param gives a parameters that decideds on the type of occlusion query.
                
                @returns occlusion query for this node
        */
        GtpVisibility::OcclusionQuery *IssueNodeOcclusionQuery(
                GtpVisibility::HierarchyNode *node, const bool testGeometry = false);

        /** Issue a occlusion query for this mesh.
                @param mesh the mesh for which an occlusion query is issued.
                @returns occlusion query for this mesh.
        */
        GtpVisibility::OcclusionQuery *IssueMeshOcclusionQuery(GtpVisibility::Mesh *mesh);
        /** If true, the interface finds and renders only objects which are marked as shadow casters.
                @remark This is important for the shadow texture pass
        */
        void SetOnlyShadowCasters(bool onlyShadowCasters);
        /** see set 
        */
        bool GetOnlyShadowCasters();
        /** see set
        */
        SceneManager *GetSceneManager();
        /** see set 
        */
        RenderSystem *GetRenderSystem();
        /** true if bounding box query is currently active. 
        */
    bool IsBoundingBoxQuery();
        /** Issues occlusion queries for a patch.
        */
        GtpVisibility::OcclusionQuery *IssuePatchOcclusionQuery(GtpVisibility::Patch *patch);
        /** Deletes all occlusion queries.
        */
        void ResetQueries();

        /** Returns the geometry of a given hierarchy node. 
                @param node the hierarchy node containing the geometry
                @param geometryList geometry is returned in this list
                @param includeChildren if the geometry of the children should be taken into account
        */
        virtual void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,    
                                                                         GeometryVector *geometryList, 
                                                                         bool includeChildren) = 0;

        void PullUpLastVisited(GtpVisibility::HierarchyNode *node, const int frameId) const {}

        GtpVisibility::HierarchyNode *GetParent(GtpVisibility::HierarchyNode *node) { return NULL; }

        /** Returns #frames this node is assumed to be visible.
        */
        virtual int GetNodeAssumedVisible(GtpVisibility::HierarchyNode *node) { return 0; };
        /** Sets #frames this node is assumed to be visible.
        */
        virtual void SetNodeAssumedVisible(GtpVisibility::HierarchyNode *node, int assumedVisible) {};
        /** Decreases #frames this node is assumed to be visible.
        */
        virtual void DecNodeAssumedVisible(GtpVisibility::HierarchyNode *node) {};
        /** Test tigher geometry bounds instead of hierarchy node.
        */
        void SetTestGeometryBounds(bool testGeometryForLeaves);
        /** See get
        */
        int GetTestGeometryBounds();

        virtual void AddToQueue(GtpVisibility::HierarchyNode *node) {};

        virtual void RenderQueue() {};

        virtual void TraverseNode2(GtpVisibility::HierarchyNode *node) {};
        
        virtual GtpVisibility::OcclusionQuery *IssueMultiQuery(
                                                                                        const GtpVisibility::HierarchyNodeContainer &nodes);

protected:

        /** Renders the given geometry 
        */
        void RenderGeometry(GtpVisibility::Mesh *geom);
        /** Renders the given patch 
        */
        void RenderPatch(GtpVisibility::Patch *patch);
        /** Materials for visualizing frustum and query culled nodes.
        */
        void CreateNodeVizMaterials();
        /** Returns pointer to current renderable bounding box geometry.
        */
        SolidBoundingBox *GetSolidBoundingBox();
        /** Renders given bounding box.
                @param box the bounding box of the scene node to be rendered 
        */
        void RenderBoundingBox(AxisAlignedBox *box);
        /** Renders bounding boxes of the geometry.
                @param node the node to be rendered
        */
        virtual void RenderGeometryBounds(GtpVisibility::HierarchyNode *node) {};
        

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

        /** Renderable of an aabb.
        */
        SolidBoundingBox *mSolidBoundingBox;

        SceneManager *mSceneManager;
        RenderSystem *mRenderSystem;

        Camera *mCamera;
        Camera *mCullCamera;

        AxisAlignedBox mBox;
        
        OcclusionQueryContainer mOcclusionQueries;

        Vector3 mCameraPosition;
        bool mOnlyShadowCasters;
        int mLeavePassesInQueue;
        bool mIsBoundingBoxQuery;

        bool mTestGeometryBounds;

        bool mTestMode;
};

} // namespace Ogre

#endif // PlatformHierarchyInterface_H