Changeset 2895

Timestamp:

09/02/08 15:29:20 (16 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/App/Demos/Vis/FriendlyCulling

Files:

• FriendlyCulling.vcproj (modified) (3 diffs)
• src/Bvh.cpp (modified) (9 diffs)
• src/Bvh.h (modified) (15 diffs)
• src/DeferredRenderer.cpp (moved) (moved from GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SsaoShader.cpp) (19 diffs)
• src/DeferredShader.cpp (modified) (15 diffs)
• src/ShadowMapping.h (modified) (1 diff)
• src/chcdemo.cpp (modified) (15 diffs)
• src/shaders/deferred.cg (modified) (2 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/FriendlyCulling.vcproj

@@ -216 +216 @@
                         </File>
                         <File
-                                RelativePath=".\src\DeferredShader.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\src\DeferredShader.h"
-                                >
-                        </File>
-                        <File
                                 RelativePath=".\src\Environment.cpp"
                                 >
@@ -321 +313 @@
                         <File
                                 RelativePath=".\src\ShadowMapping.h"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\src\SsaoShader.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\src\SsaoShader.h"
                                 >
                         </File>
@@ -544 +528 @@
                                 <File
                                         RelativePath=".\src\Camera.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath=".\src\DeferredRenderer.cpp"
                                         >
                                 </File>

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

@@ -24 +24 @@
 using namespace std;
 
+
+int BvhNode::sCurrentState = 0;
 
 
@@ -75 +77 @@
 mAxis(-1), 
 mDepth(0), 
-mPlaneMask(0),
-mPreferredPlane(0),
 mLastRenderedFrame(-999),
 mFirst(-1), 
@@ -87 +87 @@
 mIsVirtualLeaf(false)
 {
+        for (int i = 0; i < NUM_STATES; ++ i)
+        {
+                mPlaneMask[i] = 0;
+                mPreferredPlane[i]= 0;
+        }
 }
 
@@ -97 +102 @@
 void BvhNode::ResetVisibility()
 {
-        mVisibility.Reset();
+        for (int i = 0; i < NUM_STATES; ++ i)
+        {
+                mVisibility[i].Reset();
+        }
+
         mLastRenderedFrame = -999;
 }
@@ -301 +310 @@
 {
         // do the test only if necessary
-        if (!(node->mPlaneMask & (1 << i)))
+        if (!(node->mPlaneMask[BvhNode::sCurrentState] & (1 << i)))
                 return true;
                         
@@ -310 +319 @@
         {
                 // outside
-                node->mPreferredPlane = i;
+                node->mPreferredPlane[BvhNode::sCurrentState] = i;
                 return false;
         }
@@ -320 +329 @@
         {
                 // completely inside: children don't need to check against this plane no more
-                node->mPlaneMask^= 1 << i;
+                node->mPlaneMask[BvhNode::sCurrentState] ^= 1 << i;
         }
         else 
@@ -336 +345 @@
 
         if (node->GetParent())
-                node->mPlaneMask = node->GetParent()->mPlaneMask;
-
-
-        //for (int i = 0; i < 6; ++ i)
-        //      if (!TestPlane(node, i, bIntersect)) return 0;
-        
+                node->mPlaneMask[BvhNode::sCurrentState] = node->GetParent()->mPlaneMask[BvhNode::sCurrentState];
 
         ////////
         //-- apply frustum culling for the planes [mPreferredPlane - 5]
 
-        for (int i = node->mPreferredPlane; i < 6; ++ i)
+        for (int i = node->mPreferredPlane[BvhNode::sCurrentState]; i < 6; ++ i)
                 if (!TestPlane(node, i, bIntersect)) return 0;
         
+
         //////////
         //-- do the view frustum culling for the planes [0 - m_iPreferredPlane)
 
-        for (int i = 0; i < node->mPreferredPlane; ++ i)
+        for (int i = 0; i < node->mPreferredPlane[BvhNode::sCurrentState]; ++ i)
                 if (!TestPlane(node, i, bIntersect)) return 0;
         
@@ -362 +367 @@
 {
         // = 0011 1111 which means that at the beginning, all six planes have to frustum culled
-        mRoot->mPlaneMask = 0x3f;
+        mRoot->mPlaneMask[BvhNode::sCurrentState] = 0x3f;
 
         mCamera->CalcFrustum(sFrustum);

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

@@ -12 +12 @@
 namespace CHCDemoEngine
 {
+
+// the number of visibility states
+#define NUM_STATES 2
 
 ////////
@@ -149 +152 @@
         inline int CountPrimitives() const;
 
+        static void SetCurrentState(int _state) { sCurrentState = _state; }
+
 
 protected:
 
-        /////////////
-        
         /// the depth of this node
         unsigned char mDepth;
@@ -160 +163 @@
         /// the parent node
         BvhNode *mParent;
-        /// stores the visibility related info
-        VisibilityInfo mVisibility;
+
+
+        //////////////
+        //-- these members define the current state
+
+        /// stores the visibility related info 
+        VisibilityInfo mVisibility[NUM_STATES];
 
         /////////
         //-- used for view frustum culling
 
-        int mPlaneMask;
-        int mPreferredPlane;
+        int mPlaneMask[NUM_STATES];
+        int mPreferredPlane[NUM_STATES];
+
+        // the current state
+        static int sCurrentState;
+
+
+        ////////////////////
 
 
@@ -221 +235 @@
 int BvhNode::GetLastVisitedFrame() const 
 { 
-        return mVisibility.mLastVisitedFrame; 
+        return mVisibility[sCurrentState].mLastVisitedFrame; 
 }
 
@@ -227 +241 @@
 void BvhNode::SetLastVisitedFrame(const int lastVisited) 
 { 
-        mVisibility.mLastVisitedFrame = lastVisited; 
+        mVisibility[sCurrentState].mLastVisitedFrame = lastVisited; 
 }
 
@@ -233 +247 @@
 bool BvhNode::IsVisible() const 
 { 
-        return mVisibility.mIsVisible; 
+        return mVisibility[sCurrentState].mIsVisible; 
 }
 
@@ -239 +253 @@
 void BvhNode::SetVisible(bool visible) 
 { 
-        mVisibility.mIsVisible = visible; 
+        mVisibility[sCurrentState].mIsVisible = visible; 
 }
 
@@ -245 +259 @@
 void BvhNode::IncTimesTestedInvisible() 
 { 
-        ++ mVisibility.mTimesInvisible; 
+        ++ mVisibility[sCurrentState].mTimesInvisible; 
 }
 
@@ -251 +265 @@
 int BvhNode::GetTimesTestedInvisible() const 
 { 
-        return mVisibility.mTimesInvisible; 
+        return mVisibility[sCurrentState].mTimesInvisible; 
 }
 
@@ -257 +271 @@
 void BvhNode::SetTimesTestedInvisible(int t) 
 { 
-        mVisibility.mTimesInvisible = t; 
+        mVisibility[sCurrentState].mTimesInvisible = t; 
 }
 
@@ -263 +277 @@
 bool BvhNode::IsViewFrustumCulled() const 
 { 
-        return mVisibility.mIsFrustumCulled; 
+        return mVisibility[sCurrentState].mIsFrustumCulled; 
 }
 
@@ -269 +283 @@
 void BvhNode::SetViewFrustumCulled(bool frustumCulled) 
 { 
-        mVisibility.mIsFrustumCulled = frustumCulled; 
+        mVisibility[sCurrentState].mIsFrustumCulled = frustumCulled; 
 }
 
@@ -275 +289 @@
 bool BvhNode::IsNew() const 
 { 
-        return mVisibility.mIsNew;
+        return mVisibility[sCurrentState].mIsNew;
 }
 
@@ -281 +295 @@
 void BvhNode::SetIsNew(bool isNew) 
 { 
-        mVisibility.mIsNew = isNew; 
-}
-
+        mVisibility[sCurrentState].mIsNew = isNew; 
+}
+
+
+void BvhNode::SetAssumedVisibleFrameId(int t) 
+{ 
+        mVisibility[sCurrentState].mAssumedVisibleFrameId = t; 
+}
+
+
+int BvhNode::GetAssumedVisibleFrameId() const 
+{ 
+        return mVisibility[sCurrentState].mAssumedVisibleFrameId;
+}
+
+
+int BvhNode::GetLastQueriedFrame() const
+{
+        return mVisibility[sCurrentState].mLastQueriedFrame;
+}
+
+
+void BvhNode::SetLastQueriedFrame(int lastTested)
+{
+        mVisibility[sCurrentState].mLastQueriedFrame = lastTested;
+}
 
 int BvhNode::GetLastRenderedFrame() const 
@@ -309 +346 @@
 
 
-void BvhNode::SetAssumedVisibleFrameId(int t) 
-{ 
-        mVisibility.mAssumedVisibleFrameId = t; 
-}
-
-
-int BvhNode::GetAssumedVisibleFrameId() const 
-{ 
-        return mVisibility.mAssumedVisibleFrameId;
-}
-
-
-int BvhNode::GetLastQueriedFrame() const
-{
-        return mVisibility.mLastQueriedFrame;
-}
-
-
-void BvhNode::SetLastQueriedFrame(int lastTested)
-{
-        mVisibility.mLastQueriedFrame = lastTested;
-}
 
 

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

@@ -8 +8 @@
 #include "RndGauss.h"
 #include "Halton.h"
+#include "ShadowMapping.h"
 
 
@@ -23 +24 @@
 static CGprogram sCgDeferredProgram = NULL;
 static CGprogram sCgAntiAliasingProgram = NULL;
+static CGprogram sCgDeferredShadowProgram = NULL;
 
 static CGparameter sColorsTexCombineParam;
@@ -83 +85 @@
 static CGparameter sNormalsTexAntiAliasingParam;
 
+
+static CGparameter sShadowMapParam;
+static CGparameter sPositionsTexShadowParam;  
+static CGparameter sColorsTexShadowParam;  
+static CGparameter sNormalsTexShadowParam;
+
+static CGparameter sShadowMatrixParam;
+static CGparameter sMaxDepthShadowParam;
+static CGparameter sSampleWidthParam;
+
+
+
 static GLuint noiseTex = 0;
 
@@ -88 +102 @@
 static Sample2 samples[NUM_SAMPLES];
 
+static int colorBufferIdx = 0;
 
 static void PrintGLerror(char *msg)
@@ -192 +207 @@
 mScaleFactor(scaleFactor),
 mUseTemporalCoherence(true),
-mUseGlobIllum(false),
-mSampling(POISSON),
+mRegenerateSamples(true),
+mSamplingMethod(POISSON),
+mShadingMethod(DEFAULT),
 mFboIndex(0)
 {
@@ -237 +253 @@
 
         glDeleteTextures(1, &noiseTex);
-}
-
-
-void SsaoShader::SetUseGlobIllum(bool useGlobIllum)
-{
-        mUseGlobIllum = useGlobIllum;
 }
 
@@ -303 +313 @@
                 
                 cgGLSetParameter1f(sNoiseMultiplierParam, RandomValue(3.0f, 17.0f));
-
-                // generate samples for ssao kernel
-                //GenerateSamples(mSampling); 
-
                 sSamplesParam = cgGetNamedParameter(sCgSsaoProgram, "samples");
-                //cgSetArraySize(sSamplesParam, NUM_SAMPLES);
-                //cgCompileProgram(sCgSsaoProgram);
-                
-                //cgGLSetParameterArray2f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples);
         }
         else
@@ -344 +346 @@
                 sOldIllumTexGiParam = cgGetNamedParameter(sCgGiProgram, "oldIllumTex");  
 
-                // generate samples for ssao kernel
-                //GenerateSamples(); 
-                //cgGLSetParameterArray2f(sSamplesGiParam, 0, NUM_SAMPLES, (const float *)samples);
-
                 cgGLSetParameter1f(sNoiseMultiplierGiParam, RandomValue(3.0f, 17.0f));
         }
@@ -410 +408 @@
                 cerr << "antialiasing program failed to load" << endl;
 
+        sCgDeferredShadowProgram = 
+                cgCreateProgramFromFile(context, 
+                                                                CG_SOURCE,
+                                                                "src/shaders/deferred.cg", 
+                                                                RenderState::sCgFragmentProfile,
+                                                                "main_shadow",
+                                                                NULL);
+
+        if (sCgDeferredShadowProgram != NULL)
+        {
+                cgGLLoadProgram(sCgDeferredShadowProgram);
+
+                // we need size of texture for scaling
+                sPositionsTexShadowParam = cgGetNamedParameter(sCgDeferredShadowProgram, "positions");  
+                sColorsTexShadowParam = cgGetNamedParameter(sCgDeferredShadowProgram, "colors");  
+                sNormalsTexShadowParam = cgGetNamedParameter(sCgDeferredShadowProgram, "normals");
+
+                sShadowMapParam = cgGetNamedParameter(sCgDeferredShadowProgram, "shadowMap");  
+                sMaxDepthShadowParam = cgGetNamedParameter(sCgDeferredShadowProgram, "maxDepth");
+                sSampleWidthParam = cgGetNamedParameter(sCgDeferredShadowProgram, "sampleWidth");
+                sShadowMatrixParam = cgGetNamedParameter(sCgDeferredShadowProgram, "shadowMatrix");
+        }
+        else
+                cerr << "deferred program failed to load" << endl;
         PrintGLerror("init");
 }
@@ -416 +438 @@
 void SsaoShader::Render(FrameBufferObject *fbo, 
                                                 const Matrix4x4 &oldProjViewMatrix,
-                                                float expFactor)
+                                                float expFactor,
+                                                ShadowMap *shadowMap)
 {
         
@@ -447 +470 @@
         glOrtho(-offs, offs, -offs, offs, 0, 1);
 
-        FirstPass(fbo);
-        
-        if (!mUseGlobIllum)
-        {
+        if (shadowMap)
+                FirstPassShadow(fbo, shadowMap);
+        else
+                FirstPass(fbo);
+        
+        switch (mShadingMethod)
+        {
+        case SSAO:
                 ComputeSsao(fbo, expFactor, oldProjViewMatrix);
                 CombineSsao(fbo);
-        }
-        else
-        {
+                break;
+        case GI:
                 ComputeGlobIllum(fbo, expFactor, oldProjViewMatrix);
                 CombineIllum(fbo);
+                break;
+        default: // DEFAULT
+                // do nothing: standard deferred shading
+                break;
         }
 
@@ -528 +558 @@
         
 
-        if (mUseTemporalCoherence)
-        {
+        if (mUseTemporalCoherence || mRegenerateSamples)
+        {
+                mRegenerateSamples = false;
                 cgGLSetParameter1f(sNoiseMultiplierParam, RandomValue(3.0f, 17.0f));
-                cgGLSetParameter1f(sExpFactorParam, expFactor);
 
                 // q: should we generate new samples or only rotate the old ones?
                 // in the first case, the sample patterns look nicer, but the kernel
                 // needs longer to converge
-                GenerateSamples(mSampling); 
+                GenerateSamples(mSamplingMethod); 
                 cgGLSetParameterArray2f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples);
         }
-        else
-        {
-                        cgGLSetParameter1f(sExpFactorParam, 1.0f);
-        }
+
+        cgGLSetParameter1f(sExpFactorParam, mUseTemporalCoherence ? expFactor : 1.0f);
 
         Vector3 tl, tr, bl, br;
@@ -604 +632 @@
 void SsaoShader::AntiAliasing(FrameBufferObject *fbo)
 {
-        GLuint colorsTex = fbo->GetColorBuffer(0)->GetTexture();
+        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();
         GLuint normalsTex = fbo->GetColorBuffer(2)->GetTexture();
         
@@ -650 +678 @@
         fbo->Bind();
 
-        glDrawBuffers(1, mymrt + 3);
+        colorBufferIdx = 3;
+        glDrawBuffers(1, mymrt + colorBufferIdx);
 
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -754 +783 @@
 
 
-        if (mUseTemporalCoherence)
-        {
+        if (mUseTemporalCoherence || mRegenerateSamples)
+        {
+                mRegenerateSamples = false;
                 cgGLSetParameter1f(sNoiseMultiplierGiParam, RandomValue(3.0f, 17.0f));
                 cgGLSetParameter1f(sExpFactorGiParam, expFactor);
@@ -762 +792 @@
                 // in the first case, the sample patterns look nicer, but the kernel
                 // needs longer to converge
-                GenerateSamples(mSampling); 
+                GenerateSamples(mSamplingMethod); 
                 cgGLSetParameterArray2f(sSamplesGiParam, 0, NUM_SAMPLES, (const float *)samples);
         }
-        else
-        {
-                        cgGLSetParameter1f(sExpFactorGiParam, 1.0f);
-        }
+
+        cgGLSetParameter1f(sExpFactorParam, mUseTemporalCoherence ? expFactor : 1.0f);
 
         Vector3 tl, tr, bl, br;
@@ -812 +840 @@
 
         // overwrite old color texture
-        glDrawBuffers(1, mymrt);
+        colorBufferIdx = 0;
+        glDrawBuffers(1, mymrt + colorBufferIdx);
 
         cgGLEnableProfile(RenderState::sCgFragmentProfile);
@@ -863 +892 @@
         fbo->Bind();
 
-        // write into old color texture (not needed anymore)
-        glDrawBuffers(1, mymrt);
+        // overwrite old color texture
+        colorBufferIdx = 0;
+        glDrawBuffers(1, mymrt + colorBufferIdx);
 
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -903 +933 @@
 
 
+void SsaoShader::FirstPassShadow(FrameBufferObject *fbo, ShadowMap *shadowMap)
+{
+        GLuint colorsTex = fbo->GetColorBuffer(0)->GetTexture();
+
+        GLuint positionsTex = fbo->GetColorBuffer(1)->GetTexture();
+        GLuint normalsTex = fbo->GetColorBuffer(2)->GetTexture();
+        GLuint shadowTex = shadowMap->GetShadowTexture();
+
+        Matrix4x4 shadowMatrix;
+        shadowMap->GetTextureMatrix(shadowMatrix);
+
+        fbo->Bind();
+
+        colorBufferIdx = 3;
+        glDrawBuffers(1, mymrt + colorBufferIdx);
+
+        
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        cgGLBindProgram(sCgDeferredShadowProgram);
+
+        cgGLSetTextureParameter(sColorsTexShadowParam, colorsTex);
+        cgGLEnableTextureParameter(sColorsTexShadowParam);
+
+        cgGLSetTextureParameter(sPositionsTexShadowParam, positionsTex);
+        cgGLEnableTextureParameter(sPositionsTexShadowParam);
+
+        cgGLSetTextureParameter(sNormalsTexShadowParam, normalsTex);
+        cgGLEnableTextureParameter(sNormalsTexShadowParam);
+        
+        cgGLSetTextureParameter(sShadowMapParam, shadowTex);
+        cgGLEnableTextureParameter(sShadowMapParam);
+
+        cgGLSetParameter1f(sMaxDepthShadowParam, mScaleFactor);
+        cgGLSetParameter1f(sSampleWidthParam, 1.0f / shadowMap->GetSize());
+         
+        cgGLSetMatrixParameterfc(sShadowMatrixParam, (const float *)shadowMatrix.x);
+
+        glColor3f(1.0f, 1.0f, 1.0f);
+        
+        glBegin(GL_QUADS);
+
+        float offs2 = 0.5f;
+
+        glTexCoord2f(0, 0); glVertex3f(-offs2, -offs2, -0.5f);
+        glTexCoord2f(1, 0); glVertex3f( offs2, -offs2, -0.5f);
+        glTexCoord2f(1, 1); glVertex3f( offs2,  offs2, -0.5f);
+        glTexCoord2f(0, 1); glVertex3f(-offs2,  offs2, -0.5f);
+
+        glEnd();
+
+        cgGLDisableTextureParameter(sColorsTexShadowParam);
+        cgGLDisableTextureParameter(sPositionsTexShadowParam);
+        cgGLDisableTextureParameter(sNormalsTexShadowParam);
+        cgGLDisableTextureParameter(sShadowMapParam);
+
+        FrameBufferObject::Release();
+
+        PrintGLerror("deferred shading + shadows");
+}
+
+
+void SsaoShader::SetSamplingMethod(SAMPLING_METHOD s) 
+{ 
+        if (s != mSamplingMethod)
+        {
+                mSamplingMethod = s; 
+                mRegenerateSamples = true;
+        }
+}
 
 } // namespace

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

@@ -47 +47 @@
 static CGparameter sShadowMatrixParam;
 static CGparameter sMaxDepthParam;
-
+static CGparameter sSampleWidthParam;
 
 
@@ -122 +122 @@
                 sPositionsTexShadowParam = cgGetNamedParameter(sCgDeferredShadowProgram, "positions");  
                 sColorsTexShadowParam = cgGetNamedParameter(sCgDeferredShadowProgram, "colors");  
-                sNormalsTexShadowParam = cgGetNamedParameter(sCgDeferredShadowProgram, "normals"); 
+                sNormalsTexShadowParam = cgGetNamedParameter(sCgDeferredShadowProgram, "normals");
+
                 sShadowMapParam = cgGetNamedParameter(sCgDeferredShadowProgram, "shadowMap");  
                 sMaxDepthParam = cgGetNamedParameter(sCgDeferredShadowProgram, "maxDepth");
+                sSampleWidthParam = cgGetNamedParameter(sCgDeferredShadowProgram, "sampleWidth");
                 sShadowMatrixParam = cgGetNamedParameter(sCgDeferredShadowProgram, "shadowMatrix");
         }
@@ -156 +158 @@
         glOrtho(-offs, offs, -offs, offs, 0, 1);
 
-
         FirstPass(fbo);
         AntiAliasing(fbo);
 
         glEnable(GL_LIGHTING);
-        glDisable(GL_TEXTURE_2D);
-        
+                
         glMatrixMode(GL_PROJECTION);
         glPopMatrix();
@@ -172 +172 @@
 
         cgGLDisableProfile(RenderState::sCgFragmentProfile);
+        FrameBufferObject::Release();
 }
 
@@ -178 +179 @@
                                                         ShadowMap *shadowMap)
 {
+        FrameBufferObject::Release();
+
         cgGLEnableProfile(RenderState::sCgFragmentProfile);
 
@@ -183 +186 @@
         glDisable(GL_TEXTURE_2D);
         glDisable(GL_LIGHTING);
-        glDepthMask(GL_FALSE);
+        //glDepthMask(GL_FALSE);
         
 
@@ -204 +207 @@
 
         glEnable(GL_LIGHTING);
-        glEnable(GL_TEXTURE_2D);
-        glDepthMask(GL_TRUE);
+        //glEnable(GL_TEXTURE_2D);
+        //glDepthMask(GL_TRUE);
         
         glMatrixMode(GL_PROJECTION);
@@ -216 +219 @@
 
         cgGLDisableProfile(RenderState::sCgFragmentProfile);
+        FrameBufferObject::Release();
 }
 
