Changeset 139 for trunk/VUT/work/ogre_changes/OgreMain

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/OgreMain

Files:

• include/OgreRenderQueueSortingGrouping.h (modified) (2 diffs)
• include/OgreSceneManager.h (modified) (2 diffs)
• src/OgreRenderQueueSortingGrouping.cpp (modified) (2 diffs)
• src/OgreSceneManager.cpp (modified) (5 diffs)

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

@@ -197 +197 @@
         void clear(void);
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
+        
                 /** Clears solids in this group of renderables. Leaves transparents in group.
         */
         void clearSolids(void);
+
+                enum {SOLID_PASSES = 1,
+                          SOLID_PASSES_DECAL = 2,
+                          SOLID_PASSES_DIFFUSE_SPECULAR = 4,
+                          SOLID_PASSES_NOSHADOW = 8,
+                          TRANSPARENT_PASSES = 16};
+
+                /** Clears passes determined by parameter.
+                        @param passes can be one or several (combined by |) of:
+                        SOLID_PASSES 
+                        SOLID_PASSES_DECAL 
+                        SOLID_PASSES_DIFFUSE_SPECULAR
+                        SOLID_PASSES_NOSHADOW
+                        TRANSPARENT_PASSES
+                */
+                void clear(const int leavePassesInQueue);
 #endif // GTP_VISIBILITY_MODIFIED_OGRE          
         /** Sets whether or not the queue will split passes by their lighting type,
@@ -306 +323 @@
         }
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE     
+                void clear(int passes)
+        {
+            PriorityMap::iterator i, iend;
+            iend = mPriorityGroups.end();
+            for (i = mPriorityGroups.begin(); i != iend; ++i)
+            {
+                i->second->clear(passes);
+            }
+
+        }
                 /** Clears only solid renderables. Leaves transparents in queue. */
                 void clearSolids(void)

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

@@ -128 +128 @@
                         @param node scene node to be rendered
                         @param cam current camera
-                        @param leaveTransparentsInQueue if only solid objects should be rendered
-                */
-                void _renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue = false);
+                        @param leavePassesInQueue list of passes which are left in queue
+                */
+                void _renderSceneNode(Camera *cam, SceneNode *node, const int leavePassesInQueue = 0);
                 /** deletes all processed queues
-                        @remark clears render queues after rendering scene node
-                */
-                void _deleteRenderedQueueGroups(bool leaveTransparentsInQueue);
+                        @param leavePassesInQueue pass list which is not deleted from queue
+                        @remark used to clear render queues before rendering scene node
+                */
+                void _deleteRenderedQueueGroups(int leavePassesInQueue = 0);
                 /** Internal method used by _renderVisibleObjects to deal with renderables
             which override the camera's own view / projection materices. 
@@ -156 +157 @@
                 /** Renders an Ogre MovableObject.
                 */
-                void _renderMovableObject(MovableObject *mov, const bool leaveTransparentsInQueue);
+                void _renderMovableObject(MovableObject *mov, const int leavePassesInQueue);
 
 #endif // GTP_VISIBILITY_MODIFIED_OGRE

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

@@ -280 +280 @@
     void RenderPriorityGroup::clearSolids(void)
     {
-      /*  SolidRenderablePassMap::iterator i, iend;
+        /*SolidRenderablePassMap::iterator i, iend;
         // Delete queue groups which are using passes which are to be
         // deleted, we won't need these any more and they clutter up 
@@ -313 +313 @@
         clearSolidPassMap(mSolidPassesNoShadow);
     }
+        //-----------------------------------------------------------------------
+    void RenderPriorityGroup::clear(const int leavePassesInQueue)
+    {
+                SolidRenderablePassMap::iterator i, iend;
+       
+                // -- standard method if no passes are left in queue
+                if (leavePassesInQueue == 0)
+                {
+                        clear();
+                        return;
+                }
+
+        // We do not clear the unchanged solid pass maps, only the contents of each list
+        // This is because we assume passes are reused a lot and it saves resorting
+                if (!(leavePassesInQueue & SOLID_PASSES))
+                        clearSolidPassMap(mSolidPasses);
+                if (!(leavePassesInQueue & SOLID_PASSES_DECAL))
+                        clearSolidPassMap(mSolidPassesDecal);
+                if (!(leavePassesInQueue & SOLID_PASSES_DIFFUSE_SPECULAR))
+                        clearSolidPassMap(mSolidPassesDiffuseSpecular);
+                if (!(leavePassesInQueue & SOLID_PASSES_NOSHADOW))
+                        clearSolidPassMap(mSolidPassesNoShadow);
+
+        if (!(leavePassesInQueue & TRANSPARENT_PASSES))
+                        mTransparentPasses.clear();
+    }
 #endif // GTP_VISIBILITY_MODIFIED_OGRE          
 //-----------------------------------------------------------------------

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

@@ -1909 +1909 @@
 
         itransend = objs.end();
-        for (itrans = objs.begin(); 
-                itrans != itransend; ++itrans)
+        for (itrans = objs.begin(); itrans != itransend; ++itrans)
         {
                 Renderable *r = itrans->renderable;
@@ -4197 +4196 @@
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
 //-----------------------------------------------------------------------
-void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue)
+void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, const int leavePassesInQueue)
 {
         // delete previously rendered objects from renderqueue
-        _deleteRenderedQueueGroups(leaveTransparentsInQueue);
+        _deleteRenderedQueueGroups(leavePassesInQueue);
 
         node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false);
@@ -4206 +4205 @@
 }
 //-----------------------------------------------------------------------
-void SceneManager::_deleteRenderedQueueGroups(bool leaveTransparentsInQueue)
+void SceneManager::_deleteRenderedQueueGroups(const int leavePassesInQueue)
 {
         RenderQueue::QueueGroupIterator queueIt = getRenderQueue()->_getQueueGroupIterator();
@@ -4218 +4217 @@
                 if (isRenderQueueToBeProcessed(qId))
                 {
-                        if (leaveTransparentsInQueue)
-                        {
-                                pGroup->clearSolids();
-                        }
-                        else
-                        {
-                                pGroup->clear();
-                        }
+                        /*if (leaveTransparentsInQueue)
+                        {       pGroup->clearSolids();  }       else
+                        {       pGroup->clear(); }*/
+                        pGroup->clear(leavePassesInQueue);
                 }
         }
@@ -4245 +4240 @@
 }*/
 //-----------------------------------------------------------------------
-void SceneManager::_renderMovableObject(MovableObject *mov, const bool leaveTransparentsInQueue)
+void SceneManager::_renderMovableObject(MovableObject *mov, const int leavePassesInQueue)
 {
         // delete previously rendered objects from renderqueue
-        _deleteRenderedQueueGroups(leaveTransparentsInQueue);
+        _deleteRenderedQueueGroups(leavePassesInQueue);
 
         mov->_updateRenderQueue(getRenderQueue());