Changeset 159 for trunk/VUT/Ogre/src

Timestamp:

07/06/05 17:52:44 (19 years ago)

Author:

mattausch

Message:

added flags for switching on/off transparents for item buffer and vertex programs for depth pass / item buffer

Location:

trunk/VUT/Ogre/src

Files:

• OgreItemBufferQueryManager.cpp (modified) (7 diffs)
• OgreOcclusionQueriesQueryManager.cpp (modified) (2 diffs)
• OgreOctreeHierarchyInterface.cpp (modified) (1 diff)
• OgrePlatformHierarchyInterface.cpp (modified) (1 diff)
• OgrePlatformQueryManager.cpp (modified) (2 diffs)
• OgreSceneContentGenerator.cpp (modified) (1 diff)
• OgreVisibilityOctreeSceneManager.cpp (modified) (10 diffs)
• OgreVisibilityTerrainSceneManager.cpp (modified) (22 diffs)

trunk/VUT/Ogre/src/OgreItemBufferQueryManager.cpp

@@ -3 +3 @@
 #include <OgreStringConverter.h>
 #include <vector>
-
+#include <OgreSubEntity.h>
 
 namespace Ogre {
 //----------------------------------------------------------------------- 
-ItemBufferQueryManager::ItemBufferQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp):
-PlatformQueryManager(hierarchyInterface, vp)
+ItemBufferQueryManager::ItemBufferQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp,
+                                                                                           const bool renderPatches):
+PlatformQueryManager(hierarchyInterface, vp), mRenderPatchesForItemBuffer(renderPatches)
 {
 }
@@ -21 +22 @@
                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
+                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches,
                             bool relativeVisibility)
 {
         // initialise item buffer (if not already initialised)
-        InitItemBuffer(visibleNodes, visibleGeometry);
+        InitItemBuffer(visibleNodes, visibleGeometry, visiblePatches);
 
         // we need access to the scene manager and the rendersystem
@@ -32 +34 @@
         SceneManager *sm = pfHierarchyInterface->GetSceneManager();
 
-        // ---- Render scene with item buffer (i.e., objects with their id as color codes)
+        // --- Render scene with item buffer (i.e., objects with their id as color codes)
 
         // const_cast allowed because camera is not changed in renderScene
@@ -61 +63 @@
         uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy);
 
+        int n = mRenderPatchesForItemBuffer ? (int)visiblePatches->size() : (int)visibleGeometry->size();
         
         // loop through frame buffer & collect visible pixels
@@ -71 +74 @@
 
                 // if valid id <= add visibility (id values start at 1
-                if ((id > 0) && (id < (int)visibleGeometry->size()))
+                if ((id > 0) && (id < n))
                 {
-                        ((*visibleGeometry)[id]).AddVisibility(1, 1);
+                        if (mRenderPatchesForItemBuffer)
+                        {
+                                ((*visiblePatches)[id]).AddVisibility(1, 1);
+                        }
+                        else
+                        {
+                                ((*visibleGeometry)[id]).AddVisibility(1, 1);
+                        }
                 }
         }
@@ -93 +103 @@
 }
 //-----------------------------------------------------------------------
-void ItemBufferQueryManager::InitItemBuffer(InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
-                            InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry)
+void ItemBufferQueryManager::InitItemBuffer(
+                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
+                            InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
+                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches)
 {
         if (mWasInitialised)
@@ -109 +121 @@
         visibleGeometry->clear();
         visibleNodes->clear();
+        visiblePatches->clear();
 
+        int id = 0;
+
+        /* We can either use patches or meshes. If patches are used, an unique id must
+           be given each patch. Otherwise the same id must be given to all patches belonging
+           to the same mesh.
+    */
         while (it.hasMoreElements())
         {
-                visibleGeometry->push_back(GtpVisibility::MeshInfo(it.getNext(), 0, 0));
+                Entity *ent = it.getNext();
+
+                for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
+                {
+                        SubEntity *subEnt = ent->getSubEntity(i);
+
+                        if (mRenderPatchesForItemBuffer)
+                        {
+                                ++ id;
+                                visiblePatches->push_back(GtpVisibility::PatchInfo(subEnt, 0, 0));
+                        }
+                                
+                        subEnt->setId(id);
+                }
+                        
+                if (!mRenderPatchesForItemBuffer)
+                {
+                        visibleGeometry->push_back(GtpVisibility::MeshInfo(ent, 0, 0));
+                        ++ id;
+                }
         }
 }
 
+/*
+//-----------------------------------------------------------------------
+Entity* VisibilityOctreeSceneManager::createEntity(const String& entityName, 
+                                                                                                        const String& meshName)
+{
+        Entity *ent = SceneManager::createEntity(entityName, meshName);
+
+        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
+        {
+                ent->getSubEntity(i)->setId(mCurrentEntityId);
+        }
+
+        // increase counter of entity id values
+        ++ mCurrentEntityId;
+
+        return ent;
+}
+*/
 } // namespace Ogre

