Changeset 2903


Ignore:
Timestamp:
09/04/08 15:00:42 (16 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/App/Demos/Vis/FriendlyCulling/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r2901 r2903  
    4747static CGparameter sOldTexParam; 
    4848static CGparameter sNoiseTexParam; 
    49 static CGparameter sNoiseMultiplierParam; 
    5049static CGparameter sTemporalCoherenceParam; 
    5150 
    … …  
    6564static CGparameter sOldIllumTexGiParam; 
    6665static CGparameter sNoiseTexGiParam; 
    67 static CGparameter sNoiseMultiplierGiParam; 
    6866static CGparameter sTemporalCoherenceGiParam; 
    6967 
    … …  
    9290static CGparameter sSampleWidthParam; 
    9391 
     92//#define USE_3D_SSAO 
    9493 
    9594 
    … …  
    9796 
    9897// ssao random spherical samples 
     98#ifdef USE_3D_SSAO 
     99 
     100static Sample2 samples3[NUM_SAMPLES]; 
     101 
     102#else 
     103 
    99104static Sample2 samples2[NUM_SAMPLES]; 
    100 static Sample2 samples3[NUM_SAMPLES]; 
     105 
     106#endif 
    101107 
    102108static int colorBufferIdx = 0; 
    … …  
    119125static void GenerateSamples(int sampling) 
    120126{ 
    121         SphericalSampleGenerator gauss(NUM_SAMPLES, 1.0f); 
    122         gauss.Generate((float *)samples3); 
    123          
    124         /* 
     127#ifdef USE_3D_SSAO 
     128 
     129        SphericalSampleGenerator sph(NUM_SAMPLES, 1.0f); 
     130        sph.Generate((float *)samples3); 
     131 
     132#else 
    125133        switch (sampling) 
    126134        { 
    127135        case DeferredRenderer::POISSON: 
    128136                { 
    129                         static PoissonDiscSampleGenerator poisson(NUM_SAMPLES, 1.0f); 
     137                        PoissonDiscSampleGenerator poisson(NUM_SAMPLES, 1.0f); 
    130138                        poisson.Generate((float *)samples2); 
    131139                } 
    … …  
    133141        case DeferredRenderer::GAUSS: 
    134142                { 
    135                         //static GaussianSampleGenerator gauss(NUM_SAMPLES, 0.5f); 
    136                         //gauss.Generate((float *)samples2); 
    137  
    138                         static SphericalSampleGenerator gauss(NUM_SAMPLES, 0.5f); 
    139                         gauss.Generate((float *)samples3); 
     143                        //PoissonDiscSampleGenerator poisson(NUM_SAMPLES, 1.0f); 
     144                        //poisson.Generate((float *)samples2); 
     145 
     146                        PseudoRandomGenerator pseudo(NUM_SAMPLES, 1.0f); 
     147                        pseudo.Generate((float *)samples2); 
    140148                } 
    141149                break; 
    142150        default: 
     151                cout << "should not come here" << endl; 
    143152                break; 
    144         }*/ 
     153        } 
     154#endif 
    145155} 
    146156 
    … …  
    151161        float *randomNormals = new float[w * h * 3]; 
    152162 
    153         //SphericalSampleGenerator gauss(w * h, 1.0f); 
    154         //gauss.Generate(randomNormals); 
    155  
    156163        static HaltonSequence halton; 
    157164        float r[2]; 
    … …  
    159166        for (int i = 0; i < w * h * 3; i += 3) 
    160167        { 
    161                 // create random samples on a circle 
    162                 halton.GetNext(2, r); 
    163  
    164168                 
    165                 //const float theta = 2.0f * acos(sqrt(1.0f - rx)); 
    166                 //randomNormals[i + 0] = cos(theta); 
    167                 //randomNormals[i + 1] = sin(theta); 
    168                 //randomNormals[i + 2] = 0; 
     169#ifdef USE_3D_SSAO 
     170                //halton.GetNext(2, r); 
     171                r[0] = RandomValue(0, 1); 
     172                r[1] = RandomValue(0, 1); 
    169173 
    170174                const float theta = 2.0f * acos(sqrt(1.0f - r[0])); 
    … …  
    174178                randomNormals[i + 1] = sin(theta) * sin(phi); 
    175179                randomNormals[i + 2] = cos(theta); 
     180#else 
     181                // create random samples on a circle 
     182                r[0] = RandomValue(0, 1); 
     183                //halton.GetNext(1, r); 
     184 
     185                const float theta = 2.0f * acos(sqrt(1.0f - r[0])); 
     186                 
     187                randomNormals[i + 0] = cos(theta); 
     188                randomNormals[i + 1] = sin(theta); 
     189                randomNormals[i + 2] = 0; 
     190#endif 
    176191        } 
    177192 
    … …  
    274289                cgCreateProgramFromFile(context,  
    275290                                                                CG_SOURCE, 
    276                                                                 //"src/shaders/ssao.cg",  
     291#ifdef USE_3D_SSAO 
    277292                                                                "src/shaders/ssao3d.cg",  
     293 
     294#else 
     295                                                                "src/shaders/ssao.cg",  
     296#endif 
    278297                                                                RenderState::sCgFragmentProfile, 
    279298                                                                "main", 
    … …  
    288307                sNormalsTexParam = cgGetNamedParameter(sCgSsaoProgram, "normals");   
    289308                sNoiseTexParam = cgGetNamedParameter(sCgSsaoProgram, "noiseTexture"); 
    290                 sNoiseMultiplierParam = cgGetNamedParameter(sCgSsaoProgram, "noiseMultiplier"); 
    291309                 
    292310                sOldModelViewProjMatrixParam = cgGetNamedParameter(sCgSsaoProgram, "oldModelViewProj"); 
    … …  
    297315                sOldTexParam = cgGetNamedParameter(sCgSsaoProgram, "oldTex");   
    298316                 
    299                 cgGLSetParameter1f(sNoiseMultiplierParam, RandomValue(1.0f, 3.0f)); 
    300317                sSamplesParam = cgGetNamedParameter(sCgSsaoProgram, "samples"); 
    301318        } 
    … …  
    320337                sNormalsTexGiParam = cgGetNamedParameter(sCgGiProgram, "normals");   
    321338                sNoiseTexGiParam = cgGetNamedParameter(sCgGiProgram, "noiseTexture"); 
    322                 sNoiseMultiplierGiParam = cgGetNamedParameter(sCgGiProgram, "noiseMultiplier"); 
    323339                 
    324340                sOldModelViewProjMatrixGiParam = cgGetNamedParameter(sCgGiProgram, "oldModelViewProj"); 
    … …  
    330346                sOldSsaoTexGiParam = cgGetNamedParameter(sCgGiProgram, "oldSsaoTex");   
    331347                sOldIllumTexGiParam = cgGetNamedParameter(sCgGiProgram, "oldIllumTex");   
    332  
    333                 cgGLSetParameter1f(sNoiseMultiplierGiParam, RandomValue(1.0f, 3.0f)); 
    334348        } 
    335349        else 
    … …  
    500514                                                                   ) 
    501515{ 
     516#ifdef USE_3D_SSAO 
    502517        static Matrix4x4 biasMatrix(0.5f, 0.0f, 0.0f, 0.5f, 
    503518                                                                0.0f, 0.5f, 0.0f, 0.5f, 
    … …  
    507522        Matrix4x4 m = projViewMatrix * biasMatrix;  
    508523 
     524        cgGLSetMatrixParameterfc(sModelViewProjMatrixParam, (const float *)m.x); 
     525#endif 
     526 
    509527        cgGLSetMatrixParameterfc(sOldModelViewProjMatrixParam, (const float *)oldProjViewMatrix.x); 
    510         cgGLSetMatrixParameterfc(sModelViewProjMatrixParam, (const float *)m.x); 
    511528 
    512529        GLuint colorsTex = fbo->GetColorBuffer(3)->GetTexture(); 
    … …  
    558575        { 
    559576                mRegenerateSamples = false; 
    560                 cgGLSetParameter1f(sNoiseMultiplierParam, RandomValue(3.0f, 17.0f)); 
    561577 
    562578                // q: should we generate new samples or only rotate the old ones? 
    … …  
    565581                GenerateSamples(mSamplingMethod);  
    566582 
    567                 //cgGLSetParameterArray2f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples2); 
     583#ifdef USE_3D_SSAO 
    568584                cgGLSetParameterArray3f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples3); 
     585#else 
     586                cgGLSetParameterArray2f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples2); 
     587#endif 
    569588        } 
    570589 
    … …  
    779798        { 
    780799                mRegenerateSamples = false; 
    781                 cgGLSetParameter1f(sNoiseMultiplierGiParam, RandomValue(3.0f, 17.0f)); 
    782800 
    783801                // q: should we generate new samples or only rotate the old ones? 
    … …  
    785803                // needs longer to converge 
    786804                GenerateSamples(mSamplingMethod);  
     805 
     806#ifdef USE_3D_SSAO 
     807                cgGLSetParameterArray3f(sSamplesGiParam, 0, NUM_SAMPLES, (const float *)samples3); 
     808#else 
    787809                cgGLSetParameterArray2f(sSamplesGiParam, 0, NUM_SAMPLES, (const float *)samples2); 
     810#endif 
    788811        } 
    789812 

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

    r2902 r2903  
     1#include "SampleGenerator.h" 
    12#include "common.h" 
    2 #include "SampleGenerator.h" 
    33 
    44 
    55using namespace std; 
     6using namespace CHCDemoEngine; 
    67 
    78HaltonSequence SphericalSampleGenerator::sHalton; 
    89HaltonSequence PoissonDiscSampleGenerator::sHalton; 
    9 HaltonSequence GaussianSampleGenerator::sHalton; 
    1010HaltonSequence PseudoRandomGenerator::sHalton; 
    1111 
    … …  
    3232        const float f_reduction = 0.9f; 
    3333 
    34         static HaltonSequence halton; 
     34        //static HaltonSequence halton; 
    3535        float r[2]; 
    3636 
    3737        // generates poisson distribution on disc 
    38         float minDist = 2.0f / sqrt((float)mNumSamples); 
     38        float minDist = 2.0f * mRadius / sqrt((float)mNumSamples); 
    3939 
    4040        //cout << "minDist before= " << minDist << endl; 
    … …  
    5151                        ++ totalTries; 
    5252 
    53                         halton.GetNext(2, r); 
     53                        r[0] = RandomValue(0, mRadius); 
     54                        r[1] = RandomValue(0, mRadius); 
     55                        //halton.GetNext(2, r); 
    5456 
    5557                        const float rx = r[0] * 2.0f - 1.0f; 
    … …  
    5759 
    5860                        // check if in disk, else exit early 
    59                         if (rx * rx + ry * ry > 1) 
     61                        if (rx * rx + ry * ry > mRadius * mRadius) 
    6062                                continue; 
    6163 
    … …  
    8688                        } 
    8789                } 
    88                  
    89                 //cout << "sample: " << samples[i].x << " " << i << " " << samples[i].y << " r: " << sqrt(samples[i].x * samples[i].x  + samples[i].y * samples[i].y) << " tries: " << totalTries << endl; 
    90         } 
    91  
    92         //cout << "minDist after= " << minDist << endl; 
    93 } 
    94  
    95  
    96  
    97 GaussianSampleGenerator::GaussianSampleGenerator(int numSamples, float radius): 
    98 SampleGenerator(numSamples, radius) 
    99 {} 
    100  
    101  
    102 void GaussianSampleGenerator::Generate(float *samples) const 
    103 { 
    104         float r[2]; 
    105  
    106         const float sigma = mRadius; 
    107  
    108         Sample2 *s = (Sample2 *)samples; 
    109  
    110         const float p0 = 1.0f / (sigma * sqrt(2.0f * M_PI)); 
    111         const float p1 = 1.0f / (sigma * sqrt(2.0f * M_PI)); 
    112  
    113         for (int i = 0; i < mNumSamples; ++ i) 
    114         { 
    115                 sHalton.GetNext(2, r); 
    116  
    117                 float exp_x = -(r[0] * r[0]) / (2.0f * sigma * sigma); 
    118                 float exp_y = -(r[1] * r[1]) / (2.0f * sigma * sigma); 
    119  
    120                 s[i].x = p0 * pow(M_E, exp_x); 
    121                 s[i].y = p1 * pow(M_E, exp_y); 
    12290        } 
    12391 
    … …  
    133101void PseudoRandomGenerator::Generate(float *samples) const 
    134102{ 
    135         sHalton.GetNext(2 * mNumSamples, samples); 
     103        Sample2 *s = (Sample2 *)samples; 
     104 
     105        int numSamples = 0; 
     106 
     107        while (numSamples < mNumSamples) 
     108        { 
     109                const float rx = RandomValue(-mRadius, +mRadius); 
     110                const float ry = RandomValue(-mRadius, +mRadius); 
     111 
     112                // check if in disk, else exit early 
     113                if (rx * rx + ry * ry > mRadius * mRadius) 
     114                        continue; 
     115 
     116                s[numSamples].x = rx; 
     117                s[numSamples].y = ry; 
     118 
     119                ++ numSamples; 
     120        } 
    136121} 
    137122 
    … …  
    146131        float r[2]; 
    147132        Sample3 *s = (Sample3 *)samples; 
    148 /*       
    149         // idea: use poisson distribution to generate samples 
    150133 
    151         PoissonDiscSampleGenerator poisson(mNumSamples, 1.0f); 
    152         Sample2 *pSamples = new Sample2[mNumSamples]; 
    153         poisson.Generate((float *)pSamples); 
    154 */ 
    155134        for (int i = 0; i < mNumSamples; ++ i) 
    156135        { 
    157                 sHalton.GetNext(2, r); 
     136                r[0] = RandomValue(0, 1); 
     137                r[1] = RandomValue(0, 1); 
     138                //sHalton.GetNext(2, r); 
    158139                //r[0] = pSamples[i].x; r[1] = pSamples[i].y; 
    159140 

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

    r2902 r2903  
    7575 
    7676 
    77 class GaussianSampleGenerator: public SampleGenerator 
    78 { 
    79 public: 
    80          
    81         GaussianSampleGenerator(int numSamples, float radius); 
    82  
    83         virtual void Generate(float *samples) const; 
    84  
    85 protected: 
    86  
    87         static HaltonSequence sHalton; 
    88 }; 
    89  
    90  
    9177class SphericalSampleGenerator: public SampleGenerator 
    9278{ 

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

    r2901 r2903  
    153153 
    154154bool useGlobIllum = false; 
    155 bool useSsao = false; 
    156155bool useTemporalCoherence = true; 
    157156 
    … …  
    173172 
    174173DeferredRenderer::SAMPLING_METHOD samplingMethod = DeferredRenderer::POISSON; 
    175 DeferredRenderer::SHADING_METHOD shadingMethod = DeferredRenderer::DEFAULT; 
     174 
     175bool useAdvancedShading = false; 
    176176 
    177177bool showShadowMap = false; 
    … …  
    10271027                if (!ssaoShader) ssaoShader = new DeferredRenderer(texWidth, texHeight, camera, myfar / 10.0f); 
    10281028                 
     1029                DeferredRenderer::SHADING_METHOD shadingMethod; 
     1030 
     1031                if (useAdvancedShading) 
     1032                { 
     1033                        if (useGlobIllum) 
     1034                                shadingMethod = DeferredRenderer::GI; 
     1035                        else 
     1036                                shadingMethod = DeferredRenderer::SSAO; 
     1037                } 
     1038                else 
     1039                        shadingMethod = DeferredRenderer::DEFAULT; 
     1040 
     1041 
    10291042                ssaoShader->SetShadingMethod(shadingMethod); 
    10301043                ssaoShader->SetSamplingMethod(samplingMethod); 
    … …  
    11581171                else 
    11591172                        samplingMethod = DeferredRenderer::GAUSS; 
    1160  
    11611173                break; 
    11621174        case 'Y': 
    … …  
    11651177                break; 
    11661178        case 'g': 
     1179        case 'G': 
     1180                useGlobIllum = !useGlobIllum; 
     1181                break; 
    11671182        case 't': 
    11681183        case 'T': 
    … …  
    13001315                break; 
    13011316        case GLUT_KEY_F8: 
    1302                 //shadingMethod = (DeferredRenderer::SHADING_METHOD)((shadingMethod + 1) % 3); 
    1303                 shadingMethod = (DeferredRenderer::SHADING_METHOD)((shadingMethod + 1) % 2); 
    1304                  
     1317 
     1318                useAdvancedShading = !useAdvancedShading; 
     1319                //shadingMethod = (DeferredRenderer::SHADING_METHOD)((shadingMethod + 1) % 2); 
     1320 
    13051321                break; 
    13061322        case GLUT_KEY_F9: 
    … …  
    17351751                                                        useMultiQueries, useTightBounds, useRenderQueue); 
    17361752 
    1737                         sprintf(msg[i ++], "render technique: %s, SSAO: %d", renderTypeStr[renderType], useSsao); 
     1753                        sprintf(msg[i ++], "render technique: %s, SSAO: %d", renderTypeStr[renderType], useAdvancedShading); 
    17381754 
    17391755                        sprintf(msg[i ++], "triangles per virtual leaf: %5d", trianglesPerVirtualLeaf); 

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

    r2898 r2903  
    254254 
    255255 
    256 /*inline int 
    257 RandomValue(int a, int b) 
    258 { 
    259         int range = abs(a - b); 
    260         return (rand() * range) / RAND_MAX + ((a < b) ? a : b); 
    261 }*/ 
    262  
    263256inline Real sqr(Real a) 
    264257{ 

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

    r2901 r2903  
    1111 
    1212// for quadradtc falloff 
    13 //#define SAMPLE_INTENSITY 0.28f 
     13#define SAMPLE_INTENSITY 0.28f 
    1414//#define SAMPLE_INTENSITY 0.32f 
    15 #define SAMPLE_INTENSITY 2.4f 
     15//#define SAMPLE_INTENSITY 2.4f 
    1616 
    1717//#define AREA_SIZE 25e-1f 

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

    r2897 r2903  
    4646                                 uniform float3 currentNormal, 
    4747                                 uniform float3 currentViewDir, 
    48                                  uniform float noiseMultiplier, 
    4948                                 uniform float4 centerPosition 
    5049                                 ) 
    … …  
    6766        { 
    6867                float2 offset = samples[i]; 
    69                 //float3 offset = float3(samples[i], 0); 
    70  
    71                 //sample noisetex; r stores costheta, g stores sintheta 
    72                 float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy * noiseMultiplier).xy; 
    73                 //float3 mynoise = float3(tex2D(noiseTexture, IN.texCoord.xy * noiseMultiplier).xy, 0); 
    74  
    75                 // reflect sampling using the noise texture 
     68 
     69#if 1 
     70                //////////////////// 
     71                // add random noise: reflect around random normal vector (warning: slow!) 
     72                float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy).xy; 
    7673                float2 offsetTransformed = myreflect(offset, mynoise); 
    77  
     74#else 
     75                float2 offsetTransformed = offset; 
     76#endif 
    7877                // weight with projected coordinate to reach similar kernel size for near and far 
    7978                float2 texcoord = IN.texCoord.xy + offsetTransformed * AREA_SIZE * w; 
    … …  
    9695 
    9796                // if normal perpenticular to view dir, only half of the samples count 
    98                 //const float view_correction = 1.0f + VIEW_CORRECTION_SCALE * (1.0f - dot(currentViewDir, currentNormal)); 
    99                 //total_color.w -= cos_angle * distance_intensity * view_correction; 
    100                 //total_color.xyz += cos_angle * distance_intensity * view_correction * sample_color * ILLUM_INTENSITY; 
    101  
     97                /* 
     98                const float view_correction = 1.0f + VIEW_CORRECTION_SCALE * (1.0f - dot(currentViewDir, currentNormal)); 
     99                total_color.w -= cos_angle * distance_intensity * view_correction; 
     100                total_color.xyz += cos_angle * distance_intensity * view_correction * sample_color * ILLUM_INTENSITY; 
     101                */ 
    102102                total_color.w -= cos_angle * distance_intensity; 
    103103                total_color.xyz += cos_angle * distance_intensity * sample_color * ILLUM_INTENSITY; 
    … …  
    116116                   uniform sampler2D noiseTexture, 
    117117                   uniform float2 samples[NUM_SAMPLES], 
    118                    uniform float noiseMultiplier, 
    119118                   uniform sampler2D oldSsaoTex, 
    120119                   uniform sampler2D oldIllumTex, 
    … …  
    146145 
    147146        float4 new_color = globIllum(IN, colors, positions, noiseTexture,  
    148                                  samples, normal, viewDir, noiseMultiplier, centerPosition); 
     147                                 samples, normal, viewDir, centerPosition); 
    149148         
    150149 

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

    r2898 r2903  
    4141                   uniform float3 currentNormal, 
    4242                   uniform float3 currentViewDir, 
    43                    uniform float noiseMultiplier, 
    4443                   uniform float4 centerPosition 
    4544                   ) 
    … …  
    5756        { 
    5857                const float2 offset = samples[i]; 
    59                 //const float3 offset = float3(samples[i], 0); 
    6058 
     59#if 1 
    6160                //////////////////// 
    62                 // add random noise: r stores costheta, g stores sintheta 
    63  
    64                 //const float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy * noiseMultiplier).xy * 2.0f - 1.0f; 
    65                 float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy * noiseMultiplier).xy; 
    66                 //float3 mynoise = float3(tex2D(noiseTexture, IN.texCoord.xy * noiseMultiplier).xy,0); 
    67  
     61                // add random noise: reflect around random normal vector (warning: slow!) 
     62                float2 mynoise = tex2D(noiseTexture, IN.texCoord.xy).xy; 
    6863                const float2 offsetTransformed = myreflect(offset, mynoise); 
    69  
     64#else 
     65                const float2 offsetTransformed = offset; 
     66#endif 
    7067                // weight with projected coordinate to reach similar kernel size for near and far 
    7168                float2 texcoord = IN.texCoord.xy + offsetTransformed * AREA_SIZE * w; 
    … …  
    110107                   uniform sampler2D noiseTexture, 
    111108                   uniform float2 samples[NUM_SAMPLES], 
    112                    uniform float noiseMultiplier, 
    113109                   uniform sampler2D oldTex, 
    114110                   const uniform float4x4 oldModelViewProj, 
    … …  
    137133        const float currentDepth = currentCol.w; 
    138134 
    139         const float ao = ssao(IN, positions, noiseTexture, samples, normal, viewDir, noiseMultiplier, centerPosition); 
     135        const float ao = ssao(IN, positions, noiseTexture, samples, normal, viewDir, centerPosition); 
    140136                 
    141137 

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

    r2902 r2903  
    4040                   uniform float3 currentNormal, 
    4141                   uniform float3 currentViewDir, 
    42                    uniform float noiseMultiplier, 
    4342                   uniform float4 centerPosition, 
    4443                   const uniform float4x4 modelViewProj, 
    … …  
    6463                // add random noise: r stores costheta, g stores sintheta 
    6564 
    66                 float3 mynoise = (float3)tex2D(noiseTexture, IN.texCoord.xy);// * noiseMultiplier); 
    67                 //const float3 offsetTransformed = myreflect(offset, mynoise) * AREA_SIZE; 
    68                 const float3 offsetTransformed = offset * AREA_SIZE; 
     65                float3 mynoise = (float3)tex2D(noiseTexture, IN.texCoord.xy); 
     66                const float3 offsetTransformed = myreflect(offset, mynoise) * AREA_SIZE; 
     67                //const float3 offsetTransformed = offset * AREA_SIZE; 
    6968 
    7069                // compute position 
    … …  
    116115                   uniform sampler2D noiseTexture, 
    117116                   uniform float3 samples[NUM_SAMPLES], 
    118                    uniform float noiseMultiplier, 
    119117                   uniform sampler2D oldTex, 
    120118                   const uniform float4x4 oldModelViewProj, 
    … …  
    147145        realPos.w = 1.0f; 
    148146 
    149         const float ao = ssao(IN, positions, noiseTexture, samples, normal, viewDir, noiseMultiplier, centerPosition, mymodelViewProj, realPos); 
     147        const float ao = ssao(IN, positions, noiseTexture, samples, normal, viewDir, centerPosition, mymodelViewProj, realPos); 
    150148        //const float ao = ssao(IN, positions, samples, normal, viewDir, centerPosition, mymodelViewProj, realPos); 
    151149                 
Note: See TracChangeset for help on using the changeset viewer.