Ignore:
Timestamp:
10/09/08 11:19:33 (16 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/App/Demos/Vis/FriendlyCulling
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed

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

    r3012 r3017  
    1212EndProject 
    1313Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "IrradianceMapping", "IrradianceMapping.vcproj", "{91680C49-A358-48AE-A02C-66CB884B7D7F}" 
     14        ProjectSection(ProjectDependencies) = postProject 
     15                {03661866-4093-4B02-B26A-028EA91AF023} = {03661866-4093-4B02-B26A-028EA91AF023} 
     16        EndProjectSection 
    1417EndProject 
    1518Global 

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

    r3016 r3017  
    5353 
    5454static CGparameter sDownSampleOffsetParam; 
    55  
     55static CGparameter sFilterOffsetsParam; 
     56static CGparameter sFilterWeightsParam; 
    5657 
    5758static CGprogram sCgDownSampleProgram; 
    … …  
    6566 
    6667static CGparameter sColorsTexParam; 
    67 static CGparameter sPositionsTexParam; 
    6868static CGparameter sNormalsTexParam; 
    6969 
    … …  
    175175} 
    176176 
    177  
     177static void ComputeSampleOffsets(float *sampleOffsets, int w, int h) 
     178{ 
     179        /* 
     180        const float xoffs = 0.5f / w; 
     181        const float yoffs = 0.5f / h; 
     182 
     183        sampleOffsets[0] =  xoffs; sampleOffsets[1] =  yoffs; 
     184        sampleOffsets[2] =  xoffs; sampleOffsets[3] = -yoffs; 
     185        sampleOffsets[4] = -xoffs; sampleOffsets[5] = -yoffs; 
     186        sampleOffsets[6] = -xoffs; sampleOffsets[7] =  yoffs; 
     187        */ 
     188        //const float xoffs = .5f / w; 
     189        //const float yoffs = .5f / h; 
     190         
     191        const float xoffs = 1.0f / w; 
     192        const float yoffs = 1.0f / h; 
     193 
     194        int idx  = 0; 
     195 
     196        for (int x = -1; x <= 1; ++ x) 
     197        { 
     198                for (int y = -1; y <= 1; ++ y) 
     199                { 
     200                        sampleOffsets[idx + 0] = x * xoffs; 
     201                        sampleOffsets[idx + 1] = y * yoffs; 
     202 
     203                        idx += 2; 
     204                } 
     205        } 
     206} 
    178207 
    179208/** Generate poisson disc distributed sample points on the unit disc 
    … …  
    284313 
    285314        mFbo = new FrameBufferObject(w / 2, h / 2, FrameBufferObject::DEPTH_NONE); 
    286  
    287         mFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
    288         mFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
    289         mFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
    290         mFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
     315        //mFbo = new FrameBufferObject(w, h, FrameBufferObject::DEPTH_NONE); 
     316 
     317        mFbo->AddColorBuffer(ColorBufferObject::RGB_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
     318        mFbo->AddColorBuffer(ColorBufferObject::RGB_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
     319        mFbo->AddColorBuffer(ColorBufferObject::RGB_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
     320        mFbo->AddColorBuffer(ColorBufferObject::RGB_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
    291321 
    292322        mDownSampleFbo = new FrameBufferObject(w / 2, h / 2, FrameBufferObject::DEPTH_NONE); 
     323 
    293324        mDownSampleFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
    294         mDownSampleFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_16, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
    295         mDownSampleFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
     325        mDownSampleFbo->AddColorBuffer(ColorBufferObject::RGB_FLOAT_16, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR); 
    296326} 
    297327 
    … …  
    361391                cgGLLoadProgram(sCgSsaoProgram); 
    362392 
    363                 sPositionsTexParam = cgGetNamedParameter(sCgSsaoProgram, "positions");   
    364393                sColorsTexParam = cgGetNamedParameter(sCgSsaoProgram, "colors");   
    365394                sEyePosParam = cgGetNamedParameter(sCgSsaoProgram, "eyePos"); 
    … …  
    452481                sColorsTexCombinedSsaoParam = cgGetNamedParameter(sCgCombinedSsaoProgram, "colors");   
    453482                sSsaoTexCombinedSsaoParam = cgGetNamedParameter(sCgCombinedSsaoProgram, "ssaoTex"); 
     483 
     484                sFilterOffsetsParam = cgGetNamedParameter(sCgCombinedSsaoProgram, "filterOffs"); 
     485                sFilterWeightsParam = cgGetNamedParameter(sCgCombinedSsaoProgram, "filterWeights"); 
    454486        } 
    455487        else 
    … …  
    622654                DownSample(fbo, colorBufferIdx, mDownSampleFbo, 0); 
    623655                DownSample(fbo, 1, mDownSampleFbo, 1); 
    624                 DownSample(fbo, 2, mDownSampleFbo, 2); 
    625656 
    626657                ComputeSsao(fbo, tempCohFactor, oldProjViewMatrix, projViewMatrix); 
    … …  
    690721        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture(); 
    691722        GLuint normalsTex = fbo->GetColorBuffer(1)->GetTexture(); 
    692         GLuint positionsTex = fbo->GetColorBuffer(2)->GetTexture(); 
    693723#else 
    694724        GLuint colorsTex = mDownSampleFbo->GetColorBuffer(0)->GetTexture(); 
    695725        GLuint normalsTex = mDownSampleFbo->GetColorBuffer(1)->GetTexture(); 
    696         GLuint positionsTex = mDownSampleFbo->GetColorBuffer(2)->GetTexture(); 
    697726#endif 
    698727 
    … …  
    708737         
    709738        cgGLBindProgram(sCgSsaoProgram); 
    710  
    711         cgGLSetTextureParameter(sPositionsTexParam, positionsTex); 
    712         cgGLEnableTextureParameter(sPositionsTexParam); 
    713739 
    714740        cgGLSetTextureParameter(sColorsTexParam, colorsTex); 
    … …  
    764790        glTexCoord2f(0, 1); glMultiTexCoord3fARB(GL_TEXTURE1_ARB, tl.x, tl.y, tl.z); glVertex3f(-offs,  offs, -0.5f); 
    765791 
     792        //cout<<bl << " " << br << endl; 
     793 
    766794        glEnd(); 
    767795 
    768796        cgGLDisableTextureParameter(sColorsTexParam); 
    769         cgGLDisableTextureParameter(sPositionsTexParam); 
    770797        cgGLDisableTextureParameter(sNormalsTexParam); 
    771798        cgGLDisableTextureParameter(sNoiseTexParam); 
    … …  
    10401067 
    10411068 
     1069static float GaussianDistribution(float x, float y, float rho) 
     1070{ 
     1071    float g = 1.0f / sqrtf(2.0f * M_PI * rho * rho); 
     1072    g *= expf( -(x*x + y*y) / (2.0f * rho * rho)); 
     1073 
     1074    return g; 
     1075} 
     1076 
     1077 
    10421078void DeferredRenderer::CombineSsao(FrameBufferObject *fbo) 
    10431079{ 
    … …  
    10541090 
    10551091        cgGLBindProgram(sCgCombinedSsaoProgram); 
     1092 
     1093        float filterOffsets[NUM_DOWNSAMPLES * 2]; 
     1094        float filterWeights[NUM_DOWNSAMPLES]; 
     1095 
     1096        PoissonDiscSampleGenerator2 poisson(NUM_DOWNSAMPLES, 1.0f); 
     1097        poisson.Generate((float *)filterOffsets); 
     1098 
     1099        const float xoffs = 2.0f / fbo->GetWidth(); 
     1100        const float yoffs = 2.0f / fbo->GetHeight(); 
     1101 
     1102        for (int i = 0; i < NUM_DOWNSAMPLES; ++ i) 
     1103        { 
     1104                float x = filterOffsets[2 * i + 0]; 
     1105                float y = filterOffsets[2 * i + 1]; 
     1106 
     1107                filterOffsets[2 * i + 0] *= xoffs; 
     1108                filterOffsets[2 * i + 1] *= yoffs; 
     1109 
     1110                filterWeights[i] = GaussianDistribution(x, y, 1.0f); 
     1111        } 
     1112 
     1113        //ComputeSampleOffsets(filterOffsets, fbo->GetWidth(), fbo->GetHeight()); 
     1114        cgGLSetParameterArray2f(sFilterOffsetsParam, 0, NUM_DOWNSAMPLES, (const float *)filterOffsets); 
     1115        cgGLSetParameterArray1f(sFilterWeightsParam, 0, NUM_DOWNSAMPLES, (const float *)filterWeights); 
    10561116 
    10571117        cgGLSetTextureParameter(sColorsTexCombinedSsaoParam, colorsTex); 
    … …  
    11871247 
    11881248        const float minKey = 0.09f; 
    1189         const float maxKey = 0.5f; 
     1249        const float maxKey = 0.45f; 
    11901250 
    11911251        const float lightIntensity = DotProd(-light->GetDirection(), Vector3::UNIT_Z()); 
    11921252        middleGrey = lightIntensity * maxKey + (1.0f - lightIntensity) * minKey; 
    11931253 
    1194  
    1195 #if 1 
    11961254 
    11971255        ////////// 
    … …  
    12261284        PrintGLerror("ToneMapParams"); 
    12271285 
    1228 #endif 
    12291286 
    12301287        /////////////////// 
    … …  
    12651322 
    12661323 
    1267 static void ComputeDownsSampleOffsets(float *downSampleOffsets, int w, int h) 
    1268 { 
    1269         /* 
    1270         float downSampleOffsets[8]; 
    1271  
    1272         const float xoffs = 0.5f / w; 
    1273         const float yoffs = 0.5f / h; 
    1274  
    1275         downSampleOffsets[0] =  xoffs; downSampleOffsets[1] =  yoffs; 
    1276         downSampleOffsets[2] =  xoffs; downSampleOffsets[3] = -yoffs; 
    1277         downSampleOffsets[4] = -xoffs; downSampleOffsets[5] = -yoffs; 
    1278         downSampleOffsets[6] = -xoffs; downSampleOffsets[7] =  yoffs; 
    1279         */ 
    1280         //const float xoffs = .5f / w; 
    1281         //const float yoffs = .5f / h; 
    1282          
    1283         const float xoffs = 1.0f / w; 
    1284         const float yoffs = 1.0f / h; 
    1285  
    1286         int idx  = 0; 
    1287  
    1288         for (int x = -1; x <= 1; ++ x) 
    1289         { 
    1290                 for (int y = -1; y <= 1; ++ y) 
    1291                 { 
    1292                         downSampleOffsets[idx + 0] = x * xoffs; 
    1293                         downSampleOffsets[idx + 1] = y * yoffs; 
    1294  
    1295                         idx += 2; 
    1296                 } 
    1297         } 
    1298 } 
    1299  
    1300  
    13011324void DeferredRenderer::DownSample(FrameBufferObject *fbo, int bufferIdx, 
    13021325                                                                  FrameBufferObject *downSampleFbo,  
    13031326                                                                  int downSampleBufferIdx) 
    13041327{ 
    1305         float downSampleOffsets[NUM_DOWNSAMPLES * 2]; 
    1306         ComputeDownsSampleOffsets(downSampleOffsets, fbo->GetWidth(), fbo->GetHeight()); 
    1307  
    13081328        ColorBufferObject *colorBuffer = fbo->GetColorBuffer(bufferIdx); 
    13091329        GLuint colorsTex = colorBuffer->GetTexture(); 
    … …  
    13161336        cgGLSetTextureParameter(sColorsTexDownSampleParam, colorsTex); 
    13171337        cgGLEnableTextureParameter(sColorsTexDownSampleParam); 
     1338 
     1339        float downSampleOffsets[NUM_DOWNSAMPLES * 2]; 
     1340        ComputeSampleOffsets(downSampleOffsets, fbo->GetWidth(), fbo->GetHeight()); 
    13181341 
    13191342        cgGLSetParameterArray2f(sDownSampleOffsetParam, 0, NUM_DOWNSAMPLES, (const float *)downSampleOffsets); 

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

    r3007 r3017  
    9393        { 
    9494        case RGB_UBYTE:  
    95                 mGlFormat = GL_UNSIGNED_BYTE; mInternalFormat = GL_RGB8; 
    96                 components = GL_RGB; 
    97                 break; 
     95                mGlFormat = GL_UNSIGNED_BYTE; mInternalFormat = GL_RGB8; components = GL_RGB; break; 
    9896        case RGBA_UBYTE: 
    9997                mGlFormat = GL_UNSIGNED_BYTE; mInternalFormat = GL_RGBA8; break; 
     98        case RGB_FLOAT_32:  
     99                mGlFormat = GL_FLOAT; mInternalFormat = GL_RGB16F_ARB; components = GL_RGB;     break; 
    100100        case RGBA_FLOAT_16: 
    101101                mGlFormat = GL_FLOAT; mInternalFormat = GL_RGBA16F_ARB; break; 
    102         case RGB_FLOAT_32:  
    103                 mGlFormat = GL_FLOAT; mInternalFormat = GL_RGB32F_ARB; 
    104                 components = GL_RGB; 
    105                 break; 
     102        case RGB_FLOAT_16:  
     103                mGlFormat = GL_FLOAT; mInternalFormat = GL_RGB32F_ARB; components = GL_RGB;     break; 
    106104        case RGBA_FLOAT_32:  
    107105                mGlFormat = GL_FLOAT; mInternalFormat = GL_RGBA32F_ARB; break; 

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

    r3007 r3017  
    1515public: 
    1616 
    17         enum FORMAT { RGB_UBYTE, RGBA_UBYTE, RGBA_FLOAT_16, RGB_FLOAT_32, RGBA_FLOAT_32}; 
     17        enum FORMAT { RGB_UBYTE, RGBA_UBYTE, RGB_FLOAT_16, RGBA_FLOAT_16, RGB_FLOAT_32, RGBA_FLOAT_32 }; 
     18 
    1819        enum WRAP_TYPE { WRAP_REPEAT, WRAP_CLAMP_TO_EDGE }; 
    1920        enum FILTER_TYPE { FILTER_NEAREST, FILTER_LINEAR }; 

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

    r2983 r3017  
    343343                diffuse = color * 3e-1f; 
    344344 
     345        // diffuse component should be more saturated (and less blueish) for high sun positions 
     346        diffuse.x *= 1.2f; 
     347        diffuse.z *= 0.8f; 
     348 
     349        // scale diffuse component in order to make sky look less bright in relation to 
     350        // the geometry in the evening 
    345351        diffuse *= (2.0f - 1.0f * DotProd(sunDir, Vector3::UNIT_Z())); 
    346352 

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

    r3016 r3017  
    616616        fbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR, ColorBufferObject::FILTER_NEAREST); 
    617617        // the normals buffer 
    618         fbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_16, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_NEAREST); 
     618        fbo->AddColorBuffer(ColorBufferObject::RGB_FLOAT_16, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_NEAREST); 
    619619        // the positions buffer 
    620620        //fbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_NEAREST); 
    … …  
    947947        cgGLSetParameter3f(sTRParam, tr.x, tr.y, tr.z); 
    948948 
     949        //cout<<bl << " " << br << endl; 
    949950        cgGLSetParameter3f(sBLParamTex, bl.x, bl.y, bl.z); 
    950951        cgGLSetParameter3f(sBRParamTex, br.x, br.y, br.z); 
    951952        cgGLSetParameter3f(sTLParamTex, tl.x, tl.y, tl.z); 
    952953        cgGLSetParameter3f(sTRParamTex, tr.x, tr.y, tr.z); 
     954 
    953955 
    954956        // draw to 3 color buffers 

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

    r3016 r3017  
    1010 
    1111// for quadratic falloff 
    12 #define SAMPLE_INTENSITY 0.15f 
    13 //#define SAMPLE_INTENSITY 0.32f 
     12#define SAMPLE_INTENSITY 0.1f 
     13//#define SAMPLE_INTENSITY 0.2f 
    1414 
    15 #define AREA_SIZE 8e-1f 
     15#define SAMPLE_RADIUS 8e-1f 
    1616 
    1717//#define DISTANCE_SCALE 1e-1f 
    1818#define DISTANCE_SCALE 5e-2f 
    1919 
    20 #define ILLUM_INTENSITY 5e-2f 
     20#define ILLUM_INTENSITY 8e-2f 
    2121 
    22 #define VIEW_CORRECTION_SCALE 0.1f 
     22#define VIEW_CORRECTION_SCALE 1.0f 
    2323 
    2424 
    … …  
    4040#define MAX_LOD_LEVEL 10 
    4141 
    42 #define MIN_DEPTH_DIFF 1e-3f 
     42#define MIN_DEPTH_DIFF 1e-6f 
    4343// burnout 
    4444#define WHITE_LUMINANCE 3e4f 
    … …  
    4646/////////////////// 
    4747 
    48 #define NUM_DOWNSAMPLES 9 
     48#define NUM_DOWNSAMPLES 16 
    4949 
    5050 

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

    r3016 r3017  
    168168        // diffuse intensity 
    169169        const float angle = saturate(dot(normal, lightDir));  
    170         //float4 lightDiffuse = float4(1.0f, 1.0f, 0.9f, 1.0f); 
    171170        const float4 lightDiffuse = glstate.light[0].diffuse; 
    172         //float4(1.0f, 1.0f, 0.9f, 1.0f); 
    173  
     171         
    174172        float4 diffuse = lightDiffuse * angle; 
    175173 

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

    r3016 r3017  
    88struct fragment 
    99{ 
    10          // normalized screen position 
    11         float4 pos: WPOS; 
    1210        float2 texCoord: TEXCOORD0;  
    1311        float3 view: TEXCOORD1; 
    … …  
    6866                                   uniform float3 tl, 
    6967                                   uniform float3 tr 
    70                                    //, uniform float3 viewDir 
     68                                   , uniform float3 viewDir 
    7169                                   ) 
    7270{ 
    … …  
    9896#endif 
    9997                // weight with projected coordinate to reach similar kernel size for near and far 
    100                 float2 texcoord = IN.texCoord.xy + offsetTransformed * AREA_SIZE * w; 
     98                float2 texcoord = IN.texCoord.xy + offsetTransformed * w; 
    10199 
    102100                //if ((texcoord.x <= 1.0f) && (texcoord.x >= 0.0f) && (texcoord.y <= 1.0f) && (texcoord.y >= 0.0f)) ++ numSamples; 
    … …  
    115113                const float3 sample_color = sample.xyz; 
    116114 
     115                // distance between current position and sample position controls AO intensity. 
     116 
    117117                float3 vector_to_sample = sample_position - centerPosition.xyz; 
    118118                const float length_to_sample = length(vector_to_sample); 
    … …  
    124124 
    125125                const float denom = (DISTANCE_SCALE + length_to_sample * length_to_sample); 
    126                 // distance between current position and sample position controls AO intensity. 
     126 
    127127                const float ssao_intensity = SAMPLE_INTENSITY / denom; 
    128  
    129128                const float illum_intensity = ILLUM_INTENSITY / denom; 
    130129 
    131                 // if normal perpenticular to view dir, only half of the samples count 
    132 #if 0 
    133                 const float view_correction = 1.0f + VIEW_CORRECTION_SCALE * (1.0f - dot(currentViewDir, currentNormal)); 
    134                 total_color.w -= cos_angle * distance_intensity * view_correction; 
    135                 total_color.xyz += cos_angle * distance_intensity * view_correction * sample_color * ILLUM_INTENSITY; 
    136 #endif 
     130                // if normal perpenticular to view dir, only the samples approx count half 
     131#if 1 
     132                const float view_correction = 1.0f + VIEW_CORRECTION_SCALE * dot(viewDir, currentNormal); 
     133         
     134                total_ao += cos_angle * ssao_intensity * view_correction; 
     135                total_color += cos_angle * illum_intensity * sample_color * view_correction; 
     136#else 
    137137                total_ao += cos_angle * ssao_intensity; 
    138138                total_color += cos_angle * illum_intensity * sample_color; 
     139#endif 
    139140        } 
    140141 
    … …  
    170171        float3 normal = normalize(norm.xyz);     
    171172 
    172         // the w coordinate from the persp. projection 
    173         float w = norm.w; 
    174  
    175  
     173         
    176174        ///////////// 
    177175        //-- reconstruct position from the eye space depth 
    … …  
    182180        const float3 eyeSpacePos = -viewDir * eyeDepth; 
    183181 
    184         float3 centerPosition = eyePos + eyeSpacePos; 
    185         //const float3 centerPosition = tex2D(positions, IN.texCoord.xy).xyz; 
    186  
     182        const float3 centerPosition = eyePos + eyeSpacePos; 
     183        const float4 realPos = float4(centerPosition, 1.0f); 
     184 
     185        // calculcate the current projected depth for next frame 
     186        float4 currentPos = mul(modelViewProj, realPos); 
     187        const float w = SAMPLE_RADIUS / currentPos.w; 
     188        currentPos /= currentPos.w; 
     189        const float currentDepth = currentPos.z * 1e-3f; 
    187190 
    188191        /////////// 
    189192        //-- compute color bleeding + ao 
    190193 
    191         GiStruct gi = globIllum(IN, colors, noiseTexture, samples, normal, eyeSpacePos, w, bl, br, tl, tr); 
     194        GiStruct gi = globIllum(IN, colors, noiseTexture, samples, normal, eyeSpacePos, w, bl, br, tl, tr, normalize(IN.view)); 
    192195         
    193196 
    … …  
    195198        //-- compute temporally smoothing 
    196199 
    197         float4 realPos = float4(centerPosition, 1.0f); 
    198  
    199  
    200         // calculcate the current projected depth for next frame 
    201         float4 currentPos = mul(modelViewProj, realPos); 
    202         currentPos /= currentPos.w; 
    203         const float currentDepth = currentPos.z; 
    204          
    205  
    206         /////////// 
    207         //-- reprojection new frame into old one  
    208          
     200         
     201        // reprojection new frame into old one  
    209202        // calculate projected depth 
    210203        float4 projPos = mul(oldModelViewProj, realPos); 
    … …  
    212205 
    213206        // the current depth projected into the old frame 
    214         const float projDepth = projPos.z; 
     207        const float projDepth = projPos.z * 1e-3f; 
    215208 
    216209        // fit from unit cube into 0 .. 1 
    217         float2 tex = (projPos.xy) * 0.5f + 0.5f; 
     210        float2 tex = projPos.xy * 0.5f + 0.5f; 
    218211 
    219212        // retrieve the sample from the last frame 
    … …  
    221214        float4 oldIllum = tex2D(oldIllumTex, tex); 
    222215 
    223         const float oldDepth = oldSsao.w; 
    224         const float depthDif = 1.0f - projDepth / oldDepth; 
    225  
    226         float oldWeight = clamp(oldSsao.z, 0, temporalCoherence); 
     216        const float oldDepth = oldSsao.z; 
     217        //const float depthDif = 1.0f - projDepth / oldDepth; 
     218        const float depthDif = projDepth - oldDepth; 
     219 
     220        float oldWeight = clamp(oldSsao.y, 0, temporalCoherence); 
    227221 
    228222        float newWeight; 
    229223 
    230224        //const float oldNumSamples = oldSsao.y; 
    231         //const float oldAvgDepth = oldSsao.z; 
    232  
     225         
    233226        if (//(temporalCoherence > 0.0f) && 
    234227                (tex.x >= 0.0f) && (tex.x < 1.0f) &&  
    … …  
    241234                newWeight = oldWeight + 1; 
    242235 
    243                 OUT.ssao_col.xy = (gi.ao + oldSsao.xy * oldWeight) / newWeight; 
     236                OUT.ssao_col.x = (gi.ao + oldSsao.x * oldWeight) / newWeight; 
    244237                OUT.illum_col.xyz  = (gi.illum + oldIllum.xyz * oldWeight) / newWeight; 
    245238        } 
    … …  
    248241                newWeight = 0; 
    249242 
    250                 OUT.ssao_col.xy = gi.ao.xy; 
     243                OUT.ssao_col.x = gi.ao.x; 
    251244                OUT.illum_col.xyz = gi.illum; 
    252245        } 
    253246 
    254         OUT.ssao_col.z = newWeight; 
    255         OUT.ssao_col.w = currentDepth; 
     247        OUT.ssao_col.y = newWeight; 
     248        OUT.ssao_col.z = currentDepth; 
    256249 
    257250        return OUT; 

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

    r3016 r3017  
    1717  float4 worldPos: TEXCOORD1; // world position 
    1818  float3 normal: TEXCOORD2; 
    19   float4 mypos: TEXCOORD3; 
     19  float4 projPos: TEXCOORD3; 
    2020}; 
    2121 
    … …  
    2828        float4 texCoord: TEXCOORD0;     
    2929 
    30         float4 projPos: WPOS; 
     30        float4 winPos: WPOS; 
    3131        float4 worldPos: TEXCOORD1; // world position 
    3232        float3 normal: TEXCOORD2; 
    33         float4 mypos: TEXCOORD3; 
     33        float4 projPos: TEXCOORD3; 
    3434}; 
    3535 
    … …  
    3838{ 
    3939        float4 col: COLOR0; 
    40         float4 norm: COLOR1; 
     40        float3 norm: COLOR1; 
    4141        float3 pos: COLOR2; 
    4242}; 
    … …  
    5959 
    6060        OUT.normal = IN.normal; 
    61         OUT.mypos = OUT.position; 
     61        OUT.projPos = OUT.position; 
    6262 
    6363        return OUT; 
    … …  
    7575} 
    7676 
     77//#pragma position_invariant fragtex 
    7778 
    7879pixel fragtex(fragin IN,  
    … …  
    9697        // hack: use combination of emmisive + diffuse (emmisive used as constant ambient term) 
    9798        pix.col = (glstate.material.emission + glstate.material.diffuse) * texColor;  
    98         // save world space normal in third rt 
    99         pix.norm.xyz = IN.normal; 
    100         // store projection coordinates with positions (used for ssao) 
    101         pix.norm.w = IN.projPos.w; 
     99        // save world space normal in rt 
     100        pix.norm = IN.normal; 
    102101 
    103         const float4 projPos = IN.mypos / IN.mypos.w; 
    104          
    105102        // hack: squeeze some information about ambient into the texture 
    106103        //pix.col.w = glstate.material.emission.x; 
    107104 
    108105        // compute eye linear depth 
    109         const float2 screenCoord = projPos.xy * 0.5f + 0.5f; 
    110         const float magView = length(Interpol(screenCoord, bl, br, tl, tr)); 
    111         pix.col.w = length(eyePos - IN.worldPos.xyz) / magView; 
    112  
    113 #if 0 
    114         // save world position in second render target 
    115         pix.pos = IN.worldPos.xyz * maxDepth; 
    116 #endif 
     106        const float4 projPos = IN.projPos / IN.projPos.w; 
     107         
     108        float2 screenCoord = projPos.xy * 0.5f + 0.5f; 
     109         
     110        const float3 viewVec = Interpol(screenCoord, bl, br, tl, tr); 
     111        const float invMagView = 1.0f / length(viewVec); 
     112        // note: has to done in this order, otherwise strange precision problems! 
     113        pix.col.w = invMagView * length(eyePos - IN.worldPos.xyz); 
    117114 
    118115        return pix; 
    … …  
    132129        pix.col = glstate.material.diffuse + glstate.material.emission; 
    133130 
    134         pix.norm.xyz = IN.normal; 
    135          
    136         // store projection coordinates with positions (used for ssao) 
    137         pix.norm.w = IN.mypos.w; 
    138  
    139         const float4 projPos = IN.mypos / IN.mypos.w; 
     131        pix.norm = IN.normal; 
    140132 
    141133        // hack: squeeze some information about the ambient term into the target 
    … …  
    143135         
    144136        // compute eye linear depth and scale with lenght to avoid sqr root in pixel shader 
     137        const float4 projPos = IN.projPos / IN.projPos.w; 
     138         
    145139        float2 screenCoord = projPos.xy * 0.5f + 0.5f; 
    146140        const float magView = length(Interpol(screenCoord, bl, br, tl, tr)); 
    147         pix.col.w = length(eyePos - IN.worldPos.xyz)  / magView; 
    148  
    149 #if 0 
    150         pix.pos = IN.worldPos.xyz * maxDepth; 
    151 #endif 
     141        pix.col.w = length(eyePos - IN.worldPos.xyz) / magView; 
    152142 
    153143        return pix; 

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

    r3016 r3017  
    1111struct fragment 
    1212{ 
    13          // normalized screen position 
    14         float4 pos: WPOS; 
    1513        float2 texCoord: TEXCOORD0;  
    1614        float3 view: TEXCOORD1; 
    … …  
    4644 
    4745// reconstruct world space position 
    48 inline float3 ReconstructSamplePosition( 
    49                                                                                 uniform sampler2D colors, 
    50                                                                                 float2 texcoord,  
    51                                                                                 float3 bl, float3 br, float3 tl, float3 tr) 
    52 { 
    53 #if USE_EYE_SPACE_DEPTH 
    54         float eyeSpaceDepth = tex2Dlod(colors, float4(texcoord, 0, 0)).w; 
    55         //float3 rotView = normalize(Interpol(texcoord, bl, br, tl, tr)); 
    56         float3 rotView = Interpol(texcoord, bl, br, tl, tr); 
    57          
    58         float3 samplePos = -rotView * eyeSpaceDepth; 
    59 #else 
    60         float3 samplePos = tex2Dlod(colors, float4(texcoord, 0, SSAO_MIPMAP_LEVEL)).xyz; 
    61 #endif 
     46inline float3 ReconstructSamplePos(uniform sampler2D colors, 
     47                                                                   float2 texcoord,  
     48                                                                   float3 bl, float3 br, float3 tl, float3 tr) 
     49{ 
     50        const float eyeSpaceDepth = tex2Dlod(colors, float4(texcoord, 0, 0)).w; 
     51        float3 viewVec = Interpol(texcoord, bl, br, tl, tr); 
     52        float3 samplePos = -viewVec * eyeSpaceDepth; 
     53 
    6254        return samplePos; 
    6355} 
    … …  
    7668                   uniform float3 br, 
    7769                   uniform float3 tl, 
    78                    uniform float3 tr 
    79                    //, uniform float3 viewDir 
     70                   uniform float3 tr,  
     71                   uniform float3 viewDir 
    8072                   ) 
    8173{ 
    … …  
    9688                // add random noise: reflect around random normal vector (warning: slow!) 
    9789 
    98                 float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy).xy; 
     90                float2 mynoise = tex2D(noiseTexture, IN.texCoord).xy; 
    9991                const float2 offsetTransformed = myreflect(offset, mynoise); 
    10092#else 
    … …  
    10294#endif 
    10395                // weight with projected coordinate to reach similar kernel size for near and far 
    104                 float2 texcoord = IN.texCoord.xy + offsetTransformed * AREA_SIZE * scaleFactor; 
     96                float2 texcoord = IN.texCoord.xy + offsetTransformed * scaleFactor; 
    10597 
    10698                //if ((texcoord.x <= 1.0f) && (texcoord.x >= 0.0f) && (texcoord.y <= 1.0f) && (texcoord.y >= 0.0f))++ numSamples; 
    10799 
    108                 float3 samplePos = ReconstructSamplePosition(colors, texcoord, bl, br, tl, tr); 
    109  
    110  
    111                 /////// 
    112                 //-- compute contribution of current sample taking into account direction and angle 
    113  
    114                 float3 dirSample = samplePos - centerPosition.xyz; 
     100                const float3 samplePos = ReconstructSamplePos(colors, texcoord, bl, br, tl, tr); 
     101 
     102 
     103                //////////////// 
     104                //-- compute contribution of sample using the direction and angle 
     105 
     106                float3 dirSample = samplePos - centerPosition; 
    115107                const float lengthSample = length(dirSample); 
    116108 
    … …  
    118110 
    119111                // angle between current normal and direction to sample controls AO intensity. 
    120                 const float cos_angle = max(dot(nDirSample, currentNormal), 0.0f); 
     112                const float cosAngle = max(dot(nDirSample, currentNormal), 0.0f); 
    121113 
    122114                // the distance_scale offset is used to avoid singularity that occurs at global illumination when  
    123115                // the distance to a sample approaches zero 
    124                 const float intensity =  
    125                         //(SAMPLE_INTENSITY * DISTANCE_SCALE) / (DISTANCE_SCALE + lengthSample * lengthSample); 
    126                         SAMPLE_INTENSITY / (DISTANCE_SCALE + lengthSample * lengthSample); 
    127  
    128 #if 0 
     116                const float intensity = SAMPLE_INTENSITY / (DISTANCE_SCALE + lengthSample * lengthSample); 
     117 
     118#if 1 
    129119                // if surface normal perpenticular to view dir, approx. half of the samples will not count 
    130120                // => compensate for this (on the other hand, projected sampling area could be larger!) 
    131                 const float viewCorrection = 1.0f + VIEW_CORRECTION_SCALE * (1.0f - dot(currentViewDir, currentNormal)); 
    132                 total_ao += cos_angle * intensity * viewCorrection; 
     121                const float viewCorrection = 1.0f + VIEW_CORRECTION_SCALE * dot(viewDir, currentNormal); 
     122                total_ao += cosAngle * intensity * viewCorrection; 
     123#else 
     124                total_ao += cosAngle * intensity; 
    133125#endif 
    134                 total_ao += cos_angle * intensity; 
    135126        } 
    136127 
    … …  
    138129} 
    139130 
     131#pragma position_invariant main 
    140132 
    141133/** The mrt shader for screen space ambient occlusion 
    … …  
    143135pixel main(fragment IN,  
    144136                   uniform sampler2D colors, 
    145                    uniform sampler2D positions, 
    146137                   uniform sampler2D normals, 
    147138                   uniform sampler2D noiseTexture, 
    … …  
    161152 
    162153        float4 norm = tex2Dlod(normals, float4(IN.texCoord, 0 ,0)); 
    163         float3 normal = normalize(norm.xyz); 
    164  
    165         // the w coordinate from the persp. projection 
    166         float w = norm.w; 
    167  
    168  
    169 #if USE_EYE_SPACE_DEPTH 
     154        const float3 normal = normalize(norm.xyz); 
     155 
    170156        /// reconstruct position from the eye space depth 
    171157        float3 viewDir = IN.view; 
    172158        const float eyeDepth = tex2Dlod(colors, float4(IN.texCoord, 0, 0)).w; 
    173  
    174159        const float3 eyeSpacePos = -viewDir * eyeDepth; 
    175  
    176         float3 centerPosition; 
    177         centerPosition.xyz = eyePos + eyeSpacePos; 
    178  
    179         const float2 ao = ssao(IN, colors, noiseTexture, samples, normal, eyeSpacePos, w, bl, br, tl, tr); 
    180  
    181 #else 
    182  
    183         // the current world position 
    184         const float3 centerPosition = tex2Dlod(positions, float4(IN.texCoord, 0, 0)).xyz; 
    185  
    186         const float2 ao = ssao(IN, positions, noiseTexture, samples, normal, centerPosition, w, bl, br, tl, tr); 
    187  
    188 #endif 
     160        const float3 centerPosition = eyePos + eyeSpacePos; 
     161 
     162        float4 realPos = float4(centerPosition, 1.0f); 
     163 
     164 
     165        //////////////// 
     166        //-- calculcate the current projected depth for next frame 
     167         
     168        float4 currentPos = mul(modelViewProj, realPos); 
     169         
     170        const float w = SAMPLE_RADIUS / currentPos.w; 
     171        currentPos /= currentPos.w; 
     172         
     173        const float currentDepth = currentPos.z * 1e-3f; 
     174 
     175        const float2 ao = ssao(IN, colors, noiseTexture, samples, normal, eyeSpacePos, w, bl, br, tl, tr, normalize(viewDir)); 
     176 
    189177 
    190178        ///////////////// 
    191179        //-- compute temporally smoothing 
    192180 
    193         float4 realPos = float4(centerPosition, 1.0f); 
    194  
    195  
    196         // calculcate the current projected depth for next frame 
    197         float4 currentPos = mul(modelViewProj, realPos); 
    198         currentPos /= currentPos.w; 
    199         const float currentDepth = currentPos.z; 
    200          
    201  
    202         /////////// 
    203         //-- reprojection new frame into old one  
     181 
     182        // reproject new frame into old one  
    204183         
    205184        // calculate projected depth 
    … …  
    208187 
    209188        // the current depth projected into the old frame 
    210         const float projDepth = projPos.z; 
     189        const float projDepth = projPos.z * 1e-3f; 
    211190 
    212191        // fit from unit cube into 0 .. 1 
    213         float2 tex = (projPos.xy) * 0.5f + 0.5f; 
     192        const float2 tex = projPos.xy * 0.5f + 0.5f; 
    214193 
    215194        // retrieve the sample from the last frame 
    216195        float4 oldCol = tex2D(oldTex, tex); 
    217196 
    218         const float oldDepth = oldCol.w; 
    219         const float depthDif = 1.0f - projDepth / oldDepth; 
     197        const float oldDepth = oldCol.z; 
     198        //const float depthDif = 1.0f - projDepth / oldDepth; 
     199        const float depthDif = projDepth - oldDepth; 
    220200 
    221201 
    222202        //const float oldNumSamples = oldCol.y; 
    223         const float oldWeight = clamp(oldCol.z, 0, temporalCoherence); 
     203        const float oldWeight = clamp(oldCol.y, 0, temporalCoherence); 
    224204 
    225205        float newWeight; 
    … …  
    227207        // the number of valid samples in this frame 
    228208        //const float newNumSamples = ao.y; 
    229  
    230209 
    231210        if (//(temporalCoherence > 0) && 
    … …  
    239218                // increase the weight for convergence 
    240219                newWeight = oldWeight + 1.0f; 
    241                 OUT.illum_col.xy = (ao.xy + oldCol.xy * oldWeight) / newWeight; 
     220                OUT.illum_col.x = (ao.x + oldCol.x * oldWeight) / newWeight; 
    242221                //if (!(oldNumSamples > ao.y - 1.5f)) newWeight = 0; 
    243222        } 
    244223        else 
    245224        {        
    246                 OUT.illum_col.xy = ao.xy; 
     225                OUT.illum_col.x = ao.x; 
    247226                newWeight = 0; 
    248227        } 
    249228 
    250         OUT.illum_col.z = newWeight; 
    251         OUT.illum_col.w = currentDepth; 
     229        //OUT.illum_col.y=depthDif; 
     230        OUT.illum_col.y = newWeight; 
     231        OUT.illum_col.z = currentDepth; 
    252232 
    253233        return OUT; 
     234} 
     235 
     236 
     237float Filter(float2 texCoord,  
     238                         uniform sampler2D ssaoTex, 
     239                         uniform float2 filterOffs[NUM_DOWNSAMPLES], 
     240                         uniform float filterWeights[NUM_DOWNSAMPLES] 
     241) 
     242{ 
     243        float average = .0f; 
     244        float w = .0f; 
     245 
     246        for (int i = 0; i < NUM_DOWNSAMPLES; ++ i) 
     247        { 
     248                average += filterWeights[i] * tex2Dlod(ssaoTex, float4(texCoord + filterOffs[i], 0, 0)).x; 
     249                w += filterWeights[i]; 
     250        } 
     251 
     252        average *= 1.0f / (float)w; 
     253 
     254        return average; 
    254255} 
    255256 
    … …  
    257258pixel combine(fragment IN,  
    258259                          uniform sampler2D colors, 
    259                           uniform sampler2D ssaoTex) 
     260                          uniform sampler2D ssaoTex, 
     261                          uniform float2 filterOffs[NUM_DOWNSAMPLES], 
     262                          uniform float filterWeights[NUM_DOWNSAMPLES] 
     263                          ) 
    260264{ 
    261265        pixel OUT; 
    262266 
    263267        float4 col = tex2Dlod(colors, float4(IN.texCoord, 0, 0)); 
    264         float4 ao = tex2Dlod(ssaoTex, float4(IN.texCoord, 0, 0)); 
     268        float3 ao = tex2Dlod(ssaoTex, float4(IN.texCoord, 0, 0)); 
     269 
     270        if (ao.y < 2000.0f) 
     271                ao.x = Filter(IN.texCoord, ssaoTex, filterOffs, filterWeights); 
    265272 
    266273        OUT.illum_col = col * ao.x; 
    267         //OUT.illum_col = float4(ao.x,ao.x,ao.x, ao.w); 
     274        //OUT.illum_col.xyz = float3(ao.x,1-ao.y*1e-2f, 0); 
    268275        OUT.illum_col.w = col.w; 
    269276 

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

    r3010 r3017  
    6464 
    6565                float3 mynoise = (float3)tex2D(noiseTexture, IN.texCoord.xy); 
    66                 const float3 offsetTransformed = myreflect(offset, mynoise) * AREA_SIZE; 
    67                 //const float3 offsetTransformed = offset * AREA_SIZE; 
     66                const float3 offsetTransformed = myreflect(offset, mynoise) * SAMPLE_RADIUS; 
     67                //const float3 offsetTransformed = offset * SAMPLE_RADIUS; 
    6868 
    6969                // compute position 

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

    r3016 r3017  
    4646    return average; 
    4747}*/ 
    48    
     48  
     49 
     50// let bilinear filtering do its work 
    4951float4 DownSample(frag IN, 
    5052                                  uniform sampler2D colors, 
Note: See TracChangeset for help on using the changeset viewer.