trunk/VUT/Ogre/src/OgreOcclusionQueriesQueryManager.cpp

@@ -21 +21 @@
                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
+                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches,
                             bool relativeVisibility)
 {
@@ -188 +189 @@
                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
+                                   InfoContainer<GtpVisibility::PatchInfo> *visiblePatches,
                                bool relativeVisibility)
 {
-        PlatformQueryManager::ComputeFromPointVisibility(point, visibleNodes, visibleGeometry, relativeVisibility);
+        PlatformQueryManager::ComputeFromPointVisibility(point, visibleNodes, 
+                visibleGeometry, visiblePatches, relativeVisibility);
 
         // --- remove duplicates (duplicates occur if an object is on the edge of the viewport)

trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

@@ -26 +26 @@
         }
         
-        // if not all subtrees are empty
-        //if (octree->numNodes() > (int)octree->mNodes.size())
+        //if (octree->numNodes() > (int)octree->mNodes.size()) // if not all subtrees are empty
         if (!IsLeaf(node))
         {

trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp

@@ -200 +200 @@
 }
 //-----------------------------------------------------------------------
-GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery(GtpVisibility::Mesh *mesh)
+GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery(
+        GtpVisibility::Mesh *mesh)
 {
         // get next available test id

trunk/VUT/Ogre/src/OgrePlatformQueryManager.cpp

@@ -23 +23 @@
                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
+                                   InfoContainer<GtpVisibility::PatchInfo> *visiblePatches,
                                bool relativeVisibility)
 {
-        SceneManager *sm = dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager();
+        SceneManager *sm = dynamic_cast<PlatformHierarchyInterface *>
+                (mHierarchyInterface)->GetSceneManager();
+
+        // create a camera for the point query
         Camera *cam = sm->createCamera("PointQueryCam");        
 
@@ -61 +65 @@
                 }
 
-                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility);
+                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, visiblePatches, relativeVisibility);
                 
-                mViewport->getTarget()->update(); for(int j=0; j<10000000; j++) printf("wait");
+                //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait");
 
                 // permute directions

trunk/VUT/Ogre/src/OgreSceneContentGenerator.cpp

@@ -65 +65 @@
 {
         char name[25];
+
         sprintf(name, "%s Entity%d", objName.c_str(), GetObjectCount());
                 

trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

@@ -7 +7 @@
 #include <OgreLogManager.h>
 #include <OgreStringConverter.h>
+#include <OgreEntity.h>
+#include <OgreSubEntity.h>
 
 
@@ -16 +18 @@
 : 
 mVisibilityManager(visManager), 
-mRenderDepthPass(false),
 mShowVisualization(false),
 mRenderNodesForViz(false),
 mRenderNodesContentForViz(false),
 mVisualizeCulledNodes(false),
+mLeavePassesInQueue(0),
 mDelayRenderTransparents(true),
-mUseDepthPass(true),
-mSkipTransparents(false)
+mUseDepthPass(false),
+mRenderDepthPass(false),
+mUseItemBuffer(false),
+//mUseItemBuffer(true),
+mRenderItemBuffer(false),
+mCurrentEntityId(1),
+mEnableDepthWrite(true),
+mSkipTransparents(false),
+mSavedShadowTechnique(SHADOWTYPE_NONE),
+mRenderTransparentsForItemBuffer(false),
+mExecuteVertexProgramForAllPasses(false)
 {
         mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
@@ -31 +42 @@
         //mShowBoxes = true;
 
-        // TODO: find reasonable value for max depth
+        // TODO: set maxdepth to reasonable value
         mMaxDepth = 50;
 }
@@ -65 +76 @@
 }
 //-----------------------------------------------------------------------
-Pass *VisibilityOctreeSceneManager::setPass(Pass* pass)
-{
-        // setting vertex program is not efficient
-        Pass *usedPass = ((mRenderDepthPass && pass->getDepthWriteEnabled() && 
-                !pass->hasVertexProgram()) ? mDepthPass : pass);                
-
-        /*
-        // set depth fill pass only if depth write enabled
-        Pass *usedPass = (mRenderDepthPass && pass->getDepthWriteEnabled() ? mDepthPass : pass);
-
-    if (mRenderDepthPass && pass->hasVertexProgram())
+void VisibilityOctreeSceneManager::InitItemBufferPass()
+{
+        MaterialPtr itemBufferMat = MaterialManager::getSingleton().
+                getByName("Visibility/ItemBufferPass");
+
+        if (itemBufferMat.isNull())
     {
-                // set vertex program of current pass to depth pass
-                mDepthPass->setVertexProgram(pass->getVertexProgramName());
-
-                if (mDepthPass->hasVertexProgram())
-                {
-                        const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
-                        // Load this program if not done already
-                        if (!prg->isLoaded())
-                                prg->load();
-                        // Copy params
-                        mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
-                }
-                else if (mDepthPass->hasVertexProgram())
-                {
-                        mDepthPass->setVertexProgram("");
-                }
-        }*/
-
-        SceneManager::setPass(usedPass);
-
-        return usedPass;
+                // Init
+                itemBufferMat = MaterialManager::getSingleton().create("Visibility/ItemBufferPass",
+                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+
+                mItemBufferPass = itemBufferMat->getTechnique(0)->getPass(0);
+                mItemBufferPass->setColourWriteEnabled(true);
+                mItemBufferPass->setDepthWriteEnabled(true);
+                mItemBufferPass->setLightingEnabled(true);
+                //mItemBufferPass->setLightingEnabled(false);
+        }
+        else
+        {
+                mItemBufferPass = itemBufferMat->getTechnique(0)->getPass(0);
+        }
+        //mItemBufferPass->setAmbient(1, 1, 0);
 }
 //-----------------------------------------------------------------------
