Ignore:
Timestamp:
06/20/05 08:13:57 (20 years ago)
Author:
mattausch
Message:

fixed bug with tight octree boxes
added more flexible renderqueue (can delete per flag)
reordered functions in visibility terrain scene manager

Location:
trunk/VUT/work/ogre_changes
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed

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

    r115 r139  
    197197        void clear(void); 
    198198#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     199         
    199200                /** Clears solids in this group of renderables. Leaves transparents in group. 
    200201        */ 
    201202        void clearSolids(void); 
     203 
     204                enum {SOLID_PASSES = 1, 
     205                          SOLID_PASSES_DECAL = 2, 
     206                          SOLID_PASSES_DIFFUSE_SPECULAR = 4, 
     207                          SOLID_PASSES_NOSHADOW = 8, 
     208                          TRANSPARENT_PASSES = 16}; 
     209 
     210                /** Clears passes determined by parameter. 
     211                        @param passes can be one or several (combined by |) of: 
     212                        SOLID_PASSES  
     213                        SOLID_PASSES_DECAL  
     214                        SOLID_PASSES_DIFFUSE_SPECULAR 
     215                        SOLID_PASSES_NOSHADOW 
     216                        TRANSPARENT_PASSES 
     217                */ 
     218                void clear(const int leavePassesInQueue); 
    202219#endif // GTP_VISIBILITY_MODIFIED_OGRE           
    203220        /** Sets whether or not the queue will split passes by their lighting type, 
    … …  
    306323        } 
    307324#ifdef GTP_VISIBILITY_MODIFIED_OGRE      
     325                void clear(int passes) 
     326        { 
     327            PriorityMap::iterator i, iend; 
     328            iend = mPriorityGroups.end(); 
     329            for (i = mPriorityGroups.begin(); i != iend; ++i) 
     330            { 
     331                i->second->clear(passes); 
     332            } 
     333 
     334        } 
    308335                /** Clears only solid renderables. Leaves transparents in queue. */ 
    309336                void clearSolids(void) 

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

    r131 r139  
    128128                        @param node scene node to be rendered 
    129129                        @param cam current camera 
    130                         @param leaveTransparentsInQueue if only solid objects should be rendered 
    131                 */ 
    132                 void _renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue = false); 
     130                        @param leavePassesInQueue list of passes which are left in queue 
     131                */ 
     132                void _renderSceneNode(Camera *cam, SceneNode *node, const int leavePassesInQueue = 0); 
    133133                /** deletes all processed queues 
    134                         @remark clears render queues after rendering scene node 
    135                 */ 
    136                 void _deleteRenderedQueueGroups(bool leaveTransparentsInQueue); 
     134                        @param leavePassesInQueue pass list which is not deleted from queue 
     135                        @remark used to clear render queues before rendering scene node 
     136                */ 
     137                void _deleteRenderedQueueGroups(int leavePassesInQueue = 0); 
    137138                /** Internal method used by _renderVisibleObjects to deal with renderables 
    138139            which override the camera's own view / projection materices.  
    … …  
    156157                /** Renders an Ogre MovableObject. 
    157158                */ 
    158                 void _renderMovableObject(MovableObject *mov, const bool leaveTransparentsInQueue); 
     159                void _renderMovableObject(MovableObject *mov, const int leavePassesInQueue); 
    159160 
    160161#endif // GTP_VISIBILITY_MODIFIED_OGRE 

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

    r115 r139  
    280280    void RenderPriorityGroup::clearSolids(void) 
    281281    { 
    282       /*  SolidRenderablePassMap::iterator i, iend; 
     282        /*SolidRenderablePassMap::iterator i, iend; 
    283283        // Delete queue groups which are using passes which are to be 
    284284        // deleted, we won't need these any more and they clutter up  
    … …  
    313313        clearSolidPassMap(mSolidPassesNoShadow); 
    314314    } 
     315        //----------------------------------------------------------------------- 
     316    void RenderPriorityGroup::clear(const int leavePassesInQueue) 
     317    { 
     318                SolidRenderablePassMap::iterator i, iend; 
     319        
     320                // -- standard method if no passes are left in queue 
     321                if (leavePassesInQueue == 0) 
     322                { 
     323                        clear(); 
     324                        return; 
     325                } 
     326 
     327        // We do not clear the unchanged solid pass maps, only the contents of each list 
     328        // This is because we assume passes are reused a lot and it saves resorting 
     329                if (!(leavePassesInQueue & SOLID_PASSES)) 
     330                        clearSolidPassMap(mSolidPasses); 
     331                if (!(leavePassesInQueue & SOLID_PASSES_DECAL)) 
     332                        clearSolidPassMap(mSolidPassesDecal); 
     333                if (!(leavePassesInQueue & SOLID_PASSES_DIFFUSE_SPECULAR)) 
     334                        clearSolidPassMap(mSolidPassesDiffuseSpecular); 
     335                if (!(leavePassesInQueue & SOLID_PASSES_NOSHADOW)) 
     336                        clearSolidPassMap(mSolidPassesNoShadow); 
     337 
     338        if (!(leavePassesInQueue & TRANSPARENT_PASSES)) 
     339                        mTransparentPasses.clear(); 
     340    } 
    315341#endif // GTP_VISIBILITY_MODIFIED_OGRE           
    316342//----------------------------------------------------------------------- 

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

    r135 r139  
    19091909 
    19101910        itransend = objs.end(); 
    1911         for (itrans = objs.begin();  
    1912                 itrans != itransend; ++itrans) 
     1911        for (itrans = objs.begin(); itrans != itransend; ++itrans) 
    19131912        { 
    19141913                Renderable *r = itrans->renderable; 
    … …  
    41974196#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    41984197//----------------------------------------------------------------------- 
    4199 void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue) 
     4198void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, const int leavePassesInQueue) 
    42004199{ 
    42014200        // delete previously rendered objects from renderqueue 
    4202         _deleteRenderedQueueGroups(leaveTransparentsInQueue); 
     4201        _deleteRenderedQueueGroups(leavePassesInQueue); 
    42034202 
    42044203        node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false); 
    … …  
    42064205} 
    42074206//----------------------------------------------------------------------- 
    4208 void SceneManager::_deleteRenderedQueueGroups(bool leaveTransparentsInQueue) 
     4207void SceneManager::_deleteRenderedQueueGroups(const int leavePassesInQueue) 
    42094208{ 
    42104209        RenderQueue::QueueGroupIterator queueIt = getRenderQueue()->_getQueueGroupIterator(); 
    … …  
    42184217                if (isRenderQueueToBeProcessed(qId)) 
    42194218                { 
    4220                         if (leaveTransparentsInQueue) 
    4221                         { 
    4222                                 pGroup->clearSolids(); 
    4223                         } 
    4224                         else 
    4225                         { 
    4226                                 pGroup->clear(); 
    4227                         } 
     4219                        /*if (leaveTransparentsInQueue) 
     4220                        {       pGroup->clearSolids();  }       else 
     4221                        {       pGroup->clear(); }*/ 
     4222                        pGroup->clear(leavePassesInQueue); 
    42284223                } 
    42294224        } 
    … …  
    42454240}*/ 
    42464241//----------------------------------------------------------------------- 
    4247 void SceneManager::_renderMovableObject(MovableObject *mov, const bool leaveTransparentsInQueue) 
     4242void SceneManager::_renderMovableObject(MovableObject *mov, const int leavePassesInQueue) 
    42484243{ 
    42494244        // delete previously rendered objects from renderqueue 
    4250         _deleteRenderedQueueGroups(leaveTransparentsInQueue); 
     4245        _deleteRenderedQueueGroups(leavePassesInQueue); 
    42514246 
    42524247        mov->_updateRenderQueue(getRenderQueue()); 

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

    r115 r139  
    112112                @param octree the octant to be rendered (without children) 
    113113                @param onlyShadowCasters if only shadow casters are rendered 
    114                 @param leaveTransparentsInQueue if transparemt should be left in queue for later processing 
     114                @param passes if passes should be left in queue for later processing 
    115115        */ 
    116         void _renderOctant(Camera* cam, Octree *octree, bool onlyShadowCasters, bool leaveTransparentsInQueue = false); 
     116        void _renderOctant(Camera* cam, Octree *octree, bool onlyShadowCasters,  
     117                const int leavePassesInQueue = 0); 
    117118 
    118119        /** Returns stored list of boxes */ 

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

    r135 r139  
    3636#include <OgreOctree.h> 
    3737#include <OgreOctreeNode.h> 
     38#include <OgreLogManager.h> 
    3839 
    3940namespace Ogre 
    … …  
    109110                mDepth = 0; 
    110111 
     112        _updateBounds(); 
    111113#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    112114    mNumNodes = 0; 
    … …  
    175177        //mWireBoundingBox->setupBoundingBox(mBox); 
    176178        mWireBoundingBox->setupBoundingBox(mWorldAABB); 
     179 
    177180    return mWireBoundingBox; 
    178181} 
    … …  
    229232        // Reset bounds first 
    230233    mWorldAABB.setNull(); 
    231  
     234   
    232235    // Update bounds from own attached objects 
    233236        NodeList::iterator it, it_end; 
    … …  
    247250            for (int k = 0; k < 2; ++k) 
    248251            { 
    249                 if (mChildren[i][j][k] != 0) 
     252                if (mChildren[i][j][k]) 
    250253                                { 
    251254                                        mWorldAABB.merge(mChildren[i][j][k]->_getWorldAABB()); 
    … …  
    254257        } 
    255258        } 
     259        // HACK: clamp to bounds 
     260        AxisAlignedBox box; 
     261        _getCullBounds(&box); 
     262        mWorldAABB = mWorldAABB.intersection(box);  
     263         
     264        //std::stringstream d; d << "updating box: " << mWorldAABB << ", depth: " << mDepth << "null: " << mBox.isNull(); 
     265        //LogManager::getSingleton().logMessage(d.str()); 
     266 
    256267        // recursively update parent bounds 
    257268        if (mParent) 

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

    r135 r139  
    11761176//----------------------------------------------------------------------- 
    11771177void OctreeSceneManager::_renderOctant(Camera *cam, Octree *octant, bool onlyShadowCasters,  
    1178                                                                            bool leaveTransparentsInQueue)//, bool useZPassQueue) 
     1178                                                                           const int leavePassesInQueue) 
    11791179{ 
    11801180        // delete previously rendered objects from the render queue 
    1181         _deleteRenderedQueueGroups(leaveTransparentsInQueue); 
     1181        _deleteRenderedQueueGroups(leavePassesInQueue); 
    11821182 
    11831183        //Add stuff to be rendered; 

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

    r132 r139  
    388388            if (mLastNextLevel != nextLevel) 
    389389            { 
    390                                 //LogManager::getSingleton().logMessage("vbuffer binding"); 
    391                 if (nextLevel > 0) 
    392                 { 
    393                                         //LogManager::getSingleton().logMessage("level > 0"); 
    394                     mTerrain->vertexBufferBinding->setBinding(DELTA_BINDING,  
     390                                if (nextLevel > 0) 
     391                { 
     392                                        mTerrain->vertexBufferBinding->setBinding(DELTA_BINDING,  
    395393                        mDeltaBuffers[nextLevel - 1]); 
    396394                } 
    397395                else 
    398                 { 
    399                                         //LogManager::getSingleton().logMessage("level <= 0 (dummy b)"); 
     396                {                                
    400397                    // bind dummy (incase bindings checked) 
    401398                    mTerrain->vertexBufferBinding->setBinding(DELTA_BINDING,  
    … …  
    406403 
    407404        } 
    408                 //else LogManager::getSingleton().logMessage("no lod morph"); 
    409                 /*std::stringstream d;  
    410                 d << "terrain: " << this->getName() << ", notify camera: " << cam->getName() << ", pos: " << StringConverter::toString(cam->getDerivedPosition()) <<  
    411                         ", distance: " << StringConverter::toString(L) << ", lod level: " << mLastNextLevel 
    412                         << ", render level: " << getRenderLevel() << ", morph factor: " << mLODMorphFactor; 
    413                 LogManager::getSingleton().logMessage(d.str());*/ 
    414  
    415405    } 
    416406    //----------------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.