Changeset 155 for trunk/VUT/Ogre


Ignore:
Timestamp:
07/05/05 18:35:47 (19 years ago)
Author:
mattausch
Message:

added node traversal interface

Location:
trunk/VUT/Ogre
Files:
16 edited

Legend:

Unmodified
Added
Removed

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

    r154 r155  
    2222        /** Traverses given node. 
    2323                @param node current node 
    24                 @remark pushes children on distance queue 
     24                @remark pushes children on the distance queue 
    2525        */ 
    26         void TraverseNode(GtpVisibility::HierarchyNode *node); 
     26        void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
    2727        void RenderNode(GtpVisibility::HierarchyNode *node); 
    2828        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 

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

    r154 r155  
    2929        /** Traverses given node. 
    3030                @param node current node 
    31                 @remark pushes children on distance queue 
     31                @remark pushes children on a distance queue. 
    3232        */ 
    33         void TraverseNode(GtpVisibility::HierarchyNode *node); 
     33        void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
    3434        void RenderNode(GtpVisibility::HierarchyNode *node); 
    3535        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 
    … …  
    4646                                                         GtpVisibility::CullingType type); 
    4747 
    48         /*bool FindVisibleObjects(GtpVisibility::HierarchyNode *node,    
    49                                                         InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
    50                                                         bool includeChildren = false);*/ 
    51  
    52         void GetGeometry(GtpVisibility::HierarchyNode *node, 
     48        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node, 
    5349                                         GtpVisibility::GeometryList *geometryList,  
    5450                                         bool includeChildren); 
    … …  
    5753         
    5854        int GetNodeId(GtpVisibility::HierarchyNode *node); 
     55 
     56        GtpVisibility::HierarchyNode *GetNextNode(); 
    5957 
    6058protected: 
    … …  
    6967        */ 
    7068        Real GetSquaredViewDepth(const Camera* cam, const AxisAlignedBox* box) const; 
     69 
     70        int mCurrentOctreePosition; 
    7171}; 
    7272} // namespace Ogre 

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

    r139 r155  
    4747                @remark This is a convenience method which resets the stats,  
    4848                                sets the current camera, and initialises the distance queue. 
    49                 @param root root of the hierarchy 
    5049                @param cam the actual camera definding the view frustum 
    5150                @param cullCam the camera used for culling.  
    52                 @remark If null, the actual camera is used for both viewing and culling          
     51                @remark If cullCam is null, the actual camera is used for both viewing and culling               
    5352        */ 
    54         void InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam, Camera *cullCam = NULL,  
    55                 int leavePassesInQueue = 0); 
     53        void InitTraversal(Camera *cam, Camera *cullCam = NULL, int leavePassesInQueue = 0); 
    5654        /** Checks if the node is visible from the current view frustum. 
    5755                @param node the current node 
    … …  
    9593        /** see set  
    9694        */ 
    97         bool GetUseOptimization(); 
     95        bool GetTestGeometryForVisibleLeaves(); 
    9896        /** see set 
    9997        */ 

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

    r154 r155  
    2424        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 
    2525         
    26         void TraverseNode(GtpVisibility::HierarchyNode *node); 
     26        void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
    2727        void RenderNode(GtpVisibility::HierarchyNode *node); 
    2828        void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
    … …  
    4646                                                        bool includeChildren = false);*/ 
    4747         
    48         void GetGeometry(GtpVisibility::HierarchyNode *node,     
     48        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
    4949                                         GtpVisibility::GeometryList *geometryList,  
    5050                                         bool includeChildren); 
    … …  
    5353         
    5454        int GetNodeId(GtpVisibility::HierarchyNode *node); 
     55 
     56        GtpVisibility::HierarchyNode *GetNextNode(); 
    5557}; 
    5658 

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

    r153 r155  
    122122        int mLeavePassesInQueue; 
    123123        ShadowTechnique mSavedShadowTechnique; 
     124 
     125        bool mRenderOnlyBoundingBoxes; 
    124126}; 
    125127 

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

    r147 r155  
    2222                left 5  
    2323                top 5 
    24                 width 400 
     24                width 430 
    2525                height 90 
    2626                material Core/StatsBlockCenter 
    … …  
    4646                element TextArea(Example/Visibility/AlgorithmInfo): Example/Visibility/Templates/BasicText 
    4747                { 
    48                         left 170 
     48                        left 210 
    4949                        top 5 
    50                         width 90 
     50                        width 120 
    5151                        height 30 
    5252                        caption : 
    … …  
    5757                        left 5 
    5858                        top 20 
    59                         width 90 
     59                        width 120 
    6060                        height 30 
    6161                        caption [-][+] Threshold 
    … …  
    6363                element TextArea(Example/Visibility/ThresholdInfo): Example/Visibility/Templates/BasicText 
    6464                { 
    65                         left 170 
     65                        left 210 
    6666                        top 20 
    67                         width 90 
    68                         height 30 
    69                         caption : 
    70                 } 
    71                 element TextArea(Example/Visibility/UseOptimization): Example/Visibility/Templates/BasicText 
     67                        width 120 
     68                        height 30 
     69                        caption : 
     70                } 
     71                element TextArea(Example/Visibility/TestGeometryForVisibleLeaves): Example/Visibility/Templates/BasicText 
    7272                { 
    7373                        left 5 
    7474                        top 35 
    75                         width 90 
    76                         height 30 
    77                         caption [O] Optimization 
    78                 } 
    79                 element TextArea(Example/Visibility/UseOptimizationInfo): Example/Visibility/Templates/BasicText 
    80                 { 
    81                         left 170 
     75                        width 120 
     76                        height 30 
     77                        caption [G] Test Geometry For Leaves 
     78                } 
     79                element TextArea(Example/Visibility/TestGeometryForVisibleLeavesInfo): Example/Visibility/Templates/BasicText 
     80                { 
     81                        left 210 
    8282                        top 35 
    83                         width 90 
     83                        width 120 
    8484                        height 30 
    8585                        caption : 
    … …  
    8989                        left 5 
    9090                        top 50 
    91                         width 90 
     91                        width 120 
    9292                        height 30 
    9393                        caption [X] Depth pass 
    … …  
    9595                element TextArea(Example/Visibility/UseDepthPassInfo): Example/Visibility/Templates/BasicText 
    9696                { 
    97                         left 170 
     97                        left 210 
    9898                        top 50 
    99                         width 90 
     99                        width 120 
    100100                        height 30 
    101101                        caption : 
    … …  
    105105                        left 5 
    106106                        top 65 
    107                         width 90 
     107                        width 120 
    108108                        height 30 
    109109                        caption [8][9] Assumed Visibility 
    … …  
    112112                element TextArea(Example/Visibility/AssumedVisibilityInfo): Example/Visibility/Templates/BasicText 
    113113                { 
    114                         left 170 
     114                        left 210 
    115115                        top 65 
    116                         width 90 
     116                        width 120 
    117117                        height 30 
    118118                        caption : 
    … …  
    128128                top 5 
    129129                width 320 
    130                 height 120 
     130                height 150 
    131131                material Core/StatsBlockCenter 
    132132                border_size 1 1 1 1 
    … …  
    249249                        left 180 
    250250                        top 95 
     251                        width 90 
     252                        font_name TrebuchetMSBold 
     253                        caption :                        
     254                }                
     255                element TextArea(Example/Visibility/DelayedQueriesIssued): Example/Visibility/Templates/BasicText 
     256                { 
     257                        left 5 
     258                        top 110 
     259                        width 180 
     260                        height 30 
     261                        caption Avg. queries issued  
     262                }        
     263                element TextArea(Example/Visibility/DelayedQueriesIssuedInfo): Example/Visibility/Templates/BasicText 
     264                { 
     265                        left 180 
     266                        top 110 
     267                        width 90 
     268                        font_name TrebuchetMSBold 
     269                        caption :                        
     270                }                
     271                element TextArea(Example/Visibility/DelayedTraversedNodes): Example/Visibility/Templates/BasicText 
     272                { 
     273                        left 5 
     274                        top 125 
     275                        width 180 
     276                        height 30 
     277                        caption Avg. traversed Nodes 
     278                }        
     279                element TextArea(Example/Visibility/DelayedTraversedNodesInfo): Example/Visibility/Templates/BasicText 
     280                { 
     281                        left 180 
     282                        top 125 
    251283                        width 90 
    252284                        font_name TrebuchetMSBold 

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

    r87 r155  
    1212} 
    1313//----------------------------------------------------------------------- 
    14 void BspHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
     14void BspHierarchyInterface::TraverseAndRenderNode(GtpVisibility::HierarchyNode *node) 
    1515{ 
    1616} 

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

    r154 r155  
    3232        SceneManager *sm = pfHierarchyInterface->GetSceneManager(); 
    3333 
    34         //-- Render scene as item buffer (e.g., color coded objects) 
     34        // ---- Render scene as item buffer (i.e., objects with their id as color codes) 
    3535 
    3636        // const_cast allowed because camera is not changed in renderScene 
    … …  
    4949        mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0)); 
    5050 
    51         //pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR); 
    52         // render item buffer 
     51 
     52        // --- render item buffer 
    5353        pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
    5454         
     55 
     56 
    5557        // reset old overlay status 
    5658        mViewport->setOverlaysEnabled(overlayEnabled); 
    … …  
    8486                        ((*visibleGeometry)[id]).AddVisibility(1, 1); 
    8587                } 
    86                 /*else {        std::stringstream d;  
    87                         d << "adding pixel to geometry with id: " << id << ", buf 1: " << (int)buf[idx] << ", buf 2: " << (int)buf[idx + 1] << ", buf 3: " << (int)buf[idx + 2]; 
    88                         LogManager::getSingleton().logMessage(d.str()); }*/ 
    8988        } 
    9089 
    … …  
    101100                return; 
    102101 
     102 
    103103        mWasInitialised = true; 
    104104 
    105         SceneManager::EntityIterator it =  
    106                 dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)-> 
    107                 GetSceneManager()->getEntityIterator(); 
     105        SceneManager *sm =  
     106                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager(); 
     107 
     108        SceneManager::EntityIterator it = sm->getEntityIterator(); 
    108109 
    109110        // TODO: make this more efficient 
    … …  
    115116                visibleGeometry->push_back(GtpVisibility::MeshInfo(it.getNext(), 0, 0)); 
    116117        } 
     118 
     119        // -- initialise hierarchy interface for simple node traversal 
     120        mHierarchyInterface->InitTraversal(false); 
     121 
     122        GtpVisibility::HierarchyNode *node = NULL; 
     123         
     124        while (node = mHierarchyInterface->GetNextNode()) 
     125        { 
     126                visibleNodes->push_back(GtpVisibility::NodeInfo(node, 0, 0)); 
     127        } 
    117128} 
     129 
    118130} // namespace Ogre 

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

    r154 r155  
    8383                        if (i == 0) 
    8484                        { 
    85                                 mHierarchyInterface->GetGeometry(*nodeIt, &geometryList, false); 
     85                                mHierarchyInterface->GetNodeGeometryList(*nodeIt, &geometryList, false); 
    8686                        } 
    8787                } 
    … …  
    105105        mViewport->setOverlaysEnabled(overlayEnabled); 
    106106 
    107         //---- collect results 
     107        // ---- collect results 
    108108        GtpVisibility::QueryList::iterator visQueryIt, projQueryIt; 
    109109 
    … …  
    135135        } 
    136136 
    137         //---- queries for geometry 
     137        // ---- queries for geometry 
    138138        geometryIt_end = geometryList.end(); 
    139139         
    … …  
    154154                ++visQueryIt; 
    155155 
    156                 // approximate depth ordering during rendering =>  
     156                // WARNING: approximate depth ordering during rendering =>  
    157157                // geometry maybe occluded 
    158158                if (visiblePixels > 0) 

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

    r154 r155  
    1010//----------------------------------------------------------------------- 
    1111OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, RenderSystem *rsys):  
    12 SceneNodeHierarchyInterface(sm, rsys) 
    13 { 
    14 } 
    15 //----------------------------------------------------------------------- 
    16 void OctreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
     12SceneNodeHierarchyInterface(sm, rsys), mCurrentOctreePosition(0) 
     13{ 
     14} 
     15//----------------------------------------------------------------------- 
     16void OctreeHierarchyInterface::TraverseAndRenderNode(GtpVisibility::HierarchyNode *node) 
    1717{ 
    1818        ++ mNumTraversedNodes; 
    … …  
    8484        Octree *octant = static_cast<Octree *>(node); 
    8585 
    86         while(octant && !octant->isOctreeVisible()) 
     86        while (octant && !octant->isOctreeVisible()) 
    8787        { 
    8888                octant->setOctreeVisible(true); 
    … …  
    129129AxisAlignedBox *OctreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node) 
    130130{ 
    131         if (node != mPreviousNode)       
    132         { 
    133                 mPreviousNode = node; 
     131        if (node != mSavedNode) 
     132        { 
     133                mSavedNode = node; 
    134134            //static_cast<Octree *>(node)->_getCullBounds(&mBox); 
    135135                mBox = static_cast<Octree *>(node)->_getWorldAABB(); 
    136                 //std::stringstream d; d << mBox;LogManager::getSingleton().logMessage(d.str());  
    137136        } 
    138137 
    … …  
    157156} 
    158157//----------------------------------------------------------------------- 
    159 void OctreeHierarchyInterface::GetGeometry(GtpVisibility::HierarchyNode *node,   
     158void OctreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,   
    160159                                                                                   GtpVisibility::GeometryList *geometryList,  
    161160                                                                                   bool includeChildren) 
    … …  
    166165        for (nodeIt = static_cast<Octree *>(node)->mNodes.begin(); nodeIt != nodeIt_end; ++nodeIt) 
    167166        { 
    168                 SceneNodeHierarchyInterface::GetGeometry(*nodeIt, geometryList, includeChildren); 
     167                SceneNodeHierarchyInterface::GetNodeGeometryList(*nodeIt, geometryList, includeChildren); 
    169168        } 
    170169} 
    … …  
    180179} 
    181180//----------------------------------------------------------------------- 
    182 /*bool OctreeHierarchyInterface::FindVisibleObjects(GtpVisibility::HierarchyNode *node,  
    183                                                                         InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
    184                                                                         bool includeChildren) 
    185 { 
    186         bool foundVisible = false; 
    187  
    188         PlatformOcclusionQuery query(mRenderSystem); 
    189  
    190         NodeList *nodes = &static_cast<Octree *>(node)->mNodes; 
     181GtpVisibility::HierarchyNode *OctreeHierarchyInterface::GetNextNode() 
     182{ 
     183        if (mTraversalStack->empty()) 
     184                return NULL; 
    191185         
    192         NodeList::const_iterator nodeIt = nodes->begin(), nodeIt_end; 
    193          
    194         nodeIt_end = nodes->end(); 
    195  
    196         while (nodeIt != nodeIt_end) 
    197         { 
    198                 OctreeNode *octreeNode = (*nodeIt); 
    199                 if (SceneNodeHierarchyInterface::FindVisibleObjects(octreeNode, visibleGeometry, includeChildren)) 
     186        Octree *octree = static_cast<Octree *>(mTraversalStack->top()); 
     187        mTraversalStack->pop(); 
     188                 
     189        for(int i=0; i<8; ++i) 
     190        { 
     191                Octree *nextChild =  
     192                        octree->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1]; 
     193 
     194                if (nextChild) 
    200195                { 
    201                         foundVisible = true; 
     196                        mTraversalStack->push(nextChild); 
    202197                } 
    203                 ++nodeIt; 
    204         } 
    205  
    206         return foundVisible; 
    207 }*/ 
    208  
     198        } 
     199 
     200        return octree; 
     201}  
     202                 
    209203} // namespace Ogre 

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

    r139 r155  
    130130} 
    131131//----------------------------------------------------------------------- 
    132 void PlatformHierarchyInterface::InitFrame(GtpVisibility::HierarchyNode *root,  
    133                                                                                    Camera *cam, Camera *cullCam, int leavePassesInQueue) 
    134 { 
    135         GtpVisibility::HierarchyInterface::InitFrame(root); 
    136          
    137         mPreviousNode = NULL; 
     132void PlatformHierarchyInterface::InitTraversal(Camera *cam, Camera *cullCam, int leavePassesInQueue) 
     133{ 
     134        GtpVisibility::HierarchyInterface::InitTraversal(); 
     135         
     136        mSavedNode = NULL; 
    138137        mLeavePassesInQueue = leavePassesInQueue; 
    139138 
    … …  
    178177        // If camera for culling is different from camera for rendering or only solids  
    179178        // will be rendereded => cannot optimize 
    180         if (mUseOptimization && (mCamera == mCullCamera) && wasVisible && IsLeaf(node))  
     179        if (mTestGeometryForVisibleLeaves && (mCamera == mCullCamera) && wasVisible && IsLeaf(node))  
    181180        { 
    182181                //LogManager::getSingleton().logMessage("render node\n"); 
    … …  
    253252} 
    254253//----------------------------------------------------------------------- 
    255 bool PlatformHierarchyInterface::GetUseOptimization() 
    256 { 
    257         return mUseOptimization; 
     254bool PlatformHierarchyInterface::GetTestGeometryForVisibleLeaves() 
     255{ 
     256        return mTestGeometryForVisibleLeaves; 
    258257} 
    259258//----------------------------------------------------------------------- 

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

    r154 r155  
    1717} 
    1818//----------------------------------------------------------------------- 
    19 void SceneNodeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
     19void SceneNodeHierarchyInterface::TraverseAndRenderNode(GtpVisibility::HierarchyNode *node) 
    2020{ 
    2121        ++ mNumTraversedNodes; 
    … …  
    121121{ 
    122122        // only create renderable bounding box for new node 
    123         if (node != mPreviousNode) 
     123        if (node != mSavedNode) 
    124124        { 
    125                 mPreviousNode = node; 
     125                mSavedNode = node; 
    126126                mBox = static_cast<SceneNode *>(node)->_getWorldAABB(); 
    127127        } 
    … …  
    136136} 
    137137//----------------------------------------------------------------------- 
    138 void SceneNodeHierarchyInterface::GetGeometry(GtpVisibility::HierarchyNode *node,        
     138void SceneNodeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,        
    139139                                                                                          GtpVisibility::GeometryList *geometryList,  
    140140                                                                                          bool includeChildren) 
    … …  
    151151                { 
    152152                        Entity *ent = static_cast<Entity *>(movable); 
    153                         //std::stringstream d; d << "ent " << ent->getName(); LogManager::getSingleton().logMessage(d.str()); 
     153                        //std::stringstream d; d << "ent " << ent->getName();  
     154                        //LogManager::getSingleton().logMessage(d.str()); 
    154155                        geometryList->push_back(ent); 
    155156                } 
    … …  
    166167        return static_cast<SceneNode *>(node)->getId(); 
    167168} 
     169//----------------------------------------------------------------------- 
     170GtpVisibility::HierarchyNode *SceneNodeHierarchyInterface::GetNextNode() 
     171{ 
     172        if (mTraversalStack->empty()) 
     173                return NULL; 
     174         
     175        SceneNode *node = static_cast<SceneNode *>(mTraversalStack->top()); 
     176        mTraversalStack->pop(); 
     177 
     178        // internal node: add children to priority queue for further processing 
     179        Node::ChildNodeIterator it = node->getChildIterator(); 
     180                                 
     181        while (it.hasMoreElements())                     
     182        {  
     183                mTraversalStack->push(it.getNext()); 
     184        } 
     185 
     186        return node; 
     187}  
    168188} // namespace Ogre      

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

    r154 r155  
    184184        bool leaveTransparentsInQueue = mDelayRenderTransparents && !mUseDepthPass; 
    185185 
     186    // -- initialise interface for rendering traversal of the hierarchy 
     187        mHierarchyInterface->SetHierarchyRoot(mOctree); 
     188         
    186189        // possible two cameras (one for culling, one for rendering) 
    187         mHierarchyInterface->InitFrame(mOctree, mCameraInProgress,  
     190        mHierarchyInterface->InitTraversal(mCameraInProgress,  
    188191                                                        mCullCamera ? getCamera("CullCamera") : NULL, 
    189192                                                        leaveTransparentsInQueue); 
     193                 
    190194 
    191195        // reset culling manager stats 
    … …  
    352356        d << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", " 
    353357          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", " 
    354           << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetUseOptimization()) << ", " 
     358          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", " 
    355359          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << "\n" 
    356360          << "Hierarchy nodes: " << mNumOctreeNodes << ", "  

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

    r146 r155  
    2626        if (key == "AssumedVisibility") 
    2727        { 
    28                 mVisibilityManager->SetAssumedVisibility(*static_cast<const int *>(val)); 
     28                mVisibilityManager->SetAssumedVisibilityForChc(*static_cast<const int *>(val)); 
    2929                return true; 
    3030        } 
    31         if (key == "UseOptimization") 
     31        if (key == "TestGeometryForVisibleLeaves") 
    3232        { 
    33                 mHierarchyInterface->SetUseOptimization(*static_cast<const bool *>(val)); 
     33                mHierarchyInterface->TestGeometryForVisibleLeaves(*static_cast<const bool *>(val)); 
    3434                return true; 
    3535        } 

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

    r139 r155  
    4040        if (!mShowVisualization) 
    4141        { 
    42                 // two cameras (one for culling, one for rendering) 
    43                 mHierarchyInterface->InitFrame(mSceneRoot, mCameraInProgress); 
     42                mHierarchyInterface->SetHierarchyRoot(mSceneRoot); 
     43                mHierarchyInterface->InitTraversal(mCameraInProgress); 
    4444 
    4545                // reset culling manager stats 

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

    r154 r155  
    3030mEnableDepthWrite(true), 
    3131mSkipTransparents(false), 
    32 mSavedShadowTechnique(SHADOWTYPE_NONE) 
     32mSavedShadowTechnique(SHADOWTYPE_NONE), 
     33mRenderOnlyBoundingBoxes(false) 
    3334{ 
    3435        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    … …  
    126127                        if (mRenderNodesForViz) 
    127128                        { 
    128                                 OctreeNode *node = *it;  
    129                                 if ((node->numAttachedObjects() > 0) && (node->numChildren() == 0) 
    130                                         && node->getAttachedObject(0)->getMovableType() == "Entity") 
    131                                 getRenderQueue()->addRenderable(node); 
     129                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) 
     130                                        && (*it)->getAttachedObject(0)->getMovableType() == "Entity") 
     131                                getRenderQueue()->addRenderable((*it)); 
    132132 
    133133                                // addbounding boxes instead of node itself 
    … …  
    213213                PrepareVisualization(cam); 
    214214        } 
    215         else 
     215        else if (mRenderOnlyBoundingBoxes) 
     216        { 
     217        } 
     218        else  
    216219        {        
    217220                // for hierarchical culling, we interleave identification  
    218221                // and rendering of objects in _renderVisibibleObjects 
    219222 
    220                 // only for the shadow pass we use standard rendering 
     223                // for the shadow pass we use only standard rendering 
     224                // because of low occlusion 
    221225                if (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&  
    222226                        mIlluminationStage == IRS_RENDER_TO_TEXTURE) 
    … …  
    225229                } 
    226230                // only shadow casters will be rendered in shadow texture pass 
    227                 //mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
     231                // mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
    228232        } 
    229233        //TerrainSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
    … …  
    236240void VisibilityTerrainSceneManager::_renderVisibleObjects() 
    237241{ 
     242        // save ambient light to reset later 
    238243        ColourValue savedAmbient = mAmbientLight; 
    239244 
    240         // visualization or shadow pass: apply standard rendering 
    241         if (mShowVisualization || (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&  
    242                 mIlluminationStage == IRS_RENDER_TO_TEXTURE)) 
     245        // --- apply standard rendering for some cases  
     246    // e.g., visualization, shadow pass 
     247 
     248        if (mShowVisualization || mRenderOnlyBoundingBoxes || 
     249           (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE && mIlluminationStage == IRS_RENDER_TO_TEXTURE)) 
    243250        {        
    244251                IlluminationRenderStage savedStage = mIlluminationStage;  
    245252         
    246253                if (mShowVisualization)  
    247                         // disable illumination stage so we have no shadows in visualization 
     254                        // disable illumination stage because we want no shadows in visualization 
    248255                        mIlluminationStage = IRS_NONE; 
    249256 
    … …  
    455462        d << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", " 
    456463          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", " 
    457           << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetUseOptimization()) << ", " 
     464          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", " 
    458465          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", " 
    459466          << "Hierarchy nodes: " << mNumOctreeNodes << ", "  
    … …  
    699706                (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES); 
    700707 
     708        // -- initialise interface for rendering traversal of the hierarchy 
     709        mHierarchyInterface->SetHierarchyRoot(mOctree); 
     710         
    701711        // possible two cameras (one for culling, one for rendering) 
    702         mHierarchyInterface->InitFrame(mOctree, cam,  
    703                                                 mCullCamera ? getCamera("CullCamera") : NULL, 
    704                                                 mLeavePassesInQueue); 
     712        mHierarchyInterface->InitTraversal(mCameraInProgress,  
     713                                                        mCullCamera ? getCamera("CullCamera") : NULL, 
     714                                                        mLeavePassesInQueue); 
    705715                 
    706716        //std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;LogManager::getSingleton().logMessage(d.str()); 
Note: See TracChangeset for help on using the changeset viewer.