@@ -258 +262 @@
         cgGLDisableTextureParameter(sPositionsTexParam);
         cgGLDisableTextureParameter(sNormalsTexParam);
-
-        cgGLDisableProfile(RenderState::sCgFragmentProfile);
         
         FrameBufferObject::Release();
@@ -290 +292 @@
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-        cgGLEnableProfile(RenderState::sCgFragmentProfile);
-
         cgGLBindProgram(sCgAntiAliasingProgram);
 
@@ -301 +301 @@
         
         glColor3f(1.0f, 1.0f, 1.0f);
-
-        float offs2 = 0.5f;
-
+        
         glBegin(GL_QUADS);
 
@@ -320 +318 @@
         cgGLDisableTextureParameter(sNormalsTexAntiAliasingParam);
 
-        cgGLDisableProfile(RenderState::sCgFragmentProfile);
-
         PrintGLerror("antialiasing");
 }
@@ -343 +339 @@
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-        cgGLEnableProfile(RenderState::sCgFragmentProfile);
-
         cgGLBindProgram(sCgDeferredShadowProgram);
 
@@ -360 +354 @@
 
         cgGLSetParameter1f(sMaxDepthParam, mScaleFactor);
-
+        cgGLSetParameter1f(sSampleWidthParam, 1.0f / shadowMap->GetSize());
+         
         cgGLSetMatrixParameterfc(sShadowMatrixParam, (const float *)shadowMatrix.x);
 
