Changeset 3101


Ignore:
Timestamp:
11/05/08 15:14:22 (16 years ago)
Author:
mattausch
Message:

depth queries not working

Location:
GTP/trunk/App/Demos/Vis/FriendlyCulling/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r3089 r3101  
    101101 
    102102        for (; sit != sit_end; ++ sit) 
    103         { 
    104103                (*sit)->Render(state); 
    105         } 
    106104 
    107105        mTransform->Unload(state); 
    … …  
    143141 
    144142        if (lodLevel == -1) 
    145         { 
    146143                lodLevel = GetCurrentLODLevel(); 
    147         } 
    148144 
    149145        return mLODLevels[lodLevel].GetNumTriangles(); 

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

    r3089 r3101  
    66#include "RenderTraverser.h" 
    77#include "FrameBufferObject.h" 
     8#include "RenderState.h" 
    89 
    910#include <IL/il.h> 
    … …  
    7576        startil(); 
    7677 
    77         ILstring filename = ILstring("depth.tga"); 
     78        ILstring filename = ILstring("sceneQuery.tga"); 
    7879        ilRegisterType(IL_FLOAT); 
    7980 
    … …  
    100101 
    101102SceneQuery::SceneQuery(const AxisAlignedBox3 &sceneBox,  
    102                                            RenderTraverser *renderer):  
    103 mSceneBox(sceneBox), mDepth(NULL) 
     103                                           RenderTraverser *renderer, RenderState *state):  
     104mSceneBox(sceneBox), mDepth(NULL), mRenderState(state) 
    104105{ 
    105106        Prepare(renderer); 
    … …  
    112113        const int py = (mSceneBox.Max(1) - pt.y) * (texHeight - 1) / mSceneBox.Size(1); 
    113114 
    114         float d = mDepth[px + py * texHeight]; 
     115        const float d = mDepth[px + py * texHeight]; 
    115116 
    116117        static float depth = d; 
    117118 
    118         if (d > 0) 
     119        if (d > .0f) 
    119120        { 
    120121                // temporal smoothing of depth values 
    … …  
    136137        cout << "Preparing scene queries" << endl; 
    137138 
    138         const float xlen = mSceneBox.Size().x * 0.5f; 
    139         const float ylen = mSceneBox.Size().y * 0.5f; 
     139        const float xlen = mSceneBox.Size().x * .5f; 
     140        const float ylen = mSceneBox.Size().y * .5f; 
    140141         
    141142        PerspectiveCamera *orthoCam = new PerspectiveCamera(xlen / ylen); 
    … …  
    165166        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    166167 
     168        // hack: disable cull face because of alpha textured balconies 
    167169        glDisable(GL_CULL_FACE); 
    168         glEnable(GL_DEPTH_TEST); 
     170        mRenderState->LockCullFaceEnabled(true); 
     171 
     172        //glDisable(GL_CULL_FACE); 
     173        //glEnable(GL_DEPTH_TEST); 
    169174 
    170175        glMatrixMode(GL_MODELVIEW); 
    … …  
    177182 
    178183        glOrtho(xlen, -xlen, ylen, -ylen, 0.0f, mSceneBox.Size().z);  
     184        //glOrtho(xlen, .0f, ylen, .0f, .0f, mSceneBox.Size().z);  
    179185 
    180186        glMatrixMode(GL_MODELVIEW); 
    … …  
    190196        glEnableClientState(GL_NORMAL_ARRAY); 
    191197 
     198        // forward rendering 
     199        mRenderState->SetRenderTechnique(0); 
     200 
    192201        renderer->RenderScene(); 
    193202 
    … …  
    197206        renderer->SetCamera(oldCam); 
    198207         
    199  
    200         glEnable(GL_CULL_FACE); 
     208        mRenderState->LockCullFaceEnabled(false); 
     209        //glEnable(GL_CULL_FACE); 
    201210 
    202211        glMatrixMode(GL_MODELVIEW); 
    … …  
    211220 
    212221        GrabDepthBuffer(mDepth, fbo->GetDepthTex()); 
    213         //ExportDepthBuffer(mDepth); PrintGLerror("grab"); 
     222        ExportDepthBuffer(mDepth); PrintGLerror("grab depth"); 
    214223 
    215224        DEL_PTR(fbo); 

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

    r2848 r3101  
    1010 
    1111class RenderTraverser; 
     12class RenderState; 
    1213 
    1314/** A simple class that computes the first intersection of a horizontal ray with 
    … …  
    1819public: 
    1920 
    20         SceneQuery(const AxisAlignedBox3 &sceneBox, RenderTraverser *traverser); 
     21        SceneQuery(const AxisAlignedBox3 &sceneBox, RenderTraverser *traverser, 
     22                       RenderState *state); 
    2123 
    2224        ~SceneQuery() { DEL_ARRAY_PTR(mDepth); } 
    … …  
    3840        //unsigned char *mDepth; 
    3941        float *mDepth; 
     42 
     43        RenderState *mRenderState; 
    4044}; 
    4145 

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

    r3089 r3101  
    8686/// the visualization 
    8787Visualization *visualization = NULL; 
    88 /// the current render state 
    89 RenderState state; 
     88/// the current render renderState 
     89RenderState renderState; 
    9090/// the rendering algorithm 
    9191int renderMode = RenderTraverser::CHCPLUSPLUS; 
    … …  
    162162int numBatches = 0; 
    163163 
    164 // mouse navigation state 
     164// mouse navigation renderState 
    165165int xEyeBegin = 0; 
    166166int yEyeBegin = 0; 
    … …  
    267267void SpecialKeyUp(int c, int x, int y); 
    268268void Reshape(int w, int h); 
    269 void Mouse(int button, int state, int x, int y); 
     269void Mouse(int button, int renderState, int x, int y); 
    270270void LeftMotion(int x, int y); 
    271271void RightMotion(int x, int y); 
    … …  
    404404        light = new DirectionalLight(lightDir, RgbaColor(1, 1, 1, 1), RgbaColor(1, 1, 1, 1)); 
    405405        // the render queue for material sorting 
    406         renderQueue = new RenderQueue(&state); 
     406        renderQueue = new RenderQueue(&renderState); 
    407407 
    408408        glutInitWindowSize(winWidth, winHeight); 
    … …  
    527527         
    528528        // the bird-eye visualization 
    529         visualization = new Visualization(bvh, camera, NULL, &state); 
     529        visualization = new Visualization(bvh, camera, NULL, &renderState); 
    530530 
    531531        // this function assign the render queue bucket ids of the materials in beforehand 
    … …  
    533533        PrepareRenderQueue(); 
    534534        /// forward rendering is the default 
    535         state.SetRenderTechnique(FORWARD); 
     535        renderState.SetRenderTechnique(FORWARD); 
    536536        // frame time is restarted every frame 
    537537        frameTimer.Start(); 
    … …  
    729729        tr->SetHierarchy(bvh); 
    730730        tr->SetRenderQueue(renderQueue); 
    731         tr->SetRenderState(&state); 
     731        tr->SetRenderState(&renderState); 
    732732        tr->SetUseOptimization(useOptimization); 
    733733        tr->SetUseRenderQueue(useRenderQueue); 
    … …  
    853853        // multisampling does not work with deferred shading 
    854854        glDisable(GL_MULTISAMPLE_ARB); 
    855         state.SetRenderTechnique(DEFERRED); 
     855        renderState.SetRenderTechnique(DEFERRED); 
    856856 
    857857 
    … …  
    940940         
    941941                glEnable(GL_MULTISAMPLE_ARB); 
    942                 state.SetRenderTechnique(FORWARD); 
     942                renderState.SetRenderTechnique(FORWARD); 
    943943                //glEnable(GL_LIGHTING); 
    944944 
    … …  
    950950 
    951951                glDisable(GL_MULTISAMPLE_ARB); 
    952                 state.SetUseAlphaToCoverage(false); 
    953                 state.SetRenderTechnique(DEPTH_PASS); 
     952                renderState.SetUseAlphaToCoverage(false); 
     953                renderState.SetRenderTechnique(DEPTH_PASS); 
    954954 
    955955                if (!fbo) InitFBO(); fbo->Bind(); 
    … …  
    960960 
    961961                // the scene is rendered withouth any shading  
    962                 // (should be handled by render state) 
     962                // (should be handled by render renderState) 
    963963                glShadeModel(GL_FLAT); 
    964964                break; 
    … …  
    967967 
    968968                glEnable(GL_MULTISAMPLE_ARB); 
    969                 state.SetRenderTechnique(DEPTH_PASS); 
     969                renderState.SetRenderTechnique(DEPTH_PASS); 
    970970 
    971971                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    972972 
    973973                // the scene is rendered withouth any shading  
    974                 // (should be handled by render state) 
     974                // (should be handled by render renderState) 
    975975                glShadeModel(GL_FLAT); 
    976976                break; 
    … …  
    10041004        if (renderLightView) 
    10051005        { 
    1006                 // change CHC++ set of state variables:  
     1006                // change CHC++ set of renderState variables:  
    10071007                // must be done for each change of camera because otherwise  
    10081008                // the temporal coherency is broken 
    … …  
    10681068 
    10691069 
    1070         state.SetRenderTechnique(FORWARD); 
    1071         state.Reset(); 
     1070        renderState.SetRenderTechnique(FORWARD); 
     1071        renderState.Reset(); 
    10721072 
    10731073 
    … …  
    14061406 
    14071407 
    1408 void Mouse(int button, int state, int x, int y)  
    1409 { 
    1410         if ((button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN)) 
     1408void Mouse(int button, int renderState, int x, int y)  
     1409{ 
     1410        if ((button == GLUT_LEFT_BUTTON) && (renderState == GLUT_DOWN)) 
    14111411        { 
    14121412                xEyeBegin = x; 
    … …  
    14151415                glutMotionFunc(LeftMotion); 
    14161416        } 
    1417         else if ((button == GLUT_RIGHT_BUTTON) && (state == GLUT_DOWN)) 
     1417        else if ((button == GLUT_RIGHT_BUTTON) && (renderState == GLUT_DOWN)) 
    14181418        { 
    14191419                xEyeBegin = x; 
    … …  
    14261426                        glutMotionFunc(RightMotionLight); 
    14271427        } 
    1428         else if ((button == GLUT_MIDDLE_BUTTON) && (state == GLUT_DOWN)) 
     1428        else if ((button == GLUT_MIDDLE_BUTTON) && (renderState == GLUT_DOWN)) 
    14291429        { 
    14301430                horizontalMotionBegin = x; 
    … …  
    18081808                        static char *renderMethodStr[] =  
    18091809                                {"forward", "depth pass + forward", "deferred shading", "depth pass + deferred"}; 
    1810          
    18111810                        sprintf(msg[i ++], "multiqueries: %d, tight bounds: %d, render queue: %d",  
    18121811                                        useMultiQueries, useTightBounds, useRenderQueue); 
    1813  
    18141812                        sprintf(msg[i ++], "render technique: %s, SSAO: %d", renderMethodStr[renderMethod], useAdvancedShading); 
    1815  
    18161813                        sprintf(msg[i ++], "triangles per virtual leaf: %5d", trianglesPerVirtualLeaf); 
    1817  
    18181814                        sprintf(msg[i ++], "assumed visible frames: %4d, max batch size: %4d",  
    18191815                                assumedVisibleFrames, maxBatchSize); 
    … …  
    18521848                        sprintf(msg[i ++], "traversed: %5d, frustum culled: %5d, query culled: %5d", 
    18531849                                traversedNodes, frustumCulledNodes, queryCulledNodes); 
    1854  
    1855                         sprintf(msg[i ++], "issued queries: %5d, state changes: %5d, render batches: %5d",  
     1850                        sprintf(msg[i ++], "issued queries: %5d, renderState changes: %5d, render batches: %5d",  
    18561851                                issuedQueries, stateChanges, numBatches); 
    18571852 
    … …  
    18841879{ 
    18851880        if ((renderMethod == RENDER_DEFERRED) || (renderMethod == RENDER_DEPTH_PASS_DEFERRED)) 
    1886                 state.SetRenderTechnique(DEFERRED); 
     1881                renderState.SetRenderTechnique(DEFERRED); 
    18871882 
    18881883        const bool useToneMapping =  
    … …  
    18901885                 (renderMethod == RENDER_DEFERRED)) && useHDR; 
    18911886         
    1892         preetham->RenderSkyDome(-light->GetDirection(), camera, &state, !useToneMapping); 
    1893         /// once again reset the state 
    1894         state.Reset(); 
     1887        preetham->RenderSkyDome(-light->GetDirection(), camera, &renderState, !useToneMapping); 
     1888        /// once again reset the renderState 
     1889        renderState.Reset(); 
    18951890} 
    18961891 
    … …  
    19141909        else 
    19151910        { 
    1916                 state.SetRenderTechnique(FORWARD); 
     1911                renderState.SetRenderTechnique(FORWARD); 
    19171912        } 
    19181913 
    19191914        ///////////////// 
    1920         //-- reset gl state before the final visible objects pass 
    1921  
    1922         state.Reset(); 
     1915        //-- reset gl renderState before the final visible objects pass 
     1916 
     1917        renderState.Reset(); 
    19231918 
    19241919        glEnableClientState(GL_NORMAL_ARRAY); 
    … …  
    19261921        glShadeModel(GL_SMOOTH); 
    19271922        /// reset alpha to coverage flag 
    1928         state.SetUseAlphaToCoverage(true); 
     1923        renderState.SetUseAlphaToCoverage(true); 
    19291924        // clear color 
    19301925        glClear(GL_COLOR_BUFFER_BIT); 
    … …  
    19471942        // switch back to standard depth func 
    19481943        glDepthFunc(GL_LESS); 
    1949         state.Reset(); 
     1944        renderState.Reset(); 
    19501945 
    19511946        PrintGLerror("visibleobjects"); 
    … …  
    19561951{ 
    19571952        if (!sceneQuery) 
    1958                 sceneQuery = new SceneQuery(bvh->GetBox(), traverser); 
     1953        { 
     1954                sceneQuery = new SceneQuery(bvh->GetBox(), traverser, &renderState); 
     1955        } 
    19591956 
    19601957        Vector3 playerPos = camera->GetPosition(); 
    … …  
    19721969{ 
    19731970        glDisableClientState(GL_NORMAL_ARRAY); 
    1974         state.SetRenderTechnique(DEPTH_PASS); 
     1971        renderState.SetRenderTechnique(DEPTH_PASS); 
    19751972         
    19761973        // hack: disable cull face because of alpha textured balconies 
    19771974        glDisable(GL_CULL_FACE); 
    1978         state.LockCullFaceEnabled(true); 
     1975        renderState.LockCullFaceEnabled(true); 
    19791976 
    19801977        /// don't use alpha to coverage for the depth map (problems with fbo rendering) 
    1981         state.SetUseAlphaToCoverage(false); 
    1982  
    1983         // change CHC++ set of state variables  
     1978        renderState.SetUseAlphaToCoverage(false); 
     1979 
     1980        // change CHC++ set of renderState variables  
    19841981        // this must be done for each change of camera because 
    19851982        // otherwise the temporal coherency is broken 
    … …  
    19931990        camera->SetFar(farDist); 
    19941991 
    1995         state.SetUseAlphaToCoverage(true); 
    1996         state.LockCullFaceEnabled(false); 
     1992        renderState.SetUseAlphaToCoverage(true); 
     1993        renderState.LockCullFaceEnabled(false); 
    19971994 
    19981995        glEnableClientState(GL_NORMAL_ARRAY); 
    1999         // change back state 
     1996        // change back renderState 
    20001997        BvhNode::SetCurrentState(CAMERA_PASS); 
    20011998} 
    … …  
    20092006        for (int i = 0; i < 3; ++ i) 
    20102007        { 
    2011                 state.SetRenderTechnique(i); 
     2008                renderState.SetRenderTechnique(i); 
    20122009 
    20132010                // fill all shapes into the render queue        once so we can establish the buckets 

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

    r3100 r3101  
    8888         
    8989        const float sampleEyeSpaceDepth = tex2Dlod(colors, float4(texCoord, 0, 0)).w; 
    90         //float3 viewVec = normalize(Interpol(texcoord, bl, br, tl, tr)); 
     90         
    9191        const float3 viewVec = Interpol(texCoord, bl, br, tl, tr); 
    9292        const float3 samplePos = -viewVec * sampleEyeSpaceDepth; 
    … …  
    158158        // fit from unit cube into 0 .. 1 
    159159        const float2 oldTexCoords = backProjPos.xy * 0.5f + 0.5f; 
    160         //const float2 oldTexCoords = texcoord0; 
     160         
    161161 
    162162        // retrieve the sample from the last frame 
    … …  
    166166 
    167167        // vector from eye pos to old sample  
    168         //const float3 viewVec = normalize(Interpol(oldTexCoords, oldbl, oldbr, oldtl, oldtr)); 
    169168        const float3 viewVec = Interpol(oldTexCoords, oldbl, oldbr, oldtl, oldtr); 
    170         //const float3 oldWorldPos = oldEyePos - oldEyeSpaceDepth * viewVec; 
    171         //const float3 oldWorldPos = - viewVec * eyeSpaceDepth; 
    172         //const float3 dummy14 = Interpol(texcoord0, bl, br, tl, tr); 
    173  
    174         // the euclidian world space distance 
    175         //const float depthDif = length(oldWorldPos - worldPos.xyz); 
    176         //const float depthDif = length(dummy14 - viewVec); 
    177         //const float projectedEyeSpaceDepth = length(worldPos + oldEyePos); 
     169         
    178170        const float invlen = 1.0f / length(viewVec); 
    179171        const float projectedEyeSpaceDepth = length(dummyPt) * invlen; 
    180172         
    181173        const float depthDif = abs(oldEyeSpaceDepth - projectedEyeSpaceDepth); 
    182         //const float depthDif = length(oldEyePos); 
    183  
     174         
    184175        float notValid = 0.5f; 
    185176 
Note: See TracChangeset for help on using the changeset viewer.