Changeset 3242 for GTP/trunk/App/Demos/Vis/FriendlyCulling/src

Timestamp:

01/02/09 17:29:48 (15 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/App/Demos/Vis/FriendlyCulling/src

Files:

• BvhLoader.cpp (modified) (1 diff)
• DeferredRenderer.cpp (modified) (9 diffs)
• DeferredRenderer.h (modified) (4 diffs)
• Pvs.cpp (added)
• Pvs.h (added)
• ViewCellsTree.cpp (added)
• ViewCellsTree.h (added)
• VisibilitySolutionLoader.cpp (added)
• VisibilitySolutionLoader.h (added)
• chcdemo.cpp (modified) (4 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/BvhLoader.cpp

@@ -82 +82 @@
         bvh->mNumNodes = 3;
 
+        cout << "*******************\nbox: " << root->mBox << " area: " << root->mArea << endl;
+
         tQueue.push(root);
         

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

@@ -302 +302 @@
 mSavedFrameNumber(-1),
 mSavedFrameSuffix(""),
-mMaxDistance(1e6f)
+mMaxDistance(1e6f),
+mTempCohFactor(.0f),
+mUseToneMapping(false),
+mUseAntiAliasing(false),
+mUseDepthOfField(false)
 {
         ///////////
@@ -537 +541 @@
 
 void DeferredRenderer::Render(FrameBufferObject *fbo, 
-                                                          float tempCohFactor,
                                                           DirectionalLight *light,
-                                                          bool useToneMapping,
-                                                          bool useAntiAliasing,
                                                           ShadowMap *shadowMap
                                                           )
@@ -562 +563 @@
         {
         case SSAO:
-                ComputeSsao(fbo, tempCohFactor);
+                ComputeSsao(fbo, mTempCohFactor);
                 CombineSsao(fbo);
                 break;
         case GI:
-                ComputeGlobIllum(fbo, tempCohFactor);
+                ComputeGlobIllum(fbo, mTempCohFactor);
                 CombineIllum(fbo);
                 break;
@@ -574 +575 @@
         }
 
-        /// do depth of field
-        DepthOfField(fbo);
-
-        if (useToneMapping)
+        /// depth of field
+        if (mUseDepthOfField)
+        {
+                DepthOfField(fbo);
+        }
+
+        if (mUseToneMapping)
         {
                 float imageKey, whiteLum, middleGrey;
@@ -593 +597 @@
         // multisampling is difficult / costly with deferred shading
         // at least do some edge blurring 
-        if (useAntiAliasing) AntiAliasing(fbo, light, displayAfterAA); 
+        if (mUseAntiAliasing) AntiAliasing(fbo, light, displayAfterAA); 
         
         /// store the current frame
@@ -599 +603 @@
 
         // if it hasn't been done yet => just output the latest buffer
-        if (!useAntiAliasing || !displayAfterAA)
+        if (!mUseAntiAliasing || !displayAfterAA)
                 Output(fbo); 
 
@@ -1266 +1270 @@
                                                                   )
 {
-        // light source not visible
+        // light source visible?
         if (!mSunVisiblePixels) return;
 
@@ -1437 +1441 @@
 
 
-void DeferredRenderer::SetSortSamples(bool sortSamples) 
+/*void DeferredRenderer::SetSortSamples(bool sortSamples) 
 {
         mSortSamples = sortSamples; 
-}
+}*/
 
 
@@ -1452 +1456 @@
 {
         mMaxDistance = maxDist;
+}
+
+
+void DeferredRenderer::SetUseToneMapping(bool toneMapping)
+{
+        mUseToneMapping = toneMapping;
+}
+        
+
+void DeferredRenderer::SetUseAntiAliasing(bool antiAliasing)
+{
+        mUseAntiAliasing = antiAliasing;
+}
+
+
+void DeferredRenderer::SetUseDepthOfField(bool dof)
+{
+        mUseDepthOfField = dof;
+}
+
+
+void DeferredRenderer::SetTemporalCoherenceFactorForSsao(float factor)
+{
+        mTempCohFactor = factor;
 }
 

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.h

@@ -36 +36 @@
                 and a buffer holding the difference of the pixel positions from the last frame.
 
-                Set useToneMapping to true if tone mapping should be applied
-                Set useAntiAliasing true if some basic edge antialiasing should be performed
                 If a shadowMap is specified that is not NULL, the shadow mapped shading algorithm is applied.
-
+        */
+        void Render(FrameBufferObject *fbo, 
+                                DirectionalLight *light,
+                                ShadowMap *shadowMap = NULL
+                                );
+
+        
+        enum SAMPLING_METHOD {SAMPLING_POISSON, SAMPLING_QUADRATIC, SAMPLING_DEFAULT};
+        /** Use ssao or ssao + color bleeding
+        */
+        enum SHADING_METHOD {DEFAULT, SSAO, GI};
+        /** Set the samplig method for the indirect illumination
+        */
+        void SetSamplingMethod(SAMPLING_METHOD s);
+        /** Set the shading method (SSAO, SSAO + color bleeding
+        */
+        void SetShadingMethod(SHADING_METHOD s);
+        /** Sort the samples in order to provide faster texture accesses.
+        */
+        //void SetSortSamples(bool sortSamples);
+        /** Sets ssao sample intensity.
+        */
+        void SetSampleIntensity(float sampleIntensity);
+        /** Sets ssao kernel radius.
+        */
+        void SetKernelRadius(float kernelRadius);
+        /** Sets ssao filter radius.
+        */
+        void SetSsaoFilterRadius(float radius);
+        /** Passes the number of pixels that are visible from the sun.
+        */
+        void SetSunVisiblePixels(int visiblePixels);
+        /** If true temporal coherence is used for ssao
+        */
+        void SetUseTemporalCoherence(bool temporal);
+        /** if set to something other than -1 the current frame is stored on disc
+                using the specified frame number
+        */
+        void SetSaveFrame(const std::string &suffix, int frameNumber);
+        /** Sets the maximal visible distance.
+        */
+        void SetMaxDistance(float maxDist);
+        /**     Enables / disables toneMapping
+        */
+        void SetUseToneMapping(bool toneMapping);
+        
+        /** Enable antiAliasing if some basic edge antialiasing should be performed
+        */
+        void SetUseAntiAliasing(bool antiAliasing);
+        /** Enables / disables depth of field.
+        */
+        void SetUseDepthOfField(bool dof);
+        /**
                 The temporal coherence factor is the maximal number of ssao samples that are accumulated
                 without losing any prior sample information.
@@ -46 +96 @@
                 1000 samples a flickering cannot be seen.
         */
-        void Render(FrameBufferObject *fbo, 
-                                float tempCohFactor, 
-                                DirectionalLight *light,
-                                bool useToneMapping,
-                                bool useAntiAliasing,
-                                ShadowMap *shadowMap = NULL
-                                );
-
-        
-        enum SAMPLING_METHOD {SAMPLING_POISSON, SAMPLING_QUADRATIC, SAMPLING_DEFAULT};
-        /** Use ssao or ssao + color bleeding
-        */
-        enum SHADING_METHOD {DEFAULT, SSAO, GI};
-        /** Set the samplig method for the indirect illumination
-        */
-        void SetSamplingMethod(SAMPLING_METHOD s);
-        /** Set the shading method (SSAO, SSAO + color bleeding
-        */
-        void SetShadingMethod(SHADING_METHOD s);
-        /** Sort the samples so texture access is faster
-        */
-        void SetSortSamples(bool sortSamples);
-        /** Sets ssao sample intensity.
-        */
-        void SetSampleIntensity(float sampleIntensity);
-        /** Sets ssao kernel radius.
-        */
-        void SetKernelRadius(float kernelRadius);
-        /** Sets ssao filter radius.
-        */
-        void SetSsaoFilterRadius(float radius);
-        /** Sets the number of visible pixels of the sun
-        */
-        void SetSunVisiblePixels(int visiblePixels);
-        /** If true tem poral coherence is used for ssao
-        */
-        void SetUseTemporalCoherence(bool temporal);
-        /** if set to something other than -1 the current frame is stored on disc
-                using the specified frame number
-        */
-        void SetSaveFrame(const std::string &suffix, int frameNumber);
-
-        void SetMaxDistance(float maxDist);
+        void SetTemporalCoherenceFactorForSsao(float factor);
 
 
@@ -116 +124 @@
 
         void CombineSsao(FrameBufferObject *fbo);
+
         void CombineIllum(FrameBufferObject *fbo);
         /** Does some basic antialiasing (searches for edges using a edge detector,
@@ -210 +219 @@
 
         float mMaxDistance;
+
+        float mTempCohFactor;
+        bool mUseToneMapping;
+        bool mUseAntiAliasing;
+        bool mUseDepthOfField;    
 };
 

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

@@ -381 +381 @@
 #endif
 
-        cout << "=== reading environment file ===" << endl << endl;
 
         int returnCode = 0;
@@ -582 +581 @@
 
 
-        int cityEntities = LoadModel("vienna_full_hp.dem", dynamicObjects);
+/*      int cityEntities = LoadModel("vienna_full_hp.dem", dynamicObjects);
         
         for (int i = (int)dynamicObjects.size() - cityEntities; i < (int)dynamicObjects.size(); ++ i)
                 dynamicObjects[i]->GetTransform()->SetMatrix(transl);
-
+*/
 
         ///////////
@@ -1295 +1294 @@
                 deferredShader->SetSsaoFilterRadius(ssaoFilterRadius);
                 deferredShader->SetUseTemporalCoherence(useTemporalCoherence);
-                deferredShader->SetSortSamples(sortSamples);
+                //deferredShader->SetSortSamples(sortSamples);
+                deferredShader->SetTemporalCoherenceFactorForSsao(ssaoTempCohFactor);
+                deferredShader->SetUseToneMapping(useHDR);
+                deferredShader->SetUseAntiAliasing(useAntiAliasing);
+
 
                 if (recordFrames && replayPath)
@@ -1307 +1310 @@
 
                 ShadowMap *sm = showShadowMap ? shadowMap : NULL;
-                deferredShader->Render(fbo, ssaoTempCohFactor, light, useHDR, useAntiAliasing, sm);
+                deferredShader->Render(fbo, light, sm);
         }