@@ -381 +376 @@
         cgGLDisableTextureParameter(sShadowMapParam);
 
-        cgGLDisableProfile(RenderState::sCgFragmentProfile);
-        
         FrameBufferObject::Release();
 

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

@@ -46 +46 @@
         */
         void GetTextureMatrix(Matrix4x4 &m) const;
-
+        /** Return shadow size.
+        */
+        int GetSize() const { return mSize; }
 
 protected:

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

@@ -34 +34 @@
 #include "FrameBufferObject.h"
 #include "SsaoShader.h"
-#include "DeferredShader.h"
 #include "ShadowMapping.h"
 #include "Light.h"
@@ -95 +94 @@
 static int winHeight = 768;
 
-//static int winWidth = 512;
-//static int winHeight = 512;
-
 
 static float winAspectRatio = 1.0f;
@@ -172 +168 @@
 bool useLODs = true;
 
-int samplingMethod = SsaoShader::POISSON;
+SsaoShader::SAMPLING_METHOD samplingMethod = SsaoShader::POISSON;
+SsaoShader::SHADING_METHOD shadingMethod = SsaoShader::DEFAULT;
+
+bool showShadowMap = false;
+bool shadowChanged = true;
 
 static Matrix4x4 matProjectionView = IdentityMatrix();