@@ -131 +131 @@
                         if (mRenderNodesForViz)
                         {
-                                getRenderQueue()->addRenderable(*it);
+                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0)
+                                        && (*it)->getAttachedObject(0)->getMovableType() == "Entity")
+                                getRenderQueue()->addRenderable((*it));
+
                                 // addbounding boxes instead of node itself
                                 //(*it)->_addBoundingBoxToQueue(getRenderQueue());
@@ -141 +144 @@
                 }
         }
-        
+}
+//-----------------------------------------------------------------------
+Pass *VisibilityOctreeSceneManager::setPass(Pass* pass)
+{
+        // set depth fill pass if we currently do not make an aabb occlusion query
+        Pass *usedPass = (mRenderDepthPass && !mHierarchyInterface->IsBoundingBoxQuery() ? 
+                                          mDepthPass : pass);
+
+        IlluminationRenderStage savedStage = mIlluminationStage; 
+        
+        // set illumination stage to NONE so no shadow material is used 
+        // for depth pass or for occlusion query
+        if (mRenderDepthPass || mHierarchyInterface->IsBoundingBoxQuery())
+        {
+                mIlluminationStage = IRS_NONE;
+        }
+
+        //-- set vertex program of current pass in order to set correct depth
+        if (mRenderDepthPass && mExecuteVertexProgramForAllPasses && pass->hasVertexProgram())
+    {
+                // add vertex program of current pass to depth pass
+                mDepthPass->setVertexProgram(pass->getVertexProgramName());
+
+                if (mDepthPass->hasVertexProgram())
+                {
+                        const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
+                        // Load this program if not done already
+                        if (!prg->isLoaded())
+                                prg->load();
+                        // Copy params
+                        mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
+                }
+        }
+        else if (mDepthPass->hasVertexProgram())
+        {
+                mDepthPass->setVertexProgram("");
+        }
+
+        // store depth write flag to reset later
+        bool IsDepthWrite = usedPass->getDepthWriteEnabled();
+
+        // global option which enables / disables depth writes
+        if (!mEnableDepthWrite)
+        {
+                usedPass->setDepthWriteEnabled(false);
+        }
+        //else if (mIsItemBufferPass) {usedPass = mItemBufferPass;}
+
+        Pass *result = SceneManager::setPass(usedPass);
+
+        // reset depth write
+        if (!mEnableDepthWrite)
+        {
+                usedPass->setDepthWriteEnabled(IsDepthWrite);
+        }
+
+        // reset illumination stage
+        mIlluminationStage = savedStage;
+
+        return result;
 }
 //-----------------------------------------------------------------------
