Changeset 2505 for GTP/trunk/Lib/Vis


Ignore:
Timestamp:
07/03/07 15:23:55 (17 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE
Files:
6 edited

Legend:

Unmodified
Added
Removed

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

    r2280 r2505  
    2121        OcclusionQueriesQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
    2222                                                                 Viewport *vp, 
    23                                                                  int queryModes,  
    24                                                                  int itemBufferMode):   
    25         PlatformQueryManager(hierarchyInterface, vp, queryModes),  
    26         mItemBufferMode(itemBufferMode) 
     23                                                                 int queryModes):   
     24        PlatformQueryManager(hierarchyInterface, vp, queryModes) 
    2725        {} 
    2826 
    … …  
    5957                                                           bool relativeVisibility); 
    6058 
    61         void CollectRelativeGeometryVisibilityForItemBuffer(GtpVisibility::QueryList::iterator &projQueryIt, 
    62                                                                                                                 GeometryVector *geometryList,  
    63                                                                                                                 MeshInfoContainer *visibleGeometry); 
    64  
    65         void CollectRelativePatchVisibilityForItemBuffer(GtpVisibility::QueryList::iterator &projQueryIt, 
    66                                                                                                          PatchVector *patchList,  
    67                                                                                                          PatchInfoContainer *visiblePatches); 
    6859 
    6960        void CollectPatchVisibility(GtpVisibility::QueryList::iterator &visQueryIt,  
    … …  
    8475                                                                  PatchVector *patchList); 
    8576 
    86         int mItemBufferMode; 
    8777}; 
    8878 

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

    r2280 r2505  
    5252protected: 
    5353 
    54 #ifdef ITEM_BUFFER 
    55         void CollectItemBufferResults(MeshInfoContainer *visibleGeometry, 
    56                                                                   PatchInfoContainer *visiblePatches); 
    57  
    58         void InitItemBuffer(MeshInfoContainer *visibleGeometry, 
    59                                                 PatchInfoContainer *visiblePatches); 
    60 #endif // ITEM_BUFFER 
    61  
    6254        Viewport *mViewport; 
    6355        bool mWasInitialised; 

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

    r2502 r2505  
    22062206                                                                                                                   const bool nodeVisibility) 
    22072207{ 
    2208         const int itemBufferMode = 0; 
    22092208        const bool relativeVisibility = false; 
    22102209        const bool approximateVisibility = false; 
    … …  
    22202219                new OcclusionQueriesQueryManager(mHierarchyInterface, 
    22212220                                                                                 vp, 
    2222                                                                                  queryModes,  
    2223                                                                                  itemBufferMode); 
     2221                                                                                 queryModes); 
    22242222 
    22252223        mVisibilityManager->SetQueryManager(queryManager); 
    … …  
    23972395        // don't have to fill queue, just render depth 
    23982396        const bool fillQueue = false; 
    2399  
    24002397        RenderHierarchicalCulling(fillQueue); 
    24012398    
    … …  
    24952492        mBoxes.clear(); 
    24962493 
    2497         const int itemBufferMode = 0; 
    24982494        const bool relativeVisibility = false; 
    24992495        bool approximateVisibility = false; 
    … …  
    25182514                new OcclusionQueriesQueryManager(mHierarchyInterface, 
    25192515                                                                                 cam->getViewport(), 
    2520                                                                                  queryModes,  
    2521                                                                                  itemBufferMode); 
     2516                                                                                 queryModes); 
    25222517 
    25232518        mVisibilityManager->SetQueryManager(queryManager); 
    … …  
    25462541        } 
    25472542                 
    2548         if (1) 
     2543        if (0) 
    25492544        { 
    25502545                std::stringstream d;  
    … …  
    25632558                //////////// 
    25642559                //-- apply queries on geometry level 
    2565  
    25662560                AddVisibleNodeGeometryToQueue(visibleNodes, cam); 
    25672561        } 

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

    r2280 r2505  
    1919                                                        int queryModes, 
    2020                                                        int itemBufferMode) 
    21 :PlatformQueryManager(hierarchyInterface, vp, queryModes),  
    22 mItemBufferMode(itemBufferMode) 
     21:PlatformQueryManager(hierarchyInterface, vp, queryModes) 
    2322{ 
    2423}*/ 
    … …  
    3938        bool overlayEnabled = mViewport->getOverlaysEnabled(); 
    4039 
    41         //mItemBufferMode = 0; 
    42         if (0 && (mItemBufferMode && mQueryModes) != 0) 
    43         { 
    44                 /////////// 
    45                 //-- render scene with item buffer (ids are used as color codes) 
    46  
    47                 int savedQueryModes = mQueryModes; 
    48                 mQueryModes = mItemBufferMode; 
    49                  
    50                 PlatformQueryManager::ComputeCameraVisibility(camera,  
    51                                                                                                           visibleNodes, 
    52                                                                                                           visibleGeometry,  
    53                                                                                                           visiblePatches,  
    54                                                                                                           relativeVisibility, 
    55                                                                                                           approximateVisibility); 
    56                  
    57                 // overlays cause false visibility 
    58                 mViewport->setOverlaysEnabled(false); 
    59                 mQueryModes = savedQueryModes; 
    60         } 
    61         else 
    62         { 
    63                 // const_cast allowed because camera is not changed in renderScene 
    64                 Camera *pCam = const_cast<Camera *>(&camera);  
    65                 mViewport->setOverlaysEnabled(false); 
    66  
    67                 //////////////////////// 
    68                 //-- Render scene to get conservative visibility and fill depth buffer 
    69  
    70                 OcclusionCullingSceneManager *occlusionSceneMgr =  
    71                         static_cast<OcclusionCullingSceneManager *>(pfHierarchyInterface->GetSceneManager()); 
    72  
    73                 // no visibility manager available => no visibility scene manager, return 
    74                 GtpVisibility::VisibilityManager *visManager = NULL;     
    75                  
    76                 if (!occlusionSceneMgr->getOption("VisibilityManager", &visManager)) 
    77                 { 
    78                         Ogre::LogManager::getSingleton().logMessage("no vismanager found"); 
    79                         return; 
    80                 } 
    81  
    82                 // use stop and wait culling for from view point queries because probably 
    83                 // no temporal coherence 
    84                 GtpVisibility::VisibilityEnvironment::CullingManagerType occlusionType =  
    85                         visManager->GetCullingManagerType(); 
    86  
    87                 visManager->SetCullingManager(GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING); 
    88  
    89                 if (1) 
    90                         occlusionSceneMgr->RenderDepthForQuery(pCam, mViewport); 
    91                 else 
    92                         pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
    93  
    94                 visManager->SetCullingManager(occlusionType); 
    95         } 
     40        // const_cast allowed because camera is not changed in renderScene 
     41        Camera *pCam = const_cast<Camera *>(&camera);  
     42        mViewport->setOverlaysEnabled(false); 
     43 
     44        //////////////////////// 
     45        //-- Render scene to get conservative visibility and fill depth buffer 
     46 
     47        OcclusionCullingSceneManager *occlusionSceneMgr =  
     48                static_cast<OcclusionCullingSceneManager *>(pfHierarchyInterface->GetSceneManager()); 
     49 
     50        // no visibility manager available => no visibility scene manager, return 
     51        GtpVisibility::VisibilityManager *visManager = NULL;     
     52 
     53        if (!occlusionSceneMgr->getOption("VisibilityManager", &visManager)) 
     54        { 
     55                Ogre::LogManager::getSingleton().logMessage("no vismanager found"); 
     56                return; 
     57        } 
     58 
     59        // use stop and wait culling for from view point queries because 
     60        // of issues with temporal coherence 
     61        GtpVisibility::VisibilityEnvironment::CullingManagerType occlusionType =  
     62                visManager->GetCullingManagerType(); 
     63 
     64        visManager->SetCullingManager(GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING); 
     65 
     66        // rendert the scene once to fill depth buffer and to get a first approximation 
     67        // of visible objects 
     68        occlusionSceneMgr->RenderDepthForQuery(pCam, mViewport); 
     69 
     70        // reset occlusion culling manager 
     71        visManager->SetCullingManager(occlusionType); 
    9672 
    9773         
    … …  
    164140        // for relative visibility we need 2 rendering passes 
    165141        int n = relativeVisibility ? 2 : 1; 
    166         if (mItemBufferMode > 0) 
    167                 LogManager::getSingleton().logMessage("using item buffer"); 
     142         
    168143 
    169144        for (int i = 0; i < n; ++ i) 
    170145        { 
    171                 //-- queries for hierarchy nodes 
     146                //-- query the hierarchy nodes 
    172147                for (nodeIt = nodeList.begin(); nodeIt != nodeIt_end; ++ nodeIt)                 
    173148                { 
    174149                        // TODO: DELETE QUERIES FROM PREVIOUS RENDER 
    175150                        bool intersects = false; 
    176  
    177151                        pfHierarchyInterface->CheckFrustumVisible(*nodeIt, intersects); 
    178152 
    179                         // always push back if only checking approximate visibility or intersects 
     153                        // always add node if only checking for approximate visibility or intersects 
    180154                        if (approximateVisibility || intersects) 
    181155                        { 
    … …  
    195169                /////////////// 
    196170                //-- queries for geometry 
    197                  
    198                 // note: for item buffer we can capture only projected visibility 
    199  
    200                 if ((mItemBufferMode != GEOMETRY_VISIBILITY) || (i == 1)) 
    201                 {                        
    202                         for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++ geometryIt) 
    203                         { 
    204                                 if (approximateVisibility) 
    205                                 { 
    206                                         // no more information available 
    207                                         const int visPixels = 1; 
    208                                         const int projPixels = 1; 
    209  
    210                                         visibleGeometry->push_back(MeshInfo(*geometryIt, visPixels, projPixels)); 
    211                                 } 
    212                                 else 
    213                                 { 
    214                                         queryList[i].push_back(pfHierarchyInterface->IssueMeshOcclusionQuery(*geometryIt)); 
    215                                 } 
    216                         } 
    217                 } 
    218                  
     171 
     172                for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++ geometryIt) 
     173                { 
     174                        if (approximateVisibility) 
     175                        { 
     176                                // no more information available 
     177                                const int visPixels = 1; 
     178                                const int projPixels = 1; 
     179 
     180                                visibleGeometry->push_back(MeshInfo(*geometryIt, visPixels, projPixels)); 
     181                        } 
     182                        else 
     183                        { 
     184                                queryList[i].push_back(pfHierarchyInterface->IssueMeshOcclusionQuery(*geometryIt)); 
     185                        } 
     186                } 
     187 
    219188                /////////////// 
    220189                //-- queries for patches 
    221190 
    222                 if ((mItemBufferMode != PATCH_VISIBILITY) || (i == 1)) 
    223                 { 
    224                         for (patchIt = patchList.begin(); patchIt != patchIt_end; ++patchIt) 
    225                         { 
    226                                 if (approximateVisibility) 
    227                                 { 
    228                                         // no more information available 
    229                                         const int visPixels = 1; 
    230                                         const int projPixels = 1; 
    231  
    232                                         visiblePatches->push_back(PatchInfo(*patchIt, visPixels, projPixels)); 
    233                                 } 
    234                                 else 
    235                                 { 
    236                                         queryList[i].push_back(pfHierarchyInterface->IssuePatchOcclusionQuery(*patchIt)); 
    237                                 } 
    238                         } 
    239                 } 
    240  
     191                for (patchIt = patchList.begin(); patchIt != patchIt_end; ++patchIt) 
     192                { 
     193                        if (approximateVisibility) 
     194                        { 
     195                                // there is not more information available 
     196                                const int visPixels = 1; 
     197                                const int projPixels = 1; 
     198 
     199                                visiblePatches->push_back(PatchInfo(*patchIt, visPixels, projPixels)); 
     200                        } 
     201                        else 
     202                        { 
     203                                queryList[i].push_back(pfHierarchyInterface->IssuePatchOcclusionQuery(*patchIt)); 
     204                        } 
     205                } 
     206 
     207                // the second time we have to render against the cleared depth buffer to obtain 
     208                // projected pixels 
    241209                pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_DEPTH); 
    242210        } 
     211 
    243212 
    244213        ///////////////  
    … …  
    248217        GtpVisibility::QueryList::iterator projQueryIt = queryList[1].begin(); 
    249218         
    250         // collect occlusion queries for hierarchy nodes 
    251         CollectNodeVisibility(visQueryIt,  
    252                                                   projQueryIt,  
    253                                                   &nodeList,  
    254                                                   visibleNodes,  
    255                                                   relativeVisibility); 
    256  
    257  
    258         // collect occlusion queries for geometry 
    259         if ((mItemBufferMode == GEOMETRY_VISIBILITY) && relativeVisibility) 
    260         { 
    261                 // if visibility was established using the item buffer, 
    262                 // the array is organized different (e.g., ordered by id, all possible objects) 
    263                 CollectRelativeGeometryVisibilityForItemBuffer(projQueryIt,  
    264                                                                                                            &geometryList,  
    265                                                                                                            visibleGeometry); 
    266         } 
    267         else if (mItemBufferMode != GEOMETRY_VISIBILITY) 
    268         { 
     219        if (1) 
     220        {        
     221                // collect occlusion queries for hierarchy nodes 
     222                CollectNodeVisibility(visQueryIt,  
     223                        projQueryIt,  
     224                        &nodeList,  
     225                        visibleNodes,  
     226                        relativeVisibility); 
     227        } 
     228 
     229        if (1) 
     230        {        
    269231                CollectGeometryVisibility(visQueryIt,  
    270                                                                   projQueryIt,  
    271                                                                   &geometryList,  
    272                                                                   visibleGeometry,  
    273                                                                   relativeVisibility); 
    274         } 
    275  
    276  
    277         // collect occlusion queries for patches 
    278         if ((mItemBufferMode == PATCH_VISIBILITY) && relativeVisibility) 
    279         { 
    280                 CollectRelativePatchVisibilityForItemBuffer(projQueryIt,  
    281                                                                                                         &patchList,  
    282                                                                                                         visiblePatches); 
    283         } 
    284         else if (mItemBufferMode != PATCH_VISIBILITY) 
    285         { 
     232                        projQueryIt,  
     233                        &geometryList,  
     234                        visibleGeometry,  
     235                        relativeVisibility); 
     236        } 
     237 
     238        if (1) 
     239        { 
     240                // collect occlusion queries for patches 
    286241                CollectPatchVisibility(visQueryIt,  
    287                                                            projQueryIt,  
    288                                                            &patchList,  
    289                                                            visiblePatches,  
    290                                                            relativeVisibility); 
    291         }        
     242                        projQueryIt,  
     243                        &patchList,  
     244                        visiblePatches,  
     245                        relativeVisibility); 
     246        } 
     247 
    292248 
    293249        //////////// 
    … …  
    321277        // (duplicates occur if an object is on the edge of the viewport) 
    322278        RemoveDuplicateNodes(visibleNodes); 
    323  
    324         if (mItemBufferMode != GEOMETRY_VISIBILITY) 
    325         { 
    326                 RemoveDuplicateGeometry(visibleGeometry); 
    327         } 
    328  
    329         if (mItemBufferMode != PATCH_VISIBILITY) 
    330         { 
    331                 RemoveDuplicatePatches(visiblePatches); 
    332         } 
     279        RemoveDuplicateGeometry(visibleGeometry); 
     280        RemoveDuplicatePatches(visiblePatches); 
    333281} 
    334282//------------------------------------------------------------------------ 
    … …  
    374322} 
    375323//----------------------------------------------------------------------- 
    376 void OcclusionQueriesQueryManager::CollectRelativeGeometryVisibilityForItemBuffer( 
    377                                                                         GtpVisibility::QueryList::iterator &projQueryIt, 
    378                                                                         GeometryVector *geometryList,  
    379                                                                         MeshInfoContainer *visibleGeometry) 
    380 { 
    381         GeometryVector::iterator geometryIt; 
    382  
    383         //-- queries for geometry 
    384         for (geometryIt = geometryList->begin(); geometryIt != geometryList->end(); ++ geometryIt) 
    385         { 
    386                 unsigned int projectedPixels = 0; 
    387  
    388                 (*projQueryIt)->GetQueryResult(projectedPixels, true); 
    389  
    390                 ++projQueryIt; 
    391                 int id = (*geometryIt)->getSubEntity(0)->getId(); 
    392  
    393                 if ((id > 0) && (id < (int)visibleGeometry->size())) 
    394                 { 
    395                         (*visibleGeometry)[id].AddVisibility(0, projectedPixels); 
    396                 } 
    397         } 
    398 } 
    399 //----------------------------------------------------------------------- 
    400 void OcclusionQueriesQueryManager::CollectRelativePatchVisibilityForItemBuffer( 
    401                                                                         GtpVisibility::QueryList::iterator &projQueryIt, 
    402                                                                         PatchVector *patchList,  
    403                                                                         PatchInfoContainer *visiblePatches) 
    404 { 
    405         PatchVector::iterator patchIt; 
    406  
    407         //-- queries for geometry 
    408         for (patchIt = patchList->begin(); patchIt != patchList->end(); ++ patchIt) 
    409         { 
    410                 unsigned int projectedPixels = 0; 
    411  
    412                 (*projQueryIt)->GetQueryResult(projectedPixels, true); 
    413  
    414                 ++projQueryIt; 
    415                 int id = (*patchIt)->getId(); 
    416  
    417                 if ((id > 0) && (id < (int)visiblePatches->size())) 
    418                 { 
    419                         (*visiblePatches)[id].AddVisibility(0, projectedPixels); 
    420                 } 
    421         } 
    422 } 
    423 //----------------------------------------------------------------------- 
    424324void  OcclusionQueriesQueryManager::CollectGeometryVisibility( 
    425325                                                        GtpVisibility::QueryList::iterator &visQueryIt,  

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

    r2455 r2505  
    1212namespace Ogre { 
    1313 
    14  
     14//----------------------------------------------------------------------- 
     15void PlatformQueryManager::SetViewport(Viewport *vp) 
     16{ 
     17        mViewport = vp; 
     18} 
    1519//----------------------------------------------------------------------- 
    1620void PlatformQueryManager::ComputeFromPointVisibility( 
    … …  
    6569                // prevent from initialising geometry / node array again 
    6670                if (dir > 0) 
    67                 { 
    6871                        mWasInitialised = true; 
    69                 } 
    7072 
    7173                ComputeCameraVisibility(*cam,  
    … …  
    114116        //pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH); 
    115117 
    116 #ifdef ITEM_BUFFER 
    117         // initialise item buffer (if not already initialised) 
    118         InitItemBuffer(visibleGeometry, visiblePatches); 
    119  
    120         ////////// 
    121         //-- render scene with item buffer (i.e., objects with their id as color codes) 
    122  
    123         // enable item buffer (must be provided by scene manager) 
    124         bool useItemBuffer = true; 
    125         sm->setOption("UseItemBuffer", &useItemBuffer); 
    126 #endif // ITEM_BUFFER 
    127  
    128         sm->_renderScene(pCam, mViewport, false); // render item buffer 
     118        // render scene once to fill depth buffer 
     119        sm->_renderScene(pCam, mViewport, false);  
    129120    
    130 #ifdef ITEM_BUFFER 
    131         ///////// 
    132         //-- collect results 
    133         CollectItemBufferResults(visibleGeometry, visiblePatches); 
    134  
    135         ///////// 
    136         //-- reset state 
    137         useItemBuffer = false; // don't need item buffer anymore 
    138         sm->setOption("UseItemBuffer", &useItemBuffer); 
    139 #endif // ITEM_BUFFER 
    140  
    141         mWasInitialised = false; // reset initialised - flag 
     121        mWasInitialised = false; // reset flag 
    142122        mViewport->setOverlaysEnabled(overlayEnabled); // reset old overlay status 
    143123        mViewport->setBackgroundColour(bg); // reset background color 
    144124} 
    145 #ifdef ITEM_BUFFER 
    146 //----------------------------------------------------------------------- 
    147 void PlatformQueryManager::CollectItemBufferResults( 
    148                                 MeshInfoContainer *visibleGeometry, 
    149                                 PatchInfoContainer *visiblePatches) 
    150 { 
    151         int dimx = 0; 
    152         int dimy = 0; 
    153125 
    154         // copy frame buffer  
    155         uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy); 
    156  
    157         // loop through frame buffer and collect visible pixels 
    158         for (int idx = 0; idx < dimy * dimx * 3; idx += 3) 
    159         { 
    160                 //-- decode color code to receive id 
    161                 int id = buf[idx] << 16; 
    162                 id += buf[idx + 1] << 8; 
    163                 id += buf[idx + 2]; 
    164  
    165                 // if valid id <= add visibility (id values start at 1) 
    166                 if (mQueryModes == PATCH_VISIBILITY) 
    167                 {        
    168                         if ((id > 0) && (id < (int)visiblePatches->size())) 
    169                         { 
    170                                 ((*visiblePatches)[id]).AddVisibility(1, 0); 
    171                         } 
    172                 } 
    173                 else if (mQueryModes == GEOMETRY_VISIBILITY) 
    174                 { 
    175                         if ((id > 0) && (id < (int)visibleGeometry->size())) 
    176                         { 
    177                                 ((*visibleGeometry)[id]).AddVisibility(1, 0); 
    178                         } 
    179                 } 
    180         } 
    181  
    182         delete [] buf; 
    183 } 
    184  
    185 //----------------------------------------------------------------------- 
    186 void PlatformQueryManager::InitItemBuffer( 
    187                                 MeshInfoContainer *visibleGeometry, 
    188                                 PatchInfoContainer *visiblePatches) 
    189 { 
    190         if (mWasInitialised) 
    191                 return; 
    192  
    193         mWasInitialised = true; 
    194  
    195         SceneManager *sm =  
    196                 //static_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager(); 
    197                 static_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager(); 
    198  
    199         SceneManager::EntityIterator it = sm->getEntityIterator(); 
    200  
    201         // TODO: make the function more efficient 
    202  
    203         visibleGeometry->clear(); 
    204         visiblePatches->clear(); 
    205  
    206         int id = 0; 
    207  
    208         /* We can either use patches or meshes. If patches are used, an unique id must 
    209            be given each patch. Otherwise the same id must be given to all patches belonging 
    210            to the same mesh. 
    211     */ 
    212         while (it.hasMoreElements()) 
    213         { 
    214                 Entity *ent = it.getNext(); 
    215  
    216                 for (int i = 0; i < (int)ent->getNumSubEntities(); ++i) 
    217                 { 
    218                         SubEntity *subEnt = ent->getSubEntity(i); 
    219  
    220                         if (mQueryModes == PATCH_VISIBILITY) 
    221                         { 
    222                                 ++ id; 
    223                                 visiblePatches->push_back(GtpVisibility::PatchInfo(subEnt, 0, 0)); 
    224                         } 
    225                                  
    226                         subEnt->setId(id); 
    227                         //subEnt->setId((41 << 16) + (4 << 8) + 60); 
    228                 } 
    229                          
    230                 if (mQueryModes == GEOMETRY_VISIBILITY) 
    231                 { 
    232                         visibleGeometry->push_back(GtpVisibility::MeshInfo(ent, 0, 0)); 
    233                         ++ id; 
    234                 } 
    235         } 
    236 } 
    237 #endif // ITEM_BUFFER 
    238 //----------------------------------------------------------------------- 
    239 void PlatformQueryManager::SetViewport(Viewport *vp) 
    240 { 
    241         mViewport = vp; 
    242 } 
    243126} // namespace Ogre 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/Plugin_VisibilitySceneManager.vcproj

    r2353 r2505  
    114114                                AdditionalLibraryDirectories="&quot;$(OGRE_PATH)\PlugIns\OctreeSceneManager\bin\$(ConfigurationName)&quot;;&quot;$(OGRE_PATH)\OgreMain\lib\$(ConfigurationName)&quot;;&quot;$(OGRE_PATH)\Samples\Common\CEGUIRenderer\lib&quot;;&quot;$(OGRE_PATH)\Dependencies\lib\$(ConfigurationName)&quot;;&quot;..\..\..\Preprocessing\lib\$(ConfigurationName)&quot;;..\..\..\..\..\..\..\NonGTP\Xerces\xercesc\lib;..\..\..\Preprocessing\src\GL;..\..\..\..\..\..\..\NonGTP\Zlib\lib;&quot;..\..\lib\$(ConfigurationName)&quot;;&quot;..\..\..\..\..\Lib\Vis\OnlineCullingCHC\IVReader\lib\$(ConfigurationName)&quot;;&quot;..\..\..\..\..\Lib\Vis\OnlineCullingCHC\ObjReader\lib\$(ConfigurationName)&quot;" 
    115115                                ModuleDefinitionFile="..\misc\OgreVisibilitySceneManager.def" 
    116                                 GenerateDebugInformation="FALSE" 
     116                                GenerateDebugInformation="TRUE" 
    117117                                SubSystem="2" 
    118118                                OptimizeReferences="2" 
Note: See TracChangeset for help on using the changeset viewer.