source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionQueriesQueryManager.cpp @ 2532

#include <OgreLogManager.h>
#include <OgreStringConverter.h>
#include <vector>
#include <OgreSubEntity.h>

#include "OgreOcclusionQueriesQueryManager.h"
//#include "OgrePlatformHierarchyInterface.h"
#include "OgreOcclusionCullingSceneManager.h"
#include "VisibilityEnvironment.h"



namespace Ogre {

//----------------------------------------------------------------------- 
/*OcclusionQueriesQueryManager::OcclusionQueriesQueryManager(
                                                        PlatformHierarchyInterface *hierarchyInterface, 
                                                        Viewport *vp,
                                                        int queryModes,
                                                        int itemBufferMode)
:PlatformQueryManager(hierarchyInterface, vp, queryModes)
{
}*/
//-----------------------------------------------------------------------
void OcclusionQueriesQueryManager::ComputeCameraVisibility(
                                                                                        const Camera &camera,
                                                                                        NodeInfoContainer *visibleNodes,
                                                                                        MeshInfoContainer *visibleGeometry,
                                                                                        PatchInfoContainer *visiblePatches,
                                                                                        const bool relativeVisibility,
                                                                                        const bool approximateVisibility)
{
        // we need access to the scene manager and the rendersystem
        PlatformHierarchyInterface *pfHierarchyInterface = 
                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface);

        // disable overlays, reset them later
        bool overlayEnabled = mViewport->getOverlaysEnabled();

        // const_cast allowed because camera is not changed in renderScene
        Camera *pCam = const_cast<Camera *>(&camera); 
        mViewport->setOverlaysEnabled(false);


        ////////////////////////
        //-- Render scene to get conservative visibility and fill depth buffer

        OcclusionCullingSceneManager *occlusionSceneMgr = 
                static_cast<OcclusionCullingSceneManager *>(pfHierarchyInterface->GetSceneManager());

        // no visibility manager available => no visibility scene manager, return
        GtpVisibility::VisibilityManager *visManager = NULL;    

        if (!occlusionSceneMgr->getOption("VisibilityManager", &visManager))
        {
                Ogre::LogManager::getSingleton().logMessage("no vismanager found");
                return;
        }

        // use stop and wait culling for from view point queries because
        // of issues with temporal coherence
        GtpVisibility::VisibilityEnvironment::CullingManagerType occlusionType = 
                visManager->GetCullingManagerType();

        visManager->SetCullingManager(GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING);

        // rendert the scene once to fill depth buffer and to get a first approximation
        // of visible objects
        occlusionSceneMgr->RenderDepthForQuery(pCam, mViewport);

        // reset occlusion culling manager
        visManager->SetCullingManager(occlusionType);

        
        /**     Two query lists for projected pixels and for visibile pixels:
                We test queries after a rendering pass 
                to get exact visibility with regard to the current camera.
                We issue all queries at once to avoid starvation & stalls.
        */
        GtpVisibility::QueryList queryList[2];
        
        // rendered visibile hierarchy nodes from previous rendering
        GtpVisibility::NodeVector *visNodes = mHierarchyInterface->GetVisibleNodes();
        GtpVisibility::NodeVector::iterator visNodesIt, visNodesIt_end = visNodes->end();

    GtpVisibility::NodeVector nodeList;

