Changeset 139 for trunk/VUT/work


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
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/work/TestCulling/TestCullingApplication.cpp

    r133 r139  
    9494 
    9595/***********************************************/ 
    96 /* TerrainFrameListener implementation           */ 
     96/* TerrainFrameListener implementation         */ 
    9797/***********************************************/ 
    9898//----------------------------------------------------------------------- 
    … …  
    294294        mShowVisualization = !mShowVisualization; 
    295295 
    296         mSceneMgr->setOption("ShowVisualization", &mShowVisualization); 
     296        mSceneMgr->setOption("PrepareVisualization", &mShowVisualization); 
    297297        mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes); 
    298298} 

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

    r137 r139  
    7575mCullCamera(false), 
    7676mRecord(false), 
    77 mUseShadows(false), 
     77mShowShadows(false), 
    7878mShowHelp(false), 
    7979mDisplayCameraDetails(false), 
    … …  
    159159        mSceneMgr->setOption("ShowOctree", &mShowOctree); 
    160160        mSceneMgr->setOption("CullCamera", &mCullCamera); 
    161         mSceneMgr->setOption("ShowVisualization", &mShowVisualization); 
     161        mSceneMgr->setOption("PrepareVisualization", &mShowVisualization); 
    162162 
    163163        // TODO: change this (does not work with other scene manager plugins) 
    … …  
    257257        } 
    258258 
    259 //      mInputDevice->capture(); 
     259        if (mDisplayCameraDetails) 
     260    { 
     261        // Print camera details 
     262        mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) +  
     263                        " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation())); 
     264    } 
    260265 
    261266        //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly 
    … …  
    706711void TerrainFrameListener::toggleShowViz() 
    707712{ 
    708         mShowVisualization = !mShowVisualization; 
    709         mVisualizeCulledNodes = !mVisualizeCulledNodes; 
    710  
     713        mVisualizeCulledNodes = mShowVisualization = !mShowVisualization; 
     714         
    711715        // create viewport with priority VIZ_VIEWPORT_Z_ORDER:  
    712716        // will be rendered over standard viewport 
    … …  
    721725                // Alter the camera aspect ratio to match the viewport 
    722726        mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /  
    723                         Real(vizvp->getActualHeight())); 
     727                                                                   Real(vizvp->getActualHeight())); 
    724728                 
    725729                mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes); 
    … …  
    733737                mSceneMgr->setSkyPlane(true, plane, "Examples/TransparentTest", 4000, 75, false); 
    734738                */ 
    735                  
    736739        } 
    737740        else 
    738741        { 
     742                // remove visualization viewport 
    739743                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER); 
    740                 // if octree was enabled for visualization purpose, reset now 
     744 
     745                // octree bounding boxes are shown for visualization purpose, reset now 
    741746                mSceneMgr->setOption("ShowOctree", &mShowOctree); 
    742747        } 
    743748} 
    744749//----------------------------------------------------------------------- 
    745 void TerrainFrameListener::toggleUseShadows() 
    746 { 
    747         mUseShadows = !mUseShadows; 
    748  
    749         mSunLight->setCastShadows(mUseShadows); 
    750  
    751         if (mUseShadows) 
     750void TerrainFrameListener::toggleShowShadows() 
     751{ 
     752        mShowShadows = !mShowShadows; 
     753 
     754        mSunLight->setCastShadows(mShowShadows); 
     755 
     756        if (mShowShadows) 
    752757        { 
    753758                mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE); 
     759                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE); 
     760                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);            
    754761        } 
    755762        else 
    … …  
    805812                break; 
    806813        case KC_S: 
    807                 toggleUseShadows(); 
     814                toggleShowShadows(); 
    808815                break; 
    809816 
    … …  
    857864                break; 
    858865        } 
    859  
    860         if (mDisplayCameraDetails) 
    861     { 
    862         // Print camera details 
    863         mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) +  
    864                         " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation())); 
    865     } 
    866866 
    867867        CEGUI::System::getSingleton().injectKeyDown(e->getKey()); 

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

    r135 r139  
    9898        void toggleShowStats(); 
    9999 
    100         void toggleUseShadows(); 
     100        void toggleShowShadows(); 
    101101        void toggleDisplayCameraDetails(); 
    102102        void takeScreenShot(); 
    … …  
    175175        bool mCullCamera; 
    176176        bool mRecord; 
    177         bool mUseShadows; 
     177        bool mShowShadows; 
    178178        bool mVisualizeCulledNodes; 
    179179        bool mShowHelp; 

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

    r137 r139  
    8484{ 
    8585        // Set ambient light 
    86         mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); 
     86        mAmbientLight = ColourValue(0.5, 0.5, 0.5); 
     87        mSceneMgr->setAmbientLight(mAmbientLight); 
    8788         
    8889        //-- create light 
    … …  
    100101        mSunLight->setDirection(dir); 
    101102        //mSunLight->setDirection(Vector3::NEGATIVE_UNIT_Y); 
    102  
    103103        mSunLight->setDiffuseColour(1, 1, 1); 
    104104        mSunLight->setSpecularColour(1, 1, 1); 
    … …  
    137137        */ 
    138138        mSceneMgr->setShadowTextureSettings(1024, 2); 
    139 /*      if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_HWRENDER_TO_TEXTURE)) 
    140     {   // In D3D, use a 1024x1024 shadow texture 
    141                 mSceneMgr->setShadowTextureSettings(1024, 2);   }       else    { 
    142                 // Use 512x512 texture in GL since we can't go higher than the window res 
    143                 mSceneMgr->setShadowTextureSettings(512, 2);} 
    144                 */ 
    145  
    146         //mSceneMgr->setShadowColour(ColourValue(0, 0, 0)); 
    147139        mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5)); 
    148     // mSceneMgr->setShowDebugShadows(true); 
     140    //mSceneMgr->setShowDebugShadows(true); 
    149141 
    150142 
    … …  
    220212        const bool nShowViz = !showViz; 
    221213 
    222         // ambient light must be full for visualization 
     214        mSavedShadowTechnique = mSceneMgr->getShadowTechnique(); 
     215        mSavedAmbientLight = mSceneMgr->getAmbientLight(); 
     216 
     217        // -- ambient light must be full for visualization, shadows disabled 
    223218    if (showViz) 
    224219        { 
    225220                mSceneMgr->setAmbientLight(ColourValue(1, 1, 1)); 
    226         } 
    227         else 
    228         { 
    229                 mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); 
    230         } 
    231  
    232     mSceneMgr->setOption("ShowVisualization", &showViz); 
     221                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE); 
     222        } 
     223         
     224    mSceneMgr->setOption("PrepareVisualization", &showViz); 
    233225        mSceneMgr->setOption("SkyBoxEnabled", &nShowViz); 
    234226        //mSceneMgr->setOption("SkyPlaneEnabled", &showViz); 
    … …  
    239231void VisualizationRenderTargetListener::postRenderTargetUpdate(const RenderTargetEvent &evt) 
    240232{ 
     233        // reset values 
     234        mSceneMgr->setShadowTechnique(mSavedShadowTechnique); 
     235        mSceneMgr->setAmbientLight(mSavedAmbientLight); 
     236         
    241237        RenderTargetListener::postRenderTargetUpdate(evt); 
    242238} 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.h

    r133 r139  
    33 
    44#include "CEGUIForwardRefs.h" 
     5#include <OgreRenderTargetListener.h> 
    56#include "ExampleApplication.h" 
     7 
    68#include "OgreTerrainContentGenerator.h" 
    7  
    8 #include <OgreRenderTargetListener.h> 
    99#include "TerrainFrameListener.h" 
    1010 
    … …  
    1919 
    2020        SceneManager *mSceneMgr; 
     21         
     22        ShadowTechnique mSavedShadowTechnique; 
     23        ColourValue mSavedAmbientLight; 
    2124}; 
    2225 
    … …  
    5457        SceneNode *mCamNode; 
    5558        Light *mSunLight; 
    56         VisualizationRenderTargetListener *mRenderTargetListener; 
    5759 
    5860        TerrainFrameListener *mTerrainFrameListener; 
     61        ColourValue mAmbientLight; 
     62        //VisualizationRenderTargetListener *mVizRenderTargetListener; 
    5963         
    6064private: 

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