@@ -179 +179 @@
 ShadowMap *shadowMap = NULL;
 Light *light = NULL;
+
 
 // function forward declarations
@@ -225 +226 @@
 
 SsaoShader *ssaoShader = NULL;
-DeferredShader *deferredShader = NULL;
 
 static GLenum mrt[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT};
@@ -431 +431 @@
         InitCg();
 
-        DeferredShader::Init(sCgContext);
         SsaoShader::Init(sCgContext);
 
@@ -442 +441 @@
         sceneQuery = new SceneQuery(bvh->GetBox(), traverser);
 
-        Vector3 lightDir = Normalize(Vector3(0, 1, -1));
+        //Vector3 lightDir = Normalize(Vector3(0, 1, -1));
+        Vector3 lightDir = Normalize(-Vector3(0.8f, -1.0f, 0.7f));
+        
         light = new Light(lightDir, RgbaColor(1, 1, 1, 1));
 
-        const float shadowSize = 4096;
-        shadowMap = new ShadowMap(shadowSize, bvh->GetBox(), camera);
-        
+
         // frame time is restarted every frame
         frameTimer.Start();
@@ -867 +866 @@
         }
         
+        if (showShadowMap && !shadowMap)
+        {
+                const float shadowSize = 4096;
+                shadowMap = new ShadowMap(shadowSize, bvh->GetBox(), camera);
+        }
+
         // render without shading
         switch (renderType)
