Changeset 154 for trunk/VUT/Ogre/src

Timestamp:

07/04/05 17:57:51 (19 years ago)

Author:

mattausch

Message:

added item buffer queries.

Location:

trunk/VUT/Ogre/src

Files:

• OgreItemBufferQueryManager.cpp (modified) (6 diffs)
• OgreOcclusionQueriesQueryManager.cpp (added)
• OgreOctreeHierarchyInterface.cpp (modified) (2 diffs)
• OgrePlatformQueryManager.cpp (modified) (4 diffs)
• OgreSceneNodeHierarchyInterface.cpp (modified) (2 diffs)
• OgreVisibilityOctreeSceneManager.cpp (modified) (1 diff)
• OgreVisibilityTerrainSceneManager.cpp (modified) (6 diffs)

trunk/VUT/Ogre/src/OgreItemBufferQueryManager.cpp

@@ -8 +8 @@
 //----------------------------------------------------------------------- 
 ItemBufferQueryManager::ItemBufferQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp):
-PlatformQueryManager(hierarchyInterface, vp), mWasInitialised(false)
+PlatformQueryManager(hierarchyInterface, vp)
 {
 }
@@ -23 +23 @@
                             bool relativeVisibility)
 {
-        // initialise item buffer if necessary
+        // initialise item buffer (if not already initialised)
         InitItemBuffer(visibleNodes, visibleGeometry);
 
@@ -45 +45 @@
         sm->setOption("UseItemBuffer", &useItemBuffer);
         
-        // clear background with black
+        // clear background with black (i.e., not a valid item id)
         ColourValue bg = mViewport->getBackgroundColour();
         mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0));
@@ -70 +70 @@
         uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy);
 
+        
         // loop through frame buffer & collect visible pixels
         for (int idx = 0; idx < dimy * dimx * 3; idx += 3)
         {
+                // -- decode color code to receive id
                 int id = buf[idx] << 16;
                 id += buf[idx + 1] << 8;
                 id += buf[idx + 2];
 
-                // if valid id <= add visibility
-                if ((id >= 0) && (id < (int)visibleGeometry->size()))
+                // if valid id <= add visibility (id values start at 1
+                if ((id > 0) && (id < (int)visibleGeometry->size()))
                 {
                         ((*visibleGeometry)[id]).AddVisibility(1, 1);
                 }
-        /*      else
-                { 
-                        std::stringstream d; 
-                        d << "id: " << id << ", buf 1: " << (int)buf[idx] << ", buf 2: " << (int)buf[idx + 1] << ", buf 3: " << (int)buf[idx + 2];
-                        LogManager::getSingleton().logMessage(d.str());
-                }*/
+                /*else {        std::stringstream d; 
+                        d << "adding pixel to geometry with id: " << id << ", buf 1: " << (int)buf[idx] << ", buf 2: " << (int)buf[idx + 1] << ", buf 3: " << (int)buf[idx + 2];
+                        LogManager::getSingleton().logMessage(d.str()); }*/
         }
 
@@ -104 +103 @@
         mWasInitialised = true;
 
-        SceneManager::EntityIterator it = dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->
+        SceneManager::EntityIterator it = 
+                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->
                 GetSceneManager()->getEntityIterator();
 
         // TODO: make this more efficient
         visibleGeometry->clear();
+        visibleNodes->clear();
 
         while (it.hasMoreElements())
@@ -115 +116 @@
         }
 }
-//-----------------------------------------------------------------------
-void ItemBufferQueryManager::ComputeFromPointVisibility(const Vector3 &point,
-                               InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
-                               InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                               bool relativeVisibility)
-{
-        SceneManager *sm = dynamic_cast<PlatformHierarchyInterface *>
-                (mHierarchyInterface)->GetSceneManager();
-
-        Camera *cam = sm->createCamera("PointQueryCam");        
-
-        //save old camera
-        Camera *savedCam = mViewport->getCamera();
-        
-        // --- initialise new camera
-        mViewport->setCamera(cam);
-        cam->setPosition(point);
-
-        cam->setNearClipDistance(savedCam->getNearClipDistance());
-        cam->setFarClipDistance(savedCam->getFarClipDistance());
-
-        // set frustum to 45 degrees so all the scene can be captured with 6 shots
-        cam->setAspectRatio(1.0);
-        cam->setFOVy(Radian(Math::HALF_PI));
-
-        int sign = -1;
-        
-        // ---- capture visibility from all 6 directions
-        for (int i=0; i < 6; i++)       
-        {
-                sign *= -1;
-                
-                // Print camera details
-        std::stringstream d;
-                d << "Point query camera: " + StringConverter::toString(cam->getDerivedPosition()) + 
-                        " " + "O: " + StringConverter::toString(cam->getDerivedOrientation());
-                LogManager::getSingleton().logMessage(d.str());
-
-                // prevent from initialising array again
-                if (i > 0)
-                        mWasInitialised = true;
-                
-                // compute camera visibility for this direction
-                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility);
-
-                //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait"); // HACK: DISPLAY CAMERA VIEW
-
-                // --- permute directions
-                Vector3 dir(0,0,0);
-                dir[i/2] = sign;
-
-                cam->setDirection(dir);
-        }
-        
-        // reset camera
-        mViewport->setCamera(savedCam);
-}
-
 } // namespace Ogre

trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

@@ -55 +55 @@
 }
 //-----------------------------------------------------------------------
-void OctreeHierarchyInterface::SetNumOctreeNodes(unsigned int num)
-{
-        mNumOctreeNodes = num;
-}
-//-----------------------------------------------------------------------
 float OctreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
 {
@@ -173 +168 @@
                 SceneNodeHierarchyInterface::GetGeometry(*nodeIt, geometryList, includeChildren);
         }
+}
+//-----------------------------------------------------------------------
+void OctreeHierarchyInterface::SetNodeId(GtpVisibility::HierarchyNode *node, int id)
+{
+        static_cast<Octree *>(node)->setId(id);
+}
+//-----------------------------------------------------------------------
+int OctreeHierarchyInterface::GetNodeId(GtpVisibility::HierarchyNode *node)
+{
+        return static_cast<Octree *>(node)->getId();
 }
 //-----------------------------------------------------------------------

trunk/VUT/Ogre/src/OgrePlatformQueryManager.cpp

@@ -10 +10 @@
 //----------------------------------------------------------------------- 
 PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp):
-QueryManager(hierarchyInterface), mViewport(vp)
+QueryManager(hierarchyInterface), mViewport(vp), mWasInitialised(false)
 {
 }
@@ -18 +18 @@
     // run OGRE ray shooting query
     return false;
