Changeset 343 for trunk/VUT


Ignore:
Timestamp:
10/20/05 18:49:11 (19 years ago)
Author:
mattausch
Message:

added switch between NV and ARB queries in the render system and in the demos.
Fixed render queue bug: when clearing queue, we traversed through all priority groups
to clear the passmaps. This became very slow because had to traverse many elements (over 1000
for city demo). Now all we destroy the priority groups for each rendering (per hierarchy node).

Location:
trunk/VUT
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibility/src/CoherentHierarchicalCullingManager.cpp

    r295 r343  
    8383                                         
    8484                                // if we assume node to be visible in this frame => skip query  
     85                                // TODO: check this (not the expected speed up) 
    8586                                if (wasVisible && (mAssumedVisibility > 0) &&  DecideVisible(node) && mHierarchyInterface->HasGeometry(node)) 
    8687                                { 

  • trunk/VUT/Ogre/resources/overlays/VisibilityDemo.overlay

    r254 r343  
    121121                        font_name TrebuchetMSBold 
    122122                        caption :                        
    123                 }        
     123                } 
     124                element TextArea(Example/Visibility/UseArbQueries): Example/Visibility/Templates/BasicText 
     125                { 
     126                        left 5 
     127                        width 120 
     128                        height 30 
     129                        caption [A] HW Query type 
     130                }        
     131                element TextArea(Example/Visibility/UseArbQueriesInfo): Example/Visibility/Templates/BasicText 
     132                { 
     133                        left 210 
     134                        width 90 
     135                        font_name TrebuchetMSBold 
     136                        caption :                        
     137                }        
     138 
    124139        } 
    125140 

  • trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

    r174 r343  
    106106        } 
    107107#endif 
     108         
    108109} 
    109110//----------------------------------------------------------------------- 

  • trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

    r259 r343  
    237237void VisibilityOctreeSceneManager::_renderVisibleObjects() 
    238238{ 
     239         
     240                //InitVisibilityCulling(mCameraInProgress); 
     241                //mVisibilityManager->ApplyVisibilityCulling(); 
     242 
     243                if(1){ 
    239244        InitDepthPass();          // create material for depth pass 
    240245        InitItemBufferPass(); // create material for item buffer pass 
    … …  
    340345        // reset ambient light 
    341346        setAmbientLight(savedAmbient); 
    342          
     347}        
    343348        getRenderQueue()->clear(); // finally clear render queue 
    344349        OGRE_DELETE(mRenderQueue); // HACK: should be cleared before... 
    345350        //WriteLog(); // write out stats 
     351 
    346352} 
    347353 
    … …  
    428434                return true; 
    429435        } 
     436        if (key == "UseArbQueries") 
     437        { 
     438                bool useArbQueries = (*static_cast<const bool *>(val)); 
     439 
     440                if (useArbQueries) 
     441                { 
     442                        mHierarchyInterface->DeleteQueries(); 
     443                        mDestRenderSystem->setConfigOption("ArbQueries", "Yes"); 
     444                } 
     445                else 
     446                { 
     447                        mHierarchyInterface->DeleteQueries(); 
     448                        mDestRenderSystem->setConfigOption("ArbQueries", "No"); 
     449                } 
     450        } 
     451 
    430452        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    431453                setOption(key, val) || OctreeSceneManager::setOption(key, val); 

  • trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

    r259 r343  
    434434        } 
    435435 
     436        if (key == "UseArbQueries") 
     437        { 
     438                bool useArbQueries = (*static_cast<const bool *>(val)); 
     439 
     440                if (useArbQueries) 
     441                { 
     442                        mHierarchyInterface->DeleteQueries(); 
     443                        mDestRenderSystem->setConfigOption("ArbQueries", "Yes"); 
     444                } 
     445                else 
     446                { 
     447                        mHierarchyInterface->DeleteQueries(); 
     448                        mDestRenderSystem->setConfigOption("ArbQueries", "No"); 
     449                } 
     450        } 
    436451        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    437452                setOption(key, val) || TerrainSceneManager::setOption(key, val); 

  • trunk/VUT/scripts/GtpVisibility.sln

    r187 r343  
    66Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Plugin_VisibilitySceneManager", "..\Ogre\scripts\Plugin_VisibilitySceneManager.vcproj", "{80DECC17-BDDD-4412-8CF8-F7C1C17A7436}" 
    77        ProjectSection(ProjectDependencies) = postProject 
    8                 {101A7691-74F3-48B4-96A3-CF35578F5900} = {101A7691-74F3-48B4-96A3-CF35578F5900} 
    9         EndProjectSection 
    10 EndProject 
    11 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TestCulling", "..\work\TestCulling\TestCulling.vcproj", "{B5A492C7-F04F-4F9A-9483-3303EBEB4306}" 
    12         ProjectSection(ProjectDependencies) = postProject 
    13                 {80DECC17-BDDD-4412-8CF8-F7C1C17A7436} = {80DECC17-BDDD-4412-8CF8-F7C1C17A7436} 
    148                {101A7691-74F3-48B4-96A3-CF35578F5900} = {101A7691-74F3-48B4-96A3-CF35578F5900} 
    159        EndProjectSection 
    … …  
    5044                {80DECC17-BDDD-4412-8CF8-F7C1C17A7436}.Release.ActiveCfg = Release|Win32 
    5145                {80DECC17-BDDD-4412-8CF8-F7C1C17A7436}.Release.Build.0 = Release|Win32 
    52                 {B5A492C7-F04F-4F9A-9483-3303EBEB4306}.Debug.ActiveCfg = Debug|Win32 
    53                 {B5A492C7-F04F-4F9A-9483-3303EBEB4306}.Debug.Build.0 = Debug|Win32 
    54                 {B5A492C7-F04F-4F9A-9483-3303EBEB4306}.Release.ActiveCfg = Release|Win32 
    55                 {B5A492C7-F04F-4F9A-9483-3303EBEB4306}.Release.Build.0 = Release|Win32 
    5646                {248F19A6-2FE0-4F5D-8928-E0EA10609887}.Debug.ActiveCfg = Debug|Win32 
    5747                {248F19A6-2FE0-4F5D-8928-E0EA10609887}.Debug.Build.0 = Debug|Win32 

  • trunk/VUT/work/IVReader/scripts/IVReader.vcproj

    r183 r343  
    149149                        </File> 
    150150                </Filter> 
    151                 <File 
    152                         RelativePath=".\ReadMe.txt"> 
    153                 </File> 
    154151        </Files> 
    155152        <Globals> 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

    r316 r343  
    140140mNumVideoFrames(0), 
    141141mDemoFps(0), 
    142 mUseDemoFps(false) 
     142mUseDemoFps(false), 
     143mUseArbQueries(false) 
    143144{ 
    144145        //mInputDevice = PlatformManager::getSingleton().createInputReader(); 
    … …  
    188189        mTimer = Root::getSingleton().getTimer(); 
    189190        mTimeFrameEnded = mTimeFrameStarted = mTimer->getMilliseconds(); 
     191         
     192        // arb or nv queries 
     193        mSceneMgr->setOption("UseArbQueries", &mUseArbQueries); 
    190194         
    191195        // reset statistics 
    … …  
    882886                guiCurr->setCaption(currFpsString + StringConverter::toString(currentFps)); 
    883887                 
     888                //std::stringstream d; d << "frame rate :" << stats.lastFPS; 
     889                //Ogre::LogManager::getSingleton().logMessage(d.str()); 
    884890 
    885891                guiBest->setCaption(bestFpsString + StringConverter::toString(stats.bestFPS) 
    … …  
    973979        { 
    974980                mUseDepthPassInfo->setCaption(": false"); 
     981        } 
     982} 
     983//----------------------------------------------------------------------- 
     984void TerrainFrameListener::toggleUseArbQueries() 
     985{ 
     986        mUseArbQueries = !mUseArbQueries; 
     987 
     988        mSceneMgr->setOption("UseArbQueries", &mUseArbQueries); 
     989         
     990        if (mUseArbQueries) 
     991        { 
     992                mUseArbQueriesInfo->setCaption(": ARB"); 
     993        } 
     994        else 
     995        { 
     996                mUseArbQueriesInfo->setCaption(": NV"); 
    975997        } 
    976998} 
    … …  
    11731195                mUseDemoFps = !mUseDemoFps; 
    11741196                break; 
     1197        case KC_A: 
     1198                toggleUseArbQueries(); 
     1199                break; 
     1200 
    11751201        //KEY_PRESSED(KC_F3, 0.3, writeFrames()); 
    11761202        //KEY_PRESSED(KC_F4, 0.3, loadFrames()); 
    … …  
    15021528        initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space; 
    15031529        initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space; 
     1530        initOverlayElement(&mUseArbQueriesInfo, ext, "UseArbQueries", top, ": NV"); top += vert_space; 
    15041531        //initOverlayElement(&mHelpInfo, ext, "Help", top, ": "); top += vert_space; 
    15051532 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.h

    r259 r343  
    210210        */ 
    211211        void toggleUseDepthPass(); 
     212        /** Toggles wether we use ARB or NV queries. 
     213        */ 
     214        void toggleUseArbQueries(); 
    212215        /** Toggles wether the visualization is shown. 
    213216        */ 
    … …  
    288291        OverlayElement *mTestGeometryForVisibleLeavesInfo; 
    289292        OverlayElement *mUseDepthPassInfo; 
     293        OverlayElement *mUseArbQueriesInfo; 
    290294        OverlayElement *mRenderedNodesInfo; 
    291295        OverlayElement *mObjectsCountInfo; 
    … …  
    312316        bool mShowOctree; 
    313317        bool mUseDepthPass; 
     318        bool mUseArbQueries; 
    314319        bool mShowVisualization; 
    315320        bool mCullCamera; 

  • trunk/VUT/work/iv/IVFrameListener.cpp

    r316 r343  
    4848mVisibilityThreshold(0), 
    4949mAssumedVisibility(0), 
    50 mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING), 
     50//mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING), 
     51//mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING), 
     52mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING), 
    5153mNodeVizMode(NODEVIZ_NONE), 
    5254mVizCameraHeight(Real(2500.0)), 
    … …  
    6365mShowOctree(false), 
    6466mUseDepthPass(false), 
     67mUseArbQueries(false), 
    6568mTestGeometryForVisibleLeaves(false), 
    6669mShowVisualization(false), 
    … …  
    123126        mSceneMgr->setOption("DelayRenderTransparents", &delayRenderTransparents); 
    124127        mSceneMgr->setOption("UseDepthPass", &mUseDepthPass); 
    125          
     128        mSceneMgr->setOption("UseArbQueries", &mUseArbQueries); 
     129 
    126130        mSceneMgr->setOption("ShowOctree", &mShowOctree); 
    127131        mSceneMgr->setOption("CullCamera", &mCullCamera); 
    … …  
    571575                        guiAvg->setCaption(avgFpsString + StringConverter::toString(avgFps) + " ms"); 
    572576                } 
     577                //std::stringstream d; d << "frame rate :" << stats.lastFPS; 
     578                //Ogre::LogManager::getSingleton().logMessage(d.str()); 
    573579 
    574580                guiCurr->setCaption(currFpsString + StringConverter::toString(stats.lastFPS)); 
    … …  
    646652 
    647653        mSceneMgr->setOption("ShowOctree", &mShowOctree); 
     654} 
     655//----------------------------------------------------------------------- 
     656void IVFrameListener::toggleUseArbQueries() 
     657{ 
     658        mUseArbQueries = !mUseArbQueries; 
     659 
     660        mSceneMgr->setOption("UseArbQueries", &mUseArbQueries); 
     661         
     662        if (mUseArbQueries) 
     663        { 
     664                mUseArbQueriesInfo->setCaption(": ARB"); 
     665        } 
     666        else 
     667        { 
     668                mUseArbQueriesInfo->setCaption(": NV"); 
     669        } 
    648670} 
    649671//----------------------------------------------------------------------- 
    … …  
    808830                mShiftPressed = true; 
    809831                break; 
    810  
     832        case KC_A: 
     833                toggleUseArbQueries(); 
     834                break; 
    811835        default: 
    812836                break; 
    … …  
    11211145        initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space; 
    11221146        initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space; 
     1147        initOverlayElement(&mUseArbQueriesInfo, ext, "UseArbQueries", top, ": NV"); top += vert_space; 
    11231148        //initOverlayElement(&mHelpInfo, ext, "Help", top, ": "); top += vert_space; 
    11241149 

  • trunk/VUT/work/iv/IVFrameListener.h

    r259 r343  
    115115        void toggleShowOctree(); 
    116116        void toggleUseDepthPass(); 
     117        void toggleUseArbQueries(); 
    117118        void toggleShowViz(); 
    118119        void toggleRecord(); 
    … …  
    159160        OverlayElement *mTestGeometryForVisibleLeavesInfo; 
    160161        OverlayElement *mUseDepthPassInfo; 
     162        OverlayElement *mUseArbQueriesInfo; 
    161163        OverlayElement *mRenderedNodesInfo; 
    162164        OverlayElement *mObjectsCountInfo; 
    … …  
    180182        bool mShowOctree; 
    181183        bool mUseDepthPass; 
     184        bool mUseArbQueries; 
    182185        bool mShowVisualization; 
    183186        bool mCullCamera; 

  • trunk/VUT/work/iv/TestCullingIVApplication.cpp

    r259 r343  
    9292        mSceneMgr->setOption("NodeVizScale", &scale); 
    9393        // HACK: change this to relative path 
    94         String path = "D:/svn/gtp/trunk/VUT/Ogre/resources/"; 
     94        String path = "D:/svn/trunk/VUT/Ogre/resources/"; 
    9595                 
    9696        SceneNode *node1 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Node1"); 

  • trunk/VUT/work/ogre_changes/OgreMain/include/OgreRenderQueueSortingGrouping.h

    r193 r343  
    202202#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    203203         
    204                 /** Clears solids in this group of renderables. Leaves transparents in group. 
    205         */ 
    206         void clearSolids(void); 
    207  
    208204                enum {SOLID_PASSES = 1, 
    209205                          SOLID_PASSES_DECAL = 2, 
    … …  
    221217                */ 
    222218                void clear(const int leavePassesInQueue); 
     219                /** Destroys passes determined by parameter. 
     220                        @param passes can be one or several (combined by |) of: 
     221                        SOLID_PASSES  
     222                        SOLID_PASSES_DECAL  
     223                        SOLID_PASSES_DIFFUSE_SPECULAR 
     224                        SOLID_PASSES_NOSHADOW 
     225                        TRANSPARENT_PASSES 
     226                */ 
     227                void destroyPassMaps(const int leavePassesInQueue); 
     228 
    223229#endif // GTP_VISIBILITY_MODIFIED_OGRE           
    224230        /** Sets whether or not the queue will split passes by their lighting type, 
    … …  
    337343 
    338344        } 
    339                 /** Clears only solid renderables. Leaves transparents in queue. */ 
    340                 void clearSolids(void) 
     345         
     346                void destroyPasses(int passes) 
    341347        { 
    342348            PriorityMap::iterator i, iend; 
    … …  
    344350            for (i = mPriorityGroups.begin(); i != iend; ++i) 
    345351            { 
    346                 i->second->clearSolids(); 
    347             } 
     352                i->second->destroyPassMaps(passes); 
     353            } 
     354 
    348355        } 
    349356#endif // GTP_VISIBILITY_MODIFIED_OGRE           

  • trunk/VUT/work/ogre_changes/OgreMain/src/OgreRenderQueueSortingGrouping.cpp

    r139 r343  
    278278#ifdef GTP_VISIBILITY_MODIFIED_OGRE      
    279279        //----------------------------------------------------------------------- 
    280     void RenderPriorityGroup::clearSolids(void) 
    281     { 
    282         /*SolidRenderablePassMap::iterator i, iend; 
    283         // Delete queue groups which are using passes which are to be 
    284         // deleted, we won't need these any more and they clutter up  
    285         // the list and can cause problems with future clones 
    286         const Pass::PassSet& graveyardList = Pass::getPassGraveyard(); 
    287         Pass::PassSet::const_iterator gi, giend; 
    288         giend = graveyardList.end(); 
    289         for (gi = graveyardList.begin(); gi != giend; ++gi) 
    290         { 
    291             removeSolidPassEntry(*gi); 
    292         } 
    293  
    294         // Now remove any dirty passes, these will have their hashes recalculated 
    295         // by the parent queue after all groups have been processed 
    296         // If we don't do this, the std::map will become inconsistent for new insterts 
    297         const Pass::PassSet& dirtyList = Pass::getDirtyHashList(); 
    298         Pass::PassSet::const_iterator di, diend; 
    299         diend = dirtyList.end(); 
    300         for (di = dirtyList.begin(); di != diend; ++di) 
    301         { 
    302             removeSolidPassEntry(*di); 
    303         }*/ 
    304         // NB we do NOT clear the graveyard or the dirty list here, because  
    305         // it needs to be acted on for all groups, the parent queue takes  
    306         // care of this afterwards 
    307  
    308         // We do not clear the unchanged solid pass maps, only the contents of each list 
    309         // This is because we assume passes are reused a lot and it saves resorting 
    310         clearSolidPassMap(mSolidPasses); 
    311         clearSolidPassMap(mSolidPassesDecal); 
    312         clearSolidPassMap(mSolidPassesDiffuseSpecular); 
    313         clearSolidPassMap(mSolidPassesNoShadow); 
    314     } 
    315         //----------------------------------------------------------------------- 
    316280    void RenderPriorityGroup::clear(const int leavePassesInQueue) 
    317281    { 
    318                 SolidRenderablePassMap::iterator i, iend; 
    319         
    320                 // -- standard method if no passes are left in queue 
     282                //-- standard method if no passes are left in queue 
    321283                if (leavePassesInQueue == 0) 
    322284                { 
    … …  
    328290        // This is because we assume passes are reused a lot and it saves resorting 
    329291                if (!(leavePassesInQueue & SOLID_PASSES)) 
    330                         clearSolidPassMap(mSolidPasses); 
     292                        destroySolidPassMap(mSolidPasses); 
    331293                if (!(leavePassesInQueue & SOLID_PASSES_DECAL)) 
    332                         clearSolidPassMap(mSolidPassesDecal); 
     294                        destroySolidPassMap(mSolidPassesDecal); 
    333295                if (!(leavePassesInQueue & SOLID_PASSES_DIFFUSE_SPECULAR)) 
    334                         clearSolidPassMap(mSolidPassesDiffuseSpecular); 
     296                        destroySolidPassMap(mSolidPassesDiffuseSpecular); 
    335297                if (!(leavePassesInQueue & SOLID_PASSES_NOSHADOW)) 
    336                         clearSolidPassMap(mSolidPassesNoShadow); 
     298                        destroySolidPassMap(mSolidPassesNoShadow); 
    337299 
    338300        if (!(leavePassesInQueue & TRANSPARENT_PASSES)) 
    339301                        mTransparentPasses.clear(); 
    340302    } 
     303        //----------------------------------------------------------------------- 
     304    void RenderPriorityGroup::destroyPassMaps(const int leavePassesInQueue) 
     305    { 
     306                /*     
     307        const Pass::PassSet& graveyardList = Pass::getPassGraveyard(); 
     308        Pass::PassSet::const_iterator gi, giend; 
     309        giend = graveyardList.end(); 
     310        for (gi = graveyardList.begin(); gi != giend; ++gi) 
     311        { 
     312            removeSolidPassEntry(*gi); 
     313        } 
     314 
     315        const Pass::PassSet& dirtyList = Pass::getDirtyHashList(); 
     316        Pass::PassSet::const_iterator di, diend; 
     317        diend = dirtyList.end(); 
     318        for (di = dirtyList.begin(); di != diend; ++di) 
     319        { 
     320            removeSolidPassEntry(*di); 
     321                } 
     322                */ 
     323 
     324        // We do not clear the unchanged solid pass maps, only the contents of each list 
     325        // This is because we assume passes are reused a lot and it saves resorting 
     326                if (!(leavePassesInQueue & SOLID_PASSES)) 
     327                        destroySolidPassMap(mSolidPasses); 
     328                if (!(leavePassesInQueue & SOLID_PASSES_DECAL)) 
     329                        destroySolidPassMap(mSolidPassesDecal); 
     330                if (!(leavePassesInQueue & SOLID_PASSES_DIFFUSE_SPECULAR)) 
     331                        destroySolidPassMap(mSolidPassesDiffuseSpecular); 
     332                if (!(leavePassesInQueue & SOLID_PASSES_NOSHADOW)) 
     333                        destroySolidPassMap(mSolidPassesNoShadow); 
     334    } 
    341335#endif // GTP_VISIBILITY_MODIFIED_OGRE           
    342336//----------------------------------------------------------------------- 

  • trunk/VUT/work/ogre_changes/OgreMain/src/OgreSceneManager.cpp

    r316 r343  
    42264226                if (isRenderQueueToBeProcessed(qId)) 
    42274227                { 
    4228                         /*if (leaveTransparentsInQueue) 
    4229                         {       pGroup->clearSolids();  }       else 
    4230                         {       pGroup->clear(); }*/ 
    4231                         pGroup->clear(leavePassesInQueue); 
     4228                        pGroup->destroyPasses(leavePassesInQueue); 
    42324229                } 
    42334230        } 

  • trunk/VUT/work/ogre_changes/RenderSystems/GL/include/OgreGLHardwareOcclusionQuery.h

    r115 r343  
    111111#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    112112        bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH );  
     113 
     114        static bool sUseArbQueries; 
    113115#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    114116//---------------------------------------------------------------------- 
    … …  
    122124        int                             mSkipCounter; 
    123125        int                             mSkipInterval; 
    124         bool                    mHasOcclusionSupport; 
     126        bool                    mHasOcclusionSupportNV; 
     127        bool                    mHasOcclusionSupportARB; 
    125128}; 
    126129 

  • trunk/VUT/work/ogre_changes/RenderSystems/GL/src/OgreGLHardwareOcclusionQuery.cpp

    r193 r343  
    2929namespace Ogre { 
    3030 
     31bool GLHardwareOcclusionQuery::sUseArbQueries = false; 
    3132/** 
    3233  * This is a class that is the base class of the query class for  
    … …  
    5152        // Check for hardware occlusion support 
    5253        // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported. 
    53 #ifdef GTP_VISIBILITY_USE_ARB_QUERIES 
    54         if (glGenQueriesARB_ptr != 0) 
    55 #else 
    56         if (glGenOcclusionQueriesNV_ptr != 0) 
    57 #endif 
    58     { 
    59                 mHasOcclusionSupport = true; 
    60         } 
    61         else 
    62         { 
    63                 mHasOcclusionSupport = false; 
    64         } 
     54        mHasOcclusionSupportARB = (glGenQueriesARB_ptr != 0); 
     55        mHasOcclusionSupportNV = (glGenOcclusionQueriesNV_ptr != 0); 
    6556 
    66         if(mHasOcclusionSupport) 
    67         { 
    68 #ifdef GTP_VISIBILITY_USE_ARB_QUERIES 
     57        if (sUseArbQueries && mHasOcclusionSupportARB) 
    6958                glGenQueriesARB_ptr(1, &mQueryID );      
    70 #else 
     59        else if (!sUseArbQueries && mHasOcclusionSupportNV) 
    7160                glGenOcclusionQueriesNV_ptr(1, &mQueryID); 
    72 #endif 
    73         } 
    7461} 
    7562 
    … …  
    7966GLHardwareOcclusionQuery::~GLHardwareOcclusionQuery()  
    8067{  
    81         if( mHasOcclusionSupport ) 
    82         { 
    83 #ifdef GTP_VISIBILITY_USE_ARB_QUERIES 
     68        if (sUseArbQueries && mHasOcclusionSupportARB) 
    8469                glDeleteQueriesARB_ptr(1, &mQueryID); 
    85 #else 
     70        else if (!sUseArbQueries && mHasOcclusionSupportNV) 
    8671                glDeleteOcclusionQueriesNV_ptr(1, &mQueryID);   
    87 #endif 
    88         }        
    8972} 
    9073 
    … …  
    9477void GLHardwareOcclusionQuery::beginOcclusionQuery()  
    9578{  
    96         // Make it fail silently if hardware occlusion isn't supported 
    97         if(mHasOcclusionSupport) 
    98         { 
    99                 // Counter starts at 0 again at mSkipInterval  
    100 #ifndef GTP_VISIBILITY_MODIFIED_OGRE 
    101                 if(mSkipCounter == mSkipInterval)  
    102 #else 
    103                 if (mSkipCounter >= mSkipInterval)  // otherwise no query ever issued if mSkipInterval = 0 ! 
    104 #endif // GTP_VISIBILITY_MODIFIED_OGRE 
    105         { 
    106                         mSkipCounter = 0;  
    107                 } 
     79        //if (mSkipCounter >= mSkipInterval)  // otherwise no query ever issued if mSkipInterval = 0 ! 
     80        //      mSkipCounter = 0; if (mSkipCounter != 0) return; 
    10881 
    109                 if (mSkipCounter == 0) 
    110                 { 
    111 #ifdef GTP_VISIBILITY_USE_ARB_QUERIES 
     82        if (sUseArbQueries && mHasOcclusionSupportARB) 
    11283                        glBeginQueryARB_ptr(GL_SAMPLES_PASSED_ARB, mQueryID); 
    113 #else 
     84        else if (!sUseArbQueries && mHasOcclusionSupportNV) 
    11485                        glBeginOcclusionQueryNV_ptr(mQueryID); 
    115 #endif 
    116                 } 
    117         } 
    11886} 
    11987         
    12088void GLHardwareOcclusionQuery::endOcclusionQuery()  
    12189{  
    122         // Make it fail silently if hardware occlusion isn't supported 
    123         if(mHasOcclusionSupport) 
    124         { 
    125                 if( mSkipCounter == 0) 
    126                 { 
    127 #ifdef GTP_VISIBILITY_USE_ARB_QUERIES 
     90        //if( mSkipCounter != 0) return; 
     91        if (sUseArbQueries && mHasOcclusionSupportARB) 
    12892                        glEndQueryARB_ptr(GL_SAMPLES_PASSED_ARB); 
    129 #else 
     93        else if (!sUseArbQueries && mHasOcclusionSupportNV) 
    13094                        glEndOcclusionQueryNV_ptr(); 
    131 #endif 
     95//      mSkipCounter++; 
    13296                } 
    13397 
    134                 mSkipCounter++; 
    135         }  
    136 } 
    137  
    138 //------------------------------------------------------------------ 
    139 // OpenGL dosn't use the flag paramter. 
    140 //------------------------------------------------------------------ 
    14198bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag  )  
    14299{ 
    143         if( mHasOcclusionSupport )      // Make it fail silently if hardware occlusion isn't supported 
    144         { 
    145 #ifdef GTP_VISIBILITY_USE_ARB_QUERIES 
     100        if (sUseArbQueries && mHasOcclusionSupportARB) 
    146101                glGetQueryObjectuivARB_ptr(mQueryID, GL_QUERY_RESULT_ARB, NumOfFragments); 
    147 #else 
     102        else if (!sUseArbQueries && mHasOcclusionSupportNV) 
    148103glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_NV, NumOfFragments); 
    149 #endif 
    150         } 
    151104        else 
    152         { 
    153                 *NumOfFragments = 100000;               // Fails quitlly -> every object tested is visable. 
    154         } 
     105                *NumOfFragments = 100000;               // Fails quietly 
    155106 
    156107        mPixelCount = *NumOfFragments;  
    … …  
    161112#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    162113        //------------------------------------------------------------------ 
    163         bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag)  
     114bool GLHardwareOcclusionQuery::pullOcclusionQuery(unsigned int * NumOfFragments,  
     115                                                                                                  const bool waitForResult,  
     116                                                                                                  const HW_OCCLUSIONQUERY flag)  
    164117{ 
    165         unsigned int isAvailable = GL_TRUE; 
     118        if (sUseArbQueries && mHasOcclusionSupportARB)   
     119        { 
     120                int isAvailable = GL_TRUE; 
    166121 
    167                 if (mHasOcclusionSupport)        
    168         { 
    169122                if (!waitForResult) 
     123                        glGetQueryivARB_ptr(mQueryID, GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable); 
     124                 
     125                if (isAvailable == GL_TRUE) 
     126                        glGetQueryObjectuivARB_ptr(mQueryID, GL_QUERY_RESULT_ARB, NumOfFragments); 
     127 
     128                mPixelCount = *NumOfFragments; 
     129 
     130                return isAvailable == GL_TRUE; 
     131        }  
     132        else if (!sUseArbQueries && mHasOcclusionSupportNV) 
    170133                { 
    171                         // use nv queries rather that arb because they are faster (no flush) 
    172                                 //glGetQueryivARB_ptr(mQueryID, GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable); 
     134                unsigned int isAvailable = GL_TRUE; 
     135 
     136                if (!waitForResult) 
    173137                                glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable); 
    174                 } 
    175138 
    176139                if (isAvailable == GL_TRUE) 
    177                 { 
    178                                 //glGetQueryObjectuivARB_ptr(mQueryID, GL_QUERY_RESULT_ARB, NumOfFragments); 
    179140                                glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_NV, NumOfFragments); 
    180                 } 
    181         }  
    182         else 
    183         { 
    184                 // In case hardware occlusion isn't supported, every object is set visible. 
    185                 *NumOfFragments = 100000;                
    186         } 
    187141 
    188142                mPixelCount = *NumOfFragments;  
    189143 
    190         return isAvailable == GL_TRUE;   
     144                return isAvailable == GL_TRUE; 
     145                } 
     146         
     147                // In case hardware occlusion isn't supported, every object is set visible. 
     148                *NumOfFragments = 100000;                
     149                mPixelCount = *NumOfFragments;  
     150 
     151        return GL_TRUE;  
    191152} 
    192153 

  • trunk/VUT/work/ogre_changes/RenderSystems/GL/src/OgreGLRenderSystem.cpp

    r316 r343  
    281281    void GLRenderSystem::setConfigOption(const String &name, const String &value) 
    282282    { 
     283                // set occlusion query 
     284#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     285                if ( name == "ArbQueries" ) 
     286                { 
     287                        if ( value == "No" ) 
     288                        { 
     289                                GLHardwareOcclusionQuery::sUseArbQueries = false; 
     290                        } 
     291                        else if  ( value == "Yes" ) 
     292                        { 
     293                                GLHardwareOcclusionQuery::sUseArbQueries = true; 
     294                        } 
     295                        return; 
     296                } 
     297#endif 
     298 
    283299        mGLSupport->setConfigOption(name, value); 
    284300    } 
Note: See TracChangeset for help on using the changeset viewer.