Ignore:
Timestamp:
04/19/05 09:12:55 (20 years ago)
Author:
mattausch
Message:
 
Location:
trunk/VUT/OcclusionCullingSceneManager/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingOctreeSceneManager.cpp

    r45 r51  
    1616                //mDisplayNodes = true; 
    1717                //mShowBoundingBoxes = true; 
    18                 //mShowBoxes = true; 
     18                mShowBoxes = true; 
    1919                mMaxDepth = 20; 
    2020        } 
    … …  
    5757                // must be empty because objects are found and rendered in an interleaved fashion 
    5858                // in _renderVisibibleObjects  
    59                 //char *msg = "now finding visible objects\n"; OutputDebugString(msg); 
    6059        } 
    6160        //----------------------------------------------------------------------- 
    … …  
    9291                return mOcclusionCullingOctreeSceneTraverser->getOptionKeys ( refKeys ) || OctreeSceneManager::getOptionKeys( refKeys ); 
    9392        } 
    94         //----------------------------------------------------------------------- 
    95         void OcclusionCullingOctreeSceneManager::_renderOctant(Camera *cam, Octree *octant) 
    96         { 
    97                 //Add stuff to be rendered; 
    98         NodeList::iterator it = octant->mNodes.begin(); 
    99           
    100         while(it != octant->mNodes.end()) 
    101         { 
    102             OctreeNode *sn = *it; 
    103  
    104             mNumObjects++; 
    105  
    106                         // check bounding box visibility of scene nodes 
    107                         if (cam->isVisible(sn->_getWorldAABB())) 
    108                         { 
    109                                 sn->_addToRenderQueue(cam, getRenderQueue(), false); 
    110                                 //node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false); 
    111                                 mVisible.push_back(sn); 
    112  
    113                                 if (mDisplayNodes) 
    114                                         getRenderQueue()->addRenderable(sn); 
    115  
    116                                 // check if the scene manager or this node wants the bounding box shown. 
    117                                 if (sn->getShowBoundingBox() || mShowBoundingBoxes) 
    118                                         sn->_addBoundingBoxToQueue(getRenderQueue()); 
    119  
    120                                 if (mShowBoxes) 
    121                                         getRenderQueue()->addRenderable(octant->getWireBoundingBox()); 
    122                         } 
    123             ++it; 
    124         } 
    125  
    126                 SceneManager::_renderVisibleObjects(); 
    127          
    128                 // delete all rendered objects from renderqueue 
    129                 _deleteRenderedQueueGroups(); 
    130         } 
    13193}        

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingOctreeSceneTraverser.cpp

    r48 r51  
    2828                { 
    2929                        Octree *nextChild = octant->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1]; 
    30                  
     30 
     31                        /*char msg[100]; 
     32                        sprintf(msg, "node number: %d %d %d\n", (i & 4) >> 2, (i & 2) >> 1, i & 1); 
     33                        OutputDebugString(msg);*/ 
     34 
    3135                        if(nextChild) 
    3236                                mOctreeDistanceQueue->push(nextChild); 
    … …  
    4448         
    4549                        // interesting for visualization purpose 
    46                         //TODO: octree->setNodeVisible(false); 
     50                        octant->setOctreeVisible(false); 
    4751                        octant->_getCullBounds(&box); 
    4852                         
    … …  
    8185                        bool intersects = false; 
    8286 
    83                         //if(vis == OctreeCamera::NONE) 
    8487                        if(!cam->isVisible(box, intersects)) 
    8588                        { 
    … …  
    100103                        // wait if result not available 
    101104                        query->pullOcclusionQuery(&visiblePixels); 
    102                          
     105//visiblePixels = 1; 
    103106                        // node visible 
    104107                        if(visiblePixels > mVisibilityThreshold) 
    … …  
    108111                        else 
    109112                        { 
     113                                char msg[100]; 
     114                                Vector3 min = box.getMinimum(); 
     115                                Vector3 max = box.getMaximum(); 
     116 
     117                                sprintf(msg, "culling box: %3.3f %3.3f %3.3f %3.3f %3.3f %3.3f\n", min.x, min.y, min.z, max.x, max.y, max.z); 
     118                                OutputDebugString(msg); 
     119 
    110120                                mNumQueryCulledNodes ++; 
    111121                        } 
    … …  
    133143                                unsigned int visiblePixels; 
    134144                                query->pullOcclusionQuery(&visiblePixels); 
    135  
     145//visiblePixels = 1; 
    136146                                if(visiblePixels > mVisibilityThreshold) 
    137147                                { 
    … …  
    164174                                if(intersects) 
    165175                                { 
    166                                         // update node's visited flag 
     176                                        // update octant's visited flag 
    167177                                        octant->setLastVisited(mFrameId); 
    168178                                        pullUpVisibility(cam, octant);                   
    … …  
    174184                                // identify previously visible nodes 
    175185                                bool wasVisible = octant->isOctreeVisible() && (octant->lastVisited() == mFrameId - 1); 
    176                                          
     186                                 
     187                                /* char msg[100]; 
     188                                if(wasVisible) sprintf(msg, "yes, was visible, %d\n", mFrameId); 
     189                                else sprintf(msg, "no was invisible, %d\n", mFrameId); 
     190                                OutputDebugString(msg);*/ 
     191 
    177192                                // identify nodes that we cannot skip queries for 
    178193                                bool leafOrWasInvisible = !wasVisible || isLeaf(octant); 
    … …  
    196211                                        traverseOctant(cam, octant); 
    197212                                } 
    198                                 else 
    199                                 { 
    200                                         mNumFrustumCulledNodes ++; 
    201                                 } 
    202213                        } 
    203214                } 
    … …  
    218229        void OcclusionCullingOctreeSceneTraverser::renderOctant( Camera *cam, Octree *octant ) 
    219230        { 
    220                 //if(octant->numNodes() > 0) 
     231                if(octant->numNodes() == 0) return; 
    221232                if(octant->lastVisited() != octant->lastRendered()) 
    222233                { 
    223                         //setRenderingMode(MODE_RENDER); 
     234                        //TODO: does nothing useful 
     235                        setRenderingMode(MODE_RENDER); 
     236                        mNumRenderedNodes ++; 
    224237 
    225238                        octant->setLastRendered(octant->lastVisited()); 
    226                         ((OcclusionCullingOctreeSceneManager *)mSceneManager)->_renderOctant(cam, octant); 
    227                 } 
    228                 else OutputDebugString("already rendered"); 
     239                        ((OctreeSceneManager *)mSceneManager)->_renderOctant(cam, octant); 
     240                } 
     241                //else OutputDebugString("already rendered"); 
    229242        } 
    230243        //----------------------------------------------------------------------- 

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingSceneManagerDll.cpp

    r48 r51  
    3434namespace Ogre { 
    3535 
    36    // OcclusionCullingDotSceneManager *occlusionDotPlugin; 
     36        // OcclusionCullingDotSceneManager *occlusionDotPlugin; 
    3737        OcclusionCullingOctreeSceneManager *occlusionOctreePlugin; 
    3838        OcclusionCullingTerrainSceneManager *occlusionTerrainPlugin; 
    … …  
    5454                Root::getSingleton().setSceneManager( ST_GENERIC, occlusionOctreePlugin ); 
    5555                Root::getSingleton().setSceneManager( ST_EXTERIOR_CLOSE, occlusionTerrainPlugin ); 
    56                  
    57                 // MessageBox( NULL, "myplugin registered", "this is my plugin", MB_OK | MB_ICONERROR | MB_TASKMODAL); 
    5856    } 
    5957    extern "C" void dllStopPlugin(void) 

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingSceneTraverser.cpp

    r44 r51  
    1616        mQueryMode(MODE_RENDER), mNumSceneNodes(0), mCurrentAlgorithm(RENDER_COHERENT), 
    1717        mNumQueries(0), mNumTraversedNodes(0), mNumQueryCulledNodes(0), mNumFrustumCulledNodes(0),  
    18         mNumRenderedGeometry(0), mSceneManager(sm), mRenderSystem(rsys), mSceneRoot(NULL) 
     18        mNumRenderedNodes(0),mNumRenderedGeometry(0), mSceneManager(sm), mRenderSystem(rsys), mSceneRoot(NULL) 
    1919        {                
    2020                mHalfBoundingBox[0] = mHalfBoundingBox[1] = 0; 
    … …  
    3939                mNumFrustumCulledNodes = 0; 
    4040                mNumRenderedGeometry = 0; 
    41                  
     41                mNumRenderedNodes = 0; 
     42 
    4243                mCurrentTestIdx = 0; 
    4344 
    4445                initDistanceQueue(cam); 
    4546 
    46 //mCurrentAlgorithm = RENDER_CULL_FRUSTUM; 
     47                //deleteQueries(); 
     48                //char *msg = "deleting queries\n"; OutputDebugString(msg); 
     49        //for(unsigned int i=0; i < 1000; i++) 
     50                //mOcclusionQueries.push_back(mRenderSystem->createHardwareOcclusionQuery()); 
     51            //mCurrentAlgorithm = RENDER_CULL_FRUSTUM; 
     52 
    4753                switch(mCurrentAlgorithm) 
    4854                { 
    … …  
    5460                                break; 
    5561                        case RENDER_COHERENT: 
    56                                 //renderCoherentWithQueue(cam); 
    57 renderStopAndWait(cam); 
     62                                renderCoherentWithQueue(cam); 
    5863                                break; 
    5964                        default: 
    … …  
    209214                        // wait if result not available 
    210215                        query->pullOcclusionQuery(&visiblePixels); 
    211                                  
     216         
    212217                        // node visible 
    213218                        if(visiblePixels > mVisibilityThreshold) 
    … …  
    229234                // TODO: in rendervisibleobjects, the rendermode is changed by ogre itself => change this!! 
    230235                 
    231                 //setRenderingMode(MODE_QUERY); 
    232                 setRenderingMode(MODE_RENDER); 
     236                setRenderingMode(MODE_QUERY); 
     237                //setRenderingMode(MODE_RENDER); 
    233238 
    234239                // get next available test id 
    … …  
    251256                //{ 
    252257                        bool enabled = (mode == MODE_RENDER); 
    253                          
     258//if(mode == MODE_QUERY){ 
    254259                        mRenderSystem->_setColourBufferWriteEnabled(enabled,  
    255260                                enabled, enabled, enabled); 
    256261                        mRenderSystem->_setDepthBufferWriteEnabled(enabled); 
    257262                        mRenderSystem->setLightingEnabled(enabled); 
    258  
     263//} 
    259264                        mQueryMode = mode; 
    260265                //} 
    … …  
    346351        void OcclusionCullingSceneTraverser::deleteQueries( void ) 
    347352        { 
    348                 for(unsigned int i=0; i < (unsigned int)mOcclusionQueries.size(); i++) 
     353                for(unsigned int i=0; i < (unsigned int)mOcclusionQueries.size(); ++i) 
    349354                        delete mOcclusionQueries[i]; 
    350355 
    … …  
    357362                for(int half = 0; half < 2; half ++) 
    358363                { 
    359                         //static Matrix4 xform[256]; 
    360                         //TODO: this should be full boudning box 
     364                        static Matrix4 xform[256]; 
     365                        //TODO: this should be full bounding box 
    361366                        SolidHalfBoundingBox *halfbox = getSolidHalfBoundingBox(half); 
    362367                        halfbox->setupBoundingBox(*box); 
    363  
    364                         mRenderSystem->_setWorldMatrix(Matrix4::IDENTITY); 
    365368                         
     369                        //mRenderSystem->_setWorldMatrix(Matrix4::IDENTITY); 
     370                        // Set world transformation 
     371                        /*halfbox->getWorldTransforms(xform); 
     372 
     373                        int numMatrices = halfbox->getNumWorldTransforms(); 
     374                        if (numMatrices > 1) 
     375                        { 
     376                                mRenderSystem->_setWorldMatrices(xform, numMatrices); 
     377                        } 
     378                        else 
     379                        { 
     380                                mRenderSystem->_setWorldMatrix(*xform); 
     381                        } 
     382                        mRenderSystem->setClipPlanes(halfbox->getClipPlanes()); 
     383 
    366384                        static RenderOperation ro; 
    367385 
    … …  
    369387                        halfbox->getRenderOperation(ro); 
    370388                        ro.srcRenderable = halfbox;  
    371                         mRenderSystem->_render(ro); 
    372  
    373                         //mSceneManager->renderSingleObject(getSolidHalfBoundingBox(half),  
    374                         //      getSolidHalfBoundingBox(half)->getTechnique()->getPass(0), false); 
     389                        mRenderSystem->_render(ro);*/ 
     390 
     391                        mSceneManager->myrenderSingleObject(getSolidHalfBoundingBox(half),  
     392                                getSolidHalfBoundingBox(half)->getTechnique()->getPass(0), false); 
    375393                } 
    376394        } 
    … …  
    410428                { 
    411429                        mOcclusionQueries.push_back(mRenderSystem->createHardwareOcclusionQuery()); 
     430                        //char *msg = "creating query!!\n"; OutputDebugString(msg); 
    412431                } 
    413432                 

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingTerrainSceneManager.cpp

    r48 r51  
    1818                //mDisplayNodes = true; 
    1919                //mShowBoundingBoxes = true; 
    20                 //mShowBoxes = true; 
     20                mShowBoxes = true; 
    2121                mMaxDepth = 20; 
    2222        } 
    … …  
    9595        } 
    9696        //----------------------------------------------------------------------- 
    97         void OcclusionCullingTerrainSceneManager::_renderOctant(Camera *cam, Octree *octant) 
    98         { 
    99                 //Add stuff to be rendered; 
    100         NodeList::iterator it = octant->mNodes.begin(); 
    101           
    102         while(it != octant->mNodes.end()) 
    103         { 
    104             OctreeNode *sn = *it; 
    105  
    106             mNumObjects++; 
    107  
    108                         // check bounding box visibility of scene nodes 
    109                         if (cam->isVisible(sn->_getWorldAABB())) 
    110                         { 
    111                                 sn->_addToRenderQueue(cam, getRenderQueue(), false); 
    112                                 //node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false); 
    113                                 mVisible.push_back(sn); 
    114  
    115                                 if (mDisplayNodes) 
    116                                         getRenderQueue()->addRenderable(sn); 
    117  
    118                                 // check if the scene manager or this node wants the bounding box shown. 
    119                                 if (sn->getShowBoundingBox() || mShowBoundingBoxes) 
    120                                         sn->_addBoundingBoxToQueue(getRenderQueue()); 
    121  
    122                                 if (mShowBoxes) 
    123                                         getRenderQueue()->addRenderable(octant->getWireBoundingBox()); 
    124                         } 
    125             ++it; 
    126         } 
    127  
    128                 SceneManager::_renderVisibleObjects(); 
    129          
    130                 // delete all rendered objects from renderqueue 
    131                 _deleteRenderedQueueGroups(); 
    132         } 
    133         //----------------------------------------------------------------------- 
    13497        /*unsigned int OcclusionCullingTerrainSceneManager::countNumOctrees(Octree *root) 
    13598        { 

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreSolidHalfBoundingBox.cpp

    r26 r51  
    8989                setBoundingBox(aabb); 
    9090        } 
     91        // Override this method to prevent parent transforms (rotation,translation,scale) 
     92    void SolidHalfBoundingBox::getWorldTransforms( Matrix4* xform ) const 
     93    { 
     94                // return identity matrix to prevent parent transforms 
     95        *xform = Matrix4::IDENTITY; 
     96    } 
    9197} 
    9298 
Note: See TracChangeset for help on using the changeset viewer.