Changeset 2171 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

Timestamp:

02/27/07 10:25:01 (17 years ago)

Author:

mattausch

Message:

implemented function for exact visibility queries

File:

• GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp (modified) (9 diffs)

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

@@ -24 +24 @@
 #include "IVReader.h"
 #include "ObjReader.h"
-
+#include "OgreOcclusionQueriesQueryManager.h"
 
 
@@ -194 +194 @@
         String val;
 
-        LogManager::getSingleton().logMessage("****** OcclusionCullingSceneManager Options ********");
+        LogManager::getSingleton().
+                logMessage("****** OcclusionCullingSceneManager Options ********");
         config.load(stream);
 
@@ -717 +718 @@
                 // because shadows have low occlusion anyway
                 if ((mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE && 
-                        mIlluminationStage == IRS_RENDER_TO_TEXTURE) ||
+                         mIlluminationStage == IRS_RENDER_TO_TEXTURE) ||
                         mNormalExecution)
                 {
@@ -772 +773 @@
         {
                 // note matt: this is also called in TerrainSceneManager: really necessary?
-                mDestRenderSystem -> setLightingEnabled(false);
+                mDestRenderSystem->setLightingEnabled(false);
 
                 if (mUseItemBuffer)
@@ -1077 +1078 @@
                 * static_cast<unsigned int *>(val) = (unsigned int)algorithm;
 
-                getRenderQueue()->clear(true);
-
+                //getRenderQueue()->clear();
+
+                return true;
+        }
+        if (key == "VisibleObjects")
+        { 
+                if (mNormalExecution)
+                        return false;
+
+                const bool fromPoint = true;
+                const bool nodeVisibility = true;
+                
+                * static_cast<unsigned int *>(val) = 
+                        (unsigned int)FindExactVisibleObjects(mCameraInProgress, 
+                                                                                                  mCurrentViewport, 
+                                                                                                  fromPoint, 
+                                                                                                  nodeVisibility);
                 return true;
         }
@@ -1818 +1834 @@
 }
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::RenderDepthPass()
-{
+void OcclusionCullingSceneManager::RenderDepthPass(const bool fillRenderQueue)
+{
+        if (mNormalExecution)
+        {
+                // not in the normal workflow
+                return;
+        }
+
         // create material for depth pass
         InitDepthPass();
@@ -1853 +1875 @@
         mLeavePassesInQueue = 0;
                 
-        // the shaded geometry is rendered in a second pass
-        // add visible nodes found by the visibility culling algorithm
-        NodeList::const_iterator it, it_end = mVisible.end();
-
-        if(1) 
-        for (it = mVisible.begin(); it != it_end; ++ it)
-        {
-                (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
+        if (fillRenderQueue)
+        {
+                // the shaded geometry is rendered in a second pass
+                // add visible nodes found by the visibility culling algorithm
+                NodeList::const_iterator it, it_end = mVisible.end();
+        for (it = mVisible.begin(); it != it_end; ++ it)
+                {
+                        (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
+                }
         }
 }
@@ -1887 +1910 @@
 
 //-----------------------------------------------------------------------
-void OcclusionCullingSceneManager::_renderScene(Camera* camera, Viewport* vp, bool includeOverlays)
+void OcclusionCullingSceneManager::_renderScene(Camera* camera, 
+                                                                                                Viewport* vp, 
+                                                                                                bool includeOverlays)
 {
     Root::getSingleton()._setCurrentSceneManager(this);
@@ -2057 +2082 @@
     camera->_notifyRenderedFaces(mDestRenderSystem->_getFaceCount());
 }
-
+//-----------------------------------------------------------------------
+int OcclusionCullingSceneManager::FindExactVisibleObjects(Camera *camera,
+                                                                                                                  Viewport* vp,
+                                                                                                                  const bool fromPoint,
+                                                                                                                  const bool nodeVisibility)
+{
+        const int itemBufferMode = 0;
+        const bool relativeVisibility = false;
+
+        int queryModes = 0;
+
+        if (nodeVisibility)
+                queryModes |= GtpVisibility::QueryManager::NODE_VISIBILITY;
+        else
+                queryModes |= GtpVisibility::QueryManager::GEOMETRY_VISIBILITY;
+
+        OcclusionQueriesQueryManager *queryManager = 
+                new OcclusionQueriesQueryManager(mHierarchyInterface,
+                                                                                 vp,
+                                                                                 queryModes, 
+                                                                                 itemBufferMode);
+
+        mVisibilityManager->SetQueryManager(queryManager);
+
+        GtpVisibility::NodeInfoContainer visibleNodes;
+        GtpVisibility::MeshInfoContainer visibleGeometry;
+        GtpVisibility::PatchInfoContainer visiblePatches;
+
+        if (fromPoint)
+        {
+                queryManager->ComputeFromPointVisibility(camera->getDerivedPosition(), 
+                                                                                                 &visibleNodes, 
+                                                                                                 &visibleGeometry, 
+                                                                                                 &visiblePatches, 
+                                                                                                 relativeVisibility);
+        }
+        else
+        {
+                queryManager->ComputeCameraVisibility(*camera,
+                                                                                          &visibleNodes, 
+                                                                                          &visibleGeometry, 
+                                                                                          &visiblePatches, 
+                                                                                          relativeVisibility);
+        }
+                
+        if (0)
+        {
+                std::stringstream d; 
+                d << "Query mode: " << queryModes 
+                  << " visible nodes: " << (int)visibleNodes.size() 
+                  << " visible geometry: " << (int)visibleGeometry.size();
+
+                LogManager::getSingleton().logMessage(d.str());
+        }
+
+        ///////////////////////
+        //-- put items in render queue
+        //////////
+
+        getRenderQueue()->clear();
+
+        //////////////////////
+        //-- apply queries on geometry level
+
+        if (!nodeVisibility)
+        {
+                GtpVisibility::MeshInfoContainer::iterator geomIt, geomIt_end = visibleGeometry.end();
+
+                for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt)
+                {
+                        MovableObject *mo = (*geomIt).GetSource();
+
+                        // add if not 0
+                        if (!(*geomIt).GetVisiblePixels())
+                                continue;
+
+                        mo->_notifyCurrentCamera(camera);
+
+                        if (mo->isVisible())
+                        {
+                                mo->_updateRenderQueue(getRenderQueue());
+                        }
+                }
+        }
+        else
+        {
+                ////////////////
+                //-- apply queries on node level
+
+                GtpVisibility::NodeInfoContainer::iterator nodesIt, nodesIt_end = visibleNodes.end();
+
+                for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++ nodesIt)
+                {
+                        if (!(*nodesIt).GetVisiblePixels())
+                                continue;
+
+                        Octree *octree = static_cast<Octree *>((*nodesIt).GetSource());
+
+                        NodeList::iterator nIt, nIt_end = octree->mNodes.end();
+
+                        for (nIt = octree->mNodes.begin(); nIt != nIt_end; ++ nIt)
+                        {
+                                (*nIt)->_addToRenderQueue(camera, getRenderQueue(), false);
+                        }
+                }
+        }
+
+    delete queryManager;
+
+        if (nodeVisibility)
+                return (int)visibleNodes.size();
+        else
+                return (int)visibleGeometry.size();
+}
+//-----------------------------------------------------------------------
+void OcclusionCullingSceneManager::RenderDepthForQuery(Camera* camera, 
+                                                                                                           Viewport* vp)
+{
+    Root::getSingleton()._setCurrentSceneManager(this);
+        mActiveQueuedRenderableVisitor->targetSceneMgr = this;
+
+    mCameraInProgress = camera;
+
+    // Update scene graph for this camera (can happen multiple times per frame)
+    _updateSceneGraph(camera);
+
+    // Invert vertex winding?
+    if (camera->isReflected())
+    {
+        mDestRenderSystem->setInvertVertexWinding(true);
+    }
+    else
+    {
+        mDestRenderSystem->setInvertVertexWinding(false);
+    }
+
+    // Tell params about viewport
+    mAutoParamDataSource.setCurrentViewport(vp);
+    // Set the viewport
+    setViewport(vp);
+
+    // Tell params about camera
+    mAutoParamDataSource.setCurrentCamera(camera);
+    // Set autoparams for finite dir light extrusion
+    mAutoParamDataSource.setShadowDirLightExtrusionDistance(mShadowDirLightExtrudeDist);
+
+    // Tell params about current ambient light
+    mAutoParamDataSource.setAmbientLightColour(mAmbientLight);
+        // Tell rendersystem
+        mDestRenderSystem->setAmbientLight(mAmbientLight.r, mAmbientLight.g, mAmbientLight.b);
+
+    // Tell params about render target
+    mAutoParamDataSource.setCurrentRenderTarget(vp->getTarget());
+
+
+    // Set camera window clipping planes (if any)
+    if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_USER_CLIP_PLANES))
+    {
+        if (camera->isWindowSet())  
+        {
+            const std::vector<Plane>& planeList = 
+                camera->getWindowPlanes();
+            for (ushort i = 0; i < 4; ++i)
+            {
+                mDestRenderSystem->enableClipPlane(i, true);
+                mDestRenderSystem->setClipPlane(i, planeList[i]);
+            }
+        }
+        else
+        {
+            for (ushort i = 0; i < 4; ++i)
+            {
+                mDestRenderSystem->enableClipPlane(i, false);
+            }
+        }
+    }
+
+        // Prepare render queue for receiving new objects
+        prepareRenderQueue();
+
+        // Begin the frame
+    mDestRenderSystem->_beginFrame();
+
+    // Set rasterisation mode
+    mDestRenderSystem->_setPolygonMode(camera->getPolygonMode());
+
+        // Set initial camera state
+        mDestRenderSystem->_setProjectionMatrix(mCameraInProgress->getProjectionMatrixRS());
+        mDestRenderSystem->_setViewMatrix(mCameraInProgress->getViewMatrix(true));
+
+        // // Render scene content in order fill depth buffer
+        bool savedUseDepthPass = mUseDepthPass;
+        mUseDepthPass = true;
+
+        // don't need shading, render only depth pass
+        const bool fillQueue = false;
+        RenderDepthPass(fillQueue);
+        // _renderVisibleObjects();
+    
+        mUseDepthPass = savedUseDepthPass;
+   
+    // End frame
+    mDestRenderSystem->_endFrame();
+}
 //-----------------------------------------------------------------------
 const String OcclusionCullingSceneManagerFactory::FACTORY_TYPE_NAME = "OcclusionCullingSceneManager";