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

Timestamp:

05/30/05 03:20:23 (19 years ago)

Author:

mattausch

Message:

added depth pass algorithm + delayed transparent object rendering (so depth ordering is right)

Location:

trunk/VUT/work/ogre_changes/OgreMain

Files:

• include/OgreHardwareOcclusionQuery.h (modified) (2 diffs)
• include/OgreRenderQueueSortingGrouping.h (added)
• include/OgreSceneManager.h (modified) (1 diff)
• src/OgreRenderQueueSortingGrouping.cpp (added)
• src/OgreSceneManager.cpp (modified) (14 diffs)

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

@@ -96 +96 @@
       * Pulls the hardware occlusion query too see if there is a result.
       * @retval NumOfFragments will get the resulting number of fragments.
-          * @param waitForResult if true, the query will wait until a result is available
-      * @return True if success or false if not.
-          * @Remarks Hardware occlusion is an assyncronius process the result may take a frame or so.
-          *                     one idea is to test pass1 and if not visible skip pass2. Also note that objects
-          *                     not visible must be tested evrey frame. Visable objects don't need testing every frame.
-          *                     Testing non visable objects can be don unlit, no texture with low LOD object.
-          *        0 will generate all the levels till 1x1. [default: 0]
-      */
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-          virtual bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult ) = 0;
-#else
-         virtual bool pullOcclusionQuery( unsigned int* NumOfFragments ) = 0;
-#endif
-        /**
-      * Pulls the hardware occlusion query too see if there is a result.
-      * @retval NumOfFragments will get the resulting number of fragments.
-          * @param waitForResult if true, the query will wait until a result is available
       * @return True if success or false if not.
           * @Remarks In DX9 mode specifying OCCLUSIONQUERY_FLUSH as the flag, will case the driver to flush whatever API calls are batched.
           * In OpenGL mode it makes no difference if you specify OCCLUSIONQUERY_FLUSH or OCCLUSIONQUERY_NOFLUSH.
       */
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-        virtual bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult,
-                                                                         const HW_OCCLUSIONQUERY flag  ) = 0; 
-#else
-          virtual bool pullOcclusionQuery( unsigned int* NumOfFragments, 
-                                                                           const HW_OCCLUSIONQUERY flag  ) = 0; 
-#endif
+        virtual bool pullOcclusionQuery(unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH) = 0;
+
         /**
           * Let's you get the last pixel count with out doing the hardware occlusion test
@@ -143 +121 @@
         virtual void    setSkipRate( int skip ) = 0;
         virtual int             getSkipRate() = 0;
+
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+        /**
+                Pulls occlusion query.
+                @param NumOfFragments number of visible fragments if query result was available.
+                Last query result if query result was not yet available.
+
+                @param waitForResult if true, the function waits until the result is available.
+                Otherwise the function returns immediately, not waiting for the result.
+                @returns true if query result was available, false if result was not yet available
+        */
+        virtual bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, 
+                const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH ) = 0; 
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
+
 //----------------------------------------------------------------------
 // Private members

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 );
-                /** deletes all queues which we were currently processing
-                        @remark clears renderqueue after rendering scene node
+                void _renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue = false);
+                /** deletes all processed queues
+                        @remark clears render queues after rendering scene node
                 */
-                void _deleteRenderedQueueGroups();
+                void _deleteRenderedQueueGroups(bool leaveTransparentsInQueue);
                 /** Internal method used by _renderVisibleObjects to deal with renderables
             which override the camera's own view / projection materices. 

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

@@ -59 +59 @@
 #include "OgreDataStream.h"
 #include "OgreStaticGeometry.h"
-#include <windows.h> //matt: remove later
+
 // This class implements the most basic scene manager
 
@@ -665 +665 @@
         if (lastUsedVertexProgram)
         {
-                        //matt: remove later
-                        //OutputDebugString("unbinding vertex program\n");
-
             mDestRenderSystem->unbindGpuProgram(GPT_VERTEX_PROGRAM);
             lastUsedVertexProgram = false;
@@ -990 +987 @@
                                const String& groupName)
 {
-    mSkyPlaneEnabled = enable;
     if (enable)
     {
@@ -1061 +1057 @@
 
     }
+        mSkyPlaneEnabled = enable;
 }
 //-----------------------------------------------------------------------
@@ -1071 +1068 @@
                              const String& groupName)
 {
-    mSkyBoxEnabled = enable;
     if (enable)
     {
@@ -1143 +1139 @@
 
     }
-
+        mSkyBoxEnabled = enable;
 }
 //-----------------------------------------------------------------------
@@ -1157 +1153 @@
                               const String& groupName)
 {
-    mSkyDomeEnabled = enable;
     if (enable)
     {
@@ -1164 +1159 @@
         {
             OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
-                "Sky dome material '" + materialName + " not found.",
+                "Sky dome material '" + materialName + "' not found.",
                 "SceneManager::setSkyDome");
         }
@@ -1208 +1203 @@
 
     }
+        mSkyDomeEnabled = enable;
 }
 //-----------------------------------------------------------------------
@@ -2658 +2654 @@
     {
         Light* l = i->second;
+                if (l->isVisible())
+                {
         if (l->getType() == Light::LT_DIRECTIONAL)
         {
@@ -2675 +2673 @@
 
         }
+    }
     }
 
@@ -4180 +4179 @@
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
 //-----------------------------------------------------------------------
-void SceneManager::_renderSceneNode( Camera *cam, SceneNode *node )
+void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue)
 {
         node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false);
@@ -4186 +4185 @@
         
         // delete all rendered objects from renderqueue
-        _deleteRenderedQueueGroups();
-}
-//-----------------------------------------------------------------------
-void SceneManager::_deleteRenderedQueueGroups()
+        _deleteRenderedQueueGroups(leaveTransparentsInQueue);
+}
+//-----------------------------------------------------------------------
+void SceneManager::_deleteRenderedQueueGroups(bool leaveTransparentsInQueue)
 {
         RenderQueue::QueueGroupIterator queueIt = getRenderQueue()->_getQueueGroupIterator();
@@ -4200 +4199 @@
 
                 if (isRenderQueueToBeProcessed(qId))
+                {
+                        if (leaveTransparentsInQueue)
+                        {
+                                pGroup->clearSolids();
+                        }
+                        else
+                        {
                         pGroup->clear();
+        }
+                }
         }