Changeset 158 for trunk/VUT


Ignore:
Timestamp:
07/06/05 11:04:25 (19 years ago)
Author:
mattausch
Message:

removed node visibility for item buffer

Location:
trunk/VUT
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibility/include/HierarchyInterface.h

    r155 r158  
    1414typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair; 
    1515typedef std::queue<QueryPair> QueryQueue; 
    16 typedef std::stack<HierarchyNode *> TraversalStack; 
     16 
    1717 
    1818/**     Class which implements a hierarchy interface for a scene hierarchy. 
    … …  
    3333                @param node the hierarchy node 
    3434        */ 
    35         virtual void TraverseAndRenderNode(HierarchyNode *node) = 0; 
     35        virtual void TraverseNode(HierarchyNode *node) = 0; 
    3636        /** Renders current hierarchy node. 
    3737                @param node current hierarchy node to be rendered 
    … …  
    5656        */ 
    5757        HierarchyNode *GetHierarchyRoot() const; 
    58         /** Sets the scene root and initialises this hierarchy interface for a traversal. 
    59                 @param frontToBack  
    60                         if traversal is initialised for front-to-back rendering or 
    61                         simple traversal of the nodes. 
     58        /** Sets the scene root and initialises this hierarchy interface for a traversal.                
    6259                @remark also resets the statistics evaluated in the last traversal 
    6360        */ 
    64         void InitTraversal(bool frontToBack = true); 
     61        void InitTraversal(); 
    6562        /** Returns current frame id. 
    6663                @returns frame id 
    … …  
    152149        virtual void RenderGeometry(GtpVisibility::Mesh *geom) = 0; 
    153150 
    154         /** Sets node id to specified value.  
    155         */ 
    156         virtual void SetNodeId(HierarchyNode *node, int id) = 0; 
    157         /** Returns id of given node.  
    158         */ 
    159         virtual int GetNodeId(HierarchyNode *node) = 0; 
    160  
     151         
    161152        /** This is an optimization when issuing the occlusion test.  
    162153                The test is done with actual geometry rather than the bounding  
    163                 box of leave nodes previously marked as visible 
     154                box of leave nodes previously marked as visible. 
     155 
    164156                @param testGeometry if this optimization should be used 
    165157                @remark this option is only useful for the coherent hierarchical culling algorithm 
    … …  
    167159        void TestGeometryForVisibleLeaves(bool testGeometry); 
    168160 
    169         /**  
    170                 Traverses hierarchy and returns next node. 
    171                 @returns next node in hierarchy. 
    172         */ 
    173         virtual HierarchyNode *GetNextNode() = 0; 
     161 
    174162 
    175163protected: 
    176164        /// chc optimization for testing geometry of leaves instead of bounding box 
    177165        bool mTestGeometryForVisibleLeaves; 
    178  
     166        /// the current frame number 
    179167        unsigned int mFrameId; 
    180  
     168        /// points to the last occlusion query in the query list 
    181169        int mCurrentTestIdx; 
    182170         
    183171        /// number of traversed nodes 
    184172        unsigned int mNumTraversedNodes; 
    185         /// the distance queue used for rendering of nodes in front to back order. 
     173 
     174        /// The queue is useful for rendering hierarchy nodes in front to back order. 
    186175        DistanceQueue *mDistanceQueue; 
    187         /// internal structure for traversal 
    188         TraversalStack *mTraversalStack; 
    189176 
    190177        /// the root of the hierarchy 
    191178        HierarchyNode *mHierarchyRoot; 
    192179         
    193         // buffer for a node pointer 
     180        /// buffer for a node pointer 
    194181        HierarchyNode *mSavedNode; 
    195  
     182        /// list of rendered hierarchy nodes (e.g., useful for exact visibility queries) 
    196183        std::vector<HierarchyNode *> mRenderedNodes; 
    197184}; 

  • trunk/VUT/GtpVisibility/src/CoherentHierarchicalCullingManager.cpp

    r155 r158  
    4040                        { 
    4141                                mHierarchyInterface->PullUpVisibility(node); 
    42                                 mHierarchyInterface->TraverseAndRenderNode(node); 
     42                                mHierarchyInterface->TraverseNode(node); 
    4343                        } 
    4444                        else 
    … …  
    111111                                if (wasVisible) 
    112112                                { 
    113                                         mHierarchyInterface->TraverseAndRenderNode(node); 
     113                                        mHierarchyInterface->TraverseNode(node); 
    114114                                } 
    115115                        } 
    … …  
    145145 
    146146        mHierarchyInterface->PullUpVisibility(node);                     
    147         mHierarchyInterface->TraverseAndRenderNode(node); 
     147        mHierarchyInterface->TraverseNode(node); 
    148148} 
    149149 

  • trunk/VUT/GtpVisibility/src/FrustumCullingManager.cpp

    r155 r158  
    2828                {                
    2929                        mHierarchyInterface->SetNodeVisible(node, true); 
    30                         mHierarchyInterface->TraverseAndRenderNode(node); 
     30                        mHierarchyInterface->TraverseNode(node); 
    3131                } 
    3232        } 

  • trunk/VUT/GtpVisibility/src/HierarchyInterface.cpp

    r155 r158  
    1111{        
    1212        mDistanceQueue = new DistanceQueue(GreaterDistance<HierarchyNode *>(this)); 
    13         mTraversalStack = new std::stack<HierarchyNode *>; 
    1413} 
    1514//----------------------------------------------------------------------- 
    … …  
    1716{                
    1817        delete mDistanceQueue; 
    19         delete mTraversalStack; 
    2018} 
    2119//----------------------------------------------------------------------- 
    … …  
    2523} 
    2624//----------------------------------------------------------------------- 
    27 void HierarchyInterface::InitTraversal(bool frontToBack) 
     25void HierarchyInterface::InitTraversal() 
    2826{ 
    2927        // initialise for front-to-back rendering 
    30         if (frontToBack) 
    31         { 
    32                 ++ mFrameId; 
    33                 mCurrentTestIdx = 0; 
    34                 mNumTraversedNodes = 0; 
    35                 mRenderedNodes.clear(); 
    3628 
    37                 mDistanceQueue->push(mHierarchyRoot); 
    38         } 
    39         else 
    40         {       // initialise for simple node traversal 
    41                 mTraversalStack->push(mHierarchyRoot); 
    42         } 
     29        ++ mFrameId; 
     30        mCurrentTestIdx = 0; 
     31        mNumTraversedNodes = 0; 
     32        mRenderedNodes.clear(); 
     33 
     34        mDistanceQueue->push(mHierarchyRoot); 
    4335} 
    4436//----------------------------------------------------------------------- 

  • trunk/VUT/GtpVisibility/src/StopAndWaitCullingManager.cpp

    r155 r158  
    3131                { 
    3232                        mHierarchyInterface->SetNodeVisible(node, true); 
    33                         mHierarchyInterface->TraverseAndRenderNode(node); 
     33                        mHierarchyInterface->TraverseNode(node); 
    3434                } 
    3535                else 
    … …  
    4545                        if (visiblePixels > mVisibilityThreshold) 
    4646                        { 
    47                                 mHierarchyInterface->TraverseAndRenderNode(node); 
     47                                mHierarchyInterface->TraverseNode(node); 
    4848                        } 
    4949                        else 

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

    r155 r158  
    2424                @remark pushes children on the distance queue 
    2525        */ 
    26         void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
     26        void TraverseNode(GtpVisibility::HierarchyNode *node); 
    2727        void RenderNode(GtpVisibility::HierarchyNode *node); 
    2828        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 

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

    r155 r158  
    2727        void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
    2828         
    29         /** Traverses given node. 
     29        /** Traverses and renders the given node. 
    3030                @param node current node 
    3131                @remark pushes children on a distance queue. 
    3232        */ 
    33         void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
     33        void TraverseNode(GtpVisibility::HierarchyNode *node); 
     34        /** @copydoc HierarchyInterface::RenderNode */ 
    3435        void RenderNode(GtpVisibility::HierarchyNode *node); 
    3536        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 
    … …  
    5051                                         bool includeChildren); 
    5152 
    52         void SetNodeId(GtpVisibility::HierarchyNode *node, int id); 
    53          
    54         int GetNodeId(GtpVisibility::HierarchyNode *node); 
    55  
    56         GtpVisibility::HierarchyNode *GetNextNode(); 
    57  
    5853protected: 
    5954        /** Returns pointer to the bounding box of the node. 
    … …  
    6762        */ 
    6863        Real GetSquaredViewDepth(const Camera* cam, const AxisAlignedBox* box) const; 
    69  
    70         int mCurrentOctreePosition; 
    7164}; 
    7265} // namespace Ogre 

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

    r155 r158  
    2424        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 
    2525         
    26         void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
     26        void TraverseNode(GtpVisibility::HierarchyNode *node); 
    2727        void RenderNode(GtpVisibility::HierarchyNode *node); 
    2828        void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
    … …  
    4141        void VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
    4242                                                        GtpVisibility::CullingType type); 
    43  
    44         /*bool FindVisibleObjects(GtpVisibility::HierarchyNode *node,    
    45                                                         InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
    46                                                         bool includeChildren = false);*/ 
    4743         
    4844        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
    … …  
    5046                                         bool includeChildren); 
    5147 
    52         void SetNodeId(GtpVisibility::HierarchyNode *node, int id); 
    53          
    54         int GetNodeId(GtpVisibility::HierarchyNode *node); 
    55  
    56         GtpVisibility::HierarchyNode *GetNextNode(); 
    5748}; 
    5849 

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

    r156 r158  
    1111#include "OgrePlatformQueryManager.h" 
    1212#include "VisibilityManager.h" 
    13 #include <OgreSolidBoundingBox.h> 
    1413 
    1514 
    … …  
    9796        */ 
    9897        void PrepareVisualization(Camera *cam); 
    99          
     98        /** Initialises necessary parameters for hierarchical visibility culling. 
     99        */ 
    100100        void InitVisibilityCulling(Camera *cam); 
    101101 
    102  
     102        /// the interface to the scene hierarchy. 
    103103        OctreeHierarchyInterface *mHierarchyInterface; 
     104        /// manages all visibility options 
    104105        GtpVisibility::VisibilityManager *mVisibilityManager; 
    105106 
     107        /// if a visualization of the hierarchical culling is shown 
    106108        bool mShowVisualization; 
     109 
     110        /// if the culled nodes are indicated in the visualization 
    107111        bool mVisualizeCulledNodes; 
    108112 
     113        /// if symbols for the nodes are shown in the visualization 
    109114        bool mRenderNodesForViz; 
     115        /// if content of the nodes is shown in the visualization 
    110116        bool mRenderNodesContentForViz; 
     117 
     118        /// if we render transparents after the hierarchical traversal 
    111119        bool mDelayRenderTransparents; 
     120 
     121        /// if we use a depth pass (i.e., fill only the depth buffer in the first pass) 
    112122        bool mUseDepthPass; 
     123        /// if we currently render the depth pass 
    113124        bool mRenderDepthPass; 
     125         
     126        /// if we use an item buffer for rendering (i.e., object ids as color codes 
     127        bool mUseItemBuffer; 
     128        /// if we currently render the item buffer  
    114129        bool mRenderItemBuffer; 
    115         bool mUseItemBuffer; 
     130 
     131        /// if depth write should be enabled 
    116132        bool mEnableDepthWrite; 
     133        /// if transparents are skipped during rendering 
    117134        bool mSkipTransparents; 
    118135 
     136        /// the depth pass (no lighting, just filling the depth buffer) 
    119137        Pass *mDepthPass; 
    120138        Pass *mItemBufferPass; 
    121139 
    122140        int mCurrentEntityId; 
    123  
     141        /// flag for passes which should not be deleted from queue during first traversal 
    124142        int mLeavePassesInQueue; 
    125143        ShadowTechnique mSavedShadowTechnique; 
    126  
    127         bool mRenderHierarchyNodes; 
    128  
    129         std::vector<SolidBoundingBox *> mSolidBoxes; 
    130144}; 
    131145 

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

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

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

    r156 r158  
    7777        } 
    7878 
    79         delete [] buf; 
    80  
    81         // ---- render visible nodes and collect node visibility 
    82         bool renderBoxes = true; 
    83         sm->setOption("RenderHierarchyNodes", &renderBoxes); 
    84  
    85  
    86         // --- render item buffer for visible nodes only 
    87         pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
    88  
    89  
    90         // get frame buffer for node visibility 
    91         buf = mViewport->getTarget()->getBufferContents(dimx, dimy); 
    92  
    93          
    94         // loop through frame buffer & collect visible pixels 
    95         for (int idx = 0; idx < dimy * dimx * 3; idx += 3) 
    96         { 
    97                 // -- decode color code to receive id 
    98                 int id = buf[idx] << 16; 
    99                 id += buf[idx + 1] << 8; 
    100                 id += buf[idx + 2]; 
    101  
    102                 // if valid id <= add visibility (id values start at 1 
    103                 if ((id > 0) && (id < (int)visibleNodes->size())) 
    104                 { 
    105                         ((*visibleNodes)[id]).AddVisibility(1, 1); 
    106                 } 
    107         } 
     79        //-- reset options 
    10880 
    10981        // don't need item buffer anymore 
    11082        useItemBuffer = false; 
    111         //sm->setOption("UseItemBuffer", &useItemBuffer); 
    112  
    113         renderBoxes = false; 
    114         //sm->setOption("RenderHierarchyNodes", &renderBoxes); 
    115  
     83        sm->setOption("UseItemBuffer", &useItemBuffer); 
    11684        // reset initialised - flag 
    11785        mWasInitialised = false; 
    118  
    11986        // reset old overlay status 
    12087        mViewport->setOverlaysEnabled(overlayEnabled); 
    121          
     88        // reset background color 
    12289        mViewport->setBackgroundColour(bg); 
    12390 
     91        // delete array storing the frame buffer 
    12492        delete [] buf; 
    12593} 
    … …  
    146114                visibleGeometry->push_back(GtpVisibility::MeshInfo(it.getNext(), 0, 0)); 
    147115        } 
    148  
    149         // -- initialise hierarchy interface for simple node traversal 
    150         mHierarchyInterface->InitTraversal(false); 
    151  
    152         GtpVisibility::HierarchyNode *node = NULL; 
    153          
    154         int i = 1; 
    155  
    156         while (node = mHierarchyInterface->GetNextNode()) 
    157         { 
    158                 mHierarchyInterface->SetNodeId(node, i++); 
    159                 visibleNodes->push_back(GtpVisibility::NodeInfo(node, 0, 0)); 
    160         } 
    161116} 
    162117 

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

    r155 r158  
    1010//----------------------------------------------------------------------- 
    1111OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, RenderSystem *rsys):  
    12 SceneNodeHierarchyInterface(sm, rsys), mCurrentOctreePosition(0) 
     12SceneNodeHierarchyInterface(sm, rsys) 
    1313{ 
    1414} 
    1515//----------------------------------------------------------------------- 
    16 void OctreeHierarchyInterface::TraverseAndRenderNode(GtpVisibility::HierarchyNode *node) 
     16void OctreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
    1717{ 
    1818        ++ mNumTraversedNodes; 
    … …  
    168168        } 
    169169} 
    170 //----------------------------------------------------------------------- 
    171 void OctreeHierarchyInterface::SetNodeId(GtpVisibility::HierarchyNode *node, int id) 
    172 { 
    173         static_cast<Octree *>(node)->setId(id); 
    174 } 
    175 //----------------------------------------------------------------------- 
    176 int OctreeHierarchyInterface::GetNodeId(GtpVisibility::HierarchyNode *node) 
    177 { 
    178         return static_cast<Octree *>(node)->getId(); 
    179 } 
    180 //----------------------------------------------------------------------- 
    181 GtpVisibility::HierarchyNode *OctreeHierarchyInterface::GetNextNode() 
    182 { 
    183         if (mTraversalStack->empty()) 
    184                 return NULL; 
    185          
    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) 
    195                 { 
    196                         mTraversalStack->push(nextChild); 
    197                 } 
    198         } 
    199  
    200         return octree; 
    201 }  
    202                  
    203170} // namespace Ogre 

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

    r155 r158  
    130130} 
    131131//----------------------------------------------------------------------- 
    132 void PlatformHierarchyInterface::InitTraversal(Camera *cam, Camera *cullCam, int leavePassesInQueue) 
     132void PlatformHierarchyInterface::InitTraversal(Camera *cam, Camera *cullCam,  
     133                                                                                           int leavePassesInQueue) 
    133134{ 
    134135        GtpVisibility::HierarchyInterface::InitTraversal(); 

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

    r155 r158  
    1717} 
    1818//----------------------------------------------------------------------- 
    19 void SceneNodeHierarchyInterface::TraverseAndRenderNode(GtpVisibility::HierarchyNode *node) 
     19void SceneNodeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
    2020{ 
    2121        ++ mNumTraversedNodes; 
    … …  
    157157    } 
    158158} 
    159 //----------------------------------------------------------------------- 
    160 void SceneNodeHierarchyInterface::SetNodeId(GtpVisibility::HierarchyNode *node, int id) 
    161 { 
    162         static_cast<SceneNode *>(node)->setId(id); 
    163 } 
    164 //----------------------------------------------------------------------- 
    165 int SceneNodeHierarchyInterface::GetNodeId(GtpVisibility::HierarchyNode *node) 
    166 { 
    167         return static_cast<SceneNode *>(node)->getId(); 
    168 } 
    169 //----------------------------------------------------------------------- 
    170 GtpVisibility::HierarchyNode *SceneNodeHierarchyInterface::GetNextNode() 
    171 { 
    172         if (mTraversalStack->empty()) 
    173                 return NULL; 
    174          
    175         SceneNode *node = static_cast<SceneNode *>(mTraversalStack->top()); 
    176         mTraversalStack->pop(); 
    177159 
    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 }  
    188160} // namespace Ogre      

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

    r157 r158  
    3131mEnableDepthWrite(true), 
    3232mSkipTransparents(false), 
    33 mSavedShadowTechnique(SHADOWTYPE_NONE), 
    34 mRenderHierarchyNodes(false) 
    35 //mRenderHierarchyNodes(true) 
     33mSavedShadowTechnique(SHADOWTYPE_NONE) 
    3634{ 
    3735        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    … …  
    210208void VisibilityTerrainSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters) 
    211209{ 
    212         // clear list of solid boxes (used for item buffer hierarchy node rendering) 
    213         /*for (int i=0; i<(int)mSolidBoxes.size(); ++i) 
    214                 delete mSolidBoxes[i]; 
    215  
    216         mSolidBoxes.clear();*/ 
    217  
    218210        //-- show visible scene nodes and octree bounding boxes from last frame 
    219211        if (mShowVisualization) 
    … …  
    221213                PrepareVisualization(cam); 
    222214        } 
    223         else if (mRenderHierarchyNodes) 
    224         { 
    225                 AxisAlignedBox aab; 
    226                  
    227  
    228                 // get rendered hierarchy nodes from last frame 
    229                 GtpVisibility::HierarchyNodeList *nodeList = mHierarchyInterface->GetRenderedNodes(); 
    230                 GtpVisibility::HierarchyNodeList::iterator nodeIt, nodeIt_end = nodeList->end(); 
    231  
    232                 for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)                 
    233                 { 
    234                         SolidBoundingBox *solidBox = new SolidBoundingBox(); 
    235                         solidBox->SetupBoundingBox(aab); 
    236  
    237                         Octree *octree = static_cast<Octree *>(*nodeIt); 
    238                         solidBox->setId(octree->getId()); 
    239                         mSolidBoxes.push_back(solidBox); 
    240  
    241                         aab = octree->_getWorldAABB(); 
    242                         std::stringstream d; d << "bounding box with id: " << octree->getId() << ", " << aab << "\n"; 
    243                         LogManager::getSingleton().logMessage(d.str()); 
    244  
    245                         getRenderQueue()->addRenderable(solidBox);       
    246                 } 
    247         } 
    248215        else  
    249216        {        
    … …  
    273240        ColourValue savedAmbient = mAmbientLight; 
    274241 
    275         // --- apply standard rendering for some cases  
    276     // e.g., visualization, shadow pass 
    277  
    278         if (mShowVisualization || mRenderHierarchyNodes || 
     242        // --- apply standard rendering for some cases (e.g., visualization, shadow pass) 
     243 
     244        if (mShowVisualization || 
    279245           (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&  
    280246            mIlluminationStage == IRS_RENDER_TO_TEXTURE)) 
    … …  
    282248                IlluminationRenderStage savedStage = mIlluminationStage;  
    283249         
    284                 if (mShowVisualization || mRenderHierarchyNodes)  
    285                         // disable illumination stage because we want no shadows 
     250                if (mShowVisualization)  
     251                        // disable illumination stage to prevent rendering shadows 
    286252                        mIlluminationStage = IRS_NONE; 
    287253 
    … …  
    448414                return true; 
    449415        } 
    450         if (key == "RenderHierarchyNodes") 
    451         { 
    452                 mRenderHierarchyNodes = (*static_cast<const bool *>(val)); 
    453         } 
     416         
    454417        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    455418                setOption(key, val) || TerrainSceneManager::setOption(key, val); 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

    r156 r158  
    453453                        ++nodesSize; 
    454454 
    455                         int id = sm->GetHierarchyInterface()->GetNodeId((*nodesIt).GetNode()); 
    456                         std::stringstream d; d << "Node " << id << " visibility: " << vis; 
     455                        std::stringstream d; d << "Node visibility: " << vis; 
    457456                        LogManager::getSingleton().logMessage(d.str()); 
    458457                }        

  • trunk/VUT/work/ogre_changes/OgreMain/include/OgreRenderable.h

    r153 r158  
    227227            } 
    228228        } 
     229                /** Sets an id for this renderable. 
     230                */ 
    229231                void setId(int id) {mId = id;} 
     232                /** see set  
     233                */ 
    230234                int getId() {return mId;} 
    231235 

  • trunk/VUT/work/ogre_changes/OgreMain/include/OgreSceneNode.h

    r154 r158  
    444444                void setLastRendered(int frameid); 
    445445 
    446                 /** Sets scene node id  
    447                 @param the id 
    448                 */ 
    449                 void setId(int id); 
    450                 /** see set */ 
    451                 int getId(void); 
    452  
    453446        protected: 
    454447                int mLastVisited; 

  • trunk/VUT/work/ogre_changes/OgreMain/src/OgreSceneNode.cpp

    r154 r158  
    4242        mYawFixed(false), mAutoTrackTarget(0), mIsInSceneGraph(false) 
    4343#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    44         , mLastVisited(0), mVisible(false), mLastRendered(-1), mId(-1) 
     44        , mLastVisited(0), mVisible(false), mLastRendered(-1) 
    4545#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    4646    { 
    … …  
    5353        mAutoTrackTarget(0), mIsInSceneGraph(false) 
    5454        #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    55         , mLastVisited(0), mVisible(false), mId(-1) 
     55        , mLastVisited(0), mVisible(false) 
    5656        #endif //GTP_VISIBILITY_MODIFIED_OGRE 
    5757    { 
    … …  
    641641                mLastRendered = frameid; 
    642642        } 
    643         //----------------------------------------------------------------------- 
    644         void SceneNode::setId(int id) 
    645         { 
    646                 mId = id; 
    647         } 
    648         //----------------------------------------------------------------------- 
    649         int SceneNode::getId(void) 
    650         { 
    651                 return mId; 
    652         } 
    653643        #endif //GTP_VISIBILITY_MODIFIED_OGRE 
    654644} 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/include/OgreOctree.h

    r154 r158  
    192192        void _updateBounds(); 
    193193 
    194         /** Sets scene node id  
    195         @param the id 
    196         */ 
    197         void setId(int id); 
    198          
    199         /** see set */ 
    200         int getId(void); 
    201  
    202194protected: 
    203195         
    … …  
    209201        bool mVisible; 
    210202        int mDepth; 
    211         int mId; 
     203         
    212204 
    213205#endif // GTP_VISIBILITY_MODIFIED_OGRE 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctree.cpp

    r154 r158  
    8888      mHalfSize( 0, 0, 0 ) 
    8989#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    90         , mLastVisited(0), mVisible(false), mLastRendered(-1), mId(-1) 
     90        , mLastVisited(0), mVisible(false), mLastRendered(-1) 
    9191#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    9292{ 
    … …  
    271271        } 
    272272 } 
    273 //----------------------------------------------------------------------- 
    274 void Octree::setId(int id) 
    275 { 
    276         mId = id; 
    277 } 
    278 //----------------------------------------------------------------------- 
    279 int Octree::getId() 
    280 { 
    281         return mId; 
    282 } 
     273 
    283274#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    284275} 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp

    r154 r158  
    316316 
    317317    mOctree = new Octree( 0 ); 
     318 
    318319#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    319         mNumOctreeNodes = 1; 
    320         mOctree->setId(mNumOctreeNodes); 
     320        mNumOctreeNodes = 1; // count number of octants 
    321321#endif // GTP_VISIBILITY_MODIFIED_OGRE 
     322 
    322323    mMaxDepth = depth; 
    323324    mBox = box; 
    … …  
    469470            octant -> mChildren[ x ][ y ][ z ] = new Octree( octant ); 
    470471#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    471         mOctree->setId(++ mNumOctreeNodes); 
     472        ++ mNumOctreeNodes; 
    472473#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    473474 
    … …  
    10311032 
    10321033    mOctree = new Octree( 0 ); 
     1034 
    10331035#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    10341036        mNumOctreeNodes = 1; 
    1035         mOctree->setId(mNumOctreeNodes); 
    10361037#endif // GTP_VISIBILITY_MODIFIED_OGRE 
     1038 
    10371039    mOctree->mBox = box; 
    10381040 
Note: See TracChangeset for help on using the changeset viewer.