        if (mQueryModes & NODE_VISIBILITY)
        {
                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt)
                {
                        nodeList.push_back((*visNodesIt));
                }
        }

        GtpVisibility::NodeVector::iterator nodeIt, nodeIt_end = nodeList.end();

        // vector for storing entities of meshes
        GeometryVector geometryList;
        
        // store geometry of the hierarchy nodes in a geometry list
        if (mQueryModes & GEOMETRY_VISIBILITY)
        {       
                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++ visNodesIt)       
                {
                        mHierarchyInterface->GetNodeGeometryList(*visNodesIt, &geometryList, false);
                }
        }
        
        // geometry list iterator
        GeometryVector::iterator geometryIt, geometryIt_end = geometryList.end();

        // vector for storing subentities of meshes
        PatchVector patchList;

        // store patchges of the geometries in a patch list
        if (mQueryModes & PATCH_VISIBILITY)
        {
                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt)        
                {
                        GetNodePatchList(*visNodesIt, &patchList);
                }
        }

        PatchVector::iterator patchIt, patchIt_end = patchList.end();

        // to obtain the correct number of projected pixels, depth write must be disabled
        bool enableDepthWrite = false;
        // this option must be provided by the scene manager
        pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite);


        /* relative visiblity:
           1) get visible pixels count of objects
           2) clear frame buffer
           3) get projected visible pixels count:
              test all objects again without depth write (set as option in scene manager)
           4) calculate ratio between visible vs. projected pixels
        */
                
        // for relative visibility we need 2 rendering passes
        int n = relativeVisibility ? 2 : 1;

        for (int i = 0; i < n; ++ i)
        {
                //-- query the hierarchy nodes
                for (nodeIt = nodeList.begin(); nodeIt != nodeIt_end; ++ nodeIt)                
                {
                        // TODO: DELETE QUERIES FROM PREVIOUS RENDER
                        bool intersects = false;
                        pfHierarchyInterface->CheckFrustumVisible(*nodeIt, intersects);

                        // always add node if only checking for approximate visibility or intersects
                        if (approximateVisibility || intersects)
                        {
                                // no more information available
                                const int visPixels = 1;
                                const int projPixels = 1;

                                visibleNodes->push_back(NodeInfo(*nodeIt, visPixels, projPixels));
                                queryList[i].push_back(NULL);
                        }
                        else // issue occlusion query
                        {
                                queryList[i].push_back(mHierarchyInterface->IssueNodeOcclusionQuery(*nodeIt, false));
                        }
                }

                ///////////////
                //-- queries for geometry

                for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++ geometryIt)
                {
                        if (approximateVisibility)
                        {
                                // no more information available
                                const int visPixels = 1;
                                const int projPixels = 1;

                                visibleGeometry->push_back(MeshInfo(*geometryIt, visPixels, projPixels));
                        }
                        else
                        {
                                queryList[i].push_back(pfHierarchyInterface->IssueMeshOcclusionQuery(*geometryIt));
                        }
                }

                ///////////////
                //-- queries for patches

                for (patchIt = patchList.begin(); patchIt != patchIt_end; ++patchIt)
                {
                        if (approximateVisibility)
                        {
                                // there is not more information available
                                const int visPixels = 1;
                                const int projPixels = 1;

                                visiblePatches->push_back(PatchInfo(*patchIt, visPixels, projPixels));
                        }
                        else
                        {
                                queryList[i].push_back(pfHierarchyInterface->IssuePatchOcclusionQuery(*patchIt));
                        }
                }

                // the second time we have to render against the cleared depth buffer to obtain
                // projected pixels
                pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_DEPTH);
        }


        /////////////// 
        //-- collect results

        GtpVisibility::QueryList::iterator visQueryIt = queryList[0].begin();
        GtpVisibility::QueryList::iterator projQueryIt = queryList[1].begin();
        
        // collect occlusion queries for hierarchy nodes
        CollectNodeVisibility(visQueryIt, 
                        projQueryIt, 
                        &nodeList, 
                        visibleNodes, 
                        relativeVisibility);
        
        CollectGeometryVisibility(visQueryIt, 
                        projQueryIt, 
                        &geometryList, 
                        visibleGeometry, 
                        relativeVisibility);

        // collect occlusion queries for patches
        CollectPatchVisibility(visQueryIt, 
                        projQueryIt, 
                        &patchList, 
                        visiblePatches, 
                        relativeVisibility);


        ////////////
        //-- reset state

        enableDepthWrite = true;
        // this option must be provided by the scene manager
        pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite);
        // reset old overlay status
        mViewport->setOverlaysEnabled(overlayEnabled);

        mWasInitialised = false;
}
//-----------------------------------------------------------------------
void OcclusionQueriesQueryManager::ComputeFromPointVisibility(
                                                                const Vector3 &point,
                                                                NodeInfoContainer *visibleNodes,
                                                                MeshInfoContainer *visibleGeometry,
                                                                PatchInfoContainer *visiblePatches,
                                                                const bool relativeVisibility,
                                                                const bool approximateVisibility)
{
        PlatformQueryManager::ComputeFromPointVisibility(point, 
                                                                                                         visibleNodes, 
                                                                                                         visibleGeometry, 
                                                                                                         visiblePatches, 
                                                                                                         relativeVisibility,
                                                                                                         approximateVisibility);

        // adds up their visibility and removes duplicates 
        // (duplicates occur if an object is on the edge of the viewport)
        RemoveDuplicateNodes(visibleNodes);
        RemoveDuplicateGeometry(visibleGeometry);
        RemoveDuplicatePatches(visiblePatches);
}
//------------------------------------------------------------------------
void OcclusionQueriesQueryManager::CollectNodeVisibility(
                                                GtpVisibility::QueryList::iterator &visQueryIt, 
                                                GtpVisibility::QueryList::iterator &projQueryIt,
                                                GtpVisibility::NodeVector *nodeList,  
                                                NodeInfoContainer *visibleNodes,
                                                bool relativeVisibility)
{
        GtpVisibility::NodeVector::iterator nodeIt;

        //-- queries for nodes
        for (nodeIt = nodeList->begin(); nodeIt != nodeList->end(); ++ nodeIt)
        {
                if (!(*visQueryIt))
                {
                        ++ visQueryIt;
                        if (relativeVisibility)
                                ++ projQueryIt;
                        continue;
                }

                unsigned int visiblePixels = 0;
                (*visQueryIt)->GetQueryResult(visiblePixels, true);
        
                unsigned int projectedPixels = 0;

                if (relativeVisibility)
                {
                        (*projQueryIt)->GetQueryResult(projectedPixels, true);
                        ++ projQueryIt;
                }

                ++ visQueryIt;
                
                // node with visibilty 0 in queue (e.g., if node is intersected by near plane)
                if (visiblePixels > 0)
                {
                        visibleNodes->push_back(NodeInfo(*nodeIt, visiblePixels, projectedPixels));
                }
        }
}
//-----------------------------------------------------------------------
void  OcclusionQueriesQueryManager::CollectGeometryVisibility(
                                                        GtpVisibility::QueryList::iterator &visQueryIt, 
                                                        GtpVisibility::QueryList::iterator &projQueryIt,
                                                        GeometryVector *geometryList, 
                                                        MeshInfoContainer *visibleGeometry,
                                                        bool relativeVisibility)
{
        GeometryVector::iterator geometryIt;

        //-- queries for geometry
        for (geometryIt = geometryList->begin(); geometryIt != geometryList->end(); ++ geometryIt)
        {
                unsigned int visiblePixels = 0;
                (*visQueryIt)->GetQueryResult(visiblePixels, true);
                
                unsigned int projectedPixels = 0;

                if (relativeVisibility)
                {
                        (*projQueryIt)->GetQueryResult(projectedPixels, true);
                        ++ projQueryIt;
                }

                ++ visQueryIt;

                // WARNING: approximate depth ordering during rendering => 
                // visibility approximate
                if (visiblePixels > 0)
                {                        
                        visibleGeometry->push_back(MeshInfo(*geometryIt, visiblePixels, projectedPixels));
                }
        }
}
//-----------------------------------------------------------------------
void  OcclusionQueriesQueryManager::CollectPatchVisibility(
                                                        GtpVisibility::QueryList::iterator &visQueryIt, 
                                                        GtpVisibility::QueryList::iterator &projQueryIt,
                                                        PatchVector *patchList, 
                                                        PatchInfoContainer *visiblePatches,
                                                        bool relativeVisibility)
{
        PatchVector::iterator patchIt;

        //-- queries for patch
        for (patchIt = patchList->begin(); patchIt != patchList->end(); ++ patchIt)
        {
                unsigned int visiblePixels = 0;
                (*visQueryIt)->GetQueryResult(visiblePixels, true);
                
                unsigned int projectedPixels = 0;

                if (relativeVisibility)
                {
                        (*projQueryIt)->GetQueryResult(projectedPixels, true);
                        ++ projQueryIt;
                }

                ++ visQueryIt;

                // WARNING: approximate depth ordering during rendering => 
                // patch maybe occluded
                if (visiblePixels > 0)
                {                        
                        visiblePatches->push_back(
                                PatchInfo(*patchIt, visiblePixels, projectedPixels));
                }
        }
}
//-----------------------------------------------------------------------
void  OcclusionQueriesQueryManager::RemoveDuplicateNodes(
                                        NodeInfoContainer *visibleNodes)
{
        sort(visibleNodes->begin(), visibleNodes->end());

        NodeInfoContainer::iterator visibleNodesIt,
                visibleNodesIt_end = visibleNodes->end();
        
        NodeInfo *nodeInfo = NULL;

        for (visibleNodesIt = visibleNodes->begin(); visibleNodesIt != visibleNodesIt_end; 
                ++visibleNodesIt)
        {
                if (!nodeInfo || (nodeInfo->GetSource() != (*visibleNodesIt).GetSource()))
                {
                        nodeInfo = &(*visibleNodesIt);
                }
                else // add visibility
                {                       
                        nodeInfo->AddVisibility(*visibleNodesIt);
                }
        }
        
        // physically delete duplicates
        visibleNodes->erase(std::unique(visibleNodes->begin(), visibleNodes->end()),
                                                visibleNodes->end());
}
//-----------------------------------------------------------------------
void  OcclusionQueriesQueryManager::RemoveDuplicateGeometry(
                                MeshInfoContainer *visibleGeometry)
{
        sort(visibleGeometry->begin(), visibleGeometry->end());
        
        MeshInfoContainer::iterator visibleGeomIt,
                        visibleGeomIt_end = visibleGeometry->end();

        MeshInfo *geomInfo = NULL;

        for (visibleGeomIt = visibleGeometry->begin(); visibleGeomIt != visibleGeomIt_end; 
                ++visibleGeomIt)
        {
                if (!geomInfo || (geomInfo->GetSource() != (*visibleGeomIt).GetSource()))
                {
                        geomInfo = &(*visibleGeomIt);
                }
                else // info points to same mesh, just add visibility
                {
                        geomInfo->AddVisibility(*visibleGeomIt);
                }
        }

        // physically delete duplicates
        visibleGeometry->erase(std::unique(visibleGeometry->begin(), visibleGeometry->end()), 
                                                   visibleGeometry->end());
}
//-----------------------------------------------------------------------
void  OcclusionQueriesQueryManager::RemoveDuplicatePatches(
                                PatchInfoContainer *visiblePatches)
{
        sort(visiblePatches->begin(), visiblePatches->end());
        
        PatchInfoContainer::iterator visiblePatchIt,
                        visiblePatchIt_end = visiblePatches->end();

        PatchInfo *patchInfo = NULL;

        for (visiblePatchIt = visiblePatches->begin(); visiblePatchIt != visiblePatchIt_end; 
                ++visiblePatchIt)
        {
                if (!patchInfo || (patchInfo->GetSource() != (*visiblePatchIt).GetSource()))
                {
                        patchInfo = &(*visiblePatchIt);
                }
                else // info points to same mesh, just add visibility
                {
                        patchInfo->AddVisibility(*visiblePatchIt);
                }
        }

        // physically delete duplicates
        visiblePatches->erase(std::unique(visiblePatches->begin(), visiblePatches->end()), 
                                                  visiblePatches->end());
}
//-----------------------------------------------------------------------
void OcclusionQueriesQueryManager::GetNodePatchList(GtpVisibility::HierarchyNode *node, 
                                                                                                        PatchVector *patchList)
{
        GeometryVector geomList;
        mHierarchyInterface->GetNodeGeometryList(node, &geomList, false);

        // geometry list iterator
        GeometryVector::iterator geomIt, geomIt_end = geomList.end();

        for (geomIt = geomList.begin(); geomIt != geomIt_end; ++geomIt)
        {
                for     (int i = 0; i < (int)(*geomIt)->getNumSubEntities(); ++i)
                {
                        patchList->push_back((*geomIt)->getSubEntity(i));
                }
        }
}

} // namespace Ogre