@@ -153 +215 @@
         else 
         {       
-                mVisible.clear();
-            mBoxes.clear();
-        
-                // if there is no depth pass =>
-                // we interleave identification and rendering of objects 
-                // in _renderVisibibleObjects
-
+                // for hierarchical culling, we interleave identification 
+                // and rendering of objects in _renderVisibibleObjects
+
+                // for the shadow pass we use only standard rendering
+                // because of low occlusion
+                if (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE && 
+                        mIlluminationStage == IRS_RENDER_TO_TEXTURE)
+                {
+                        OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
+                }
                 // only shadow casters will be rendered in shadow texture pass
-                mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
-        }
+                // mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
+        }
+        
+        
+        // -- delete lists stored for visualization
+        mVisible.clear();
+        mBoxes.clear();
 }
 //-----------------------------------------------------------------------
 void VisibilityOctreeSceneManager::_renderVisibleObjects()
 {
-        // create material for depth pass
-        InitDepthPass();
-        
-        // visualization: apply standard rendering
-        if (mShowVisualization)
+        // save ambient light to reset later
+        ColourValue savedAmbient = mAmbientLight;
+
+        //-- apply standard rendering for some modes (e.g., visualization, shadow pass)
+
+        if (mShowVisualization ||
+           (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE && 
+            mIlluminationStage == IRS_RENDER_TO_TEXTURE))
+        {
+                IlluminationRenderStage savedStage = mIlluminationStage; 
+        
+                if (mShowVisualization)
+                {
+                        // disable illumination stage to prevent rendering shadows
+                        mIlluminationStage = IRS_NONE;
+                }
+
+                // standard rendering for shadow maps because of performance
+                OctreeSceneManager::_renderVisibleObjects();
+
+                mIlluminationStage = savedStage;
+        }
+        else //-- the hierarchical culling algorithm
         {       
+                // don't render backgrounds for item buffer
+                if (mUseItemBuffer)
+                {
+                        clearSpecialCaseRenderQueues();
+                        getRenderQueue()->clear();
+                }       
+
+                //-- hierarchical culling
+                // the objects of different layers (e.g., background, scene, 
+                // overlay) must be identified and rendered one after another
+
+                //-- render all early skies
+                clearSpecialCaseRenderQueues();
+                addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
+                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);
+                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
+
                 OctreeSceneManager::_renderVisibleObjects();
-                return;
-        }       
-
-        //-- hierarchical culling
-        // the objects of different layers (e.g., background, scene, 
-        // overlay) must be identified and rendered one after another
-
-        bool leaveTransparentsInQueue = mDelayRenderTransparents && !mUseDepthPass;
-
-    // -- initialise interface for rendering traversal of the hierarchy
-        mHierarchyInterface->SetHierarchyRoot(mOctree);
-        
-        // possible two cameras (one for culling, one for rendering)
-        mHierarchyInterface->InitTraversal(mCameraInProgress, 
-                                                        mCullCamera ? getCamera("CullCamera") : NULL,
-                                                        leaveTransparentsInQueue);
-                
-
-        // reset culling manager stats
-        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes);
-        
-        mSkipTransparents = false;
-
-        //-- render background, in case there is one
-        clearSpecialCaseRenderQueues();
-        addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
-        addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);
-        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
-
-        SceneManager::_renderVisibleObjects();
 
 
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
-        _deleteRenderedQueueGroups();
+                // delete previously rendered content
+                _deleteRenderedQueueGroups();
 #endif
 
-        //-- render visible objects (i.e., all but overlay)
-        clearSpecialCaseRenderQueues();
-        addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE);
-        addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
-        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
-        
-        // transparents are skipped from hierarchical rendering
-        // => they need sorting, thus we render them afterwards
-        mSkipTransparents = mDelayRenderTransparents;
-
-        // set state for depth pass
-    mRenderDepthPass = mUseDepthPass;
-        
-        /** 
-        * the hierarchical culling algorithm
-          * for depth pass: will just find objects and update depth buffer
-          * for delayed rendering: will render all but transparents
-        **/
-        
-        mVisibilityManager->ApplyVisibilityCulling();
-        
-        //-- now we can savely render all remaining objects, e.g., transparents, overlay
-        mSkipTransparents = false;
-
-        clearSpecialCaseRenderQueues();
-        SceneManager::_renderVisibleObjects();
-
-        // for depth pass: add visible nodes found with the visibility culling
-        if (mUseDepthPass)
-        {
-                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
-                {
-                        (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
-                }
+                //-- prepare queue for visible objects (i.e., all but overlay and skies late)
+                clearSpecialCaseRenderQueues();
+                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE);
+                addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
+                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
+        
+
+                // set all necessary parameters for 
+                // hierarchical visibility culling and rendering
+                InitVisibilityCulling(mCameraInProgress);
+        
+                /** 
+                * the hierarchical culling algorithm
+                * for depth pass: we just find objects and update depth buffer
+                * for "delayed" rendering: we render some passes afterwards
+                * e.g., transparents, because they need front-to-back sorting
+                **/
+        
+                mVisibilityManager->ApplyVisibilityCulling();
+        
+                // delete remaining renderables from queue (all not in mLeavePassesInQueue)
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+                _deleteRenderedQueueGroups(mLeavePassesInQueue);
+#endif
+
+                //-- reset parameters
                 mRenderDepthPass = false;
-    }
-        mSkipTransparents = false;
-                
-        //-- now we can render all remaining queue objects
-        // for depth pass: all
-        // for delayed rendering: transparents, overlay 
-        clearSpecialCaseRenderQueues();
-        OctreeSceneManager::_renderVisibleObjects();
-        
-        WriteLog(); // write out stats
-}
+                mRenderItemBuffer = false;
+                mSkipTransparents = false;
+                mLeavePassesInQueue = 0;
+                mShadowTechnique = mSavedShadowTechnique;
+
+
+                // add visible nodes found by the visibility culling algorithm
+                if (mUseDepthPass)
+                {
+                        for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
+                        {
+                                (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
+                        }
+                }
+        
+                //-- we render all remaining queue objects
+                // used for depth pass, transparents, overlay 
+                clearSpecialCaseRenderQueues();
+                OctreeSceneManager::_renderVisibleObjects();
+        
+        }   // hierarchical culling
+
+        // reset ambient light
+        setAmbientLight(savedAmbient);
+        
+        getRenderQueue()->clear(); // finally clear render queue
+        //WriteLog(); // write out stats
+}
+
 //-----------------------------------------------------------------------
 void VisibilityOctreeSceneManager::_updateSceneGraph(Camera* cam)
