Ignore:
Timestamp:
05/08/06 06:55:17 (18 years ago)
Author:
mattausch
Message:

update for ogre 1.2
OcclusionCullingSceneManager? is the only scenemanager in the solution now

Location:
GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r903 r925  
    1111#include <OgreMaterialManager.h> 
    1212#include <OgreIteratorWrappers.h> 
     13#include <OgreHeightmapTerrainPageSource.h> 
    1314#include "VspBspTree.h" 
    1415#include "Containers.h" 
    … …  
    4445mSkipTransparents(false), 
    4546mRenderTransparentsForItemBuffer(true), 
    46 mExecuteVertexProgramForAllPasses(true), 
     47//mExecuteVertexProgramForAllPasses(true), 
     48mExecuteVertexProgramForAllPasses(false), 
    4749mIsHierarchicalCulling(false), 
    4850mViewCellsLoaded(false), 
    … …  
    5658        if (0) 
    5759        { 
    58         mDisplayNodes = true; 
    59         mShowBoundingBoxes = true; 
    60         mShowBoxes = true; 
     60                mDisplayNodes = true; 
     61                mShowBoundingBoxes = true; 
     62                mShowBoxes = true; 
    6163        } 
    6264 
    6365        // TODO: set maxdepth to reasonable value 
    6466        mMaxDepth = 50; 
     67 
     68        //loadVisibilityConfig("GtpVisibility.cfg"); 
     69        //LoadViewCells(""); 
     70        //mViewCellsLoaded = true; 
    6571} 
    6672//----------------------------------------------------------------------- 
    … …  
    117123} 
    118124//------------------------------------------------------------------------- 
     125#if 1 
    119126void OcclusionCullingSceneManager::setWorldGeometry( DataStreamPtr& stream, const String& typeName ) 
    120127{ 
    … …  
    146153 
    147154 } 
    148  
     155#endif 
    149156//----------------------------------------------------------------------- 
    150157void OcclusionCullingSceneManager::PrepareVisualization(Camera *cam) 
    … …  
    183190                        { 
    184191                                // render the leaf nodes 
    185                                 if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) &&  
    186                                          (*it)->getAttachedObject(0)->getMovableType() == "Entity") 
     192                                if ((*it)->numAttachedObjects() &&  
     193                                        !(*it)->numChildren() &&  
     194                                        ((*it)->getAttachedObject(0)->getMovableType() == "Entity") && 
     195                                        (*it)->getAttachedObject(0)->isVisible()) 
    187196                                { 
    188197                                        getRenderQueue()->addRenderable((*it)); 
    … …  
    217226        Pass *usedPass = useDepthPass ? mDepthPass : pass; 
    218227                 
    219         IlluminationRenderStage savedStage = mIlluminationStage;  
     228 
     229        const IlluminationRenderStage savedStage = mIlluminationStage;  
    220230         
    221231        // set illumination stage to NONE so no shadow material is used  
    … …  
    583593                return true; 
    584594        } 
    585          
     595        if (key == "VisibilityManager") 
     596        { 
     597                * static_cast<GtpVisibility::VisibilityManager **>(val) =  
     598                        (GtpVisibility::VisibilityManager *)mVisibilityManager; 
     599                return true; 
     600        } 
     601        if (key == "HierarchInterface") 
     602        { 
     603                * static_cast<GtpVisibility::HierarchyInterface **>(val) =  
     604                        (GtpVisibility::HierarchyInterface *)mHierarchyInterface; 
     605                return true; 
     606        } 
     607 
    586608        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    587609                getOption(key, val) && TerrainSceneManager::getOption(key, val); 
    … …  
    630652} 
    631653//----------------------------------------------------------------------- 
    632 void OcclusionCullingSceneManager::renderObjects( 
    633         const QueuedRenderableCollection& objs, 
    634         QueuedRenderableCollection::OrganisationMode om, 
    635     bool doLightIteration, const LightList* manualLightList) 
    636 { 
    637         // for correct rendering, transparents must be rendered after hierarchical culling 
    638         // => do nothing 
    639         if (NORMAL_RENDER_HACK || !mSkipTransparents) 
    640         { 
    641                 OctreeSceneManager::renderObjects(objs, om, doLightIteration, manualLightList); 
    642         } 
    643 } 
     654void OcclusionCullingSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,  
     655                                                                                                                                QueuedRenderableCollection::OrganisationMode om) 
     656{ 
     657    // Basic render loop 
     658    // Iterate through priorities 
     659    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator(); 
     660 
     661    while (groupIt.hasMoreElements()) 
     662    { 
     663        RenderPriorityGroup* pPriorityGrp = groupIt.getNext(); 
     664 
     665        // Sort the queue first 
     666        pPriorityGrp->sort(mCameraInProgress); 
     667 
     668        // Do solids 
     669        renderObjects(pPriorityGrp->getSolidsBasic(), om, true); 
     670 
     671                // for correct rendering, transparents must be rendered after hierarchical culling 
     672                // => do nothing 
     673 
     674        // Do transparents (always descending) 
     675                if (NORMAL_RENDER_HACK || !mSkipTransparents) 
     676                { 
     677                        renderObjects(pPriorityGrp->getTransparents(),  
     678                        QueuedRenderableCollection::OM_SORT_DESCENDING, true); 
     679                } 
     680 
     681 
     682    }// for each priority 
     683} 
     684 
    644685//----------------------------------------------------------------------- 
    645686bool OcclusionCullingSceneManager::validatePassForRendering(Pass* pass) 
    … …  
    836877                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/ 
    837878                        // mIlluminationStage = IRS_AMBIENT;  
    838                         getRenderQueue()->setSplitPassesByLightingType(true); 
     879                        //getRenderQueue()->setSplitPassesByLightingType(true); 
    839880                } 
    840881         
    … …  
    11731214                        //-- compute new filtered cell 
    11741215                        GtpVisibilityPreprocessor::PrVs prvs; 
    1175                         mViewCellsManager->GetPrVS(viewPoint, prvs); 
     1216                        mViewCellsManager->GetPrVS(viewPoint, prvs, 5); 
    11761217                        viewCell = prvs.mViewCell; 
    11771218                } 
    … …  
    12061247} 
    12071248//----------------------------------------------------------------------- 
    1208 SceneManager* OcclusionCullingSceneManagerFactory::createInstance( 
    1209         const String& instanceName) 
    1210 { 
    1211         return new OcclusionCullingSceneManager(instanceName, visManager); 
     1249SceneManager *OcclusionCullingSceneManagerFactory::createInstance( 
     1250                const String& instanceName) 
     1251{ 
     1252        OcclusionCullingSceneManager* tsm = new OcclusionCullingSceneManager(instanceName, visManager); 
     1253         
     1254        // Create & register default sources (one per manager) 
     1255        HeightmapTerrainPageSource* ps = new HeightmapTerrainPageSource(); 
     1256        mTerrainPageSources.push_back(ps); 
     1257        tsm->registerPageSource("Heightmap", ps); 
     1258 
     1259        return tsm; 
    12121260} 
    12131261//----------------------------------------------------------------------- 

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

    r726 r925  
    44#include <vector> 
    55#include <OgreSubEntity.h> 
    6  
     6#include "OgrePlatformHierarchyInterface.h" 
    77 
    88namespace Ogre { 
    … …  
    1010//-----------------------------------------------------------------------  
    1111OcclusionQueriesQueryManager::OcclusionQueriesQueryManager( 
    12                                                         PlatformHierarchyInterface *hierarchyInterface,  
     12                                                        GtpVisibility::HierarchyInterface *hierarchyInterface,  
    1313                                                        Viewport *vp, 
    1414                                                        int queryModes, 

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

    r880 r925  
    11#include "OgreOctreeHierarchyInterface.h" 
    2 #include "OgreVisibilityOctreeSceneManager.h" 
     2//#include "OgreVisibilityOctreeSceneManager.h" 
    33#include <OgreOctree.h> 
    44#include <OgreLogManager.h> 
    … …  
    2525                RenderNode(node); 
    2626        } 
     27         
    2728         
    2829        // if not all subtrees are empty 
    … …  
    141142AxisAlignedBox *OctreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node) 
    142143{ 
    143         if (node != mSavedNode) 
     144        // reuse box if node is the same 
     145        // only create renderable bounding box for new node 
     146        if (1 || (node != mSavedNode)) 
    144147        { 
    145148                mSavedNode = node; 

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

    r903 r925  
    123123        if (mCurrentTestIdx >= (int)mOcclusionQueries.size()) 
    124124        { 
    125                 mCurrentTestIdx == (int)mOcclusionQueries.size(); 
     125                mCurrentTestIdx = (int)mOcclusionQueries.size(); 
    126126                mOcclusionQueries.push_back(new PlatformOcclusionQuery(mRenderSystem)); 
    127127        } 
    … …  
    139139 
    140140        mCamera = cam; 
     141        // set culling camera for visualization 
    141142        mCullCamera = cullCam ? cullCam : cam; 
    142143 

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

    r903 r925  
    3232        bool isAvailable = true; 
    3333 
    34         /*if (!waitForResult) 
     34        if (!waitForResult) 
     35        { 
    3536                isAvailable = !mHardwareOcclusionQuery->isStillOutstanding(); 
    36         */ 
    37 //visiblePixels = 800; 
     37                //std::stringstream d; d << "available: " << isAvailable; 
     38                //Ogre::LogManager::getSingleton().logMessage(d.str()); 
     39        } 
     40 
    3841        if (isAvailable) 
    3942                return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels); 
    40  
    41         return isAvailable; 
     43         
     44        return false; 
    4245} 
    4346 

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

    r897 r925  
    66#include <vector> 
    77#include <OgreSubEntity.h> 
    8  
     8#include "OgrePlatformHierarchyInterface.h" 
    99 
    1010namespace Ogre { 
    1111 
    1212//-----------------------------------------------------------------------  
    13 PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
     13PlatformQueryManager::PlatformQueryManager(GtpVisibility::HierarchyInterface *hierarchyInterface,  
    1414                                                                                   Viewport *vp, int queryModes): 
    1515QueryManager(hierarchyInterface, queryModes),  
    … …  
    1919} 
    2020//----------------------------------------------------------------------- 
    21 bool PlatformQueryManager::ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine) 
     21bool PlatformQueryManager::ShootRay(const Ray &ray,  
     22                                                                        std::vector<Mesh *> *visibleMeshes,  
     23                                                                        bool isGlobalLine) 
    2224{ 
    2325    // run OGRE ray shooting query 

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

    r903 r925  
    7474         mRenderOp.indexData->indexBuffer = ibuf; 
    7575         // set material with no lighting, no color, no depth write 
    76          //SetOcclusionQueryMaterial(); 
    77          setMaterial("BaseWhiteNoLighting"); 
     76         SetOcclusionQueryMaterial(); 
     77         //setMaterial("BaseWhiteNoLighting"); 
    7878} 
    7979//----------------------------------------------------------------------- 

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

    r903 r925  
    365365                InitVisibilityCulling(mCameraInProgress); 
    366366         
    367          
    368367                /**  
    369368                * the hierarchical culling algorithm 
    … …  
    411410 
    412411        // reset ambient light 
    413         //setAmbientLight(savedAmbient); 
     412        setAmbientLight(savedAmbient); 
    414413 
    415414        getRenderQueue()->clear(); // finally clear render queue 
    416         if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ... 
     415        if (1) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ... 
    417416 
    418417        if (0) WriteLog(); // write out stats 
    … …  
    595594} 
    596595//----------------------------------------------------------------------- 
    597 void VisibilityOctreeSceneManager::renderObjects( 
    598                         const QueuedRenderableCollection& objs,  
    599                         QueuedRenderableCollection::OrganisationMode om, 
    600             bool doLightIteration, const LightList* manualLightList) 
    601 { 
    602         // for correct rendering, transparents must be rendered after hierarchical culling 
    603         // => do nothing 
    604         if (NORMAL_RENDER_HACK || !mSkipTransparents) 
    605         { 
    606                 OctreeSceneManager::renderObjects(objs, om, doLightIteration, manualLightList); 
    607         } 
    608 } 
     596void VisibilityOctreeSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,  
     597                                                                                                                                QueuedRenderableCollection::OrganisationMode om) 
     598{ 
     599    // Basic render loop 
     600    // Iterate through priorities 
     601    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator(); 
     602 
     603    while (groupIt.hasMoreElements()) 
     604    { 
     605        RenderPriorityGroup* pPriorityGrp = groupIt.getNext(); 
     606 
     607        // Sort the queue first 
     608        pPriorityGrp->sort(mCameraInProgress); 
     609 
     610        // Do solids 
     611        renderObjects(pPriorityGrp->getSolidsBasic(), om, true); 
     612 
     613                // for correct rendering, transparents must be rendered after hierarchical culling 
     614                // => do nothing 
     615 
     616        // Do transparents (always descending) 
     617                if (NORMAL_RENDER_HACK || !mSkipTransparents) 
     618                { 
     619                        renderObjects(pPriorityGrp->getTransparents(),  
     620                        QueuedRenderableCollection::OM_SORT_DESCENDING, true); 
     621                } 
     622 
     623 
     624    }// for each priority 
     625} 
     626 
    609627//----------------------------------------------------------------------- 
    610628bool VisibilityOctreeSceneManager::validatePassForRendering(Pass* pass) 
    … …  
    770788        mIsDepthPassPhase = mUseDepthPass; 
    771789 
    772         mIsHierarchicalCulling = true; // during hierarchical culling 
     790        // from now on we are during hierarchical culling 
     791        mIsHierarchicalCulling = true;  
    773792 
    774793        // item buffer needs full ambient lighting to use item colors as unique id 
    … …  
    828847        // possible two cameras (one for culling, one for rendering) 
    829848        mHierarchyInterface->InitTraversal(mCameraInProgress,  
    830                                                         mCullCamera ? getCamera("CullCamera") : NULL, 
    831                                                         mLeavePassesInQueue); 
     849                                                                           mCullCamera ? getCamera("CullCamera") : NULL, 
     850                                       mLeavePassesInQueue); 
    832851                 
    833852        //std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue; 
    … …  
    11351154                        //-- compute new filtered cell 
    11361155                        GtpVisibilityPreprocessor::PrVs prvs; 
    1137                         mViewCellsManager->GetPrVS(viewPoint, prvs); 
     1156                        mViewCellsManager->GetPrVS(viewPoint, prvs, 5); 
    11381157                        viewCell = prvs.mViewCell; 
    11391158                } 

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

    r897 r925  
    1313VisibilitySceneManager::VisibilitySceneManager(const String& name,  
    1414                                                                                           GtpVisibility::VisibilityManager *visManager) 
    15 :SceneManager(name), mVisibilityManager(visManager), mUseDepthPass(false), mShowVisualization(false) 
     15:SceneManager(name),  
     16mVisibilityManager(visManager),  
     17mUseDepthPass(false),  
     18mShowVisualization(false) 
    1619{ 
    17         mHierarchyInterface =  
    18                 new SceneNodeHierarchyInterface(this, mDestRenderSystem); 
     20        mHierarchyInterface = new SceneNodeHierarchyInterface(this, mDestRenderSystem); 
    1921} 
    2022//----------------------------------------------------------------------- 

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

    r897 r925  
    2424*/ 
    2525 
    26 #include <OgreVisibilityTerrainSceneManager.h> 
    27 #include <OgreVisibilityOctreeSceneManager.h> 
    28 //#include <OgreVisibilityDotSceneManager.h> 
     26//#include <OgreVisibilityTerrainSceneManager.h> 
     27//#include <OgreVisibilityOctreeSceneManager.h> 
     28#include <OgreOcclusionCullingSceneManager.h> 
    2929 
    3030//#include <OgreHeightmapTerrainPageSource.h> 
    … …  
    4040namespace Ogre { 
    4141 
    42 VisibilityOctreeSceneManagerFactory *visibilityOctreePlugin; 
    43 VisibilityTerrainSceneManagerFactory *visibilityTerrainPlugin; 
     42//VisibilityOctreeSceneManagerFactory *visibilityOctreePlugin; 
     43//VisibilityTerrainSceneManagerFactory *visibilityTerrainPlugin; 
     44OcclusionCullingSceneManagerFactory *occlusionCullingPlugin; 
    4445 
    4546//----------------------------------------------------------------------- 
    … …  
    4748{ 
    4849        visEnv = new GtpVisibility::VisibilityEnvironment(); 
    49         visEnv->LoadEnvironment("vienna_simple.env"); 
     50        visEnv->LoadEnvironment("simple.env"); 
    5051        visManager = new GtpVisibility::VisibilityManager(visEnv); 
    5152 
    5253        // Create new scene manager 
    53         visibilityOctreePlugin = new VisibilityOctreeSceneManagerFactory(visManager); 
    54         visibilityTerrainPlugin = new VisibilityTerrainSceneManagerFactory(visManager); 
     54        //visibilityOctreePlugin = new VisibilityOctreeSceneManagerFactory(visManager); 
     55        //visibilityTerrainPlugin = new VisibilityTerrainSceneManagerFactory(visManager); 
     56        occlusionCullingPlugin = new OcclusionCullingSceneManagerFactory(visManager); 
    5557        // Construct listener manager singleton 
    5658        new TerrainPageSourceListenerManager(); 
    5759 
    5860        // Register 
    59         Root::getSingleton().addSceneManagerFactory(visibilityOctreePlugin); 
    60         Root::getSingleton().addSceneManagerFactory(visibilityTerrainPlugin); 
     61        //Root::getSingleton().addSceneManagerFactory(visibilityOctreePlugin); 
     62        //Root::getSingleton().addSceneManagerFactory(visibilityTerrainPlugin); 
     63        Root::getSingleton().addSceneManagerFactory(occlusionCullingPlugin); 
    6164} 
    6265//----------------------------------------------------------------------- 
    6366extern "C" void __declspec(dllexport) dllShutdownPlugin() 
    6467{ 
    65         Root::getSingleton().removeSceneManagerFactory(visibilityOctreePlugin); 
    66         Root::getSingleton().removeSceneManagerFactory(visibilityTerrainPlugin); 
     68        //Root::getSingleton().removeSceneManagerFactory(visibilityOctreePlugin); 
     69        //Root::getSingleton().removeSceneManagerFactory(visibilityTerrainPlugin); 
     70        Root::getSingleton().removeSceneManagerFactory(occlusionCullingPlugin); 
    6771        // destroy listener manager 
    6872        delete TerrainPageSourceListenerManager::getSingletonPtr(); 
    … …  
    7579        // (HACK: crashes on delete!!!! FIX this  
    7680        //delete visibilityOctreePlugin; 
    77         //delete visibilityTerrainPlugin; 
    78         //delete occlusionDotPlugin; 
    79          
     81    //delete visibilityTerrainPlugin; 
     82        delete occlusionCullingPlugin; 
     83 
    8084        delete visManager; 
    8185        delete visEnv; 
    … …  
    8387 
    8488 
     89 
    8590} //namespace Ogre 

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

    r903 r925  
    341341                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    342342 
     343 
    343344                // set all necessary parameters for  
    344345                // hierarchical visibility culling and rendering 
    345346                InitVisibilityCulling(mCameraInProgress); 
     347 
    346348 
    347349                /**  
    … …  
    389391        // HACK: set the new render level index, important to avoid cracks 
    390392        // in terrain caused by LOD 
    391         TerrainRenderable::NextRenderLevelIndex(); 
     393        //TerrainRenderable::NextRenderLevelIndex(); 
    392394         
    393395        // reset ambient light 
    … …  
    395397 
    396398        getRenderQueue()->clear(); // finally clear render queue 
    397         if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ... 
     399        if (1) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ... 
    398400 
    399401        if (0) WriteLog(); // write out stats 
    … …  
    547549} 
    548550//----------------------------------------------------------------------- 
    549 void VisibilityTerrainSceneManager::renderObjects( 
    550         const QueuedRenderableCollection& objs, 
    551         QueuedRenderableCollection::OrganisationMode om, 
    552         bool doLightIteration, const LightList* manualLightList) 
    553 { 
    554         // for correct rendering, transparents must be rendered after hierarchical culling 
    555         // => do nothing 
    556         if (NORMAL_RENDER_HACK || !mSkipTransparents) 
    557         { 
    558                 SceneManager::renderObjects(objs, om, doLightIteration, manualLightList); 
    559         } 
     551//----------------------------------------------------------------------- 
     552void VisibilityTerrainSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,  
     553                                                                                                                                 QueuedRenderableCollection::OrganisationMode om) 
     554{ 
     555    // Basic render loop 
     556    // Iterate through priorities 
     557    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator(); 
     558 
     559    while (groupIt.hasMoreElements()) 
     560    { 
     561        RenderPriorityGroup* pPriorityGrp = groupIt.getNext(); 
     562 
     563        // Sort the queue first 
     564        pPriorityGrp->sort(mCameraInProgress); 
     565 
     566        // Do solids 
     567        renderObjects(pPriorityGrp->getSolidsBasic(), om, true); 
     568 
     569                // for correct rendering, transparents must be rendered after hierarchical culling 
     570                // => do nothing 
     571 
     572        // Do transparents (always descending) 
     573                if (NORMAL_RENDER_HACK || !mSkipTransparents) 
     574                { 
     575                        renderObjects(pPriorityGrp->getTransparents(),  
     576                        QueuedRenderableCollection::OM_SORT_DESCENDING, true); 
     577                } 
     578 
     579 
     580    }// for each priority 
    560581} 
    561582//----------------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.