@@ -897 +902 @@
         
                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
                 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
 
@@ -904 +908 @@
         case RenderState::DEFERRED:
 
-                shadowMap->ComputeShadowMap(light, traverser);
+                // change CHC state (must be done for each change of camera)
+                BvhNode::SetCurrentState(1);
+
+                if (showShadowMap && shadowChanged)
+                {
+                        shadowChanged = false;
+
+                        cgGLDisableProfile(RenderState::sCgFragmentProfile);
+                        cgGLDisableProfile(RenderState::sCgVertexProfile);
+
+                        state.SetRenderType(RenderState::DEPTH_PASS);
+
+                        // the scene is rendered withouth any shading   
+                        shadowMap->ComputeShadowMap(light, traverser);
+
+                        // change back state
+                        BvhNode::SetCurrentState(0);
+
+                        glEnable(GL_LIGHTING);
+                        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+                }
 
                 if (!fbo) InitFBO();
+
 
                 // multisampling does not work with deferred shading
@@ -989 +1014 @@
                 cgGLDisableProfile(RenderState::sCgFragmentProfile);
 
-                if (useSsao)
-                {
-                        if (!ssaoShader) ssaoShader = new SsaoShader(texWidth, texHeight, camera, myfar / 10.0f);
-                        ssaoShader->Render(fbo, oldViewProjMatrix, ssaoExpFactor);
-
-                }
-                else
-                {
-                        if (!deferredShader) deferredShader = new DeferredShader(texWidth, texHeight, myfar / 10.0f);
-                        
-                        deferredShader->Render(fbo, shadowMap);
-                }
+                if (!ssaoShader) ssaoShader = new SsaoShader(texWidth, texHeight, camera, myfar / 10.0f);
+                
+                ssaoShader->SetShadingMethod(shadingMethod);
+                ssaoShader->SetSamplingMethod(samplingMethod);
+                ssaoShader->SetUseTemporalCoherence(useTemporalCoherence);
+
+                ShadowMap *sm = showShadowMap ? shadowMap : NULL;
+                ssaoShader->Render(fbo, oldViewProjMatrix, ssaoExpFactor, sm);
         }
 
