source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp @ 1276

Revision 1276, 36.7 KB checked in by mattausch, 18 years ago (diff)
Line 
1#include "OgreOcclusionCullingSceneManager.h"
2#include "OgreVisibilityOptionsManager.h"
3#include <OgreMath.h>
4#include <OgreIteratorWrappers.h>
5#include <OgreRenderSystem.h>
6#include <OgreCamera.h>
7#include <OgreLogManager.h>
8#include <OgreStringConverter.h>
9#include <OgreEntity.h>
10#include <OgreSubEntity.h>
11#include <OgreMaterialManager.h>
12#include <OgreIteratorWrappers.h>
13#include <OgreHeightmapTerrainPageSource.h>
14#include "VspBspTree.h"
15#include "Containers.h"
16#include "ViewCellsManager.h"
17#include <OgreConfigFile.h>
18#include "OgreTypeConverter.h"
19#include "OgreMeshInstance.h"
20#include "common.h"
21#include "OgreBoundingBoxConverter.h"
22
23
24namespace Ogre {
25
26//-----------------------------------------------------------------------
27OcclusionCullingSceneManager::OcclusionCullingSceneManager(const String& name,
28                                                        GtpVisibility::VisibilityManager *visManager):
29TerrainSceneManager(name),
30mVisibilityManager(visManager),
31mShowVisualization(false),
32mRenderNodesForViz(false),
33mRenderNodesContentForViz(false),
34mVisualizeCulledNodes(false),
35mLeavePassesInQueue(0),
36mDelayRenderTransparents(true),
37mUseDepthPass(false),
38mIsDepthPassPhase(false),
39mUseItemBuffer(false),
40mIsItemBufferPhase(false),
41mCurrentEntityId(1),
42mEnableDepthWrite(true),
43mSkipTransparents(false),
44mRenderTransparentsForItemBuffer(true),
45mExecuteVertexProgramForAllPasses(false),
46mIsHierarchicalCulling(false),
47mViewCellsLoaded(false),
48mUseViewCells(false),
49mUseVisibilityFilter(false),
50mCurrentViewCell(NULL),
51mElementaryViewCell(NULL),
52mDeleteQueueAfterRendering(true),
53mNormalExecution(false)
54{
55        Ogre::LogManager::getSingleton().logMessage("creating occlusion culling scene manager");
56
57        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
58       
59        if (0)
60        {
61                mDisplayNodes = true;
62                mShowBoundingBoxes = true;
63                mShowBoxes = true;
64        }
65
66        // TODO: set maxdepth to reasonable value
67        mMaxDepth = 50;
68}
69//-----------------------------------------------------------------------
70void OcclusionCullingSceneManager::InitDepthPass()
71{
72        MaterialPtr depthMat = MaterialManager::getSingleton().getByName("Visibility/DepthPass");
73
74        if (depthMat.isNull())
75    {
76                depthMat = MaterialManager::getSingleton().create(
77                "Visibility/DepthPass",
78                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
79
80        mDepthPass = depthMat->getTechnique(0)->getPass(0);
81                mDepthPass->setColourWriteEnabled(false);
82                mDepthPass->setDepthWriteEnabled(true);
83                mDepthPass->setLightingEnabled(false);
84        }
85        else
86        {
87                mDepthPass = depthMat->getTechnique(0)->getPass(0);
88        }
89}
90//-----------------------------------------------------------------------
91OcclusionCullingSceneManager::~OcclusionCullingSceneManager()
92{
93        OGRE_DELETE(mHierarchyInterface);
94        CLEAR_CONTAINER(mObjects);
95        OGRE_DELETE(mCurrentViewCell);
96}
97//-----------------------------------------------------------------------
98void OcclusionCullingSceneManager::InitItemBufferPass()
99{
100        MaterialPtr itemBufferMat = MaterialManager::getSingleton().
101                getByName("Visibility/ItemBufferPass");
102
103        if (itemBufferMat.isNull())
104    {
105                // Init
106                itemBufferMat = MaterialManager::getSingleton().create("Visibility/ItemBufferPass",
107                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
108
109                mItemBufferPass = itemBufferMat->getTechnique(0)->getPass(0);
110                mItemBufferPass->setColourWriteEnabled(true);
111                mItemBufferPass->setDepthWriteEnabled(true);
112                mItemBufferPass->setLightingEnabled(true);
113                //mItemBufferPass->setLightingEnabled(false);
114        }
115        else
116        {
117                mItemBufferPass = itemBufferMat->getTechnique(0)->getPass(0);
118        }
119        //mItemBufferPass->setAmbient(1, 1, 0);
120}
121//-------------------------------------------------------------------------
122#if 1
123void OcclusionCullingSceneManager::setWorldGeometry( DataStreamPtr& stream, const String& typeName )
124{
125    // Clear out any existing world resources (if not default)
126    if (ResourceGroupManager::getSingleton().getWorldResourceGroupName() !=
127        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)
128    {
129        ResourceGroupManager::getSingleton().clearResourceGroup(
130            ResourceGroupManager::getSingleton().getWorldResourceGroupName());
131    }
132        destroyLevelIndexes();
133    mTerrainPages.clear();
134    // Load the configuration
135    loadConfig(stream);
136        initLevelIndexes();
137
138    // Resize the octree, allow for 1 page for now
139    float max_x = mOptions.scale.x * mOptions.pageSize;
140    float max_y = mOptions.scale.y;
141    float max_z = mOptions.scale.z * mOptions.pageSize;
142
143        float maxAxis = std::max(max_x, max_y);
144        maxAxis = std::max(maxAxis, max_z);
145        resize( AxisAlignedBox( 0, 0, 0, maxAxis, maxAxis, maxAxis ) );
146   
147    setupTerrainMaterial();
148
149    setupTerrainPages();
150
151 }
152#endif
153//-----------------------------------------------------------------------
154void OcclusionCullingSceneManager::PrepareVisualization(Camera *cam)
155{
156        // add player camera for visualization purpose
157        try
158        {
159                Camera *c;
160                if ((c = getCamera("PlayerCam")) != NULL)
161                {
162                        getRenderQueue()->addRenderable(c);
163                }   
164    }
165    catch (...)
166    {
167        // ignore
168    }
169        // add bounding boxes of rendered objects
170        if (0)
171        for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
172        {
173                getRenderQueue()->addRenderable(*it);
174        }
175       
176        if (mRenderNodesForViz || mRenderNodesContentForViz)
177        {
178                // HACK: change node material so it is better suited for visualization
179                MaterialPtr nodeMat = MaterialManager::getSingleton().getByName("Core/NodeMaterial");
180                nodeMat->setAmbient(1, 1, 0);
181                nodeMat->setLightingEnabled(true);
182                nodeMat->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
183
184                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
185                {
186                        if (mRenderNodesForViz)
187                        {
188                                // render the leaf nodes
189                                if ((*it)->numAttachedObjects() &&
190                                        !(*it)->numChildren() &&
191                                        ((*it)->getAttachedObject(0)->getMovableType() == "Entity") &&
192                                        (*it)->getAttachedObject(0)->isVisible())
193                                {
194                                        getRenderQueue()->addRenderable((*it));
195                                }
196
197                                // addbounding boxes instead of node itself
198                                //(*it)->_addBoundingBoxToQueue(getRenderQueue());
199                        }
200                        // add renderables itself
201                        if (mRenderNodesContentForViz)
202                        {
203                                (*it)->_addToRenderQueue(cam, getRenderQueue(), false);
204                        }
205                }
206        }       
207}
208//-----------------------------------------------------------------------
209const Pass *OcclusionCullingSceneManager::_setPass(const Pass* pass, bool evenIfSuppressed)
210{
211        if (mNormalExecution)
212        {
213                return SceneManager::_setPass(pass);
214        }
215
216        // TODO: setting vertex program is not efficient
217        //Pass *usedPass = ((mIsDepthPassPhase && !pass->hasVertexProgram()) ? mDepthPass : pass);
218       
219        // set depth fill pass if we currently do not make an aabb occlusion query
220        const bool useDepthPass =
221                (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery());
222
223        const IlluminationRenderStage savedStage = mIlluminationStage;
224       
225        // set illumination stage to NONE so no shadow material is used
226        // for depth pass or for occlusion query
227        if (mIsDepthPassPhase || mHierarchyInterface->IsBoundingBoxQuery())
228        {
229                mIlluminationStage = IRS_NONE;
230        }
231       
232        // --- set vertex program of current pass in order to set correct depth
233        if (mExecuteVertexProgramForAllPasses &&
234                mIsDepthPassPhase &&
235                pass->hasVertexProgram())
236        {
237                // add vertex program of current pass to depth pass
238                mDepthPass->setVertexProgram(pass->getVertexProgramName());
239
240                if (mDepthPass->hasVertexProgram())
241                {
242                        const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
243                        // Load this program if not done already
244                        if (!prg->isLoaded())
245                                prg->load();
246                        // Copy params
247                        mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
248                }
249        }
250        else if (mDepthPass->hasVertexProgram()) // reset vertex program
251        {
252                mDepthPass->setVertexProgram("");
253        }
254       
255        const Pass *usedPass = useDepthPass ? mDepthPass : pass;
256
257        // save old depth write: needed for item buffer
258        const bool IsDepthWrite = usedPass->getDepthWriteEnabled();
259
260        // global option which enables / disables depth writes
261        if (!mEnableDepthWrite)
262        {
263                //usedPass->setDepthWriteEnabled(false);
264        }
265        //else if (mIsItemBufferPass) {usedPass = mItemBufferPass;}
266       
267
268        //-- set actual pass here
269
270        const Pass *result = SceneManager::_setPass(usedPass);
271
272
273        // reset depth write
274        if (!mEnableDepthWrite)
275        {
276                //usedPass->setDepthWriteEnabled(IsDepthWrite);
277        }
278
279        // reset illumination stage
280        mIlluminationStage = savedStage;
281
282        return result;
283}
284//-----------------------------------------------------------------------
285void OcclusionCullingSceneManager::_findVisibleObjects(Camera* cam,
286                                                                                                                bool onlyShadowCasters)
287{
288        if (mNormalExecution)
289        {
290                OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
291                return;
292        }
293
294
295        //-- show visible scene nodes and octree bounding boxes from last frame
296        if (mShowVisualization)
297    {
298                PrepareVisualization(cam);
299        }
300        else
301        {       
302                // for hierarchical culling, we interleave identification
303                // and rendering of objects in _renderVisibibleObjects
304
305                // for the shadow pass we use only standard rendering
306                // because of low occlusion
307                if (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&
308                        mIlluminationStage == IRS_RENDER_TO_TEXTURE)
309                {
310                        OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
311                }
312
313                // only shadow casters will be rendered in shadow texture pass
314                if (0) mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
315
316
317                //-- apply view cell pvs
318                updatePvs(cam);
319        }
320       
321       
322        // lists only used for visualization
323        mVisible.clear();
324        mBoxes.clear();
325}
326//-----------------------------------------------------------------------
327void OcclusionCullingSceneManager::_renderVisibleObjects()
328{
329        if (mNormalExecution)
330        {
331                OctreeSceneManager::_renderVisibleObjects();
332                return;
333        }
334
335        InitDepthPass();          // create material for depth pass
336        InitItemBufferPass(); // create material for item buffer pass
337
338        // save ambient light to reset later
339        ColourValue savedAmbient = mAmbientLight;
340
341        //-- apply standard rendering for some modes (e.g., visualization, shadow pass)
342
343        if (mShowVisualization ||
344           (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&
345            mIlluminationStage == IRS_RENDER_TO_TEXTURE))
346        {       
347                IlluminationRenderStage savedStage = mIlluminationStage;
348       
349                if (mShowVisualization)
350                {
351                        // disable illumination stage to prevent rendering shadows
352                        mIlluminationStage = IRS_NONE;
353                }
354
355                // standard rendering for shadow maps because of performance
356                TerrainSceneManager::_renderVisibleObjects();
357
358                mIlluminationStage = savedStage;
359        }
360        else //-- the hierarchical culling algorithm
361        {
362                // note matt: this is also called in TerrainSceneManager: really necessary?
363                mDestRenderSystem -> setLightingEnabled(false);
364
365                // don't render backgrounds for item buffer
366                if (mUseItemBuffer)
367                {
368                        clearSpecialCaseRenderQueues();
369                        getRenderQueue()->clear();
370                }
371
372                //-- hierarchical culling
373                // the objects of different layers (e.g., background, scene,
374                // overlay) must be identified and rendered one after another
375
376                //-- render all early skies
377                clearSpecialCaseRenderQueues();
378                addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
379                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);
380                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
381
382                TerrainSceneManager::_renderVisibleObjects();
383
384#ifdef GTP_VISIBILITY_MODIFIED_OGRE
385                // delete previously rendered content
386                _deleteRenderedQueueGroups();
387#endif
388
389                //-- prepare queue for visible objects (i.e., all but overlay and skies late)
390                clearSpecialCaseRenderQueues();
391                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE);
392                addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
393       
394                // exclude this queues from hierarchical rendering
395                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
396
397
398                // set all necessary parameters for
399                // hierarchical visibility culling and rendering
400                InitVisibilityCulling(mCameraInProgress);
401
402
403                /**
404                * the hierarchical culling algorithm
405                * for depth pass: we just find objects and update depth buffer
406                * for "delayed" rendering: we render some passes afterwards
407                * e.g., transparents, because they need front-to-back sorting
408                **/
409               
410                mVisibilityManager->ApplyVisibilityCulling();
411
412                // delete remaining renderables from queue:
413                // all which are not in mLeavePassesInQueue)
414#ifdef GTP_VISIBILITY_MODIFIED_OGRE
415                _deleteRenderedQueueGroups(mLeavePassesInQueue);
416#endif
417
418                //-- reset parameters needed for special rendering
419               
420                mIsDepthPassPhase = false;
421                mIsItemBufferPhase = false;
422                mSkipTransparents = false;
423                mIsHierarchicalCulling = false;
424               
425                mLeavePassesInQueue = 0;
426               
427                // add visible nodes found by the visibility culling algorithm
428                if (mUseDepthPass)
429                {
430                        NodeList::const_iterator it, it_end = mVisible.end();
431
432                        //getRenderQueue()->clear();
433                        for (it = mVisible.begin(); it != it_end; ++ it)
434                        {
435                                (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
436                        }
437                }
438                //-- now we can render all remaining queue objects
439                //-- used for depth pass, transparents, overlay
440                clearSpecialCaseRenderQueues();
441
442                TerrainSceneManager::_renderVisibleObjects();
443        } // end hierarchical culling
444               
445        // HACK: set the new render level index, important to avoid cracks
446        // in terrain caused by LOD
447        TerrainRenderable::NextRenderLevelIndex();
448       
449        // reset ambient light
450        setAmbientLight(savedAmbient);
451
452        if (!mDeleteQueueAfterRendering)
453                getRenderQueue()->clear(); // finally clear render queue
454        else
455                OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ...
456
457        if (0) WriteLog(); // write out stats
458}
459
460//-----------------------------------------------------------------------
461void OcclusionCullingSceneManager::_updateSceneGraph(Camera* cam)
462{
463        if (mNormalExecution)
464        {
465                OctreeSceneManager::_updateSceneGraph(cam);
466                return;
467        }
468
469        mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
470        mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
471
472        TerrainSceneManager::_updateSceneGraph(cam);
473}
474//-----------------------------------------------------------------------
475bool OcclusionCullingSceneManager::setOption(const String & key, const void * val)
476{
477        if (key == "UseDepthPass")
478        {
479                mUseDepthPass = (*static_cast<const bool *>(val));
480                return true;
481        }
482        if (key == "PrepareVisualization")
483        {
484                mShowVisualization = (*static_cast<const bool *>(val));
485                return true;
486        }
487        if (key == "RenderNodesForViz")
488        {
489                mRenderNodesForViz = (*static_cast<const bool *>(val));
490                return true;
491        }
492        if (key == "RenderNodesContentForViz")
493        {
494                mRenderNodesContentForViz = (*static_cast<const bool *>(val));
495                return true;
496        }
497        if (key == "SkyBoxEnabled")
498        {
499                mSkyBoxEnabled = (*static_cast<const bool *>(val));
500                return true;
501        }
502        if (key == "SkyPlaneEnabled")
503        {
504                mSkyPlaneEnabled = (*static_cast<const bool *>(val));
505                return true;
506        }
507        if (key == "SkyDomeEnabled")
508        {
509                mSkyDomeEnabled = (*static_cast<const bool *>(val));
510                return true;
511        }
512        if (key == "VisualizeCulledNodes")
513        {
514                mVisualizeCulledNodes = (*static_cast<const bool *>(val));
515                return true;
516        }
517        if (key == "DelayRenderTransparents")
518        {
519                mDelayRenderTransparents = (*static_cast<const bool *>(val));
520                return true;
521        }
522        if (key == "DepthWrite")
523        {
524                mEnableDepthWrite = (*static_cast<const bool *>(val));
525                return true;
526        }
527        if (key == "UseItemBuffer")
528        {
529                mUseItemBuffer = (*static_cast<const bool *>(val));
530                return true;
531        }
532        if (key == "ExecuteVertexProgramForAllPasses")
533        {
534                mExecuteVertexProgramForAllPasses  = (*static_cast<const bool *>(val));
535                return true;
536        }
537        if (key == "RenderTransparentsForItemBuffer")
538        {
539                mRenderTransparentsForItemBuffer  = (*static_cast<const bool *>(val));
540                return true;
541        }
542        if (key == "NodeVizScale")
543        {
544                OctreeNode::setVizScale(*static_cast<const float *>(val));
545                return true;
546        }
547        if (key == "LoadViewCells")
548        {
549                if (!mViewCellsLoaded)
550                {
551                        String filename(static_cast<const char *>(val));
552                        mViewCellsLoaded = LoadViewCells(filename);     
553                }
554
555                return mViewCellsLoaded;
556        }
557        if (key == "UseViewCells")
558        {
559                if (mViewCellsLoaded)
560                {
561                        mUseViewCells = *static_cast<const bool *>(val);
562
563                        // reset view cell
564                        OGRE_DELETE(mCurrentViewCell);
565
566                        if (mUseViewCells)
567                                mCurrentViewCell = mViewCellsManager->GenerateViewCell();
568
569                        mElementaryViewCell = NULL;
570
571                        // if using view cells, all objects are set to false initially
572                        SetObjectsVisible(!mUseViewCells);
573                }
574
575                return true;
576        }
577        if (key == "NormalExecution")
578        {
579                mNormalExecution = *static_cast<const bool *>(val);
580                return true;
581        }
582        if (key == "UseVisibilityFilter")
583        {
584                mUseVisibilityFilter = *static_cast<const bool *>(val);
585                // set null =>recomputation of the pvs
586        mElementaryViewCell = NULL;
587                return true;
588        }
589
590        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
591                setOption(key, val) || TerrainSceneManager::setOption(key, val);
592}
593//-----------------------------------------------------------------------
594bool OcclusionCullingSceneManager::getOption(const String & key, void *val)
595{
596        if (key == "NumHierarchyNodes")
597        {
598                * static_cast<unsigned int *>(val) = (unsigned int)mNumOctants;
599                return true;
600        }
601        if (key == "VisibilityManager")
602        {
603                * static_cast<GtpVisibility::VisibilityManager **>(val) =
604                        (GtpVisibility::VisibilityManager *)mVisibilityManager;
605                return true;
606        }
607        if (key == "HierarchInterface")
608        {
609                * static_cast<GtpVisibility::HierarchyInterface **>(val) =
610                        (GtpVisibility::HierarchyInterface *)mHierarchyInterface;
611                return true;
612        }
613
614        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
615                getOption(key, val) && TerrainSceneManager::getOption(key, val);
616}
617//-----------------------------------------------------------------------
618bool OcclusionCullingSceneManager::getOptionValues(const String & key,
619                                                                                                        StringVector &refValueList)
620{
621        return TerrainSceneManager::getOptionValues( key, refValueList);
622}
623//-----------------------------------------------------------------------
624bool OcclusionCullingSceneManager::getOptionKeys(StringVector & refKeys)
625{
626        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
627                getOptionKeys(refKeys) || TerrainSceneManager::getOptionKeys(refKeys);
628}
629//-----------------------------------------------------------------------
630void OcclusionCullingSceneManager::setVisibilityManager(GtpVisibility::
631                                                                                                                 VisibilityManager *visManager)
632{
633        mVisibilityManager = visManager;
634}
635//-----------------------------------------------------------------------
636GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::getVisibilityManager( void )
637{
638        return mVisibilityManager;
639}
640//-----------------------------------------------------------------------
641void OcclusionCullingSceneManager::WriteLog()
642{
643        std::stringstream d;
644
645        d << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", "
646          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", "
647          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", "
648          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", "
649          << "Hierarchy nodes: " << mNumOctants << ", "
650          << "Traversed nodes: " << mHierarchyInterface->GetNumTraversedNodes() << ", "
651          << "Rendered nodes: " << mHierarchyInterface->GetNumRenderedNodes() << ", "
652          << "Query culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumQueryCulledNodes() << ", "
653          << "Frustum culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumFrustumCulledNodes() << ", "
654      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << ", "
655          << "Found objects: " << (int)mVisible.size() << "\n";
656
657        LogManager::getSingleton().logMessage(d.str());
658}
659//-----------------------------------------------------------------------
660void OcclusionCullingSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,
661                                                                                                                                QueuedRenderableCollection::OrganisationMode om)
662{
663    // Basic render loop
664    // Iterate through priorities
665    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
666
667    while (groupIt.hasMoreElements())
668    {
669        RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
670
671        // Sort the queue first
672        pPriorityGrp->sort(mCameraInProgress);
673
674        // Do solids
675        renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
676
677                // for correct rendering, transparents must be rendered after hierarchical culling
678                // => do nothing
679
680        // Do transparents (always descending)
681                if (mNormalExecution || !mSkipTransparents)
682                {
683                        renderObjects(pPriorityGrp->getTransparents(),
684                        QueuedRenderableCollection::OM_SORT_DESCENDING, true);
685                }
686
687
688    }// for each priority
689}
690
691//-----------------------------------------------------------------------
692bool OcclusionCullingSceneManager::validatePassForRendering(Pass* pass)
693{
694        if (mNormalExecution)
695        {
696                return SceneManager::validatePassForRendering(pass);
697        }
698
699        // skip all but first pass if we are doing the depth pass
700        if ((mIsDepthPassPhase || mIsItemBufferPhase) && (pass->getIndex() > 0))
701        {
702                return false;
703        }
704        // all but first pass
705        /*else if ((!mIsDepthPassPhase || mIsItemBufferPhase) && (pass->getIndex() != 0))
706        {
707                return false;
708        }*/
709
710        return SceneManager::validatePassForRendering(pass);
711}
712//-----------------------------------------------------------------------
713void OcclusionCullingSceneManager::_renderQueueGroupObjects(RenderQueueGroup* pGroup,
714                                                                                                                        QueuedRenderableCollection::OrganisationMode om)
715{
716        if (mNormalExecution || !mIsItemBufferPhase)
717        {
718                TerrainSceneManager::_renderQueueGroupObjects(pGroup, om);
719                return;
720        }
721#ifdef  ITEM_BUFFER
722        //-- item buffer
723        //-- item buffer: render objects using false colors
724
725    // Iterate through priorities
726    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
727
728        while (groupIt.hasMoreElements())
729    {
730                RenderItemBuffer(groupIt.getNext());
731        }
732#endif // ITEM_BUFFER
733}
734#ifdef ITEM_BUFFER
735//-----------------------------------------------------------------------
736void OcclusionCullingSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
737{
738        // Do solids
739        QueuedRenderableCollection solidObjs = pGroup->getSolidsBasic();//msz
740
741        // ----- SOLIDS LOOP -----
742        RenderPriorityGroup::SolidRenderablePassMap::const_iterator ipass, ipassend;
743        ipassend = solidObjs.end();
744
745        for (ipass = solidObjs.begin(); ipass != ipassend; ++ipass)
746        {
747                // Fast bypass if this group is now empty
748                if (ipass->second->empty())
749                        continue;
750
751                // Render only first pass of renderable as false color
752                if (ipass->first->getIndex() > 0)
753                        continue;
754
755                RenderPriorityGroup::RenderableList* rendList = ipass->second;
756               
757                RenderPriorityGroup::RenderableList::const_iterator irend, irendend;
758                irendend = rendList->end();
759                       
760                for (irend = rendList->begin(); irend != irendend; ++irend)
761                {
762                        if (0)
763                        {
764                        std::stringstream d; d << "itembuffer, pass name: " <<
765                                ipass->first->getParent()->getParent()->getName();
766                               
767                        LogManager::getSingleton().logMessage(d.str());
768                        }
769                       
770                        RenderSingleObjectForItemBuffer(*irend, ipass->first);
771                }
772        }
773
774        //-- TRANSPARENT LOOP: must be handled differently from solids
775
776        // transparents are treated either as solids or completely discarded
777        if (mRenderTransparentsForItemBuffer)
778        {
779                QueuedRenderableCollection transpObjs = pGroup->getTransparents(); //msz
780                RenderPriorityGroup::TransparentRenderablePassList::const_iterator
781                        itrans, itransend;
782
783                itransend = transpObjs.end();
784                for (itrans = transpObjs.begin(); itrans != itransend; ++itrans)
785                {
786                        // like for solids, render only first pass
787                        if (itrans->pass->getIndex() == 0)
788                        {       
789                                RenderSingleObjectForItemBuffer(itrans->renderable, itrans->pass);
790                        }
791                }
792        }
793}
794//-----------------------------------------------------------------------
795void OcclusionCullingSceneManager::RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass)
796{
797        static LightList nullLightList;
798       
799        int col[4];
800       
801        // -- create color code out of object id
802        col[0] = (rend->getId() >> 16) & 255;
803        col[1] = (rend->getId() >> 8) & 255;
804        col[2] = rend->getId() & 255;
805//      col[3] = 255;
806
807        //mDestRenderSystem->setColour(col[0], col[1], col[2], col[3]);
808   
809        mItemBufferPass->setAmbient(ColourValue(col[0] / 255.0f,
810                                                                                    col[1] / 255.0f,
811                                                                                        col[2] / 255.0f, 1));
812
813        // set vertex program of current pass
814        if (mExecuteVertexProgramForAllPasses && pass->hasVertexProgram())
815        {
816                mItemBufferPass->setVertexProgram(pass->getVertexProgramName());
817
818                if (mItemBufferPass->hasVertexProgram())
819                {
820                        const GpuProgramPtr& prg = mItemBufferPass->getVertexProgram();
821                        // Load this program if not done already
822                        if (!prg->isLoaded())
823                                prg->load();
824                        // Copy params
825                        mItemBufferPass->setVertexProgramParameters(pass->getVertexProgramParameters());
826                }
827        }
828        else if (mItemBufferPass->hasVertexProgram())
829        {
830                mItemBufferPass->setVertexProgram("");
831        }
832
833        const Pass *usedPass = _setPass(mItemBufferPass);
834
835
836        // render a single object, this will set up auto params if required
837        renderSingleObject(rend, usedPass, false, &nullLightList);
838}
839#endif // ITEM_BUFFER
840//-----------------------------------------------------------------------
841GtpVisibility::VisibilityManager *OcclusionCullingSceneManager::GetVisibilityManager()
842{
843        return mVisibilityManager;
844}
845//-----------------------------------------------------------------------
846void OcclusionCullingSceneManager::InitVisibilityCulling(Camera *cam)
847{
848        // reset culling manager stats
849        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes);
850
851        // set depth pass flag before rendering
852        mIsDepthPassPhase = mUseDepthPass;
853
854        mIsHierarchicalCulling = true; // during hierarchical culling
855
856        // item buffer needs full ambient lighting to use item colors as unique id
857        if (mUseItemBuffer)
858        {
859                mIsItemBufferPhase = true;
860                setAmbientLight(ColourValue(1,1,1,1));
861        }
862
863
864        // set passes which are stored in render queue
865        // for rendering AFTER hierarchical culling, i.e., passes which need
866        // a special rendering order
867       
868        mLeavePassesInQueue = 0;
869
870        // if we have the depth pass or use an item buffer, no passes are left in the queue
871        if (1 && !mUseDepthPass && !mUseItemBuffer)
872        {
873                if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
874                {
875                        // TODO: remove this pass because it should be processed during hierarchical culling
876                        //mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW;
877
878                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DECAL;
879                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DIFFUSE_SPECULAR;
880                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
881
882                        // just render ambient passes
883                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
884                        // mIlluminationStage = IRS_AMBIENT;
885                        //getRenderQueue()->setSplitPassesByLightingType(true);
886                }
887       
888                if (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE)
889                {
890                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW;
891                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
892                }
893       
894                // transparents should be rendered after hierarchical culling to
895                // provide front-to-back ordering
896                if (mDelayRenderTransparents)
897                {
898                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
899                }
900        }
901
902        // skip rendering transparents during the hierarchical culling
903        // (because they will be rendered afterwards)
904        mSkipTransparents =
905                (mIsDepthPassPhase || (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES));
906
907        // -- initialise interface for rendering traversal of the hierarchy
908        mHierarchyInterface->SetHierarchyRoot(mOctree);
909       
910        // possible two cameras (one for culling, one for rendering)
911        mHierarchyInterface->InitTraversal(mCameraInProgress,
912                                                                           mCullCamera ? getCamera("CullCamera") : NULL,
913                                                                           mLeavePassesInQueue);
914               
915}
916//-----------------------------------------------------------------------
917OctreeHierarchyInterface *OcclusionCullingSceneManager::GetHierarchyInterface()
918{
919        return mHierarchyInterface;
920}
921//-----------------------------------------------------------------------
922void OcclusionCullingSceneManager::endFrame()
923{
924        TerrainRenderable::ResetRenderLevelIndex();
925}
926//-----------------------------------------------------------------------
927Entity* OcclusionCullingSceneManager::createEntity(const String& entityName,
928                                                                                                        const String& meshName)
929{
930        Entity *ent = SceneManager::createEntity(entityName, meshName);
931
932        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i)
933        {
934                ent->getSubEntity(i)->setId(mCurrentEntityId);
935        }
936
937        // increase counter of entity id values
938        ++ mCurrentEntityId;
939
940        return ent;
941}
942//-----------------------------------------------------------------------
943void OcclusionCullingSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
944        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
945{
946        // only render solid passes during hierarchical culling
947        if (mIsHierarchicalCulling)
948        {
949                RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
950            LightList lightList;
951
952                while (groupIt.hasMoreElements())
953                {
954                        RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
955
956                        // Sort the queue first
957                        pPriorityGrp->sort(mCameraInProgress);
958
959                        // Clear light list
960                        lightList.clear();
961
962                        // Render all the ambient passes first, no light iteration, no lights
963                        /*** msz: no more IRS_AMBIENT, see OgreSceneManager.h ***/
964                        // mIlluminationStage = IRS_AMBIENT;
965
966                        OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, false, &lightList);
967                        // Also render any objects which have receive shadows disabled
968                        OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, true);
969#if 0           
970                        std::stringstream d;
971                        d << " solid size: " << (int)pPriorityGrp->_getSolidPasses().size()
972                                << " solid no shadow size: " << (int)pPriorityGrp->_getSolidPassesNoShadow().size()
973                                << "difspec size: " << (int)pPriorityGrp->_getSolidPassesDiffuseSpecular().size()
974                                << " decal size: " << (int)pPriorityGrp->_getSolidPassesDecal().size();
975                        LogManager::getSingleton().logMessage(d.str());
976#endif
977                }
978        }
979        else // render the rest of the passes
980        {
981                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup, om);
982        }
983}
984//-----------------------------------------------------------------------
985void OcclusionCullingSceneManager::renderModulativeStencilShadowedQueueGroupObjects(
986        RenderQueueGroup* pGroup, QueuedRenderableCollection::OrganisationMode om)
987{
988   if (mIsHierarchicalCulling)
989   {
990           // Iterate through priorities
991           RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
992
993           while (groupIt.hasMoreElements())
994           {
995                   RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
996
997                   // Sort the queue first
998                   pPriorityGrp->sort(mCameraInProgress);
999
1000                   // Do (shadowable) solids
1001                   OctreeSceneManager::renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
1002           }
1003   }
1004   else
1005   {
1006           OctreeSceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup, om);
1007   }
1008}
1009//-------------------------------------------------------------------------
1010void OcclusionCullingSceneManager::SetObjectsVisible(const bool visible)
1011{
1012        GtpVisibilityPreprocessor::ObjectContainer::iterator it, it_end = mObjects.end();
1013
1014        for (it = mObjects.begin(); it != it_end; ++ it)
1015        {
1016                OgreMeshInstance *omi = static_cast<OgreMeshInstance *>(*it);
1017                Entity *ent = omi->GetMesh();
1018               
1019                ent->setVisible(visible);
1020        }
1021}
1022//-----------------------------------------------------------------------
1023bool OcclusionCullingSceneManager::LoadViewCells(const String &filename)
1024{
1025        // objects are set to invisible initially
1026        SetObjectsVisible(false);
1027       
1028        const string bboxesFilename = mVisibilityManager->GetVisibilityEnvironment()->getViewCellsFileName();
1029
1030        // converter between view cell ids and Ogre entites
1031        GtpVisibilityPreprocessor::IndexedBoundingBoxContainer iboxes;
1032        OgreBoundingBoxConverter bconverter(this);
1033
1034        // load the view cells assigning the found objects to the pvss
1035        mViewCellsManager =
1036                GtpVisibilityPreprocessor::ViewCellsManager::LoadViewCells(filename, &mObjects, false, &bconverter);
1037
1038        return (mViewCellsManager != NULL);
1039}
1040//-------------------------------------------------------------------------
1041void OcclusionCullingSceneManager::applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc,
1042                                                                                                        const bool load)
1043{       // NOTE: should not happen, rather apply view cell representing unbounded space then
1044        if (!vc)
1045        {       
1046                // set everything visible for savety
1047                SetObjectsVisible(true);
1048
1049                return;
1050        }
1051               
1052        GtpVisibilityPreprocessor::ObjectPvsMap::const_iterator oit,
1053                        oit_end = vc->GetPvs().mEntries.end();
1054
1055        //-- PVS of view cell
1056        for (oit = vc->GetPvs().mEntries.begin(); oit != oit_end; ++ oit)
1057        {
1058                if (!(*oit).first) continue;
1059
1060                OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance *>((*oit).first);
1061                omi->GetMesh()->setVisible(load);
1062                //GtpVisibilityPreprocessor::Debug << "assigned id " << omi->GetId() << endl;
1063        }
1064}
1065//-------------------------------------------------------------------------
1066void OcclusionCullingSceneManager::updatePvs(Camera *cam)
1067{
1068        if (!(mViewCellsLoaded && mUseViewCells))
1069                return;
1070
1071        const GtpVisibilityPreprocessor::Vector3 viewPoint =
1072                OgreTypeConverter::ConvertFromOgre(cam->getDerivedPosition());
1073
1074        GtpVisibilityPreprocessor::ViewCell *newElementary =
1075                mViewCellsManager->GetViewCell(viewPoint);
1076
1077        // elementary view cell did not change => apply same pvs
1078        if (mElementaryViewCell == newElementary)
1079                return;
1080
1081        mElementaryViewCell = newElementary;
1082        //LogManager::getSingleton().logMessage("unloading");
1083        //-- unload old pvs
1084        applyViewCellPvs(mCurrentViewCell, false);
1085
1086
1087        //-- the new view cell
1088               
1089        GtpVisibilityPreprocessor::ViewCell *viewCell;
1090
1091               
1092        if (mUseVisibilityFilter)
1093        {
1094                //-- compute new filtered cell
1095                GtpVisibilityPreprocessor::PrVs prvs;
1096                mViewCellsManager->GetPrVS(viewPoint, prvs, 5);
1097                viewCell = prvs.mViewCell;
1098        }
1099        else
1100        {
1101                viewCell = newElementary;
1102        }
1103        //LogManager::getSingleton().logMessage("loading");
1104        //-- load new pvs
1105        applyViewCellPvs(viewCell, true);
1106
1107        // store pvs
1108        mCurrentViewCell->SetPvs(viewCell->GetPvs());
1109
1110        // delete merge tree of filtered view cell
1111        if (mUseVisibilityFilter)
1112                mViewCellsManager->DeleteLocalMergeTree(viewCell);
1113}
1114#if 0
1115//-------------------------------------------------------------------------
1116void OcclusionCullingSceneManager::TestVisible(SceneNode *node)
1117{
1118        // first test for scene node, then for octant (part of the hierarchy)
1119        if (!node->mVisibleChildren)
1120                node->setVisible(false);
1121
1122        node->getOctant()->mVisibleChildren --;
1123}
1124//-------------------------------------------------------------------------
1125void OcclusionCullingSceneManager::TestVisible(Octree *octant)
1126{
1127        // first test for scene node, then for octant (part of the hierarchy)
1128        if (!octant->mVisibleChildren)
1129                octant->setVisible(false);
1130}
1131
1132//-------------------------------------------------------------------------
1133void OcclusionCullingSceneManager::UpdateVisibility(Entity *ent)
1134{
1135        if (!ent->isVisible())
1136        {
1137                bool visible = TestVisible(ent->getParentNode());
1138               
1139                if (!visible)
1140                        visible = TestVisible(octant->getParentNode());
1141
1142                if (!visible)
1143                        mHierarchyInterface->pullupVisibility();
1144        }
1145}
1146#endif
1147//-----------------------------------------------------------------------
1148const String OcclusionCullingSceneManagerFactory::FACTORY_TYPE_NAME = "OcclusionCullingSceneManager";
1149//-----------------------------------------------------------------------
1150void OcclusionCullingSceneManagerFactory::initMetaData(void) const
1151{
1152        mMetaData.typeName = FACTORY_TYPE_NAME;
1153        mMetaData.description = "Scene manager organising the scene on the basis of an octree with advanced occlusion culling (TM).";
1154        mMetaData.sceneTypeMask = 0xFFFF; // support all types
1155        mMetaData.worldGeometrySupported = false;
1156}
1157//-----------------------------------------------------------------------
1158SceneManager *OcclusionCullingSceneManagerFactory::createInstance(
1159                const String& instanceName)
1160{
1161        OcclusionCullingSceneManager* tsm = new OcclusionCullingSceneManager(instanceName, visManager);
1162       
1163        // Create & register default sources (one per manager)
1164        HeightmapTerrainPageSource* ps = new HeightmapTerrainPageSource();
1165        mTerrainPageSources.push_back(ps);
1166        tsm->registerPageSource("Heightmap", ps);
1167
1168        return tsm;
1169}
1170//-----------------------------------------------------------------------
1171void OcclusionCullingSceneManagerFactory::destroyInstance(SceneManager* instance)
1172{
1173        delete instance;
1174}
1175
1176} // namespace Ogre
Note: See TracBrowser for help on using the repository browser.