-}
-//-----------------------------------------------------------------------
-void PlatformQueryManager::ComputeCameraVisibility(const Camera &camera,
-                            InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
-                            InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                            bool relativeVisibility)
-{
-        // we need access to the scene manager and the rendersystem
-        PlatformHierarchyInterface *pfHierarchyInterface = 
-                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface);
-
-        //-- Render scene to get conservative visibility and fill depth buffer 
-
-        // const_cast allowed because camera is not changed in renderScene
-        Camera *pCam = const_cast<Camera *>(&camera); 
-
-        // disable overlays, reset them later
-        bool overlayEnabled = mViewport->getOverlaysEnabled();
-        mViewport->setOverlaysEnabled(false);
-
-        //-- render the scene once to update depth buffer
-        pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false);
-
-        /* 
-                Two query lists for projected pixels and for visibile pixels:
-                We test queries after a rendering pass 
-                to get exact visibility with regard to the current camera.
-                We issue all queries at once to avoid starvation & stalls.
-        */
-        GtpVisibility::QueryList queryList[2];
-        
-        // get rendered hierarchy nodes
-        GtpVisibility::HierarchyNodeList *nodeList = mHierarchyInterface->GetRenderedNodes();
-        // vector for storing entities of meshes
-        GtpVisibility::GeometryList geometryList;
-        
-        GtpVisibility::HierarchyNodeList::iterator nodeIt, nodeIt_end = nodeList->end();
-        // geometry list has still do be built
-        GtpVisibility::GeometryList::iterator geometryIt, geometryIt_end;
-
-        // to obtain the correct number of projected pixels, depth write must be disabled
-        bool enableDepthWrite = false;
-
-        // this option must be provided by the scene manager
-        pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite);
-
-        /* relative visiblity:
-                1) get visible pixels count of objects
-                2) clear frame buffer
-                3) get projected visible pixels count:
-                   test all objects again without depth write (set as option in scene manager)
-                4) calculate ratio between visible vs. projected pixels
-        */
-        // for relative visibility we need 2 rendering passes
-        int n = relativeVisibility ? 2 : 1;
-        
-        for (int i=0; i<n; ++i)
-        {
-                //-- queries for hierarchy nodes
-                for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)                
-                {
-                        // TODO: DELETE QUERIES FROM PREVIOUS RENDER
-                        queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*nodeIt, false));
-                        
-                        // store geometry of the hierarchy node in a geometry list (only once!)
-                        if (i == 0)
-                        {
-                                mHierarchyInterface->GetGeometry(*nodeIt, &geometryList, false);
-                        }
-                }
-
-                geometryIt_end = geometryList.end();
-
-                //-- add queries for geometry
-                for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt)
-                {
-                        queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt));
-                }
-
-        
-                pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_DEPTH);
-        }
-
-        enableDepthWrite = true;
-        // this option must be provided by the scene manager
-        pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite);
-        // reset old overlay status
-        mViewport->setOverlaysEnabled(overlayEnabled);
-
-        //---- collect results
-        GtpVisibility::QueryList::iterator visQueryIt, projQueryIt;
-
-        visQueryIt = queryList[0].begin();
-        projQueryIt = queryList[1].begin();
-
-        
-        for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)
-        {
-                unsigned int visiblePixels = 0;
-                (*visQueryIt)->GetQueryResult(visiblePixels, true);
-        
-                unsigned int projectedPixels = 0;
-
-                if (relativeVisibility)
-                {
-                        (*projQueryIt)->GetQueryResult(projectedPixels, true);
-                
-                        ++projQueryIt;
-                }
-
-                ++visQueryIt;
-                
-                // node with visibilty 0 in queue (e.g., if node is intersected by near plane)
-                if (visiblePixels > 0)
-                {
-                        visibleNodes->push_back(GtpVisibility::NodeInfo(*nodeIt, visiblePixels, projectedPixels));
-                }
-        }
-
-        //---- queries for geometry
-        geometryIt_end = geometryList.end();
-        
-        for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt)
-        {
-                unsigned int visiblePixels = 0;
-                (*visQueryIt)->GetQueryResult(visiblePixels, true);
-                
-                unsigned int projectedPixels = 0;
-
-                if (relativeVisibility)
-                {
-                        (*projQueryIt)->GetQueryResult(projectedPixels, true);
-
-                        ++projQueryIt;
-                }
-
-                ++visQueryIt;
-
-                // approximate depth ordering during rendering => 
-                // geometry maybe occluded
-                if (visiblePixels > 0)
-                {                        
-                        visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt, visiblePixels, 
-                                projectedPixels));
-                }
-        }
-
-}
-//-----------------------------------------------------------------------
-inline bool nodeinfo_eq(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2) 
-{ 
-        return info1.GetNode() == info2.GetNode(); 
-}
-//-----------------------------------------------------------------------
-inline bool meshinfo_eq(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2) 
-{ 
-        return info1.GetMesh() == info2.GetMesh(); 
-}
-//-----------------------------------------------------------------------
-inline bool nodeinfo_lower(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2) 
-{ 
-        return info1.GetNode() < info2.GetNode(); 
-}
-//-----------------------------------------------------------------------
-inline bool meshinfo_lower(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2) 
-{ 
-        return info1.GetMesh() < info2.GetMesh(); 
 }
 //-----------------------------------------------------------------------
@@ -222 +55 @@
                 LogManager::getSingleton().logMessage(d.str());
 
+                // prevent from initialising geometry / node array again
+                if (i > 0)
+                        mWasInitialised = true;
+
                 ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility);
                 
@@ -235 +72 @@
         // reset camera
         mViewport->setCamera(savedCam);
