Ignore:
Timestamp:
03/16/07 17:20:26 (18 years ago)
Author:
mattausch
Message:

improved scenemanager config

Location:
GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    r2254 r2255  
    191191        void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays); 
    192192 
    193         int FindExactVisibleObjects(Camera *camera, 
    194                                                                 Viewport* vp, 
    195                                                                 const bool fromPoint, 
    196                                                                 const bool nodeVisibility);      
     193        int QueryVisibleObjectsExact(Camera *camera, 
     194                                                                 Viewport* vp, 
     195                                                                 const bool fromPoint, 
     196                                                                 const bool nodeVisibility);     
    197197 
    198198        void AddVisibleMeshGeometryToQueue(const GtpVisibility::MeshInfoContainer &visibleGeometry,  
    … …  
    299299        int mCurrentFrame; 
    300300 
     301        int mQueryMode; 
     302         
     303        enum {EXACT_QUERIES, NODE_QUERIES, APPROXIMATE_QUERIES}; 
     304 
    301305        ObjReader *mObjReader; 
    302306 
    … …  
    305309        bool mUseFromPointQueries; 
    306310 
    307         bool mUseExactQueries; 
    308          
    309         bool mUseDepthPassForQueries; 
     311        bool mResetMaterialForQueries; 
    310312}; 
    311313 

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

    r2171 r2255  
    1515                on different hierarchy types, while reusing the implementation of the query methods. 
    1616    */ 
    17         OcclusionQueriesQueryManager(GtpVisibility::HierarchyInterface *hierarchyInterface, Viewport *vp, 
    18                                                                  int queryModes, int itemBufferMode); 
     17        OcclusionQueriesQueryManager(GtpVisibility::HierarchyInterface *hierarchyInterface,  
     18                                                                 Viewport *vp, 
     19                                                                 int queryModes,  
     20                                                                 int itemBufferMode); 
    1921     
    2022    void ComputeCameraVisibility(const Camera &camera, 
    … …  
    2224                                                                 GtpVisibility::MeshInfoContainer *visibleGeometry, 
    2325                                                                 GtpVisibility::PatchInfoContainer *visiblePatches, 
    24                                                                  bool relativeVisibility = false); 
     26                                                                 const bool relativeVisibility, 
     27                                                                 const bool approximateVisibility); 
    2528     
    2629    /**  
    … …  
    3235                                                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
    3336                                                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
    34                                                                         bool relativeVisibility = false); 
     37                                                                        const bool relativeVisibility, 
     38                                                                        const bool approximateVisibility); 
    3539     
    3640 

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

    r925 r2255  
    1818    */ 
    1919        PlatformQueryManager(GtpVisibility::HierarchyInterface *hierarchyInterface,  
    20                                  Viewport *vp, int queryModes); 
     20                                 Viewport *vp,  
     21                                                 int queryModes); 
    2122     
    2223    /**  
    … …  
    2526    */ 
    2627    void ComputeFromPointVisibility(const Vector3 &point, 
    27                                GtpVisibility::NodeInfoContainer *visibleNodes, 
    28                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
    29                                    GtpVisibility::PatchInfoContainer *visiblePatches, 
    30                                bool relativeVisibility = false); 
     28                                                                        GtpVisibility::NodeInfoContainer *visibleNodes, 
     29                                                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
     30                                                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
     31                                                                        const bool relativeVisibility, 
     32                                                                        const bool approximateVisibility); 
    3133   
    3234        void ComputeCameraVisibility(const Camera &camera, 
    33                                GtpVisibility::NodeInfoContainer *visibleNodes, 
    34                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
    35                                    GtpVisibility::PatchInfoContainer *visiblePatches, 
    36                                bool relativeVisibility = false); 
     35                                                                 GtpVisibility::NodeInfoContainer *visibleNodes, 
     36                                                                 GtpVisibility::MeshInfoContainer *visibleGeometry, 
     37                                                                 GtpVisibility::PatchInfoContainer *visiblePatches, 
     38                                                                 const bool relativeVisibility, 
     39                                                                 const bool approximateVisibility); 
    3740   
    3841        bool ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine = false);   

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

    r2254 r2255  
    6767mFlushRate(10), 
    6868mCurrentFrame(0), 
    69 mUseVisibilityQueries(false), 
     69mUseVisibilityQueries(true), 
    7070mUseFromPointQueries(false), 
    71 mUseExactQueries(false), 
    72 mUseDepthPassForQueries(false) 
     71mQueryMode(NODE_QUERIES), 
     72mResetMaterialForQueries(false) 
    7373{ 
    7474        Ogre::LogManager::getSingleton(). 
    … …  
    245245        } 
    246246 
    247         val = config.getSetting("UseExactQueries"); 
     247        val = config.getSetting("QueryObjectsMode"); 
    248248 
    249249        if (!val.empty()) 
    250250        { 
     251                if (val == "EXACT") 
     252                        mQueryMode = EXACT_QUERIES; 
     253                else if (val == "NODE") 
     254                        mQueryMode = NODE_QUERIES; 
     255                else  
     256                        mQueryMode = APPROXIMATE_QUERIES; 
     257        } 
     258 
     259        val = config.getSetting("ResetMaterialForQueries"); 
     260 
     261        if (!val.empty()) 
     262        { 
    251263                if (val == "yes") 
    252                         mUseExactQueries = true; 
     264                        mResetMaterialForQueries = true; 
    253265                else 
    254                         mUseExactQueries = false; 
    255         } 
    256  
    257         val = config.getSetting("UseDepthPassForQueries"); 
    258  
    259         if (!val.empty()) 
    260         { 
    261                 if (val == "yes") 
    262                         mUseDepthPassForQueries = true; 
    263                 else 
    264                         mUseDepthPassForQueries = false; 
     266                        mResetMaterialForQueries = false; 
    265267        } 
    266268 
    … …  
    314316                        algorithm =  
    315317                                GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING; 
     318                        LogManager::getSingleton().logMessage("Using chc algorithm"); 
    316319                } 
    317320                else if (val == "SWC") 
    … …  
    319322                         algorithm =  
    320323                                 GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING; 
     324 
     325                         LogManager::getSingleton().logMessage("Using stop and wait algorithm"); 
    321326                 } 
    322327                 else if (val == "VFC") 
    … …  
    324329                         algorithm =  
    325330                                 GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING; 
     331 
     332                         LogManager::getSingleton().logMessage("Using frustum culling algorithm"); 
    326333                 } 
    327334                 else // default rendering 
    … …  
    331338 
    332339                         mNormalExecution = true; 
     340                         LogManager::getSingleton().logMessage("Using default octree scene manager rendering"); 
    333341                 } 
    334342 
    335343                 mVisibilityManager->SetCullingManager(algorithm); 
    336  
    337                  stringstream d; 
    338                  d << "setting algorithm to: " << algorithm; 
    339                  LogManager::getSingleton().logMessage(d.str()); 
    340344        } 
    341345 
    342346        ///////////// 
    343347        // terrain options 
     348 
     349        if (mUseDepthPass) 
     350                LogManager::getSingleton().logMessage("using depth pass"); 
     351        else 
     352                LogManager::getSingleton().logMessage("not using depth pass"); 
     353         
     354        if (mExecuteVertexProgramForAllPasses) 
     355                LogManager::getSingleton().logMessage("executing vertex program for passes"); 
     356        else 
     357                LogManager::getSingleton().logMessage("not executing vertex program for passes"); 
     358 
     359        if (mUseVisibilityQueries) 
     360                LogManager::getSingleton().logMessage("using visibility queries"); 
     361        else 
     362                LogManager::getSingleton().logMessage("not using visibility queries"); 
     363 
     364        if (mUseFromPointQueries) 
     365                LogManager::getSingleton().logMessage("using from point queries"); 
     366        else 
     367                LogManager::getSingleton().logMessage("not using from point queries"); 
     368 
     369        if (mQueryMode == EXACT_QUERIES) 
     370                LogManager::getSingleton().logMessage("using exact queries"); 
     371        else if (mQueryMode == NODE_QUERIES) 
     372                LogManager::getSingleton().logMessage("using node queries"); 
     373        else if (mQueryMode == APPROXIMATE_QUERIES) 
     374                LogManager::getSingleton().logMessage("using approximate queries"); 
     375 
     376        if (mResetMaterialForQueries) 
     377                LogManager::getSingleton().logMessage("resetting material for queries"); 
     378        else 
     379                LogManager::getSingleton().logMessage("resetting material for queries"); 
     380 
     381        if (mDeleteQueueAfterRendering) 
     382                LogManager::getSingleton().logMessage("flushing queue after some frames"); 
     383        else 
     384                LogManager::getSingleton().logMessage("not flushing queue after some frames"); 
    344385 
    345386        if (!mShowTerrain) 
    … …  
    449490        selectPageSource(pageSourceName, optlist); 
    450491 
    451         if (mUseDepthPass) 
    452                 LogManager::getSingleton().logMessage("using depth"); 
    453         else 
    454                 LogManager::getSingleton().logMessage("not using depth"); 
    455          
    456         if (mExecuteVertexProgramForAllPasses) 
    457                 LogManager::getSingleton().logMessage("executing vertex program for passes"); 
    458         else 
    459                 LogManager::getSingleton().logMessage("not executing vertex program for passes"); 
    460  
    461         if (mUseVisibilityQueries) 
    462                 LogManager::getSingleton().logMessage("using visibility queries"); 
    463         else 
    464                 LogManager::getSingleton().logMessage("not using visibility queries"); 
    465  
    466         if (mUseFromPointQueries) 
    467                 LogManager::getSingleton().logMessage("using from point queries"); 
    468         else 
    469                 LogManager::getSingleton().logMessage("not using from point queries"); 
    470  
    471         if (mUseExactQueries) 
    472                 LogManager::getSingleton().logMessage("using exact queries"); 
    473         else 
    474                 LogManager::getSingleton().logMessage("not using exact queries"); 
    475  
    476         if (mUseDepthPassForQueries) 
    477                 LogManager::getSingleton().logMessage("using depth pass for queries"); 
    478         else 
    479                 LogManager::getSingleton().logMessage("not using depth pass for queries"); 
    480  
    481         if (mDeleteQueueAfterRendering) 
    482                 LogManager::getSingleton().logMessage("flushing queue after rendering"); 
    483         else 
    484                 LogManager::getSingleton().logMessage("not flushing queue after rendering"); 
    485  
     492         
    486493        LogManager::getSingleton().logMessage("****** OcclusionCullingSceneManager Options Finished ********"); 
    487494} 
    … …  
    11261133                return true; 
    11271134        } 
    1128         if (key == "UseExactQueries") 
    1129         { 
    1130                 mUseExactQueries = *static_cast<const bool *>(val); 
    1131  
    1132                 return true; 
    1133         } 
    1134         if (key == "UseDepthPassForQueries") 
    1135         { 
    1136                 mUseDepthPassForQueries = *static_cast<const bool *>(val); 
     1135        if (key == "QueryMode") 
     1136        { 
     1137                mQueryMode = *static_cast<const int *>(val); 
     1138 
     1139                return true; 
     1140        } 
     1141        if (key == "ResetMaterialForQueries") 
     1142        { 
     1143                mResetMaterialForQueries = *static_cast<const bool *>(val); 
    11371144        } 
    11381145        if (key == "UseFromPointQueries") 
    … …  
    11921199                return true; 
    11931200        } 
     1201 
    11941202        if (key == "VisibleObjects") 
    11951203        {  
    … …  
    12011209                 
    12021210                * static_cast<unsigned int *>(val) =  
    1203                         (unsigned int)FindExactVisibleObjects(mCameraInProgress,  
    1204                                                                                                   mCurrentViewport,  
    1205                                                                                                   fromPoint,  
    1206                                                                                                   nodeVisibility); 
     1211                        (unsigned int)QueryVisibleObjectsExact(mCameraInProgress,  
     1212                                                                                                   mCurrentViewport,  
     1213                                                                                                   fromPoint,  
     1214                                                                                                   nodeVisibility); 
    12071215                return true; 
    12081216        } 
    … …  
    18651873        int i = 0; 
    18661874 
    1867         if (filename == "terrain") 
    1868         { 
    1869                 LogManager::getSingleton().logMessage("loading terrain"); 
     1875        if (filename == "terrain" || filename == "") 
     1876        { 
     1877                LogManager::getSingleton().logMessage("not loading scene"); 
    18701878 
    18711879                // terrain hack 
    … …  
    22032211} 
    22042212//----------------------------------------------------------------------- 
    2205 int OcclusionCullingSceneManager::FindExactVisibleObjects(Camera *camera, 
    2206                                                                                                                   Viewport* vp, 
    2207                                                                                                                   const bool fromPoint, 
    2208                                                                                                                   const bool nodeVisibility) 
     2213int OcclusionCullingSceneManager::QueryVisibleObjectsExact(Camera *camera, 
     2214                                                                                                                   Viewport* vp, 
     2215                                                                                                                   const bool fromPoint, 
     2216                                                                                                                   const bool nodeVisibility) 
    22092217{ 
    22102218        const int itemBufferMode = 0; 
    22112219        const bool relativeVisibility = false; 
     2220        const bool approximateVisibility = false; 
    22122221 
    22132222        int queryModes = 0; 
    … …  
    22362245                                                                                                 &visibleGeometry,  
    22372246                                                                                                 &visiblePatches,  
    2238                                                                                                  relativeVisibility); 
     2247                                                                                                 relativeVisibility, 
     2248                                                                                                 approximateVisibility); 
    22392249        } 
    22402250        else 
    … …  
    22442254                                                                                          &visibleGeometry,  
    22452255                                                                                          &visiblePatches,  
    2246                                                                                           relativeVisibility); 
     2256                                                                                          relativeVisibility, 
     2257                                                                                          approximateVisibility); 
    22472258        } 
    22482259                 
    … …  
    24892500        // note:have to disable deph write for nodes! 
    24902501    bool savedUseDepthPass = mUseDepthPass; 
    2491         if (mUseDepthPassForQueries) mUseDepthPass = true; 
     2502        if (mResetMaterialForQueries) mUseDepthPass = true; 
    24922503 
    24932504        // lists only used for visualization 
    … …  
    24982509        const int itemBufferMode = 0; 
    24992510        const bool relativeVisibility = false; 
     2511        bool approximateVisibility = false; 
    25002512 
    25012513        int queryModes = 0; 
    25022514 
    2503         if (mUseExactQueries) 
     2515        if (mQueryMode != 0) 
     2516        { 
     2517                queryModes |= GtpVisibility::QueryManager::NODE_VISIBILITY; 
     2518 
     2519                if (mQueryMode == 2) 
     2520                { 
     2521                        approximateVisibility = true; 
     2522                } 
     2523        } 
     2524        else 
     2525        { 
    25042526                queryModes |= GtpVisibility::QueryManager::GEOMETRY_VISIBILITY; 
    2505         else 
    2506                 queryModes |= GtpVisibility::QueryManager::NODE_VISIBILITY; 
     2527        }        
    25072528                         
    25082529 
    … …  
    25262547                                                                                                 &visibleGeometry,  
    25272548                                                                                                 &visiblePatches,  
    2528                                                                                                  relativeVisibility); 
     2549                                                                                                 relativeVisibility, 
     2550                                                                                                 approximateVisibility); 
    25292551        } 
    25302552        else 
    … …  
    25342556                                                                                          &visibleGeometry,  
    25352557                                                                                          &visiblePatches,  
    2536                                                                                           relativeVisibility); 
     2558                                                                                          relativeVisibility, 
     2559                                                                                          approximateVisibility); 
    25372560        } 
    25382561                 
    … …  
    25502573        //-- put items in render queue 
    25512574         
    2552         if (mUseExactQueries) 
     2575        if (mQueryMode != EXACT_QUERIES) 
    25532576        { 
    25542577                //////////// 
    25552578                //-- apply queries on geometry level 
    25562579 
     2580                AddVisibleNodeGeometryToQueue(visibleNodes, cam); 
     2581        } 
     2582        else 
     2583        { 
    25572584                AddVisibleMeshGeometryToQueue(visibleGeometry, cam); 
    2558         } 
    2559         else 
    2560         { 
    2561                 AddVisibleNodeGeometryToQueue(visibleNodes, cam); 
    25622585        } 
    25632586 

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

    r2254 r2255  
    2828                                                                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
    2929                                                                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
    30                                                                                         bool relativeVisibility) 
     30                                                                                        const bool relativeVisibility, 
     31                                                                                        const bool approximateVisibility) 
    3132{ 
    3233        // we need access to the scene manager and the rendersystem 
    … …  
    3738        bool overlayEnabled = mViewport->getOverlaysEnabled(); 
    3839 
    39         /////////// 
    40         //-- render scene with item buffer (i.e., objects with their id as color codes) 
    41  
    4240        //mItemBufferMode = 0; 
    43         if (0 &&  
    44                 (mItemBufferMode && mQueryModes) != 0) 
    45         { 
     41        if (0 && (mItemBufferMode && mQueryModes) != 0) 
     42        { 
     43                /////////// 
     44                //-- render scene with item buffer (ids are used as color codes) 
     45 
    4646                int savedQueryModes = mQueryModes; 
    4747                mQueryModes = mItemBufferMode; 
    … …  
    5151                                                                                                          visibleGeometry,  
    5252                                                                                                          visiblePatches,  
    53                                                                                                           relativeVisibility); 
     53                                                                                                          relativeVisibility, 
     54                                                                                                          approximateVisibility); 
    5455                 
    5556                // overlays cause false visibility 
    … …  
    175176                        pfHierarchyInterface->CheckFrustumVisible(*nodeIt, intersects); 
    176177 
    177                         // always push back if intersects 
    178                         if (1 && intersects) 
     178                        // always push back if only checking approximate visibility or intersects 
     179                        if (approximateVisibility || intersects) 
    179180                        { 
    180181                                // no more information available 
    … …  
    185186                                queryList[i].push_back(NULL); 
    186187                        } 
    187                         else 
     188                        else // issue occlusion query 
    188189                        { 
    189190                                queryList[i].push_back(mHierarchyInterface->IssueNodeOcclusionQuery(*nodeIt, false)); 
    … …  
    200201                        for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++ geometryIt) 
    201202                        { 
    202                                 queryList[i].push_back(pfHierarchyInterface->IssueMeshOcclusionQuery(*geometryIt)); 
     203                                if (approximateVisibility) 
     204                                { 
     205                                        // no more information available 
     206                                        const int visPixels = 1; 
     207                                        const int projPixels = 1; 
     208 
     209                                        visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt, visPixels, projPixels)); 
     210                                } 
     211                                else 
     212                                { 
     213                                        queryList[i].push_back(pfHierarchyInterface->IssueMeshOcclusionQuery(*geometryIt)); 
     214                                } 
    203215                        } 
    204216                } 
    … …  
    211223                        for (patchIt = patchList.begin(); patchIt != patchIt_end; ++patchIt) 
    212224                        { 
    213                                 queryList[i].push_back(pfHierarchyInterface->IssuePatchOcclusionQuery(*patchIt)); 
     225                                if (approximateVisibility) 
     226                                { 
     227                                        // no more information available 
     228                                        const int visPixels = 1; 
     229                                        const int projPixels = 1; 
     230 
     231                                        visiblePatches->push_back(GtpVisibility::PatchInfo(*patchIt, visPixels, projPixels)); 
     232                                } 
     233                                else 
     234                                { 
     235                                        queryList[i].push_back(pfHierarchyInterface->IssuePatchOcclusionQuery(*patchIt)); 
     236                                } 
    214237                        } 
    215238                } 
    … …  
    284307                                                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
    285308                                                                GtpVisibility::PatchInfoContainer *visiblePatches, 
    286                                                                 bool relativeVisibility) 
     309                                                                const bool relativeVisibility, 
     310                                                                const bool approximateVisibility) 
    287311{ 
    288312        PlatformQueryManager::ComputeFromPointVisibility(point,  
    … …  
    290314                                                                                                         visibleGeometry,  
    291315                                                                                                         visiblePatches,  
    292                                                                                                          relativeVisibility); 
     316                                                                                                         relativeVisibility, 
     317                                                                                                         approximateVisibility); 
    293318 
    294319        // adds up their visibility and removes duplicates  

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

    r2184 r2255  
    3333                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
    3434                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
    35                                         bool relativeVisibility) 
     35                                        const bool relativeVisibility, 
     36                                        const bool approximateVisibility) 
    3637{ 
    3738        SceneManager *sm = 
    … …  
    8788                                                                visibleGeometry,  
    8889                                                                visiblePatches,  
    89                                             relativeVisibility); 
     90                                            relativeVisibility, 
     91                                                                approximateVisibility); 
    9092                //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait"); 
    9193 
    … …  
    102104//----------------------------------------------------------------------- 
    103105void PlatformQueryManager::ComputeCameraVisibility( 
    104                                                                 const Camera &camera, 
    105                                                                 GtpVisibility::NodeInfoContainer *visibleNodes, 
    106                                                                 GtpVisibility::MeshInfoContainer *visibleGeometry, 
    107                                                                 GtpVisibility::PatchInfoContainer *visiblePatches, 
    108                                                                 bool relativeVisibility) 
     106                                                                        const Camera &camera, 
     107                                                                        GtpVisibility::NodeInfoContainer *visibleNodes, 
     108                                                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
     109                                                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
     110                                                                        const bool relativeVisibility, 
     111                                                                        const bool approximateVisibility) 
    109112{ 
    110113        // we need access to the scene manager and the rendersystem 

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

    r2254 r2255  
    5353                                Name="VCPostBuildEventTool" 
    5454                                CommandLine="copy $(OutDir)\$(TargetFileName) $(OGRE_PATH)\Samples\Common\bin\$(ConfigurationName) 
    55 copy $(OutDir)\$(TargetFileName) E:\svn\gametools\GTP\trunk\App\Demos\Illum\Ogre\bin\$(ConfigurationName) 
    5655"/> 
    5756                        <Tool 
    … …  
    125124                                Name="VCPostBuildEventTool" 
    126125                                CommandLine="copy $(OutDir)\$(TargetFileName) $(OGRE_PATH)\Samples\Common\bin\$(ConfigurationName) 
    127 copy $(OutDir)\$(TargetFileName) E:\svn\gametools\GTP\trunk\App\Demos\Illum\Ogre\bin\$(ConfigurationName) 
    128126"/> 
    129127                        <Tool 
Note: See TracChangeset for help on using the changeset viewer.