Ignore:
Timestamp:
06/17/08 03:47:02 (17 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/App/Demos/Vis/CHC_revisited
Files:
3 added
16 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/CHC_revisited/BinaryLoader.cpp

    r2763 r2764  
    1818SceneEntity *BinaryLoader::LoadSceneEntity(ifstream &str) 
    1919{        
    20         Geometry *geom = LoadGeometry(str); 
    21         Material *mat = LoadMaterial(str); 
    22         Matrix4x4 *trafo = NULL;//IdentityMatrix(); 
     20        // shape 
     21        int shapeId; 
     22        str.read(reinterpret_cast<char *>(&shapeId), sizeof(int)); 
     23 
     24        Geometry *geom = mGeometryTable[shapeId]; 
     25        Material *mat = mMaterialTable[shapeId]; 
     26 
     27 
     28        bool hasTrafo; 
     29        str.read(reinterpret_cast<char *>(&hasTrafo), sizeof(bool)); 
     30 
     31        Matrix4x4 *trafo; 
     32         
     33        if (!hasTrafo) 
     34        { 
     35                trafo = NULL; 
     36        } 
     37        else 
     38        { 
     39                trafo = new Matrix4x4(); 
     40                //*trafo = IdentityMatrix(); 
     41                str.read(reinterpret_cast<char *>(trafo->x), sizeof(Matrix4x4)); 
     42                //str.read(reinterpret_cast<char *>(trafo), sizeof(Matrix4x4)); 
     43                //cout << "m:\n" << *trafo<<endl; 
     44        } 
    2345 
    2446        SceneEntity *sceneGeom = new SceneEntity(geom, mat, trafo); 
    … …  
    3759                // texture 
    3860                int texnameSize; 
    39                 int id; 
    40  
    41                 str.read(reinterpret_cast<char *>(&id), sizeof(int)); 
     61 
     62                //str.read(reinterpret_cast<char *>(&id), sizeof(int)); 
    4263                str.read(reinterpret_cast<char *>(&texnameSize), sizeof(int)); 
    4364 
    … …  
    4869                Texture *tex = new Texture(texname); 
    4970 
    50                 mTextureTable[id] = tex; 
    51         } 
     71                mTextureTable[i] = tex; 
     72        } 
     73 
     74        cout << "loaded " << mTextureTable.size() << " textures" << endl; 
     75} 
     76 
     77 
     78void BinaryLoader::LoadShapes(ifstream &str) 
     79{ 
     80        int numShapes; 
     81        str.read(reinterpret_cast<char *>(&numShapes), sizeof(int)); 
     82 
     83        for (int i = 0; i < numShapes; ++ i) 
     84        { 
     85                Geometry *geom = LoadGeometry(str); 
     86                Material *mat = LoadMaterial(str); 
     87 
     88                mGeometryTable[i] = geom; 
     89                mMaterialTable[i] = mat; 
     90        } 
     91 
     92        cout << "loaded " << mGeometryTable.size() << " shapes" << endl; 
    5293} 
    5394 
    … …  
    61102        // texture 
    62103        int texId; 
    63  
    64104        str.read(reinterpret_cast<char *>(&texId), sizeof(int)); 
    65         //cout << "texid: " << texId << endl; 
    66105 
    67106        if (texId >= 0) 
    68         { 
    69107                mat->SetTexture(mTextureTable[texId]); 
    70         } 
     108         
    71109 
    72110        // material 
    … …  
    99137 
    100138        return app;*/ 
    101  
    102139        return mat; 
    103140} 
    … …  
    156193 
    157194 
    158 bool BinaryLoader::Load(const std::string &filename, SceneEntityContainer &geometry) 
     195void BinaryLoader::LoadSceneEntities(ifstream &str, SceneEntityContainer &entities) 
     196{ 
     197        int entityCount; 
     198        str.read(reinterpret_cast<char *>(&entityCount), sizeof(int)); 
     199 
     200        entities.resize(entityCount); 
     201 
     202        for (int i = 0; i < entityCount; ++ i) 
     203        { 
     204                SceneEntity *ent = LoadSceneEntity(str); 
     205                ent->id = i; 
     206                entities[i] = ent; 
     207        } 
     208 
     209        cout << "loaded " << entityCount << " scene entities" << endl; 
     210} 
     211 
     212 
     213bool BinaryLoader::Load(const std::string &filename, SceneEntityContainer &entities) 
    159214{ 
    160215        //clear_textures(); // clear the texture table 
    … …  
    166221                return false; 
    167222 
     223        cout << "loading textures" << endl; 
     224         
    168225        // load the texture table 
    169226        LoadTextures(istr); 
    170227 
    171         // #shapes 
    172         int shapeCount; 
    173         istr.read(reinterpret_cast<char *>(&shapeCount), sizeof(int)); 
    174  
    175         geometry.resize(shapeCount); 
    176  
    177         for (size_t i = 0; i < geometry.size(); ++ i) 
    178                 geometry[i] = NULL; 
    179          
    180  
    181         int progress = 0; 
    182  
    183         for (int i = 0; i < shapeCount; ++ i) 
    184         { 
    185                 //int id;istr.read(reinterpret_cast<char *>(&id), sizeof(int)); 
    186                 SceneEntity *ent = LoadSceneEntity(istr); 
    187                 ent->id = i; 
    188  
    189                 geometry[i] = ent; 
    190                  
    191                 int p = (i + 1) * 100 / shapeCount; 
    192                  
    193                 if (p >= progress) 
    194                 { 
    195                         cout << "% loaded: " << p << endl; 
    196                         progress += 10; 
    197                 } 
    198         } 
    199  
    200         for (size_t i = 0; i < geometry.size(); ++ i) 
    201         { 
    202                 if (!geometry[i]) 
    203                         Debug << "error: index " << i << " missing" << endl; 
    204         } 
    205  
     228        cout << "loading shapes (geometry + materials)" << endl; 
     229 
     230        // load the shapees 
     231        LoadShapes(istr); 
     232 
     233        cout << "loading scene entites" << endl; 
     234        LoadSceneEntities(istr, entities); 
     235         
    206236        cout << "bin loading finished" << endl; 
    207237 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/BinaryLoader.h

    r2757 r2764  
    3030         
    3131        void LoadTextures(std::ifstream &str); 
     32        void LoadShapes(std::ifstream &str); 
     33        void LoadSceneEntities(std::ifstream &str, SceneEntityContainer &entities); 
    3234 
    3335        SceneEntity *LoadSceneEntity(std::ifstream &str); 
    … …  
    3537        Geometry *LoadGeometry(std::ifstream &str); 
    3638 
    37         /*SceneEntity *LoadShape(igzstream &str); 
    38         Material *LoadMaterial(igzstream &str); 
    39         Geometry *LoadGeometry(igzstream &str); 
    40         */ 
    41  
    4239        std::map<int, Texture *> mTextureTable; 
     40        std::map<int, Material *> mMaterialTable; 
     41        std::map<int, Geometry *> mGeometryTable; 
    4342}; 
    4443 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Bvh.cpp

    r2763 r2764  
    366366        // store near plane 
    367367        sNearPlane = Plane3(mCamera->GetDirection(), mCamera->GetPosition()); 
    368 //      Debug << "near: " << sNearPlane << " d " << mCamera->GetDirection() << " " << mCamera->GetPosition() << std::endl; 
    369 //      for (int i = 0; i < 6; ++ i) Debug << "plane: " << sFrustum.mClipPlanes[i] << std::endl; 
    370 } 
    371  
    372  
    373 float Bvh::CalcDistance(BvhNode *node) const 
    374 { 
    375         return node->GetBox().GetMinVisibleDistance(sNearPlane); 
     368} 
     369 
     370 
     371void Bvh::CalcDistance(BvhNode *node) const 
     372{ 
     373        node->mDistance = node->GetBox().GetMinVisibleDistance(sNearPlane); 
    376374} 
    377375 
    … …  
    872870        } 
    873871 
     872        mNumVirtualNodes = 0; 
     873 
    874874        // assign new virtual leaves based on specified number of triangles per leaf 
    875875        std::stack<BvhNode *> nodeStack; 
    … …  
    880880                BvhNode *node = nodeStack.top(); 
    881881                nodeStack.pop(); 
     882 
     883                ++ mNumVirtualNodes; 
    882884 
    883885                if (node->IsLeaf())  
    … …  
    948950        const Vector3 u = box.Max(); 
    949951 
    950         /////////// 
    951         //-- render AABB as triangle strips 
    952  
    953         glVertex3f(l.x, l.y, u.z); 
    954         glVertex3f(u.x, l.y, u.z); 
    955         glVertex3f(l.x, u.y, u.z); 
    956         glVertex3f(u.x, u.y, u.z); 
    957         glVertex3f(l.x, u.y, l.z);  
    958         glVertex3f(u.x, u.y, l.z); 
    959         glVertex3f(l.x, l.y, l.z);  
    960         glVertex3f(u.x, l.y, l.z); 
    961  
    962         glPrimitiveRestartNV(); 
    963  
    964         //-- render second half of AABB 
    965         glVertex3f(l.x, u.y, u.z);  
    966         glVertex3f(l.x, u.y, l.z); 
    967         glVertex3f(l.x, l.y, u.z); 
    968         glVertex3f(l.x, l.y, l.z); 
    969         glVertex3f(u.x, l.y, u.z);  
    970         glVertex3f(u.x, l.y, l.z); 
    971         glVertex3f(u.x, u.y, u.z);  
    972         glVertex3f(u.x, u.y, l.z); 
    973 } 
    974  
    975  
    976  
    977 } 
     952        glBegin(GL_TRIANGLE_STRIP); 
     953        { 
     954                /////////// 
     955                //-- render AABB as triangle strips 
     956 
     957                glVertex3f(l.x, l.y, u.z); 
     958                glVertex3f(u.x, l.y, u.z); 
     959                glVertex3f(l.x, u.y, u.z); 
     960                glVertex3f(u.x, u.y, u.z); 
     961                glVertex3f(l.x, u.y, l.z);  
     962                glVertex3f(u.x, u.y, l.z); 
     963                glVertex3f(l.x, l.y, l.z);  
     964                glVertex3f(u.x, l.y, l.z); 
     965 
     966                glPrimitiveRestartNV(); 
     967 
     968                //-- render second half of AABB 
     969                glVertex3f(l.x, u.y, u.z);  
     970                glVertex3f(l.x, u.y, l.z); 
     971                glVertex3f(l.x, l.y, u.z); 
     972                glVertex3f(l.x, l.y, l.z); 
     973                glVertex3f(u.x, l.y, u.z);  
     974                glVertex3f(u.x, l.y, l.z); 
     975                glVertex3f(u.x, u.y, u.z);  
     976                glVertex3f(u.x, u.y, l.z); 
     977        } 
     978        glEnd(); 
     979} 
     980 
     981} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Bvh.h

    r2763 r2764  
    505505                note that negative values can appear because culling is done only afterwards 
    506506        */ 
    507         float CalcDistance(BvhNode *node) const; 
     507        void CalcDistance(BvhNode *node) const; 
     508        /** Returns the stored distance. 
     509        */ 
     510        float GetDistance(BvhNode *node) const  { return node->mDistance; } 
    508511        /** Pulls up the last visited classification in the bvh. 
    509512        */ 
    … …  
    544547        */ 
    545548        const BvhStats &GetBvhStats() const {return mBvhStats;} 
    546          
     549        /** Renders the geometry contained in this node. 
     550        */ 
    547551        int Render(BvhNode *node, RenderState *state); 
     552        /** Returns number of 'virtual' nodes in the hierarchy, i.e. 
     553                the number of nodes actually used for traversal. 
     554        */ 
     555        int GetNumVirtualNodes() const  { return mNumVirtualNodes; } 
    548556 
    549557 
    … …  
    602610 
    603611        void RenderBoundingBoxImmediate(const AxisAlignedBox3 &box); 
     612 
     613 
    604614 
    605615        //////////////////////// 
    … …  
    645655        AxisAlignedBox3 mBox; 
    646656 
     657        int mNumVirtualNodes; 
     658 
    647659        ////////////// 
    648660 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/CHCTraverser.cpp

    r2755 r2764  
    11#include "CHCTraverser.h" 
     2#include "SceneEntity.h" 
     3 
    24 
    35namespace CHCDemo 
    … …  
    1719void CHCTraverser::Render() 
    1820{ 
    19 #if 0 
     21        mStats.Reset(); 
     22        mRenderState->mTexturesEnabled = false; 
     23        EnqueueNode(mBvh->GetRoot()); 
     24 
    2025        QueryQueue queryQueue; 
    2126 
    … …  
    2429        { 
    2530                while (!queryQueue.empty() &&  
    26                            (ResultAvailable(queryQueue.front()) || mDistanceQueue.empty())) 
     31                           (queryQueue.front()->ResultAvailable() || mDistanceQueue.empty())) 
    2732                { 
    28                         HierarchyNode *node = queryQueue.front(); 
     33                        OcclusionQuery *query = queryQueue.front(); 
    2934                        queryQueue.pop(); 
    3035                         
    3136                        // wait until result available 
    32                         int visiblePixels = GetOcclusionQueryResult(node); 
     37                        int visiblePixels = query->GetQueryResult(); 
    3338 
    34                         if(visiblePixels > mVisibilityThreshold) 
     39                        if (visiblePixels > mVisibilityThreshold) 
    3540                        { 
    36                                 PullUpVisibility(node); 
     41                                BvhNode *node = query->GetFrontNode(); 
     42 
     43                                mBvh->MakeParentsVisible(node); 
    3744                                TraverseNode(node); 
    3845                        } 
    3946                        else 
    4047                        { 
    41                                 mNumQueryCulledNodes ++; 
     48                                ++ mStats.mNumQueryCulledNodes; 
    4249                        } 
    4350                }        
    … …  
    4653                if (!mDistanceQueue.empty()) 
    4754                { 
    48                         HierarchyNode *node = mDistanceQueue.top(); 
    49  
     55                        BvhNode *node = mDistanceQueue.top(); 
    5056                        mDistanceQueue.pop(); 
    5157         
    52                         mNumTraversedNodes ++; 
    53  
    54                         bool intersects; 
    55                          
    56                         if (InsideViewFrustum(node, intersects)) 
     58                        if (mBvh->IsWithinViewFrustum(node)) 
    5759                        { 
    5860                                // for near plane intersecting bounding box possible  
    5961                                // wrong results => skip occlusion query 
    60                                 if(intersects) 
     62                                if (IntersectsNearPlane(node)) 
    6163                                { 
    6264                                        // update node's visited flag 
    63                                         node->SetLastVisited(mFrameID); 
     65                                        node->SetLastVisitedFrame(mFrameID); 
    6466                                        node->SetVisible(true); 
    65                                         PullUpVisibility(node); 
     67                                        mBvh->MakeParentsVisible(node); 
     68 
    6669                                        TraverseNode(node); 
    6770                                } 
    … …  
    6972                                {                
    7073                                        // identify previously visible nodes 
    71                                         bool wasVisible = node->Visible() && (node->LastVisited() == mFrameID - 1); 
     74                                        const bool wasVisible = node->IsVisible() && (node->GetLastVisitedFrame() == mFrameID - 1); 
    7275                                         
    7376                                        // identify nodes that we cannot skip queries for 
    74                                         bool leafOrWasInvisible = (node->LastVisited() != mFrameID) && (!wasVisible || node->IsLeaf()); 
     77                                        const bool leafOrWasInvisible =  
     78                                                (node->GetLastVisitedFrame() != mFrameID) && (!wasVisible || node->IsVirtualLeaf()); 
    7579 
    7680                                        // reset node's visibility classification  
    … …  
    7882 
    7983                                        // update node's visited flag 
    80                                         node->SetLastVisited(mFrameID); 
     84                                        node->SetLastVisitedFrame(mFrameID); 
    8185                                         
    8286                                        // skip testing previously visible interior nodes 
    83                                         if(leafOrWasInvisible) 
     87                                        if (leafOrWasInvisible) 
    8488                                        { 
    85                                                 IssueOcclusionQuery(node, wasVisible); 
    86                                                 queryQueue.push(node); 
     89                                                OcclusionQuery *query = IssueOcclusionQuery(node, wasVisible); 
     90                                                queryQueue.push(query); 
    8791                                        } 
    8892                                         
    8993                                        // always traverse a node if it was visible 
    90                                         if(wasVisible) 
     94                                        if (wasVisible) 
    9195                                                TraverseNode(node); 
    9296                                } 
    … …  
    9599                        { 
    96100                                // for stats 
    97                                 mNumFrustumCulledNodes ++; 
     101                                ++ mStats.mNumFrustumCulledNodes; 
    98102                        } 
    99103                } 
    100104        } 
    101 #endif 
    102105} 
    103106 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Camera.cpp

    r2762 r2764  
    2929        mDirection.Normalize(); 
    3030 
    31         Vector3 side = CrossProd(Vector3(0, 1, 0), mDirection); 
     31        //Vector3 side = CrossProd(Vector3(0, 1, 0), mDirection); 
     32        Vector3 side = CrossProd(Vector3(0, 0, 1), mDirection); 
     33         
    3234        mUp = -Normalize(CrossProd(side, mDirection)); 
    3335        mRight = -Normalize(CrossProd(mDirection, mUp)); 
     36 
    3437 
    3538        float k = tan(mFovy/2); 
    … …  
    5356 
    5457 
     58void Camera::SetNear(float nearDist)  
     59{ 
     60        mNear = nearDist; 
     61} 
     62 
     63 
    5564void Camera::LookInBox(const AxisAlignedBox3 &box) 
    5665{ 
    57         mDirection = Vector3(0, 0, 1); 
     66        //mDirection = Vector3(0, 0, 1); 
     67        mDirection = Vector3(0, 1, 0); 
    5868        mPosition = box.Center(); 
    59         mPosition.y += 50; 
     69        mPosition.z = box.Min(2) + 0.9f * box.Size(2); 
    6070 
    6171        Precompute(); 
    … …  
    6575void Camera::LookAtBox(const AxisAlignedBox3 &box) 
    6676{ 
    67         mDirection = Vector3(0, 0, box.Min().z - box.Max().z); 
     77        mDirection = Vector3(0, box.Min().y - box.Max().y, 0); 
    6878        mPosition = Vector3(0);//box.Max() - mDirection; 
    6979 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Camera.h

    r2762 r2764  
    5757        void ComputePoints(Vector3 &ftl, Vector3 &ftr, Vector3 &fbl, Vector3 &fbr, 
    5858                               Vector3 &ntl, Vector3 &ntr, Vector3 &nbl, Vector3 &nbr); 
     59         
     60        inline float GetNear() const { return mNear; } 
     61        void SetNear(float nearDist); 
    5962 
    6063 
    … …  
    7477        int mWidth; 
    7578        int mHeight; 
     79 
     80        float mNear; 
    7681}; 
    7782 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/FrustumCullingTraverser.cpp

    r2763 r2764  
    1515void FrustumCullingTraverser::Render() 
    1616{ 
     17        mStats.Reset(); 
    1718        mRenderState->mTexturesEnabled = false; 
    18         mDistanceQueue.push(mBvh->GetRoot()); 
     19        EnqueueNode(mBvh->GetRoot()); 
    1920 
    20  
    21         int traversed = 0; 
    2221        while (!mDistanceQueue.empty()) 
    2322        { 
    … …  
    2726                // interesting for the visualization, so rest and set 
    2827                node->SetVisible(false); 
    29                 //mNumTraversedNodes ++; 
    3028 
    3129                if (mBvh->IsWithinViewFrustum(node)) 
    … …  
    3432                        // so set it also here 
    3533                        //node->SetLastVisited(mFrameID); 
    36                         //node->SetVisible(true); 
    37                         ++ traversed; 
     34                        node->SetVisible(true); 
    3835                        TraverseNode(node); 
    3936                } 
    4037                else 
    4138                { 
    42                         //mNumFrustumCulledNodes ++; 
     39                        mStats.mNumFrustumCulledNodes ++; 
    4340                } 
    44                 //cout << "intersect: " << intersect << " bx " << node->GetBox() << endl; 
    4541        } 
    46          
    47         //std::cout << "traversed: " << traversed << std::endl; 
    4842} 
    4943 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/OcclusionQuery.cpp

    r2763 r2764  
    8585        } 
    8686        else 
     87        { 
    8788                query = mOcclusionQueries[mCurrentQueryIdx]; 
     89        } 
     90 
     91        ++ mCurrentQueryIdx; 
    8892 
    8993        return query; 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/RenderTraverser.cpp

    r2763 r2764  
    77namespace CHCDemo 
    88{ 
     9 
     10         
     11void TraversalStatistics::Reset() 
     12{ 
     13        // reset statistics 
     14        mNumTraversedNodes = 0; 
     15        mNumQueryCulledNodes = 0; 
     16        mNumFrustumCulledNodes = 0; 
     17        mNumRenderedGeometry = 0; 
     18        mNumRenderedTriangles = 0; 
     19 
     20        mNumIssuedQueries = 0; 
     21        mRenderTime = 0; 
     22} 
     23 
     24 
     25 
     26/******************************************************/ 
     27/*           RenderTraverser implementation           */ 
     28/******************************************************/ 
     29 
    930 
    1031RenderTraverser::RenderTraverser():  
    … …  
    1334mBvh(NULL),  
    1435mIsQueryMode(false), 
    15 mUseOptimization(true), 
    16 mCurrentQueryIdx(0) 
     36mUseOptimization(true) 
    1737{ 
    1838} 
    … …  
    2141RenderTraverser::~RenderTraverser() 
    2242{ 
    23         //DelQueries(); 
    24 } 
    25  
    26  
    27 /*void RenderTraverser::Render(int mode) 
    28 { 
    29         mDistanceQueue.push(mHierarchyRoot); 
    30  
    31         long startTime = getTime(); 
    32  
    33         Preprocess(); 
    34  
    35         switch(mode) 
    36         { 
    37                 case RENDER_CULL_FRUSTUM: 
    38                         RenderCullFrustum(); 
    39             break; 
    40                 case RENDER_STOP_AND_WAIT: 
    41                         RenderStopAndWait(); 
    42                         break; 
    43                 case RENDER_COHERENT: 
    44                         RenderCoherentWithQueue(); 
    45                         break; 
    46                 default: 
    47                         RenderCullFrustum(); 
    48                         break; 
    49         } 
    50  
    51         mFrameID ++; 
    52          
    53  
    54         long endTime = getTime(); 
    55         mRenderTime = endTime - startTime; 
    56  
    57         finishTiming(); 
    58 }*/ 
     43        mQueryHandler.DestroyQueries(); 
     44} 
     45 
    5946 
    6047void RenderTraverser::EnqueueNode(BvhNode *node) 
    … …  
    6754void RenderTraverser::TraverseNode(BvhNode *node) 
    6855{ 
     56        ++ mStats.mNumTraversedNodes; 
    6957 
    7058        if (node->IsVirtualLeaf()) 
    7159        { 
    7260                //RenderBox(node->GetBox()); 
    73  
    74                 //mNumRenderedGeometry += 
    75                 mBvh->Render(node, mRenderState); 
     61                mStats.mNumRenderedGeometry +=  mBvh->Render(node, mRenderState); 
    7662        } 
    7763        else  
    … …  
    117103OcclusionQuery *RenderTraverser::IssueOcclusionQuery(BvhNode *node, bool wasVisible) 
    118104{ 
     105        ++ mStats.mNumIssuedQueries; 
     106 
    119107        OcclusionQuery *query = mQueryHandler.RequestQuery(); 
     108        query->Reset(); 
     109        query->AddNode(node); 
    120110 
    121111        query->BeginQuery(); 
    … …  
    131121 
    132122        // change state so the bounding box gets not actually rendered on the screen 
    133         //Switch2GLQueryState(); 
     123        Switch2GLQueryState(); 
    134124        mBvh->RenderBoundingBox(node); 
    135         //Switch2GLRenderState(); 
     125        Switch2GLRenderState(); 
    136126 
    137127        query->EndQuery(); 
    … …  
    155145 
    156146 
    157 #if 0 
    158  
    159 Bvh *RenderTraverser::GetHierarchy() 
    160 { 
    161         return mBvh; 
    162 } 
    163  
    164  
     147void RenderTraverser::PullUpVisibility(BvhNode *node) 
     148{ 
     149        while(node && ! node->IsVisible()) 
     150        { 
     151                node->SetVisible(true); 
     152                node = node->GetParent(); 
     153        } 
     154} 
     155 
     156 
     157void RenderTraverser::SetVisibilityThreshold(int threshold) 
     158{ 
     159        mVisibilityThreshold = threshold; 
     160} 
     161 
     162 
     163int RenderTraverser::GetVisibilityThreshold() const 
     164{ 
     165        return mVisibilityThreshold; 
     166} 
     167 
     168 
     169/* 
    165170void RenderTraverser::RenderVisualization() 
    166171{ 
    … …  
    184189                } 
    185190        } 
    186 } 
    187  
    188  
    189 void RenderTraverser::PullUpVisibility(HierarchyNode *node) 
    190 { 
    191         while(node && !node->Visible()) 
    192         { 
    193                 node->SetVisible(true); 
    194                 node = node->GetParent(); 
    195         } 
    196 } 
    197  
    198 bool RenderTraverser::ResultAvailable(HierarchyNode *node) const 
    199 { 
    200         unsigned int result; 
    201         if (mUseArbQueries) 
    202         { 
    203                 glGetQueryObjectuivARB(node->GetOcclusionQuery(), 
    204                                                            GL_QUERY_RESULT_AVAILABLE_ARB, &result); 
    205         } 
    206         else 
    207         { 
    208                  
    209                 glGetOcclusionQueryuivNV(node->GetOcclusionQuery(),  
    210                                                                  GL_PIXEL_COUNT_AVAILABLE_NV, &result); 
    211  
    212         } 
    213          
    214         return (result == GL_TRUE); 
    215 } 
    216  
    217  
    218 void RenderTraverser::Preprocess() 
    219 { 
    220         if (!mOcclusionQueries) 
    221         { 
    222                 mOcclusionQueries = new unsigned int[mHierarchyRoot->GetNumHierarchyNodes()]; 
    223  
    224                 // generate ids for occlusion test 
    225                 if (mUseArbQueries) 
    226                 { 
    227                         glGenQueriesARB(mHierarchyRoot->GetNumHierarchyNodes(), mOcclusionQueries); 
    228                 } 
    229                 else 
    230                 { 
    231                         glGenOcclusionQueriesNV(mHierarchyRoot->GetNumHierarchyNodes(), mOcclusionQueries); 
    232                 } 
    233         } 
    234  
    235         // view frustum planes for view frustum culling 
    236         calcViewFrustumPlanes(&mClipPlanes, mProjViewMatrix); 
    237         calcAABNPVertexIndices(mNPVertexIndices, mClipPlanes); 
    238  
    239         mCurrentQueryIdx = 0; 
    240  
    241         // reset statistics 
    242         mNumTraversedNodes = 0; 
    243         mNumQueryCulledNodes = 0; 
    244         mNumFrustumCulledNodes = 0; 
    245         mNumRenderedGeometry = 0; 
    246 } 
    247  
    248  
    249 void RenderTraverser::DelQueries() 
    250 { 
    251         if (!mOcclusionQueries) 
    252                 return; 
    253  
    254         // tell the driver that the occlusion queries won't be needed any more 
    255         if (mUseArbQueries) 
    256         { 
    257                 glDeleteQueriesARB(mHierarchyRoot->GetNumHierarchyNodes(), mOcclusionQueries); 
    258         } 
    259         else 
    260         { 
    261                 glDeleteOcclusionQueriesNV(mHierarchyRoot->GetNumHierarchyNodes(), mOcclusionQueries); 
    262         } 
    263  
    264         delete [] mOcclusionQueries; 
    265  
    266         mOcclusionQueries = NULL; 
    267 } 
    268  
    269  
    270 void RenderTraverser::SetViewpoint(Vector3 const &viewpoint) 
    271 { 
    272         copyVector3(mViewpoint, viewpoint); 
    273 } 
    274          
    275  
    276 void RenderTraverser::SetProjViewMatrix(Matrix4x4 const &projViewMatrix) 
    277 { 
    278         copyMatrix(mProjViewMatrix, projViewMatrix); 
    279 } 
    280  
    281  
    282 bool RenderTraverser::InsideViewFrustum(HierarchyNode *node, bool &intersects) 
    283 { 
    284         Vector3x8 vertices; 
    285          
    286         bool intersect = false; 
    287  
    288         calcAABoxPoints(vertices, node->GetBoundingVolume()); 
    289  
    290         // simply test all 6 vertices 
    291         for (int i = 0; i < 6; i++) 
    292         {                
    293                 // test the n-vertex 
    294                 // note: the calcAABNearestVertexId should be preprocessed 
    295                 if(!pointBeforePlane(mClipPlanes.plane[i], vertices[mNPVertexIndices[i * 2]])) 
    296                 { 
    297                         // outside 
    298                         return false; 
    299                 } 
    300         } 
    301  
    302         // test if bounding box is intersected by nearplane (using the p-vertex) 
    303         intersects = (!pointBeforePlane(mClipPlanes.plane[5], vertices[mNPVertexIndices[11]])); 
    304  
    305         // -- get vector from viewpoint to center of bounding volume 
    306         Vector3 vec; 
    307         calcAABoxCenter(vec, node->GetBoundingVolume()); 
    308         diffVector3(vec, vec, mViewpoint); 
    309  
    310         // compute distance from nearest point to viewpoint 
    311         diffVector3(vec, vertices[calcAABNearestVertexIdx(vec)], mViewpoint); 
    312         node->SetDistance(squaredLength(vec)); 
    313          
    314         return true; 
    315 } 
    316  
    317  
    318 void RenderTraverser::SetVisibilityThreshold(int threshold) 
    319 { 
    320         mVisibilityThreshold = threshold; 
    321 } 
    322  
    323 void RenderTraverser::SetUseArbQueries(const bool useArbQueries) 
    324 { 
    325         DelQueries(); 
    326         mUseArbQueries = useArbQueries; 
    327 } 
    328  
    329 bool RenderTraverser::GetUseArbQueries() const 
    330 { 
    331         return mUseArbQueries; 
    332 } 
    333  
    334 long RenderTraverser::GetRenderTime() 
    335 { 
    336         return mRenderTime; 
    337 } 
    338  
    339 int RenderTraverser::GetNumTraversedNodes() 
    340 { 
    341         return mNumTraversedNodes; 
    342 } 
    343  
    344 int RenderTraverser::GetNumQueryCulledNodes() 
    345 { 
    346         return mNumQueryCulledNodes; 
    347 } 
    348  
    349 int RenderTraverser::GetNumFrustumCulledNodes() 
    350 { 
    351         return mNumFrustumCulledNodes; 
    352 } 
    353  
    354  
    355 int RenderTraverser::GetNumRenderedGeometry() 
    356 { 
    357         return mNumRenderedGeometry; 
    358 } 
    359  
    360  
    361 #endif 
     191}*/ 
    362192 
    363193 
    … …  
    474304 
    475305 
    476 } 
     306 
     307} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/RenderTraverser.h

    r2763 r2764  
    77#include "Bvh.h" 
    88#include "OcclusionQuery.h" 
    9  
     9#include "Camera.h" 
    1010 
    1111namespace CHCDemo 
    … …  
    1919struct TraversalStatistics 
    2020{ 
    21         friend class RenderTraverser; 
     21public: 
    2222 
    23 public: 
     23        void Reset(); 
    2424 
    2525        ////////// 
    2626        //-- several statistics for a rendering pass 
    2727 
    28         long GetRenderTime(); 
    29         int GetNumTraversedNodes(); 
    30         int GetNumQueryCulledNodes(); 
    31         int GetNumFrustumCulledNodes(); 
    32         int GetNumRenderedGeometry(); 
    33          
    34 protected: 
    35  
    36         // statistics 
    3728        int mNumTraversedNodes; 
    3829        int mNumQueryCulledNodes; 
    3930        int mNumFrustumCulledNodes; 
    4031        int mNumRenderedGeometry; 
     32        int mNumRenderedTriangles; 
     33        int mNumIssuedQueries; 
    4134 
    4235        long mRenderTime; 
    … …  
    5245{ 
    5346public: 
    54         //enum {RENDER_CULL_FRUSTUM, RENDER_STOP_AND_WAIT, RENDER_COHERENT, NUM_RENDERMODES}; 
     47        enum {CULL_FRUSTUM, STOP_AND_WAIT, CHC, NUM_RENDERMODES}; 
    5548 
    5649        RenderTraverser(); 
    … …  
    7164        */ 
    7265        void SetCamera(Camera *cam)  {mCamera = cam;} 
    73         /** sets view projection matrix 
    74         */ 
    75         //void SetProjViewMatrix(Matrix4x4 const &projViewMatrix); 
    7666        /** Sets visible pixels threshold for visibility classification 
    7767        */ 
    … …  
    9282        void RenderFrustum(); 
    9383 
     84        const TraversalStatistics &GetStats() const { return mStats; } 
    9485 
    9586protected: 
    … …  
    120111        void Switch2GLQueryState(); 
    121112 
     113        inline bool IntersectsNearPlane(BvhNode *node) const {return mBvh->GetDistance(node) < mCamera->GetNear();} 
     114 
    122115        void EnqueueNode(BvhNode *node); 
    123116 
    … …  
    129122        //-- members 
    130123 
    131         // /the current clip planes of the view frustum 
    132         //VecPlane mClipPlanes; 
    133         /// the indices of the np-vertices of the bounding box for view frustum culling 
    134         //int mNPVertexIndices[12]; 
    135  
    136124        /// the current camera 
    137125        Camera *mCamera; 
    138         //Matrix4x4 mProjViewMatrix; 
    139126        /// the root of the scene hierarchy 
    140127        Bvh *mBvh; 
    … …  
    144131        int mFrameID; 
    145132        int mVisibilityThreshold; 
    146          
    147         //unsigned int *mOcclusionQueries; 
    148         int mCurrentQueryIdx; 
     133 
    149134        bool mIsQueryMode; 
    150135         
    … …  
    155140 
    156141        QueryHandler mQueryHandler; 
     142 
     143        TraversalStatistics mStats; 
    157144}; 
    158145 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/StopAndWaitTraverser.cpp

    r2763 r2764  
    2323void StopAndWaitTraverser::Render() 
    2424{ 
     25        mStats.Reset(); 
    2526        mRenderState->mTexturesEnabled = false; 
    26         mDistanceQueue.push(mBvh->GetRoot()); 
     27        EnqueueNode(mBvh->GetRoot()); 
    2728 
    28  
     29        //cout<<"\n***** starting frame **********\n"; 
    2930        int traversed = 0; 
    3031        while (!mDistanceQueue.empty()) 
    … …  
    3334                mDistanceQueue.pop(); 
    3435         
     36                //float d = mBvh->GetDistance(node);cout << d << " "; 
     37 
    3538                // interesting for the visualization, so rest and set 
    3639                node->SetVisible(false); 
    37                 //mNumTraversedNodes ++; 
     40 
    3841 
    3942                if (mBvh->IsWithinViewFrustum(node)) 
    4043                { 
    4144                        // if intersects near plane assume visible and don't issue test 
    42                         if (mBvh->CalcDistance(node) < 0.1f) 
     45                        if (IntersectsNearPlane(node)) 
    4346                        { 
    4447                                TraverseNode(node); 
    … …  
    5053                                int visiblePixels = query->GetQueryResult(); 
    5154 
    52                                 if (visiblePixels > 0) 
     55                                if (visiblePixels > mVisibilityThreshold) 
    5356                                { 
    54                                         cout<< "visible: " << visiblePixels << endl; 
     57                                        //cout<< "visible: " << visiblePixels << endl; 
    5558                                        // update node's visited flag => needed for rendering 
    5659                                        // so set it also here 
    5760                                        //node->SetLastVisited(mFrameID); 
    5861                                        //node->SetVisible(true); 
    59                                         ++ traversed; 
     62                                 
    6063                                        TraverseNode(node); 
     64                                } 
     65                                else 
     66                                { 
     67                                        ++ mStats.mNumQueryCulledNodes; 
    6168                                } 
    6269                        } 
    … …  
    6471                else 
    6572                { 
    66                         //mNumFrustumCulledNodes ++; 
     73                        ++ mStats.mNumFrustumCulledNodes; 
    6774                } 
    6875                //cout << "intersect: " << intersect << " bx " << node->GetBox() << endl; 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Texture.cpp

    r2758 r2764  
    6060        glBindTexture(GL_TEXTURE_2D, mTexId); 
    6161        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
     62        //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
    6263        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
    6364        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/chc_revisited.vcproj

    r2756 r2764  
    128128                                AdditionalIncludeDirectories="GL;Devil/include" 
    129129                                PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" 
     130                                StringPooling="true" 
    130131                                RuntimeLibrary="2" 
     132                                BufferSecurityCheck="false" 
     133                                EnableEnhancedInstructionSet="2" 
    131134                                RuntimeTypeInfo="false" 
    132135                                UsePrecompiledHeader="0" 
    … …  
    154157                                OptimizeReferences="2" 
    155158                                EnableCOMDATFolding="2" 
     159                                OptimizeForWindows98="1" 
    156160                                TargetMachine="1" 
    157161                        /> 
    … …  
    241245                        </File> 
    242246                        <File 
     247                                RelativePath=".\SceneQuery.cpp" 
     248                                > 
     249                        </File> 
     250                        <File 
     251                                RelativePath=".\SceneQuery.h" 
     252                                > 
     253                        </File> 
     254                        <File 
    243255                                RelativePath=".\Timers.cpp" 
    244256                                > 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/chcdemo.cpp

    r2763 r2764  
    1616#include "FrustumCullingTraverser.h" 
    1717#include "StopAndWaitTraverser.h" 
    18  
     18#include "CHCTraverser.h" 
    1919 
    2020 
    … …  
    3636/// the current render state 
    3737RenderState state; 
    38  
     38/// the rendering algorithm 
     39int renderMode = RenderTraverser::CULL_FRUSTUM; 
     40/// the visibility threshold 
     41int threshold = 0; 
    3942// eye near plane distance 
    4043float nearDist = 0.1f;  
     44 
    4145int winWidth = 1024; 
    4246int winHeight = 768; 
    … …  
    4953bool showBoundingVolumes = false; 
    5054bool visMode = false; 
    51 bool showCreateParams = false; 
     55 
    5256 
    5357int currentFrame = -1; 
    … …  
    5862//mouse navigation state 
    5963int xEyeBegin, yEyeBegin, yMotionBegin, verticalMotionBegin, horizontalMotionBegin = 0; 
    60 //int renderMode = RenderTraverser::RENDER_COHERENT; 
    6164 
    6265const int renderTimeSize = 100; 
    … …  
    7982void UpdateEyeMtx(); 
    8083void SetupLighting(); 
     84void DisplayStats(); 
    8185 
    8286void begin2D(); 
    … …  
    97101long calcRenderTime(void); 
    98102void resetTimer(void); 
    99 void calcDecimalPoint(std::string &str, int d); 
    100  
     103void CalcDecimalPoint(std::string &str, int d); 
     104void ResetTraverser(); 
    101105 
    102106 
    … …  
    105109{ 
    106110        camera = new Camera(winWidth, winHeight); 
     111        camera->SetNear(nearDist); 
    107112 
    108113        glutInitWindowSize(winWidth, winHeight); 
    … …  
    145150        sceneBox = bvh->GetBox(); 
    146151 
    147         //traverser = new FrustumCullingTraverser(); 
    148         traverser = new StopAndWaitTraverser(); 
    149         traverser->SetHierarchy(bvh); 
    150         traverser->SetRenderState(&state); 
    151  
    152         //SetupProjection(800, 600, 60, sceneBox); 
     152        ResetTraverser(); 
     153 
    153154        //camera->LookAtBox(sceneBox); 
    154155        camera->LookInBox(sceneBox); 
    155         //camera->SetPosition(Vector3(0, 0, -3)); 
    156         //camera->SetDirection(Vector3(0, 0, 1)); 
    157156 
    158157        /// initialise rendertime array 
    … …  
    274273 
    275274 
     275void ResetTraverser() 
     276{ 
     277        DEL_PTR(traverser); 
     278 
     279        switch (renderMode) 
     280        { 
     281        case RenderTraverser::CULL_FRUSTUM: 
     282                traverser = new FrustumCullingTraverser(); 
     283                break; 
     284        case RenderTraverser::STOP_AND_WAIT: 
     285                traverser = new StopAndWaitTraverser(); 
     286                break; 
     287        case RenderTraverser::CHC: 
     288                traverser = new CHCTraverser(); 
     289                break; 
     290        default: 
     291                traverser = new FrustumCullingTraverser(); 
     292        } 
     293 
     294        traverser->SetHierarchy(bvh); 
     295        traverser->SetRenderState(&state); 
     296} 
     297 
     298 
    276299void SetupLighting() 
    277300{ 
    … …  
    343366void display(void)  
    344367{ 
    345         char * msg[] = {"Frustum culling only", "Hierarchical stop and wait", 
    346                                     "Coherent hierarchical culling"}; 
    347  
    348         char msg2[200]; 
    349         char msg3[200]; 
    350         char msg4[100]; 
    351         char msg5[100]; 
    352         char msg6[100]; 
    353         char msg7[100]; 
    354         char msg8[100]; 
    355  
    356  
    357         /*sprintf_s(msg2, "Traversed: %4d, frustum culled: %4d, query culled: %4d (of %d nodes)", 
    358                         traverser.GetNumTraversedNodes(), traverser.GetNumFrustumCulledNodes(), 
    359                         traverser.GetNumQueryCulledNodes(),  
    360                         traverser.GetHierarchy()->GetNumHierarchyNodes()); 
    361 */ 
    362         char *optstr[2] = {"", ", using optimization"}; 
    363          
    364         float fps = 1e3f; 
    365         long renderTime = calcRenderTime(); 
    366         if (renderTime) fps = 1e3f / (float)renderTime; 
    367  
    368         //sprintf_s(msg3, "Threshold: %4d, algorithm rendering time: %ld ms (%3.3f fps), queries: %s",  
    369         //      traverser.GetVisibilityThreshold(), renderTime / 1000, fps, optstr[useOptimization]); 
    370         sprintf_s(msg3, "render time: %ld ms (%3.3f fps), queries: %s",  renderTime, fps, optstr[useOptimization]); 
    371  
    372         string str; 
    373         string str2; 
    374  
    375         /*calcDecimalPoint(str, Geometry::CountTriangles(objectType) * traverser.GetNumRenderedGeometry()); 
    376         calcDecimalPoint(str2, Geometry::CountTriangles(objectType) * numObjects); 
    377  
    378         sprintf_s(msg4, "Rendered objects %d (of %d), rendered triangles: %s (of %s)",  
    379                         traverser.GetNumRenderedGeometry(), numObjects, str.c_str(), str2.c_str());  
    380 */ 
    381          
    382368        ++ currentFrame; 
    383369 
    … …  
    391377 
    392378        InitTiming(); 
    393  
    394379        long t1, t2; 
    395380 
    … …  
    404389 
    405390        traverser->Render(); 
    406 /* 
    407         bool usesTextures = false; 
    408  
    409         SceneEntityContainer::const_iterator sit, sit_end = sceneEntities.end(); 
    410  
    411         for (sit = sceneEntities.begin(); sit != sit_end; ++ sit) 
    412         { 
    413                 SceneEntity *entity = *sit; 
    414  
    415                 if (!usesTextures && entity->GetGeometry()->HasTexture()) 
    416                 { 
    417                         glEnable(GL_TEXTURE_2D); 
    418                         glEnableClientState(GL_TEXTURE_COORD_ARRAY); 
    419                         usesTextures = true; 
    420                 } 
    421                 else if (usesTextures && !entity->GetGeometry()->HasTexture()) 
    422                 { 
    423                         glDisable(GL_TEXTURE_2D); 
    424                         glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
    425                         usesTextures = false; 
    426                 } 
    427  
    428                 entity->Render(); 
    429         } 
    430 */ 
     391 
    431392        glDisableClientState(GL_VERTEX_ARRAY); 
    432393        glDisableClientState(GL_NORMAL_ARRAY); 
    … …  
    438399        t2 = GetTime(); 
    439400        long loop_time = TimeDiff(t1, t2); 
    440         //cout<<"t: " << loop_time<<endl; 
    441  
    442         /* 
    443         traverser.SetViewpoint(eyePos); 
    444         traverser.SetProjViewMatrix(eyeProjView); 
    445         traverser.Render(renderMode); 
    446         */ 
    447  
     401         
    448402        // cycle through rendertime array 
    449403        renderTimes[renderTimesIdx] = loop_time;// traverser.GetRenderTime(); 
    … …  
    455409        //if(visMode) displayVisualization(); 
    456410         
    457  
    458         begin2D(); 
    459          
    460         if(showHelp) 
    461         {        
    462                 drawHelpMessage(); 
    463         } 
    464         else 
    465         { 
    466                 glColor3f(1.0,1.0,1.0); 
    467                 //output(10, winHeight-10, msg[renderMode]); 
    468  
    469                 if(showStatistics) 
    470                 { 
    471                         if(showCreateParams) 
    472                         { 
    473                                 output(10, winHeight-150, msg8); 
    474                                 output(10, winHeight-130, msg7); 
    475                                 output(10, winHeight-110, msg6); 
    476                                 output(10, winHeight-90,  msg5); 
    477                         } 
    478  
    479                         output(10, winHeight-70, msg3); 
    480                         //output(10, winHeight-50, msg4); 
    481                         //output(10, winHeight-30, msg2); 
    482                 } 
    483         } 
    484         end2D(); 
    485  
     411        DisplayStats(); 
    486412        glutSwapBuffers(); 
    487413} 
    … …  
    491417void keyboard(const unsigned char c, const int x, const int y)  
    492418{ 
    493         //int threshold; 
    494         //HierarchyNode *hierarchy; 
    495  
    496419        switch(c)  
    497420        { 
    … …  
    500423                break; 
    501424        case 32: //space 
    502                 // renderMode = (renderMode + 1) % RenderTraverser::NUM_RENDERMODES; 
     425                renderMode = (renderMode + 1) % RenderTraverser::NUM_RENDERMODES; 
    503426                resetTimer(); 
    504                 //traverser.Render(renderMode);         // render once so stats are updated 
     427                ResetTraverser(); 
    505428                break; 
    506429        case 'h': 
    … …  
    518441                break; 
    519442        case '+': 
    520                 //threshold = traverser.GetVisibilityThreshold() + 10; 
    521                 //traverser.SetVisibilityThreshold(threshold); 
     443                threshold = traverser->GetVisibilityThreshold() + 10; 
     444                traverser->SetVisibilityThreshold(threshold); 
    522445                break; 
    523446        case '-': 
    524                 //threshold = traverser.GetVisibilityThreshold() - 10; 
    525                 //if(threshold < 0) threshold = 0; 
    526  
    527                 //traverser.SetVisibilityThreshold(threshold);           
     447                threshold = traverser->GetVisibilityThreshold() - 10; 
     448                if(threshold < 0) threshold = 0; 
     449 
     450                traverser->SetVisibilityThreshold(threshold);            
    528451                break; 
    529452        case '1': 
    … …  
    541464                setupVisView(); 
    542465                break; 
    543         case 'r': 
    544         case 'R': 
    545                 showCreateParams = !showCreateParams; 
    546                 break; 
    547466        case 'g': 
    548467        case 'G': 
    549468                useOptimization = !useOptimization; 
    550                 //traverser.SetUseOptimization(useOptimization); 
    551                 break; 
    552                 /* 
    553         case 'c': 
    554         case 'C':        
    555                 hierarchy = traverser.GetHierarchy(); 
    556                 // delete old hierarchy 
    557                 if (hierarchy) delete hierarchy;  
    558                 deleteGeometry(); 
    559  
    560                 maxTranslation[2] = -3.0 - zLength; 
    561                 numObjects = numNextObjects; 
    562                 objectType = nextObjectType; 
    563                  
    564                 hierarchy = generateHierarchy(numObjects); 
    565                 traverser.SetHierarchy(hierarchy); 
    566  
    567                 showCreateParams = false; 
    568  
    569                 traverser.Render(renderMode); // render once to update stats 
    570                 resetTimer(); 
    571                 break; 
    572                 */ 
     469                traverser->SetUseOptimization(useOptimization); 
    573470        default: 
    574471                return; 
    … …  
    694591 
    695592        // don't move in the vertical direction 
    696         Vector3 horView(viewDir[0], 0, viewDir[2]); 
    697          
    698         eyeXAngle = -0.2f *  M_PI * (xEyeBegin - x) / 180.0; 
     593        //Vector3 horView(viewDir[0], 0, viewDir[2]); 
     594        Vector3 horView(viewDir[0], viewDir[1], 0); 
     595         
     596        eyeXAngle = 0.2f *  M_PI * (xEyeBegin - x) / 180.0; 
    699597 
    700598        // rotate view vector 
    701         Matrix4x4 rot = RotationYMatrix(eyeXAngle); 
     599        //Matrix4x4 rot = RotationYMatrix(eyeXAngle); 
     600        Matrix4x4 rot = RotationZMatrix(eyeXAngle); 
    702601        viewDir = rot * viewDir; 
    703602 
    … …  
    746645        // the 90 degree rotated view vector  
    747646        // y zero so we don't move in the vertical 
    748         Vector3 rVec(viewDir[0], 0, viewDir[2]); 
    749          
    750         Matrix4x4 rot = RotationYMatrix(M_PI * 0.5f); 
     647        //Vector3 rVec(viewDir[0], 0, viewDir[2]); 
     648        Vector3 rVec(viewDir[0], viewDir[1], 0); 
     649         
     650        //Matrix4x4 rot = RotationYMatrix(M_PI * 0.5f); 
     651        Matrix4x4 rot = RotationZMatrix(M_PI * 0.5f); 
    751652        rVec = rot * rVec; 
    752653         
    753         pos += rVec * (x - horizontalMotionBegin) * 0.1f; 
    754         pos[1] += (verticalMotionBegin - y) * 0.1f; 
     654        pos -= rVec * (x - horizontalMotionBegin) * 0.1f; 
     655        //pos[1] += (verticalMotionBegin - y) * 0.1f; 
     656        pos[2] += (verticalMotionBegin - y) * 0.1f; 
    755657 
    756658        camera->SetPosition(pos); 
    … …  
    902804 
    903805// this function inserts a dezimal point after each 1000 
    904 void calcDecimalPoint(string &str, int d) 
     806void CalcDecimalPoint(string &str, int d) 
    905807{ 
    906808        vector<int> numbers; 
    … …  
    920822        } 
    921823         
    922         for (size_t i = numbers.size() - 2; i >= 0; i--) 
     824        for (int i = (int)numbers.size() - 2; i >= 0; i--) 
    923825        { 
    924826                sprintf_s(hstr, ",%03d", numbers[i]); 
    … …  
    926828        } 
    927829} 
     830 
     831 
     832void DisplayStats() 
     833{ 
     834        char *msg[] = {"Frustum Culling", "Stop and Wait", 
     835                                    "Coherent Culling"}; 
     836 
     837        char msg2[200]; 
     838        char msg3[200]; 
     839        char msg4[200]; 
     840 
     841 
     842        sprintf_s(msg2, "traversed: %4d, frustum culled: %4d, query culled: %4d (of %d nodes)", 
     843                          traverser->GetStats().mNumTraversedNodes, traverser->GetStats().mNumFrustumCulledNodes, 
     844                          traverser->GetStats().mNumQueryCulledNodes, bvh->GetNumVirtualNodes()); 
     845 
     846        char *optstr[2] = {"", ", using optimization"}; 
     847         
     848        float fps = 1e3f; 
     849        long renderTime = calcRenderTime(); 
     850        if (renderTime) fps /= (float)renderTime; 
     851 
     852        sprintf_s(msg3, "Threshold: %4d, render time: %ld ms (%3.3f fps), issued queries: %d%s",  
     853                traverser->GetVisibilityThreshold(), renderTime, fps, traverser->GetStats().mNumIssuedQueries, optstr[useOptimization]); 
     854 
     855        string str; 
     856        string str2; 
     857 
     858        int dummy = 0; 
     859        CalcDecimalPoint(str, dummy); 
     860        CalcDecimalPoint(str2, traverser->GetStats().mNumRenderedTriangles); 
     861 
     862        sprintf_s(msg4, "rendered objects %d (of %d), rendered triangles: %s (of %s)",  
     863                          traverser->GetStats().mNumRenderedGeometry, sceneEntities.size(), str.c_str(), str2.c_str());  
     864 
     865 
     866        begin2D(); 
     867         
     868        if(showHelp) 
     869        {        
     870                drawHelpMessage(); 
     871        } 
     872        else 
     873        { 
     874                glColor3f(1.0f ,1.0f ,1.0f ); 
     875                output(20, winHeight - 10, msg[renderMode]); 
     876 
     877                if(showStatistics) 
     878                { 
     879                        output(20, winHeight - 70, msg3); 
     880                        output(20, winHeight - 50, msg4); 
     881                        output(20, winHeight - 30, msg2); 
     882                } 
     883        } 
     884 
     885        end2D(); 
     886}        

  • GTP/trunk/App/Demos/Vis/CHC_revisited/common.cpp

    r2756 r2764  
    194194        // get the absolute path 
    195195        size_t c = strlen(name); 
    196         int i = c - 1; 
     196        size_t i = c - 1; 
    197197        bool wasDot = false; 
    198198 
    … …  
    258258StripPath(const char *s) 
    259259{ 
    260         const int len = strlen(s); 
    261  
    262         int i = len; 
     260        const size_t len = strlen(s); 
     261 
     262        size_t i = len; 
    263263        for (; i>0; i--) { 
    264264                if (s[i]=='/' || s[i]=='\\') 
Note: See TracChangeset for help on using the changeset viewer.