@@ -1118 +1139 @@
                         samplingMethod = SsaoShader::GAUSS;
 
-                ssaoShader->SetSamplingMethod(samplingMethod);
-
+                break;
+        case 'Y':
+        case 'y':
+                showShadowMap = !showShadowMap;
                 break;
         case 'g':
-        case 'G':
-                useGlobIllum = !useGlobIllum;
-                ssaoShader->SetUseGlobIllum(useGlobIllum);
-                break;
         case 't':
         case 'T':
                 useTemporalCoherence = !useTemporalCoherence;
-                ssaoShader->SetUseTemporalCoherence(useTemporalCoherence);
                 break;
         case 'o':
@@ -1262 +1280 @@
                 break;
         case GLUT_KEY_F8:
-                useSsao = !useSsao;
+                shadingMethod = (SsaoShader::SHADING_METHOD)((shadingMethod + 1) % 3);
+                
                 break;
         case GLUT_KEY_F9:
@@ -1562 +1581 @@
         DEL_PTR(fbo);
         DEL_PTR(ssaoShader);
-        DEL_PTR(deferredShader);
 
         if (sCgMrtVertexProgram)
@@ -1766 +1784 @@
 }
 
-
+// render visible object from depth pass
 void RenderVisibleObjects()
 {

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

@@ -81 +81 @@
                                   uniform sampler2D shadowMap,
                                   uniform float4x4 shadowMatrix,
-                                  uniform float maxDepth
+                                  uniform float maxDepth,
+                                  uniform float sampleWidth
                                   )
 {
@@ -102 +103 @@
         float4 lightSpacePos = mul(shadowMatrix, position);
 
-        float shadowDepth = tex2D(shadowMap, lightSpacePos.xy);
+        float shadowDepth[9];
+
+        float w = sampleWidth;
+
+        // pcf sampling using 3 x 3 tab
+
+        shadowDepth[0] = tex2D(shadowMap, lightSpacePos.xy).x;
+        
+        shadowDepth[1] = tex2D(shadowMap, lightSpacePos.xy + float2( w,  w)).x;
+        shadowDepth[2] = tex2D(shadowMap, lightSpacePos.xy - float2( w, -w)).x;
+        shadowDepth[3] = tex2D(shadowMap, lightSpacePos.xy - float2(-w, -w)).x;
+        shadowDepth[4] = tex2D(shadowMap, lightSpacePos.xy - float2(-w,  w)).x;
+
+        shadowDepth[5] = tex2D(shadowMap, lightSpacePos.xy - float2( w,  0)).x;
+        shadowDepth[6] = tex2D(shadowMap, lightSpacePos.xy - float2( 0,  w)).x;
+        shadowDepth[7] = tex2D(shadowMap, lightSpacePos.xy - float2(-w,  0)).x;
+        shadowDepth[8] = tex2D(shadowMap, lightSpacePos.xy - float2( 0, -w)).x;
 
         OUT.color = col;
         
-        // hack: prevent shadowing the sky
-        if ((amb < 0.9) &&      
+        float depth = lightSpacePos.z / lightSpacePos.w;
+
+        float d = 0.0f;
+
+        for (int i = 0; i < 9; ++ i)
+        {
+                d += step(shadowDepth[i], depth);
+        }
+
+        d /= 9.0f;
+        
+        /*if ((amb < 0.9) && // hack: prevent shadowing the sky 
                 (lightSpacePos.z / lightSpacePos.w > shadowDepth))
         {
                 OUT.color *= 0.1f;
+        }*/
+        
+        if (amb < 0.9) // hack: prevent shadowing the sky       
+        {
+                const float x = 0.1f;
+                OUT.color *= x + (1.0f - x) * (1.0f - d);
         }