source: GTP/trunk/Lib/Vis/OnlineCullingCHC/include/CoherentHierarchicalCullingPlusPlusManager.h @ 2557

#ifndef _CoherentHierarchicalCullingPlusPlusManager_H__
#define _CoherentHierarchicalCullingPlusPlusManager_H__

#include "CullingManager.h"
#include "HierarchyInterface.h"


namespace GtpVisibility
{

/** Renders the scene with the coherent hierarchical culling algorithm. 
*/
class CoherentHierarchicalCullingPlusPlusManager: public CullingManager
{
public:
        CoherentHierarchicalCullingPlusPlusManager();
        /** Constructor taking the assumed visibility into account, i.e., the estimation
                for how many frames the current visibility is considered to be valid
        */
        CoherentHierarchicalCullingPlusPlusManager(const unsigned int assumedVisibility);

        void RenderScene();
        
        /** Sets assumed visibility (i.e., an estimation for 
                how many frames the visibility is considered to be valid).
                @param assumedVisibility indicates for how many frames the 
                same visibility is be assumed.
                if 0, the visibility is tested deterministically for each frame.
        */
        void SetAssumedVisibility(const unsigned int assumedVisibility);        
        /** This is an optimization when issuing the occlusion test. 
                The test is done with actual geometry rather than the bounding 
                box of leave nodes previously marked as visible.

                @param testGeometry if this optimization should be used
                @remark this option is only useful for the coherent hierarchical culling algorithm
        */
        void SetTestGeometryForVisibleLeaves(const bool testGeometry);
        /** See TestGeometryForVisibleLeaves
        */
        bool GetTestGeometryForVisibleLeaves();


protected:

        /** Decides if node is considered to be visible depeding on the 
                assumed visibility factor.
                @returns if node is considered to be visible
        */
        bool DecideVisible(HierarchyNode *node) const;

        /** Skip query for this node.
        */
        void SkipQuery(HierarchyNode *node) const;

        /** If this node is still valid for traversal in this frame.
                It is possible that the parent was tested invisible before
                so this node can be skipped.
        */
        bool NodeInvalid(HierarchyNode *node) const;

        void AssignAssumedVisibility(GtpVisibility::HierarchyNode *node);

        void IssueBatchedQuery(HierarchyNodeContainer &nodes);

        inline void IssueQuery(HierarchyNode *node, const bool testGeometry);

        //void IssueOptimalBatches(QueryHeap &nodes);


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

        /** number of steps the visibility is assumed to be valid.
        */
        unsigned int mAssumedVisibility;

        bool mTestGeometryForVisibleLeaves;

        QueryQueue mQueryQueue;

        std::queue<HierarchyNode *> mVisibleNodes;
        HierarchyNodeContainer mInvisibleNodes;

        int mMaxInvisibleNodesSize;
};

} // namespace GtpVisibility

#endif // CoherentHierarchicalCullingPlusPlusManager_H