Changeset 130 for trunk/VUT/Ogre/src

Timestamp:

06/14/05 02:50:05 (20 years ago)

Author:

mattausch

Message:

added visibility queries

Location:

trunk/VUT/Ogre/src

Files:

• OgreOctreeHierarchyInterface.cpp (modified) (3 diffs)
• OgrePlatformHierarchyInterface.cpp (modified) (7 diffs)
• OgreSceneContentGenerator.cpp (modified) (1 diff)
• OgreSceneNodeHierarchyInterface.cpp (modified) (3 diffs)
• OgreTerrainContentGenerator.cpp (modified) (1 diff)
• OgreVisibilityTerrainSceneManager.cpp (modified) (10 diffs)

trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

@@ -9 +9 @@
 
 //-----------------------------------------------------------------------
-OctreeHierarchyInterface::OctreeHierarchyInterface(SceneManager *sm, RenderSystem *rsys): 
-PlatformHierarchyInterface(sm, rsys)
+OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, RenderSystem *rsys): 
+SceneNodeHierarchyInterface(sm, rsys)
 {
 }
@@ -106 +106 @@
                 octant->setLastRendered(mFrameId);
 
-                static_cast<OctreeSceneManager *>(mSceneManager)->_renderOctant(mCamera, 
+                dynamic_cast<OctreeSceneManager *>(mSceneManager)->_renderOctant(mCamera, 
                         octant, mOnlyShadowCasters, mLeaveTransparentsInQueue);
 
-                mNumRenderedNodes ++;
+                mRenderedNodes.push_back(node);
         }
 #endif
@@ -157 +157 @@
         }
 
-        static_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box);
-}
+        dynamic_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box);
+}
+//-----------------------------------------------------------------------
+void OctreeHierarchyInterface::GetGeometry(GtpVisibility::HierarchyNode *node,  
+                                                                                   GtpVisibility::GeometryList *geometryList, 
+                                                                                   bool includeChildren)
+{
+        NodeList::const_iterator nodeIt, nodeIt_end;
+        nodeIt_end = static_cast<Octree *>(node)->mNodes.end();
+
+        for (nodeIt = static_cast<Octree *>(node)->mNodes.begin(); nodeIt != nodeIt_end; ++nodeIt)
+        {
+                SceneNodeHierarchyInterface::GetGeometry(*nodeIt, geometryList, includeChildren);
+        }
+}
+//-----------------------------------------------------------------------
+/*bool OctreeHierarchyInterface::FindVisibleObjects(GtpVisibility::HierarchyNode *node, 
+                                                                        InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
+                                                                        bool includeChildren)
+{
+        bool foundVisible = false;
+
+        PlatformOcclusionQuery query(mRenderSystem);
+
+        NodeList *nodes = &static_cast<Octree *>(node)->mNodes;
+        
+        NodeList::const_iterator nodeIt = nodes->begin(), nodeIt_end;
+        
+        nodeIt_end = nodes->end();
+
+        while (nodeIt != nodeIt_end)
+        {
+                OctreeNode *octreeNode = (*nodeIt);
+                if (SceneNodeHierarchyInterface::FindVisibleObjects(octreeNode, visibleGeometry, includeChildren))
+                {
+                        foundVisible = true;
+                }
+                ++nodeIt;
+        }
+
+        return foundVisible;
+}*/
+
 } // namespace Ogre

trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp

@@ -1 +1 @@
 #include <OgreCamera.h>
 #include <OgreLogManager.h>
+#include <OgreSubEntity.h>
+#include <OgreEntity.h>
+#include <OgreMovableObject.h>
 #include "OgreSolidBoundingBox.h"
 #include "OgrePlatformHierarchyInterface.h"
@@ -138 +141 @@
         mCullCamera = cullCam ? cullCam : cam;
 
-        if (mCullCamera != mCamera)
-                LogManager::getSingleton().logMessage("cullcamera is not camera!");
+        //if (mCullCamera != mCamera)
+        //      LogManager::getSingleton().logMessage("cullcamera is not camera");
 
         // create materials for node visualization
@@ -186 +189 @@
         {
                 mIsBoundingBoxQuery = true;
+
                 //LogManager::getSingleton().logMessage("render box\n");
                 RenderBoundingBox(GetBoundingBox(node));
@@ -197 +201 @@
 }
 //-----------------------------------------------------------------------
