Changeset 145


Ignore:
Timestamp:
06/22/05 10:05:06 (20 years ago)
Author:
mattausch
Message:

fixed bug when canceling login
fixed visibility queries using occlusion queries

Location:
trunk/VUT
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/VUT/GtpVisibility/include/VisibilityInfo.h

    r144 r145  
    99namespace GtpVisibility { 
    1010   
    11 /** Class storing the visibility information of a scene node.  
     11/** Class storing visibility information. 
    1212*/ 
    13 class NodeInfo  
     13class VisibilityInfo 
    1414{ 
    1515public: 
    16     NodeInfo(HierarchyNode *node, const int projectedPixels, const int visiblePixels):  
    17         mNode(node)//, mProjectedPixels(projectedPixels), mVisiblePixels(visiblePixels)  
    18         {} 
     16        VisibilityInfo(const int visiblePixels, const int projectedPixels); 
    1917 
    20         int GetVisiblePixels() const {return mVisiblePixels;} 
    21         int GetProjectedPixels() const {return mProjectedPixels;} 
     18        int GetVisiblePixels() const; 
     19        int GetProjectedPixels() const; 
    2220 
    23         void SetVisiblePixels(int vis) {mVisiblePixels = vis;} 
    24         void SetProjectedPixels(int vis) {mProjectedPixels = vis;} 
     21        void SetVisiblePixels(int vis); 
     22        void SetProjectedPixels(int vis); 
     23         
     24        /** Computes ratio of visible to projected pixels. */ 
     25        float ComputeRelativeVisibility(); 
    2526 
    26         void SetNode(HierarchyNode *node) {mNode = node;} 
    27         HierarchyNode *GetNode() const {return mNode;} 
     27        /** Adds visibility to current visibility information. 
     28        */ 
     29        void AddVisibility(const VisibilityInfo &info); 
    2830 
    29         float ComputeRelativeVisibility() { float result = mVisiblePixels; if (mProjectedPixels) result /= (float)mProjectedPixels; return result;} 
     31 
     32protected: 
     33        /** number of visible pixels. */ 
     34    int mVisiblePixels; 
     35        /** number of projected pixels */ 
     36        int mProjectedPixels; 
     37}; 
     38/** Class storing the visibility information of a hierarchy node.  
     39*/ 
     40class NodeInfo: public VisibilityInfo 
     41{ 
     42public: 
     43    NodeInfo(HierarchyNode *node, const int visiblePixels, const int projectedPixels); 
     44 
     45        void SetNode(HierarchyNode *node); 
     46        HierarchyNode *GetNode() const; 
    3047        //bool operator<(const NodeInfo& rhs) const {return mNode < rhs.mNode;} 
    3148 
    3249protected: 
    3350 
    34     /** pointer to the scene node */ 
     51    /** Pointer to the hierarchy nnode. 
     52        */ 
    3553    HierarchyNode *mNode; 
    36      
    37     int mVisiblePixels; 
    38         int mProjectedPixels; 
    3954}; 
    4055   
    4156/** Class storing the visibility information of a mesh. 
    4257*/ 
    43 class MeshInfo  
     58class MeshInfo: public VisibilityInfo 
    4459{ 
    4560public: 
    46         MeshInfo(Mesh *mesh,  const int projectedPixels, const int visiblePixels):  
    47         mMesh(mesh), mProjectedPixels(projectedPixels), mVisiblePixels(visiblePixels)  
    48         {} 
     61        MeshInfo(Mesh *mesh, const int visiblePixels, const int projectedPixels); 
    4962 
    50         int GetVisiblePixels() const {return mVisiblePixels;} 
    51         int GetProjectedPixels() const {return mProjectedPixels;} 
     63        Mesh *GetMesh() const; 
     64        void SetMesh(Mesh *mesh); 
    5265 
    53         void SetVisiblePixels(float vis) { mVisiblePixels = vis;} 
    54         void SetProjectedPixels(float vis) { mProjectedPixels = vis;} 
    55  
    56         Mesh *GetMesh() const {return mMesh;} 
    57         void SetMesh(Mesh *mesh) {mMesh = mesh;} 
    58  
    59         bool operator<(const MeshInfo& rhs) const {return mMesh < rhs.mMesh;} 
    60         //bool operator>(const MeshInfo& rhs) const {return mMesh > rhs.mMesh;} 
     66        //bool operator<(const MeshInfo& rhs) const {return mMesh < rhs.mMesh;} 
    6167        //bool operator==(const MeshInfo& rhs) const {return mMesh == rhs.mMesh;} 
    6268         
     
    6672        */ 
    6773    Mesh *mMesh; 
    68    
    69     int mVisiblePixels; 
    70         int mProjectedPixels; 
    7174}; 
    7275   
  • trunk/VUT/Ogre/src/OgrePlatformQueryManager.cpp

    r144 r145  
    130130                ++visQueryIt; 
    131131                 
    132                 // nodes with visibilty 0 in queue:  
    133                 // happens if node is intersected by near plane 
     132                // node with visibilty 0 in queue (e.g., if node is intersected by near plane) 
    134133                if (visiblePixels > 0) 
    135134                { 
     
    161160                if (visiblePixels > 0) 
    162161                {                         
    163                         visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt,  
    164                                 visiblePixels, projectedPixels)); 
     162                        visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt, visiblePixels,  
     163                                projectedPixels)); 
    165164                } 
    166165        } 
     
    209208        cam->setAspectRatio(1.0); 
    210209        cam->setFOVy(Radian(Math::HALF_PI)); 
    211  
    212         std::stringstream d; 
    213         d << "old camera: " + StringConverter::toString(savedCam->getDerivedPosition()) +  
    214                 " " + "O: " + StringConverter::toString(savedCam->getDerivedOrientation()); 
    215         LogManager::getSingleton().logMessage(d.str()); 
    216210 
    217211        int sign = -1; 
     
    230224                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility); 
    231225                 
    232                 //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("HAAHHAHAHAHAH"); 
     226                //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait"); 
    233227 
    234228                // permute directions 
     
    254248 
    255249        for (visibleNodesIt = visibleNodes->begin(); visibleNodesIt != visibleNodesIt_end;  
    256                 ++visibleNodesIt); 
     250                ++visibleNodesIt) 
    257251        { 
    258252                if (!nodeInfo || (nodeInfo->GetNode() != (*visibleNodesIt).GetNode())) 
     
    260254                        nodeInfo = &(*visibleNodesIt); 
    261255                } 
    262                 else 
    263                 { 
    264                         // add visibility 
    265                         nodeInfo->SetVisiblePixels(nodeInfo->GetVisiblePixels() +  
    266                                 (*visibleNodesIt).GetVisiblePixels()); 
    267                  
    268                         nodeInfo->SetProjectedPixels(nodeInfo->GetProjectedPixels() +  
    269                                 (*visibleNodesIt).GetProjectedPixels()); 
     256                else // add visibility 
     257                {                        
     258                        nodeInfo->AddVisibility(*visibleNodesIt); 
    270259                } 
    271260 
     
    283272        GtpVisibility::MeshInfo *geomInfo = NULL; 
    284273 
     274        int i=0; 
    285275        for (visibleGeomIt = visibleGeometry->begin(); visibleGeomIt != visibleGeomIt_end;  
    286                 ++visibleGeomIt); 
     276                ++visibleGeomIt) 
    287277        { 
    288278                if (!geomInfo || (geomInfo->GetMesh() != (*visibleGeomIt).GetMesh())) 
     
    290280                        geomInfo = &(*visibleGeomIt); 
    291281                } 
    292                 else // info points to equal mesh 
    293                 { 
    294                         // add visibility 
    295                         geomInfo->SetVisiblePixels(geomInfo->GetVisiblePixels() +  
    296                                 (*visibleGeomIt).GetVisiblePixels()); 
    297  
    298                         geomInfo->SetProjectedPixels(nodeInfo->GetProjectedPixels() +  
    299                                 (*visibleNodesIt).GetProjectedPixels()); 
     282                else // info points to same mesh, just add visibility 
     283                { 
     284                        geomInfo->AddVisibility(*visibleGeomIt); 
    300285                } 
    301286        } 
  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

    r144 r145  
    377377        for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt) 
    378378        { 
    379                 averageGeometryVis += (*geomIt).GetVisiblePixels(); 
    380  
    381                 std::stringstream d; d << "Geometry visibility: " << (*geomIt).GetVisiblePixels(); 
     379                float vis = relativeVisibility ?  
     380                        (*geomIt).ComputeRelativeVisibility() : (float)(*geomIt).GetVisiblePixels(); 
     381                 
     382                averageGeometryVis += vis; 
     383 
     384                std::stringstream d; d << "Geometry visibility: " << vis; 
    382385                LogManager::getSingleton().logMessage(d.str()); 
    383386        } 
     
    387390        for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++nodesIt) 
    388391        { 
    389                 averageNodeVis += (*nodesIt).GetVisiblePixels(); 
    390  
    391                 std::stringstream d; d << "Node visibility: " << (*nodesIt).GetVisiblePixels(); 
     392                float vis = relativeVisibility ?  
     393                        (*nodesIt).ComputeRelativeVisibility() : (float)(*nodesIt).GetVisiblePixels(); 
     394                 
     395                averageNodeVis += vis; 
     396                 
     397                std::stringstream d; d << "Node visibility: " << vis; 
    392398                LogManager::getSingleton().logMessage(d.str()); 
    393399        } 
    394400 
    395         if ((int)visibleNodes.size()) 
     401        if (visibleNodes.size()) 
    396402                averageNodeVis /= (float)visibleNodes.size(); 
    397         if ((int)visibleGeometry.size()) 
     403        if (visibleGeometry.size()) 
    398404                averageGeometryVis /= (float)visibleGeometry.size(); 
    399405 
  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

    r144 r145  
    1818/*     TestCullingTerrainApplication implementation    */ 
    1919/*******************************************************/ 
    20  
     20TestCullingTerrainApplication::TestCullingTerrainApplication(): 
     21mTerrainContentGenerator(NULL) 
     22{ 
     23} 
    2124//----------------------------------------------------------------------- 
    2225TestCullingTerrainApplication::~TestCullingTerrainApplication() 
     
    6972bool TestCullingTerrainApplication::setup() 
    7073{ 
    71         bool result = ExampleApplication::setup(); 
    72  
    73         if (mWindow) 
     74        bool carryOn = ExampleApplication::setup(); 
     75 
     76        if (carryOn) 
    7477                createRenderTargetListener(); 
    7578 
    76         return result; 
     79        return carryOn; 
    7780} 
    7881//----------------------------------------------------------------------- 
  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.h

    r139 r145  
    2828{ 
    2929public: 
     30        TestCullingTerrainApplication(); 
    3031        ~TestCullingTerrainApplication(); 
    3132 
Note: See TracChangeset for help on using the changeset viewer.