Changeset 173 for trunk


Ignore:
Timestamp:
07/13/05 18:28:40 (19 years ago)
Author:
mattausch
Message:

did some code cleanup

Location:
trunk/VUT
Files:
1 deleted
8 edited

Legend:

Unmodified
Added
Removed

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

    r171 r173  
    6868        void RemoveDuplicateNodes(InfoContainer<GtpVisibility::NodeInfo> *visibleNodes); 
    6969        void RemoveDuplicateGeometry(InfoContainer<GtpVisibility::MeshInfo> *visibleMesh); 
     70        void RemoveDuplicatePatches(InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
    7071 
    7172        bool mUseItemBuffer; 

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

    r171 r173  
    4545protected: 
    4646 
     47        void CollectItemBufferResults( 
     48                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     49                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
     50 
    4751        void InitItemBuffer(InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    4852                                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 

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

    r171 r173  
    2222} 
    2323//----------------------------------------------------------------------- 
     24inline bool patchinfo_eq(const GtpVisibility::PatchInfo &info1, const GtpVisibility::PatchInfo &info2)  
     25{  
     26        return info1.GetPatch() == info2.GetPatch();  
     27} 
     28//----------------------------------------------------------------------- 
    2429inline bool nodeinfo_lower(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
    2530{  
    … …  
    3136        return info1.GetMesh() < info2.GetMesh();  
    3237} 
    33  
     38//----------------------------------------------------------------------- 
     39inline bool patchinfo_lower(const GtpVisibility::PatchInfo &info1, const GtpVisibility::PatchInfo &info2)  
     40{  
     41        return info1.GetPatch() < info2.GetPatch();  
     42} 
    3443 
    3544 
    … …  
    100109        GtpVisibility::GeometryList::iterator geometryIt, geometryIt_end = geometryList.end(); 
    101110 
     111        // vector for storing subentities of meshes 
     112        GtpVisibility::PatchList patchList; 
     113        GtpVisibility::PatchList::iterator patchIt, patchIt_end = patchList.end(); 
    102114 
    103115        // to obtain the correct number of projected pixels, depth write must be disabled 
    … …  
    128140 
    129141                //-- 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)); 
     145                } 
     146                 
     147                //-- queries for patches: if item buffer, capture only projected visibility 
    130148                if (!(mUseItemBuffer && (i == 0))) 
    131149                { 
    132                         for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
     150                        for (patchIt = patchList.begin(); patchIt != patchIt_end; ++patchIt) 
    133151                        { 
    134                                 queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt)); 
     152                                queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*patchIt)); 
    135153                        } 
    136154                } 
    … …  
    150168                if (relativeVisibility) 
    151169                { 
    152                         CollectRelativeGeometryVisibilityForItemBuffer(projQueryIt, &geometryList, visibleGeometry); 
     170                        CollectRelativePatchVisibilityForItemBuffer(projQueryIt, &patchList, visiblePatches); 
    153171                } 
    154172    } 
    155173        else 
    156174        { 
    157                 CollectGeometryVisibility(visQueryIt, projQueryIt, &geometryList,  
    158                         visibleGeometry, relativeVisibility); 
    159             //CollectPatchVisibility(patchList, visiblePatches); 
    160         } 
    161  
    162  
     175                CollectPatchVisibility(visQueryIt, projQueryIt, &patchList, visiblePatches, relativeVisibility); 
     176        }        
     177         
     178        CollectGeometryVisibility(visQueryIt, projQueryIt, &geometryList, visibleGeometry, relativeVisibility); 
     179                 
    163180        //-- reset options 
    164181        enableDepthWrite = true; 
    … …  
    397414                meshinfo_eq), visibleGeometry->end()); 
    398415} 
    399  
     416//----------------------------------------------------------------------- 
     417void  OcclusionQueriesQueryManager::RemoveDuplicatePatches( 
     418                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches) 
     419{ 
     420        sort(visiblePatches->begin(), visiblePatches->end(), patchinfo_lower); 
     421         
     422        InfoContainer<GtpVisibility::PatchInfo>::iterator visiblePatchIt, 
     423                        visiblePatchIt_end = visiblePatches->end(); 
     424 
     425        GtpVisibility::PatchInfo *patchInfo = NULL; 
     426 
     427        for (visiblePatchIt = visiblePatches->begin(); visiblePatchIt != visiblePatchIt_end;  
     428                ++visiblePatchIt) 
     429        { 
     430                if (!patchInfo || (patchInfo->GetPatch() != (*visiblePatchIt).GetPatch())) 
     431                { 
     432                        patchInfo = &(*visiblePatchIt); 
     433                } 
     434                else // info points to same mesh, just add visibility 
     435                { 
     436                        patchInfo->AddVisibility(*visiblePatchIt); 
     437                } 
     438        } 
     439 
     440        // physically delete duplicates 
     441        visiblePatches->erase(std::unique(visiblePatches->begin(), visiblePatches->end(),  
     442                patchinfo_eq), visiblePatches->end()); 
     443} 
    400444} // namespace Ogre 

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

    r171 r173  
    1616mViewport(vp),  
    1717mWasInitialised(false), 
    18 mRenderPatches(false) 
     18mRenderPatches(renderPatches) 
    1919{ 
    2020} 
    … …  
    125125 
    126126        //-- collect results 
    127  
     127        CollectItemBufferResults(visibleGeometry, visiblePatches); 
     128 
     129        //-- reset options 
     130 
     131        useItemBuffer = false; // don't need item buffer anymore 
     132        sm->setOption("UseItemBuffer", &useItemBuffer); 
     133 
     134        mWasInitialised = false; // reset initialised - flag 
     135        mViewport->setOverlaysEnabled(overlayEnabled); // reset old overlay status 
     136        mViewport->setBackgroundColour(bg); // reset background color 
     137} 
     138//----------------------------------------------------------------------- 
     139void PlatformQueryManager::CollectItemBufferResults( 
     140                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     141                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches) 
     142{ 
    128143        int dimx = 0; 
    129144        int dimy = 0; 
    … …  
    151166                { 
    152167                        if (mRenderPatches) 
    153                         { 
     168                        {        
    154169                                ((*visiblePatches)[id]).AddVisibility(1, 0); 
    155170                        } 
    … …  
    161176        } 
    162177 
    163  
    164         //-- reset options 
    165  
    166         useItemBuffer = false; // don't need item buffer anymore 
    167         sm->setOption("UseItemBuffer", &useItemBuffer); 
    168  
    169         mWasInitialised = false; // reset initialised - flag 
    170         mViewport->setOverlaysEnabled(overlayEnabled); // reset old overlay status 
    171         mViewport->setBackgroundColour(bg); // reset background color 
    172  
    173         delete [] buf;  // delete copy of the frame buffer 
    174 } 
     178        delete [] buf; 
     179} 
     180 
    175181//----------------------------------------------------------------------- 
    176182void PlatformQueryManager::InitItemBuffer( 
    … …  
    215221                        subEnt->setId(id); 
    216222                        //subEnt->setId((41 << 16) + (4 << 8) + 60); 
    217                         //subEnt->setId((2 << 16) + (4 << 8) + 60); 
    218223                } 
    219224                         

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

    r171 r173  
    1212#include "TestCullingTerrainApplication.h" 
    1313 
     14 
     15//-- captions for overlays 
     16String TerrainFrameListener::msAlgorithmCaptions[] =  
     17{ 
     18        "View Frustum Culling",  
     19        "Stop and Wait Culling",  
     20        "Coherent Hierarchical Culling" 
     21}; 
     22 
     23String TerrainFrameListener::msQueryTypeCaptions[] =  
     24{ 
     25        "from camera",  
     26        "from viewpoint" 
     27}; 
     28 
     29String TerrainFrameListener::msQueryRelativeVisCaptions[] =  
     30{ 
     31        "visible pixels",  
     32        "relative visibility" 
     33}; 
     34 
     35String TerrainFrameListener::msQueryMethodCaptions[] =  
     36{ 
     37        "occlusion queries",  
     38        "item buffer" 
     39}; 
     40 
     41Real TerrainFrameListener::msObjectTerrainOffsets[] =  
     42{ 
     43        0, 
     44        7, 
     45        0 
     46}; 
     47 
     48Real TerrainFrameListener::msObjectScales[] =  
     49{ 
     50        0.1, 
     51        0.6, 
     52        0.07 
     53}; 
     54 
     55String TerrainFrameListener::msObjectCaptions[] = 
     56{ 
     57        "robot", 
     58        "athene", 
     59        //"tree2", 
     60        //"HongKong_Tower", 
     61        "ninja" 
     62        //"ogrehead" 
     63}; 
     64 
    1465// output file for frame info 
    1566const char* frames_out_filename = "frame.out"; 
    … …  
    1768const char* objects_out_filename = "objects.out"; 
    1869 
    19  
    20 // --- captions for overlays 
    21  
    22 String currentAlgorithmCaptions[GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS] =  
    23 { 
    24         "View Frustum Culling",  
    25         "Stop and Wait Culling",  
    26         "Coherent Hierarchical Culling" 
    27 }; 
    28  
    29 String queryTypeCaptions[] =  
    30 { 
    31         "from camera",  
    32         "from viewpoint" 
    33 }; 
    34  
    35 String queryRelativeVisCaptions[] =  
    36 { 
    37         "visible pixels",  
    38         "relative visibility" 
    39 }; 
    40  
    41 String queryMethodCaptions[] =  
    42 { 
    43         "occlusion queries",  
    44         "item buffer" 
    45 }; 
    46  
    47 Real currentObjectTerrainOffsets[] =  
    48 { 
    49         0, 
    50         7, 
    51         0 
    52 }; 
    53 Real currentObjectScales[] =  
    54 { 
    55         0.1, 
    56         0.1, 
    57         0.07 
    58 }; 
    5970 
    6071//----------------------------------------------------------------------- 
    … …  
    210221                 mCurrentObject = mTerrainContentGenerator->GenerateSceneObject( 
    211222                         mouseRay.getOrigin()/*queryResult*/, Vector3(val, 0, 0),  
    212                          mApplication->getCurrentObjectCaption(mCurrentObjectType)); 
     223                         msObjectCaptions[mCurrentObjectType]); 
    213224                 
    214225         mLMouseDown = true;  
    … …  
    281292                 { 
    282293                         // apply offset so object is ON terrain 
    283                          queryResult.y += currentObjectTerrainOffsets[mCurrentObjectType]; 
     294                         queryResult.y += msObjectTerrainOffsets[mCurrentObjectType]; 
    284295                         mCurrentObject->setPosition(queryResult); 
    285296                 } 
    … …  
    414425 
    415426        mQueryManager = new OcclusionQueriesQueryManager(sm->GetHierarchyInterface(), 
    416                         mWindow->getViewport(0), false, useItemBuffer); 
     427                        mWindow->getViewport(0), true, useItemBuffer); 
    417428        //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false); 
    418429         
    … …  
    437448                 
    438449        std::stringstream d;  
    439         d << queryTypeCaptions[fromPoint ?  1 : 0].c_str() << " " 
    440           << queryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str() << " " 
    441       << queryMethodCaptions[useItemBuffer ? 1 : 0].c_str(); 
     450        d << msQueryTypeCaptions[fromPoint ?  1 : 0].c_str() << " " 
     451          << msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str() << " " 
     452      << msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str(); 
    442453        LogManager::getSingleton().logMessage(d.str()); 
    443454 
    … …  
    515526                 
    516527                sprintf(str, ": %s, %s, %s",  
    517                                 queryTypeCaptions[fromPoint ?  1 : 0].c_str(), 
    518                                 queryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str(), 
    519                                 queryMethodCaptions[useItemBuffer ? 1 : 0].c_str()); 
     528                                msQueryTypeCaptions[fromPoint ?  1 : 0].c_str(), 
     529                                msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str(), 
     530                                msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str()); 
    520531 
    521532                mQueryTypeInfo->setCaption(str); 
    … …  
    635646                //-- write out stats for recorded walkthrough 
    636647                std::stringstream d; 
    637                 d << "Algorithm: " << currentAlgorithmCaptions[mCurrentAlgorithm] << "\n" 
     648                d << "Algorithm: " << msAlgorithmCaptions[mCurrentAlgorithm] << "\n" 
    638649                  //<< "avg. FPS: " << mWindow->getAverageFPS() << "\n" 
    639650                  << "avg. FPS: " << avgFps << "\n" 
    … …  
    737748 
    738749        // parameters for new object 
    739         mTerrainContentGenerator->SetOffset(currentObjectTerrainOffsets[mCurrentObjectType]); 
    740         Real scale = currentObjectScales[mCurrentObjectType]; 
     750        mTerrainContentGenerator->SetOffset(msObjectTerrainOffsets[mCurrentObjectType]); 
     751        Real scale = msObjectScales[mCurrentObjectType]; 
    741752        mTerrainContentGenerator->SetScale(Vector3(scale, scale, scale)); 
    742753 
    743         mCurrentObjectTypeInfo->setCaption(": " +  
    744                 mApplication->getCurrentObjectCaption(mCurrentObjectType)); 
     754        mCurrentObjectTypeInfo->setCaption(": " + msObjectCaptions[mCurrentObjectType]); 
    745755} 
    746756//----------------------------------------------------------------------- 
    747757void TerrainFrameListener::setAlgorithm(int algorithm) 
    748758{ 
    749         mAlgorithmInfo->setCaption(": " + currentAlgorithmCaptions[mCurrentAlgorithm]); 
     759        mAlgorithmInfo->setCaption(": " + msAlgorithmCaptions[mCurrentAlgorithm]); 
    750760        mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm); 
    751761} 
    … …  
    13701380         
    13711381        initOverlayElement(&mAlgorithmInfo, ext, "Algorithm", top, 
    1372                 ": " + currentAlgorithmCaptions[mCurrentAlgorithm]); top += vert_space; 
     1382                ": " + msAlgorithmCaptions[mCurrentAlgorithm]); top += vert_space; 
    13731383 
    13741384        initOverlayElement(&mThresholdInfo, ext, "Threshold", top, ": 0"); top += vert_space; 

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

    r164 r173  
    1313#include "OgrePlatformQueryManager.h" 
    1414 
     15 
    1516class TestCullingTerrainApplication; 
    1617 
    … …  
    1819using namespace Ogre; 
    1920 
    20 // z order index of visualizaion viewport 
    21 #define VIZ_VIEWPORT_Z_ORDER 10 
    2221 
    2322/** Frame listener specialised for terrains. 
    … …  
    8483   //enum {NODEVIZ_NONE, NODEVIZ_RENDER_GEOMETRY, NODEVIZ_MODES_NUM}; 
    8584 
    86   void zoomVizCamera(int zoom); 
     85   void zoomVizCamera(int zoom); 
    8786         
    8887   void addFrameInfo(SceneNode *camNode, Real timeElapsed); 
    … …  
    141140        void setObjectType(int objectType); 
    142141 
     142        static String msAlgorithmCaptions[]; 
     143        static String msQueryTypeCaptions[];  
     144        static String msQueryRelativeVisCaptions[]; 
     145        static String msQueryMethodCaptions[]; 
     146        static Real msObjectTerrainOffsets[];  
     147        static Real msObjectScales[]; 
     148        static String msObjectCaptions[]; 
     149 
    143150protected: 
    144151 
    145152        void initHelpOverlayElement(String name, int top); 
    146         void initOverlayElement(OverlayElement **elInfo, String ext, String name, int top, String caption); 
     153        void initOverlayElement(OverlayElement **elInfo, String ext, String name,  
     154                                                        int top, String caption); 
    147155 
    148156        //-- initialise overlays 

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

    r164 r173  
    1111//#include "OgreRefAppWorld.h" 
    1212#include "TestCullingTerrainApplication.h" 
    13  
     13#include "TerrainFrameListener.h" 
    1414 
    1515#define WIN32_LEAN_AND_MEAN 
    1616#include <windows.h> 
    1717 
    18 String currentObjectCaptions[] = 
    19 { 
    20         "robot", 
    21         "athene", 
    22         "ninja" 
    23         //"ogrehead" 
    24 }; 
    25  
    26 const float walk_duration = 10.0f; 
    27 const float wait_duration = 2.0f; 
    28 const float rotate_factor = 0.7f; 
    29 const float move_factor = 0.03; 
    30  
    31 /***************************************/ 
    32 /*      EntityState implementation     */ 
    33 /***************************************/ 
     18 
     19/**********************************************/ 
     20/*             EntityState implementation     */ 
     21/**********************************************/ 
     22 
     23 
    3424Vector3 EntityState::msMinPos = Vector3::ZERO; 
    3525Vector3 EntityState::msMaxPos = Vector3::ZERO; 
    … …  
    250240        mSunLight->setCastShadows(true); 
    251241 
    252         // set light angle not too sharp, otherwise shadows textures will be broken 
     242        // set light angle not too small over the surface, otherwise shadows textures will be broken 
    253243        Vector3 dir(0.5, 1, 0.5); 
    254244        dir.normalise(); 
    … …  
    288278        mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt); */ 
    289279 
    290         mSceneMgr->setShadowTextureSettings(1024, 2); 
     280        // Use 512x512 texture in GL since we can't go higher than the window res 
     281        mSceneMgr->setShadowTextureSettings(512, 2); 
     282 
    291283        mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5)); 
    292284    
    … …  
    326318void  TestCullingTerrainApplication::generateScene(int num, int objectType) 
    327319{ 
    328         mTerrainContentGenerator->GenerateScene(num, currentObjectCaptions[objectType]); 
     320        Vector3 scale(TerrainFrameListener::msObjectScales[objectType],  
     321                                  TerrainFrameListener::msObjectScales[objectType], 
     322                                  TerrainFrameListener::msObjectScales[objectType]); 
     323 
     324        mTerrainContentGenerator->SetScale(scale); 
     325        mTerrainContentGenerator->SetOffset(TerrainFrameListener::msObjectTerrainOffsets[objectType]); 
     326        mTerrainContentGenerator->GenerateScene(num, TerrainFrameListener::msObjectCaptions[objectType]); 
    329327 
    330328        if (objectType != 0) // from our objects, only robot has animation phases 
    … …  
    384382} 
    385383//----------------------------------------------------------------------- 
    386 String TestCullingTerrainApplication::getCurrentObjectCaption(int id) 
    387 { 
    388         return currentObjectCaptions[id]; 
    389 } 
    390 //----------------------------------------------------------------------- 
    391384void TestCullingTerrainApplication::chooseSceneManager() 
    392385{ 

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

    r164 r173  
    1111#include <OgreEntity.h> 
    1212 
     13// z order index of visualizaion viewport 
     14#define VIZ_VIEWPORT_Z_ORDER 10 
     15 
     16 
     17//-- constants for animation 
     18const float walk_duration = 10.0f; 
     19const float wait_duration = 2.0f; 
     20const float rotate_factor = 0.7f; 
     21const float move_factor = 0.03; 
     22 
     23 
     24/** Rendertarget listener which shows a visualization. 
     25*/ 
    1326class VisualizationRenderTargetListener: public RenderTargetListener 
    1427{ 
Note: See TracChangeset for help on using the changeset viewer.