Changeset 94 for trunk/VUT/Ogre

Timestamp:

05/12/05 18:55:25 (20 years ago)

Author:

mattausch

Message:

 

Location:

trunk/VUT/Ogre

Files:

• include/OgrePlatformHierarchyInterface.h (modified) (2 diffs)
• src/OgreOctreeHierarchyInterface.cpp (modified) (4 diffs)
• src/OgrePlatformHierarchyInterface.cpp (modified) (7 diffs)
• src/OgreSceneNodeHierarchyInterface.cpp (modified) (1 diff)
• src/OgreSolidBoundingBox.cpp (modified) (1 diff)
• src/OgreVisibilityOctreeSceneManager.cpp (modified) (3 diffs)
• src/OgreVisibilitySceneManager.cpp (modified) (1 diff)
• src/OgreVisibilitySceneManagerDll.cpp (modified) (1 diff)
• src/OgreVisibilityTerrainSceneManager.cpp (modified) (1 diff)

trunk/VUT/Ogre/include/OgrePlatformHierarchyInterface.h

@@ -34 +34 @@
         GtpVisibility::OcclusionQuery *GetNextOcclusionQuery();
                 
-        /** Sets the current camera.
+        /** Sets the current camera used for the rendering.
                 @param cam the current camera
         */
         void SetCamera(Camera *cam);
-                
+        /** Sets the current camera used for culling.
+                @param cam the current camera
+                @remark the default is the camera used for rendering
+        */
+        void SetCullCamera(Camera *cullCam);
         /** Initialises this scene traverser for the current frame.
         @param root root of the hierarchy
                 @param cam current camera
+                @param cullCam the camera used for culling. If null, the current camera is used
                 @remark convenience method wich calls VisibilitySceneTraverser::initFrame,
                 sets the current camera, and initialises the distance queue.
         */
-        void InitFrame(GtpVisibility::HierarchyNode *root, Ogre::Camera *cam);
+        void InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam, Camera *cullCam = NULL);
         /** Checks if the node is visible from the current view frustum.
                 @param node the current node
@@ -95 +100 @@
 
         Camera *mCamera;
+        Camera *mCullCamera;
+
         AxisAlignedBox mBox;
         

trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

@@ -2 +2 @@
 #include "OgreVisibilityOctreeSceneManager.h"
 #include <OgreOctree.h>
+#include <OgreLogManager.h>
+
 #include <windows.h>
 
 namespace Ogre {
-//namespace GtpVisibility {
+
 //-----------------------------------------------------------------------
 OctreeHierarchyInterface::OctreeHierarchyInterface(SceneManager *sm, RenderSystem *rsys): 
@@ -25 +27 @@
         
         // if not all subtrees are empty
-        if (octree->numNodes() > (int)octree->mNodes.size())
+        //if (octree->numNodes() > (int)octree->mNodes.size())
+        if (!IsLeaf(node))
         {
                 for(int i=0; i<8; ++i)
@@ -42 +45 @@
 bool OctreeHierarchyInterface::IsLeaf(GtpVisibility::HierarchyNode *node) const
 {
-        Octree *octant = static_cast<Octree *>(node);
-
-        for(int i=0; i<8; i++)
-        {
-                if (octant->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1])
-                        return false;
-        }
-
-        return true;
+        Octree *octree = static_cast<Octree *>(node);
+        // HACK: if there are subtrees, they are empty => we are not interested in them
+        return octree->numNodes() == (int)octree->mNodes.size();
 }
 //-----------------------------------------------------------------------
@@ -68 +65 @@
         Vector3 mid = ((box->getMinimum() - box->getMaximum()) * 0.5) + box->getMinimum();
 
-        return (mCamera->getDerivedPosition() - mid).squaredLength();
+        return (mCullCamera->getDerivedPosition() - mid).squaredLength();
 }
 //-----------------------------------------------------------------------

trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp

@@ -1 +1 @@
 #include <OgreCamera.h>
-
+#include <OgreLogManager.h>
 //#include "OgreSolidHalfBoundingBox.h"
 #include "OgreSolidBoundingBox.h"
@@ -11 +11 @@
 //-----------------------------------------------------------------------
 PlatformHierarchyInterface::PlatformHierarchyInterface(SceneManager *sm, RenderSystem *rsys):
-mSceneManager(sm), mRenderSystem(rsys), mSolidBoundingBox(NULL)/*, mSolidHalfBoundingBox(NULL)*/
+mSceneManager(sm), mRenderSystem(rsys), mSolidBoundingBox(NULL),
+mCamera(NULL), mCullCamera(NULL)
 {
 }
