Ignore:
Timestamp:
01/31/07 01:51:57 (17 years ago)
Author:
mattausch
Message:

worked on integration manual

Location:
GTP/trunk/Lib/Vis/OnlineCullingCHC
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r1676 r2066  
    2121typedef vector<Entity *> EntityContainer; 
    2222 
    23 class ObjectsIntersectable: public GtpVisibilityPreprocessor::IntersectableWrapper<EntityContainer *> 
     23class EngineIntersectable: public GtpVisibilityPreprocessor::IntersectableWrapper<EntityContainer *> 
    2424{ 
    2525public: 
    26         ObjectsIntersectable(EntityContainer *item): 
     26        EngineIntersectable(EntityContainer *item): 
    2727        GtpVisibilityPreprocessor::IntersectableWrapper<EntityContainer *>(item) {} 
    2828 
    2929        // hack 
    30         ObjectsIntersectable::~ObjectsIntersectable()  
    31         { 
    32                 //CLEAR_CONTAINER(*mItem); 
     30        EngineIntersectable::~EngineIntersectable()  
     31        { 
    3332                delete mItem; 
    3433        } 
    … …  
    3635        int Type() const 
    3736        { 
    38                 return Intersectable::OBJECTS_INTERSECTABLE; 
     37                return Intersectable::ENGINE_INTERSECTABLE; 
    3938        } 
    4039}; 
    … …  
    9089                                                                 vector<Entity *> &objects) const; 
    9190 
     91        /// this can be any scene manager 
    9292        T *mSceneMgr; 
    9393}; 
    … …  
    108108                 
    109109        // get intersecting scene nodes 
     110        // note: this function must be provided by scene manager 
    110111        mSceneMgr->findNodesIn(mybox, sceneNodeList, NULL); 
    111112                 
    … …  
    169170        return bestFittingObj; 
    170171} 
    171 //----------------------------------------------------------------------- 
    172 /*template<typename T> 
     172 
     173 
     174#define ENLARGE_OBJECT_BBOX 0 
     175#define ENLRAGE_NODE_BBOX 0  
     176template<typename T> 
    173177void PlatFormBoundingBoxConverter<T>::FindIntersectingObjects(const AxisAlignedBox &box, 
    174178                                                                                                                          EntityContainer &objects) const 
    175 {//return; 
     179{ 
    176180        list<SceneNode *> sceneNodeList; 
    177181                         
    178         // get intersecting scene nodes (= candidates) 
     182        // find intersecting scene nodes to get candidates for intersection 
     183    // note: this function has to be provided by scene manager 
     184#if ENLARGE_NODE_BBOX 
     185        // make search radius larger 
    179186        AxisAlignedBox mybox = EnlargeBox(box); 
    180187        mSceneMgr->findNodesIn(mybox, sceneNodeList, NULL); 
    181         //mSceneMgr->findNodesIn(box, sceneNodeList, NULL); 
    182188 
    183189        list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end(); 
    184190 
    185         GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(mybox); 
    186         //GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(box); 
    187  
    188         // find really intersecting objects 
     191        GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox =  
     192                OgreTypeConverter::ConvertFromOgre(mybox); 
     193#else 
     194 
     195        mSceneMgr->findNodesIn(box, sceneNodeList, NULL); 
     196 
     197        GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox =  
     198                OgreTypeConverter::ConvertFromOgre(box); 
     199#endif 
     200         
     201        // loop through the intersected scene nodes 
    189202        for (sit = sceneNodeList.begin(); sit != sceneNodeList.end(); ++ sit) 
    190203        { 
    … …  
    192205                SceneNode::ObjectIterator oit = sn->getAttachedObjectIterator(); 
    193206 
     207                // find the objects that intersect the box 
    194208        while (oit.hasMoreElements()) 
    195209                { 
    … …  
    198212                        // we are only interested in scene entities 
    199213                        if (mo->getMovableType() != "Entity") 
     214                                continue; 
     215                         
     216                        // get the bounding box of the objects 
     217#if ENLARGE_OBJECT_BBOX) 
     218                        // compare with enlarged entitiy box 
     219                        const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox()); 
     220#else 
     221                        const AxisAlignedBox bbox = mo->getWorldBoundingBox(); 
     222#endif 
     223 
     224                        // test for intersection (note: function provided of preprocessor) 
     225                        if (Overlap(nodeBox, OgreTypeConverter::ConvertFromOgre(bbox))) 
    200226                        { 
    201                                 continue; 
     227                                objects.push_back(static_cast<Entity *>(mo)); 
    202228                        } 
    203                           
    204                         //const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox()); 
    205                         const AxisAlignedBox bbox = mo->getWorldBoundingBox(); 
    206  
    207                         const bool overlaps = Overlap(nodeBox, 
    208                                                                                   OgreTypeConverter::ConvertFromOgre(bbox) 
    209                                                                                   ); 
    210                                                                                   //,0.00001); 
    211          
    212                          if (overlaps) 
    213                          { 
    214                                  objects.push_back(static_cast<Entity *>(mo)); 
    215                          } 
    216229                } 
    217230        } 
    218231} 
    219 */ 
    220 template<typename T> 
    221 void PlatFormBoundingBoxConverter<T>::FindIntersectingObjects(const AxisAlignedBox &box, 
    222                                                                                                                           EntityContainer &objects) const 
    223 {//return; 
    224         list<SceneNode *> sceneNodeList; 
    225                          
    226         // get intersecting scene nodes (= candidates) 
    227         //AxisAlignedBox mybox = EnlargeBox(box); 
    228         //mSceneMgr->findNodesIn(mybox, sceneNodeList, NULL); 
    229         mSceneMgr->findNodesIn(box, sceneNodeList, NULL); 
    230  
    231         list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end(); 
    232  
    233         //GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(mybox); 
    234         GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(box); 
    235  
    236         // find really intersecting objects 
    237         for (sit = sceneNodeList.begin(); sit != sceneNodeList.end(); ++ sit) 
    238         { 
    239                 SceneNode *sn = *sit; 
    240                 SceneNode::ObjectIterator oit = sn->getAttachedObjectIterator(); 
    241  
    242         while (oit.hasMoreElements()) 
    243                 { 
    244                         MovableObject *mo = oit.getNext(); 
    245  
    246                         // we are only interested in scene entities 
    247                         if (mo->getMovableType() != "Entity") 
    248                         { 
    249                                 continue; 
    250                         } 
    251                           
    252                         //const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox()); 
    253                         const AxisAlignedBox bbox = mo->getWorldBoundingBox(); 
    254  
    255                         const bool overlaps =  
    256                                 Overlap(nodeBox, OgreTypeConverter::ConvertFromOgre(bbox)); 
    257                                                                                  
    258          
    259                          if (overlaps) 
    260                          { 
    261                                  objects.push_back(static_cast<Entity *>(mo)); 
    262                          } 
    263                 } 
    264         } 
    265 } 
    266232#if USE_KD_PVS 
    267 //------------------------------------------------------------------------- 
    268 template<typename T> 
    269 bool PlatFormBoundingBoxConverter<T>::IdentifyObjects( 
    270         const GtpVisibilityPreprocessor::IndexedBoundingBoxContainer &iboxes, 
    271         GtpVisibilityPreprocessor::ObjectContainer &objects) const 
    272 { 
    273         //Ogre::LogManager().logMessage("pvs: intersecting objects"); 
    274         const long startTime = GtpVisibilityPreprocessor::GetTime(); 
    275  
    276         GtpVisibilityPreprocessor::IndexedBoundingBoxContainer:: 
    277                 const_iterator iit, iit_end = iboxes.end(); 
    278    
    279         int i = 0; 
    280  
    281         for (iit = iboxes.begin(); iit != iit_end; ++ iit, ++ i) 
    282         { 
    283                 if (0 && ((i % 1000) == 0)) 
    284                 { 
    285                         std::stringstream d; d << "found " << i << " objects"; 
    286                         Ogre::LogManager().getSingleton().logMessage(d.str()); 
    287                 } 
    288  
    289                 const AxisAlignedBox box = OgreTypeConverter::ConvertToOgre((*iit).second); 
    290                  
    291                 //GtpVisibilityPreprocessor::ObjectContainer *entryObjects = new EntityContainer(); 
    292                 EntityContainer *entryObjects = new EntityContainer(); 
    293  
    294                 // find all objects that intersect the bounding box 
    295                 FindIntersectingObjects(box, *entryObjects); 
    296  
    297                 /*vector<Entity *>::const_iterator mit, mit_end = sceneObjects.end(); 
    298                  
    299                 for (mit = sceneObjects.begin(); mit != mit_end; ++ mit) 
    300                 { 
    301                         Entity *ent = *mit; 
    302                         // create new mesh instance 
    303                         OgreMeshInstance *omi = new OgreGetOrCreateOgreMeshInstance(ent); 
    304                         //omi->SetId((*iit).first); 
    305                         entryObjects->push_back(omi); 
    306                 }*/ 
    307  
    308                 ObjectsIntersectable *entry =  
    309                         new ObjectsIntersectable(entryObjects); 
    310                 entry->SetId((*iit).first); 
    311                 //kdObj->mBbox = (*iit).second; 
    312                 objects.push_back(entry); 
    313         } 
    314  
    315         //std::stringstream d; d << "finished object intersection in " << GtpVisibilityPreprocessor::TimeDiff(startTime, GtpVisibilityPreprocessor::GetTime()) * 1e-3 << "secs"; 
    316         //Ogre::LogManager().logMessage(d.str()); 
    317  
    318         return true; 
    319 } 
    320 #else 
    321233//------------------------------------------------------------------------- 
    322234template<typename T> 
    … …  
    330242        for (iit = iboxes.begin(); iit != iit_end; ++ iit) 
    331243        { 
     244                const AxisAlignedBox box =  
     245                        OgreTypeConverter::ConvertToOgre((*iit).second); 
     246                 
     247                EntityContainer *entryObjects = new EntityContainer(); 
     248 
     249                // find all objects that intersect the bounding box 
     250                FindIntersectingObjects(box, *entryObjects); 
     251 
     252                EngineIntersectable *entry =  
     253                        new EngineIntersectable(entryObjects); 
     254                entry->SetId((*iit).first); 
     255 
     256                objects.push_back(entry); 
     257        } 
     258 
     259        return true; 
     260} 
     261#else 
     262//------------------------------------------------------------------------- 
     263template<typename T> 
     264bool PlatFormBoundingBoxConverter<T>::IdentifyObjects( 
     265        const GtpVisibilityPreprocessor::IndexedBoundingBoxContainer &iboxes, 
     266        GtpVisibilityPreprocessor::ObjectContainer &objects) const 
     267{ 
     268        GtpVisibilityPreprocessor::IndexedBoundingBoxContainer:: 
     269                const_iterator iit, iit_end = iboxes.end(); 
     270   
     271        for (iit = iboxes.begin(); iit != iit_end; ++ iit) 
     272        { 
    332273                const GtpVisibilityPreprocessor::AxisAlignedBox3 box = (*iit).second; 
    333274                const AxisAlignedBox currentBox = OgreTypeConverter::ConvertToOgre(box); 
    334275    
    335276                Entity *ent = FindBestFittingObject(currentBox); 
    336  
    337                 if (ent) 
    338                 { 
    339                         // create new mesh instance 
    340                         OgreMeshInstance *omi = new OgreMeshInstance(ent); 
    341                         omi->SetId((*iit).first); 
    342                         objects.push_back(omi); 
    343                 } 
     277                if (!ent) continue; 
     278                 
     279                // create new mesh instance 
     280                OgreMeshInstance *omi = new OgreMeshInstance(ent); 
     281                omi->SetId((*iit).first); 
     282                objects.push_back(omi); 
    344283        } 
    345284 

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

    r1593 r2066  
    1010        Wrapper for Ogre object intances for use with the preprocessed view cells. 
    1111*/ 
     12#if 0 
    1213class __declspec(dllexport) OgreMeshInstance: public GtpVisibilityPreprocessor::Intersectable 
    1314{ 
    … …  
    5657}; 
    5758 
     59 
    5860} // namespace Ogre 
    59  
     61#endif 
    6062#endif // OgreMeshIntance 

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

    r1344 r2066  
    15361536                        it != leaf->mBvhRenderables.end(); it ++) 
    15371537                { 
    1538                         SceneNode *sn = dynamic_cast<SceneNode *>(*it); 
     1538                        SceneNode *sn = static_cast<SceneNode *>(*it); 
    15391539 
    15401540                        if (sn != exclude) 
    … …  
    16181618                while (it != end) 
    16191619                { 
    1620                         scenenode = dynamic_cast<BvHierarchySceneNode *>(*it); 
     1620                        scenenode = static_cast<BvHierarchySceneNode *>(*it); 
    16211621                        mBuildLog->logMessage(pad + "# Leaf   level " +  
    16221622                                StringConverter::toString(node->getLevel()) +  

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

    r1320 r2066  
    132132        } 
    133133 
    134         dynamic_cast<BvHierarchySceneManager *>(mSceneManager)->getRenderQueue()->addRenderable(box); 
     134        static_cast<BvHierarchySceneManager *>(mSceneManager)->getRenderQueue()->addRenderable(box); 
    135135} 
    136136 

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

    r1816 r2066  
    13571357                if (entry.mObject) 
    13581358                { 
    1359                         OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(entry.mObject); 
     1359                        OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(entry.mObject); 
    13601360                        omi->GetEntity()->setVisible(load); 
    13611361                } 

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

    r1593 r2066  
    15281528                        it != leaf->mKdRenderables.end(); it ++) 
    15291529                { 
    1530                         SceneNode *sn = dynamic_cast<SceneNode *>(*it); 
     1530                        SceneNode *sn = static_cast<SceneNode *>(*it); 
    15311531 
    15321532                        if (sn != exclude) 
    … …  
    16061606                while (it != end) 
    16071607                { 
    1608                         scenenode = dynamic_cast<KdTreeSceneNode *>(*it); 
     1608                        scenenode = static_cast<KdTreeSceneNode *>(*it); 
    16091609                        mBuildLog->logMessage(pad + "# Leaf   level " +  
    16101610                                StringConverter::toString(node->getLevel()) +  

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

    r1304 r2066  
    132132        } 
    133133 
    134         dynamic_cast<KdTreeSceneManager *>(mSceneManager)->getRenderQueue()->addRenderable(box); 
     134        static_cast<KdTreeSceneManager *>(mSceneManager)->getRenderQueue()->addRenderable(box); 
    135135} 
    136136 

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

    r1816 r2066  
    13461346        ////////// 
    13471347        //-- set PVS of view cell visible 
     1348 
    13481349        GtpVisibilityPreprocessor::ObjectPvsIterator pit = vc->GetPvs().GetIterator(); 
    13491350 
    … …  
    13541355                if (entry.mObject) 
    13551356                { 
    1356                         OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(entry.mObject); 
     1357                        OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(entry.mObject); 
    13571358                        omi->GetEntity()->setVisible(load); 
    13581359                } 

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

    r1593 r2066  
    44namespace Ogre 
    55{ 
    6  
    76        OgreMeshInstance::OgreMeshInstance(Entity *ent): 
    87        GtpVisibilityPreprocessor::Intersectable(), mEntity(ent) 
    … …  
    7473                return s; 
    7574        } 
    76          
    7775} 

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

    r1823 r2066  
    2828 
    2929//----------------------------------------------------------------------- 
    30 OcclusionCullingSceneManager::OcclusionCullingSceneManager(const String& name,  
    31                                                         GtpVisibility::VisibilityManager *visManager): 
     30OcclusionCullingSceneManager::OcclusionCullingSceneManager( 
     31                                                                const String& name,  
     32                                                                GtpVisibility::VisibilityManager *visManager): 
    3233TerrainSceneManager(name), 
    3334mVisibilityManager(visManager),  
    … …  
    432433 
    433434                        if (obj->Type() ==  
    434                                 GtpVisibilityPreprocessor::Intersectable::OBJECTS_INTERSECTABLE) 
     435                                GtpVisibilityPreprocessor::Intersectable::ENGINE_INTERSECTABLE) 
    435436                        { 
    436                                 ObjectsIntersectable *oi = dynamic_cast<ObjectsIntersectable *>(obj); 
     437                                EngineIntersectable *oi = static_cast<EngineIntersectable *>(obj); 
    437438 
    438439                                EntityContainer *entries = oi->GetItem(); 
    … …  
    457458                        case GtpVisibilityPreprocessor::Intersectable::OGRE_MESH_INSTANCE: 
    458459                                { 
    459                                         OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(obj); 
     460                                        OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(obj); 
    460461                                        omi->GetEntity()->_updateRenderQueue(getRenderQueue()); 
    461462                                } 
    462463                                break; 
    463464 
    464                         case GtpVisibilityPreprocessor::Intersectable::OBJECTS_INTERSECTABLE: 
     465                        case GtpVisibilityPreprocessor::Intersectable::ENGINE_INTERSECTABLE: 
    465466                                { 
    466                                         ObjectsIntersectable *oi = dynamic_cast<ObjectsIntersectable *>(obj); 
     467                                        EngineIntersectable *oi = static_cast<EngineIntersectable *>(obj); 
    467468 
    468469                                        EntityContainer *entries = oi->GetItem(); 
    … …  
    471472                                        for (eit = entries->begin(); eit != eit_end; ++ eit) 
    472473                                        { 
    473                                                 //OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(*eit); 
     474                                                //OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(*eit); 
    474475                                                Entity *ent = *eit; 
    475476                                                Any newAny = ent->getUserAny(); 
    … …  
    13941395                        case GtpVisibilityPreprocessor::Intersectable::OGRE_MESH_INSTANCE: 
    13951396                                { 
    1396                                         OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(entry); 
     1397                                        OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(entry); 
    13971398                                        omi->GetEntity()->setVisible(visible); 
    13981399                                        //GtpVisibilityPreprocessor::Debug << "assigned id " << omi->GetId() << endl; 
    13991400                                } 
    14001401                                break; 
    1401                         case GtpVisibilityPreprocessor::Intersectable::OBJECTS_INTERSECTABLE: 
     1402                        case GtpVisibilityPreprocessor::Intersectable::ENGINE_INTERSECTABLE: 
    14021403                                { 
    1403                                         //GtpVisibilityPreprocessor::ObjectsIntersectable *oi =  
    1404                                         //      dynamic_cast<GtpVisibilityPreprocessor::ObjectsIntersectable *>(entry); 
    1405                                         ObjectsIntersectable *oi = dynamic_cast<ObjectsIntersectable *>(entry); 
    1406  
    1407                                         //GtpVisibilityPreprocessor::ObjectContainer *entries = oi->GetItem(); 
     1404                                        EngineIntersectable *oi = static_cast<EngineIntersectable *>(entry); 
     1405 
    14081406                                        EntityContainer *entries = oi->GetItem(); 
    14091407                                        EntityContainer::const_iterator eit, 
    … …  
    14111409                                        for (eit = entries->begin(); eit != eit_end; ++ eit) 
    14121410                                        { 
    1413                                                 //OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(*eit); 
    14141411                                                Entity *ent = *eit; 
    14151412                                                ent->setVisible(visible); 
    1416                                                 //GtpVisibilityPreprocessor::Debug << "assigned id " << omi->GetId() << endl; 
    14171413                                        } 
    14181414                                } 
    … …  
    14841480                        case GtpVisibilityPreprocessor::Intersectable::OGRE_MESH_INSTANCE: 
    14851481                                { 
    1486                                         OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(obj); 
     1482                                        OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(obj); 
    14871483                                        omi->GetEntity()->setVisible(load); 
    14881484                                        //GtpVisibilityPreprocessor::Debug << "assigned id " << omi->GetId() << endl; 
    14891485                                } 
    14901486                                break; 
    1491                         case GtpVisibilityPreprocessor::Intersectable::OBJECTS_INTERSECTABLE: 
     1487                        case GtpVisibilityPreprocessor::Intersectable::ENGINE_INTERSECTABLE: 
    14921488                                { 
    1493                                         //GtpVisibilityPreprocessor::ObjectsIntersectable *oi =  
    1494                                         //      dynamic_cast<GtpVisibilityPreprocessor::ObjectsIntersectable *>(entry); 
    1495                                         ObjectsIntersectable *oi = dynamic_cast<ObjectsIntersectable *>(obj); 
     1489                                        //GtpVisibilityPreprocessor::EngineIntersectable *oi =  
     1490                                        //      static_cast<GtpVisibilityPreprocessor::EngineIntersectable *>(entry); 
     1491                                        EngineIntersectable *oi = static_cast<EngineIntersectable *>(obj); 
    14961492 
    14971493                                        //GtpVisibilityPreprocessor::ObjectContainer *entries = oi->GetItem(); 
    … …  
    15021498                                        for (eit = entries->begin(); eit != eit_end; ++ eit) 
    15031499                                        { 
    1504                                                 //OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>(*eit); 
     1500                                                //OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(*eit); 
    15051501                                                //omi->GetEntity()->setVisible(load); 
    15061502                                                Entity *ent = *eit; 

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

    r1602 r2066  
    2727        // we need access to the scene manager and the rendersystem 
    2828        PlatformHierarchyInterface *pfHierarchyInterface =  
    29                 //dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
     29                //static_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    3030                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    3131 

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

    r944 r2066  
    116116                octant->setLastRendered(mFrameId); 
    117117                OctreeSceneManager *ocm =  
    118                         dynamic_cast<OctreeSceneManager *>(mSceneManager); 
     118                        static_cast<OctreeSceneManager *>(mSceneManager); 
    119119 
    120120                ocm->_renderOctant(mCamera, octant, mOnlyShadowCasters, mLeavePassesInQueue); 
    … …  
    172172        } 
    173173 
    174         //dynamic_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box); 
    175         dynamic_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box); 
     174        //static_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box); 
     175        static_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box); 
    176176} 
    177177//----------------------------------------------------------------------- 

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

    r925 r2066  
    3333                               bool relativeVisibility) 
    3434{ 
    35         SceneManager *sm = //dynamic_cast<PlatformHierarchyInterface *> 
     35        SceneManager *sm = //static_cast<PlatformHierarchyInterface *> 
    3636                static_cast<PlatformHierarchyInterface *> 
    3737                (mHierarchyInterface)->GetSceneManager(); 
    … …  
    9696        // we need access to the scene manager and the rendersystem 
    9797        PlatformHierarchyInterface *pfHierarchyInterface =  
    98                 //dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
     98                //static_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    9999                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    100100 
    … …  
    195195 
    196196        SceneManager *sm =  
    197                 //dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager(); 
     197                //static_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager(); 
    198198                static_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager(); 
    199199 

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

    r925 r2066  
    115115                VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
    116116        { 
    117                 dynamic_cast<CoherentHierarchicalCullingManager *>(mCullingManager)-> 
     117                static_cast<CoherentHierarchicalCullingManager *>(mCullingManager)-> 
    118118                                SetAssumedVisibility(assumedVisibility); 
    119119        } 
Note: See TracChangeset for help on using the changeset viewer.