@@ -312 +398 @@
                 return true;
         }
+
+        if (key == "DepthWrite")
+        {
+                mEnableDepthWrite = (*static_cast<const bool *>(val));
+                return true;
+        }
+        if (key == "UseItemBuffer")
+        {
+                mUseItemBuffer = (*static_cast<const bool *>(val));
+                return true;
+        }
+        if (key == "ExecuteVertexProgramForAllPasses")
+        { 
+                mExecuteVertexProgramForAllPasses  = (*static_cast<const bool *>(val));
+                return true;
+        }
+        if (key == "RenderTransparentsForItemBuffer")
+        { 
+                mRenderTransparentsForItemBuffer  = (*static_cast<const bool *>(val));
+                return true;
+        }
+
         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                 setOption(key, val) || OctreeSceneManager::setOption(key, val);
@@ -372 +480 @@
 }
 //-----------------------------------------------------------------------
-void VisibilityOctreeSceneManager::renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs, 
+void VisibilityOctreeSceneManager::renderObjects(
+        const RenderPriorityGroup::TransparentRenderablePassList& objs, 
             bool doLightIteration, const LightList* manualLightList)
 {
+        // for correct rendering, transparents must be rendered after hierarchical culling
         if (!mSkipTransparents)
         {
@@ -380 +490 @@
         }
 }
