Ignore:
Timestamp:
06/27/08 13:33:46 (17 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/App/Demos/Vis/FriendlyCulling/src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderQueue.cpp

    r2800 r2801  
    77using namespace std; 
    88 
     9// sort by alpha, in second instance per texture 
     10//#define SORT_ALPHA 
    911 
    1012namespace CHCDemoEngine 
    … …  
    1214 
    1315 
    14 inline static bool IsLower(SceneEntity *ent1, SceneEntity *ent2) 
     16inline static bool CompTexture(SceneEntity *ent1, SceneEntity *ent2) 
    1517{ 
    1618        // group by texture size 
    … …  
    2527 
    2628 
    27 inline static bool IsLower2(SceneEntity *ent1, SceneEntity *ent2) 
     29#ifdef SORT_ALPHA 
     30 
     31inline static bool CompMat(SceneEntity *ent1, SceneEntity *ent2) 
     32{  
     33        return ent1->GetMaterial()->IsAlphaTestEnabled() < ent2->GetMaterial()->IsAlphaTestEnabled(); 
     34} 
     35 
     36#else 
     37 
     38inline static bool CompMat(SceneEntity *ent1, SceneEntity *ent2) 
    2839{ 
    2940        return ent1->GetMaterial() < ent2->GetMaterial(); 
    3041} 
     42 
     43#endif 
    3144 
    3245 
    … …  
    3750 
    3851RenderQueue::RenderQueue(RenderState *state): 
    39 mState(state) 
     52mState(state), mMinSizeForSorting(3) 
    4053{ 
    4154} 
    … …  
    100113 
    101114        // show ordering by material 
    102         Debug << "\nmaterial ptr: " << endl; 
     115        Debug << "\nmaterial: " << endl; 
    103116         
    104117        for (sit = mEntities.begin(); sit != sit_end; ++ sit) 
    105118        { 
     119#ifdef SORT_ALPHA 
     120                Debug << (*sit)->GetMaterial()->IsAlphaTestEnabled() << " "; 
     121#else 
    106122                Debug << (*sit)->GetMaterial() << " "; 
     123#endif 
    107124        } 
    108125} 
    … …  
    118135void RenderQueue::Sort() 
    119136{ 
     137#ifdef SORT_ALPHA 
     138        // sort by texture size 
     139        sort(mEntities.begin(), mEntities.end(), CompTexture); 
     140        // sort by alpha test enabled 
     141        stable_sort(mEntities.begin(), mEntities.end(), CompMat); 
     142#else 
    120143        // sort by material 
    121         sort(mEntities.begin(), mEntities.end(), IsLower2); 
     144        sort(mEntities.begin(), mEntities.end(), CompMat); 
    122145        // sort by texture size 
    123         stable_sort(mEntities.begin(), mEntities.end(), IsLower); 
     146        stable_sort(mEntities.begin(), mEntities.end(), CompTexture); 
     147#endif 
    124148} 
    125149 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderQueue.h

    r2795 r2801  
    3939        /** Returns the number entities currently in the queue. 
    4040        */ 
    41         int GetSize() const { return (int)mEntities.size(); } 
     41        inline int GetSize() const { return (int)mEntities.size(); } 
    4242        /** Renders and clears the queue. 
    4343        */ 
    4444        void Apply(); 
    45         /** Prints the ordering in the render queue. 
     45        /** Prints the current state of the render queue. 
    4646        */ 
    4747        void Print(); 
    4848 
    49         PerfTimer sortTimer; 
    50  
    51  
    5249protected: 
    5350 
    54         /** Sorts the render queue according to some parameters. 
     51        /** Sorts the render queue by materials / textures. 
    5552        */ 
    5653        void Sort(); 
    … …  
    6461}; 
    6562 
     63/// measures sort time for detailed benchmarks 
     64static PerfTimer sortTimer; 
     65 
     66 
    6667} 
    6768 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.cpp

    r2800 r2801  
    1212mAlphaTestEnabled(false),  
    1313mTexturesEnabled(false),  
    14 mMode(RENDER)  
     14mMode(RENDER), 
     15mIsDepthPass(false) 
    1516{ 
    1617        Reset();  
    … …  
    2930        if (mode == QUERY) 
    3031        { 
    31                 //glDisableClientState(GL_NORMAL_ARRAY); 
    32                 glDisable(GL_LIGHTING); 
    33                 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); 
     32                if (!mIsDepthPass) 
     33                { 
     34                        glDisable(GL_LIGHTING); 
     35                        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); 
     36                } 
     37 
    3438                glDepthMask(GL_FALSE); 
    3539 
    … …  
    4145                //-- restore render state 
    4246 
    43                 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 
     47                if (!mIsDepthPass) 
     48                { 
     49                        glEnable(GL_LIGHTING); 
     50                        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 
     51                } 
     52 
    4453                glDepthMask(GL_TRUE); 
    45                 glEnable(GL_LIGHTING); 
    4654        } 
    4755 
    … …  
    5260void RenderState::SetState(bool texturing, bool alphaTest) 
    5361{ 
    54         if (mTexturesEnabled && !texturing)  
    55         { 
    56                 mTexturesEnabled = false; 
    57                 glDisable(GL_TEXTURE_2D); 
    58                 glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
    59         } 
    60         else if (!mTexturesEnabled && texturing) 
    61         { 
    62                 mTexturesEnabled = true; 
    63                 //glEnable(GL_TEXTURE_2D); 
    64                 //glEnableClientState(GL_TEXTURE_COORD_ARRAY); 
    65         } 
    66  
    6762        if (mAlphaTestEnabled && !alphaTest)  
    6863        { 
    … …  
    7368        { 
    7469                mAlphaTestEnabled = true; 
    75                 //glEnable(GL_ALPHA_TEST); 
    76                 //glAlphaFunc(GL_GEQUAL, 0.5f); 
     70                glEnable(GL_ALPHA_TEST); 
     71        } 
     72 
     73        // allow only alpha textures in depth pass 
     74        if (mTexturesEnabled &&  
     75                (!texturing || mIsDepthPass && !mAlphaTestEnabled)) 
     76        { 
     77                mTexturesEnabled = false; 
     78                glDisable(GL_TEXTURE_2D); 
     79                glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     80        } 
     81        else if (!mTexturesEnabled && texturing) 
     82        { 
     83                if (!mIsDepthPass || mAlphaTestEnabled) 
     84                { 
     85                        mTexturesEnabled = true; 
     86                        glEnable(GL_TEXTURE_2D); 
     87                        glEnableClientState(GL_TEXTURE_COORD_ARRAY); 
     88                } 
    7789        } 
    7890} 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.h

    r2800 r2801  
    4848        inline int GetCurrentVboId() { return mCurrentVboId; } 
    4949 
     50        void SetDepthPass(bool depthPass) { mIsDepthPass = depthPass; } 
     51        bool IsDepthPass() { return mIsDepthPass; } 
    5052 
    5153protected: 
    … …  
    5759 
    5860        int mCurrentVboId; 
     61 
     62        bool mIsDepthPass; 
    5963}; 
    6064 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderTraverser.cpp

    r2800 r2801  
    2929        mNumBatches = 0; 
    3030 
    31         mRenderTime = 0; 
    3231        mWaitTime = 0; 
    3332        mQueryTime = 0; 
    … …  
    5049mAssumedVisibleFrames(10), 
    5150mMaxBatchSize(50), 
    52 mUseTightBounds(false), mShowBounds(false) 
     51mUseTightBounds(false),  
     52mShowBounds(false), 
     53mRenderQueue(NULL) 
    5354{ 
    5455} 
    … …  
    111112 
    112113                        if (mUseRenderQueue) 
    113                                 mRenderQueue.Enqueue(ent); 
     114                                mRenderQueue->Enqueue(ent); 
    114115                        else 
    115116                                ent->Render(mRenderState); 
     117 
     118                        // store the visible entities for rendering in the second pass 
     119                        if (mUseDepthPass) 
     120                                mVisibleObjects.push_back(ent); 
    116121                }                
    117122        } 
    … …  
    128133{ 
    129134        mRenderState = state; 
    130         mRenderQueue.SetRenderState(state); 
    131135} 
    132136 
    … …  
    134138void RenderTraverser::RenderScene() 
    135139{ 
    136         PerfTimer timer; 
    137          
    138         glFinish(); 
    139  
    140         timer.Start(); 
     140        mVisibleObjects.clear(); 
    141141 
    142142        glEnableClientState(GL_VERTEX_ARRAY); 
    143         glEnableClientState(GL_NORMAL_ARRAY); 
     143         
     144        if (!mUseDepthPass) 
     145                glEnableClientState(GL_NORMAL_ARRAY); 
    144146 
    145147        ++ mFrameId; 
    … …  
    166168        glDisableClientState(GL_VERTEX_ARRAY); 
    167169        glDisableClientState(GL_NORMAL_ARRAY); 
    168  
    169         glFinish(); 
    170  
    171  
    172         mStats.mRenderTime = timer.Elapsedms(); 
    173          
    174         //Debug << "type: " << GetType() << endl; 
    175         //if (mUseRenderQueue) Debug << "rq sort: " << 1e3f * mRenderQueue.sortTimer.TotalTime() << " ms" << endl; 
    176         /* 
     170         
     171 
     172#ifdef PRINT_VERBOSE_BENCHMARKS 
     173 
     174        Debug << "traversal type: " << GetType() << endl; 
     175        if (mUseRenderQueue) Debug << "rq sort: " << 1e3f * mRenderQueue.sortTimer.TotalTime() << " ms" << endl; 
     176         
    177177        Debug << "wait time: " << 1e3f * waitTimer.TotalTime() << " ms" << endl; 
    178178        Debug << "query time: " << 1e3f * queryTimer.TotalTime() << " ms" << endl; 
    179179        Debug << "rest time: " << 1e3f * restTimer.TotalTime() << " ms" << endl; 
    180         */ 
     180 
     181#endif 
    181182} 
    182183 
    … …  
    186187        mUseRenderQueue = useRenderQueue; 
    187188        //std::cout << "using render queue: " << mUseRenderQueue << std::endl; 
     189} 
     190 
     191 
     192void RenderTraverser::SetUseDepthPass(bool b) 
     193{ 
     194        mUseDepthPass = b; 
    188195} 
    189196 
    … …  
    275282                ++ mStats.mNumStateChanges; 
    276283                  
    277         if (mRenderQueue.GetSize() > 0) 
     284        if (mRenderQueue->GetSize() > 0) 
    278285                ++ mStats.mNumBatches; 
    279286 
    280         mRenderQueue.Apply(); 
    281 } 
    282  
    283  
    284 } 
     287        mRenderQueue->Apply(); 
     288} 
     289 
     290 
     291} 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderTraverser.h

    r2800 r2801  
    3939        int mNumStateChanges; 
    4040        int mNumBatches; 
    41          
    42         double mRenderTime; 
    4341 
    4442        double mWaitTime; 
    … …  
    5351{ 
    5452public: 
    55          
     53 
     54        /** Default constructor. 
     55        */ 
     56        RenderTraverser(); 
     57        /** Virtual constructor, has to be redefined in subclasses 
     58        */ 
     59        virtual ~RenderTraverser(); 
     60        /** Abstract method that traverses and renders the scene 
     61        */ 
     62        void RenderScene(); 
     63 
    5664        enum {CULL_FRUSTUM, STOP_AND_WAIT, CHC, CHCPLUSPLUS, NUM_TRAVERSAL_TYPES}; 
    57  
    58         RenderTraverser(); 
    59         ~RenderTraverser(); 
    60  
    61         //! Renders the scene with the specified method 
    62         /** 
    63                 The method is one of 
     65        /** Returns the type of the traversal. 
     66            The type is one of 
    6467                CULL_FRUSTUM: view frustum culling only 
    6568                STOP_AND_WAIT: hierarchical stop and wait algorithm 
    … …  
    6770                CHCPLUSPLUS: coherent hierarchical algorithm revisited 
    6871        */ 
    69         void RenderScene(); 
     72        virtual int GetType() const = 0; 
    7073        /** Sets the scene hierarchy. 
    7174        */ 
    … …  
    7477        */ 
    7578        void SetCamera(Camera *cam)  {mCamera = cam;} 
     79        /** Sets the render queue. 
     80        */ 
     81        void SetRenderQueue(RenderQueue *rq) {mRenderQueue =rq;} 
    7682        /** Renders a visualization of the hierarchy 
    7783        */ 
    … …  
    8692        */ 
    8793        int GetCurrentFrameId() const { return mFrameId; } 
    88  
    89  
     94         
    9095        ////////////////// 
    9196        //-- options for the different rendering algorithms 
    … …  
    95100        */ 
    96101        void SetUseRenderQueue(bool useRenderQueue); 
     102        /** If depth pass should be used. 
     103                If true, the entities found visible in the current pass are stored 
     104        */ 
     105        void SetUseDepthPass(bool storeVisibleObjects); 
    97106        /** Sets visible pixels threshold for visibility classification 
    98107        */ 
    99108        void SetVisibilityThreshold(int threshold); 
    100  
    101109 
    102110        /////////////////// 
    103111        //-- CHC / CHC ++ related options 
    104112 
    105  
    106113        /** CHC optimization to query the geometry itself instead of the bounding box. 
    107114        */ 
    … …  
    122129        */ 
    123130        void SetShowBounds(bool showBounds); 
    124  
    125         virtual int GetType() const = 0; 
    126          
     131        /** Returns the entities found visible in current frame 
     132            (only if StoreVisibleObjects is set) 
     133        */ 
     134        const SceneEntityContainer &GetVisibleObjects() const { return mVisibleObjects; } 
     135 
    127136protected: 
    128137 
    … …  
    172181        TraversalStatistics mStats; 
    173182         
    174         RenderQueue mRenderQueue; 
     183        RenderQueue *mRenderQueue; 
     184 
     185        /// the objects found visible in current frame 
     186        SceneEntityContainer mVisibleObjects; 
    175187 
    176188 
    … …  
    194206        bool mShowBounds; 
    195207 
    196         // timers 
    197         PerfTimer restTimer; 
    198         PerfTimer waitTimer; 
    199         PerfTimer queryTimer; 
     208        bool mUseDepthPass; 
    200209}; 
    201210 
    … …  
    207216 
    208217 
     218/// timers for detailed benchmarks 
     219static PerfTimer restTimer; 
     220static PerfTimer waitTimer; 
     221static PerfTimer queryTimer; 
     222 
    209223} 
    210224 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Timer/BenchTimer.h

    r2777 r2801  
    3333// we definitely want timers to be inlined! 
    3434#define PERFTIMER_INLINE __forceinline 
    35  
    36  
     35     
     36    #ifndef WIN32_LEAN_AND_MEAN 
    3737        #define WIN32_LEAN_AND_MEAN 
     38    #endif 
    3839        #define NOMINMAX 
    3940        #include <windows.h>    // for LARGE_INTEGER 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Timer/PerfTimer.h

    r2777 r2801  
    1313// 
    1414//  15-jul-99 14:00:00  mw      created 
    15 // =========================================================================== 
    16 //  $Header: /usr/local/cvsyare/cvsyare/include/yareutils/PerfTimer.h,v 1.1 2002/09/24 16:53:47 wimmer Exp $  
    17 // =========================================================================== 
     15 
    1816 
    1917#ifndef NO_PRAGMA_ONCE 
    … …  
    2422#define _PERFTIMER_H 
    2523 
    26 //#define NO_RDTSC_TIMER 
     24// RDTSC timer does not work with modern CPUs 
     25#define NO_RDTSC_TIMER 
    2726 
    2827#ifdef WIN32 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp

    r2800 r2801  
    2222#include "Timer/PerfTimer.h" 
    2323#include "SceneQuery.h" 
     24#include "RenderQueue.h" 
    2425 
    2526 
    … …  
    6061 
    6162SceneQuery *sceneQuery = NULL; 
     63RenderQueue *renderQueue = NULL; 
     64 
    6265 
    6366/// these values get scaled with the frame rate 
    … …  
    6669/// elapsed time in seconds 
    6770double elapsedTime = 1.0f; 
     71double algTime = 1.0f; 
    6872 
    6973int winWidth = 1024; 
    … …  
    99103bool useRenderQueue = true; 
    100104bool useMultiQueries = true; 
    101  
    102105bool flyMode = true; 
    103  
    104 /// the accumulated z axis rotation 
    105 float rotation = 0; 
     106bool depthPass = false; 
     107 
    106108 
    107109SceneEntityContainer skyGeometry; 
    … …  
    126128void DrawHelpMessage(); 
    127129void RenderSky(); 
     130void RenderVisibleObjects(); 
    128131 
    129132void Begin2D(); 
    … …  
    146149void KeyVerticalMotion(float shift); 
    147150 
     151void PlaceViewer(const Vector3 &oldPos); 
     152 
    148153 
    149154inline float KeyRotationAngle() { return keyRotation * elapsedTime; } 
    … …  
    162167        visCamera->SetNear(0.0f); 
    163168        visCamera->Yaw(.5 * M_PI); 
     169 
     170        renderQueue = new RenderQueue(&state); 
    164171 
    165172        glutInitWindowSize(winWidth, winHeight); 
    … …  
    268275        //glEnable(GL_ALPHA_TEST); 
    269276        glDisable(GL_ALPHA_TEST); 
    270         glAlphaFunc(GL_GEQUAL, 0.1f); 
     277        glAlphaFunc(GL_GEQUAL, 0.5f); 
    271278 
    272279        glFrontFace(GL_CCW); 
    … …  
    283290        glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseColor); 
    284291        glMaterialfv(GL_FRONT, GL_SPECULAR, specularColor); 
     292 
     293        glDepthFunc(GL_LESS); 
    285294} 
    286295 
    … …  
    298307                "'F5',          - toggles between fly / walkmode", 
    299308                "'F6',          - shows/hides parameters", 
     309                "'F7',          - depth pass", 
    300310                "'SPACE'        - cycles through occlusion culling algorithms", 
    301311                "", 
    … …  
    380390        traverser->SetCamera(camera); 
    381391        traverser->SetHierarchy(bvh); 
     392        traverser->SetRenderQueue(renderQueue); 
    382393        traverser->SetRenderState(&state); 
    383394        traverser->SetUseOptimization(useOptimization); 
    … …  
    388399        traverser->SetUseMultiQueries(useMultiQueries); 
    389400        traverser->SetUseTightBounds(useTightBounds); 
     401        traverser->SetUseDepthPass(depthPass); 
     402        traverser->SetRenderQueue(renderQueue); 
    390403} 
    391404 
    … …  
    430443 
    431444        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); 
    432         //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); 
    433         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); 
     445        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); 
     446        //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); 
    434447        //glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_SEPARATE_SPECULAR_COLOR_EXT); 
    435448        glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_SINGLE_COLOR_EXT); 
    … …  
    481494 
    482495void Display()  
    483 { 
     496{        
     497        PerfTimer frameTimer, algTimer; 
     498        frameTimer.Start(); 
     499 
    484500        Vector3 oldPos = camera->GetPosition(); 
    485  
    486         PerfTimer frameTimer; 
    487         frameTimer.Start(); 
    488501 
    489502        if (leftKeyPressed) 
    … …  
    500513                KeyVerticalMotion(KeyShift()); 
    501514 
    502         Vector3 playerPos = camera->GetPosition(); 
    503          
    504         if (!flyMode) 
    505         { 
    506         Vector3 playerPos = camera->GetPosition(); 
    507  
    508                 bool validIntersect = sceneQuery->CalcIntersection(playerPos); 
    509  
    510                 if (validIntersect && 
    511                         (( playerPos.z - oldPos.z) < bvh->GetBox().Size(2) * 1e-1f)) 
    512                 { 
    513         camera->SetPosition(playerPos); 
    514                 } 
    515         } 
     515        // place view on ground 
     516        if (!flyMode) PlaceViewer(oldPos); 
     517 
     518        // note: have to flush queue in order to get reliable timings 
     519        // for optimal performance, remove this 
     520        glFinish(); 
     521 
     522        algTimer.Start(); 
    516523 
    517524        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
     525 
     526        glDepthFunc(GL_LESS); 
     527        glDisable(GL_TEXTURE_2D); 
     528        glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     529 
     530        // render without shading 
     531        if (depthPass)  
     532        { 
     533                state.SetDepthPass(true); 
     534                glDisable(GL_LIGHTING); 
     535        } 
     536        else 
     537        { 
     538                state.SetDepthPass(false); 
     539                glEnable(GL_LIGHTING); 
     540        } 
    518541 
    519542        // bring eye modelview matrix up-to-date 
    … …  
    523546        traverser->RenderScene(); 
    524547 
    525          
     548 
     549        ////// 
     550        //-- other rendering 
     551 
     552        glEnableClientState(GL_VERTEX_ARRAY); 
     553        glEnableClientState(GL_NORMAL_ARRAY); 
     554 
     555 
     556        // reset depth pass and render visible objects 
     557        if (depthPass)  
     558        { 
     559                RenderVisibleObjects(); 
     560        } 
     561         
     562 
    526563        /////////////// 
    527564        //-- render sky 
    528565 
    529566        RenderSky(); 
    530          
     567 
     568        state.Reset(); 
     569 
     570        glDisableClientState(GL_VERTEX_ARRAY); 
     571        glDisableClientState(GL_NORMAL_ARRAY); 
     572 
     573 
     574         
     575        // note: have to flush queue in order to get reliable timings 
     576        // for optimal performance, remove this 
     577        glFinish(); 
     578        algTime = algTimer.Elapsedms(); 
     579 
     580        /////////// 
     581 
    531582        if (visMode) DisplayVisualization(); 
    532583         
    … …  
    719770                flyMode = !flyMode; 
    720771                break; 
     772        case GLUT_KEY_F7: 
     773                depthPass = !depthPass; 
     774                traverser->SetUseDepthPass(depthPass); 
     775                break; 
    721776        case GLUT_KEY_LEFT: 
    722777                { 
    … …  
    9881043        DEL_PTR(camera); 
    9891044        DEL_PTR(loader); 
     1045        DEL_PTR(renderQueue); 
    9901046} 
    9911047 
    … …  
    10321088 
    10331089 
    1034         static double renderTime = traverser->GetStats().mRenderTime; 
     1090        static double renderTime = algTime; 
    10351091        const float expFactor = 0.3f; 
    1036         renderTime = traverser->GetStats().mRenderTime * expFactor + (1.0f - expFactor) * renderTime; 
     1092 
     1093        // if there was something fishy going on in this frame => don't count 
     1094        if (algTime < 1000)  
     1095                renderTime = algTime * expFactor + (1.0f - expFactor) * algTime; 
    10371096 
    10381097        accumulatedTime += renderTime; 
    … …  
    10581117                      assumedVisibleFrames, maxBatchSize); 
    10591118 
    1060         sprintf(msg3, "render queue: %d, multiqueries: %d, tight bounds: %d",  
    1061                       useRenderQueue, useMultiQueries, useTightBounds); 
     1119        sprintf(msg3, "render queue: %d, depth pass: %d, multiqueries: %d, tight bounds: %d",  
     1120                      useRenderQueue, depthPass, useMultiQueries, useTightBounds); 
    10621121 
    10631122        string str; 
    … …  
    10881147        else 
    10891148        { 
    1090         //      glColor3f(1.0f, 1.0f, 1.0f); 
    1091                 glColor3f(1.0f, 0.0f, 0.0f); 
     1149                glColor3f(1.0f, 1.0f, 1.0f); 
     1150                //glColor3f(1.0f, 0.0f, 0.0f); 
    10921151                Output(850, 30, msg[renderMode]); 
    10931152 
    … …  
    11151174void RenderSky() 
    11161175{ 
    1117         glEnableClientState(GL_VERTEX_ARRAY); 
    1118         glEnableClientState(GL_NORMAL_ARRAY); 
    1119  
    11201176        SceneEntityContainer::const_iterator sit, sit_end = skyGeometry.end(); 
    11211177 
    11221178        for (sit = skyGeometry.begin(); sit != sit_end; ++ sit) 
    11231179                (*sit)->Render(&state); 
    1124  
    1125         glDisableClientState(GL_VERTEX_ARRAY); 
    1126         glDisableClientState(GL_NORMAL_ARRAY); 
    1127  
     1180} 
     1181 
     1182 
     1183void RenderVisibleObjects() 
     1184{ 
     1185        state.SetDepthPass(false); 
    11281186        state.Reset(); 
    1129 } 
     1187 
     1188        glEnable(GL_LIGHTING); 
     1189        glDepthFunc(GL_LEQUAL); 
     1190 
     1191        //cout << "visible: " << (int)traverser->GetVisibleObjects().size() << endl; 
     1192 
     1193        SceneEntityContainer::const_iterator sit,  
     1194                sit_end = traverser->GetVisibleObjects().end(); 
     1195 
     1196        for (sit = traverser->GetVisibleObjects().begin(); sit != sit_end; ++ sit) 
     1197                renderQueue->Enqueue(*sit); 
     1198                 
     1199        renderQueue->Apply(); 
     1200 
     1201        glDepthFunc(GL_LESS); 
     1202} 
     1203 
     1204 
     1205void PlaceViewer(const Vector3 &oldPos) 
     1206{ 
     1207        Vector3 playerPos = camera->GetPosition(); 
     1208 
     1209        bool validIntersect = sceneQuery->CalcIntersection(playerPos); 
     1210 
     1211        if (validIntersect && 
     1212                (( playerPos.z - oldPos.z) < bvh->GetBox().Size(2) * 1e-1f)) 
     1213        { 
     1214                camera->SetPosition(playerPos); 
     1215        } 
     1216} 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/common.h

    r2800 r2801  
    494494#define INITIAL_TRIANGLES_PER_VIRTUAL_LEAVES 1000 
    495495 
    496 } 
    497  
    498 #endif 
    499  
    500  
    501  
    502  
    503  
    504  
    505  
    506  
     496// #define PRINT_VERBOSE_BENCHMARKS 
     497} 
     498 
     499#endif 
     500 
     501 
     502 
     503 
     504 
     505 
     506 
     507 
Note: See TracChangeset for help on using the changeset viewer.