-void PlatformHierarchyInterface::SetOcclusionPass()
+GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery(GtpVisibility::Mesh *mesh)
+{
+        // get next available test id
+        GtpVisibility::OcclusionQuery *query = GetNextOcclusionQuery();
+
+        //-- the actual query test
+        query->BeginQuery();
+        
+        RenderGeometry(mesh);
+
+        query->EndQuery();
+
+        return query;
+}
+//-----------------------------------------------------------------------
+/*void PlatformHierarchyInterface::SetOcclusionPass()
 {
     // disable vertex and fragment program
@@ -215 +234 @@
         // Set colour write mode off
         mRenderSystem->_setColourBufferWriteEnabled(false, false, false, false);
-}
+}*/
 //-----------------------------------------------------------------------
 SolidBoundingBox *PlatformHierarchyInterface::GetSolidBoundingBox()
@@ -228 +247 @@
 {
         mOnlyShadowCasters = onlyShadowCasters;
-        //mIsShadowPass = mOnlyShadowCasters ;
 }
 //-----------------------------------------------------------------------
@@ -245 +263 @@
         return mIsBoundingBoxQuery;
 }
+//-----------------------------------------------------------------------
+void PlatformHierarchyInterface::RenderGeometry(GtpVisibility::Mesh *geom)
+{
+        mSceneManager->_renderMovableObject(geom, mLeaveTransparentsInQueue);
+}
+//-----------------------------------------------------------------------
+SceneManager *PlatformHierarchyInterface::GetSceneManager()
+{
+        return mSceneManager;
+}
+//-----------------------------------------------------------------------
+RenderSystem *PlatformHierarchyInterface::GetRenderSystem()
+{
+        return mRenderSystem;
+}
 } // namespace Ogre

trunk/VUT/Ogre/src/OgreSceneContentGenerator.cpp

@@ -186 +186 @@
         return true;
 }
+
 } // namespace Ogre

trunk/VUT/Ogre/src/OgreSceneNodeHierarchyInterface.cpp

@@ -1 @@
-#include "OgreSceneNodeHierarchyInterface.h"
 #include <OgreIteratorWrappers.h>
 #include <OgreCamera.h>
 #include <OgreSceneNode.h>
+#include <OgreEntity.h>
+#include <OgreSubEntity.h>
+#include <OgreLogManager.h>
+#include "OgreSceneNodeHierarchyInterface.h"
+#include "OgrePlatformOcclusionQuery.h"
+
 
 namespace Ogre {
@@ -40 +45 @@
         {
                 sceneNode->setLastRendered(sceneNode->lastVisited());
-                mNumRenderedNodes ++;
+                mRenderedNodes.push_back(node);
 
                 mSceneManager->_renderSceneNode(mCamera, sceneNode, mLeaveTransparentsInQueue);
@@ -130 +135 @@
         // TODO
 }
+//-----------------------------------------------------------------------
+void SceneNodeHierarchyInterface::GetGeometry(GtpVisibility::HierarchyNode *node,       
+                                                                                          GtpVisibility::GeometryList *geometryList, 
+                                                                                          bool includeChildren)
+{
+        SceneNode::ObjectIterator objIt = 
+                static_cast<SceneNode *>(node)->getAttachedObjectIterator();
+
+        while (objIt.hasMoreElements())
+    {
+                MovableObject *movable = objIt.getNext();
+                
+                // we are interested only in the entities, i.e., intances of geometry
+                if (movable->getMovableType() == "Entity")
+                {
+                        Entity *ent = static_cast<Entity *>(movable);
+                        //std::stringstream d; d << "ent " << ent->getName(); 
+                        //LogManager::getSingleton().logMessage(d.str());
+                        geometryList->push_back(ent);
+                }
+    }
+}
 } // namespace Ogre     

trunk/VUT/Ogre/src/OgreTerrainContentGenerator.cpp