@@ -64 +65 @@
 }
 //-----------------------------------------------------------------------
+void PlatformHierarchyInterface::SetCullCamera(Ogre::Camera *cullCam)
+{
+        mCullCamera = cullCam;
+}
+//-----------------------------------------------------------------------
 GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::GetNextOcclusionQuery()
 {
@@ -74 +80 @@
 }
 //-----------------------------------------------------------------------
-void PlatformHierarchyInterface::InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam)
+void PlatformHierarchyInterface::InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam, Camera *cullCam)
 {
         GtpVisibility::HierarchyInterface::InitFrame(root);
@@ -80 +86 @@
 
         SetCamera(cam);
+
+        if(cullCam)
+                SetCullCamera(cullCam);
+        else
+                SetCullCamera(cam);
 }
 //-----------------------------------------------------------------------
@@ -96 +107 @@
 {
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
-        return mCamera->isVisible(*GetBoundingBox(node), intersects);
+        return mCullCamera->isVisible(*GetBoundingBox(node), intersects);
 #else
         return true;
@@ -113 +124 @@
         // if node is leaf and was visible => will be rendered anyway.
         // In this case we can also test with the real geometry.
-        if(mUseOptimization && wasVisible && IsLeaf(node))
+        // if camera for culling is different from camera for rendering => cannot optimize
+        if (mUseOptimization && wasVisible && IsLeaf(node) && (mCamera == mCullCamera))
         {
+                //LogManager::getSingleton().logMessage("render node\n");
                 RenderNode(node);
         }
         else
         {
+                //LogManager::getSingleton().logMessage("render box\n");
                 RenderBoundingBox(GetBoundingBox(node));
         }

trunk/VUT/Ogre/src/OgreSceneNodeHierarchyInterface.cpp

@@ -3 +3 @@
 #include <OgreCamera.h>
 #include <OgreSceneNode.h>
-
-//#include <windows.h>
 
 namespace Ogre {

trunk/VUT/Ogre/src/OgreSolidBoundingBox.cpp

@@ -6 +6 @@
 #include "OgreCamera.h"
 #include "OgreMaterialManager.h"
-//#include <windows.h>
+
 
 namespace Ogre {

trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

@@ -6 +6 @@
 #include <OgreCamera.h>
 #include <OgreLogManager.h>
-
-#include <windows.h>
 
 namespace Ogre {
@@ -18 +16 @@
         mHierarchyInterface = 
                 new OctreeHierarchyInterface(this, mDestRenderSystem);
-        //visManager->SetCullingManager(GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING);
-        
+                
         //mDisplayNodes = true;
         //mShowBoundingBoxes = true;
@@ -34 +31 @@
 void VisibilityOctreeSceneManager::_renderVisibleObjects()
 {
-        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress);
+        Camera *cullCam = NULL;
+
+        if(mCullCamera) cullCam = getCamera("CullCamera");
+        
+        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress, cullCam);
         mVisibilityManager->GetCullingManager()->InitFrame();
 

trunk/VUT/Ogre/src/OgreVisibilitySceneManager.cpp

@@ -7 +7 @@
 #include "OgreVisibilityOptionsManager.h"
 
-//#include <windows.h>
 
 namespace Ogre {

trunk/VUT/Ogre/src/OgreVisibilitySceneManagerDll.cpp

@@ -34 +34 @@
 #include <OgreRoot.h>
 
-//#include <windows.h>
 GtpVisibility::VisibilityEnvironment *visEnv;
 GtpVisibility::VisibilityManager *visManager;

trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

@@ -32 +32 @@
 void VisibilityTerrainSceneManager::_renderVisibleObjects()
 {
-        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress);
+        Camera *cullCam = NULL;
+
+        // if two cameras (one for culling, one for visualization)
+        if(mCullCamera)
+                cullCam = getCamera("CullCamera");
+        
+        if(cullCam && (mCameraInProgress != cullCam))
+                OutputDebugString("using cullcam\n");
+        else
+                OutputDebugString("not using cullcam\n");
+
+        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress, cullCam);
         mVisibilityManager->GetCullingManager()->InitFrame();