Changeset 2955


Ignore:
Timestamp:
09/18/08 08:06:31 (16 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/Material.cpp

    r2844 r2955  
    7474        } 
    7575 
    76         if (state->GetRenderType() == RenderState::DEFERRED) 
     76        if (state->GetRenderPassType() == RenderState::DEFERRED) 
    7777        { 
    7878                if (mTexture) 
    … …  
    8787                } 
    8888        } 
    89         else if (state->GetRenderType() == RenderState::FIXED) 
     89        else if (state->GetRenderPassType() == RenderState::FIXED) 
    9090        { 
    9191                glMaterialfv(GL_FRONT, GL_AMBIENT, (float *)&mAmbientColor.r); 

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

    r2950 r2955  
    2323mMode(RENDER), 
    2424mRenderType(FIXED), 
    25 mUseAlphaToCoverage(true) 
     25mUseAlphaToCoverage(true), 
     26mLockCullFaceEnabled(false) 
    2627{ 
    2728        Reset();  
    … …  
    8283void RenderState::SetState(bool texturing, bool alphaTest, bool cullFace) 
    8384{ 
    84         if (mCullFaceEnabled && !cullFace)  
     85        if (!mLockCullFaceEnabled) 
    8586        { 
    86                 mCullFaceEnabled = false; 
    87                 glDisable(GL_CULL_FACE); 
     87                if (mCullFaceEnabled && !cullFace)  
     88                { 
     89                        mCullFaceEnabled = false; 
     90                        glDisable(GL_CULL_FACE); 
     91                } 
     92                else if (!mCullFaceEnabled && cullFace) 
     93                { 
     94                        mCullFaceEnabled = true; 
     95                        glEnable(GL_CULL_FACE); 
     96                } 
    8897        } 
    89         else if (!mCullFaceEnabled && cullFace) 
    90         { 
    91                 mCullFaceEnabled = true; 
    92                 glEnable(GL_CULL_FACE); 
    93         } 
    94  
    9598        if (mAlphaTestEnabled && !alphaTest)  
    9699        { 
    … …  
    144147        mCurrentVboId = -1; 
    145148 
    146         SetState(false, false, true); 
     149        mCullFaceEnabled = true; 
     150        glEnable(GL_CULL_FACE); 
     151         
     152        mAlphaTestEnabled = false; 
     153         
     154        glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB); 
     155        glDisable(GL_ALPHA_TEST); 
     156 
     157        mTexturesEnabled = false; 
     158 
     159        glDisable(GL_TEXTURE_2D); 
     160        glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     161 
    147162        SetState(RENDER); 
    148163} 
    … …  
    155170 
    156171 
     172void RenderState::SetRenderPassType(RenderPassType t)  
     173{  
     174        mRenderType = t;  
    157175} 
     176 
     177 
     178RenderState::RenderPassType RenderState::GetRenderPassType() const  
     179{ 
     180        return mRenderType;  
     181} 
     182 
     183 
     184void RenderState::LockCullFaceEnabled(bool lockCull) 
     185{  
     186        mLockCullFaceEnabled =  lockCull;  
     187} 
     188 
     189 
     190} 

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

    r2948 r2955  
    2424        }; 
    2525 
    26         enum RenderType 
     26        /// the used render type for this render pass 
     27        enum RenderPassType 
    2728        { 
    2829                FIXED, 
    2930                DEPTH_PASS, 
    30                 DEFERRED, 
    31                 DEPTH_PASS_DEFERRED, 
    32                 NUM_RENDER_TYPES 
     31                DEFERRED 
    3332        }; 
    3433 
    … …  
    3837         
    3938        ~RenderState() { Reset(); }; 
    40  
    4139        /** This must be called each time before and after an occlusion test. 
    4240                Mode is one of render mode or query mode. Returns true if a state 
    … …  
    6260        */ 
    6361        void SetUseAlphaToCoverage(bool useAlphaToCoverage); 
    64  
    65         void SetRenderType(RenderType type) { mRenderType = type; } 
    66         RenderType GetRenderType() const { return mRenderType; } 
    67  
    68  
    69         /////////////////// 
     62        /** Sets the type of rendering used (foreward, depth pass, deferred) 
     63        */ 
     64        void SetRenderPassType(RenderPassType t); 
     65        /** See Set 
     66        */ 
     67        RenderPassType GetRenderPassType() const; 
     68        /** If true, the current value of cull face enabled / disable will 
     69                not be changed by the render state. 
     70        */ 
     71        void LockCullFaceEnabled(bool lockCull); 
    7072 
    7173 
    … …  
    9092        int mCurrentVboId; 
    9193 
    92         RenderType mRenderType; 
     94        RenderPassType mRenderType; 
    9395 
    9496        bool mUseAlphaToCoverage; 
     97 
     98        bool mLockCullFaceEnabled; 
    9599}; 
    96100 

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

    r2954 r2955  
    197197        for (int i = 0; i < mNumSamples; ++ i) 
    198198        { 
    199                 Sample2 spl = s[i]; 
     199                Sample2 &spl = s[i]; 
    200200 
    201201                float len = sqrt(spl.x * spl.x + spl.y * spl.y); 

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

    r2954 r2955  
    11#include "SkyPreetham.h" 
     2#include "common.h" 
     3#include "Vector3.h" 
     4 
     5 
    26//#include <rendering/effect/FEffect.h> 
    37//#include <rendering/FVertexbuffer.h> 
    48 
    59 
     10inline float CBQ(float x) 
     11{ 
     12        return x * x * x; 
     13} 
     14 
     15 
     16inline float SQR(float x) 
     17{ 
     18        return x * x ; 
     19} 
    620 
    721 
    … …  
    923 
    1024 
    11 SkyPreetham::SkyPreetham(): 
    12         mEffect(NULL), 
    13         mTurbidity(4.0), 
    14         mSunEffect(NULL), 
    15         mSunTexture(NULL), 
    16         mSunQuad(NULL) 
     25SkyPreetham::SkyPreetham(float turbitity): 
     26//      mEffect(NULL), 
     27        mTurbidity(turbitity) 
     28//      mSunEffect(NULL), 
     29//      mSunTexture(NULL), 
     30//      mSunQuad(NULL) 
    1731{ 
    18         mEffect = D().getScene().getEffect("../effects/sky_preetham.fx"); 
     32/*      mEffect = D().getScene().getEffect("../effects/sky_preetham.fx"); 
    1933 
    2034        mVertexBuffer = D().getScene().getVertexBuffer("../models/sky.vbo"); 
    … …  
    2236        mSunEffect = D().getScene().getEffect("../effects/sky_sun.fx"); 
    2337        mSunTexture = D().getScene().getTexture2D("../textures/sky_sun.png"); 
    24  
    25         createSunQuad(); 
     38*/ 
     39        CreateSunQuad(); 
    2640} 
    2741 
    … …  
    2943SkyPreetham::~SkyPreetham() 
    3044{ 
    31         FDelete(mSunQuad); 
     45        //DEL_PTR(mSunQuad); 
    3246} 
    3347 
    3448 
    3549 
    36 void SkyPreetham::Compute() 
     50void SkyPreetham::Compute(const Vector3 &sunDir) 
    3751{ 
     52        float sun_theta[2]; 
    3853 
    39         FVector2 sun_theta; 
    40         FVector3 l_dir = D().getScene().getLight().getDirection(); 
    41         mTurbidity = D().getScene().getLight().getTurbitity(); 
     54        sun_theta[0] = acos(sunDir.y); 
    4255 
    43         sun_theta.x = acos(l_dir.y); 
    44         sun_theta.y = cos( sun_theta.x ) * cos( sun_theta.x ); 
     56        const float cos_theta =  cos(sun_theta[0]); 
     57        sun_theta[1] = cos_theta * cos_theta; 
    4558 
     59        Vector3 zenithColor; 
    4660 
    47 #define CBQ(X)          ((X) * (X) * (X)) 
    48 #define SQR(X)          ((X) * (X)) 
     61        zenithColor.x = ( 0.00165f * CBQ(sun_theta[0]) - 0.00374f * SQR(sun_theta[0]) + 0.00208f * sun_theta[0] + 0.0f)     * SQR(mTurbidity) +  
     62                                    (-0.02902f * CBQ(sun_theta[0]) + 0.06377f * SQR(sun_theta[0]) - 0.03202f * sun_theta[0] + 0.00394f) * mTurbidity + 
     63                                        ( 0.11693f * CBQ(sun_theta[0]) - 0.21196f * SQR(sun_theta[0]) + 0.06052f * sun_theta[0] + 0.25885f); 
    4964 
    50         const double PI = (double)3.1415926535897932; 
     65        zenithColor.y = (0.00275f  * CBQ(sun_theta[0]) - 0.00610f * SQR(sun_theta[0]) + 0.00316f * sun_theta[0] + 0.0f)     * SQR(mTurbidity) + 
     66                        (-0.04214f * CBQ(sun_theta[0]) + 0.08970f * SQR(sun_theta[0]) - 0.04153f * sun_theta[0] + 0.00515f) * mTurbidity + 
     67                            ( 0.15346f * CBQ(sun_theta[0]) - 0.26756f * SQR(sun_theta[0]) + 0.06669f * sun_theta[0] + 0.26688f); 
     68         
     69        zenithColor.z  = (float)((4.0453f * mTurbidity - 4.9710f) *     tan((4.0f / 9.0f - mTurbidity / 120.0f) *  
     70                                                         (M_PI - 2.0f * sun_theta[0])) - 0.2155f * mTurbidity + 2.4192f); 
    5171 
    52         FVector3 zenithColor; 
    53  
    54         zenithColor.x  = ( 0.00165f * CBQ(sun_theta.x) - 0.00374f  * SQR(sun_theta.x) + 
    55                 0.00208f *       sun_theta.x  +     0.0f) * SQR(mTurbidity) + 
    56                 (-0.02902f * CBQ(sun_theta.x) + 0.06377f  * SQR(sun_theta.x) - 
    57                 0.03202f *       sun_theta.x  + 0.00394f) *        mTurbidity + 
    58                 ( 0.11693f * CBQ(sun_theta.x) - 0.21196f  * SQR(sun_theta.x) + 
    59                 0.06052f *       sun_theta.x + 0.25885f); 
    60  
    61         zenithColor.y  = ( 0.00275f * CBQ(sun_theta.x) - 0.00610f  * SQR(sun_theta.x) + 
    62                 0.00316f *       sun_theta.x +     0.0f) * SQR(mTurbidity) + 
    63                 (-0.04214f * CBQ(sun_theta.x) + 0.08970f  * SQR(sun_theta.x) - 
    64                 0.04153f *       sun_theta.x  + 0.00515f) *        mTurbidity  + 
    65                 ( 0.15346f * CBQ(sun_theta.x) - 0.26756f  * SQR(sun_theta.x) + 
    66                 0.06669f *       sun_theta.x  + 0.26688f); 
    67  
    68         zenithColor.z  = (float)((4.0453f * mTurbidity - 4.9710f) * 
    69                 tan((4.0f / 9.0f - mTurbidity / 120.0f) * (PI - 2.0f * sun_theta.x)) - 
    70                 0.2155f * mTurbidity + 2.4192f); 
    7172        // convert kcd/m² to cd/m² 
    7273        zenithColor.z *= 1000; 
    … …  
    7475        double ABCDE_x[5], ABCDE_y[5], ABCDE_Y[5]; 
    7576 
    76         ABCDE_x[0] = -0.01925 * mTurbidity   - 0.25922; 
    77         ABCDE_x[1] = -0.06651 * mTurbidity   + 0.00081; 
    78         ABCDE_x[2] = -0.00041 * mTurbidity   + 0.21247; 
    79         ABCDE_x[3] = -0.06409 * mTurbidity   - 0.89887; 
    80         ABCDE_x[4] = -0.00325 * mTurbidity   + 0.04517; 
     77        ABCDE_x[0] = -0.01925 * mTurbidity - 0.25922; 
     78        ABCDE_x[1] = -0.06651 * mTurbidity + 0.00081; 
     79        ABCDE_x[2] = -0.00041 * mTurbidity + 0.21247; 
     80        ABCDE_x[3] = -0.06409 * mTurbidity - 0.89887; 
     81        ABCDE_x[4] = -0.00325 * mTurbidity + 0.04517; 
    8182 
    82         ABCDE_y[0] = -0.01669 * mTurbidity  - 0.26078; 
    83         ABCDE_y[1] = -0.09495 * mTurbidity   + 0.00921; 
    84         ABCDE_y[2] = -0.00792 * mTurbidity   + 0.21023; 
    85         ABCDE_y[3] = -0.04405 * mTurbidity   - 1.65369; 
    86         ABCDE_y[4] = -0.01092 * mTurbidity   + 0.05291; 
     83        ABCDE_y[0] = -0.01669 * mTurbidity - 0.26078; 
     84        ABCDE_y[1] = -0.09495 * mTurbidity + 0.00921; 
     85        ABCDE_y[2] = -0.00792 * mTurbidity + 0.21023; 
     86        ABCDE_y[3] = -0.04405 * mTurbidity - 1.65369; 
     87        ABCDE_y[4] = -0.01092 * mTurbidity + 0.05291; 
    8788 
    88         ABCDE_Y[0] =  0.17872 * mTurbidity   - 1.46303; 
    89         ABCDE_Y[1] = -0.35540 * mTurbidity   + 0.42749; 
    90         ABCDE_Y[2] = -0.02266 * mTurbidity   + 5.32505; 
    91         ABCDE_Y[3] =  0.12064 * mTurbidity   - 2.57705; 
    92         ABCDE_Y[4] = -0.06696 * mTurbidity   + 0.37027; 
     89        ABCDE_Y[0] =  0.17872 * mTurbidity - 1.46303; 
     90        ABCDE_Y[1] = -0.35540 * mTurbidity + 0.42749; 
     91        ABCDE_Y[2] = -0.02266 * mTurbidity + 5.32505; 
     92        ABCDE_Y[3] =  0.12064 * mTurbidity - 2.57705; 
     93        ABCDE_Y[4] = -0.06696 * mTurbidity + 0.37027; 
    9394 
    94  
     95/* 
    9596        F().getRenderDevice().setDefaultDepthStencilMode(FRenderDevice::DEPTHSTENCIL_TEST_NO_OVERWRITE); 
    9697 
    … …  
    126127 
    127128        F().getRenderDevice().setDefaultDepthStencilMode(FRenderDevice::DEPTHSTENCIL_TEST_AND_OVERWRITE); 
     129        */ 
    128130} 
    129131 
    130132 
    131 void SkyPreetham::renderSunDisk() 
     133void SkyPreetham::RenderSunDisk() 
    132134{ 
     135        /* 
    133136        F().getRenderDevice().setDefaultBlendingMode(FRenderDevice::BLENDING_ADDITIVE); 
    134137 
    … …  
    154157 
    155158        F().getRenderDevice().setDefaultBlendingMode(FRenderDevice::BLENDING_NONE); 
     159        */ 
    156160} 
    157161 
    158162 
    159 void SkyPreetham::createSunQuad() 
     163void SkyPreetham::CreateSunQuad() 
    160164{ 
     165        /* 
    161166        mSunQuad = new FVertexBuffer(); 
    162167        mSunQuad->setupPrimitiveType(FVertexBuffer::PRIMITIVES_TRIANGLES); 
    … …  
    180185        mSunQuad->setIndex(4, 1); 
    181186        mSunQuad->setIndex(5, 3); 
     187        */ 
    182188} 

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

    r2954 r2955  
    22#define _SKYPREETHAM_H__ 
    33 
    4 class SkyPreetham: public Entity 
     4 
     5namespace CHCDemoEngine{ 
     6class Vector3; 
     7} 
     8 
     9class SkyPreetham 
    510{ 
    611public: 
    … …  
    914        virtual ~SkyPreetham(); 
    1015 
     16        void Compute(const CHCDemoEngine::Vector3 &sunDir); 
     17 
    1118protected: 
    1219 
    13         void renderSunDisk(); 
    14         void createSunQuad(); 
     20        void RenderSunDisk(); 
     21        void CreateSunQuad(); 
    1522 
    1623 
    1724        /// Members. 
    18         FEffect*                mEffect; 
     25/*      FEffect*                mEffect; 
    1926 
    2027        FEffect*                mSunEffect; 
    2128        FTexture2D*             mSunTexture; 
    2229        FVertexBuffer*  mSunQuad; 
    23  
     30*/ 
    2431        float mTurbidity; 
    2532}; 

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

    r2954 r2955  
    7171        float ABCDE_x[5], ABCDE_y[5], ABCDE_Y[5]; 
    7272 
    73         ABCDE_x[0] = -0.01925f * turbidity   - 0.25922f; 
    74         ABCDE_x[1] = -0.06651f * turbidity   + 0.00081f; 
    75         ABCDE_x[2] = -0.00041f * turbidity   + 0.21247f; 
    76         ABCDE_x[3] = -0.06409f * turbidity   - 0.89887f; 
    77         ABCDE_x[4] = -0.00325f * turbidity   + 0.04517f; 
     73        ABCDE_x[0] = -0.01925f * turbidity - 0.25922f; 
     74        ABCDE_x[1] = -0.06651f * turbidity + 0.00081f; 
     75        ABCDE_x[2] = -0.00041f * turbidity + 0.21247f; 
     76        ABCDE_x[3] = -0.06409f * turbidity - 0.89887f; 
     77        ABCDE_x[4] = -0.00325f * turbidity + 0.04517f; 
    7878 
    79         ABCDE_y[0] = -0.01669f * turbidity  - 0.26078f; 
    80         ABCDE_y[1] = -0.09495f * turbidity   + 0.00921f; 
    81         ABCDE_y[2] = -0.00792f * turbidity   + 0.21023f; 
    82         ABCDE_y[3] = -0.04405f * turbidity   - 1.65369f; 
    83         ABCDE_y[4] = -0.01092f * turbidity   + 0.05291f; 
     79        ABCDE_y[0] = -0.01669f * turbidity - 0.26078f; 
     80        ABCDE_y[1] = -0.09495f * turbidity + 0.00921f; 
     81        ABCDE_y[2] = -0.00792f * turbidity + 0.21023f; 
     82        ABCDE_y[3] = -0.04405f * turbidity - 1.65369f; 
     83        ABCDE_y[4] = -0.01092f * turbidity + 0.05291f; 
    8484 
    85         ABCDE_Y[0] =  0.17872f * turbidity   - 1.46303f; 
    86         ABCDE_Y[1] = -0.35540f * turbidity   + 0.42749f; 
    87         ABCDE_Y[2] = -0.02266f * turbidity   + 5.32505f; 
    88         ABCDE_Y[3] =  0.12064f * turbidity   - 2.57705f; 
    89         ABCDE_Y[4] = -0.06696f * turbidity   + 0.37027f; 
     85        ABCDE_Y[0] =  0.17872f * turbidity - 1.46303f; 
     86        ABCDE_Y[1] = -0.35540f * turbidity + 0.42749f; 
     87        ABCDE_Y[2] = -0.02266f * turbidity + 5.32505f; 
     88        ABCDE_Y[3] =  0.12064f * turbidity - 2.57705f; 
     89        ABCDE_Y[4] = -0.06696f * turbidity + 0.37027f; 
    9090 
    9191        Vector3 num; 

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

    r2954 r2955  
    22#define __SUNCOLOR_H__ 
    33 
    4 //#include "Vector3.h" 
    5  
    64namespace CHCDemoEngine{ 
    7  
    85class Vector3; 
    96} 
     7 
    108/** Class describing a plane in 3D space. 
    119*/ 

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

    r2952 r2955  
    2525        if (!mMatrix) return; 
    2626         
    27         if (state->GetRenderType() == RenderState::DEFERRED) 
     27        if (state->GetRenderPassType() == RenderState::DEFERRED) 
    2828        { 
    2929                cgGLSetMatrixParameterfc(sModelMatrixParam, (const float *)mMatrix->x); 
    … …  
    3939        if (!mMatrix) return; 
    4040 
    41         if (state->GetRenderType() == RenderState::DEFERRED) 
     41        if (state->GetRenderPassType() == RenderState::DEFERRED) 
    4242        { 
    4343                static Matrix4x4 identity = IdentityMatrix(); 

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

    r2954 r2955  
    166166PerfTimer frameTimer, algTimer; 
    167167 
    168 int renderType = RenderState::FIXED; 
     168/// the used render type for this render pass 
     169enum RenderMethod 
     170{ 
     171        RENDER_FIXED, 
     172        RENDER_DEPTH_PASS, 
     173        RENDER_DEFERRED, 
     174        RENDER_DEPTH_PASS_DEFERRED, 
     175        RENDER_NUM_RENDER_TYPES 
     176}; 
     177 
     178/// one of four possible render methods 
     179int renderMethod = RENDER_FIXED; 
    169180 
    170181PerformanceGraph *perfGraph = NULL; 
    … …  
    459470        visualization = new Visualization(bvh, camera, NULL, &state); 
    460471         
    461         state.SetRenderType(RenderState::FIXED); 
     472        state.SetRenderPassType(RenderState::FIXED); 
    462473        sceneQuery = new SceneQuery(bvh->GetBox(), traverser); 
    463474 
    … …  
    756767        tr->SetUseMultiQueries(useMultiQueries); 
    757768        tr->SetUseTightBounds(useTightBounds); 
    758         tr->SetUseDepthPass((renderType == RenderState::DEPTH_PASS) || (renderType == RenderState::DEPTH_PASS_DEFERRED)); 
     769        tr->SetUseDepthPass((renderMethod == RENDER_DEPTH_PASS) || (renderMethod == RENDER_DEPTH_PASS_DEFERRED)); 
    759770        tr->SetRenderQueue(renderQueue); 
    760771 
    … …  
    840851        matProjectionView = matViewing * matProjection; 
    841852         
    842         if ((renderType == RenderState::DEFERRED) || (renderType == RenderState::DEPTH_PASS_DEFERRED)) 
     853        if ((renderMethod == RENDER_DEFERRED) || (renderMethod == RENDER_DEPTH_PASS_DEFERRED)) 
    843854        { 
    844855                cgGLSetMatrixParameterfc(Transform3::sModelMatrixParam, (const float *)IdentityMatrix().x); 
    … …  
    878889        glDisable(GL_MULTISAMPLE_ARB); 
    879890 
    880         state.SetRenderType(RenderState::DEFERRED); 
     891        state.SetRenderPassType(RenderState::DEFERRED); 
    881892 
    882893        cgGLEnableProfile(RenderState::sCgVertexProfile); 
    … …  
    933944 
    934945        // hack 
    935         int oldRenderType = renderType; 
     946        int oldRenderMethod = renderMethod; 
    936947 
    937948        if (renderLightView) 
    938                 renderType = RenderState::FIXED; 
     949                renderMethod = RenderState::FIXED; 
    939950 
    940951        glEnableClientState(GL_VERTEX_ARRAY); 
    … …  
    942953 
    943954        // render with the specified method (forward rendering, forward + depth, deferred) 
    944         switch (renderType) 
    945         { 
    946         case RenderState::FIXED: 
     955        switch (renderMethod) 
     956        { 
     957        case RENDER_FIXED: 
    947958         
    948959                glEnable(GL_MULTISAMPLE_ARB); 
    949960                 
    950                 state.SetRenderType(RenderState::FIXED); 
     961                state.SetRenderPassType(RenderState::FIXED); 
    951962                glEnable(GL_LIGHTING); 
    952963 
    … …  
    960971                break; 
    961972 
    962         case RenderState::DEPTH_PASS_DEFERRED: 
     973        case RENDER_DEPTH_PASS_DEFERRED: 
    963974 
    964975                glDisable(GL_MULTISAMPLE_ARB); 
    965976                state.SetUseAlphaToCoverage(false); 
    966977 
    967                 state.Reset(); 
    968                 state.SetRenderType(RenderState::DEPTH_PASS); 
     978                state.SetRenderPassType(RenderState::DEPTH_PASS); 
    969979 
    970980                if (!fbo) InitFBO(); fbo->Bind(); 
    … …  
    985995                break; 
    986996 
    987         case RenderState::DEPTH_PASS: 
     997        case RENDER_DEPTH_PASS: 
    988998 
    989999                glEnable(GL_MULTISAMPLE_ARB); 
    … …  
    9921002                cgGLDisableProfile(RenderState::sCgVertexProfile); 
    9931003 
    994                 state.SetRenderType(RenderState::DEPTH_PASS); 
     1004                state.SetRenderPassType(RenderState::DEPTH_PASS); 
    9951005 
    9961006                // the scene is rendered withouth any shading    
    … …  
    10601070         
    10611071        // reset depth pass and render visible objects 
    1062         if ((renderType == RenderState::DEPTH_PASS) || 
    1063                 (renderType == RenderState::DEPTH_PASS_DEFERRED)) 
     1072        if ((renderMethod == RENDER_DEPTH_PASS) || 
     1073                (renderMethod == RENDER_DEPTH_PASS_DEFERRED)) 
    10641074        { 
    10651075                RenderVisibleObjects(); 
    … …  
    10781088 
    10791089 
    1080         if ((renderType == RenderState::DEFERRED) || (renderType == RenderState::DEPTH_PASS_DEFERRED)) 
     1090        if ((renderMethod == RENDER_DEFERRED) || 
     1091                (renderMethod == RENDER_DEPTH_PASS_DEFERRED)) 
    10811092        { 
    10821093                //glPopAttrib(); 
    … …  
    11111122 
    11121123 
    1113         state.SetRenderType(RenderState::FIXED); 
     1124        state.SetRenderPassType(RenderState::FIXED); 
    11141125        state.Reset(); 
    11151126 
    … …  
    11181129        glDisableClientState(GL_NORMAL_ARRAY); 
    11191130         
    1120         renderType = oldRenderType; 
     1131        renderMethod = oldRenderMethod; 
    11211132 
    11221133 
    … …  
    13751386        case GLUT_KEY_F7: 
    13761387 
    1377                 renderType = (renderType + 1) % RenderState::NUM_RENDER_TYPES; 
    1378                 traverser->SetUseDepthPass((renderType == RenderState::DEPTH_PASS) || (renderType == RenderState::DEPTH_PASS_DEFERRED)); 
     1388                renderMethod = (renderMethod + 1) % 4; 
     1389 
     1390                traverser->SetUseDepthPass( 
     1391                        (renderMethod == RENDER_DEPTH_PASS) ||  
     1392                        (renderMethod == RENDER_DEPTH_PASS_DEFERRED) 
     1393                        ); 
    13791394                 
    13801395                break; 
    … …  
    18501865                        int i = 0; 
    18511866 
    1852                         static char *renderTypeStr[] = {"forward", "depth pass + forward", "deferred shading", "depth pass + deferred"}; 
     1867                        static char *renderMethodStr[] = {"forward", "depth pass + forward", "deferred shading", "depth pass + deferred"}; 
    18531868         
    18541869                        sprintf(msg[i ++], "multiqueries: %d, tight bounds: %d, render queue: %d",  
    18551870                                                        useMultiQueries, useTightBounds, useRenderQueue); 
    18561871 
    1857                         sprintf(msg[i ++], "render technique: %s, SSAO: %d", renderTypeStr[renderType], useAdvancedShading); 
     1872                        sprintf(msg[i ++], "render technique: %s, SSAO: %d", renderMethodStr[renderMethod], useAdvancedShading); 
    18581873 
    18591874                        sprintf(msg[i ++], "triangles per virtual leaf: %5d", trianglesPerVirtualLeaf); 
    … …  
    19401955void RenderVisibleObjects() 
    19411956{ 
    1942         if (renderType == RenderState::DEPTH_PASS_DEFERRED) 
     1957        if (renderMethod == RENDER_DEPTH_PASS_DEFERRED) 
    19431958        { 
    19441959                if (showShadowMap && !renderLightView) 
    … …  
    19561971                glDrawBuffers(3, mrt); 
    19571972                glClear(GL_COLOR_BUFFER_BIT); 
    1958                 //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    19591973        } 
    19601974        else 
    … …  
    19631977                glEnable(GL_LIGHTING); 
    19641978 
    1965                 state.SetRenderType(RenderState::FIXED); 
     1979                state.SetRenderPassType(RenderState::FIXED); 
    19661980        } 
    19671981 
    … …  
    20152029        glDisableClientState(GL_NORMAL_ARRAY); 
    20162030 
    2017         state.SetRenderType(RenderState::DEPTH_PASS); 
     2031        state.SetRenderPassType(RenderState::DEPTH_PASS); 
     2032        state.LockCullFaceEnabled(true); 
     2033        state.SetUseAlphaToCoverage(false); 
    20182034 
    20192035        // change CHC++ set of state variables (must be done for each change of camera because 
    20202036        // otherwise the temporal coherency is broken 
    20212037        BvhNode::SetCurrentState(1); 
    2022         state.SetUseAlphaToCoverage(false); 
    20232038 
    20242039        // hack: temporarily change camera far plane 
    20252040        camera->SetFar(newfar); 
    2026  
     2041        glDisable(GL_CULL_FACE); 
     2042         
    20272043        // the scene is rendered withouth any shading    
    20282044        shadowMap->ComputeShadowMap(shadowTraverser, matProjectionView); 
    20292045 
     2046        glEnable(GL_CULL_FACE); 
    20302047        camera->SetFar(farDist); 
    20312048 
    20322049        state.SetUseAlphaToCoverage(true); 
     2050        state.LockCullFaceEnabled(false); 
    20332051 
    20342052        glEnableClientState(GL_NORMAL_ARRAY); 
Note: See TracChangeset for help on using the changeset viewer.