Changeset 2171


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

implemented function for exact visibility queries

Location:
GTP/trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TerrainFrameListener.cpp

    r2168 r2171  
    570570                                                                                                bool relativeVisibility,  
    571571                                                                                                bool useItemBuffer) 
    572 {Ogre::LogManager::getSingleton().logMessage("here225"); 
     572{ 
    573573        int itemBufferMode = useItemBuffer ? mItemBufferMode : 0; 
    574574         
    … …  
    579579 
    580580        // no visibility manager available => no visibility scene manager, return 
    581         GtpVisibility::VisibilityManager *visManager = NULL; 
    582          
     581        GtpVisibility::VisibilityManager *visManager = NULL;     
    583582        if (!mSceneMgr->getOption("VisibilityManager", &visManager)) 
    584583        { 
    … …  
    586585                return; 
    587586        } 
     587 
    588588        GtpVisibility::HierarchyInterface *hierarchyInterface = NULL; 
    589589        if (!mSceneMgr->getOption("HierarchyInterface", &hierarchyInterface)) 
    … …  
    592592                return; 
    593593        } 
    594 Ogre::LogManager::getSingleton().logMessage("here663"); 
     594 
    595595        mQueryManager = new OcclusionQueriesQueryManager(hierarchyInterface, 
    596                         mWindow->getViewport(0), queryModes, itemBufferMode); 
    597 Ogre::LogManager::getSingleton().logMessage("here6699"); 
     596                                                                                                         mWindow->getViewport(0),  
     597                                                                                                         queryModes,  
     598                                                                                                         itemBufferMode); 
     599 
    598600        //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false); 
    599  
    600601 
    601602        visManager->SetQueryManager(mQueryManager); 
    … …  
    604605        GtpVisibility::MeshInfoContainer visibleGeometry; 
    605606        GtpVisibility::PatchInfoContainer visiblePatches; 
    606 Ogre::LogManager::getSingleton().logMessage("here999"); 
    607607 
    608608        if (fromPoint) 
    609         {Ogre::LogManager::getSingleton().logMessage("her11e5"); 
    610                 mQueryManager-> 
    611                         ComputeFromPointVisibility(mCamNode->getPosition(), &visibleNodes,  
    612                                                                            &visibleGeometry, &visiblePatches, relativeVisibility); 
     609        { 
     610                mQueryManager->ComputeFromPointVisibility(mCamNode->getPosition(),  
     611                                                                                                  &visibleNodes,  
     612                                                                                                  &visibleGeometry,  
     613                                                                                                  &visiblePatches,  
     614                                                                                                  relativeVisibility); 
    613615        } 
    614616        else 
    615617        { 
    616                 Ogre::LogManager::getSingleton().logMessage("here995"); 
    617618                mQueryManager->ComputeCameraVisibility(*mCamera, 
    618                             &visibleNodes, &visibleGeometry, &visiblePatches, relativeVisibility); 
     619                                                                                           &visibleNodes,  
     620                                                                                           &visibleGeometry,  
     621                                                                                           &visiblePatches,  
     622                                                                                           relativeVisibility); 
    619623        } 
    620624                 
    … …  
    630634        int geomSize = 0, nodesSize = 0, patchSize = 0; 
    631635 
    632         /////////////////////////////////////////////////////////////////////////// 
     636        ///////////////// 
    633637        //-- apply queries on geometry level 
    634638 
    … …  
    654658 
    655659 
    656  
    657         /////////////////////////////////////////////////////////////////////////// 
     660        //////////////// 
    658661        //-- apply queries on node level 
    659  
    660662 
    661663        GtpVisibility::NodeInfoContainer::iterator nodesIt, nodesIt_end = visibleNodes.end(); 
    … …  
    678680 
    679681 
    680         /////////////////////////////////////////////////////////////////////////// 
     682        //////////////// 
    681683        //-- apply queries on patch level 
    682684 
    … …  
    12491251void TerrainFrameListener::toggleShowViewCells() 
    12501252{ 
    1251         mShowViewCells = !mShowViewCells; 
    1252         mSceneMgr->setOption("ShowViewCells", &mShowViewCells); 
     1253        if (0) // tmp matt 
     1254        { 
     1255                mShowViewCells = !mShowViewCells; 
     1256                mSceneMgr->setOption("ShowViewCells", &mShowViewCells); 
     1257        } 
     1258        else  
     1259        { 
     1260                unsigned int numObjects; 
     1261                mSceneMgr->getOption("VisibleObjects", &numObjects); 
     1262        } 
    12531263} 
    12541264//----------------------------------------------------------------------- 

  • GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TestCullingTerrain.vcproj

    r2168 r2171  
    9898                                LinkIncremental="1" 
    9999                                AdditionalLibraryDirectories=""$(OGRE_PATH)\Dependencies\Lib\$(ConfigurationName)";"$(OGRE_PATH)\OgreMain\Lib\$(ConfigurationName)";"$(OGRE_PATH)\PlugIns\OctreeSceneManager\bin\$(ConfigurationName)";"$(OGRE_PATH)\Samples\Common\CEGUIRenderer\lib";"..\..\..\..\..\Lib\Vis\OnlineCullingCHC\lib\$(ConfigurationName)";"..\..\..\..\..\Lib\Vis\OnlineCullingCHC\OGRE\lib\$(ConfigurationName)";"..\..\..\..\..\Lib\Vis\OnlineCullingCHC\IVReader\lib\$(ConfigurationName)";..\..\..\..\..\..\..\NonGTP\Xerces\xercesc\lib;"..\..\..\..\..\Lib\Vis\Preprocessing\lib\$(ConfigurationName)"" 
    100                                 GenerateDebugInformation="TRUE" 
     100                                GenerateDebugInformation="FALSE" 
    101101                                SubSystem="2" 
    102102                                OptimizeReferences="2" 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOcclusionCullingSceneManager.h

    r2164 r2171  
    124124        bool LoadViewCells(const String &filename); 
    125125 
     126        void RenderDepthForQuery(Camera* camera, Viewport* vp); 
     127 
    126128protected: 
    127129         
    … …  
    130132        void SetObjectVisible(GtpVisibilityPreprocessor::Intersectable *entry,  
    131133                                                  const bool visible); 
     134 
    132135        void ShowViewCellsGeometry(); 
    133136 
    … …  
    180183        void loadConfig(DataStreamPtr& stream); 
    181184 
    182         void RenderDepthPass(); 
     185        void RenderDepthPass(const bool fillRenderQueue = true); 
    183186 
    184187        void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays); 
     188 
     189        int FindExactVisibleObjects(Camera *camera, 
     190                                                                Viewport* vp, 
     191                                                                const bool fromPoint, 
     192                                                                const bool nodeVisibility);      
    185193 
    186194        ////////////////////////////////////////// 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOcclusionQueriesQueryManager.h

    r925 r2171  
    1919     
    2020    void ComputeCameraVisibility(const Camera &camera, 
    21                             GtpVisibility::NodeInfoContainer *visibleNodes, 
    22                             GtpVisibility::MeshInfoContainer *visibleGeometry, 
    23                                 GtpVisibility::PatchInfoContainer *visiblePatches, 
    24                             bool relativeVisibility = false); 
     21                                                                GtpVisibility::NodeInfoContainer *visibleNodes, 
     22                                                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
     23                                                                 GtpVisibility::PatchInfoContainer *visiblePatches, 
     24                                                                bool relativeVisibility = false); 
    2525     
    2626    /**  
    … …  
    2929    */ 
    3030    void ComputeFromPointVisibility(const Vector3 &point, 
    31                                GtpVisibility::NodeInfoContainer *visibleNodes, 
    32                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
    33                                    GtpVisibility::PatchInfoContainer *visiblePatches, 
    34                                bool relativeVisibility = false); 
     31                                                                        GtpVisibility::NodeInfoContainer *visibleNodes, 
     32                                                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
     33                                                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
     34                                                                        bool relativeVisibility = false); 
    3535     
    3636 

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

    r2170 r2171  
    2424#include "IVReader.h" 
    2525#include "ObjReader.h" 
    26  
     26#include "OgreOcclusionQueriesQueryManager.h" 
    2727 
    2828 
    … …  
    194194        String val; 
    195195 
    196         LogManager::getSingleton().logMessage("****** OcclusionCullingSceneManager Options ********"); 
     196        LogManager::getSingleton(). 
     197                logMessage("****** OcclusionCullingSceneManager Options ********"); 
    197198        config.load(stream); 
    198199 
    … …  
    717718                // because shadows have low occlusion anyway 
    718719                if ((mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&  
    719                         mIlluminationStage == IRS_RENDER_TO_TEXTURE) || 
     720                         mIlluminationStage == IRS_RENDER_TO_TEXTURE) || 
    720721                        mNormalExecution) 
    721722                { 
    … …  
    772773        { 
    773774                // note matt: this is also called in TerrainSceneManager: really necessary? 
    774                 mDestRenderSystem -> setLightingEnabled(false); 
     775                mDestRenderSystem->setLightingEnabled(false); 
    775776 
    776777                if (mUseItemBuffer) 
    … …  
    10771078                * static_cast<unsigned int *>(val) = (unsigned int)algorithm; 
    10781079 
    1079                 getRenderQueue()->clear(true); 
    1080  
     1080                //getRenderQueue()->clear(); 
     1081 
     1082                return true; 
     1083        } 
     1084        if (key == "VisibleObjects") 
     1085        {  
     1086                if (mNormalExecution) 
     1087                        return false; 
     1088 
     1089                const bool fromPoint = true; 
     1090                const bool nodeVisibility = true; 
     1091                 
     1092                * static_cast<unsigned int *>(val) =  
     1093                        (unsigned int)FindExactVisibleObjects(mCameraInProgress,  
     1094                                                                                                  mCurrentViewport,  
     1095                                                                                                  fromPoint,  
     1096                                                                                                  nodeVisibility); 
    10811097                return true; 
    10821098        } 
    … …  
    18181834} 
    18191835//----------------------------------------------------------------------- 
    1820 void OcclusionCullingSceneManager::RenderDepthPass() 
    1821 { 
     1836void OcclusionCullingSceneManager::RenderDepthPass(const bool fillRenderQueue) 
     1837{ 
     1838        if (mNormalExecution) 
     1839        { 
     1840                // not in the normal workflow 
     1841                return; 
     1842        } 
     1843 
    18221844        // create material for depth pass 
    18231845        InitDepthPass(); 
    … …  
    18531875        mLeavePassesInQueue = 0; 
    18541876                 
    1855         // the shaded geometry is rendered in a second pass 
    1856         // add visible nodes found by the visibility culling algorithm 
    1857         NodeList::const_iterator it, it_end = mVisible.end(); 
    1858  
    1859         if(1)  
    1860         for (it = mVisible.begin(); it != it_end; ++ it) 
    1861         { 
    1862                 (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false); 
     1877        if (fillRenderQueue) 
     1878        { 
     1879                // the shaded geometry is rendered in a second pass 
     1880                // add visible nodes found by the visibility culling algorithm 
     1881                NodeList::const_iterator it, it_end = mVisible.end(); 
     1882        for (it = mVisible.begin(); it != it_end; ++ it) 
     1883                { 
     1884                        (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false); 
     1885                } 
    18631886        } 
    18641887} 
    … …  
    18871910 
    18881911//----------------------------------------------------------------------- 
    1889 void OcclusionCullingSceneManager::_renderScene(Camera* camera, Viewport* vp, bool includeOverlays) 
     1912void OcclusionCullingSceneManager::_renderScene(Camera* camera,  
     1913                                                                                                Viewport* vp,  
     1914                                                                                                bool includeOverlays) 
    18901915{ 
    18911916    Root::getSingleton()._setCurrentSceneManager(this); 
    … …  
    20572082    camera->_notifyRenderedFaces(mDestRenderSystem->_getFaceCount()); 
    20582083} 
    2059  
     2084//----------------------------------------------------------------------- 
     2085int OcclusionCullingSceneManager::FindExactVisibleObjects(Camera *camera, 
     2086                                                                                                                  Viewport* vp, 
     2087                                                                                                                  const bool fromPoint, 
     2088                                                                                                                  const bool nodeVisibility) 
     2089{ 
     2090        const int itemBufferMode = 0; 
     2091        const bool relativeVisibility = false; 
     2092 
     2093        int queryModes = 0; 
     2094 
     2095        if (nodeVisibility) 
     2096                queryModes |= GtpVisibility::QueryManager::NODE_VISIBILITY; 
     2097        else 
     2098                queryModes |= GtpVisibility::QueryManager::GEOMETRY_VISIBILITY; 
     2099 
     2100        OcclusionQueriesQueryManager *queryManager =  
     2101                new OcclusionQueriesQueryManager(mHierarchyInterface, 
     2102                                                                                 vp, 
     2103                                                                                 queryModes,  
     2104                                                                                 itemBufferMode); 
     2105 
     2106        mVisibilityManager->SetQueryManager(queryManager); 
     2107 
     2108        GtpVisibility::NodeInfoContainer visibleNodes; 
     2109        GtpVisibility::MeshInfoContainer visibleGeometry; 
     2110        GtpVisibility::PatchInfoContainer visiblePatches; 
     2111 
     2112        if (fromPoint) 
     2113        { 
     2114                queryManager->ComputeFromPointVisibility(camera->getDerivedPosition(),  
     2115                                                                                                 &visibleNodes,  
     2116                                                                                                 &visibleGeometry,  
     2117                                                                                                 &visiblePatches,  
     2118                                                                                                 relativeVisibility); 
     2119        } 
     2120        else 
     2121        { 
     2122                queryManager->ComputeCameraVisibility(*camera, 
     2123                                                                                          &visibleNodes,  
     2124                                                                                          &visibleGeometry,  
     2125                                                                                          &visiblePatches,  
     2126                                                                                          relativeVisibility); 
     2127        } 
     2128                 
     2129        if (0) 
     2130        { 
     2131                std::stringstream d;  
     2132                d << "Query mode: " << queryModes  
     2133                  << " visible nodes: " << (int)visibleNodes.size()  
     2134                  << " visible geometry: " << (int)visibleGeometry.size(); 
     2135 
     2136                LogManager::getSingleton().logMessage(d.str()); 
     2137        } 
     2138 
     2139        /////////////////////// 
     2140        //-- put items in render queue 
     2141        ////////// 
     2142 
     2143        getRenderQueue()->clear(); 
     2144 
     2145        ////////////////////// 
     2146        //-- apply queries on geometry level 
     2147 
     2148        if (!nodeVisibility) 
     2149        { 
     2150                GtpVisibility::MeshInfoContainer::iterator geomIt, geomIt_end = visibleGeometry.end(); 
     2151 
     2152                for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt) 
     2153                { 
     2154                        MovableObject *mo = (*geomIt).GetSource(); 
     2155 
     2156                        // add if not 0 
     2157                        if (!(*geomIt).GetVisiblePixels()) 
     2158                                continue; 
     2159 
     2160                        mo->_notifyCurrentCamera(camera); 
     2161 
     2162                        if (mo->isVisible()) 
     2163                        { 
     2164                                mo->_updateRenderQueue(getRenderQueue()); 
     2165                        } 
     2166                } 
     2167        } 
     2168        else 
     2169        { 
     2170                //////////////// 
     2171                //-- apply queries on node level 
     2172 
     2173                GtpVisibility::NodeInfoContainer::iterator nodesIt, nodesIt_end = visibleNodes.end(); 
     2174 
     2175                for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++ nodesIt) 
     2176                { 
     2177                        if (!(*nodesIt).GetVisiblePixels()) 
     2178                                continue; 
     2179 
     2180                        Octree *octree = static_cast<Octree *>((*nodesIt).GetSource()); 
     2181 
     2182                        NodeList::iterator nIt, nIt_end = octree->mNodes.end(); 
     2183 
     2184                        for (nIt = octree->mNodes.begin(); nIt != nIt_end; ++ nIt) 
     2185                        { 
     2186                                (*nIt)->_addToRenderQueue(camera, getRenderQueue(), false); 
     2187                        } 
     2188                } 
     2189        } 
     2190 
     2191    delete queryManager; 
     2192 
     2193        if (nodeVisibility) 
     2194                return (int)visibleNodes.size(); 
     2195        else 
     2196                return (int)visibleGeometry.size(); 
     2197} 
     2198//----------------------------------------------------------------------- 
     2199void OcclusionCullingSceneManager::RenderDepthForQuery(Camera* camera,  
     2200                                                                                                           Viewport* vp) 
     2201{ 
     2202    Root::getSingleton()._setCurrentSceneManager(this); 
     2203        mActiveQueuedRenderableVisitor->targetSceneMgr = this; 
     2204 
     2205    mCameraInProgress = camera; 
     2206 
     2207    // Update scene graph for this camera (can happen multiple times per frame) 
     2208    _updateSceneGraph(camera); 
     2209 
     2210    // Invert vertex winding? 
     2211    if (camera->isReflected()) 
     2212    { 
     2213        mDestRenderSystem->setInvertVertexWinding(true); 
     2214    } 
     2215    else 
     2216    { 
     2217        mDestRenderSystem->setInvertVertexWinding(false); 
     2218    } 
     2219 
     2220    // Tell params about viewport 
     2221    mAutoParamDataSource.setCurrentViewport(vp); 
     2222    // Set the viewport 
     2223    setViewport(vp); 
     2224 
     2225    // Tell params about camera 
     2226    mAutoParamDataSource.setCurrentCamera(camera); 
     2227    // Set autoparams for finite dir light extrusion 
     2228    mAutoParamDataSource.setShadowDirLightExtrusionDistance(mShadowDirLightExtrudeDist); 
     2229 
     2230    // Tell params about current ambient light 
     2231    mAutoParamDataSource.setAmbientLightColour(mAmbientLight); 
     2232        // Tell rendersystem 
     2233        mDestRenderSystem->setAmbientLight(mAmbientLight.r, mAmbientLight.g, mAmbientLight.b); 
     2234 
     2235    // Tell params about render target 
     2236    mAutoParamDataSource.setCurrentRenderTarget(vp->getTarget()); 
     2237 
     2238 
     2239    // Set camera window clipping planes (if any) 
     2240    if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_USER_CLIP_PLANES)) 
     2241    { 
     2242        if (camera->isWindowSet())   
     2243        { 
     2244            const std::vector<Plane>& planeList =  
     2245                camera->getWindowPlanes(); 
     2246            for (ushort i = 0; i < 4; ++i) 
     2247            { 
     2248                mDestRenderSystem->enableClipPlane(i, true); 
     2249                mDestRenderSystem->setClipPlane(i, planeList[i]); 
     2250            } 
     2251        } 
     2252        else 
     2253        { 
     2254            for (ushort i = 0; i < 4; ++i) 
     2255            { 
     2256                mDestRenderSystem->enableClipPlane(i, false); 
     2257            } 
     2258        } 
     2259    } 
     2260 
     2261        // Prepare render queue for receiving new objects 
     2262        prepareRenderQueue(); 
     2263 
     2264        // Begin the frame 
     2265    mDestRenderSystem->_beginFrame(); 
     2266 
     2267    // Set rasterisation mode 
     2268    mDestRenderSystem->_setPolygonMode(camera->getPolygonMode()); 
     2269 
     2270        // Set initial camera state 
     2271        mDestRenderSystem->_setProjectionMatrix(mCameraInProgress->getProjectionMatrixRS()); 
     2272        mDestRenderSystem->_setViewMatrix(mCameraInProgress->getViewMatrix(true)); 
     2273 
     2274        // // Render scene content in order fill depth buffer 
     2275        bool savedUseDepthPass = mUseDepthPass; 
     2276        mUseDepthPass = true; 
     2277 
     2278        // don't need shading, render only depth pass 
     2279        const bool fillQueue = false; 
     2280        RenderDepthPass(fillQueue); 
     2281        // _renderVisibleObjects(); 
     2282     
     2283        mUseDepthPass = savedUseDepthPass; 
     2284    
     2285    // End frame 
     2286    mDestRenderSystem->_endFrame(); 
     2287} 
    20602288//----------------------------------------------------------------------- 
    20612289const String OcclusionCullingSceneManagerFactory::FACTORY_TYPE_NAME = "OcclusionCullingSceneManager"; 

  • 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, 

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

    r2066 r2171  
    2727} 
    2828//----------------------------------------------------------------------- 
    29 void PlatformQueryManager::ComputeFromPointVisibility(const Vector3 &point, 
    30                                GtpVisibility::NodeInfoContainer *visibleNodes, 
    31                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
    32                                    GtpVisibility::PatchInfoContainer *visiblePatches, 
    33                                bool relativeVisibility) 
    34 { 
    35         SceneManager *sm = //static_cast<PlatformHierarchyInterface *> 
     29void PlatformQueryManager::ComputeFromPointVisibility( 
     30                                        const Vector3 &point, 
     31                                        GtpVisibility::NodeInfoContainer *visibleNodes, 
     32                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
     33                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
     34                                        bool relativeVisibility) 
     35{ 
     36        SceneManager *sm = 
    3637                static_cast<PlatformHierarchyInterface *> 
    37                 (mHierarchyInterface)->GetSceneManager(); 
     38                                                                (mHierarchyInterface)->GetSceneManager(); 
    3839 
    3940        // create a camera for the point query 
    … …  
    4344        Camera *savedCam = mViewport->getCamera(); 
    4445         
    45         // --- initialise new camera 
     46         
     47        ////////////// 
     48        //-- initialise new camera 
     49 
    4650        mViewport->setCamera(cam); 
    4751        cam->setPosition(point); 
    … …  
    5660        int sign = -1; 
    5761         
    58         // ---- capture visibility from all 6 directions 
     62        /////////////// 
     63        //-- capture visibility from all 6 directions 
     64 
    5965        for (int dir=0; dir < 6; dir++)  
    6066        { 
    … …  
    6268                 
    6369                // Print camera details 
    64         std::stringstream d; 
    65                 d << "Point query camera: " + StringConverter::toString(cam->getDerivedPosition()) +  
    66                         " " + "O: " + StringConverter::toString(cam->getDerivedOrientation()); 
    67                 LogManager::getSingleton().logMessage(d.str()); 
     70        if (0) 
     71                { 
     72                        std::stringstream d; 
     73                        d << "Point query camera: " + StringConverter::toString(cam->getDerivedPosition()) +  
     74                                " " + "O: " + StringConverter::toString(cam->getDerivedOrientation()); 
     75                        LogManager::getSingleton().logMessage(d.str()); 
     76                } 
    6877 
    6978                // prevent from initialising geometry / node array again 
    … …  
    7382                } 
    7483 
    75                 ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, visiblePatches,  
     84                ComputeCameraVisibility(*cam,  
     85                                                                visibleNodes,  
     86                                                                visibleGeometry,  
     87                                                                visiblePatches,  
    7688                                            relativeVisibility); 
    7789                //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait"); 
    … …  
    7991                // permute directions 
    8092                Vector3 direction(0,0,0); 
    81                 direction[dir/2] = sign; 
     93                direction[dir / 2] = sign; 
    8294 
    8395                cam->setDirection(direction); 
    … …  
    88100} 
    89101//----------------------------------------------------------------------- 
    90 void PlatformQueryManager::ComputeCameraVisibility(const Camera &camera, 
    91                             GtpVisibility::NodeInfoContainer *visibleNodes, 
    92                             GtpVisibility::MeshInfoContainer *visibleGeometry, 
    93                                 GtpVisibility::PatchInfoContainer *visiblePatches, 
    94                             bool relativeVisibility) 
     102void PlatformQueryManager::ComputeCameraVisibility( 
     103                                                                const Camera &camera, 
     104                                                                GtpVisibility::NodeInfoContainer *visibleNodes, 
     105                                                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
     106                                                                GtpVisibility::PatchInfoContainer *visiblePatches, 
     107                                                                bool relativeVisibility) 
    95108{ 
    96109        // we need access to the scene manager and the rendersystem 
    97110        PlatformHierarchyInterface *pfHierarchyInterface =  
    98                 //static_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    99111                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    100112 
    … …  
    113125        mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0)); 
    114126        //pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH); 
     127 
    115128#ifdef ITEM_BUFFER 
    116129        // initialise item buffer (if not already initialised) 
    117130        InitItemBuffer(visibleGeometry, visiblePatches); 
    118131 
     132        ////////// 
    119133        //-- render scene with item buffer (i.e., objects with their id as color codes) 
    120134 
    … …  
    127141    
    128142#ifdef ITEM_BUFFER 
     143        ///////// 
    129144        //-- collect results 
    130145        CollectItemBufferResults(visibleGeometry, visiblePatches); 
    131146 
    132         //-- reset options 
    133  
     147        ///////// 
     148        //-- reset state 
    134149        useItemBuffer = false; // don't need item buffer anymore 
    135150        sm->setOption("UseItemBuffer", &useItemBuffer); 

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

    r1486 r2171  
    1616        { 
    1717                // delete old queries (not needed for e.g., view frustum culling) 
    18                 // note cannot be deleted because of new ogre occlusion query implementation 
    19                 // there we cannot just delete the queries, so they would stay! 
    20                 //mHierarchyInterface->ResetQueries(); 
     18                // note cannot be deleted because of new ogre occlusion query  
     19                // implementation there we cannot just delete the queries, so  
     20                // they would stay! 
     21                // mHierarchyInterface->ResetQueries(); 
    2122                mVisibilityManager->SetCullingManager(*static_cast<const  
    2223                        GtpVisibility::VisibilityEnvironment::CullingManagerType *>(val)); 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/Plugin_VisibilitySceneManager.vcproj

    r2168 r2171  
    112112                                AdditionalLibraryDirectories="&quot;$(OGRE_PATH)\PlugIns\OctreeSceneManager\bin\$(ConfigurationName)&quot;;&quot;$(OGRE_PATH)\OgreMain\lib\$(ConfigurationName)&quot;;&quot;$(OGRE_PATH)\Samples\Common\CEGUIRenderer\lib&quot;;&quot;$(OGRE_PATH)\Dependencies\lib\$(ConfigurationName)&quot;;&quot;..\..\..\Preprocessing\lib\$(ConfigurationName)&quot;;..\..\..\..\..\..\..\NonGTP\Xerces\xercesc\lib;..\..\..\Preprocessing\src\GL;..\..\..\..\..\..\..\NonGTP\Zlib\lib;&quot;..\..\lib\$(ConfigurationName)&quot;;&quot;..\..\..\..\..\Lib\Vis\OnlineCullingCHC\IVReader\lib\$(ConfigurationName)&quot;;&quot;..\..\..\..\..\Lib\Vis\OnlineCullingCHC\ObjReader\lib\$(ConfigurationName)&quot;" 
    113113                                ModuleDefinitionFile="..\misc\OgreVisibilitySceneManager.def" 
    114                                 GenerateDebugInformation="TRUE" 
     114                                GenerateDebugInformation="FALSE" 
    115115                                SubSystem="2" 
    116116                                OptimizeReferences="2" 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/DummyQueryManager.h

    r316 r2171  
    66 
    77namespace GtpVisibility { 
     8     
    89/** This implements dummy visibility queries. The queries return only the root of the 
    9     hierarchy as visible node. 
     10        hierarchy as visible node. 
    1011*/ 
    11   class DummyQueryManager : public QueryManager 
    12   { 
    13   public: 
     12class DummyQueryManager : public QueryManager 
     13{ 
     14public: 
    1415    /** Constructor taking a scene traverser for a specific type of hierarchyInterface 
    1516        as argument.  
    … …  
    2122       @sa QueryManager::ComputeCameraVisibility() 
    2223     */ 
    23     virtual void 
    24     ComputeCameraVisibility(const Camera &camera, 
    25                             NodeInfoContainer *visibleNodes, 
    26                             MeshInfoContainer *visibleGeometry, 
    27                                 PatchInfoContainer *visiblePatches, 
    28                             bool relativeVisibility = false ); 
     24    virtual void  ComputeCameraVisibility(const Camera &camera, 
     25                                                                                  NodeInfoContainer *visibleNodes, 
     26                                                                                  MeshInfoContainer *visibleGeometry, 
     27                                                                                  PatchInfoContainer *visiblePatches, 
     28                                                                                  bool relativeVisibility = false); 
    2929     
    3030    /** 
    3131       @sa QueryManager::ComputeFromPointVisibility() 
    3232     */ 
    33     virtual void 
    34     ComputeFromPointVisibility(const Vector3 &point, 
    35                                NodeInfoContainer *visibleNodes, 
    36                                MeshInfoContainer *visibleGeometry, 
    37                                    PatchInfoContainer *visiblePatches, 
    38                                bool relativeVisibility = false 
    39                                ); 
    40      
    41   }; 
     33    virtual void ComputeFromPointVisibility(const Vector3 &point, 
     34                                                                                    NodeInfoContainer *visibleNodes, 
     35                                                                                        MeshInfoContainer *visibleGeometry, 
     36                                                                                        PatchInfoContainer *visiblePatches, 
     37                                                                                        bool relativeVisibility = false); 
     38}; 
    4239   
    43 }; 
     40} 
    4441#endif // VisibilitySummyQueryManager 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager.cpp

    r1816 r2171  
    2525        unsigned int visiblePixels = 0; 
    2626         
    27         //Ogre::LogManager::getSingleton().logMessage("chc"); 
     27        ///////////// 
    2828        //-- PART 1: process finished occlusion queries 
     29 
    2930        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty()) 
    3031        { 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/StopAndWaitCullingManager.cpp

    r925 r2171  
    1313                         
    1414                // interesting for visualization purpose 
    15                 mHierarchyInterface->SetNodeVisible(node, false); 
    16                 mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
     15                if (mVisualizeCulledNodes) 
     16                { 
     17                        mHierarchyInterface->SetNodeVisible(node, false); 
     18                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
     19                } 
    1720 
    1821                bool intersects = false; 
    … …  
    3033                else if (intersects) 
    3134                { 
    32                         mHierarchyInterface->SetNodeVisible(node, true); 
     35                        if (mVisualizeCulledNodes) 
     36                        { 
     37                                mHierarchyInterface->SetNodeVisible(node, true); 
     38                        } 
     39 
    3340                        mHierarchyInterface->TraverseNode(node); 
    3441                } 
    … …  
    4249                 
    4350                        // node visible 
    44                         if (0 || visiblePixels > mVisibilityThreshold) 
     51                        if (visiblePixels > mVisibilityThreshold) 
    4552                        { 
    4653                                mHierarchyInterface->TraverseNode(node); 
Note: See TracChangeset for help on using the changeset viewer.