Changeset 174 for trunk


Ignore:
Timestamp:
07/14/05 09:06:16 (19 years ago)
Author:
mattausch
Message:
 
Location:
trunk/VUT
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibility/include/DummyQueryManager.h

    r159 r174  
    1616    */ 
    1717    DummyQueryManager( HierarchyInterface *hierarchyInterface ): 
    18       QueryManager(hierarchyInterface) {} 
     18      QueryManager(hierarchyInterface, 0) {} 
    1919     
    2020    /** 

  • trunk/VUT/GtpVisibility/include/HierarchyInterface.h

    r171 r174  
    126126        /** Returns vector of previously rendered hierarchy nodes. 
    127127        */ 
    128         std::vector<HierarchyNode *> *GetRenderedNodes(); 
     128        std::vector<HierarchyNode *> *GetVisibleNodes(); 
    129129        /** Returns vector of previoulsy rendered geometry. 
    130130        */ 
    … …  
    182182        HierarchyNode *mSavedNode; 
    183183        /// list of rendered hierarchy nodes (e.g., useful for exact visibility queries) 
    184         std::vector<HierarchyNode *> mRenderedNodes; 
     184        std::vector<HierarchyNode *> mVisibleNodes; 
    185185}; 
    186186} // namespace GtpVisibility 

  • trunk/VUT/GtpVisibility/include/QueryManager.h

    r159 r174  
    2727        on different hierarchy types, while reusing the implementation of the query methods. 
    2828     */ 
    29     QueryManager(HierarchyInterface *hierarchyInterface); 
     29    QueryManager(HierarchyInterface *hierarchyInterface, int queryModes); 
    3030     
    3131    /**  
    … …  
    9090        void SetHierarchyInterface(HierarchyInterface *hierarchyInterface); 
    9191 
     92        enum {PATCH_VISIBILITY = 2, 
     93                  GEOMETRY_VISIBILITY = 4, 
     94                  NODE_VISIBILITY = 8}; 
     95 
    9296protected: 
    93     HierarchyInterface *mHierarchyInterface; 
    9497   
     98        HierarchyInterface *mHierarchyInterface; 
     99        int mQueryModes;   
    95100}; 
    96101 

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

    r158 r174  
    3030        mCurrentTestIdx = 0; 
    3131        mNumTraversedNodes = 0; 
    32         mRenderedNodes.clear(); 
     32        mVisibleNodes.clear(); 
    3333 
    3434        mDistanceQueue->push(mHierarchyRoot); 
    … …  
    6363unsigned int HierarchyInterface::GetNumRenderedNodes() 
    6464{ 
    65         return (unsigned int)mRenderedNodes.size(); 
     65        return (unsigned int)mVisibleNodes.size(); 
    6666} 
    6767//----------------------------------------------------------------------- 
    … …  
    7171} 
    7272//----------------------------------------------------------------------- 
    73 std::vector<HierarchyNode *> *HierarchyInterface::GetRenderedNodes() 
     73std::vector<HierarchyNode *> *HierarchyInterface::GetVisibleNodes() 
    7474{ 
    75         return &mRenderedNodes; 
     75        return &mVisibleNodes; 
    7676} 
    7777} // namespace GtpVisibility 

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

    r130 r174  
    44namespace GtpVisibility { 
    55  
    6 QueryManager::QueryManager(HierarchyInterface *hierarchyInterface) 
    7 :mHierarchyInterface(hierarchyInterface) 
     6QueryManager::QueryManager(HierarchyInterface *hierarchyInterface, int queryModes): 
     7mHierarchyInterface(hierarchyInterface), 
     8mQueryModes(queryModes) 
    89{ 
    910} 

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

    r173 r174  
    1515                on different hierarchy types, while reusing the implementation of the query methods. 
    1616    */ 
    17         OcclusionQueriesQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
    18                                          Viewport *vp, 
    19                                                                  bool renderPatches, 
    20                                          bool useItemBufferForGeometry); 
     17        OcclusionQueriesQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp, 
     18                                                                 int queryModes, int itemBufferMode); 
    2119     
    2220    void ComputeCameraVisibility(const Camera &camera, 
    … …  
    7068        void RemoveDuplicatePatches(InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
    7169 
    72         bool mUseItemBuffer; 
     70        /** Returns the patches of the geometry of a given node.  
     71                @param node the node containing the patches 
     72                @param patchList the patches are returned in this list 
     73        */ 
     74        virtual void GetNodePatchList(GtpVisibility::HierarchyNode *node,        
     75                                                                  GtpVisibility::PatchList *patchList); 
     76 
     77        int mItemBufferMode; 
    7378}; 
    7479 

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

    r158 r174  
    4848 
    4949        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node, 
    50                                         GtpVisibility::GeometryList *geometryList,  
    51                                         bool includeChildren); 
    52  
     50                                                        GtpVisibility::GeometryList *geometryList,  
     51                                                        bool includeChildren); 
     52         
    5353protected: 
    5454        /** Returns pointer to the bounding box of the node. 

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

    r156 r174  
    106106    bool IsBoundingBoxQuery(); 
    107107 
     108        GtpVisibility::OcclusionQuery *IssueOcclusionQuery(GtpVisibility::Patch *patch); 
    108109 
    109110protected: 
    … …  
    111112        */ 
    112113        void RenderGeometry(GtpVisibility::Mesh *geom); 
     114 
     115        /** Renders a patch  
     116        */ 
     117        void RenderPatch(GtpVisibility::Patch *patch); 
    113118 
    114119        /** Materials for visualizing frustum and query culled nodes. 

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

    r173 r174  
    1818    */ 
    1919        PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
    20                                  Viewport *vp, 
    21                                                  bool renderPatches); 
     20                                 Viewport *vp, int queryModes); 
    2221     
    2322    /**  
    … …  
    4241        */ 
    4342        void SetViewport(Viewport *vp); 
    44          
     43 
    4544protected: 
    4645 
    … …  
    5352 
    5453        Viewport *mViewport; 
     54         
    5555        bool mWasInitialised; 
    56         bool mRenderPatches; 
    5756}; 
    5857 

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

    r173 r174  
    4747                                                        PlatformHierarchyInterface *hierarchyInterface,  
    4848                                                        Viewport *vp, 
    49                                                         bool renderPatches, 
    50                                                         bool useItemBufferForGeometry): 
    51 PlatformQueryManager(hierarchyInterface, vp, renderPatches), 
    52 mUseItemBuffer(useItemBufferForGeometry) 
     49                                                        int queryModes, 
     50                                                        int itemBufferMode): 
     51PlatformQueryManager(hierarchyInterface, vp, queryModes),  
     52mItemBufferMode(itemBufferMode) 
    5353{ 
    5454} 
    … …  
    6060                            bool relativeVisibility) 
    6161{ 
    62          // we need access to the scene manager and the rendersystem 
     62        // we need access to the scene manager and the rendersystem 
    6363        PlatformHierarchyInterface *pfHierarchyInterface =  
    6464                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    … …  
    6868 
    6969        //-- render scene with item buffer (i.e., objects with their id as color codes) 
    70         if (mUseItemBuffer) 
    71         { 
     70        if ((mItemBufferMode && mQueryModes) != 0) 
     71        { 
     72                int savedQueryModes = mQueryModes; 
     73                mQueryModes = mItemBufferMode; 
     74                 
    7275                PlatformQueryManager::ComputeCameraVisibility(camera, visibleNodes, 
    7376                            visibleGeometry, visiblePatches, relativeVisibility); 
    74  
     77                 
     78                // overlays cause false visibility 
    7579                mViewport->setOverlaysEnabled(false); 
     80                mQueryModes = savedQueryModes; 
    7681        } 
    7782        else 
    … …  
    9398        GtpVisibility::QueryList queryList[2]; 
    9499         
    95         // rendered hierarchy nodes from previous render 
    96         GtpVisibility::HierarchyNodeList *nodeList = mHierarchyInterface->GetRenderedNodes(); 
    97         GtpVisibility::HierarchyNodeList::iterator nodeIt, nodeIt_end = nodeList->end(); 
     100        // rendered visibile hierarchy nodes from previous rendering 
     101        GtpVisibility::HierarchyNodeList *visNodes = mHierarchyInterface->GetVisibleNodes(); 
     102        GtpVisibility::HierarchyNodeList::iterator visNodesIt, visNodesIt_end = visNodes->end(); 
     103 
     104    GtpVisibility::HierarchyNodeList nodeList; 
     105 
     106        if (mQueryModes && NODE_VISIBILITY) 
     107        { 
     108                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt) 
     109                { 
     110                        nodeList.push_back((*visNodesIt)); 
     111                } 
     112        } 
     113 
     114        GtpVisibility::HierarchyNodeList::iterator nodeIt, nodeIt_end = nodeList.end(); 
    98115 
    99116        // vector for storing entities of meshes 
    100117        GtpVisibility::GeometryList geometryList; 
    101118         
    102         // store geometry of the hierarchy node in a geometry list (only once!) 
    103         for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)                 
    104         { 
    105                 mHierarchyInterface->GetNodeGeometryList(*nodeIt, &geometryList, false); 
    106         } 
    107  
     119        // store geometry of the hierarchy nodes in a geometry list 
     120        if (mQueryModes && GEOMETRY_VISIBILITY) 
     121        {        
     122                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt)         
     123                { 
     124                        mHierarchyInterface->GetNodeGeometryList(*visNodesIt, &geometryList, false); 
     125                } 
     126        } 
     127         
    108128        // geometry list iterator 
    109129        GtpVisibility::GeometryList::iterator geometryIt, geometryIt_end = geometryList.end(); 
    … …  
    111131        // vector for storing subentities of meshes 
    112132        GtpVisibility::PatchList patchList; 
     133 
     134        // store patchges of the geometries in a patch list 
     135        if (mQueryModes && PATCH_VISIBILITY) 
     136        { 
     137                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt)         
     138                { 
     139                        GetNodePatchList(*visNodesIt, &patchList); 
     140                } 
     141        } 
     142 
    113143        GtpVisibility::PatchList::iterator patchIt, patchIt_end = patchList.end(); 
    114144 
    … …  
    133163        { 
    134164                //-- queries for hierarchy nodes 
    135                 for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)                 
     165                for (nodeIt = nodeList.begin(); nodeIt != nodeIt_end; ++nodeIt)          
    136166                { 
    137167                        // TODO: DELETE QUERIES FROM PREVIOUS RENDER 
    … …  
    140170 
    141171                //-- queries for geometry: if item buffer, capture only projected visibility 
    142                 for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
    143                 { 
    144                         queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt)); 
     172                if ((mItemBufferMode != GEOMETRY_VISIBILITY) || (i == 1)) 
     173                { 
     174                        for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
     175                        { 
     176                                queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt)); 
     177                        } 
    145178                } 
    146179                 
    147180                //-- queries for patches: if item buffer, capture only projected visibility 
    148                 if (!(mUseItemBuffer && (i == 0))) 
     181                if ((mItemBufferMode != PATCH_VISIBILITY) || (i == 1)) 
    149182                { 
    150183                        for (patchIt = patchList.begin(); patchIt != patchIt_end; ++patchIt) 
    … …  
    162195        GtpVisibility::QueryList::iterator projQueryIt = queryList[1].begin(); 
    163196         
    164         CollectNodeVisibility(visQueryIt, projQueryIt, nodeList, visibleNodes, relativeVisibility); 
    165  
    166         if (mUseItemBuffer) 
    167         { 
    168                 if (relativeVisibility) 
    169                 { 
    170                         CollectRelativePatchVisibilityForItemBuffer(projQueryIt, &patchList, visiblePatches); 
    171                 } 
    172     } 
     197        // collect occlusion queries for hierarchy nodes 
     198        CollectNodeVisibility(visQueryIt, projQueryIt, &nodeList, visibleNodes, relativeVisibility); 
     199 
     200 
     201 
     202        // collect occlusion queries for geometry 
     203        if ((mItemBufferMode == GEOMETRY_VISIBILITY) && relativeVisibility) 
     204        { 
     205                // if visibility was established using the item buffer, 
     206                // the array is organized different (e.g., ordered by id, all possible objects) 
     207                CollectRelativeGeometryVisibilityForItemBuffer(projQueryIt, &geometryList, visibleGeometry); 
     208        } 
     209        else 
     210        { 
     211                CollectGeometryVisibility(visQueryIt, projQueryIt, &geometryList, visibleGeometry,  
     212                                                                  relativeVisibility); 
     213        } 
     214 
     215 
     216        // collect occlusion queries for patches 
     217        if ((mItemBufferMode == PATCH_VISIBILITY) && relativeVisibility) 
     218        { 
     219                CollectRelativePatchVisibilityForItemBuffer(projQueryIt, &patchList, visiblePatches); 
     220        } 
    173221        else 
    174222        { 
    175223                CollectPatchVisibility(visQueryIt, projQueryIt, &patchList, visiblePatches, relativeVisibility); 
    176224        }        
    177          
    178         CollectGeometryVisibility(visQueryIt, projQueryIt, &geometryList, visibleGeometry, relativeVisibility); 
     225 
    179226                 
    180227        //-- reset options 
    … …  
    201248        RemoveDuplicateNodes(visibleNodes); 
    202249         
    203         if (!mUseItemBuffer) 
     250        if (mItemBufferMode != GEOMETRY_VISIBILITY) 
    204251        { 
    205252                RemoveDuplicateGeometry(visibleGeometry); 
     253        } 
     254         
     255        if (mItemBufferMode != PATCH_VISIBILITY) 
     256        { 
     257                RemoveDuplicatePatches(visiblePatches); 
    206258        } 
    207259} 
    … …  
    442494                patchinfo_eq), visiblePatches->end()); 
    443495} 
     496//----------------------------------------------------------------------- 
     497void OcclusionQueriesQueryManager::GetNodePatchList(GtpVisibility::HierarchyNode *node,  
     498                                                                                                        GtpVisibility::PatchList *patchList) 
     499{ 
     500        GtpVisibility::GeometryList geomList; 
     501        mHierarchyInterface->GetNodeGeometryList(node, &geomList, false); 
     502 
     503        // geometry list iterator 
     504        GtpVisibility::GeometryList::iterator geomIt, geomIt_end = geomList.end(); 
     505 
     506        for (geomIt = geomList.begin(); geomIt != geomIt_end; ++geomIt) 
     507        { 
     508                for     (int i = 0; i < (int)(*geomIt)->getNumSubEntities(); ++i) 
     509                { 
     510                        patchList->push_back((*geomIt)->getSubEntity(i)); 
     511                } 
     512        } 
     513} 
     514 
    444515} // namespace Ogre 

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

    r159 r174  
    103103                        octant, mOnlyShadowCasters, mLeavePassesInQueue); 
    104104 
    105                 mRenderedNodes.push_back(node); 
     105                mVisibleNodes.push_back(node); 
    106106        } 
    107107#endif 
    … …  
    167167        } 
    168168} 
     169 
    169170} // namespace Ogre 

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

    r159 r174  
    201201//----------------------------------------------------------------------- 
    202202GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery( 
     203        GtpVisibility::Patch *patch) 
     204{ 
     205        // get next available test id 
     206        GtpVisibility::OcclusionQuery *query = GetNextOcclusionQuery(); 
     207 
     208        //-- the actual query test 
     209        query->BeginQuery(); 
     210         
     211        RenderPatch(patch); 
     212 
     213        query->EndQuery(); 
     214 
     215        return query; 
     216} 
     217//----------------------------------------------------------------------- 
     218GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery( 
    203219        GtpVisibility::Mesh *mesh) 
    204220{ 
    … …  
    269285} 
    270286//----------------------------------------------------------------------- 
     287void PlatformHierarchyInterface::RenderPatch(GtpVisibility::Patch *patch) 
     288{ 
     289        Pass *pass = patch->getTechnique()->getPass(0); 
     290        mSceneManager->setPass(pass); 
     291        mSceneManager->renderSingleObject(patch, pass, false); 
     292} 
     293//----------------------------------------------------------------------- 
    271294SceneManager *PlatformHierarchyInterface::GetSceneManager() 
    272295{ 
    … …  
    278301        return mRenderSystem; 
    279302} 
     303 
    280304} // namespace Ogre 

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

    r173 r174  
    1212//-----------------------------------------------------------------------  
    1313PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
    14                                                                                    Viewport *vp, bool renderPatches): 
    15 QueryManager(hierarchyInterface),  
     14                                                                                   Viewport *vp, int queryModes): 
     15QueryManager(hierarchyInterface, queryModes),  
    1616mViewport(vp),  
    17 mWasInitialised(false), 
    18 mRenderPatches(renderPatches) 
     17mWasInitialised(false) 
    1918{ 
    2019} 
    … …  
    147146        uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy); 
    148147 
    149         int n = mRenderPatches ?  
    150                 (int)visiblePatches->size() : (int)visibleGeometry->size(); 
    151  
    152148        //std::stringstream d; d << "dimx: " << dimx << ", dimy: " << dimy; LogManager::getSingleton().logMessage(d.str()); 
    153149 
    … …  
    163159 
    164160                // if valid id <= add visibility (id values start at 1) 
    165                 if ((id > 0) && (id < n)) 
    166                 { 
    167                         if (mRenderPatches) 
    168                         {        
     161                if (mQueryModes == PATCH_VISIBILITY) 
     162                {        
     163                        if ((id > 0) && (id < (int)visiblePatches->size())) 
     164                        { 
    169165                                ((*visiblePatches)[id]).AddVisibility(1, 0); 
    170166                        } 
    171                         else 
     167                } 
     168                else if (mQueryModes == GEOMETRY_VISIBILITY) 
     169                { 
     170                        if ((id > 0) && (id < (int)visibleGeometry->size())) 
    172171                        { 
    173172                                ((*visibleGeometry)[id]).AddVisibility(1, 0); 
    … …  
    213212                        SubEntity *subEnt = ent->getSubEntity(i); 
    214213 
    215                         if (mRenderPatches) 
     214                        if (mQueryModes == PATCH_VISIBILITY) 
    216215                        { 
    217216                                ++ id; 
    … …  
    223222                } 
    224223                         
    225                 if (!mRenderPatches) 
     224                if (mQueryModes == GEOMETRY_VISIBILITY) 
    226225                { 
    227226                        visibleGeometry->push_back(GtpVisibility::MeshInfo(ent, 0, 0)); 

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

    r158 r174  
    4545        { 
    4646                sceneNode->setLastRendered(sceneNode->lastVisited()); 
    47                 mRenderedNodes.push_back(node); 
     47                mVisibleNodes.push_back(node); 
    4848 
    4949                mSceneManager->_renderSceneNode(mCamera, sceneNode, mLeavePassesInQueue); 

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

    r164 r174  
    737737 
    738738    }// for each priority 
    739 } 
    740 */ 
    741 /*//----------------------------------------------------------------------- 
    742 Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName,  
    743                                                                                                         const String& meshName) 
    744 { 
    745         Entity *ent = SceneManager::createEntity(entityName, meshName); 
    746  
    747         for (int i = 0; i < (int)ent->getNumSubEntities(); ++i) 
    748         { 
    749                 ent->getSubEntity(i)->setId(mCurrentEntityId); 
    750         } 
    751  
    752         // increase counter of entity id values 
    753         ++ mCurrentEntityId; 
    754  
    755         return ent; 
    756739}*/ 
    757740}   // namespace Ogre 

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

    r166 r174  
    1414 
    1515//----------------------------------------------------------------------- 
    16 VisibilityTerrainSceneManager::VisibilityTerrainSceneManager(GtpVisibility:: 
    17                                                                                                                          VisibilityManager *visManager):  
     16VisibilityTerrainSceneManager::VisibilityTerrainSceneManager( 
     17                                                        GtpVisibility::VisibilityManager *visManager):  
    1818mVisibilityManager(visManager),  
    1919mShowVisualization(false), 
    … …  
    752752        { 
    753753                ent->getSubEntity(i)->setId(mCurrentEntityId); 
    754                 //ent->getSubEntity(i)->setId((41 << 16) + (4 << 8) + 60); 
    755                 //ent->getSubEntity(i)->setId((2 << 16) + (4 << 8) + 60); 
    756754        } 
    757755 

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

    r173 r174  
    126126mDelayedQueriesIssued(0.0), 
    127127mDelayedTraversedNodes(0.0), 
    128 mUseItemBuffer(false), 
    129 mRenderPatchesForItemBuffer(false), 
    130128mCurrentObjectType(0), 
    131129mApplication(app), 
    132130mUseAnimation(false), 
    133 mDeleteObjects(false) 
     131mDeleteObjects(false), 
     132mUseItemBuffer(false), 
     133mItemBufferMode(GtpVisibility::QueryManager::PATCH_VISIBILITY) 
    134134{ 
    135135        //mInputDevice = PlatformManager::getSingleton().createInputReader(); 
    … …  
    424424                dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr); 
    425425 
     426        int itemBufferMode = useItemBuffer ? mItemBufferMode : 0; 
     427         
     428        int queryModes = GtpVisibility::QueryManager::PATCH_VISIBILITY;  
     429        queryModes |= GtpVisibility::QueryManager::GEOMETRY_VISIBILITY; 
     430        queryModes |= GtpVisibility::QueryManager::NODE_VISIBILITY; 
     431 
    426432        mQueryManager = new OcclusionQueriesQueryManager(sm->GetHierarchyInterface(), 
    427                         mWindow->getViewport(0), true, useItemBuffer); 
     433                        mWindow->getViewport(0), queryModes, useItemBuffer); 
     434 
    428435        //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false); 
    429436         
    … …  
    10111018 
    10121019        case KC_C: 
    1013                 mRenderPatchesForItemBuffer = !mRenderPatchesForItemBuffer; 
     1020 
     1021                if (mItemBufferMode != GtpVisibility::QueryManager::GEOMETRY_VISIBILITY) 
     1022                        mItemBufferMode = GtpVisibility::QueryManager::GEOMETRY_VISIBILITY; 
     1023                else 
     1024                        mItemBufferMode = GtpVisibility::QueryManager::PATCH_VISIBILITY; 
     1025 
    10141026                break; 
    10151027 

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

    r173 r174  
    224224        bool mUseItemBuffer; 
    225225        bool mUseAnimation; 
    226         bool mRenderPatchesForItemBuffer; 
     226         
     227        int mItemBufferMode; 
    227228 
    228229        Real mVizCameraHeight; 
Note: See TracChangeset for help on using the changeset viewer.