Changeset 153 for trunk/VUT/Ogre


Ignore:
Timestamp:
07/04/05 03:15:53 (19 years ago)
Author:
mattausch
Message:

added item buffer queries

Location:
trunk/VUT/Ogre
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/Ogre/include/OgreVisibilityTerrainSceneManager.h

    r139 r153  
    8080        GtpVisibility::VisibilityManager *GetVisibilityManager(); 
    8181 
     82        /** Returns hierarchy interface. 
     83        */ 
     84        OctreeHierarchyInterface *GetHierarchyInterface(); 
     85 
    8286protected: 
    8387         
    … …  
    107111        bool mRenderDepthPass; 
    108112        bool mRenderItemBuffer; 
     113        bool mUseItemBuffer; 
    109114        bool mEnableDepthWrite; 
    110115        bool mSkipTransparents; 
    … …  
    115120        int mCurrentEntityId; 
    116121 
    117         PlatformQueryManager *mQueryManager; 
    118  
    119122        int mLeavePassesInQueue; 
    120123        ShadowTechnique mSavedShadowTechnique; 

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

    r150 r153  
    3737        bool overlayEnabled = mViewport->getOverlaysEnabled(); 
    3838        mViewport->setOverlaysEnabled(false); 
     39 
     40        //-- render the scene once to update depth buffer 
    3941        pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
    4042 
    … …  
    234236        mViewport->setCamera(savedCam); 
    235237 
    236         // --- remove duplicates (happens if an object is on the edge of the viewport) 
     238        // --- remove duplicates (duplicates occur if an object is on the edge of the viewport) 
    237239 
    238240        // before duplicates can be deleted we have to add up their visibility 
    … …  
    259261        } 
    260262         
    261         // really delete duplicates 
     263        // physically delete duplicates 
    262264        visibleNodes->erase( std::unique(visibleNodes->begin(),  
    263265                visibleNodes->end(), nodeinfo_eq), visibleNodes->end()); 
    … …  
    284286        } 
    285287 
    286         // really delete duplicates 
     288        // physically delete duplicates 
    287289        visibleGeometry->erase(std::unique(visibleGeometry->begin(), visibleGeometry->end(),  
    288290                meshinfo_eq), visibleGeometry->end()); 

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

    r150 r153  
    1313 
    1414//----------------------------------------------------------------------- 
    15 VisibilityTerrainSceneManager::VisibilityTerrainSceneManager( 
    16         GtpVisibility::VisibilityManager *visManager):  
     15VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(GtpVisibility:: 
     16                                                                                                                         VisibilityManager *visManager):  
    1717mVisibilityManager(visManager),  
    18 mRenderDepthPass(false), 
    1918mShowVisualization(false), 
    2019mRenderNodesForViz(false), 
    … …  
    2423mDelayRenderTransparents(true), 
    2524mUseDepthPass(false), 
    26 mRenderItemBuffer(true), 
     25mRenderDepthPass(false), 
     26//mUseItemBuffer(false), 
     27mUseItemBuffer(true), 
     28mRenderItemBuffer(false), 
    2729mCurrentEntityId(0), 
    2830mEnableDepthWrite(true), 
    … …  
    3133{ 
    3234        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    33         mQueryManager = new PlatformQueryManager(mHierarchyInterface, mCurrentViewport); 
    34  
    35         mVisibilityManager->SetQueryManager(mQueryManager); 
    3635         
    3736        //mDisplayNodes = true; 
    … …  
    9493                mHierarchyInterface = NULL; 
    9594        } 
    96         if (mQueryManager) 
    97         { 
    98                 delete mQueryManager; 
    99                 mQueryManager = NULL; 
    100         } 
    10195} 
    10296//----------------------------------------------------------------------- 
    … …  
    259253                mIlluminationStage = savedStage; 
    260254        } 
    261         else // the hierarchical culling algorithm 
    262         { 
    263                 //-- hierarchical culling 
     255        else // -- the hierarchical culling algorithm 
     256        { 
     257                // don't render backgrounds for item buffer 
     258                if (mUseItemBuffer) 
     259                { 
     260                        clearSpecialCaseRenderQueues(); 
     261                        getRenderQueue()->clear(); 
     262                } 
     263 
    264264                // the objects of different layers (e.g., background, scene,  
    265265                // overlay) must be identified and rendered one after another 
    … …  
    272272 
    273273                TerrainSceneManager::_renderVisibleObjects(); 
     274                 
    274275 
    275276#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     277                // delete previously rendered contenbt 
    276278                _deleteRenderedQueueGroups(); 
    277279#endif 
    … …  
    284286 
    285287 
    286                 //-- set all necessary parameters for hierarchical visibility culling and rendering 
     288                // set all necessary parameters for  
     289                // hierarchical visibility culling and rendering 
    287290                InitVisibilityCulling(mCameraInProgress); 
    288291 
    289292                /**  
    290293                * the hierarchical culling algorithm 
    291                 * if using depth pass: will just find objects and update depth buffer 
    292                 * for "delayed" rendering: will render some passes afterwards, e.g. transparents 
     294                * if we use a depth pass: will just find objects and update depth buffer 
     295                * for "delayed" rendering: will render some passes afterwards, e.g., transparents 
    293296                **/ 
    294297                 
    … …  
    302305                //-- reset parameters 
    303306                mRenderDepthPass = false; 
     307                mRenderItemBuffer = false; 
    304308                mSkipTransparents = false; 
    305309                mLeavePassesInQueue = 0; 
    306310                mShadowTechnique = mSavedShadowTechnique; 
    307                 mRenderItemBuffer = false; 
     311                 
    308312 
    309313                // add visible nodes found by the visibility culling algorithm 
    … …  
    326330        TerrainRenderable::setCurrentRenderLevelIndex(levelIdx); 
    327331 
    328         getRenderQueue()->clear(); 
    329  
    330332        // reset ambient light 
    331333        setAmbientLight(savedAmbient); 
     334 
     335        getRenderQueue()->clear(); 
    332336        //WriteLog(); // write out stats 
    333337} 
    … …  
    404408                return true; 
    405409        } 
    406         if (key == "ItemBuffer") 
    407         { 
    408                 mRenderItemBuffer = (*static_cast<const bool *>(val)); 
     410        if (key == "UseItemBuffer") 
     411        { 
     412                mUseItemBuffer = (*static_cast<const bool *>(val)); 
    409413                return true; 
    410414        } 
    … …  
    425429} 
    426430//----------------------------------------------------------------------- 
    427 bool VisibilityTerrainSceneManager::getOptionValues(const String & key, StringVector &refValueList) 
     431bool VisibilityTerrainSceneManager::getOptionValues(const String & key,  
     432                                                                                                        StringVector &refValueList) 
    428433{ 
    429434        return TerrainSceneManager::getOptionValues( key, refValueList); 
    … …  
    436441} 
    437442//----------------------------------------------------------------------- 
    438 void VisibilityTerrainSceneManager::setVisibilityManager(GtpVisibility::VisibilityManager *visManager) 
     443void VisibilityTerrainSceneManager::setVisibilityManager(GtpVisibility:: 
     444                                                                                                                 VisibilityManager *visManager) 
    439445{ 
    440446        mVisibilityManager = visManager; 
    … …  
    634640        InitItemBufferPass(); // create material for item buffer pass 
    635641 
     642        // reset culling manager stats 
     643        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
     644 
    636645        // save shadow technique. It will be reset after hierarchical culling 
    637646        mSavedShadowTechnique = mShadowTechnique; 
    638647 
    639  
    640         mLeavePassesInQueue = 0; 
    641          
     648        // render standard solids without shadows during hierarchical culling pass 
     649        if ((mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE) || 
     650            (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE)) 
     651        { 
     652         
     653                mShadowTechnique = SHADOWTYPE_NONE; 
     654        } 
     655 
     656        // set depth pass flag before rendering 
     657        mRenderDepthPass = mUseDepthPass; 
     658 
    642659        // item buffer needs full ambient lighting to use item colors as unique id 
    643660        if (mUseItemBuffer)  
    … …  
    649666 
    650667        // set passes which should be stored in render queue  
    651         // for rendering after hierarchical culling 
    652  
    653         if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE) 
    654         { 
    655                 // render standard solids without shadows during hierarchical culling pass 
    656                 mShadowTechnique = SHADOWTYPE_NONE; 
    657  
    658                 if (!mUseDepthPass) 
    659                 { 
    660                         // TODO: remove this because should be processed in first pass 
     668        // for rendering AFTER hierarchical culling, i.e., passes which need  
     669        // a special rendering order 
     670        mLeavePassesInQueue = 0; 
     671 
     672        if (!mUseDepthPass || !mUseItemBuffer) 
     673        { 
     674                if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE) 
     675                { 
     676                        // TODO: remove this pass because it should be processed during hierarchical culling 
    661677                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW; 
    662678 
    … …  
    664680                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DIFFUSE_SPECULAR; 
    665681                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES; 
    666                 } 
    667         } 
    668         if (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE) 
    669         { 
    670                 // render standard solids without shadows during hierarchical culling pass 
    671                 mShadowTechnique = SHADOWTYPE_NONE; 
    672  
    673                 if (!mUseDepthPass) 
     682 
     683                        // just render ambient stuff 
     684                        mIlluminationStage = IRS_AMBIENT; 
     685                } 
     686         
     687                if (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE) 
    674688                { 
    675689                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW; 
    676690                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES; 
    677691                } 
    678         } 
    679          
    680         if (mDelayRenderTransparents && (!mUseDepthPass)) 
    681         { 
    682                 mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES; 
    683         } 
    684         //std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;LogManager::getSingleton().logMessage(d.str()); 
     692         
     693                // transparents should be rendered after hierarchical culling to  
     694                // provide front-to-back ordering 
     695                if (mDelayRenderTransparents) 
     696                { 
     697                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES; 
     698                } 
     699        } 
     700 
     701        // skip rendering transparents in the hierarchical culling 
     702        // (because they will be rendered afterwards) 
     703        mSkipTransparents = mUseDepthPass ||  
     704                (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES); 
    685705 
    686706        // possible two cameras (one for culling, one for rendering) 
    … …  
    689709                                                mLeavePassesInQueue); 
    690710                 
    691          
    692         // reset culling manager stats 
    693         mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
    694  
    695         // set depth pass flag before rendering 
    696         mRenderDepthPass = mUseDepthPass; 
    697         // set flag for skipping transparents in the hierarchical culling pass 
    698         mSkipTransparents = mUseDepthPass ||  
    699                 (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES); 
    700 } 
    701  
     711        //std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;LogManager::getSingleton().logMessage(d.str()); 
     712} 
     713//----------------------------------------------------------------------- 
     714OctreeHierarchyInterface *VisibilityTerrainSceneManager::GetHierarchyInterface() 
     715{ 
     716        return mHierarchyInterface; 
     717} 
    702718//----------------------------------------------------------------------- 
    703719/*void VisibilityTerrainSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup) 
    704720{ 
    705     // Basic render loop 
    706     // Iterate through priorities 
     721    // Basic render loop: Iterate through priorities 
    707722    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator(); 
    708723 
    … …  
    714729        pPriorityGrp->sort(mCameraInProgress); 
    715730 
    716                 //TODO: render other splid passes for shadows 
    717         // Do solids 
     731                // Do solids 
     732                // TODO: render other solid passes for shadows 
    718733        renderObjects(pPriorityGrp->_getSolidPassesNoShadows(), true); 
    719734 
Note: See TracChangeset for help on using the changeset viewer.