Changeset 2930


Ignore:
Timestamp:
09/11/08 14:52:51 (16 years ago)
Author:
mattausch
Message:

worked on ssao sampling

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

Legend:

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

    r2928 r2930  
    138138        switch (sampling) 
    139139        { 
    140         case DeferredRenderer::POISSON: 
     140        case DeferredRenderer::SAMPLING_POISSON: 
    141141                { 
    142                         PoissonDiscSampleGenerator poisson(NUM_SAMPLES, 1.0f); 
     142                        PoissonDiscSampleGenerator2 poisson(NUM_SAMPLES, 1.0f); 
    143143                        poisson.Generate((float *)samples2); 
    144144                } 
    145145                break; 
    146         case DeferredRenderer::GAUSS: 
     146        case DeferredRenderer::SAMPLING_QUADRATIC: 
    147147                { 
    148                         //PoissonDiscSampleGenerator poisson(NUM_SAMPLES, 1.0f); 
    149                         //poisson.Generate((float *)samples2); 
    150  
    151                         PseudoRandomGenerator pseudo(NUM_SAMPLES, 1.0f); 
    152                         pseudo.Generate((float *)samples2); 
     148                        QuadraticDiscSampleGenerator2 g(NUM_SAMPLES, 1.0f); 
     149                        g.Generate((float *)samples2); 
    153150                } 
    154151                break; 
    155         default: 
    156                 cout << "should not come here" << endl; 
    157                 break; 
     152        default: // SAMPLING_DEFAULT 
     153 
     154                RandomSampleGenerator2 g(NUM_SAMPLES, 1.0f); 
     155                g.Generate((float *)samples2); 
    158156        } 
    159157#endif 
     
    225223mUseTemporalCoherence(true), 
    226224mRegenerateSamples(true), 
    227 mSamplingMethod(POISSON), 
     225mSamplingMethod(SAMPLING_POISSON), 
    228226mShadingMethod(DEFAULT), 
    229227mFboIndex(0) 
  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.h

    r2928 r2930  
    5353        void SetUseTemporalCoherence(bool temporal); 
    5454 
    55         enum SAMPLING_METHOD {POISSON, GAUSS}; 
     55        enum SAMPLING_METHOD {SAMPLING_POISSON, SAMPLING_QUADRATIC, SAMPLING_DEFAULT}; 
    5656        enum SHADING_METHOD {DEFAULT, SSAO, GI}; 
    5757 
  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SampleGenerator.cpp

    r2903 r2930  
    66using namespace CHCDemoEngine; 
    77 
    8 HaltonSequence SphericalSampleGenerator::sHalton; 
    9 HaltonSequence PoissonDiscSampleGenerator::sHalton; 
    10 HaltonSequence PseudoRandomGenerator::sHalton; 
     8HaltonSequence SphericalSampleGenerator3::sHalton; 
     9HaltonSequence PoissonDiscSampleGenerator2::sHalton; 
     10HaltonSequence RandomSampleGenerator2::sHalton; 
     11HaltonSequence QuadraticDiscSampleGenerator2::sHalton; 
    1112 
    1213 
     
    1617 
    1718 
    18 PoissonDiscSampleGenerator::PoissonDiscSampleGenerator(int numSamples, float radius): 
     19PoissonDiscSampleGenerator2::PoissonDiscSampleGenerator2(int numSamples, float radius): 
    1920SampleGenerator(numSamples, radius) 
    2021{} 
    2122 
    2223 
    23 void PoissonDiscSampleGenerator::Generate(float *samples) const 
     24void PoissonDiscSampleGenerator2::Generate(float *samples) const 
    2425{ 
    25         // this is a hacky poisson sampling generator which does random dart-throwing 
    26         // until it is not able to place any dart for a number of tries 
    27         // in this case, the required min distance is reduced 
     26        // this is a hacky poisson sampling generator which does random dart-throwing on a disc. 
     27        // as a savety criterium, the min distance requirement is relaxed if we are not  
     28        // able to place any dart for a number of tries 
    2829        // the solution is a possion sampling with respect to the adjusted min distance 
    2930        // better solutions have been proposed, i.e., using hierarchical sampling 
    30  
    3131        const float maxTries = 1000; 
    3232        const float f_reduction = 0.9f; 
     
    3636 
    3737        // generates poisson distribution on disc 
    38         float minDist = 2.0f * mRadius / sqrt((float)mNumSamples); 
     38        // start with some threshold. best case: all samples lie on the circumference 
     39        //const float minDist = 2.0f * mRadius / sqrt((float)mNumSamples); 
     40        const float eps = 0.2f; 
     41        const float minDist = 2.0f * mRadius * M_PI * (1.0f - eps) / (float)mNumSamples; 
     42        float sqrMinDist = minDist * minDist; 
    3943 
    4044        //cout << "minDist before= " << minDist << endl; 
    4145        Sample2 *s = (Sample2 *)samples; 
    4246 
     47        int totalTries = 0; 
     48 
     49        // check if on disc 
    4350        for (int i = 0; i < mNumSamples; ++ i) 
    4451        { 
    45                 int tries = 0, totalTries = 0; 
     52                int tries = 0; 
    4653 
    4754                // repeat until valid sample was found 
     
    5158                        ++ totalTries; 
    5259 
    53                         r[0] = RandomValue(0, mRadius); 
    54                         r[1] = RandomValue(0, mRadius); 
    55                         //halton.GetNext(2, r); 
     60                        // note: should use halton, but seems somewhat broken 
     61                        //r[0] = RandomValue(.0f, mRadius); 
     62                        //r[1] = RandomValue(.0f, mRadius); 
     63                        sHalton.GetNext(2, r); 
    5664 
     65                        // scale to -1 .. 1 
    5766                        const float rx = r[0] * 2.0f - 1.0f; 
    5867                        const float ry = r[1] * 2.0f - 1.0f; 
     
    6877                        { 
    6978                                const float dist =  
    70                                         sqrt((s[j].x - rx) * (s[j].x - rx) + 
    71                                              (s[j].y - ry) * (s[j].y - ry)); 
     79                                        (s[j].x - rx) * (s[j].x - rx) + 
     80                                        (s[j].y - ry) * (s[j].y - ry); 
    7281                         
    73                                 if (dist < minDist) 
     82                                if (dist < sqrMinDist) 
    7483                                        sampleValid = false; 
    7584                        } 
     
    8493                        if (tries > maxTries) 
    8594                        { 
    86                                 minDist *= f_reduction; 
     95                                sqrMinDist *= f_reduction; 
    8796                                tries = 0; 
    8897                        } 
     
    9099        } 
    91100 
    92         //cout << "minDist after= " << minDist << endl; 
     101        //cout << "minDist after= " << sqrt(sqrMinDist) << " #tries: " << totalTries << endl; 
    93102} 
    94103 
    95104 
    96 PseudoRandomGenerator::PseudoRandomGenerator(int numSamples, float radius): 
     105RandomSampleGenerator2::RandomSampleGenerator2(int numSamples, float radius): 
    97106SampleGenerator(numSamples, radius) 
    98107{} 
    99108 
    100109 
    101 void PseudoRandomGenerator::Generate(float *samples) const 
     110void RandomSampleGenerator2::Generate(float *samples) const 
    102111{ 
    103112        Sample2 *s = (Sample2 *)samples; 
     
    105114        int numSamples = 0; 
    106115 
     116        float r[2]; 
     117 
    107118        while (numSamples < mNumSamples) 
    108119        { 
    109                 const float rx = RandomValue(-mRadius, +mRadius); 
    110                 const float ry = RandomValue(-mRadius, +mRadius); 
     120                //r[0] = RandomValue(-mRadius, mRadius); 
     121                //r[1] = RandomValue(-mRadius, mRadius); 
     122                sHalton.GetNext(2, r); 
     123                 
     124                const float rx = r[0] * 2.0f - 1.0f; 
     125                const float ry = r[1] * 2.0f - 1.0f; 
    111126 
    112127                // check if in disk, else exit early 
     
    122137 
    123138 
    124 SphericalSampleGenerator::SphericalSampleGenerator(int numSamples, float radius): 
     139SphericalSampleGenerator3::SphericalSampleGenerator3(int numSamples, float radius): 
    125140SampleGenerator(numSamples, radius) 
    126141{} 
    127142 
    128143 
    129 void SphericalSampleGenerator::Generate(float *samples) const 
     144void SphericalSampleGenerator3::Generate(float *samples) const 
    130145{ 
    131146        float r[2]; 
     
    136151                r[0] = RandomValue(0, 1); 
    137152                r[1] = RandomValue(0, 1); 
     153 
    138154                //sHalton.GetNext(2, r); 
    139                 //r[0] = pSamples[i].x; r[1] = pSamples[i].y; 
    140155 
    141156                // create stratified samples over sphere 
     
    147162                s[i].z = mRadius * cos(theta); 
    148163        } 
     164} 
    149165 
    150         //delete [] pSamples; 
     166 
     167QuadraticDiscSampleGenerator2::QuadraticDiscSampleGenerator2(int numSamples, float radius): 
     168SampleGenerator(numSamples, radius) 
     169{} 
     170 
     171 
     172void QuadraticDiscSampleGenerator2::Generate(float *samples) const 
     173{ 
     174        float r[2]; 
     175        Sample2 *s = (Sample2 *)samples; 
     176 
     177        for (int i = 0; i < mNumSamples; ++ i) 
     178        { 
     179                //r[0] = samples[i * 2]; 
     180                //r[1] = samples[i * 2 + 1]; 
     181                sHalton.GetNext(2, r); 
     182 
     183                // create samples over disc: the sample density 
     184                // decreases quadratically with the distance to the origin 
     185                s[i].x = mRadius * r[1] * sin(2.0f * M_PI * r[0]); 
     186                s[i].y = mRadius * r[1] * cos(2.0f * M_PI * r[0]); 
     187 
     188                //s[i].x = mRadius * r[1] * r[1] * sin(2.0f * M_PI * r[0]); 
     189                //s[i].y = mRadius * r[1] * r[1] * cos(2.0f * M_PI * r[0]); 
     190        } 
    151191} 
  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SampleGenerator.h

    r2911 r2930  
    4747 
    4848 
    49 class PseudoRandomGenerator: public SampleGenerator 
     49class RandomSampleGenerator2: public SampleGenerator 
    5050{ 
    5151public: 
    5252         
    53         PseudoRandomGenerator(int numSamples, float radius); 
     53        RandomSampleGenerator2(int numSamples, float radius); 
    5454 
    5555        virtual void Generate(float *samples) const; 
     
    6565        according to some d related to the number of samples. 
    6666*/ 
    67 class PoissonDiscSampleGenerator: public SampleGenerator 
     67class PoissonDiscSampleGenerator2: public SampleGenerator 
    6868{ 
    6969public: 
    7070         
    71         PoissonDiscSampleGenerator(int numSamples, float radius); 
     71        PoissonDiscSampleGenerator2(int numSamples, float radius); 
    7272 
    7373        virtual void Generate(float *samples) const; 
     
    7878}; 
    7979 
    80 /** This class generates random spherical samples. 
     80 
     81/** This class generates random samples on a disc 
     82        that have the property that their density decreases quadratically 
     83        with the distance 
    8184*/ 
    82 class SphericalSampleGenerator: public SampleGenerator 
     85class QuadraticDiscSampleGenerator2: public SampleGenerator 
    8386{ 
    8487public: 
    8588         
    86         SphericalSampleGenerator(int numSamples, float radius); 
     89        QuadraticDiscSampleGenerator2(int numSamples, float radius); 
     90 
     91        virtual void Generate(float *samples) const; 
     92 
     93protected: 
     94 
     95        static HaltonSequence sHalton; 
     96}; 
     97 
     98 
     99/** This class generates random spherical samples. 
     100*/ 
     101class SphericalSampleGenerator3: public SampleGenerator 
     102{ 
     103public: 
     104         
     105        SphericalSampleGenerator3(int numSamples, float radius); 
    87106 
    88107        virtual void Generate(float *samples) const; 
  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp

    r2929 r2930  
    171171bool useLODs = true; 
    172172 
    173 DeferredRenderer::SAMPLING_METHOD samplingMethod = DeferredRenderer::POISSON; 
     173DeferredRenderer::SAMPLING_METHOD samplingMethod = DeferredRenderer::SAMPLING_POISSON; 
    174174 
    175175bool useAdvancedShading = false; 
     
    11801180        case 'P': 
    11811181        case 'p': 
    1182                 if (samplingMethod == DeferredRenderer::GAUSS) 
    1183                         samplingMethod = DeferredRenderer::POISSON; 
    1184                 else 
    1185                         samplingMethod = DeferredRenderer::GAUSS; 
     1182                samplingMethod = DeferredRenderer::SAMPLING_METHOD((samplingMethod + 1) % 3); 
     1183                cout << "ssao sampling method: " << samplingMethod << endl; 
    11861184                break; 
    11871185        case 'Y': 
  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaderenv.h

    r2905 r2930  
    1010//#define SAMPLE_INTENSITY 40.0f 
    1111 
    12 // for quadradtc falloff 
    13 //#define SAMPLE_INTENSITY 0.28f 
     12// for quadratic falloff 
    1413#define SAMPLE_INTENSITY 0.32f 
    15 //#define SAMPLE_INTENSITY 2.4f 
     14//#define SAMPLE_INTENSITY 0.85f 
     15//#define SAMPLE_INTENSITY 5.0f 
    1616 
     17//#define AREA_SIZE 15e-1f 
    1718//#define AREA_SIZE 25e-1f 
    18 //#define AREA_SIZE 6e-1f 
    1919#define AREA_SIZE 8e-1f 
    20 //#define AREA_SIZE 5e-1f 
    2120 
    2221#define VIEW_CORRECTION_SCALE 0.0f 
    2322//#define VIEW_CORRECTION_SCALE 0.1f 
    2423 
    25 //#define DISTANCE_SCALE 5e-7f 
     24//#define DISTANCE_SCALE 1e-4f 
    2625#define DISTANCE_SCALE 1e-6f 
    27 //#define DISTANCE_SCALE 0.0f 
     26//#define DISTANCE_SCALE 1e-8f 
    2827 
    2928#define ILLUM_INTENSITY 5e-1f; 
Note: See TracChangeset for help on using the changeset viewer.