Changeset 139


Ignore:
Timestamp:
06/20/05 08:13:57 (20 years ago)
Author:
mattausch
Message:

fixed bug with tight octree boxes
added more flexible renderqueue (can delete per flag)
reordered functions in visibility terrain scene manager

Location:
trunk/VUT
Files:
1 added
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibility/src/CoherentHierarchicalCullingManager.cpp

    r130 r139  
    77void CoherentHierarchicalCullingManager::RenderScene() 
    88{ 
    9         //InitFrame(); 
    109        QueryQueue queryQueue; 
    1110        unsigned int visiblePixels = 0; 

  • trunk/VUT/GtpVisibility/src/FrustumCullingManager.cpp

    r115 r139  
    77void FrustumCullingManager::RenderScene() 
    88{ 
    9         //InitFrame(); 
    10  
    119        while (!mHierarchyInterface->GetQueue()->empty()) 
    1210        { 

  • trunk/VUT/GtpVisibility/src/StopAndWaitCullingManager.cpp

    r115 r139  
    77void StopAndWaitCullingManager::RenderScene() 
    88{ 
    9         //InitFrame(); 
    10          
    119        while (!mHierarchyInterface->GetQueue()->empty()) 
    1210        { 
    … …  
    2119 
    2220                if (!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
    23                 {//if (mHierarchyInterface->mIsShadowPass) 
    24                         mNumFrustumCulledNodes ++; 
     21                { 
     22                        ++ mNumFrustumCulledNodes; 
     23                 
    2524                        if (mVisualizeCulledNodes) 
    2625                        { 
    … …  
    3837                        } 
    3938 
    40                         mNumQueriesIssued ++; 
     39                        ++ mNumQueriesIssued; 
    4140 
    4241                        unsigned int visiblePixels = 0; 
    … …  
    5049                        } 
    5150                        else 
    52                         {       //if (mHierarchyInterface->mIsShadowPass) 
    53                                 mNumQueryCulledNodes ++; 
     51                        {        
     52                                ++ mNumQueryCulledNodes; 
     53 
    5454                                if (mVisualizeCulledNodes) 
    5555                                { 

  • trunk/VUT/Ogre/include/OgrePlatformHierarchyInterface.h

    r130 r139  
    5353        */ 
    5454        void InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam, Camera *cullCam = NULL,  
    55                 bool leaveTransparentsInQueue = false); 
     55                int leavePassesInQueue = 0); 
    5656        /** Checks if the node is visible from the current view frustum. 
    5757                @param node the current node 
    … …  
    162162 
    163163        bool mOnlyShadowCasters; 
    164         bool mLeaveTransparentsInQueue; 
     164        int mLeavePassesInQueue; 
    165165        bool mIsBoundingBoxQuery; 
    166166}; 

  • trunk/VUT/Ogre/include/OgreVisibilityOctreeSceneManager.h

    r130 r139  
    6767         
    6868        /** Prepares visualization of hierarchical culling. */ 
    69         void ShowVisualization(Camera *cam); 
     69        void PrepareVisualization(Camera *cam); 
    7070        OctreeHierarchyInterface *mHierarchyInterface; 
    7171        GtpVisibility::VisibilityManager *mVisibilityManager; 

  • trunk/VUT/Ogre/include/OgreVisibilityTerrainSceneManager.h

    r133 r139  
    9090        /** Fills render queue so that a visualization can be rendered.  
    9191        */ 
    92         void ShowVisualization(Camera *cam); 
     92        void PrepareVisualization(Camera *cam); 
     93         
     94        void InitVisibilityCulling(Camera *cam); 
     95 
    9396 
    9497        OctreeHierarchyInterface *mHierarchyInterface; 
    … …  
    9699 
    97100        bool mShowVisualization; 
    98         bool mSkipTransparents; 
    99101        bool mVisualizeCulledNodes; 
    100102 
    … …  
    106108        bool mRenderItemBuffer; 
    107109        bool mEnableDepthWrite; 
     110        bool mSkipTransparents; 
    108111 
    109112        Pass *mDepthPass; 
    … …  
    113116 
    114117        PlatformQueryManager *mQueryManager; 
     118 
     119        int mLeavePassesInQueue; 
     120        ShadowTechnique mSavedShadowTechnique; 
    115121}; 
    116122 

  • trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

    r135 r139  
    1616void OctreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
    1717{ 
    18         mNumTraversedNodes ++; 
     18        ++ mNumTraversedNodes; 
    1919 
    2020        Octree *octree = static_cast<Octree *>(node); 
    … …  
    107107 
    108108                dynamic_cast<OctreeSceneManager *>(mSceneManager)->_renderOctant(mCamera,  
    109                         octant, mOnlyShadowCasters, mLeaveTransparentsInQueue); 
     109                        octant, mOnlyShadowCasters, mLeavePassesInQueue); 
    110110 
    111111                mRenderedNodes.push_back(node); 
    … …  
    134134AxisAlignedBox *OctreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node) 
    135135{ 
    136         if(node != mPreviousNode) 
     136        if (node != mPreviousNode)       
    137137        { 
    138138                mPreviousNode = node; 
    139         //      static_cast<Octree *>(node)->_getCullBounds(&mBox); 
     139            //static_cast<Octree *>(node)->_getCullBounds(&mBox); 
    140140                mBox = static_cast<Octree *>(node)->_getWorldAABB(); 
     141                //std::stringstream d; d << mBox;LogManager::getSingleton().logMessage(d.str());  
    141142        } 
    142143 

  • trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp

    r135 r139  
    1313PlatformHierarchyInterface::PlatformHierarchyInterface(SceneManager *sm, RenderSystem *rsys): 
    1414mSceneManager(sm), mRenderSystem(rsys), mSolidBoundingBox(NULL), mCamera(NULL),  
    15 mCullCamera(NULL), mOnlyShadowCasters(false), mLeaveTransparentsInQueue(false), 
     15mCullCamera(NULL), mOnlyShadowCasters(false), mLeavePassesInQueue(0), 
    1616mIsBoundingBoxQuery(false) 
    1717{ 
    … …  
    131131//----------------------------------------------------------------------- 
    132132void PlatformHierarchyInterface::InitFrame(GtpVisibility::HierarchyNode *root,  
    133                                                                                    Camera *cam, Camera *cullCam, bool leaveTransparentsInQueue) 
     133                                                                                   Camera *cam, Camera *cullCam, int leavePassesInQueue) 
    134134{ 
    135135        GtpVisibility::HierarchyInterface::InitFrame(root); 
    136136         
    137137        mPreviousNode = NULL; 
    138         mLeaveTransparentsInQueue = leaveTransparentsInQueue; 
     138        mLeavePassesInQueue = leavePassesInQueue; 
    139139 
    140140        mCamera = cam; 
    141141        mCullCamera = cullCam ? cullCam : cam; 
    142  
    143         //if (mCullCamera != mCamera) 
    144         //      LogManager::getSingleton().logMessage("cullcamera is not camera"); 
    145142 
    146143        // create materials for node visualization 
    … …  
    268265void PlatformHierarchyInterface::RenderGeometry(GtpVisibility::Mesh *geom) 
    269266{ 
    270         mSceneManager->_renderMovableObject(geom, mLeaveTransparentsInQueue); 
     267        mSceneManager->_renderMovableObject(geom, mLeavePassesInQueue); 
    271268} 
    272269//----------------------------------------------------------------------- 

  • trunk/VUT/Ogre/src/OgreSceneNodeHierarchyInterface.cpp

    r130 r139  
    1919void SceneNodeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
    2020{ 
    21         mNumTraversedNodes ++; 
     21        ++ mNumTraversedNodes; 
    2222         
    2323        SceneNode *sceneNode = static_cast<SceneNode *>(node); 
    … …  
    4747                mRenderedNodes.push_back(node); 
    4848 
    49                 mSceneManager->_renderSceneNode(mCamera, sceneNode, mLeaveTransparentsInQueue); 
     49                mSceneManager->_renderSceneNode(mCamera, sceneNode, mLeavePassesInQueue); 
    5050        } 
    5151#endif 
    … …  
    151151                { 
    152152                        Entity *ent = static_cast<Entity *>(movable); 
    153                         //std::stringstream d; d << "ent " << ent->getName();  
    154                         //LogManager::getSingleton().logMessage(d.str()); 
     153                        //std::stringstream d; d << "ent " << ent->getName(); LogManager::getSingleton().logMessage(d.str()); 
    155154                        geometryList->push_back(ent); 
    156155                } 

  • trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

    r122 r139  
    2121mRenderNodesContentForViz(false), 
    2222mVisualizeCulledNodes(false), 
    23 mSkipTransparents(false), 
    2423mDelayRenderTransparents(true), 
    25 mUseDepthPass(true) 
     24mUseDepthPass(true), 
     25mSkipTransparents(false) 
    2626{ 
    2727        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    … …  
    101101} 
    102102//----------------------------------------------------------------------- 
    103 void VisibilityOctreeSceneManager::ShowVisualization(Camera *cam) 
     103void VisibilityOctreeSceneManager::PrepareVisualization(Camera *cam) 
    104104{ 
    105105        // add player camera for visualization purpose 
    106         try { 
     106        try  
     107        { 
    107108                Camera *c; 
    108109                if ((c = getCamera("PlayerCam")) != NULL) 
    … …  
    129130                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it) 
    130131                { 
    131  
    132132                        if (mRenderNodesForViz) 
    133133                        { 
    … …  
    150150        if (mShowVisualization) 
    151151    { 
    152                 ShowVisualization(cam); 
     152                PrepareVisualization(cam); 
    153153        } 
    154154        else  
    … …  
    189189                                                        leaveTransparentsInQueue); 
    190190 
    191         // call initframe to reset culling manager stats 
     191        // reset culling manager stats 
    192192        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
    193193         
    … …  
    204204 
    205205#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    206         _deleteRenderedQueueGroups(false); 
     206        _deleteRenderedQueueGroups(); 
    207207#endif 
    208208 
    … …  
    272272                return true; 
    273273        } 
    274         if (key == "ShowVisualization") 
     274        if (key == "PrepareVisualization") 
    275275        { 
    276276                mShowVisualization = (*static_cast<const bool *>(val)); 

  • trunk/VUT/Ogre/src/OgreVisibilitySceneManager.cpp

    r115 r139  
    4343                mHierarchyInterface->InitFrame(mSceneRoot, mCameraInProgress); 
    4444 
    45                 // call initframe to reset culling manager stats 
     45                // reset culling manager stats 
    4646                mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
    4747        } 
    … …  
    6868 
    6969#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    70         _deleteRenderedQueueGroups(false); 
     70        _deleteRenderedQueueGroups(); 
    7171#endif 
    7272 
    … …  
    8484 
    8585#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    86         //_deleteRenderedQueueGroups(); 
     86        _deleteRenderedQueueGroups(); 
    8787#endif 
    8888 

  • trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

    r137 r139  
    2121mRenderNodesContentForViz(false), 
    2222mVisualizeCulledNodes(false), 
    23 mSkipTransparents(false), 
     23mLeavePassesInQueue(0), 
    2424mDelayRenderTransparents(true), 
    2525mUseDepthPass(false), 
    2626mRenderItemBuffer(false), 
    2727mCurrentEntityId(0), 
    28 mEnableDepthWrite(true) 
     28mEnableDepthWrite(true), 
     29mSkipTransparents(false), 
     30mSavedShadowTechnique(SHADOWTYPE_NONE) 
    2931{ 
    3032        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    … …  
    3234 
    3335        mVisibilityManager->SetQueryManager(mQueryManager); 
     36         
    3437        //mDisplayNodes = true; 
    3538        //mShowBoundingBoxes = true; 
    … …  
    97100} 
    98101//----------------------------------------------------------------------- 
    99 void VisibilityTerrainSceneManager::ShowVisualization(Camera *cam) 
     102void VisibilityTerrainSceneManager::PrepareVisualization(Camera *cam) 
    100103{ 
    101104        // add player camera for visualization purpose 
    … …  
    128131                        if (mRenderNodesForViz) 
    129132                        { 
    130                                 //getRenderQueue()->addRenderable(*it); 
     133                                OctreeNode *node = *it;  
     134                                if ((node->numAttachedObjects() > 0) && (node->numChildren() == 0) 
     135                                        && node->getAttachedObject(0)->getMovableType() == "Entity") 
     136                                getRenderQueue()->addRenderable(node); 
    131137 
    132138                                // addbounding boxes instead of node itself 
    133                                 (*it)->_addBoundingBoxToQueue(getRenderQueue()); 
     139                                //(*it)->_addBoundingBoxToQueue(getRenderQueue()); 
    134140                        } 
    135141                        if (mRenderNodesContentForViz)  
    … …  
    143149Pass *VisibilityTerrainSceneManager::setPass(Pass* pass) 
    144150{ 
    145         //Pass *usedPass = ((mRenderDepthPass && !pass->hasVertexProgram()) ? mDepthPass : pass); // setting vertex program is not efficient 
     151        // TODO: setting vertex program is not efficient 
     152        //Pass *usedPass = ((mRenderDepthPass && !pass->hasVertexProgram()) ? mDepthPass : pass);  
    146153         
    147154        // set depth fill pass only if depth write enabled 
    … …  
    182189 
    183190        bool IsDepthWrite = usedPass->getDepthWriteEnabled(); 
     191 
    184192        // global option which enables / disables depth writes 
    185193        if (!mEnableDepthWrite) 
    … …  
    187195                usedPass->setDepthWriteEnabled(false); 
    188196        } 
    189  
    190197        //else if (mIsItemBufferPass) {usedPass = mItemBufferPass;} 
    191198         
    … …  
    207214{ 
    208215        // needs full ambient lighting for item colors to be exact 
    209         /*if (mRenderItemBuffer) 
    210         {       setAmbientLight(ColourValue(1,1,1,1)); }*/ 
     216        //if (mRenderItemBuffer) {setAmbientLight(ColourValue(1,1,1,1));} 
    211217         
    212218        //-- show visible scene nodes and octree bounding boxes from last frame 
    213219        if (mShowVisualization) 
    214220    { 
    215                 ShowVisualization(cam); 
    216         } 
    217          
     221                PrepareVisualization(cam); 
     222        } 
     223        else 
     224        {        
     225                // we interleave identification and rendering of objects  
     226                // in _renderVisibibleObjects 
     227 
     228                // only shadow casters will be rendered in shadow texture pass 
     229                mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
     230                //InitVisibilityCulling(cam); 
     231        } 
    218232        //TerrainSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
    219233         
    220234        mVisible.clear(); 
    221235        mBoxes.clear(); 
    222          
    223         // if there is no depth pass => 
    224         // we interleave identification and rendering of objects  
    225         // in _renderVisibibleObjects 
    226  
    227         // only shadow casters will be rendered in shadow texture pass 
    228         mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
    229  
    230         bool leaveTransparentsInQueue = mDelayRenderTransparents && !mUseDepthPass; 
    231  
    232         // possible two cameras (one for culling, one for rendering) 
    233         mHierarchyInterface->InitFrame(mOctree, cam, //mCameraInProgress,  
    234                                                 mCullCamera ? getCamera("CullCamera") : NULL, 
    235                                                 leaveTransparentsInQueue); 
     236 
    236237} 
    237238//----------------------------------------------------------------------- 
    238239void VisibilityTerrainSceneManager::_renderVisibleObjects() 
    239240{ 
    240         // increase terrain renderlevel 
    241         int renderLevel = TerrainRenderable::getCurrentRenderLevelIndex() + 1; 
    242  
    243         if (TerrainRenderable::getCurrentRenderLevelIndex() >= 10) 
    244         {   // max. 10 different renderlevels 
    245                 renderLevel = 0; 
    246         } 
    247  
    248241        // visualization: apply standard rendering 
    249242        if (mShowVisualization) 
    250243        {        
     244                IlluminationRenderStage savedStage = mIlluminationStage;  
     245         
     246                // disable illumination stage so we have no shadow rendering 
     247                mIlluminationStage = IRS_NONE; 
     248         
    251249                TerrainSceneManager::_renderVisibleObjects(); 
    252                 TerrainRenderable::setCurrentRenderLevelIndex(renderLevel); 
    253                 return; 
    254         } 
    255  
    256         InitDepthPass();        // create material for depth pass 
    257         InitItemBufferPass(); // create material for item buffer pass 
    258  
    259         //-- hierarchical culling 
    260         // the objects of different layers (e.g., background, scene,  
    261         // overlay) must be identified and rendered one after another 
    262  
    263         // frame initialisation to reset culling manager stats 
    264         mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
    265          
    266         mSkipTransparents = false; 
    267  
    268         //-- render background, in case there is one 
    269         clearSpecialCaseRenderQueues(); 
    270         addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND); 
    271         addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY); 
    272         setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE); 
    273  
    274         TerrainSceneManager::_renderVisibleObjects(); 
     250        } 
     251        else 
     252        { 
     253                //-- hierarchical culling 
     254                // the objects of different layers (e.g., background, scene,  
     255                // overlay) must be identified and rendered one after another 
     256 
     257                //-- render all early skies 
     258                clearSpecialCaseRenderQueues(); 
     259                addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND); 
     260                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY); 
     261                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE); 
     262 
     263                TerrainSceneManager::_renderVisibleObjects(); 
    275264 
    276265#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    277         _deleteRenderedQueueGroups(false); 
     266                _deleteRenderedQueueGroups(); 
    278267#endif 
    279268 
    280         //-- render visible objects (i.e., all but overlay and skies late) 
    281         clearSpecialCaseRenderQueues(); 
    282         addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE); 
    283         addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY); 
    284         setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    285  
    286         // transparents are skipped from hierarchical rendering 
    287         // => they need sorting, thus we render them afterwards 
    288         mSkipTransparents = mDelayRenderTransparents; 
    289  
    290         // set state for depth pass 
    291     mRenderDepthPass = mUseDepthPass; 
    292          
    293         /**  
    294           * the hierarchical culling algorithm 
    295           * for depth pass: will just find objects and update depth buffer 
    296           * for delayed rendering: will render all but transparents 
    297         **/ 
    298          
    299         mVisibilityManager->ApplyVisibilityCulling(); 
    300  
    301         // delete remaining renderables from queue (or all but transparents) 
     269                //-- prepare queue for visible objects (i.e., all but overlay and skies late) 
     270                clearSpecialCaseRenderQueues(); 
     271                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_LATE); 
     272                addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY); 
     273                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
     274 
     275 
     276                //-- set all necessary parameters for hierarchical visibility culling and rendering 
     277                InitVisibilityCulling(mCameraInProgress); 
     278 
     279                /**  
     280                * the hierarchical culling algorithm 
     281                * if using depth pass: will just find objects and update depth buffer 
     282                * for "delayed" rendering: will render some passes afterwards, e.g. transparents 
     283                **/ 
     284                 
     285                mVisibilityManager->ApplyVisibilityCulling(); 
     286 
     287                // delete remaining renderables from queue (all not in mLeavePassesInQueue) 
    302288#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    303         _deleteRenderedQueueGroups(mSkipTransparents); 
     289                _deleteRenderedQueueGroups(mLeavePassesInQueue); 
    304290#endif 
    305291 
    306         // for depth pass: add visible nodes found with the visibility culling 
    307         if (mUseDepthPass) 
    308         { 
    309                 for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it) 
    310                 { 
    311                         (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false); 
    312                 } 
     292                //-- reset parameters 
    313293                mRenderDepthPass = false; 
    314         } 
    315  
    316         mSkipTransparents = false; 
    317  
    318         //-- now we can render all remaining queue objects 
    319         // for depth pass: all 
    320         // for delayed rendering: transparents, overlay  
    321         clearSpecialCaseRenderQueues(); 
    322         TerrainSceneManager::_renderVisibleObjects(); 
    323  
    324         TerrainRenderable::setCurrentRenderLevelIndex(renderLevel); 
     294                mSkipTransparents = false; 
     295                mLeavePassesInQueue = 0; 
     296                mShadowTechnique = mSavedShadowTechnique; 
     297 
     298 
     299                // add visible nodes found by the visibility culling algorithm 
     300                if (mUseDepthPass) 
     301                { 
     302                        for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it) 
     303                        { 
     304                                (*it)->_addToRenderQueue(mCameraInProgress, getRenderQueue(), false); 
     305                        } 
     306                } 
     307                 
     308                //-- now we can render all remaining queue objects 
     309                // for depth pass, transparents, overlay  
     310                clearSpecialCaseRenderQueues(); 
     311                TerrainSceneManager::_renderVisibleObjects(); 
     312        } 
     313                 
     314        // set the new render level index afterwards => new level in the next frame  
     315        TerrainRenderable::setCurrentRenderLevelIndex( 
     316                (TerrainRenderable::getCurrentRenderLevelIndex() + 1) % 10); 
     317 
    325318        getRenderQueue()->clear(); 
    326319        //WriteLog(); // write out stats 
    … …  
    346339                return true; 
    347340        } 
    348         if (key == "ShowVisualization") 
     341        if (key == "PrepareVisualization") 
    349342        { 
    350343                mShowVisualization = (*static_cast<const bool *>(val)); 
    … …  
    453446} 
    454447//----------------------------------------------------------------------- 
    455 void VisibilityTerrainSceneManager::renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs,  
    456             bool doLightIteration, const LightList* manualLightList) 
     448void VisibilityTerrainSceneManager::renderObjects( 
     449        const RenderPriorityGroup::TransparentRenderablePassList& objs,  
     450    bool doLightIteration, const LightList* manualLightList) 
    457451{ 
    458452        // for correct rendering, transparents must be rendered after hierarchical culling 
    … …  
    519513                        std::stringstream d; d << "itembuffer, pass name: " <<  
    520514                                ipass->first->getParent()->getParent()->getName(); 
    521                                 //<< ", renderable name: " << irend-> 
    522  
     515                                 
    523516                        LogManager::getSingleton().logMessage(d.str()); 
    524517                         
    525                         //if(ipass->first->getParent()->getParent()->getName() == "Examples/Athene") 
    526                                 //<< ", renderable name: " << irend-> 
    527                                 RenderSingleObjectForItemBuffer(*irend, ipass->first); 
    528                                 //RenderSingleObjectForOcclusionQuery( 
     518                        RenderSingleObjectForItemBuffer(*irend, ipass->first); 
    529519                } 
    530520        } 
    … …  
    556546        mItemBufferPass->setAmbient(ColourValue(0, 1, 1)); 
    557547        //mItemBufferPass->setDiffuse(ColourValue(0, col, 0)); 
    558 //      mItemBufferPass->setSpecular(ColourValue(0, col, 0)); 
    559 //      mItemBufferPass->_load(); 
     548    //mItemBufferPass->setSpecular(ColourValue(0, col, 0)); 
     549    //mItemBufferPass->_load(); 
    560550 
    561551        // set vertex program of current pass 
    … …  
    579569        } 
    580570 
    581         //LogManager::getSingleton().logMessage("has vertex program"); 
    582571        Pass *usedPass = setPass(mItemBufferPass);  
    583572        //Pass *usedPass = setPass(pass); 
    584         std::stringstream d; 
    585         d << "item buffer id: " << rend->getId() << ", col: " << col; 
     573         
     574        std::stringstream d; d << "item buffer id: " << rend->getId() << ", col: " << col; 
    586575        LogManager::getSingleton().logMessage(d.str()); 
    587576 
    … …  
    607596        return ent; 
    608597} 
    609  
     598//----------------------------------------------------------------------- 
     599void VisibilityTerrainSceneManager::InitVisibilityCulling(Camera *cam) 
     600{ 
     601        InitDepthPass();          // create material for depth pass 
     602        InitItemBufferPass(); // create material for item buffer pass 
     603 
     604        // save shadow technique so after first pass it can be reset 
     605        mSavedShadowTechnique = mShadowTechnique; 
     606 
     607 
     608        // set passes which should be stored in render queue for rendering afterwards 
     609        mLeavePassesInQueue = 0; 
     610         
     611/*      if (mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE) 
     612        { 
     613                mShadowTechnique = SHADOWTYPE_NONE; 
     614 
     615                if (!mUseDepthPass) 
     616                { 
     617                        // TODO: remove this 
     618                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW; 
     619 
     620                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DECAL; 
     621                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_DIFFUSE_SPECULAR; 
     622                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES; 
     623                } 
     624        } 
     625        if (mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE) 
     626        { 
     627                mShadowTechnique = SHADOWTYPE_NONE; 
     628 
     629                if (!mUseDepthPass) 
     630                { 
     631                        mLeavePassesInQueue |= RenderPriorityGroup::SOLID_PASSES_NOSHADOW; 
     632                        mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES; 
     633                } 
     634        } 
     635        */ 
     636        if (mDelayRenderTransparents && (!mUseDepthPass)) 
     637        { 
     638                mLeavePassesInQueue |= RenderPriorityGroup::TRANSPARENT_PASSES; 
     639        } 
     640        std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue; 
     641        LogManager::getSingleton().logMessage(d.str()); 
     642 
     643        // possible two cameras (one for culling, one for rendering) 
     644        mHierarchyInterface->InitFrame(mOctree, cam,  
     645                                                mCullCamera ? getCamera("CullCamera") : NULL, 
     646                                                mLeavePassesInQueue); 
     647                 
     648         
     649        // reset culling manager stats 
     650        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
     651 
     652        // set depth pass flag before rendering 
     653    mRenderDepthPass = mUseDepthPass; 
     654         
     655        // set flag for skipping transparents for this rendering pass 
     656        mSkipTransparents = mUseDepthPass || (mLeavePassesInQueue &  
     657                RenderPriorityGroup::TRANSPARENT_PASSES); 
     658} 
     659 
     660//----------------------------------------------------------------------- 
     661/*void VisibilityTerrainSceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup) 
     662{ 
     663    // Basic render loop 
     664    // Iterate through priorities 
     665    RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator(); 
     666 
     667    while (groupIt.hasMoreElements()) 
     668    { 
     669        RenderPriorityGroup* pPriorityGrp = groupIt.getNext(); 
     670 
     671        // Sort the queue first 
     672        pPriorityGrp->sort(mCameraInProgress); 
     673 
     674                //TODO: render other splid passes for shadows 
     675        // Do solids 
     676        renderObjects(pPriorityGrp->_getSolidPassesNoShadows(), true); 
     677 
     678                // do solid passes no shadows if addititive stencil shadows 
     679                if (mSavedShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE) 
     680                        renderObjects(pPriorityGrp->_getSolidPassesNoShadows(), true); 
     681                 
     682        // Do transparents 
     683        renderObjects(pPriorityGrp->_getTransparentPasses(), true); 
     684 
     685 
     686    }// for each priority 
     687} 
     688*/ 
    610689} // namespace Ogre 

  • trunk/VUT/work/TestCulling/TestCullingApplication.cpp

    r133 r139  
    9494 
    9595/***********************************************/ 
    96 /* TerrainFrameListener implementation           */ 
     96/* TerrainFrameListener implementation         */ 
    9797/***********************************************/ 
    9898//----------------------------------------------------------------------- 
    … …  
    294294        mShowVisualization = !mShowVisualization; 
    295295 
    296         mSceneMgr->setOption("ShowVisualization", &mShowVisualization); 
     296        mSceneMgr->setOption("PrepareVisualization", &mShowVisualization); 
    297297        mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes); 
    298298} 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

    r137 r139  
    7575mCullCamera(false), 
    7676mRecord(false), 
    77 mUseShadows(false), 
     77mShowShadows(false), 
    7878mShowHelp(false), 
    7979mDisplayCameraDetails(false), 
    … …  
    159159        mSceneMgr->setOption("ShowOctree", &mShowOctree); 
    160160        mSceneMgr->setOption("CullCamera", &mCullCamera); 
    161         mSceneMgr->setOption("ShowVisualization", &mShowVisualization); 
     161        mSceneMgr->setOption("PrepareVisualization", &mShowVisualization); 
    162162 
    163163        // TODO: change this (does not work with other scene manager plugins) 
    … …  
    257257        } 
    258258 
    259 //      mInputDevice->capture(); 
     259        if (mDisplayCameraDetails) 
     260    { 
     261        // Print camera details 
     262        mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) +  
     263                        " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation())); 
     264    } 
    260265 
    261266        //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly 
    … …  
    706711void TerrainFrameListener::toggleShowViz() 
    707712{ 
    708         mShowVisualization = !mShowVisualization; 
    709         mVisualizeCulledNodes = !mVisualizeCulledNodes; 
    710  
     713        mVisualizeCulledNodes = mShowVisualization = !mShowVisualization; 
     714         
    711715        // create viewport with priority VIZ_VIEWPORT_Z_ORDER:  
    712716        // will be rendered over standard viewport 
    … …  
    721725                // Alter the camera aspect ratio to match the viewport 
    722726        mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /  
    723                         Real(vizvp->getActualHeight())); 
     727                                                                   Real(vizvp->getActualHeight())); 
    724728                 
    725729                mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes); 
    … …  
    733737                mSceneMgr->setSkyPlane(true, plane, "Examples/TransparentTest", 4000, 75, false); 
    734738                */ 
    735                  
    736739        } 
    737740        else 
    738741        { 
     742                // remove visualization viewport 
    739743                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER); 
    740                 // if octree was enabled for visualization purpose, reset now 
     744 
     745                // octree bounding boxes are shown for visualization purpose, reset now 
    741746                mSceneMgr->setOption("ShowOctree", &mShowOctree); 
    742747        } 
    743748} 
    744749//----------------------------------------------------------------------- 
    745 void TerrainFrameListener::toggleUseShadows() 
    746 { 
    747         mUseShadows = !mUseShadows; 
    748  
    749         mSunLight->setCastShadows(mUseShadows); 
    750  
    751         if (mUseShadows) 
     750void TerrainFrameListener::toggleShowShadows() 
     751{ 
     752        mShowShadows = !mShowShadows; 
     753 
     754        mSunLight->setCastShadows(mShowShadows); 
     755 
     756        if (mShowShadows) 
    752757        { 
    753758                mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE); 
     759                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE); 
     760                //mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);            
    754761        } 
    755762        else 
    … …  
    805812                break; 
    806813        case KC_S: 
    807                 toggleUseShadows(); 
     814                toggleShowShadows(); 
    808815                break; 
    809816 
    … …  
    857864                break; 
    858865        } 
    859  
    860         if (mDisplayCameraDetails) 
    861     { 
    862         // Print camera details 
    863         mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) +  
    864                         " " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation())); 
    865     } 
    866866 
    867867        CEGUI::System::getSingleton().injectKeyDown(e->getKey()); 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.h

    r135 r139  
    9898        void toggleShowStats(); 
    9999 
    100         void toggleUseShadows(); 
     100        void toggleShowShadows(); 
    101101        void toggleDisplayCameraDetails(); 
    102102        void takeScreenShot(); 
    … …  
    175175        bool mCullCamera; 
    176176        bool mRecord; 
    177         bool mUseShadows; 
     177        bool mShowShadows; 
    178178        bool mVisualizeCulledNodes; 
    179179        bool mShowHelp; 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

    r137 r139  
    8484{ 
    8585        // Set ambient light 
    86         mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); 
     86        mAmbientLight = ColourValue(0.5, 0.5, 0.5); 
     87        mSceneMgr->setAmbientLight(mAmbientLight); 
    8788         
    8889        //-- create light 
    … …  
    100101        mSunLight->setDirection(dir); 
    101102        //mSunLight->setDirection(Vector3::NEGATIVE_UNIT_Y); 
    102  
    103103        mSunLight->setDiffuseColour(1, 1, 1); 
    104104        mSunLight->setSpecularColour(1, 1, 1); 
    … …  
    137137        */ 
    138138        mSceneMgr->setShadowTextureSettings(1024, 2); 
    139 /*      if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_HWRENDER_TO_TEXTURE)) 
    140     {   // In D3D, use a 1024x1024 shadow texture 
    141                 mSceneMgr->setShadowTextureSettings(1024, 2);   }       else    { 
    142                 // Use 512x512 texture in GL since we can't go higher than the window res 
    143                 mSceneMgr->setShadowTextureSettings(512, 2);} 
    144                 */ 
    145  
    146         //mSceneMgr->setShadowColour(ColourValue(0, 0, 0)); 
    147139        mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5)); 
    148     // mSceneMgr->setShowDebugShadows(true); 
     140    //mSceneMgr->setShowDebugShadows(true); 
    149141 
    150142 
    … …  
    220212        const bool nShowViz = !showViz; 
    221213 
    222         // ambient light must be full for visualization 
     214        mSavedShadowTechnique = mSceneMgr->getShadowTechnique(); 
     215        mSavedAmbientLight = mSceneMgr->getAmbientLight(); 
     216 
     217        // -- ambient light must be full for visualization, shadows disabled 
    223218    if (showViz) 
    224219        { 
    225220                mSceneMgr->setAmbientLight(ColourValue(1, 1, 1)); 
    226         } 
    227         else 
    228         { 
    229                 mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); 
    230         } 
    231  
    232     mSceneMgr->setOption("ShowVisualization", &showViz); 
     221                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE); 
     222        } 
     223         
     224    mSceneMgr->setOption("PrepareVisualization", &showViz); 
    233225        mSceneMgr->setOption("SkyBoxEnabled", &nShowViz); 
    234226        //mSceneMgr->setOption("SkyPlaneEnabled", &showViz); 
    … …  
    239231void VisualizationRenderTargetListener::postRenderTargetUpdate(const RenderTargetEvent &evt) 
    240232{ 
     233        // reset values 
     234        mSceneMgr->setShadowTechnique(mSavedShadowTechnique); 
     235        mSceneMgr->setAmbientLight(mSavedAmbientLight); 
     236         
    241237        RenderTargetListener::postRenderTargetUpdate(evt); 
    242238} 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.h

    r133 r139  
    33 
    44#include "CEGUIForwardRefs.h" 
     5#include <OgreRenderTargetListener.h> 
    56#include "ExampleApplication.h" 
     7 
    68#include "OgreTerrainContentGenerator.h" 
    7  
    8 #include <OgreRenderTargetListener.h> 
    99#include "TerrainFrameListener.h" 
    1010 
    … …  
    1919 
    2020        SceneManager *mSceneMgr; 
     21         
     22        ShadowTechnique mSavedShadowTechnique; 
     23        ColourValue mSavedAmbientLight; 
    2124}; 
    2225 
    … …  
    5457        SceneNode *mCamNode; 
    5558        Light *mSunLight; 
    56         VisualizationRenderTargetListener *mRenderTargetListener; 
    5759 
    5860        TerrainFrameListener *mTerrainFrameListener; 
     61        ColourValue mAmbientLight; 
     62        //VisualizationRenderTargetListener *mVizRenderTargetListener; 
    5963         
    6064private: 

  • trunk/VUT/work/ogre_changes/OgreMain/include/OgreRenderQueueSortingGrouping.h

    r115 r139  
    197197        void clear(void); 
    198198#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     199         
    199200                /** Clears solids in this group of renderables. Leaves transparents in group. 
    200201        */ 
    201202        void clearSolids(void); 
     203 
     204                enum {SOLID_PASSES = 1, 
     205                          SOLID_PASSES_DECAL = 2, 
     206                          SOLID_PASSES_DIFFUSE_SPECULAR = 4, 
     207                          SOLID_PASSES_NOSHADOW = 8, 
     208                          TRANSPARENT_PASSES = 16}; 
     209 
     210                /** Clears passes determined by parameter. 
     211                        @param passes can be one or several (combined by |) of: 
     212                        SOLID_PASSES  
     213                        SOLID_PASSES_DECAL  
     214                        SOLID_PASSES_DIFFUSE_SPECULAR 
     215                        SOLID_PASSES_NOSHADOW 
     216                        TRANSPARENT_PASSES 
     217                */ 
     218                void clear(const int leavePassesInQueue); 
    202219#endif // GTP_VISIBILITY_MODIFIED_OGRE           
    203220        /** Sets whether or not the queue will split passes by their lighting type, 
    … …  
    306323        } 
    307324#ifdef GTP_VISIBILITY_MODIFIED_OGRE      
     325                void clear(int passes) 
     326        { 
     327            PriorityMap::iterator i, iend; 
     328            iend = mPriorityGroups.end(); 
     329            for (i = mPriorityGroups.begin(); i != iend; ++i) 
     330            { 
     331                i->second->clear(passes); 
     332            } 
     333 
     334        } 
    308335                /** Clears only solid renderables. Leaves transparents in queue. */ 
    309336                void clearSolids(void) 

  • trunk/VUT/work/ogre_changes/OgreMain/include/OgreSceneManager.h

    r131 r139  
    128128                        @param node scene node to be rendered 
    129129                        @param cam current camera 
    130                         @param leaveTransparentsInQueue if only solid objects should be rendered 
    131                 */ 
    132                 void _renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue = false); 
     130                        @param leavePassesInQueue list of passes which are left in queue 
     131                */ 
     132                void _renderSceneNode(Camera *cam, SceneNode *node, const int leavePassesInQueue = 0); 
    133133                /** deletes all processed queues 
    134                         @remark clears render queues after rendering scene node 
    135                 */ 
    136                 void _deleteRenderedQueueGroups(bool leaveTransparentsInQueue); 
     134                        @param leavePassesInQueue pass list which is not deleted from queue 
     135                        @remark used to clear render queues before rendering scene node 
     136                */ 
     137                void _deleteRenderedQueueGroups(int leavePassesInQueue = 0); 
    137138                /** Internal method used by _renderVisibleObjects to deal with renderables 
    138139            which override the camera's own view / projection materices.  
    … …  
    156157                /** Renders an Ogre MovableObject. 
    157158                */ 
    158                 void _renderMovableObject(MovableObject *mov, const bool leaveTransparentsInQueue); 
     159                void _renderMovableObject(MovableObject *mov, const int leavePassesInQueue); 
    159160 
    160161#endif // GTP_VISIBILITY_MODIFIED_OGRE 

  • trunk/VUT/work/ogre_changes/OgreMain/src/OgreRenderQueueSortingGrouping.cpp

    r115 r139  
    280280    void RenderPriorityGroup::clearSolids(void) 
    281281    { 
    282       /*  SolidRenderablePassMap::iterator i, iend; 
     282        /*SolidRenderablePassMap::iterator i, iend; 
    283283        // Delete queue groups which are using passes which are to be 
    284284        // deleted, we won't need these any more and they clutter up  
    … …  
    313313        clearSolidPassMap(mSolidPassesNoShadow); 
    314314    } 
     315        //----------------------------------------------------------------------- 
     316    void RenderPriorityGroup::clear(const int leavePassesInQueue) 
     317    { 
     318                SolidRenderablePassMap::iterator i, iend; 
     319        
     320                // -- standard method if no passes are left in queue 
     321                if (leavePassesInQueue == 0) 
     322                { 
     323                        clear(); 
     324                        return; 
     325                } 
     326 
     327        // We do not clear the unchanged solid pass maps, only the contents of each list 
     328        // This is because we assume passes are reused a lot and it saves resorting 
     329                if (!(leavePassesInQueue & SOLID_PASSES)) 
     330                        clearSolidPassMap(mSolidPasses); 
     331                if (!(leavePassesInQueue & SOLID_PASSES_DECAL)) 
     332                        clearSolidPassMap(mSolidPassesDecal); 
     333                if (!(leavePassesInQueue & SOLID_PASSES_DIFFUSE_SPECULAR)) 
     334                        clearSolidPassMap(mSolidPassesDiffuseSpecular); 
     335                if (!(leavePassesInQueue & SOLID_PASSES_NOSHADOW)) 
     336                        clearSolidPassMap(mSolidPassesNoShadow); 
     337 
     338        if (!(leavePassesInQueue & TRANSPARENT_PASSES)) 
     339                        mTransparentPasses.clear(); 
     340    } 
    315341#endif // GTP_VISIBILITY_MODIFIED_OGRE           
    316342//----------------------------------------------------------------------- 

  • trunk/VUT/work/ogre_changes/OgreMain/src/OgreSceneManager.cpp

    r135 r139  
    19091909 
    19101910        itransend = objs.end(); 
    1911         for (itrans = objs.begin();  
    1912                 itrans != itransend; ++itrans) 
     1911        for (itrans = objs.begin(); itrans != itransend; ++itrans) 
    19131912        { 
    19141913                Renderable *r = itrans->renderable; 
    … …  
    41974196#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    41984197//----------------------------------------------------------------------- 
    4199 void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue) 
     4198void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, const int leavePassesInQueue) 
    42004199{ 
    42014200        // delete previously rendered objects from renderqueue 
    4202         _deleteRenderedQueueGroups(leaveTransparentsInQueue); 
     4201        _deleteRenderedQueueGroups(leavePassesInQueue); 
    42034202 
    42044203        node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false); 
    … …  
    42064205} 
    42074206//----------------------------------------------------------------------- 
    4208 void SceneManager::_deleteRenderedQueueGroups(bool leaveTransparentsInQueue) 
     4207void SceneManager::_deleteRenderedQueueGroups(const int leavePassesInQueue) 
    42094208{ 
    42104209        RenderQueue::QueueGroupIterator queueIt = getRenderQueue()->_getQueueGroupIterator(); 
    … …  
    42184217                if (isRenderQueueToBeProcessed(qId)) 
    42194218                { 
    4220                         if (leaveTransparentsInQueue) 
    4221                         { 
    4222                                 pGroup->clearSolids(); 
    4223                         } 
    4224                         else 
    4225                         { 
    4226                                 pGroup->clear(); 
    4227                         } 
     4219                        /*if (leaveTransparentsInQueue) 
     4220                        {       pGroup->clearSolids();  }       else 
     4221                        {       pGroup->clear(); }*/ 
     4222                        pGroup->clear(leavePassesInQueue); 
    42284223                } 
    42294224        } 
    … …  
    42454240}*/ 
    42464241//----------------------------------------------------------------------- 
    4247 void SceneManager::_renderMovableObject(MovableObject *mov, const bool leaveTransparentsInQueue) 
     4242void SceneManager::_renderMovableObject(MovableObject *mov, const int leavePassesInQueue) 
    42484243{ 
    42494244        // delete previously rendered objects from renderqueue 
    4250         _deleteRenderedQueueGroups(leaveTransparentsInQueue); 
     4245        _deleteRenderedQueueGroups(leavePassesInQueue); 
    42514246 
    42524247        mov->_updateRenderQueue(getRenderQueue()); 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/include/OgreOctreeSceneManager.h

    r115 r139  
    112112                @param octree the octant to be rendered (without children) 
    113113                @param onlyShadowCasters if only shadow casters are rendered 
    114                 @param leaveTransparentsInQueue if transparemt should be left in queue for later processing 
     114                @param passes if passes should be left in queue for later processing 
    115115        */ 
    116         void _renderOctant(Camera* cam, Octree *octree, bool onlyShadowCasters, bool leaveTransparentsInQueue = false); 
     116        void _renderOctant(Camera* cam, Octree *octree, bool onlyShadowCasters,  
     117                const int leavePassesInQueue = 0); 
    117118 
    118119        /** Returns stored list of boxes */ 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctree.cpp

    r135 r139  
    3636#include <OgreOctree.h> 
    3737#include <OgreOctreeNode.h> 
     38#include <OgreLogManager.h> 
    3839 
    3940namespace Ogre 
    … …  
    109110                mDepth = 0; 
    110111 
     112        _updateBounds(); 
    111113#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    112114    mNumNodes = 0; 
    … …  
    175177        //mWireBoundingBox->setupBoundingBox(mBox); 
    176178        mWireBoundingBox->setupBoundingBox(mWorldAABB); 
     179 
    177180    return mWireBoundingBox; 
    178181} 
    … …  
    229232        // Reset bounds first 
    230233    mWorldAABB.setNull(); 
    231  
     234   
    232235    // Update bounds from own attached objects 
    233236        NodeList::iterator it, it_end; 
    … …  
    247250            for (int k = 0; k < 2; ++k) 
    248251            { 
    249                 if (mChildren[i][j][k] != 0) 
     252                if (mChildren[i][j][k]) 
    250253                                { 
    251254                                        mWorldAABB.merge(mChildren[i][j][k]->_getWorldAABB()); 
    … …  
    254257        } 
    255258        } 
     259        // HACK: clamp to bounds 
     260        AxisAlignedBox box; 
     261        _getCullBounds(&box); 
     262        mWorldAABB = mWorldAABB.intersection(box);  
     263         
     264        //std::stringstream d; d << "updating box: " << mWorldAABB << ", depth: " << mDepth << "null: " << mBox.isNull(); 
     265        //LogManager::getSingleton().logMessage(d.str()); 
     266 
    256267        // recursively update parent bounds 
    257268        if (mParent) 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp

    r135 r139  
    11761176//----------------------------------------------------------------------- 
    11771177void OctreeSceneManager::_renderOctant(Camera *cam, Octree *octant, bool onlyShadowCasters,  
    1178                                                                            bool leaveTransparentsInQueue)//, bool useZPassQueue) 
     1178                                                                           const int leavePassesInQueue) 
    11791179{ 
    11801180        // delete previously rendered objects from the render queue 
    1181         _deleteRenderedQueueGroups(leaveTransparentsInQueue); 
     1181        _deleteRenderedQueueGroups(leavePassesInQueue); 
    11821182 
    11831183        //Add stuff to be rendered; 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreTerrainRenderable.cpp

    r132 r139  
    388388            if (mLastNextLevel != nextLevel) 
    389389            { 
    390                                 //LogManager::getSingleton().logMessage("vbuffer binding"); 
    391                 if (nextLevel > 0) 
    392                 { 
    393                                         //LogManager::getSingleton().logMessage("level > 0"); 
    394                     mTerrain->vertexBufferBinding->setBinding(DELTA_BINDING,  
     390                                if (nextLevel > 0) 
     391                { 
     392                                        mTerrain->vertexBufferBinding->setBinding(DELTA_BINDING,  
    395393                        mDeltaBuffers[nextLevel - 1]); 
    396394                } 
    397395                else 
    398                 { 
    399                                         //LogManager::getSingleton().logMessage("level <= 0 (dummy b)"); 
     396                {                                
    400397                    // bind dummy (incase bindings checked) 
    401398                    mTerrain->vertexBufferBinding->setBinding(DELTA_BINDING,  
    … …  
    406403 
    407404        } 
    408                 //else LogManager::getSingleton().logMessage("no lod morph"); 
    409                 /*std::stringstream d;  
    410                 d << "terrain: " << this->getName() << ", notify camera: " << cam->getName() << ", pos: " << StringConverter::toString(cam->getDerivedPosition()) <<  
    411                         ", distance: " << StringConverter::toString(L) << ", lod level: " << mLastNextLevel 
    412                         << ", render level: " << getRenderLevel() << ", morph factor: " << mLODMorphFactor; 
    413                 LogManager::getSingleton().logMessage(d.str());*/ 
    414  
    415405    } 
    416406    //----------------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.