Ignore:
Timestamp:
04/30/06 15:31:04 (19 years ago)
Author:
mattausch
Message:

fixed uint bug

Location:
GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreVisibilityOctreeSceneManager.h

    r863 r865  
    99 
    1010#include "OgreOctreeHierarchyInterface.h" 
     11#include "OgrePlatformQueryManager.h" 
    1112#include "VisibilityManager.h" 
    1213 
    … …  
    6768        */ 
    6869        bool validatePassForRendering(Pass* pass); 
    69  
     70        /** This function renders renderables using false color ids. 
     71        */ 
    7072        void RenderItemBuffer(RenderPriorityGroup* pGroup); 
     73        /** Renders a single object using false color id. 
     74        */ 
    7175        void RenderSingleObjectForItemBuffer(Renderable *rend, Pass *pass); 
     76        /** Overritten from scene manager to include the false color id rendering of the 
     77                scene objects. 
     78        */ 
    7279        void renderQueueGroupObjects(RenderQueueGroup* pGroup); 
    7380 
    7481        /** Override from SceneManager so that sub entities can be assigned an id for item buffer. 
    7582        */ 
    76         //Entity* createEntity(const String& entityName, const String& meshName); 
     83        Entity* createEntity(const String& entityName, const String& meshName); 
    7784 
    7885        /** Returns pointer to visibility manager. 
    … …  
    8592 
    8693        void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup); 
     94        /** Override this because we must handle shadows differently. 
     95        */ 
    8796        void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup); 
    8897 
    … …  
    122131        bool mRenderNodesContentForViz; 
    123132 
    124         /// render transparents after the hierarchical traversal 
     133        /// if we render transparents after the hierarchical traversal 
    125134        bool mDelayRenderTransparents; 
    126135 
    127         /// use a depth pass (i.e., fill only the depth buffer in the first pass) 
     136        /// if we use a depth pass (i.e., fill only the depth buffer in the first pass) 
    128137        bool mUseDepthPass; 
    129         /// flag indicating if we currently render the depth pass 
     138        /// if we currently rendering the depth pass 
    130139        bool mIsDepthPassPhase; 
    131140 
    … …  
    155164 
    156165        bool mIsHierarchicalCulling; 
     166 
     167        std::ofstream mDummyLog; 
    157168}; 
    158169 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreVisibilityTerrainSceneManager.h

    r726 r865  
    1111#include "OgrePlatformQueryManager.h" 
    1212#include "VisibilityManager.h" 
     13 
    1314 
    1415namespace Ogre { 
    … …  
    5556        virtual void renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs,  
    5657            bool doLightIteration, const LightList* manualLightList = 0); 
     58 
    5759        /** Writes out stats into the Ogre log file. 
    5860        */ 
    5961        void WriteLog(); 
    6062 
    61         /** We override this because we want to include the z-fail pass.  
     63        /** Override pass so we can do the z-fail pass.  
    6264        */ 
    6365        Pass* setPass(Pass* pass); 
     66 
    6467        /** Override from SceneManager so we can skip all but first pass for depth pass.  
    6568        */ 
    … …  
    114117        void InitVisibilityCulling(Camera *cam); 
    115118 
     119 
     120 
    116121        /// the interface to the scene hierarchy. 
    117122        OctreeHierarchyInterface *mHierarchyInterface; 
    … …  
    156161        int mLeavePassesInQueue; 
    157162 
     163 
    158164        /// if transparent object are considered for item buffer visibility 
    159165        bool mRenderTransparentsForItemBuffer; 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

    r863 r865  
    752752                                                                           mLeavePassesInQueue); 
    753753                 
    754         std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue; 
    755         LogManager::getSingleton().logMessage(d.str()); 
    756754} 
    757755//----------------------------------------------------------------------- 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityOctreeSceneManager.cpp

    r726 r865  
    1111#include <OgreConfigFile.h> 
    1212 
     13// normal terrain rendering 
     14const static NORMAL_RENDER_HACK = false; 
     15 
    1316namespace Ogre { 
    1417 
    1518//----------------------------------------------------------------------- 
    1619VisibilityOctreeSceneManager::VisibilityOctreeSceneManager( 
    17         GtpVisibility::VisibilityManager *visManager) 
    18 :  
     20        GtpVisibility::VisibilityManager *visManager): 
     21OctreeSceneManager(), 
    1922mVisibilityManager(visManager),  
    2023mShowVisualization(false), 
    … …  
    3740        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    3841                 
    39         //mDisplayNodes = true; 
    40         //mShowBoundingBoxes = true; 
    41         //mShowBoxes = true; 
     42        if (0) 
     43        { 
     44                mDisplayNodes = true; 
     45                mShowBoundingBoxes = true; 
     46                mShowBoxes = true; 
     47        } 
    4248 
    4349        // TODO: set maxdepth to reasonable value 
    … …  
    112118        // ignore 
    113119    } 
     120        // add bounding boxes of rendered objects 
    114121        for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) 
    115122{ 
    116123                getRenderQueue()->addRenderable(*it); 
    117124        } 
     125         
    118126        if (mRenderNodesForViz || mRenderNodesContentForViz) 
    119127        { 
    120                 // change node material so it is better suited for visualization 
     128                // HACK: change node material so it is better suited for visualization 
    121129                MaterialPtr nodeMat = MaterialManager::getSingleton().getByName("Core/NodeMaterial"); 
    122130                nodeMat->setAmbient(1, 1, 0); 
    … …  
    128136                        if (mRenderNodesForViz) 
    129137                        { 
    130                                 if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) 
    131                                         && (*it)->getAttachedObject(0)->getMovableType() == "Entity") 
     138                                // render the leaf nodes 
     139                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) &&  
     140                                         (*it)->getAttachedObject(0)->getMovableType() == "Entity") 
     141                                { 
    132142                                getRenderQueue()->addRenderable((*it)); 
     143                                } 
    133144 
    134145                                // addbounding boxes instead of node itself 
    … …  
    145156Pass *VisibilityOctreeSceneManager::setPass(Pass* pass) 
    146157{ 
     158        if (NORMAL_RENDER_HACK) 
     159        { 
     160                return SceneManager::setPass(pass); 
     161        } 
     162 
     163        // TODO: setting vertex program is not efficient 
     164        //Pass *usedPass = ((mIsDepthPassPhase && !pass->hasVertexProgram()) ? mDepthPass : pass);  
     165         
    147166        // set depth fill pass if we currently do not make an aabb occlusion query 
    148         Pass *usedPass = (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery() ?  
    149                                           mDepthPass : pass); 
     167        const bool useDepthPass =  
     168                (mIsDepthPassPhase && !mHierarchyInterface->IsBoundingBoxQuery()); 
     169 
     170        Pass *usedPass = useDepthPass ? mDepthPass : pass; 
    150171 
    151172        IlluminationRenderStage savedStage = mIlluminationStage;  
    … …  
    158179        } 
    159180 
    160         //-- set vertex program of current pass in order to set correct depth 
    161         if (mIsDepthPassPhase && mExecuteVertexProgramForAllPasses && pass->hasVertexProgram()) 
     181        // --- set vertex program of current pass in order to set correct depth 
     182        if (mExecuteVertexProgramForAllPasses &&  
     183                mIsDepthPassPhase &&  
     184                pass->hasVertexProgram()) 
    162185    { 
    163186                // add vertex program of current pass to depth pass 
    … …  
    174197                } 
    175198        } 
    176         else if (mDepthPass->hasVertexProgram()) 
     199        else if (mDepthPass->hasVertexProgram()) // reset vertex program 
    177200        { 
    178201                mDepthPass->setVertexProgram(""); 
    179202        } 
    180203 
    181         // store depth write flag to reset later 
    182         bool IsDepthWrite = usedPass->getDepthWriteEnabled(); 
     204        // save old depth write: needed for item buffer 
     205        const bool IsDepthWrite = usedPass->getDepthWriteEnabled(); 
    183206 
    184207        // global option which enables / disables depth writes 
    … …  
    187210                usedPass->setDepthWriteEnabled(false); 
    188211        } 
    189         //else if (mIsItemBufferPass) {usedPass = mItemBufferPass;} 
    190  
     212 
     213 
     214        //-- set actual pass here 
    191215        Pass *result = SceneManager::setPass(usedPass); 
     216 
    192217 
    193218        // reset depth write 
    … …  
    205230void VisibilityOctreeSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters) 
    206231{ 
     232        if (NORMAL_RENDER_HACK) 
     233        { 
     234                OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
     235                return; 
     236        } 
     237 
    207238        //-- show visible scene nodes and octree bounding boxes from last frame 
    208239        if (mShowVisualization) 
    … …  
    223254                } 
    224255                // only shadow casters will be rendered in shadow texture pass 
    225                 // mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
     256                if (0) mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
    226257        } 
    227258         
    … …  
    234265void VisibilityOctreeSceneManager::_renderVisibleObjects() 
    235266{ 
    236          
    237                 //InitVisibilityCulling(mCameraInProgress); 
    238                 //mVisibilityManager->ApplyVisibilityCulling(); 
    239  
    240                 if(1){ 
     267        if (NORMAL_RENDER_HACK) 
     268        { 
     269                OctreeSceneManager::_renderVisibleObjects(); 
     270 
     271                return; 
     272        } 
     273 
    241274        InitDepthPass();          // create material for depth pass 
    242275        InitItemBufferPass(); // create material for item buffer pass 
    … …  
    266299        else //-- the hierarchical culling algorithm 
    267300        {        
     301                // this is also called in TerrainSceneManager: really 
     302                // nexessary? 
     303                mDestRenderSystem -> setLightingEnabled(false); 
     304 
    268305                // don't render backgrounds for item buffer 
    269306                if (mUseItemBuffer) 
    … …  
    284321 
    285322                OctreeSceneManager::_renderVisibleObjects(); 
    286  
     323                ///////////////////////////////////////////////// 
    287324 
    288325#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    297334                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    298335         
     336                // exclude this queues from hierarchical rendering 
     337                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    299338 
    300339                // set all necessary parameters for  
    … …  
    311350                mVisibilityManager->ApplyVisibilityCulling(); 
    312351         
    313                 // delete remaining renderables from queue (all not in mLeavePassesInQueue) 
     352                // delete remaining renderables from queue: 
     353                // all which are not in mLeavePassesInQueue) 
    314354#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    315355                _deleteRenderedQueueGroups(mLeavePassesInQueue); 
    … …  
    324364                mLeavePassesInQueue = 0; 
    325365 
     366#if 1    
    326367                // add visible nodes found by the visibility culling algorithm 
    327368                if (mUseDepthPass) 
    328369                { 
    329                         for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it) 
     370                        NodeList::const_iterator it, it_end = mVisible.end(); 
     371 
     372                        //getRenderQueue()->clear(); 
     373                        for (it = mVisible.begin(); it != it_end; ++ it) 
    330374                        { 
    331375                                (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false); 
    332376                        } 
    333377                } 
    334          
    335                 //-- we render all remaining queue objects 
    336                 // used for depth pass, transparents, overlay  
     378#endif   
     379                //-- now we can render all remaining queue objects 
     380                //-- used for depth pass, transparents, overlay 
    337381                clearSpecialCaseRenderQueues(); 
     382 
    338383                OctreeSceneManager::_renderVisibleObjects(); 
    339384         
    340         }   // hierarchical culling 
     385        } // hierarchical culling 
    341386 
    342387        // reset ambient light 
    343388        setAmbientLight(savedAmbient); 
    344 }        
     389 
    345390        getRenderQueue()->clear(); // finally clear render queue 
    346         OGRE_DELETE(mRenderQueue); // HACK: should be cleared before... 
    347         //WriteLog(); // write out stats 
    348  
     391        if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ... 
     392 
     393        if (0) WriteLog(); // write out stats 
    349394} 
    350395 
    … …  
    352397void VisibilityOctreeSceneManager::_updateSceneGraph(Camera* cam) 
    353398{ 
     399        if (NORMAL_RENDER_HACK) 
     400        { 
     401                OctreeSceneManager::_updateSceneGraph(cam); 
     402                return; 
     403        } 
     404 
    354405        mVisibilityManager->GetCullingManager()->SetHierarchyInterface(mHierarchyInterface); 
    355406        mHierarchyInterface->SetRenderSystem(mDestRenderSystem); 
    … …  
    431482                return true; 
    432483        } 
     484 
    433485        if (key == "UseArbQueries") 
    434486        { 
    … …  
    491543          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", " 
    492544          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", " 
    493           << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << "\n" 
     545          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", " 
    494546          << "Hierarchy nodes: " << mNumOctants << ", "  
    495547          << "Traversed nodes: " << mHierarchyInterface->GetNumTraversedNodes() << ", " 
    … …  
    497549          << "Query culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumQueryCulledNodes() << ", " 
    498550          << "Frustum culled nodes: " << mVisibilityManager->GetCullingManager()->GetNumFrustumCulledNodes() << ", " 
    499       << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << "\n"; 
    500           /*<< "avg. FPS: " << mCurrentViewport->getTarget()->getAverageFPS() << ", " 
    501           << "best FPS: " << mCurrentViewport->getTarget()->getBestFPS() << ", " 
    502           << "worst FPS: " << mCurrentViewport->getTarget()->getWorstFPS() << ", " 
    503           << "best frame time: " <<     mCurrentViewport->getTarget()->getBestFrameTime() << ", " 
    504           << "worst frame time: " << mCurrentViewport->getTarget()->getWorstFrameTime() << "\n";*/ 
     551      << "Queries issued: " << mVisibilityManager->GetCullingManager()->GetNumQueriesIssued() << ", " 
     552          << "Found objects: " << (int)mVisible.size() << "\n"; 
    505553 
    506554        LogManager::getSingleton().logMessage(d.str()); 
    … …  
    512560{ 
    513561        // for correct rendering, transparents must be rendered after hierarchical culling 
    514         if (!mSkipTransparents) 
    515         { 
    516                 OctreeSceneManager::renderObjects(objs, doLightIteration, manualLightList); 
     562        // => do nothing 
     563        if (NORMAL_RENDER_HACK || !mSkipTransparents) 
     564        { 
     565                SceneManager::renderObjects(objs, doLightIteration, manualLightList); 
    517566        } 
    518567} 
    … …  
    520569bool VisibilityOctreeSceneManager::validatePassForRendering(Pass* pass) 
    521570{ 
     571        if (NORMAL_RENDER_HACK) 
     572        { 
     573                return SceneManager::validatePassForRendering(pass); 
     574        } 
     575 
    522576        // skip all but first pass if we are doing the depth pass 
    523         if ((mIsDepthPassPhase || mIsItemBufferPhase) && pass->getIndex() > 0) 
     577        if ((mIsDepthPassPhase || mIsItemBufferPhase) && (pass->getIndex() > 0)) 
    524578        { 
    525579                return false; 
    526580        } 
     581        // all but first pass 
     582        /*else if ((!mIsDepthPassPhase || mIsItemBufferPhase) && (pass->getIndex() != 0)) 
     583        { 
     584                return false; 
     585        }*/ 
     586 
    527587        return SceneManager::validatePassForRendering(pass); 
    528588} 
    … …  
    530590void VisibilityOctreeSceneManager::renderQueueGroupObjects(RenderQueueGroup* pGroup) 
    531591{ 
    532         if (!mIsItemBufferPhase) 
     592        if (NORMAL_RENDER_HACK || !mIsItemBufferPhase) 
    533593        { 
    534594                OctreeSceneManager::renderQueueGroupObjects(pGroup); 
    … …  
    536596        } 
    537597 
    538         //-- renders item buffer 
     598        //-- item buffer: render objects using false colors 
    539599 
    540600    // Iterate through priorities 
    … …  
    562622                        continue; 
    563623 
    564                 // Render only first pass 
     624                // Render only first pass of renderable as false color 
    565625                if (ipass->first->getIndex() > 0) 
    566626                        continue; 
    … …  
    573633                for (irend = rendList->begin(); irend != irendend; ++irend) 
    574634                { 
     635                        if (0) 
     636                        { 
    575637                        std::stringstream d; d << "itembuffer, pass name: " <<  
    576638                                ipass->first->getParent()->getParent()->getName(); 
    577639                                 
    578640                        LogManager::getSingleton().logMessage(d.str()); 
     641                        } 
    579642                         
    580643                        RenderSingleObjectForItemBuffer(*irend, ipass->first); 
    … …  
    582645        } 
    583646 
    584         //-- TRANSPARENT LOOP: must be handled differently  
     647        //-- TRANSPARENT LOOP: must be handled differently from solids 
    585648 
    586649        // transparents are treated either as solids or completely discarded 
    … …  
    645708 
    646709 
    647         // Render a single object, this will set up auto params if required 
     710        // render a single object, this will set up auto params if required 
    648711        renderSingleObject(rend, usedPass, false, &nullLightList); 
    649712} 
    … …  
    678741        mLeavePassesInQueue = 0; 
    679742 
    680         if (0 && !mUseDepthPass && !mUseItemBuffer) 
     743        if (!mUseDepthPass && !mUseItemBuffer) 
    681744        { 
    682745                if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE) 
    … …  
    689752                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES; 
    690753 
    691                         // just render ambient passes 
     754                        // just render ambient stuff 
    692755                        mIlluminationStage = IRS_AMBIENT; 
    693756                        getRenderQueue()->setSplitPassesByLightingType(true); 
    … …  
    708771        } 
    709772 
    710         // skip rendering transparents in the hierarchical culling 
     773        // skip rendering transparents during the hierarchical culling 
    711774        // (because they will be rendered afterwards) 
    712         mSkipTransparents = mUseDepthPass ||  
    713                 (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES); 
     775        mSkipTransparents =  
     776                (mIsDepthPassPhase || (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES)); 
    714777 
    715778        // -- initialise interface for rendering traversal of the hierarchy 
    … …  
    721784                                                        mLeavePassesInQueue); 
    722785                 
    723         std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue; 
    724         LogManager::getSingleton().logMessage(d.str()); 
    725786} 
    726787//----------------------------------------------------------------------- 
    … …  
    730791} 
    731792//----------------------------------------------------------------------- 
    732 void VisibilityOctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup) 
     793Entity* VisibilityOctreeSceneManager::createEntity(const String& entityName,  
     794                                                                                                        const String& meshName) 
     795{ 
     796        Entity *ent = SceneManager::createEntity(entityName, meshName); 
     797 
     798        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i) 
     799        { 
     800                ent->getSubEntity(i)->setId(mCurrentEntityId); 
     801        } 
     802 
     803        // increase counter of entity id values 
     804        ++ mCurrentEntityId; 
     805 
     806        return ent; 
     807} 
     808//----------------------------------------------------------------------- 
     809void VisibilityOctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects( 
     810        RenderQueueGroup* pGroup) 
    733811{ 
    734812        // only render solid passes during hierarchical culling 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityTerrainSceneManager.cpp

    r726 r865  
    99#include <OgreEntity.h> 
    1010#include <OgreSubEntity.h> 
    11  
     11#include <OgreConfigFile.h> 
    1212 
    1313// normal terrain rendering 
    … …  
    6262 
    6363        mDepthPass = depthMat->getTechnique(0)->getPass(0); 
    64  
    6564                mDepthPass->setColourWriteEnabled(false); 
    6665                mDepthPass->setDepthWriteEnabled(true); 
    6766                mDepthPass->setLightingEnabled(false); 
    68                 //mDepthPass->setDepthCheckEnabled(true); 
    6967        } 
    7068        else 
    … …  
    290288         
    291289                if (mShowVisualization)  
     290                { 
    292291                        // disable illumination stage to prevent rendering shadows 
    293292                        mIlluminationStage = IRS_NONE; 
     293                } 
    294294 
    295295                // standard rendering for shadow maps because of performance 
    … …  
    300300        else //-- the hierarchical culling algorithm 
    301301        {  
    302                 // from TerrainSceneManager 
     302                // this is also called in TerrainSceneManager: really 
     303                // nexessary? 
    303304                mDestRenderSystem -> setLightingEnabled(false); 
    304305 
    … …  
    379380         
    380381                OctreeSceneManager::_renderVisibleObjects(); 
    381         } 
     382        } // hierarchical culling 
    382383                 
    383384        // HACK: set the new render level index, important to avoid cracks 
    … …  
    389390 
    390391        getRenderQueue()->clear(); // finally clear render queue 
    391         if (0) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ... 
     392        if (1) OGRE_DELETE(mRenderQueue); // HACK: should rather only be cleared ... 
    392393 
    393394        if (0) WriteLog(); // write out stats 
    … …  
    594595        if (NORMAL_RENDER_HACK || !mIsItemBufferPhase) 
    595596        { 
    596                 SceneManager::renderQueueGroupObjects(pGroup); 
     597                OctreeSceneManager::renderQueueGroupObjects(pGroup); 
    597598                return; 
    598599        } 
    … …  
    639640                                std::stringstream d; d << "itembuffer, pass name: " <<  
    640641                                ipass->first->getParent()->getParent()->getName(); 
     642                                 
    641643                                LogManager::getSingleton().logMessage(d.str()); 
    642644                        } 
    … …  
    726728        mIsDepthPassPhase = mUseDepthPass; 
    727729 
     730        mIsHierarchicalCulling = true; // during hierarchical culling 
     731 
    728732        // item buffer needs full ambient lighting to use item colors as unique id 
    729733        if (mUseItemBuffer)  
    … …  
    737741        // for rendering AFTER hierarchical culling, i.e., passes which need  
    738742        // a special rendering order 
     743         
    739744        mLeavePassesInQueue = 0; 
    740745 
    … …  
    752757                        // just render ambient stuff 
    753758                        mIlluminationStage = IRS_AMBIENT; 
     759                        getRenderQueue()->setSplitPassesByLightingType(true); 
    754760                } 
    755761         
    … …  
    837843                } 
    838844        } 
    839         else 
     845        else // render the rest of the passes 
    840846        { 
    841847                OctreeSceneManager::renderAdditiveStencilShadowedQueueGroupObjects(pGroup); 
Note: See TracChangeset for help on using the changeset viewer.