source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityOctreeSceneManager.cpp @ 720

Revision 720, 26.2 KB checked in by mattausch, 18 years ago (diff)
Line 
1#include "OgreVisibilityOctreeSceneManager.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 <OgreConfigFile.h>
12
13namespace Ogre {
14
15//-----------------------------------------------------------------------
16VisibilityOctreeSceneManager::VisibilityOctreeSceneManager(
17        GtpVisibility::VisibilityManager *visManager)
18:
19mVisibilityManager(visManager),
20mShowVisualization(false),
21mRenderNodesForViz(false),
22mRenderNodesContentForViz(false),
23mVisualizeCulledNodes(false),
24mLeavePassesInQueue(0),
25mDelayRenderTransparents(true),
26//mDelayRenderTransparents(false),
27//mUseDepthPass(true),
28mUseDepthPass(false),
29mIsDepthPassPhase(false),
30mUseItemBuffer(false),
31//mUseItemBuffer(true),
32mIsItemBufferPhase(false),
33mCurrentEntityId(1),
34mEnableDepthWrite(true),
35mSkipTransparents(false),
36mRenderTransparentsForItemBuffer(true),
37mExecuteVertexProgramForAllPasses(true),
38mIsHierarchicalCulling(false)
39{
40        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
41               
42        //mDisplayNodes = true;
43        //mShowBoundingBoxes = true;
44        //mShowBoxes = true;
45
46        // TODO: set maxdepth to reasonable value
47        mMaxDepth = 50;
48
49        //loadVisibilityConfig("GtpVisibility.cfg");
50}
51//-----------------------------------------------------------------------
52void VisibilityOctreeSceneManager::InitDepthPass()
53{
54        MaterialPtr depthMat = MaterialManager::getSingleton().getByName("Visibility/DepthPass");
55
56        if (depthMat.isNull())
57    {
58                depthMat = MaterialManager::getSingleton().create(
59                "Visibility/DepthPass",
60                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
61
62                mDepthPass = depthMat->getTechnique(0)->getPass(0);
63                mDepthPass->setColourWriteEnabled(false);
64                mDepthPass->setDepthWriteEnabled(true);
65                mDepthPass->setLightingEnabled(false);
66        }
67        else
68        {
69                mDepthPass = depthMat->getTechnique(0)->getPass(0);
70        }
71}
72//-----------------------------------------------------------------------
73VisibilityOctreeSceneManager::~VisibilityOctreeSceneManager()
74{
75        OGRE_DELETE(mHierarchyInterface);
76}
77//-----------------------------------------------------------------------
78void VisibilityOctreeSceneManager::InitItemBufferPass()
79{
80        MaterialPtr itemBufferMat = MaterialManager::getSingleton().
81                getByName("Visibility/ItemBufferPass");
82
83        if (itemBufferMat.isNull())
84    {
85                // Init
86                itemBufferMat = MaterialManager::getSingleton().create("Visibility/ItemBufferPass",
87                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
88
89                mItemBufferPass = itemBufferMat->getTechnique(0)->getPass(0);
90                mItemBufferPass->setColourWriteEnabled(true);
91                mItemBufferPass->setDepthWriteEnabled(true);
92                mItemBufferPass->setLightingEnabled(true);
93                //mItemBufferPass->setLightingEnabled(false);
94        }
95        else
96        {
97                mItemBufferPass = itemBufferMat->getTechnique(0)->getPass(0);
98        }
99        //mItemBufferPass->setAmbient(1, 1, 0);
100}
101//-----------------------------------------------------------------------
102void VisibilityOctreeSceneManager::PrepareVisualization(Camera *cam)
103{
104        // add player camera for visualization purpose
105        try
106        {
107                Camera *c;
108                if ((c = getCamera("PlayerCam")) != NULL)
109                {
110                        getRenderQueue()->addRenderable(c);
111                }   
112    }
113    catch(...)
114    {
115        // ignore
116    }
117        for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
118{
119                getRenderQueue()->addRenderable(*it);
120        }
121        if (mRenderNodesForViz || mRenderNodesContentForViz)
122        {
123                // change node material so it is better suited for visualization
124                MaterialPtr nodeMat = MaterialManager::getSingleton().getByName("Core/NodeMaterial");
125                nodeMat->setAmbient(1, 1, 0);
126                nodeMat->setLightingEnabled(true);
127                nodeMat->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
128
129                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
130                {
131                        if (mRenderNodesForViz)
132                        {
133                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0)
134                                        && (*it)->getAttachedObject(0)->getMovableType() == "Entity")
135                                getRenderQueue()->addRenderable((*it));
136
137                                // addbounding boxes instead of node itself
138                                //(*it)->_addBoundingBoxToQueue(getRenderQueue());
139                        }
140                        if (mRenderNodesContentForViz)
141                        {
142                                (*it)->_addToRenderQueue(cam, getRenderQueue(), false);
143                        }
144                }
145        }
146}
147//-----------------------------------------------------------------------
148Pass *VisibilityOctreeSceneManager::setPass(Pass* pass)
149{
150        // set depth fill pass if we currently do not make an aabb occlusion query
151        Pass *usedPass = (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery() ?
152                                          mDepthPass : pass);
153
154        IlluminationRenderStage savedStage = mIlluminationStage;
155       
156        // set illumination stage to NONE so no shadow material is used
157        // for depth pass or for occlusion query
158        if (mIsDepthPassPhase || mHierarchyInterface->IsBoundingBoxQuery())
159        {
160                mIlluminationStage = IRS_NONE;
161        }
162
163        //-- set vertex program of current pass in order to set correct depth
164        if (mIsDepthPassPhase && mExecuteVertexProgramForAllPasses && pass->hasVertexProgram())
165    {
166                // add vertex program of current pass to depth pass
167                mDepthPass->setVertexProgram(pass->getVertexProgramName());
168
169                if (mDepthPass->hasVertexProgram())
170                {
171                        const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
172                        // Load this program if not done already
173                        if (!prg->isLoaded())
174                                prg->load();
175                        // Copy params
176                        mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
177                }
178        }
179        else if (mDepthPass->hasVertexProgram())
180        {
181                mDepthPass->setVertexProgram("");
182        }
183
184        // store depth write flag to reset later
185        bool IsDepthWrite = usedPass->getDepthWriteEnabled();
186
187        // global option which enables / disables depth writes
188        if (!mEnableDepthWrite)
189        {
190                usedPass->setDepthWriteEnabled(false);
191        }
192        //else if (mIsItemBufferPass) {usedPass = mItemBufferPass;}
193
194        Pass *result = SceneManager::setPass(usedPass);
195
196        // reset depth write
197        if (!mEnableDepthWrite)
198        {
199                usedPass->setDepthWriteEnabled(IsDepthWrite);
200        }
201
202        // reset illumination stage
203        mIlluminationStage = savedStage;
204
205        return result;
206}
207//-----------------------------------------------------------------------
208void VisibilityOctreeSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
209{
210        //-- show visible scene nodes and octree bounding boxes from last frame
211        if (mShowVisualization)
212    {
213                PrepareVisualization(cam);
214        }
215        else
216        {       
217                // for hierarchical culling, we interleave identification
218                // and rendering of objects in _renderVisibibleObjects
219
220                // for the shadow pass we use only standard rendering
221                // because of low occlusion
222                if (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&
223                        mIlluminationStage == IRS_RENDER_TO_TEXTURE)
224                {
225                        OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
226                }
227                // only shadow casters will be rendered in shadow texture pass
228                // mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
229        }
230       
231       
232        // -- delete lists stored for visualization
233        mVisible.clear();
234        mBoxes.clear();
235}
236//-----------------------------------------------------------------------
237void VisibilityOctreeSceneManager::_renderVisibleObjects()
238{
239       
240                //InitVisibilityCulling(mCameraInProgress);
241                //mVisibilityManager->ApplyVisibilityCulling();
242
243                if(1){
244        InitDepthPass();          // create material for depth pass
245        InitItemBufferPass(); // create material for item buffer pass
246
247        // save ambient light to reset later
248        ColourValue savedAmbient = mAmbientLight;
249
250        //-- apply standard rendering for some modes (e.g., visualization, shadow pass)
251
252        if (mShowVisualization ||
253           (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&
254            mIlluminationStage == IRS_RENDER_TO_TEXTURE))
255        {
256                IlluminationRenderStage savedStage = mIlluminationStage;
257       
258                if (mShowVisualization)
259                {
260                        // disable illumination stage to prevent rendering shadows
261                        mIlluminationStage = IRS_NONE;
262                }
263
264                // standard rendering for shadow maps because of performance
265                OctreeSceneManager::_renderVisibleObjects();
266
267                mIlluminationStage = savedStage;
268        }
269        else //-- the hierarchical culling algorithm
270        {       
271                // don't render backgrounds for item buffer
272                if (mUseItemBuffer)
273                {
274                        clearSpecialCaseRenderQueues();
275                        getRenderQueue()->clear();
276                }       
277
278                //-- hierarchical culling
279                // the objects of different layers (e.g., background, scene,
280                // overlay) must be identified and rendered one after another
281
282                //-- render all early skies
283                clearSpecialCaseRenderQueues();
284                addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND);
285                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY);
286                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE);
287
288                OctreeSceneManager::_renderVisibleObjects();
289
290
291#ifdef GTP_VISIBILITY_MODIFIED_OGRE
292                // delete previously rendered content
293                _deleteRenderedQueueGroups();
294#endif
295
296                //-- prepare queue for visible objects (i.e., all but overlay and skies late)
297                clearSpecialCaseRenderQueues();
298                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE);
299                addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY);
300                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE);
301       
302
303                // set all necessary parameters for
304                // hierarchical visibility culling and rendering
305                InitVisibilityCulling(mCameraInProgress);
306       
307                /**
308                * the hierarchical culling algorithm
309                * for depth pass: we just find objects and update depth buffer
310                * for "delayed" rendering: we render some passes afterwards
311                * e.g., transparents, because they need front-to-back sorting
312                **/
313       
314                mVisibilityManager->ApplyVisibilityCulling();
315       
316                // delete remaining renderables from queue (all not in mLeavePassesInQueue)
317#ifdef GTP_VISIBILITY_MODIFIED_OGRE
318                _deleteRenderedQueueGroups(mLeavePassesInQueue);
319#endif
320
321                //-- reset parameters
322                mIsDepthPassPhase = false;
323                mIsItemBufferPhase = false;
324                mSkipTransparents = false;
325                mIsHierarchicalCulling = false;
326
327                mLeavePassesInQueue = 0;
328
329                // add visible nodes found by the visibility culling algorithm
330                if (mUseDepthPass)
331                {
332                        for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it)
333                        {
334                                (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false);
335                        }
336                }
337       
338                //-- we render all remaining queue objects
339                // used for depth pass, transparents, overlay
340                clearSpecialCaseRenderQueues();
341                OctreeSceneManager::_renderVisibleObjects();
342       
343        }   // hierarchical culling
344
345        // reset ambient light
346        setAmbientLight(savedAmbient);
347}       
348        getRenderQueue()->clear(); // finally clear render queue
349        OGRE_DELETE(mRenderQueue); // HACK: should be cleared before...
350        //WriteLog(); // write out stats
351
352}
353
354//-----------------------------------------------------------------------
355void VisibilityOctreeSceneManager::_updateSceneGraph(Camera* cam)
356{
357        mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface);
358        mHierarchyInterface->SetRenderSystem(mDestRenderSystem);
359
360        OctreeSceneManager::_updateSceneGraph(cam);
361}
362//-----------------------------------------------------------------------
363bool VisibilityOctreeSceneManager::setOption(const String & key, const void * val)
364{
365        if (key == "UseDepthPass")
366        {
367                mUseDepthPass = (*static_cast<const bool *>(val));
368                return true;
369        }
370        if (key == "PrepareVisualization")
371        {
372                mShowVisualization = (*static_cast<const bool *>(val));
373                return true;
374        }
375        if (key == "RenderNodesForViz")
376        {
377                mRenderNodesForViz = (*static_cast<const bool *>(val));
378                return true;
379        }
380        if (key == "RenderNodesContentForViz")
381        {
382                mRenderNodesContentForViz = (*static_cast<const bool *>(val));
383                return true;
384        }
385        if (key == "SkyBoxEnabled")
386        {
387                mSkyBoxEnabled = (*static_cast<const bool *>(val));
388                return true;
389        }
390        if (key == "SkyPlaneEnabled")
391        {
392                mSkyPlaneEnabled = (*static_cast<const bool *>(val));
393                return true;
394        }
395        if (key == "SkyDomeEnabled")
396        {
397                mSkyDomeEnabled = (*static_cast<const bool *>(val));
398                return true;
399        }
400        if (key == "VisualizeCulledNodes")
401        {
402                mVisualizeCulledNodes = (*static_cast<const bool *>(val));
403                return true;
404        }
405        if (key == "DelayRenderTransparents")
406        {
407                mDelayRenderTransparents = (*static_cast<const bool *>(val));
408                return true;
409        }
410
411        if (key == "DepthWrite")
412        {
413                mEnableDepthWrite = (*static_cast<const bool *>(val));
414                return true;
415        }
416        if (key == "UseItemBuffer")
417        {
418                mUseItemBuffer = (*static_cast<const bool *>(val));
419                return true;
420        }
421        if (key == "ExecuteVertexProgramForAllPasses")
422        {
423                mExecuteVertexProgramForAllPasses  = (*static_cast<const bool *>(val));
424                return true;
425        }
426        if (key == "RenderTransparentsForItemBuffer")
427        {
428                mRenderTransparentsForItemBuffer  = (*static_cast<const bool *>(val));
429                return true;
430        }
431        if (key == "NodeVizScale")
432        {
433                OctreeNode::setVizScale(*static_cast<const float *>(val));
434                return true;
435        }
436        if (key == "UseArbQueries")
437        {
438                bool useArbQueries = (*static_cast<const bool *>(val));
439
440                if (useArbQueries)
441                {
442                        mHierarchyInterface->DeleteQueries();
443                        mDestRenderSystem->setConfigOption("ArbQueries", "Yes");
444                }
445                else
446                {
447                        mHierarchyInterface->DeleteQueries();
448                        mDestRenderSystem->setConfigOption("ArbQueries", "No");
449                }
450        }
451
452        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
453                setOption(key, val) || OctreeSceneManager::setOption(key, val);
454}
455//-----------------------------------------------------------------------
456bool VisibilityOctreeSceneManager::getOption(const String & key, void *val)
457{
458        if (key == "NumHierarchyNodes")
459        {
460                * static_cast<unsigned int *>(val) = (unsigned int)mNumOctants;
461                return true;
462        }
463
464        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
465                getOption(key, val) && OctreeSceneManager::getOption(key, val);
466}
467//-----------------------------------------------------------------------
468bool VisibilityOctreeSceneManager::getOptionValues(const String & key, StringVector  &refValueList)
469{
470        return OctreeSceneManager::getOptionValues( key, refValueList );
471}
472//-----------------------------------------------------------------------
473bool VisibilityOctreeSceneManager::getOptionKeys(StringVector & refKeys)
474{
475        return  VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
476                getOptionKeys (refKeys) || OctreeSceneManager::getOptionKeys(refKeys);
477}
478//-----------------------------------------------------------------------
479void VisibilityOctreeSceneManager::setVisibilityManager(GtpVisibility::VisibilityManager *visManager)
480{
481    mVisibilityManager = visManager;
482}
483//-----------------------------------------------------------------------
484GtpVisibility::VisibilityManager *VisibilityOctreeSceneManager::getVisibilityManager()
485{
486        return mVisibilityManager;
487}
488//-----------------------------------------------------------------------
489void VisibilityOctreeSceneManager::WriteLog()
490{
491        std::stringstream d;
492
493        d << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", "
494          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", "
495          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", "
496          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << "\n"
497          << "Hierarchy nodes: " << mNumOctants << ", "
498          << "Traversed nodes: " << mHierarchyInterface->GetNumTraversedNodes() << ", "
499          << "Rendered nodes: " << mHierarchyInterface->GetNumRenderedNodes() << ", "
500          << "Query culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumQueryCulledNodes() << ", "
501          << "Frustum culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumFrustumCulledNodes() << ", "
502      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << "\n";
503          /*<< "avg. FPS: " << mCurrentViewport->getTarget()->getAverageFPS() << ", "
504          << "best FPS: " << mCurrentViewport->getTarget()->getBestFPS() << ", "
505          << "worst FPS: " << mCurrentViewport->getTarget()->getWorstFPS() << ", "
506          << "best frame time: " <<     mCurrentViewport->getTarget()->getBestFrameTime() << ", "
507          << "worst frame time: " << mCurrentViewport->getTarget()->getWorstFrameTime() << "\n";*/
508
509        LogManager::getSingleton().logMessage(d.str());
510}
511//-----------------------------------------------------------------------
512void VisibilityOctreeSceneManager::renderObjects(
513        const RenderPriorityGroup::TransparentRenderablePassList& objs,
514            bool doLightIteration, const LightList* manualLightList)
515{
516        // for correct rendering, transparents must be rendered after hierarchical culling
517        if (!mSkipTransparents)
518        {
519                OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList);
520        }
521}
522//-----------------------------------------------------------------------
523bool VisibilityOctreeSceneManager::validatePassForRendering(Pass* pass)
524{
525        // skip all but first pass if we are doing the depth pass
526        if ((mIsDepthPassPhase || mIsItemBufferPhase) && pass->getIndex() > 0)
527        {
528                return false;
529        }
530        return SceneManager::validatePassForRendering(pass);
531}
532//-----------------------------------------------------------------------
533void VisibilityOctreeSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup)
534{
535        if (!mIsItemBufferPhase)
536        {
537                OctreeSceneManager::renderQueueGroupObjects(pGroup);
538                return;
539        }
540
541        //-- renders item buffer
542
543    // Iterate through priorities
544    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
545
546        while (groupIt.hasMoreElements())
547    {
548                RenderItemBuffer(groupIt.getNext());
549        }
550}
551//-----------------------------------------------------------------------
552void VisibilityOctreeSceneManager::RenderItemBuffer(RenderPriorityGroup* pGroup)
553{
554        // Do solids
555        RenderPriorityGroup::SolidRenderablePassMap solidObjs = pGroup->_getSolidPasses();
556
557        // ----- SOLIDS LOOP -----
558        RenderPriorityGroup::SolidRenderablePassMap::const_iterator ipass, ipassend;
559        ipassend = solidObjs.end();
560
561        for (ipass = solidObjs.begin(); ipass != ipassend; ++ipass)
562        {
563                // Fast bypass if this group is now empty
564                if (ipass->second->empty())
565                        continue;
566
567                // Render only first pass
568                if (ipass->first->getIndex() > 0)
569                        continue;
570
571                RenderPriorityGroup::RenderableList* rendList = ipass->second;
572               
573                RenderPriorityGroup::RenderableList::const_iterator irend, irendend;
574                irendend = rendList->end();
575                       
576                for (irend = rendList->begin(); irend != irendend; ++irend)
577                {
578                        std::stringstream d; d << "itembuffer, pass name: " <<
579                                ipass->first->getParent()->getParent()->getName();
580                               
581                        LogManager::getSingleton().logMessage(d.str());
582                       
583                        RenderSingleObjectForItemBuffer(*irend, ipass->first);
584                }
585        }
586
587        //-- TRANSPARENT LOOP: must be handled differently
588
589        // transparents are treated either as solids or completely discarded
590        if (mRenderTransparentsForItemBuffer)
591        {
592                RenderPriorityGroup::TransparentRenderablePassList transpObjs =
593                        pGroup->_getTransparentPasses();
594                RenderPriorityGroup::TransparentRenderablePassList::const_iterator
595                        itrans, itransend;
596
597                itransend = transpObjs.end();
598                for (itrans = transpObjs.begin(); itrans != itransend; ++itrans)
599                {
600                        // like for solids, render only first pass
601                        if (itrans->pass->getIndex() == 0)
602                        {       
603                                RenderSingleObjectForItemBuffer(itrans->renderable, itrans->pass);
604                        }
605                }
606        }
607}
608//-----------------------------------------------------------------------
609void VisibilityOctreeSceneManager::RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass)
610{
611        static LightList nullLightList;
612       
613        int col[4];
614       
615        // -- create color code out of object id
616        col[0] = (rend->getId() >> 16) & 255;
617        col[1] = (rend->getId() >> 8) & 255;
618        col[2] = rend->getId() & 255;
619//      col[3] = 255;
620
621        //mDestRenderSystem->setColour(col[0], col[1], col[2], col[3]);
622   
623        mItemBufferPass->setAmbient(ColourValue(col[0] / 255.0f,
624                                                                                    col[1] / 255.0f,
625                                                                                        col[2] / 255.0f, 1));
626
627        // set vertex program of current pass
628        if (mExecuteVertexProgramForAllPasses && pass->hasVertexProgram())
629        {
630                mItemBufferPass->setVertexProgram(pass->getVertexProgramName());
631
632                if (mItemBufferPass->hasVertexProgram())
633                {
634                        const GpuProgramPtr& prg = mItemBufferPass->getVertexProgram();
635                        // Load this program if not done already
636                        if (!prg->isLoaded())
637                                prg->load();
638                        // Copy params
639                        mItemBufferPass->setVertexProgramParameters(pass->getVertexProgramParameters());
640                }
641        }
642        else if (mItemBufferPass->hasVertexProgram())
643        {
644                mItemBufferPass->setVertexProgram("");
645        }
646
647        Pass *usedPass = setPass(mItemBufferPass);
648
649
650        // Render a single object, this will set up auto params if required
651        renderSingleObject(rend, usedPass, false, &nullLightList);
652}
653//-----------------------------------------------------------------------
654GtpVisibility::VisibilityManager *VisibilityOctreeSceneManager::GetVisibilityManager()
655{
656        return mVisibilityManager;
657}
658//-----------------------------------------------------------------------
659void VisibilityOctreeSceneManager::InitVisibilityCulling(Camera *cam)
660{
661        // reset culling manager stats
662        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes);
663
664        // set depth pass flag before rendering
665        mIsDepthPassPhase = mUseDepthPass;
666
667        mIsHierarchicalCulling = true; // during hierarchical culling
668
669        // item buffer needs full ambient lighting to use item colors as unique id
670        if (mUseItemBuffer)
671        {
672                mIsItemBufferPhase = true;
673                setAmbientLight(ColourValue(1,1,1,1));
674        }
675
676
677        // set passes which are stored in render queue
678        // for rendering AFTER hierarchical culling, i.e., passes which need
679        // a special rendering order
680       
681        mLeavePassesInQueue = 0;
682
683        if (0 && !mUseDepthPass && !mUseItemBuffer)
684        {
685                if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
686                {
687                        // TODO: remove this pass because it should be processed during hierarchical culling
688                        //mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW;
689
690                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DECAL;
691                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DIFFUSE_SPECULAR;
692                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
693
694                        // just render ambient passes
695                        mIlluminationStage = IRS_AMBIENT;
696                        getRenderQueue()->setSplitPassesByLightingType(true);
697                }
698       
699                if (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE)
700                {
701                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW;
702                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
703                }
704       
705                // transparents should be rendered after hierarchical culling to
706                // provide front-to-back ordering
707                if (mDelayRenderTransparents)
708                {
709                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES;
710                }
711        }
712
713        // skip rendering transparents in the hierarchical culling
714        // (because they will be rendered afterwards)
715        mSkipTransparents = mUseDepthPass ||
716                (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES);
717
718        // -- initialise interface for rendering traversal of the hierarchy
719        mHierarchyInterface->SetHierarchyRoot(mOctree);
720       
721        // possible two cameras (one for culling, one for rendering)
722        mHierarchyInterface->InitTraversal(mCameraInProgress,
723                                                        mCullCamera ? getCamera("CullCamera") : NULL,
724                                                        mLeavePassesInQueue);
725               
726        std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;
727        LogManager::getSingleton().logMessage(d.str());
728}
729//-----------------------------------------------------------------------
730OctreeHierarchyInterface *VisibilityOctreeSceneManager::GetHierarchyInterface()
731{
732        return mHierarchyInterface;
733}
734//-----------------------------------------------------------------------
735void VisibilityOctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
736{
737        // only render solid passes during hierarchical culling
738        if (mIsHierarchicalCulling)
739        {
740                RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
741            LightList lightList;
742
743                while (groupIt.hasMoreElements())
744                {
745                        RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
746
747                        // Sort the queue first
748                        pPriorityGrp->sort(mCameraInProgress);
749
750                        // Clear light list
751                        lightList.clear();
752
753                        // Render all the ambient passes first, no light iteration, no lights
754                        mIlluminationStage = IRS_AMBIENT;
755
756                        OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), false, &lightList);
757                        // Also render any objects which have receive shadows disabled
758                        OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPassesNoShadow(), true);
759               
760                        /*std::stringstream d;
761                        d << " solid size: " << (int)pPriorityGrp->_getSolidPasses().size()
762                                << " solid no shadow size: " << (int)pPriorityGrp->_getSolidPassesNoShadow().size()
763                                << "difspec size: " << (int)pPriorityGrp->_getSolidPassesDiffuseSpecular().size()
764                                << " decal size: " << (int)pPriorityGrp->_getSolidPassesDecal().size();
765                        LogManager::getSingleton().logMessage(d.str());*/
766                }
767        }
768        else // render the rest of the passes
769        {
770                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup);
771        }
772}
773//-----------------------------------------------------------------------
774void VisibilityOctreeSceneManager::renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup)
775{
776   if (mIsHierarchicalCulling)
777   {
778           // Iterate through priorities
779           RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
780
781           while (groupIt.hasMoreElements())
782           {
783                   RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
784
785                   // Sort the queue first
786                   pPriorityGrp->sort(mCameraInProgress);
787
788                   // Do (shadowable) solids
789                   OctreeSceneManager::renderObjects(pPriorityGrp->_getSolidPasses(), true);
790           }
791   }
792   else
793   {
794           SceneManager::renderModulativeStencilShadowedQueueGroupObjects(pGroup);
795   }
796}
797//-------------------------------------------------------------------------
798void VisibilityOctreeSceneManager::loadVisibilityConfig(const String& filename)
799{
800        /// Set up the options
801        ConfigFile config;
802        String val;
803
804        config.load(filename);
805
806        val = config.getSetting("Algorithm");
807
808    if (!val.empty())
809        {
810                 VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).setOption("Algorithm", val.c_str());
811        }
812
813        val = config.getSetting("UseDepthPass");
814
815        if (!val.empty())
816        {
817                 setOption("UseDepthPass", val.c_str());
818        }
819}
820}  // namespace Ogre
Note: See TracBrowser for help on using the repository browser.