-
+//-----------------------------------------------------------------------
+bool VisibilityOctreeSceneManager::validatePassForRendering(Pass* pass)
+{
+        // skip all but first pass if we are doing the depth pass
+        if ((mRenderDepthPass || mRenderItemBuffer) && pass->getIndex() > 0)
+        {
+                return false;
+        }
+        return SceneManager::validatePassForRendering(pass);
+}
+//-----------------------------------------------------------------------
+void VisibilityOctreeSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
+{
+        if (!mRenderItemBuffer)
+        {
+                OctreeSceneManager::renderQueueGroupObjects(pGroup);
+                return;
+        }
+
+        // --- item buffer
+
+    // Iterate through priorities
+    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
+
+        while (groupIt.hasMoreElements())
+    {
+                RenderItemBuffer(groupIt.getNext());
+        }
+}
+//-----------------------------------------------------------------------
+void VisibilityOctreeSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
+{
+        // Do solids
+        RenderPriorityGroup::SolidRenderablePassMap solidObjs = pGroup->_getSolidPasses();
+
+        // ----- SOLIDS LOOP -----
+        RenderPriorityGroup::SolidRenderablePassMap::const_iterator ipass, ipassend;
+        ipassend = solidObjs.end();
+
+        for (ipass = solidObjs.begin(); ipass != ipassend; ++ipass)
+        {
+                // Fast bypass if this group is now empty
+                if (ipass->second->empty()) 
+                        continue;
+
+                // Render only first pass
+                if (ipass->first->getIndex() > 0)
+                        continue;
+
+                RenderPriorityGroup::RenderableList* rendList = ipass->second;
+                
+                RenderPriorityGroup::RenderableList::const_iterator irend, irendend;
+                irendend = rendList->end();
+                        
+                for (irend = rendList->begin(); irend != irendend; ++irend)
+                {
+                        std::stringstream d; d << "itembuffer, pass name: " << 
+                                ipass->first->getParent()->getParent()->getName();
+                                
+                        LogManager::getSingleton().logMessage(d.str());
+                        
+                        RenderSingleObjectForItemBuffer(*irend, ipass->first);
+                }
+        }
+
+        // -- TRANSPARENT LOOP: must be handled differently 
+
+        // transparents are treated either as solids or completely discarded
+        if (mRenderTransparentsForItemBuffer)
+        {
+                RenderPriorityGroup::TransparentRenderablePassList transpObjs = 
+                        pGroup->_getTransparentPasses();
+                RenderPriorityGroup::TransparentRenderablePassList::const_iterator 
+                        itrans, itransend;
+
+                itransend = transpObjs.end();
+                for (itrans = transpObjs.begin(); itrans != itransend; ++itrans)
+                {
+                        // like for solids, render only first pass
+                        if (itrans->pass->getIndex() == 0)
+                        {       
+                                RenderSingleObjectForItemBuffer(itrans->renderable, itrans->pass);
+                        }
+                } 
+        }
+}
+//-----------------------------------------------------------------------
+void VisibilityOctreeSceneManager::RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass)
+{
+        static LightList nullLightList;
+        
+        int col[4];
+        
+        // -- create color code out of object id
+        col[0] = (rend->getId() >> 16) & 255;
+        col[1] = (rend->getId() >> 8) & 255;
+        col[2] = rend->getId() & 255;
+//      col[3] = 255;
+
+        //mDestRenderSystem->setColour(col[0], col[1], col[2], col[3]);
+    
+        mItemBufferPass->setAmbient(ColourValue(col[0] / 255.0f,
+                                                                                    col[1] / 255.0f, 
+                                                                                        col[2] / 255.0f, 1));
+
+        // set vertex program of current pass
+        if (mExecuteVertexProgramForAllPasses && pass->hasVertexProgram())
+        {
+                mItemBufferPass->setVertexProgram(pass->getVertexProgramName());
+
+                if (mItemBufferPass->hasVertexProgram())
+                {
+                        const GpuProgramPtr& prg = mItemBufferPass->getVertexProgram();
+                        // Load this program if not done already
+                        if (!prg->isLoaded())
+                                prg->load();
+                        // Copy params
+                        mItemBufferPass->setVertexProgramParameters(pass->getVertexProgramParameters());
+                }
+        }
+        else if (mItemBufferPass->hasVertexProgram())
+        {
+                mItemBufferPass->setVertexProgram("");
+        }
+
+        Pass *usedPass = setPass(mItemBufferPass); 
+
+
+        // Render a single object, this will set up auto params if required
+        renderSingleObject(rend, usedPass, false, &nullLightList);
+}
+//-----------------------------------------------------------------------
+GtpVisibility::VisibilityManager *VisibilityOctreeSceneManager::GetVisibilityManager()
+{
+        return mVisibilityManager;
+}
+//-----------------------------------------------------------------------
+void VisibilityOctreeSceneManager::InitVisibilityCulling(Camera *cam)
+{
+        InitDepthPass();          // create material for depth pass
+        InitItemBufferPass(); // create material for item buffer pass
+
+        // reset culling manager stats
+        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes);
+
+        // save shadow technique. It will be reset after hierarchical culling
+        mSavedShadowTechnique = mShadowTechnique;
+
+        // render standard solids without shadows during hierarchical culling pass
+        if ((mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE) ||
+            (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE))
+        {       
+                mShadowTechnique = SHADOWTYPE_NONE;
+        }
+
+        // set depth pass flag before rendering
+        mRenderDepthPass = mUseDepthPass;
+
+        // item buffer needs full ambient lighting to use item colors as unique id
+        if (mUseItemBuffer) 
+        {
+                mRenderItemBuffer = true;
+                setAmbientLight(ColourValue(1,1,1,1));
+        }
+
+
+        // set passes which are stored in render queue 
+        // for rendering AFTER hierarchical culling, i.e., passes which need 
+        // a special rendering order
+        
+        mLeavePassesInQueue = 0;
+
+        if (!mUseDepthPass || !mUseItemBuffer)
+        {
+                if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
+                {
+                        // TODO: remove this pass because it should be processed during hierarchical culling
+                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW;
+
+                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DECAL;
+                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DIFFUSE_SPECULAR;
+                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
+
+                        // just render ambient passes
+                        mIlluminationStage = IRS_AMBIENT;
+                }
+        
+                if (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE)
+                {
+                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW;
+                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
+                }
+        
+                // transparents should be rendered after hierarchical culling to 
+                // provide front-to-back ordering
+                if (mDelayRenderTransparents)
+                {
+                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
+                }
+        }
+
+        // skip rendering transparents in the hierarchical culling
+        // (because they will be rendered afterwards)
+        mSkipTransparents = mUseDepthPass || 
+                (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES);
+
+        // -- initialise interface for rendering traversal of the hierarchy
+        mHierarchyInterface->SetHierarchyRoot(mOctree);
+        
+        // possible two cameras (one for culling, one for rendering)
+        mHierarchyInterface->InitTraversal(mCameraInProgress, 
+                                                        mCullCamera ? getCamera("CullCamera") : NULL,
+                                                        mLeavePassesInQueue);
+                
+        //std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;LogManager::getSingleton().logMessage(d.str());
+}
+//-----------------------------------------------------------------------
+OctreeHierarchyInterface *VisibilityOctreeSceneManager::GetHierarchyInterface()
+{
+        return mHierarchyInterface;
+}
+//-----------------------------------------------------------------------
+/*void VisibilityOctreeSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup)
+{
+    // Basic render loop: Iterate through priorities
+    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
+
+    while (groupIt.hasMoreElements())
+    {
+        RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
+
+        // Sort the queue first
+        pPriorityGrp->sort(mCameraInProgress);
+
+                // Do solids
+                // TODO: render other solid passes for shadows
+        renderObjects(pPriorityGrp->_getSolidPassesNoShadows(), true);
+
+                // do solid passes no shadows if addititive stencil shadows
+                if (mSavedShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
+                        renderObjects(pPriorityGrp->_getSolidPassesNoShadows(), true);
+                
+        // Do transparents
+        renderObjects(pPriorityGrp->_getTransparentPasses(), true);
+
+
+    }// for each priority
+}
+*/
+//-----------------------------------------------------------------------
+/*
+Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName, 
+                                                                                                        const String& meshName)
+{
+        Entity *ent = SceneManager::createEntity(entityName, meshName);
+
+        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
+        {
+                ent->getSubEntity(i)->setId(mCurrentEntityId);
+        }
+
+        // increase counter of entity id values
+        ++ mCurrentEntityId;
+
+        return ent;
+}*/
 }   // namespace Ogre

trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

@@ -31 +31 @@
 mEnableDepthWrite(true),
 mSkipTransparents(false),
-mSavedShadowTechnique(SHADOWTYPE_NONE)
+mSavedShadowTechnique(SHADOWTYPE_NONE),
+mRenderTransparentsForItemBuffer(false),
+mExecuteVertexProgramForAllPasses(false)
 {
         mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
@@ -37 +39 @@
         //mDisplayNodes = true;
         //mShowBoundingBoxes = true;
+        //mShowBoxes = true;
+        //mShowBoxes = true;
 
         // TODO: set maxdepth to reasonable value
@@ -48 +52 @@
         if (depthMat.isNull())
     {
-                // Init
                 depthMat = MaterialManager::getSingleton().create(
                 "Visibility/DepthPass",
                 ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+
         mDepthPass = depthMat->getTechnique(0)->getPass(0);
                 mDepthPass->setColourWriteEnabled(false);
@@ -60 +64 @@
         {
                 mDepthPass = depthMat->getTechnique(0)->getPass(0);
+        }
+}
+//-----------------------------------------------------------------------
+VisibilityTerrainSceneManager::~VisibilityTerrainSceneManager()
+{
+        if (mHierarchyInterface)
+        {
+                delete mHierarchyInterface;
+                mHierarchyInterface = NULL;
         }
 }
@@ -85 +98 @@
         }
         //mItemBufferPass->setAmbient(1, 1, 0);
-}
-//-----------------------------------------------------------------------
-VisibilityTerrainSceneManager::~VisibilityTerrainSceneManager()
-{
-        if (mHierarchyInterface)
-        {
-                delete mHierarchyInterface;
-                mHierarchyInterface = NULL;
-        }
 }
 //-----------------------------------------------------------------------
@@ -160 +164 @@
         }
         
-        if (mRenderDepthPass)
-        {
-                // --- set vertex program of current pass so z-buffer is updated correctly
-        if (pass->hasVertexProgram())
-                {
-                        mDepthPass->setVertexProgram(pass->getVertexProgramName());
-
-                        if (mDepthPass->hasVertexProgram())
-                        {
-                                const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
-                                // Load this program if not done already
-                                if (!prg->isLoaded())
-                                        prg->load();
-                                // Copy params
-                                mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
-                        }
-                }
-                else if (mDepthPass->hasVertexProgram())
-                {
-                        mDepthPass->setVertexProgram("");
-                }
-        }
+        // --- set vertex program of current pass in order to set correct depth
+        if (mExecuteVertexProgramForAllPasses && mRenderDepthPass && pass->hasVertexProgram())
+        {
+                // add vertex program of current pass to depth pass
+                mDepthPass->setVertexProgram(pass->getVertexProgramName());
+
+                if (mDepthPass->hasVertexProgram())
+                {
+                        const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
+                        // Load this program if not done already
+                        if (!prg->isLoaded())
+                                prg->load();
+                        // Copy params
+                        mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
+                }
+        }
+        else if (mDepthPass->hasVertexProgram())
+        {
+                mDepthPass->setVertexProgram("");
+        }
+        
 
         bool IsDepthWrite = usedPass->getDepthWriteEnabled();
@@ -228 +231 @@
                 // mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
         }
-        //TerrainSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
+        
         
         // -- delete lists stored for visualization
@@ -240 +243 @@
         ColourValue savedAmbient = mAmbientLight;
 
-        // --- apply standard rendering for some cases (e.g., visualization, shadow pass)
+        //-- apply standard rendering for some modes (e.g., visualization, shadow pass)
 
         if (mShowVisualization ||
@@ -257 +260 @@
                 mIlluminationStage = savedStage;
         }
-        else // -- the hierarchical culling algorithm
+        else //-- the hierarchical culling algorithm
         {
                 // don't render backgrounds for item buffer
@@ -266 +269 @@
                 }
 
+                //-- hierarchical culling
                 // the objects of different layers (e.g., background, scene, 
                 // overlay) must be identified and rendered one after another
@@ -279 +283 @@
 
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
-                // delete previously rendered contenbt
+                // delete previously rendered content
                 _deleteRenderedQueueGroups();
 #endif
@@ -296 +300 @@
                 /** 
                 * the hierarchical culling algorithm
-                * if we use a depth pass: will just find objects and update depth buffer
-                * for "delayed" rendering: will render some passes afterwards, e.g., transparents
+                * for depth pass: we just find objects and update depth buffer
+                * for "delayed" rendering: we render some passes afterwards
+                * e.g., transparents, because they need front-to-back sorting
                 **/
                 
@@ -325 +330 @@
                 
                 //-- now we can render all remaining queue objects
-                // for depth pass, transparents, overlay 
+                // used for depth pass, transparents, overlay 
                 clearSpecialCaseRenderQueues();
                 TerrainSceneManager::_renderVisibleObjects();
         }
                 
