Ignore:
Timestamp:
07/28/06 17:06:01 (18 years ago)
Author:
szydlowski
Message:

continued work on the hierarchy interface

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

Legend:

Unmodified
Added
Removed

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

    r1163 r1170  
    465465                else 
    466466                { 
    467                         KdTree::Branch * branch = static_cast<KdTree::Branch *>(node); 
     467                        KdTree::Branch * branch = KDBRANCHPTR_CAST(node); 
    468468                        AxisAlignedBox aabb = rend->getBoundingBox(); 
    469469                        Plane::Side smin = branch->mSplitPlane->getSide(aabb.getMinimum()); 
    … …  
    576576                else 
    577577                { 
    578                         KdTree::Branch * parent = static_cast<KdTree::Branch *>(node->mParent); 
     578                        KdTree::Branch * parent = KDBRANCHPTR_CAST(node->mParent); 
    579579 
    580580                        if (node == parent->mLeft) 
    … …  
    619619                if (node->isLeaf()) 
    620620                { 
    621                         KdTree::Leaf * leaf = static_cast<KdTree::Leaf *>(node); 
     621                        KdTree::Leaf * leaf = KDLEAFPTR_CAST(node); 
    622622                        KdRenderableList::iterator it  = leaf->mKdRenderables.begin(); 
    623623                        KdRenderableList::iterator end = leaf->mKdRenderables.end(); 
    … …  
    630630                else 
    631631                { 
    632                         KdTree::Branch * branch = static_cast<KdTree::Branch *>(node); 
     632                        KdTree::Branch * branch = KDBRANCHPTR_CAST(node); 
    633633                        if (branch->mLeft) 
    634634                                addRendToList(branch->mLeft, nodelist); 
    … …  
    12721272        } 
    12731273 
    1274         void KdTree::queueVisibleObjects(Camera* cam, RenderQueue* queue, bool onlyShadowCasters, bool showBoxes) 
    1275         { 
     1274        void KdTree::queueVisibleObjects(Camera* cam, RenderQueue* queue, bool onlyShadowCasters,  
     1275                KdTree::RenderMethod renderMethod, bool showBoxes) 
     1276        { 
     1277                // for now only recurse or stack render methods 
    12761278                if (mKdRoot) 
    1277                         recQueueVisibleObjects(mKdRoot, Root::getSingleton().getCurrentFrameNumber(), cam, queue, onlyShadowCasters, showBoxes); 
    1278         } 
    1279  
    1280         void KdTree::recQueueVisibleObjects(KdTree::Node * node, unsigned long currentFrame, Camera* cam, RenderQueue* queue, bool onlyShadowCasters, bool showBoxes) 
     1279                { 
     1280                        //if (renderMethod == KdTree::KDRM_STACK) 
     1281                        //{ 
     1282                        //      stackQueueVisibleObjects(mKdRoot, Root::getSingleton().getCurrentFrameNumber(),  
     1283                        //              cam, queue, onlyShadowCasters, showBoxes); 
     1284                        //} 
     1285                        //else 
     1286                        //{ 
     1287                                recQueueVisibleObjects(mKdRoot, Root::getSingleton().getCurrentFrameNumber(), 
     1288                                        cam, queue, onlyShadowCasters, showBoxes); 
     1289                        //} 
     1290                } 
     1291        } 
     1292 
     1293        void KdTree::recQueueVisibleObjects(KdTree::Node * node, unsigned long currentFrame,  
     1294                Camera* cam, RenderQueue* queue, bool onlyShadowCasters, bool showBoxes) 
    12811295        { 
    12821296                // test visibility 
    … …  
    12911305                        if (node->isLeaf()) 
    12921306                        { 
    1293                                 KdTree::Leaf * leaf = static_cast<KdTree::Leaf *>(node); 
     1307                                KdTree::Leaf * leaf = KDLEAFPTR_CAST(node); 
    12941308                                KdRenderableList::iterator it  = leaf->mKdRenderables.begin(); 
    12951309                                KdRenderableList::iterator end = leaf->mKdRenderables.end(); 
    … …  
    13121326                        else 
    13131327                        { 
    1314                                 KdTree::Branch * branch = static_cast<KdTree::Branch *>(node); 
     1328                                KdTree::Branch * branch = KDBRANCHPTR_CAST(node); 
    13151329#ifdef KDTREE_DEBUG 
    13161330                                if (wbb) 
    … …  
    13251339                                if (branch->mRight) 
    13261340                                        recQueueVisibleObjects(branch->mRight, currentFrame, cam, queue, onlyShadowCasters, showBoxes); 
     1341                        } 
     1342                } 
     1343        } 
     1344 
     1345        void KdTree::stackQueueVisibleObjects(KdTree::Node * root, unsigned long currentFrame, Camera* cam, RenderQueue* queue, bool onlyShadowCasters, bool showBoxes) 
     1346        { 
     1347                static NodeStack nodestack; 
     1348                if (!nodestack.empty()) OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,  
     1349                        "Stuff left in stack from previos frame", "KdTree::stackQueueVisibleObjects"); 
     1350 
     1351                nodestack.push(root); 
     1352 
     1353                while (!nodestack.empty()) 
     1354                { 
     1355                        KdTree::Node * node = nodestack.top(); 
     1356                        nodestack.pop(); 
     1357 
     1358                        // test visibility 
     1359                        if (cam->isVisible(node->mAABB)) 
     1360                        { 
     1361        #ifdef KDTREE_DEBUG 
     1362                                WireBoundingBox * wbb = 0; 
     1363                                if (showBoxes) 
     1364                                        wbb = node->getWireBoundingBox(); 
     1365        #endif 
     1366 
     1367                                if (node->isLeaf()) 
     1368                                { 
     1369                                        KdTree::Leaf * leaf = KDLEAFPTR_CAST(node); 
     1370                                        KdRenderableList::iterator it  = leaf->mKdRenderables.begin(); 
     1371                                        KdRenderableList::iterator end = leaf->mKdRenderables.end(); 
     1372                                        while (it != end) 
     1373                                        {                        
     1374                                                if (!(*it)->isQueued(currentFrame, cam)) 
     1375                                                { 
     1376                                                        (*it)->queueObjects(cam, queue, onlyShadowCasters); 
     1377                                                } 
     1378                                                it++; 
     1379                                        } 
     1380        #ifdef KDTREE_DEBUG 
     1381                                        if (wbb) 
     1382                                                queue->addRenderable(wbb); 
     1383        #else 
     1384                                        if (showBoxes) 
     1385                                                queue->addRenderable(leaf->getWireBoundingBox()); 
     1386        #endif 
     1387                                } 
     1388                                else 
     1389                                { 
     1390                                        KdTree::Branch * branch = KDBRANCHPTR_CAST(node); 
     1391        #ifdef KDTREE_DEBUG 
     1392                                        if (wbb) 
     1393                                                queue->addRenderable(wbb); 
     1394        #else 
     1395                                        if (showBoxes) 
     1396                                                queue->addRenderable(branch->getWireBoundingBox()); 
     1397        #endif 
     1398 
     1399                                        if (branch->mLeft) 
     1400                                                nodestack.push(branch->mLeft); 
     1401                                        if (branch->mRight) 
     1402                                                nodestack.push(branch->mRight); 
     1403                                } 
    13271404                        } 
    13281405                } 
    … …  
    13511428                if (node->isLeaf()) 
    13521429                { 
    1353                         KdTree::Leaf * leaf = static_cast<KdTree::Leaf *>(node); 
     1430                        KdTree::Leaf * leaf = KDLEAFPTR_CAST(node); 
    13541431                        KdRenderableList::iterator it  = leaf->mKdRenderables.begin(); 
    13551432                        KdRenderableList::iterator end = leaf->mKdRenderables.end(); 
    … …  
    13651442                else 
    13661443                { 
    1367                         KdTree::Branch * branch = static_cast<KdTree::Branch *>(node); 
     1444                        KdTree::Branch * branch = KDBRANCHPTR_CAST(node); 
    13681445                        if (branch->mLeft) 
    13691446                        { 
    … …  
    13961473                if (node->isLeaf()) 
    13971474                { 
    1398                         KdTree::Leaf * leaf = static_cast<KdTree::Leaf *>(node); 
     1475                        KdTree::Leaf * leaf = KDLEAFPTR_CAST(node); 
    13991476                        return (PlaneEvent::surfaceArea(node->mAABB)/vs)*PlaneEvent::KI*leaf->mKdRenderables.size(); 
    14001477                } 
    14011478                else 
    14021479                { 
    1403                         KdTree::Branch * branch = static_cast<KdTree::Branch *>(node); 
     1480                        KdTree::Branch * branch = KDBRANCHPTR_CAST(node); 
    14041481                        return (PlaneEvent::surfaceArea(node->mAABB)/vs)*PlaneEvent::KT + calcCost(branch->mLeft, vs) + calcCost(branch->mRight, vs); 
    14051482                } 

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

    r1165 r1170  
    1515 
    1616KdTreeHierarchyInterface::KdTreeHierarchyInterface(KdTreeSceneManager *sm, RenderSystem *rsys): 
    17         SceneNodeHierarchyInterface(sm, rsys) 
     17PlatformHierarchyInterface(sm, rsys) 
    1818{ 
    1919 
    … …  
    2222bool KdTreeHierarchyInterface::IsLeaf(GtpVisibility::HierarchyNode *node) const 
    2323{ 
    24         KdTree::Node * kdnode = static_cast<KdTree::Node *>(node); 
    25         return kdnode->isLeaf(); 
     24        return KDNODEPTR_CAST(node)->isLeaf(); 
    2625} 
    2726 
     27void KdTreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
     28{ 
     29        ++ mNumTraversedNodes; 
    2830 
     31        KdTree::Node * kdnode = KDNODEPTR_CAST(node); 
     32 
     33        // if the node is a leaf and has geometry => render it 
     34        if (kdnode->isLeaf()) 
     35        { 
     36                if (!kdnode->isEmpty()) 
     37                { 
     38                        RenderNode(node); 
     39                } 
     40        } 
     41        else 
     42        { 
     43                KdTree::Branch * kdbranch = KDBRANCHPTR_CAST(node); 
     44                if (kdbranch->mLeft) 
     45                        mDistanceQueue->push(kdbranch->mLeft); 
     46                if (kdbranch->mRight) 
     47                        mDistanceQueue->push(kdbranch->mRight); 
     48        } 
    2949} 
     50 
     51void KdTreeHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node) 
     52{ 
     53        /*** TODO ***/ 
     54} 
     55 
     56void KdTreeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const 
     57{ 
     58        /*** TODO ***/ 
     59} 
     60 
     61float KdTreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const 
     62{ 
     63        /*** TODO ***/ 
     64        return 0.0; 
     65} 
     66 
     67AxisAlignedBox * KdTreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node) 
     68{ 
     69        /*** TODO ***/ 
     70        return new AxisAlignedBox(); 
     71} 
     72 
     73bool KdTreeHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const 
     74{ 
     75        return KDNODEPTR_CAST(node)->hasGeometry(); 
     76} 
     77 
     78void KdTreeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible) const 
     79{ 
     80        /*** TODO ***/ 
     81} 
     82 
     83bool KdTreeHierarchyInterface::IsNodeVisible(GtpVisibility::HierarchyNode *node) const 
     84{ 
     85        /*** TODO ***/ 
     86        return true; 
     87} 
     88 
     89void KdTreeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node, const unsigned int frameId) const 
     90{ 
     91        /*** TODO ***/ 
     92} 
     93 
     94unsigned int KdTreeHierarchyInterface::LastVisited(GtpVisibility::HierarchyNode *node) const 
     95{ 
     96        /*** TODO ***/ 
     97        return 0; 
     98} 
     99 
     100void KdTreeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
     101                                                                                                   GtpVisibility::CullingType type) const 
     102{ 
     103        /*** TODO ***/ 
     104} 
     105 
     106void KdTreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,  
     107                                                                                                   GtpVisibility::GeometryVector *geometryList,  
     108                                                                                                   bool includeChildren)  
     109{ 
     110        /*** TODO ***/ 
     111} 
     112 
     113} // namespace Ogre 

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

    r1165 r1170  
    3232                // kill the old kd-tree if exists  
    3333                OGRE_DELETE(mKdTree); 
     34 
     35                mRenderMethod = KdTree::KDRM_RECURSE; 
    3436 
    3537                //mBuildMethod = KdTree::KDBM_RECURSIVE; 
    … …  
    160162                        } 
    161163                } 
     164                else if (strKey == "RenderMethod") 
     165                { 
     166                        String rm = *static_cast<const String *>(pValue); 
     167                        if (rm == "Recursive") 
     168                        { 
     169                                mRenderMethod = KdTree::KDRM_RECURSE; 
     170                                return true; 
     171                        } 
     172                        else if (rm == "Stack") 
     173                        { 
     174                                mRenderMethod = KdTree::KDRM_STACK; 
     175                                return true; 
     176                        } 
     177                        else if (rm == "StopAndWait") 
     178                        { 
     179                                mRenderMethod = KdTree::KDRM_SAW; 
     180                                return true; 
     181                        } 
     182                        else if (rm == "CHC") 
     183                        { 
     184                                mRenderMethod = KdTree::KDRM_CHC; 
     185                                return true; 
     186                        } 
     187                        else 
     188                        { 
     189                                return false; 
     190                        } 
     191                } 
    162192                else if (strKey == "ShowKdTree") 
    163193                { 
    … …  
    208238                        { 
    209239                                *static_cast<String *>(pDestValue) = "Recursive"; 
     240                        } 
     241                        return true; 
     242                } 
     243                else if (strKey == "RenderMethod") 
     244                { 
     245                        if (mRenderMethod == KdTree::KDRM_RECURSE) 
     246                        { 
     247                                *static_cast<String *>(pDestValue) = "Recursive"; 
     248                        } 
     249                        else if (mRenderMethod == KdTree::KDRM_STACK) 
     250                        { 
     251                                *static_cast<String *>(pDestValue) = "Stack"; 
     252                        } 
     253                        else if (mRenderMethod == KdTree::KDRM_SAW) 
     254                        { 
     255                                *static_cast<String *>(pDestValue) = "StopAndWait"; 
     256                        } 
     257                        else if (mRenderMethod == KdTree::KDRM_CHC) 
     258                        { 
     259                                *static_cast<String *>(pDestValue) = "CHC"; 
    210260                        } 
    211261                        return true; 
    … …  
    278328                        // inserting single nodes yields sub-optimal results 
    279329                        // rebuilding tree takes too long 
    280                         // "What now", spoke Zeus ... 
     330                        // "What now?", spoke Zeus ... 
    281331 
    282332                        //mKdTree->insert(node); 
    … …  
    293343                getRenderQueue()->clear(); 
    294344                if (mKdTree) 
    295                         mKdTree->queueVisibleObjects(cam, getRenderQueue(), onlyShadowCasters, mShowBoxes); 
     345                        mKdTree->queueVisibleObjects(cam, getRenderQueue(), onlyShadowCasters, mRenderMethod, mShowBoxes); 
    296346                //SceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
    297347        } 
Note: See TracChangeset for help on using the changeset viewer.