Changeset 155 for trunk/VUT/Ogre/src


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

added node traversal interface

Location:
trunk/VUT/Ogre/src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • 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.