-        // set the new render level index afterwards => new level in the next frame 
-        int levelIdx = TerrainRenderable::getCurrentRenderLevelIndex() + 1;
-        TerrainRenderable::setCurrentRenderLevelIndex(levelIdx);
-
+        // set the new render level index 
+        TerrainRenderable::NextRenderLevelIndex();
+        
         // reset ambient light
         setAmbientLight(savedAmbient);
 
-        getRenderQueue()->clear();
+        getRenderQueue()->clear(); // finally clear render queue
         //WriteLog(); // write out stats
 }
@@ -397 +401 @@
                 return true;
         }
-        // notifiy that frame has ended so terrain render level can be reset for correct
-        // terrain rendering
-        if (key == "TerrainLevelIdx")
-        {
-                TerrainRenderable::setCurrentRenderLevelIndex((*static_cast<const int *>(val)));
-                return true;
-        }
+
         if (key == "DepthWrite")
         {
@@ -414 +412 @@
                 return true;
         }
-        
+        if (key == "ExecuteVertexProgramForAllPasses")
+        { 
+                mExecuteVertexProgramForAllPasses  = (*static_cast<const bool *>(val));
+                return true;
+        }
+        if (key == "RenderTransparentsForItemBuffer")
+        { 
+                mRenderTransparentsForItemBuffer  = (*static_cast<const bool *>(val));
+                return true;
+        }
+
         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                 setOption(key, val) || TerrainSceneManager::setOption(key, val);
@@ -547 +555 @@
         }
 
-        // ----- TRANSPARENT LOOP: must be handled differently 
-        // TODO: HOW TO HANDLE OCCLUDED OBJECTS ????
-        RenderPriorityGroup::TransparentRenderablePassList
-                transpObjs = pGroup->_getTransparentPasses();
-        RenderPriorityGroup::TransparentRenderablePassList::const_iterator itrans, itransend;
-
-        itransend = transpObjs.end();
-        for (itrans = transpObjs.begin(); itrans != itransend; ++itrans)
-        {
-                // like for solids, render only first pass
-                if (itrans->pass->getIndex() == 0)
-                {       
-                        RenderSingleObjectForItemBuffer(itrans->renderable, itrans->pass);
-                }
-        } 
+        // -- TRANSPARENT LOOP: must be handled differently 
+
+        // transparents are treated either as solids or completely discarded
+        if (mRenderTransparentsForItemBuffer)
+        {
+                RenderPriorityGroup::TransparentRenderablePassList transpObjs = 
+                        pGroup->_getTransparentPasses();
+                RenderPriorityGroup::TransparentRenderablePassList::const_iterator 
+                        itrans, itransend;
+
+                itransend = transpObjs.end();
+                for (itrans = transpObjs.begin(); itrans != itransend; ++itrans)
+                {
+                        // like for solids, render only first pass
+                        if (itrans->pass->getIndex() == 0)
+                        {       
+                                RenderSingleObjectForItemBuffer(itrans->renderable, itrans->pass);
+                        }
+                }
+        }
 }
 //-----------------------------------------------------------------------
@@ -583 +596 @@
 
         // set vertex program of current pass
-        if (pass->hasVertexProgram())
+        if (mExecuteVertexProgramForAllPasses && pass->hasVertexProgram())
         {
                 mItemBufferPass->setVertexProgram(pass->getVertexProgramName());
@@ -614 +627 @@
 }
 //-----------------------------------------------------------------------
-Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName, 
-                                                                                                        const String& meshName)
-{
-        Entity *ent = SceneManager::createEntity(entityName, meshName);
-
-        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
-        {
-                ent->getSubEntity(i)->setId(mCurrentEntityId);
-        }
-
-        // increase counter of entity id values
-        ++ mCurrentEntityId;
-
-        return ent;
-}
-//-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::InitVisibilityCulling(Camera *cam)
 {
@@ -644 +641 @@
         if ((mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE) ||
             (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE))
-        {
-        
+        {       
                 mShadowTechnique = SHADOWTYPE_NONE;
         }
@@ -660 +656 @@
 
 
-        // set passes which should be stored in render queue 
+        // set passes which are stored in render queue 
         // for rendering AFTER hierarchical culling, i.e., passes which need 
         // a special rendering order
@@ -715 +711 @@
 }
 //-----------------------------------------------------------------------
+void VisibilityTerrainSceneManager::endFrame()
+{
+        TerrainRenderable::ResetRenderLevelIndex();
+}
+//-----------------------------------------------------------------------
 /*void VisibilityTerrainSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup)
 {
@@ -742 +743 @@
 }
 */
+//-----------------------------------------------------------------------
+/*
+Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName, 
+                                                                                                        const String& meshName)
+{
+        Entity *ent = SceneManager::createEntity(entityName, meshName);
+
+        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
+        {
+                ent->getSubEntity(i)->setId(mCurrentEntityId);
+        }
+
+        // increase counter of entity id values
+        ++ mCurrentEntityId;
+
+        return ent;
+}
+*/
 } // namespace Ogre