@@ -68 +68 @@
 //-----------------------------------------------------------------------
 SceneNode *TerrainContentGenerator::GenerateSceneObject(const Vector3 &position, 
-                                         const Vector3 &rotation, const String& objName)
+                                         const Vector3 &rotation, const String& objName, const bool clampToTerrain)
 {
         Vector3 queryResult;
         // set y to max height so we are sure to be over terrain
         Vector3 pos(position.x, MAX_HEIGHT, position.z);
+
+        if (!clampToTerrain)
+        {
+                return SceneContentGenerator::GenerateSceneObject(queryResult, rotation, objName);
+        }
 
         if (mRayQueryExecutor->executeRayQuery(&queryResult, position, Vector3::NEGATIVE_UNIT_Y))

trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

@@ -24 +24 @@
 mDelayRenderTransparents(true),
 mUseDepthPass(false),
-mRenderItemBuffer(true),
+mRenderItemBuffer(false),
 mCurrentEntityId(0)
 {
         mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
-
+        mQueryManager = new PlatformQueryManager(mHierarchyInterface, mCurrentViewport);
+
+        mVisibilityManager->SetQueryManager(mQueryManager);
         //mDisplayNodes = true;
         //mShowBoundingBoxes = true;
@@ -87 +89 @@
                 mHierarchyInterface = NULL;
         }
+        if (mQueryManager)
+        {
+                delete mQueryManager;
+                mQueryManager = NULL;
+        }
 }
 //-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::ShowVisualization(Camera *cam)
 {
-        LogManager::getSingleton().logMessage("***********VISUALIZATION************");
         // add player camera for visualization purpose
         try 
@@ -189 +195 @@
                 setAmbientLight(ColourValue(1,1,1,1));
         }
-
-        LogManager::getSingleton().logMessage("***********FIND OBJECTS************");
-        getRenderQueue()->clear();
+        //getRenderQueue()->clear();
 
         //-- show visible scene nodes and octree bounding boxes from last frame
@@ -221 +225 @@
 void VisibilityTerrainSceneManager::_renderVisibleObjects()
 {
-        /*
-        std::stringstream d;
-        d << "Terrain render level: " << TerrainRenderable::getCurrentRenderLevelIndex();
-        LogManager::getSingleton().logMessage(d.str());
-
         // increase terrain renderlevel
         int renderLevel = TerrainRenderable::getCurrentRenderLevelIndex() + 1;
@@ -233 +232 @@
                 renderLevel = 0;
         }
-*/
+
         // visualization: apply standard rendering
         if (mShowVisualization)
         {       
                 TerrainSceneManager::_renderVisibleObjects();
-        //      TerrainRenderable::setCurrentRenderLevelIndex(renderLevel);
+                TerrainRenderable::setCurrentRenderLevelIndex(renderLevel);
                 return;
         }
-
-        LogManager::getSingleton().logMessage("***********RENDER OBJECTS************");
 
         InitDepthPass();        // create material for depth pass
@@ -309 +306 @@
         TerrainSceneManager::_renderVisibleObjects();
 
-        //TerrainRenderable::setCurrentRenderLevelIndex(renderLevel);
+        TerrainRenderable::setCurrentRenderLevelIndex(renderLevel);
         //WriteLog(); // write out stats
 }
@@ -374 +371 @@
         // notifiy that frame has ended so terrain render level can be reset for correct
         // terrain rendering
-/*      if (key == "TerrainLevelIdx")
+        if (key == "TerrainLevelIdx")
         {
                 TerrainRenderable::setCurrentRenderLevelIndex((*static_cast<const int *>(val)));
                 return true;
-        }*/
+        }
         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                 setOption(key, val) || TerrainSceneManager::setOption(key, val);
@@ -507 +504 @@
                                 //<< ", renderable name: " << irend->
                                 RenderSingleObjectForItemBuffer(*irend, ipass->first);
-                                RenderSingleObjectForOcclusionQuery(
+                                //RenderSingleObjectForOcclusionQuery(
                 }
         }
@@ -562 +559 @@
         //LogManager::getSingleton().logMessage("has vertex program");
         Pass *usedPass = setPass(mItemBufferPass); 
-//Pass *usedPass = setPass(pass);
+        //Pass *usedPass = setPass(pass);
         std::stringstream d;
         d << "item buffer id: " << rend->getId() << ", col: " << col;
@@ -571 +568 @@
 }
 //-----------------------------------------------------------------------
-Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName, const String& meshName)
+GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::GetVisibilityManager()
+{
+        return mVisibilityManager;
+}
+//-----------------------------------------------------------------------
+Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName, 
+                                                                                                        const String& meshName)
 {
         Entity *ent = SceneManager::createEntity(entityName, meshName);
 
-        for (int i = 0; i < ent->getNumSubEntities(); ++i)
+        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
         {
                 ent->getSubEntity(i)->setId(mCurrentEntityId ++);