Ignore:
Timestamp:
02/27/07 10:25:01 (17 years ago)
Author:
mattausch
Message:

implemented function for exact visibility queries

File:
1 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionQueriesQueryManager.cpp

    r2168 r2171  
    55#include <OgreSubEntity.h> 
    66#include "OgrePlatformHierarchyInterface.h" 
     7#include "OgreOcclusionCullingSceneManager.h" 
     8#include "VisibilityEnvironment.h" 
     9 
     10 
    711 
    812namespace Ogre { 
    … …  
    1923} 
    2024//----------------------------------------------------------------------- 
    21 void OcclusionQueriesQueryManager::ComputeCameraVisibility(const Camera &camera, 
    22                                                                                                                    GtpVisibility::NodeInfoContainer *visibleNodes, 
    23                                                                                                                    GtpVisibility::MeshInfoContainer *visibleGeometry, 
    24                                                                                                                    GtpVisibility::PatchInfoContainer *visiblePatches, 
    25                                                                                                                    bool relativeVisibility) 
     25void OcclusionQueriesQueryManager::ComputeCameraVisibility( 
     26                                                                                        const Camera &camera, 
     27                                                                                        GtpVisibility::NodeInfoContainer *visibleNodes, 
     28                                                                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
     29                                                                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
     30                                                                                        bool relativeVisibility) 
    2631{ 
    2732        // we need access to the scene manager and the rendersystem 
    2833        PlatformHierarchyInterface *pfHierarchyInterface =  
    29                 //static_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    3034                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    3135 
    3236        // disable overlays, reset them later 
    3337        bool overlayEnabled = mViewport->getOverlaysEnabled(); 
    34 Ogre::LogManager::getSingleton().logMessage("here020202"); 
     38 
    3539        /////////// 
    3640        //-- render scene with item buffer (i.e., objects with their id as color codes) 
    37 //mItemBufferMode = 0; 
    38         if ((mItemBufferMode && mQueryModes) != 0) 
     41 
     42        //mItemBufferMode = 0; 
     43        if (0 &&  
     44                (mItemBufferMode && mQueryModes) != 0) 
    3945        { 
    4046                int savedQueryModes = mQueryModes; 
    4147                mQueryModes = mItemBufferMode; 
    4248                 
    43                 PlatformQueryManager::ComputeCameraVisibility(camera, visibleNodes, 
    44                             visibleGeometry, visiblePatches, relativeVisibility); 
     49                PlatformQueryManager::ComputeCameraVisibility(camera,  
     50                                                                                                          visibleNodes, 
     51                                                                                                          visibleGeometry,  
     52                                                                                                          visiblePatches,  
     53                                                                                                          relativeVisibility); 
    4554                 
    4655                // overlays cause false visibility 
    … …  
    5463                mViewport->setOverlaysEnabled(false); 
    5564 
     65                //////////////////////// 
    5666                //-- Render scene to get conservative visibility and fill depth buffer 
    57                 pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
    58         } 
    59  
    60          
    61         /*      Two query lists for projected pixels and for visibile pixels: 
     67 
     68                OcclusionCullingSceneManager *occlusionSceneMgr =  
     69                        static_cast<OcclusionCullingSceneManager *>(pfHierarchyInterface->GetSceneManager()); 
     70 
     71                // no visibility manager available => no visibility scene manager, return 
     72                GtpVisibility::VisibilityManager *visManager = NULL;     
     73                 
     74                if (!occlusionSceneMgr->getOption("VisibilityManager", &visManager)) 
     75                { 
     76                        Ogre::LogManager::getSingleton().logMessage("no vismanager found"); 
     77                        return; 
     78                } 
     79 
     80                // use stop and wait culling for from view point queries because probably 
     81                // no temporal coherence 
     82                GtpVisibility::VisibilityEnvironment::CullingManagerType occlusionType =  
     83                        visManager->GetCullingManagerType(); 
     84 
     85                visManager->SetCullingManager(GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING); 
     86 
     87                if (1) 
     88                        occlusionSceneMgr->RenderDepthForQuery(pCam, mViewport); 
     89                else 
     90                        pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
     91 
     92                visManager->SetCullingManager(occlusionType); 
     93        } 
     94 
     95         
     96        /*      Two query lists for projected pixels and for visibile pixels: 
    6297                We test queries after a rendering pass  
    6398                to get exact visibility with regard to the current camera. 
    … …  
    88123        if (mQueryModes & GEOMETRY_VISIBILITY) 
    89124        {        
    90                 for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt)         
     125                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++ visNodesIt)        
    91126                { 
    92127                        mHierarchyInterface->GetNodeGeometryList(*visNodesIt, &geometryList, false); 
    … …  
    128163        int n = relativeVisibility ? 2 : 1; 
    129164        if (mItemBufferMode > 0) 
    130                 LogManager::getSingleton().logMessage("item buffer"); 
    131  
    132         for (int i = 0; i < n; ++i) 
     165                LogManager::getSingleton().logMessage("using item buffer"); 
     166 
     167        for (int i = 0; i < n; ++ i) 
    133168        { 
    134169                //-- queries for hierarchy nodes 
    … …  
    139174                } 
    140175 
     176                //////////////////////////// 
    141177                //-- queries for geometry: if item buffer, capture only projected visibility 
     178 
    142179                if ((mItemBufferMode != GEOMETRY_VISIBILITY) || (i == 1)) 
    143180                {                        
    144                         for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
     181                        for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++ geometryIt) 
    145182                        { 
    146183                                queryList[i].push_back(pfHierarchyInterface->IssueMeshOcclusionQuery(*geometryIt)); 
    … …  
    148185                } 
    149186                 
     187                //////////////////////// 
    150188                //-- queries for patches: if item buffer, capture only projected visibility 
     189 
    151190                if ((mItemBufferMode != PATCH_VISIBILITY) || (i == 1)) 
    152191                { 
    … …  
    160199        } 
    161200 
    162          
     201        ///////////////  
    163202        //-- collect results 
     203 
    164204        GtpVisibility::QueryList::iterator visQueryIt = queryList[0].begin(); 
    165205        GtpVisibility::QueryList::iterator projQueryIt = queryList[1].begin(); 
    166206         
    167207        // collect occlusion queries for hierarchy nodes 
    168         CollectNodeVisibility(visQueryIt, projQueryIt, &nodeList, visibleNodes, relativeVisibility); 
     208        CollectNodeVisibility(visQueryIt,  
     209                                                  projQueryIt,  
     210                                                  &nodeList,  
     211                                                  visibleNodes,  
     212                                                  relativeVisibility); 
    169213 
    170214 
    … …  
    174218                // if visibility was established using the item buffer, 
    175219                // the array is organized different (e.g., ordered by id, all possible objects) 
    176                 CollectRelativeGeometryVisibilityForItemBuffer(projQueryIt, &geometryList, visibleGeometry); 
     220                CollectRelativeGeometryVisibilityForItemBuffer(projQueryIt,  
     221                                                                                                           &geometryList,  
     222                                                                                                           visibleGeometry); 
    177223        } 
    178224        else if (mItemBufferMode != GEOMETRY_VISIBILITY) 
    179225        { 
    180                 CollectGeometryVisibility(visQueryIt, projQueryIt, &geometryList, visibleGeometry,  
     226                CollectGeometryVisibility(visQueryIt,  
     227                                                                  projQueryIt,  
     228                                                                  &geometryList,  
     229                                                                  visibleGeometry,  
    181230                                                                  relativeVisibility); 
    182231        } 
    … …  
    186235        if ((mItemBufferMode == PATCH_VISIBILITY) && relativeVisibility) 
    187236        { 
    188                 CollectRelativePatchVisibilityForItemBuffer(projQueryIt, &patchList, visiblePatches); 
     237                CollectRelativePatchVisibilityForItemBuffer(projQueryIt,  
     238                                                                                                        &patchList,  
     239                                                                                                        visiblePatches); 
    189240        } 
    190241        else if (mItemBufferMode != PATCH_VISIBILITY) 
    191242        { 
    192                 CollectPatchVisibility(visQueryIt, projQueryIt, &patchList, visiblePatches, relativeVisibility); 
     243                CollectPatchVisibility(visQueryIt,  
     244                                                           projQueryIt,  
     245                                                           &patchList,  
     246                                                           visiblePatches,  
     247                                                           relativeVisibility); 
    193248        }        
    194249 
    195                  
    196         //-- reset options 
     250        //////////// 
     251        //-- reset state 
     252 
    197253        enableDepthWrite = true; 
    198254        // this option must be provided by the scene manager 
    … …  
    204260} 
    205261//----------------------------------------------------------------------- 
    206 void OcclusionQueriesQueryManager::ComputeFromPointVisibility(const Vector3 &point, 
    207                                GtpVisibility::NodeInfoContainer *visibleNodes, 
    208                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
    209                                    GtpVisibility::PatchInfoContainer *visiblePatches, 
    210                                bool relativeVisibility) 
    211 {Ogre::LogManager::getSingleton().logMessage("here5"); 
    212         PlatformQueryManager::ComputeFromPointVisibility(point, visibleNodes,  
    213                 visibleGeometry, visiblePatches, relativeVisibility); 
     262void OcclusionQueriesQueryManager::ComputeFromPointVisibility( 
     263                                                                const Vector3 &point, 
     264                                                                GtpVisibility::NodeInfoContainer *visibleNodes, 
     265                                                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
     266                                                                GtpVisibility::PatchInfoContainer *visiblePatches, 
     267                                                                bool relativeVisibility) 
     268{ 
     269        PlatformQueryManager::ComputeFromPointVisibility(point,  
     270                                                                                                         visibleNodes,  
     271                                                                                                         visibleGeometry,  
     272                                                                                                         visiblePatches,  
     273                                                                                                         relativeVisibility); 
    214274 
    215275        // adds up their visibility and removes duplicates  
    216276        // (duplicates occur if an object is on the edge of the viewport) 
    217277        RemoveDuplicateNodes(visibleNodes); 
    218         Ogre::LogManager::getSingleton().logMessage("here6"); 
     278 
    219279        if (mItemBufferMode != GEOMETRY_VISIBILITY) 
    220280        { 
    221281                RemoveDuplicateGeometry(visibleGeometry); 
    222282        } 
    223         Ogre::LogManager::getSingleton().logMessage("here7"); 
     283 
    224284        if (mItemBufferMode != PATCH_VISIBILITY) 
    225285        { 
    … …  
    228288} 
    229289//------------------------------------------------------------------------ 
    230 void  OcclusionQueriesQueryManager::CollectNodeVisibility( 
     290void OcclusionQueriesQueryManager::CollectNodeVisibility( 
    231291                                                GtpVisibility::QueryList::iterator &visQueryIt,  
    232292                                                GtpVisibility::QueryList::iterator &projQueryIt, 
    … …  
    238298 
    239299        //-- queries for nodes 
    240         for (nodeIt = nodeList->begin(); nodeIt != nodeList->end(); ++nodeIt) 
     300        for (nodeIt = nodeList->begin(); nodeIt != nodeList->end(); ++ nodeIt) 
    241301        { 
    242302                unsigned int visiblePixels = 0; 
    … …  
    248308                { 
    249309                        (*projQueryIt)->GetQueryResult(projectedPixels, true); 
    250                  
    251                         ++projQueryIt; 
    252                 } 
    253  
    254                 ++visQueryIt; 
     310                        ++ projQueryIt; 
     311                } 
     312 
     313                ++ visQueryIt; 
    255314                 
    256315                // node with visibilty 0 in queue (e.g., if node is intersected by near plane) 
    257316                if (visiblePixels > 0) 
    258317                { 
    259                         visibleNodes->push_back(GtpVisibility::NodeInfo(*nodeIt, visiblePixels,  
    260                                 projectedPixels)); 
     318                        visibleNodes->push_back( 
     319                                GtpVisibility::NodeInfo(*nodeIt, visiblePixels, projectedPixels)); 
    261320                } 
    262321        } 
    … …  
    384443                                        GtpVisibility::NodeInfoContainer *visibleNodes) 
    385444{ 
    386         stable_sort(visibleNodes->begin(), visibleNodes->end()/*, nodeinfo_lt*/); 
     445        sort(visibleNodes->begin(), visibleNodes->end()); 
    387446 
    388447        GtpVisibility::NodeInfoContainer::iterator visibleNodesIt, 
    … …  
    412471                                GtpVisibility::MeshInfoContainer *visibleGeometry) 
    413472{ 
    414         stable_sort(visibleGeometry->begin(), visibleGeometry->end()); 
     473        sort(visibleGeometry->begin(), visibleGeometry->end()); 
    415474         
    416475        GtpVisibility::MeshInfoContainer::iterator visibleGeomIt, 
    … …  
    440499                                GtpVisibility::PatchInfoContainer *visiblePatches) 
    441500{ 
    442         stable_sort(visiblePatches->begin(), visiblePatches->end()); 
     501        sort(visiblePatches->begin(), visiblePatches->end()); 
    443502         
    444503        GtpVisibility::PatchInfoContainer::iterator visiblePatchIt, 
Note: See TracChangeset for help on using the changeset viewer.