Changeset 2825 for GTP/trunk/App


Ignore:
Timestamp:
07/09/08 03:05:23 (16 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/App/Demos/Vis/FriendlyCulling
Files:
2 added
12 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/FriendlyCulling.vcproj

    r2809 r2825  
    216216                        </File> 
    217217                        <File 
     218                                RelativePath=".\src\Environment.cpp" 
     219                                > 
     220                        </File> 
     221                        <File 
     222                                RelativePath=".\src\Environment.h" 
     223                                > 
     224                        </File> 
     225                        <File 
    218226                                RelativePath=".\src\glInterface.h" 
    219227                                > 

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

    r2802 r2825  
    1313#include "Geometry.h" 
    1414#include "RenderState.h" 
     15#include "Material.h" 
    1516#include "gzstream.h" 
    1617 
    … …  
    10301031 
    10311032 
    1032 void Bvh::RenderBoundsForViz(BvhNode *node, bool useTightBounds) 
     1033void Bvh::RenderBoundsForViz(BvhNode *node, RenderState *state, bool useTightBounds) 
    10331034{ 
    10341035        glDisable(GL_TEXTURE_2D); 
    10351036        glDisable(GL_LIGHTING); 
    10361037        glColor3f(1, 1, 1); 
    1037          
     1038 
     1039        // hack: for deferred shading we have to define a material 
     1040        static Material boxMat; 
     1041        boxMat.SetEmmisive(RgbaColor(1.0f, 1.0f, 1.0f, 1.0f)); 
     1042 
     1043        boxMat.Render(state); 
     1044 
    10381045        if (!useTightBounds) 
    10391046        { 

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

    r2800 r2825  
    556556        /** Render wireframe bvh for visualization purpose. 
    557557        */ 
    558         void RenderBoundsForViz(BvhNode *node, bool useTightBounds); 
     558        void RenderBoundsForViz(BvhNode *node, RenderState *state, bool useTightBounds); 
    559559 
    560560 

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

    r2822 r2825  
    6060 
    6161 
    62 //void Material::Render(RenderState *state) 
    6362void Material::Render(RenderState *state) 
    6463{ 
    … …  
    6867        { 
    6968                mTexture->Bind(); 
    70  
    71                 cgGLSetParameter4f(sAmbientTexParam,  
    72                                                    mEmmisiveColor.r,  
    73                                                    mEmmisiveColor.g,  
    74                                                    mEmmisiveColor.b,  
    75                                                    mEmmisiveColor.a); 
    76  
    77                 cgGLSetParameter4f(sDiffuseTexParam, mDiffuseColor.r, mDiffuseColor.g, mDiffuseColor.b, mDiffuseColor.a); 
    7869        } 
    7970        else 
    8071        { 
    81                 cgGLSetParameter4f(sAmbientParam,  
    82                                                    mEmmisiveColor.r,  
    83                                                    mEmmisiveColor.g,  
    84                                                    mEmmisiveColor.b,  
    85                                                    mEmmisiveColor.a); 
    86  
    87                 cgGLSetParameter4f(sDiffuseParam, mDiffuseColor.r, mDiffuseColor.g, mDiffuseColor.b, mDiffuseColor.a); 
    88                  
    8972                glBindTexture(GL_TEXTURE_2D, 0); 
    9073        } 
    9174 
    92         glMaterialfv(GL_FRONT, GL_AMBIENT, (float *)&mAmbientColor.r); 
    93         glMaterialfv(GL_FRONT, GL_DIFFUSE, (float *)&mDiffuseColor.r); 
    94         glMaterialfv(GL_FRONT, GL_EMISSION, (float *)&mEmmisiveColor.r); 
    95         glMaterialfv(GL_FRONT, GL_SPECULAR, (float *)&mSpecularColor.r); 
     75        if (state->GetRenderType() == RenderState::DEFERRED) 
     76        { 
     77                if (mTexture) 
     78                { 
     79                        cgGLSetParameter4f(sAmbientTexParam, mEmmisiveColor.r, mEmmisiveColor.g, mEmmisiveColor.b, mEmmisiveColor.a); 
     80                        cgGLSetParameter4f(sDiffuseTexParam, mDiffuseColor.r, mDiffuseColor.g, mDiffuseColor.b, mDiffuseColor.a); 
     81                } 
     82                else 
     83                { 
     84                        cgGLSetParameter4f(sAmbientParam, mEmmisiveColor.r, mEmmisiveColor.g, mEmmisiveColor.b, mEmmisiveColor.a); 
     85                        cgGLSetParameter4f(sDiffuseParam, mDiffuseColor.r, mDiffuseColor.g, mDiffuseColor.b, mDiffuseColor.a); 
     86                } 
     87        } 
     88        else if (state->GetRenderType() == RenderState::FIXED) 
     89        { 
     90                glMaterialfv(GL_FRONT, GL_AMBIENT, (float *)&mAmbientColor.r); 
     91                glMaterialfv(GL_FRONT, GL_DIFFUSE, (float *)&mDiffuseColor.r); 
     92                glMaterialfv(GL_FRONT, GL_EMISSION, (float *)&mEmmisiveColor.r); 
     93                glMaterialfv(GL_FRONT, GL_SPECULAR, (float *)&mSpecularColor.r); 
     94        } 
    9695} 
    9796 

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

    r2819 r2825  
    1414 
    1515 
     16///////////////// 
     17 
    1618RenderState::RenderState(): 
    1719mAlphaTestEnabled(false),  
    1820mTexturesEnabled(false),  
    1921mMode(RENDER), 
    20 mIsDepthPass(false) 
     22mRenderType(FIXED) 
    2123{ 
    2224        Reset();  
    … …  
    3537        if (mode == QUERY) 
    3638        { 
    37                 if (!mIsDepthPass) 
     39                if (mRenderType != DEPTH_PASS) 
    3840                { 
    3941                        glDisable(GL_LIGHTING); 
    4042                        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); 
    4143 
    42                         cgGLDisableProfile(sCgFragmentProfile); 
    43                         cgGLDisableProfile(sCgVertexProfile); 
     44                        if (mRenderType == DEFERRED) 
     45                        { 
     46                                cgGLDisableProfile(sCgFragmentProfile); 
     47                                cgGLDisableProfile(sCgVertexProfile); 
     48                        } 
    4449                } 
    4550 
    … …  
    5358                //-- restore render state 
    5459 
    55                 if (!mIsDepthPass) 
     60                if (mRenderType != DEPTH_PASS) 
    5661                { 
    5762                        glEnable(GL_LIGHTING); 
    5863                        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 
    5964 
    60                         cgGLEnableProfile(sCgFragmentProfile); 
    61                         cgGLEnableProfile(sCgVertexProfile); 
     65                        if (mRenderType == DEFERRED) 
     66                        { 
     67                                cgGLEnableProfile(sCgFragmentProfile); 
     68                                cgGLEnableProfile(sCgVertexProfile); 
     69                        } 
    6270                } 
    6371 
    … …  
    8290        } 
    8391 
    84         // allow only alpha textures in depth pass 
    8592        if (mTexturesEnabled &&  
    86                 (!texturing || mIsDepthPass && !mAlphaTestEnabled)) 
     93                (!texturing || (mRenderType == DEPTH_PASS) && !mAlphaTestEnabled)) 
    8794        { 
    8895                mTexturesEnabled = false; 
    8996 
    90                 cgGLBindProgram(sCgMrtFragmentProgram); 
     97                if (mRenderType == DEFERRED) 
     98                        cgGLBindProgram(sCgMrtFragmentProgram); 
    9199 
    92100                glDisable(GL_TEXTURE_2D); 
    … …  
    95103        else if (!mTexturesEnabled && texturing) 
    96104        { 
    97                 if (!mIsDepthPass || mAlphaTestEnabled) 
     105                // support only alpha textures in depth pass 
     106                if ((mRenderType != DEPTH_PASS) || mAlphaTestEnabled) 
    98107                { 
    99108                        mTexturesEnabled = true; 
    100109 
    101                         cgGLBindProgram(sCgMrtFragmentTexProgram); 
     110                        if (mRenderType == DEFERRED) 
     111                                cgGLBindProgram(sCgMrtFragmentTexProgram); 
    102112 
    103113                        glEnable(GL_TEXTURE_2D); 
    … …  
    111121{ 
    112122        mCurrentVboId = -1; 
     123 
    113124        SetState(false, false); 
    114125        SetState(RENDER); 

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

    r2819 r2825  
    2222                QUERY, 
    2323                RENDER 
     24        }; 
     25 
     26        enum RenderType 
     27        { 
     28                FIXED, 
     29                DEPTH_PASS, 
     30                DEFERRED 
    2431        }; 
    2532 
    … …  
    5158        inline int GetCurrentVboId() { return mCurrentVboId; } 
    5259 
    53         void SetDepthPass(bool depthPass) { mIsDepthPass = depthPass; } 
    54         bool IsDepthPass() { return mIsDepthPass; } 
     60        void SetRenderType(RenderType type) { mRenderType = type; } 
     61        RenderType GetRenderType() { return mRenderType; } 
     62 
     63 
     64        /////////////////// 
    5565 
    5666        static CGprofile sCgFragmentProfile; 
    … …  
    7080        int mCurrentVboId; 
    7181 
    72         bool mIsDepthPass; 
     82        RenderType mRenderType; 
    7383}; 
    7484 

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

    r2802 r2825  
    7878 
    7979                if (mShowBounds) 
    80                         mBvh->RenderBoundsForViz(node, mUseTightBounds);                 
     80                        mBvh->RenderBoundsForViz(node, mRenderState, mUseTightBounds);           
    8181        } 
    8282        else  

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

    r2824 r2825  
    4848        { 
    4949                trafo = NULL; 
    50                 sceneGeom = new SceneEntity(geom, mat, trafo); 
    5150        } 
    5251        else 
    … …  
    5554                str.read(reinterpret_cast<char *>(trafo->x), sizeof(Matrix4x4)); 
    5655                mTrafos.push_back(trafo); 
    57 #if 0 // use static geometry  
    58                 Vector3 *vertices = new Vector3[geom->mNumVertices]; 
    59  
    60                 for (int i = 0; i < geom->mNumVertices; ++ i) 
    61                 { 
    62                         Vector3 v = geom->mVertices[i]; 
    63  
    64                         v = (*trafo) * v; 
    65                         vertices[i] = v; 
    66                 } 
    67  
    68                 Geometry *tgeom = new Geometry(vertices, geom->mNormals, geom->mTexCoords, geom->mNumVertices, false); 
    69  
    70                 sceneGeom = new SceneEntity(tgeom, mat, NULL); 
    71 #else 
    72                 // use instancing 
    73                 sceneGeom = new SceneEntity(geom, mat, trafo); 
    74 #endif 
    75         } 
     56        } 
     57 
     58        // use instancing 
     59        sceneGeom = new SceneEntity(geom, mat, trafo); 
    7660 
    7761        return sceneGeom; 

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

    r2823 r2825  
    3030        if (mMaterial) mMaterial->Render(state); 
    3131 
    32         static Matrix4x4 identity = IdentityMatrix(); 
    33  
    3432        if (mTransform) 
    3533        { 
    36                 cgGLSetMatrixParameterfc(sModelMatrixParam, (const float *)mTransform->x); 
    37                 //glPushMatrix(); 
    38                 //glMultMatrixf((float *)mTransform->x); 
    39                 mGeometry->Render(state); 
     34                if (state->GetRenderType() == RenderState::DEFERRED) 
     35                { 
     36                        cgGLSetMatrixParameterfc(sModelMatrixParam, (const float *)mTransform->x); 
    4037 
    41                 cgGLSetMatrixParameterfc(sModelMatrixParam, (const float *)identity.x); 
    42                 //glPopMatrix(); 
     38                        mGeometry->Render(state); 
     39 
     40                        static Matrix4x4 identity = IdentityMatrix(); 
     41                        cgGLSetMatrixParameterfc(sModelMatrixParam, (const float *)identity.x); 
     42                } 
     43                else 
     44                { 
     45                        glPushMatrix(); 
     46                        glMultMatrixf((float *)mTransform->x); 
     47                         
     48                        mGeometry->Render(state); 
     49 
     50                        glPopMatrix(); 
     51                } 
    4352        } 
    4453        else 

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

    r2817 r2825  
    6161{ 
    6262        glEnable(GL_TEXTURE_2D); 
     63 
    6364        glGenTextures(1, &mTexId); 
    6465        glBindTexture(GL_TEXTURE_2D, mTexId); 
     66         
    6567        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
    66         //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
    67         //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND); 
    68          
    6968        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
    7069        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); 
    71  
    72         //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
    73         //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
    7470 
    7571        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 
    7672        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 
    7773 
     74        glTexImage2D(GL_RGBA, 0, GL_RGBA, mWidth, mHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, mImage); 
    7875        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, mWidth, mHeight, GL_RGBA, GL_UNSIGNED_BYTE, mImage); 
    79         //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, mWidth, mHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, mImage); 
     76 
     77        glBindTexture(GL_TEXTURE_2D, 0); 
    8078} 
    8179 

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

    r2823 r2825  
    133133bool useMultiQueries = true; 
    134134bool flyMode = true; 
    135 bool depthPass = false; 
    136 bool useGlFinish = false; 
    137135 
    138136SceneEntityContainer skyGeometry; 
    … …  
    150148 
    151149PerfTimer frameTimer, algTimer; 
     150 
     151int renderType = RenderState::FIXED; 
    152152 
    153153 
    … …  
    340340        } 
    341341 
    342         // create noise texture for ssao 
    343         CreateNoiseTex2D(); 
    344  
    345  
    346342        const string bvh_filename = string(model_path + "city.bvh"); 
    347343        BvhLoader bvhLoader; 
    … …  
    360356        InitCg(); 
    361357 
     358        // create noise texture for ssao 
     359        CreateNoiseTex2D(); 
     360 
    362361        bvh->SetCamera(camera); 
    363362 
     363        // init render traverser 
    364364        ResetTraverser(); 
    365365 
    … …  
    369369        visualization = new Visualization(bvh, camera, NULL, &state); 
    370370 
    371         //sceneQuery = new SceneQuery(bvh->GetBox(), traverser); 
     371        sceneQuery = new SceneQuery(bvh->GetBox(), traverser); 
    372372 
    373373 
    … …  
    479479                sNormalsTexParamSsao = cgGetNamedParameter(sCgSsaoProgram, "normals");   
    480480                sNoiseTexParamSsao = cgGetNamedParameter(sCgSsaoProgram, "noiseTexture"); 
     481                cgGLDisableTextureParameter(sNoiseTexParamSsao); 
    481482 
    482483                sSamplesParamSsao = cgGetNamedParameter(sCgSsaoProgram, "samples"); 
    … …  
    792793        traverser->SetUseMultiQueries(useMultiQueries); 
    793794        traverser->SetUseTightBounds(useTightBounds); 
    794         traverser->SetUseDepthPass(depthPass); 
     795        traverser->SetUseDepthPass(renderType == RenderState::DEPTH_PASS); 
    795796        traverser->SetRenderQueue(renderQueue); 
    796797} 
    … …  
    801802        glEnable(GL_LIGHTING); 
    802803        glEnable(GL_LIGHT0); 
    803         //glEnable(GL_LIGHT1); 
    804         glDisable(GL_LIGHT1); 
    805  
     804        glEnable(GL_LIGHT1); 
     805         
    806806        //GLfloat ambient[] = {0.5, 0.5, 0.5, 1.0}; 
    807807        GLfloat ambient[] = {0.2, 0.2, 0.2, 1.0}; 
    … …  
    809809        GLfloat specular[] = {1.0, 1.0, 1.0, 1.0}; 
    810810             
    811         GLfloat lmodel_ambient[] = {0.5f, 0.5f, 0.5f, 1.0f}; 
    812         //GLfloat lmodel_ambient[] = {0.2f, 0.2f, 0.2f, 1.0f}; 
     811        //GLfloat lmodel_ambient[] = {0.5f, 0.5f, 0.5f, 1.0f}; 
     812        GLfloat lmodel_ambient[] = {0.3f, 0.3f, 0.3f, 1.0f}; 
    813813 
    814814        glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); 
    … …  
    816816        glLightfv(GL_LIGHT0, GL_SPECULAR, specular); 
    817817 
    818         GLfloat position[] = {1.0, 1.0, 1.0, 0.0}; 
    819         glLightfv(GL_LIGHT0, GL_POSITION, position); 
    820  
    821818 
    822819        //////////// 
    823820        //-- second light 
    824821 
    825         GLfloat ambient1[] = {0.5, 0.5, 0.5, 1.0}; 
    826         //GLfloat diffuse1[] = {1.0, 1.0, 1.0, 1.0}; 
    827         GLfloat diffuse1[] = {0.5, 0.5, 0.5, 1.0}; 
    828         GLfloat specular1[] = {0.5, 0.5, 0.5, 1.0}; 
     822        GLfloat ambient1[] = {0.2, 0.2, 0.2, 1.0}; 
     823        GLfloat diffuse1[] = {1.0, 1.0, 1.0, 1.0}; 
     824        //GLfloat diffuse1[] = {0.5, 0.5, 0.5, 1.0}; 
     825        GLfloat specular1[] = {0.0, 0.0, 0.0, 1.0}; 
    829826 
    830827        glLightfv(GL_LIGHT1, GL_AMBIENT, ambient1); 
    831828        glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse1); 
    832829        glLightfv(GL_LIGHT1, GL_SPECULAR, specular1); 
    833          
    834         GLfloat position1[] = {0.0, 1.0, 0.0, 1.0}; 
     830 
     831         
     832        ////////////////////////////// 
     833 
     834        GLfloat position[] = {0.8f, -1.0f, 0.7f, 0.0f}; 
     835        glLightfv(GL_LIGHT0, GL_POSITION, position); 
     836 
     837        GLfloat position1[] = {-0.5f, 0.5f, 0.4f, 0.0f}; 
    835838        glLightfv(GL_LIGHT1, GL_POSITION, position1); 
    836839 
    837840        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); 
    838841        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE); 
    839         //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE); 
    840         //glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_SEPARATE_SPECULAR_COLOR_EXT); 
    841842        glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_SINGLE_COLOR_EXT); 
    842843} 
    … …  
    854855        camera->SetupCameraView(); 
    855856 
    856         GLfloat position[] = {0.8f, 1.0f, 1.5f, 0.0f}; 
     857        GLfloat position[] = {0.8f, -1.0f, 0.7f, 0.0f}; 
    857858        glLightfv(GL_LIGHT0, GL_POSITION, position); 
    858859 
    859         GLfloat position1[] = {bvh->GetBox().Center().x, bvh->GetBox().Center().y, bvh->GetBox().Max().z, 1.0f}; 
     860        GLfloat position1[] = {-0.5f, 0.5f, 0.4f, 0.0f}; 
    860861        glLightfv(GL_LIGHT1, GL_POSITION, position1); 
     862 
     863         
     864        if (renderType == RenderState::DEFERRED) 
     865        { 
     866                // set modelview matrix for shaders 
     867                cgGLSetStateMatrixParameter(sModelViewProjMatrixParam,  
     868                                                                        CG_GL_MODELVIEW_PROJECTION_MATRIX,  
     869                                                                        CG_GL_MATRIX_IDENTITY); 
     870 
     871                static Matrix4x4 identity = IdentityMatrix(); 
     872                cgGLSetMatrixParameterfc(SceneEntity::sModelMatrixParam, (const float *)identity.x); 
     873        }        
    861874} 
    862875 
    … …  
    909922        if (!flyMode) PlaceViewer(oldPos); 
    910923 
    911         if (useGlFinish) glFinish(); 
    912  
    913924        algTimer.Start(); 
    914925 
    915         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); 
    916          
    917         glPushAttrib(GL_VIEWPORT_BIT); 
    918         glViewport(0, 0, texWidth, texHeight); 
    919  
    920         cgGLEnableProfile(RenderState::sCgFragmentProfile); 
    921         cgGLBindProgram(RenderState::sCgMrtFragmentProgram); 
    922  
    923         cgGLEnableProfile(RenderState::sCgVertexProfile); 
    924         cgGLBindProgram(sCgMrtVertexProgram); 
    925  
    926         glDrawBuffers(3, mrt); 
    927          
     926         
     927        // render without shading 
     928        switch (renderType) 
     929        { 
     930        case RenderState::FIXED: 
     931         
     932                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); 
     933 
     934                state.SetRenderType(RenderState::FIXED); 
     935                glEnable(GL_LIGHTING); 
     936 
     937                cgGLDisableProfile(RenderState::sCgFragmentProfile); 
     938                cgGLDisableProfile(RenderState::sCgVertexProfile); 
     939 
     940                glDrawBuffers(1, mrt); 
     941 
     942                break; 
     943 
     944        case RenderState::DEPTH_PASS: 
     945                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); 
     946 
     947                state.SetRenderType(RenderState::DEPTH_PASS); 
     948                glDisable(GL_LIGHTING); 
     949 
     950                cgGLDisableProfile(RenderState::sCgFragmentProfile); 
     951                cgGLDisableProfile(RenderState::sCgVertexProfile); 
     952         
     953                glDrawBuffers(1, mrt); 
     954 
     955                break; 
     956         
     957        case RenderState::DEFERRED: 
     958                state.SetRenderType(RenderState::DEFERRED); 
     959 
     960                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo); 
     961         
     962                glPushAttrib(GL_VIEWPORT_BIT); 
     963                glViewport(0, 0, texWidth, texHeight); 
     964 
     965                cgGLEnableProfile(RenderState::sCgFragmentProfile); 
     966                cgGLBindProgram(RenderState::sCgMrtFragmentProgram); 
     967 
     968                cgGLEnableProfile(RenderState::sCgVertexProfile); 
     969                cgGLBindProgram(sCgMrtVertexProgram); 
     970 
     971                glDrawBuffers(3, mrt); 
     972 
     973                break; 
     974        } 
     975 
    928976        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    929977 
    930978        glDepthFunc(GL_LESS); 
     979 
    931980        glDisable(GL_TEXTURE_2D); 
    932981        glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
    933  
    934         // render without shading 
    935         if (depthPass)  
    936         { 
    937                 state.SetDepthPass(true); 
    938                 glDisable(GL_LIGHTING); 
    939         } 
    940         else 
    941         { 
    942                 state.SetDepthPass(false); 
    943                 glEnable(GL_LIGHTING); 
    944         } 
    945          
     982                 
    946983 
    947984        // bring eye modelview matrix up-to-date 
    948985        SetupEyeView(); 
    949986 
    950         // set modelview matrix for shaders 
    951         cgGLSetStateMatrixParameter(sModelViewProjMatrixParam, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); 
    952          
    953         static Matrix4x4 identity = IdentityMatrix(); 
    954         cgGLSetMatrixParameterfc(SceneEntity::sModelMatrixParam, (const float *)identity.x); 
    955          
    956987 
    957988        // actually render the scene geometry using one of the specified algorithms 
    … …  
    959990 
    960991 
    961         ////// 
     992        ///////// 
    962993        //-- do the rest of the rendering 
    963994 
    … …  
    967998 
    968999        // reset depth pass and render visible objects 
    969         if (depthPass)  
     1000        if (renderType == RenderState::DEPTH_PASS)  
    9701001        { 
    9711002                RenderVisibleObjects(); 
    … …  
    9831014        glDisableClientState(GL_NORMAL_ARRAY); 
    9841015         
    985          
    986         cgGLDisableProfile(RenderState::sCgVertexProfile); 
    987         cgGLDisableProfile(RenderState::sCgFragmentProfile); 
    988  
    989         glPopAttrib(); 
    990  
    991         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); 
    992  
    993         DisplayRenderTexture(); 
    994  
    995         if (useGlFinish) glFinish(); 
     1016 
     1017        if (renderType == RenderState::DEFERRED)  
     1018        { 
     1019                glPopAttrib(); 
     1020                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); 
     1021 
     1022                cgGLDisableProfile(RenderState::sCgVertexProfile); 
     1023                cgGLDisableProfile(RenderState::sCgFragmentProfile); 
     1024 
     1025                glDrawBuffers(1, mrt); 
     1026 
     1027                DisplayRenderTexture(); 
     1028        } 
     1029 
    9961030 
    9971031        algTime = algTimer.Elapsedms(); 
    9981032 
     1033 
    9991034        /////////// 
     1035 
     1036        state.SetRenderType(RenderState::FIXED); 
    10001037 
    10011038        if (visMode) DisplayVisualization(); 
    … …  
    11881225                break; 
    11891226        case GLUT_KEY_F7: 
    1190                 depthPass = !depthPass; 
    1191                 traverser->SetUseDepthPass(depthPass); 
     1227 
     1228                renderType = (renderType + 1) % 3; 
     1229                traverser->SetUseDepthPass(renderType == RenderState::DEPTH_PASS); 
     1230                 
    11921231                break; 
    11931232        case GLUT_KEY_F8: 
    1194                 useGlFinish = !useGlFinish; 
    1195                 break; 
    1196         case GLUT_KEY_F9: 
    11971233                useSsao = !useSsao; 
    11981234                break; 
    … …  
    15821618        sprintf(msg[i ++], "assumed visible frames: %4d, max batch size: %4d",  
    15831619                    assumedVisibleFrames, maxBatchSize); 
    1584  
    1585         sprintf(msg[i ++], "multiqueries: %d, tight bounds: %d, render queue: %d, depth pass: %d, glFinish: %d",  
    1586                     useMultiQueries, useTightBounds, useRenderQueue, depthPass, useGlFinish); 
     1620         
     1621        static char *renderTypeStr[] = {"fixed function", "fixed function + depth pass", "deferred shading"}; 
     1622 
     1623        sprintf(msg[i ++], "multiqueries: %d, tight bounds: %d, render queue: %d, render technique: %s",  
     1624                    useMultiQueries, useTightBounds, useRenderQueue, renderTypeStr[renderType]); 
    15871625 
    15881626        sprintf(msg[i ++], "triangles per virtual leaf: %5d", trianglesPerVirtualLeaf); 
    … …  
    16301668void RenderVisibleObjects() 
    16311669{ 
    1632         state.SetDepthPass(false); 
     1670        state.SetRenderType(RenderState::FIXED); 
    16331671        state.Reset(); 
    16341672 
    … …  
    18111849void CreateNoiseTex2D() 
    18121850{ 
    1813         randomNormals = new GLubyte[texWidth * texHeight * 4]; 
    1814  
    1815         for (int i = 0; i < texWidth * texHeight * 4; i += 4) 
     1851        randomNormals = new GLubyte[texWidth * texHeight * 3]; 
     1852 
     1853        for (int i = 0; i < texWidth * texHeight * 3; i += 3) 
    18161854        { 
    18171855                // create random samples over sphere 
    … …  
    18221860                randomNormals[i + 1] = (GLubyte)((sin(theta) * 0.5f + 0.5f) * 255.0f); 
    18231861                randomNormals[i + 2] = 0; 
    1824                 randomNormals[i + 3] = 255; 
    18251862        } 
    18261863 
    … …  
    18281865        glGenTextures(1, &noiseTex); 
    18291866        glBindTexture(GL_TEXTURE_2D, noiseTex); 
    1830         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
    1831  
    1832         gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, texWidth, texHeight, GL_RGBA, GL_UNSIGNED_BYTE, randomNormals); 
     1867                 
    18331868        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 
    18341869        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    … …  
    18361871        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 
    18371872 
     1873        //glTexImage2D(GL_RGBA, 0, GL_RGBA, texWidth, texHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, randomNormals); 
     1874        gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, texWidth, texHeight, GL_RGB, GL_UNSIGNED_BYTE, randomNormals); 
     1875 
    18381876        glBindTexture(GL_TEXTURE_2D, 0); 
    18391877        glDisable(GL_TEXTURE_2D); 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/deferred.cg

    r2823 r2825  
    11#define NUM_SAMPLES 12 
    2 //#define SAMPLE_INTENSITY 0.4f 
    3 #define SAMPLE_INTENSITY 0.7f 
     2#define SAMPLE_INTENSITY 1.2f 
     3//#define SAMPLE_INTENSITY 0.7f 
    44#define AREA_SIZE 5e-1f 
    55 
    … …  
    102102    float2 offsetTransformed = rotate(offset, noise); 
    103103    //float2 offsetTransformed = reflect(offset, noise); 
    104  
    105     //offsetTransformed.x = noise.r * offset.x - noise.g * offset.y; 
    106     //offsetTransformed.y = noise.g * offset.x + noise.r * offset.y; 
    107                  
     104                
    108105    // weight with projected coordinate to reach similar kernel size for near and far 
    109106    float2 texcoord = IN.texCoord.xy + offsetTransformed * AREA_SIZE * w; 
    … …  
    118115    float cos_angle = dot(direction_to_sample, currentNormal); 
    119116    cos_angle = max(cos_angle, 0.0f); 
    120      
     117    cos_angle *= cos_angle; 
     118 
    121119    // distance between current position and sample position controls AO intensity. 
    122     //const float maxdist = 2e-1f; 
     120    //const float maxdist = 4e-1f; 
    123121    const float maxdist = 5e-1f; 
    124122     
Note: See TracChangeset for help on using the changeset viewer.