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

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