-
-        // --- remove duplicates (duplicates occur if an object is on the edge of the viewport)
-
-        // before duplicates can be deleted we have to add up their visibility
-
-        // --- visible nodes
-        sort(visibleNodes->begin(), visibleNodes->end(), nodeinfo_lower);
-        InfoContainer<GtpVisibility::NodeInfo>::iterator visibleNodesIt,
-                visibleNodesIt_end = visibleNodes->end();
-        
-        GtpVisibility::NodeInfo *nodeInfo = NULL;
-
-        for (visibleNodesIt = visibleNodes->begin(); visibleNodesIt != visibleNodesIt_end; 
-                ++visibleNodesIt)
-        {
-                if (!nodeInfo || (nodeInfo->GetNode() != (*visibleNodesIt).GetNode()))
-                {
-                        nodeInfo = &(*visibleNodesIt);
-                }
-                else // add visibility
-                {                       
-                        nodeInfo->AddVisibility(*visibleNodesIt);
-                }
-
-        }
-        
-        // physically delete duplicates
-        visibleNodes->erase( std::unique(visibleNodes->begin(), 
-                visibleNodes->end(), nodeinfo_eq), visibleNodes->end());
-
-        // --- visible geometry
-        sort(visibleGeometry->begin(), visibleGeometry->end(), meshinfo_lower);
-        InfoContainer<GtpVisibility::MeshInfo>::iterator visibleGeomIt,
-                visibleGeomIt_end = visibleGeometry->end();
-
-        GtpVisibility::MeshInfo *geomInfo = NULL;
-
-        int i=0;
-        for (visibleGeomIt = visibleGeometry->begin(); visibleGeomIt != visibleGeomIt_end; 
-                ++visibleGeomIt)
-        {
-                if (!geomInfo || (geomInfo->GetMesh() != (*visibleGeomIt).GetMesh()))
-                {
-                        geomInfo = &(*visibleGeomIt);
-                }
-                else // info points to same mesh, just add visibility
-                {
-                        geomInfo->AddVisibility(*visibleGeomIt);
-                }
-        }
-
-        // physically delete duplicates
-        visibleGeometry->erase(std::unique(visibleGeometry->begin(), visibleGeometry->end(), 
-                meshinfo_eq), visibleGeometry->end());
-        
 }
 //-----------------------------------------------------------------------

trunk/VUT/Ogre/src/OgreSceneNodeHierarchyInterface.cpp

@@ -147 +147 @@
                 MovableObject *movable = objIt.getNext();
                 
-                // we are interested only in the entities, i.e., intances of geometry
+                // we are interested only in the entities, i.e., instances of geometry
                 if (movable->getMovableType() == "Entity")
                 {
@@ -156 +156 @@
     }
 }
+//-----------------------------------------------------------------------
+void SceneNodeHierarchyInterface::SetNodeId(GtpVisibility::HierarchyNode *node, int id)
+{
+        static_cast<SceneNode *>(node)->setId(id);
+}
+//-----------------------------------------------------------------------
+int SceneNodeHierarchyInterface::GetNodeId(GtpVisibility::HierarchyNode *node)
+{
+        return static_cast<SceneNode *>(node)->getId();
+}
 } // namespace Ogre     

trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

@@ -259 +259 @@
         mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
 
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-    mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes);
-#endif
         OctreeSceneManager::_updateSceneGraph(cam);
 }

trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

@@ -24 +24 @@
 mUseDepthPass(false),
 mRenderDepthPass(false),
-//mUseItemBuffer(false),
-mUseItemBuffer(true),
+mUseItemBuffer(false),
+//mUseItemBuffer(true),
 mRenderItemBuffer(false),
-mCurrentEntityId(0),
+mCurrentEntityId(1),
 mEnableDepthWrite(true),
 mSkipTransparents(false),
@@ -327 +327 @@
                 
         // set the new render level index afterwards => new level in the next frame 
-        int levelIdx = (TerrainRenderable::getCurrentRenderLevelIndex() + 1) % 10;
+        int levelIdx = TerrainRenderable::getCurrentRenderLevelIndex() + 1;
         TerrainRenderable::setCurrentRenderLevelIndex(levelIdx);
 
@@ -343 +343 @@
         mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
 
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-    mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes);
-#endif
         TerrainSceneManager::_updateSceneGraph(cam);
 }
@@ -567 +564 @@
         int col[4];
         
+        // -- create color code out of object id
         col[0] = (rend->getId() >> 16) & 255;
         col[1] = (rend->getId() >> 8) & 255;
@@ -599 +597 @@
 
         Pass *usedPass = setPass(mItemBufferPass); 
-        //Pass *usedPass = setPass(pass);
-        
-        if (rend->getId() > 0)
+        
+        /*if (rend->getId() > 0)
         {
                 std::stringstream d; d << "item buffer id: " << rend->getId() << ", col: " << col[0] <<
                         " " << col[1] << " " << col[2] << " " << col[3];
                 LogManager::getSingleton().logMessage(d.str());
-        }
+        }*/
 
         // Render a single object, this will set up auto params if required
         renderSingleObject(rend, usedPass, false, &nullLightList);
-
-        // reset colour
-        //mDestRenderSystem->setColour(255, 255, 255, 255);
 }
 //-----------------------------------------------------------------------
@@ -630 +624 @@
         }
 
+        // increase counter of entity id values
         ++ mCurrentEntityId;