source: GTP/trunk/Lib/Vis/OnlineCullingCHC/src/VisibilityManager.cpp @ 2280

#include "VisibilityManager.h"
#include "StopAndWaitCullingManager.h"
#include "CoherentHierarchicalCullingManager.h"
#include "FrustumCullingManager.h"
#include "DummyPreprocessingManager.h"
#include "RandomUpdateCullingManager.h"
#include "CullingLogManager.h"


namespace GtpVisibility {

//-----------------------------------------------------------------------
VisibilityManager::VisibilityManager(VisibilityEnvironment *visEnvironment):
mVisibilityThreshold(0), 
mCullingManager(NULL),
mQueryManager(NULL),
mPreprocessingManager(new DummyPreprocessingManager(NULL)),
mVisibilityEnvironment(visEnvironment),
mAssumedVisibilityForChc(0)
{
#if 1
        SetCullingManager(VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING);
#endif
#if 0   
        SetCullingManager(VisibilityEnvironment::STOP_AND_WAIT_CULLING);
#endif
#if 0
        SetCullingManager(VisibilityEnvironment::FRUSTUM_CULLING);
#endif
}
//-----------------------------------------------------------------------
VisibilityManager::~VisibilityManager()
{
        delete mCullingManager;
        delete mPreprocessingManager;
        CullingLogManager::DelSingleton();
}
//-----------------------------------------------------------------------
void VisibilityManager::SetCullingManager(VisibilityEnvironment::
                                                                                  CullingManagerType ocmType)
{
        // change only if necessary
        if (!mCullingManager || (mCullingManagerType != ocmType))
        {
                // delete old culling manager
                if (mCullingManager)
                {
                        delete mCullingManager;
                }

                mCullingManagerType = ocmType;
                
                switch (ocmType)
                {
                case VisibilityEnvironment::STOP_AND_WAIT_CULLING:
                        mCullingManager = new StopAndWaitCullingManager();
                        break;

                case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING:
                        mCullingManager = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc);
                        break;

                case VisibilityEnvironment::FRUSTUM_CULLING:
                        //mCullingManager = new FrustumCullingManager();
                        mCullingManager = new RandomUpdateCullingManager();
                        break;

                default:
                        mCullingManager = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc);
                        break;

                }

                /////////
                //-- set threshold
                mCullingManager->SetVisibilityThreshold(mVisibilityThreshold);  
        }
}
//-----------------------------------------------------------------------
void VisibilityManager::SetVisibilityCullingThreshold(unsigned int visibilityThreshold)
{
        mVisibilityThreshold = visibilityThreshold;
        mCullingManager->SetVisibilityThreshold(mVisibilityThreshold);
}
//-----------------------------------------------------------------------
CullingManager *VisibilityManager::GetCullingManager()
{
        return mCullingManager;
}
//-----------------------------------------------------------------------
void VisibilityManager::ApplyVisibilityCulling()
{
        mCullingManager->RenderScene();
}
//-----------------------------------------------------------------------
VisibilityEnvironment::CullingManagerType VisibilityManager::GetCullingManagerType()
{
        return mCullingManagerType;
}
//-----------------------------------------------------------------------
void VisibilityManager::SetQueryManager(QueryManager *queryManager)
{
        mQueryManager = queryManager;
}
//-----------------------------------------------------------------------
QueryManager *VisibilityManager::GetQueryManager()
{
        return mQueryManager;
}
//-----------------------------------------------------------------------
void VisibilityManager::SetAssumedVisibilityForChc(unsigned int assumedVisibility) 
                                                                         
{
        mAssumedVisibilityForChc = assumedVisibility;

        // in case we currently use chc
        if (VisibilityManager::GetCullingManagerType() == 
                VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING)
        {
                static_cast<CoherentHierarchicalCullingManager *>(mCullingManager)->
                                SetAssumedVisibility(assumedVisibility);
        }
}
//-----------------------------------------------------------------------
VisibilityEnvironment *VisibilityManager::GetVisibilityEnvironment()
{
        return mVisibilityEnvironment;
}

} // namespace GtpVisibility