Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaderenv.h
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaderenv.h	(revision 3214)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaderenv.h	(revision 3216)
@@ -19,7 +19,4 @@
 
 #define NUM_SSAO_FILTER_SAMPLES 16
-
-#define SSAO_FILTER_WIDTH 12.0f
-//#define SSAO_FILTER_WIDTH 6.0f
 
 #define SSAO_CONVERGENCE_THRESHOLD 700.0f
Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/combineSsao.cg
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/combineSsao.cg	(revision 3212)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/shaders/combineSsao.cg	(revision 3216)
@@ -21,6 +21,7 @@
 
 
-/** Filter taking into account depth and normal differences, 
-    and convergence of a sample  
+/** Filter taking into account depth, normal discontinuities 
+   and ssao convergence of a sample (the higher the more reliably
+   has the sample a correct ssao value)
 */
 float DiscontinuityFilter(float2 texCoord,
@@ -31,73 +32,9 @@
 						  uniform sampler2D colorsTex,
 						  uniform float2 filterOffs[NUM_SSAO_FILTER_SAMPLES],
-						  uniform float filterWeights[NUM_SSAO_FILTER_SAMPLES],
-						  float scale
-						  )
-{
-	float average = .0f;
-	float total_w = .0f;
-
-	const float eyeSpaceDepth = color.w;
-
-	const float3 centerNormal = tex2Dlod(normalsTex, float4(texCoord, 0, 0)).xyz;
-
-	float4 aoSample;
-	float3 sampleNorm;
-	float3 samplePos;
-	float w;
-	float4 sampleTexCoord;
-	float depthFactor;
-	float normalFactor;
-	float convergenceFactor;
-	float sampleDepth;
-
-	for (int i = 0; i < NUM_SSAO_FILTER_SAMPLES; ++ i)
-	{
-		sampleTexCoord = float4(texCoord + filterOffs[i] * scale, 0, 0);
-
-		aoSample = tex2Dlod(ssaoTex, sampleTexCoord);
-		sampleNorm = tex2Dlod(normalsTex, sampleTexCoord).xyz;
-
-		// check depth discontinuity
-		sampleDepth = tex2Dlod(colorsTex, sampleTexCoord).w;
-		//sampleDepth = aoSample.w;
-		
-		//depthFactor = 1.0f / max(abs(eyeSpaceDepth - sampleDepth), 1e-2f);
-		depthFactor = 1.0f - step(1e-2f, abs(1.0f - eyeSpaceDepth / sampleDepth));
-		//normalFactor = max(step(0.6f, dot(sampleNorm, centerNormal)), 1e-3f);
-		normalFactor = max(dot(sampleNorm, centerNormal), 1e-3f);
-		//convergenceFactor = min(100.0f, aoSample.y);
-		convergenceFactor = aoSample.y + 1.0f;
-
-		// combine the weights
-		w = filterWeights[i] * convergenceFactor * depthFactor * normalFactor;
-		//w = normalFactor * convergenceFactor;
-
-		average += aoSample.x * w;
-		total_w += w;
-	}
-
-	average /= max(total_w, 1e-6f);
-
-	return saturate(average);
-}
-
-
-
-/** Filter taking into account depth and normal differences, 
-   and convergence of a sample  
-*/
-float DiscontinuityFilter2(float2 texCoord,
-						   float4 ao,
-						   float4 color,
-						   uniform sampler2D ssaoTex,
-						   uniform sampler2D normalsTex,
-						   uniform sampler2D colorsTex,
-						   uniform float2 filterOffs[NUM_SSAO_FILTER_SAMPLES],
-						   float scale,
-						   float3 bl,
-						   float3 br,
-						   float3 tl,
-						   float3 tr)
+						  float scale,
+						  float3 bl,
+						  float3 br,
+						  float3 tl,
+						  float3 tr)
 {
 	float average = .0f;
@@ -154,20 +91,22 @@
 
 /** Function combining image and indirect illumination buffer using a 
-	depth and normal aware discontinuity filter.
+	depth and normal aware discontinuity filter. We assume that 
+	we are using half resolution ssao for this version of the combineSsao
 */
-pixel combine(fragment IN, 
-			  uniform sampler2D colorsTex,
-			  uniform sampler2D ssaoTex,
-			  uniform sampler2D normalsTex,
-			  uniform float2 filterOffs[NUM_SSAO_FILTER_SAMPLES],
-			  uniform float filterWeights[NUM_SSAO_FILTER_SAMPLES],
-			  uniform float4x4 modelViewProj,
-			  uniform float3 bl,
-			  uniform float3 br,
-			  uniform float3 tl,
-			  uniform float3 tr,
-			  uniform float w,
-			  uniform float h
-			  )
+pixel CombineSsaoHalfRes(fragment IN, 
+						 uniform sampler2D colorsTex,
+						 uniform sampler2D ssaoTex,
+						 uniform sampler2D normalsTex,
+						 uniform float2 filterOffs[NUM_SSAO_FILTER_SAMPLES],
+						 uniform float filterWeights[NUM_SSAO_FILTER_SAMPLES],
+						 uniform float ssaoFilterRadius,
+						 uniform float4x4 modelViewProj,
+						 uniform float3 bl,
+						 uniform float3 br,
+						 uniform float3 tl,
+						 uniform float3 tr,
+						 uniform float w,
+						 uniform float h
+						 )
 {
 	pixel OUT;
@@ -176,7 +115,9 @@
 	float4 ao =  tex2Dlod(ssaoTex, float4(IN.texCoord, 0, 0));
 
+	// the following has to be done for half resolution ssao:
 	// get the minimum convergence by exactly sampling the 4 surrounding
 	// texels in the old texture, otherwise flickering because convergence
 	// will be interpolated when upsampling and filter size does not match!
+
 	float4 texelCenterConv;
 	const float xoffs = .5f / w; const float yoffs = .5f / h;
@@ -210,10 +151,10 @@
 
 		// descend to zero filter size after reaching thres pixels
-		const float convergenceWeight = SSAO_CONVERGENCE_THRESHOLD / (SSAO_FILTER_WIDTH - 1.0f);
+		const float convergenceWeight = SSAO_CONVERGENCE_THRESHOLD / (ssaoFilterRadius - 1.0f);
 		const float convergenceScale = convergenceWeight / (convergence + convergenceWeight);
-		const float scale = SSAO_FILTER_WIDTH * convergenceScale * distanceScale;
+		const float scale = ssaoFilterRadius * convergenceScale * distanceScale;
 
 		// the filtered ssao value
-		ao.x = DiscontinuityFilter2(IN.texCoord, ao, col, ssaoTex, normalsTex, colorsTex, filterOffs, scale, bl, br, tl, tr);
+		ao.x = DiscontinuityFilter(IN.texCoord, ao, col, ssaoTex, normalsTex, colorsTex, filterOffs, scale, bl, br, tl, tr);
 	}
 
Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.h
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.h	(revision 3215)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.h	(revision 3216)
@@ -26,15 +26,24 @@
 public:
 	/** Constructor for a deferred shader taking the requested output image size,
-		the current camera;
+		the current camera, and if the ssao should be full or half resolution
 	*/
-	DeferredRenderer(int w, int h, PerspectiveCamera *cam);
-	/** The algorithm renders the scene given an fbo consists of 1 color buffer, 
-		1 position buffer, and 1 normal buffer.
-		We also need the  projection view matrix of the last frame for reprojection, and
-		a smoothing factor for temporal coherence
+	DeferredRenderer(int w, int h, PerspectiveCamera *cam, bool ssaoUsefulResolution);
+	/** Destructor
 	*/
+	~DeferredRenderer();
+	/** The main render function
+	    Currently our fbo consists of one combined color + depth buffer, a normal buffer, 
+		and a buffer holding the difference of the pixel positions from the last frame.
 
-	~DeferredRenderer();
+		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.
 
+		The temporal coherence factor is the maximal number of ssao samples that are accumulated
+		without losing any prior sample information.
+		Set this number too low and flickering can be seen, too
+		high and the adaption to some changes in the ssao might be too slow. Usually from about
+		1000 samples a flickering cannot be seen.
+	*/
 	void Render(FrameBufferObject *fbo, 
 				float tempCohFactor, 
@@ -46,10 +55,8 @@
 
 	
-	void SetUseTemporalCoherence(bool temporal);
-
 	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
 	*/
@@ -58,13 +65,22 @@
 	*/
 	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);
 
 
@@ -126,4 +142,6 @@
 	void LenseFlare(FrameBufferObject *fbo, DirectionalLight *light);
  
+	void PrepareSsaoFilter();
+
 
 	////////////
@@ -133,4 +151,7 @@
 	/// deferred shading output image height
 	int mHeight;
+
+	//////////////////
+
 
 	PerspectiveCamera *mCamera;
@@ -152,6 +173,4 @@
 	FBOContainer mFBOs;
 
-	static ShaderContainer sShaders;
-
 	Matrix4x4 mProjViewMatrix;
 	Matrix4x4 mOldProjViewMatrix;
@@ -166,4 +185,5 @@
 
 	float mKernelRadius;
+	float mSsaoFilterRadius;
 	float mSampleIntensity;
 
Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SceneEntityConverter.h
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SceneEntityConverter.h	(revision 2953)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SceneEntityConverter.h	(revision 3216)
@@ -23,7 +23,4 @@
 	*/
 	SceneEntityConverter() {};
-	
-	//~SceneEntityConverter();
-
 	/** Converts this box to a scene entity
 	*/
Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ResourceManager.h
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ResourceManager.h	(revision 3215)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ResourceManager.h	(revision 3216)
@@ -63,4 +63,5 @@
 	bool mUseNormalMapping;
 
+
 protected:
 	
Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/irradiance.cpp
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/irradiance.cpp	(revision 3213)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/irradiance.cpp	(revision 3216)
@@ -1135,5 +1135,5 @@
 
 		if (!deferredShader) deferredShader = 
-			new DeferredRenderer(texWidth, texHeight, camera);
+			new DeferredRenderer(texWidth, texHeight, camera, 0);
 		
 		DeferredRenderer::SHADING_METHOD shadingMethod;
Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp	(revision 3215)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp	(revision 3216)
@@ -110,4 +110,6 @@
 int maxDepthForTestingChildren = 3;
 
+bool ssaoUseFullResolution = false;
+
 
 /// the technique used for rendering
@@ -151,4 +153,5 @@
 float ssaoKernelRadius = 1e-8f;
 float ssaoSampleIntensity = 0.2f;
+float ssaoFilterRadius = 12.0f;
 float ssaoTempCohFactor = 255.0;
 bool sortSamples = true;
@@ -400,4 +403,6 @@
 		env.GetFloatParam(string("ssaoSampleIntensity"), ssaoSampleIntensity);
 
+		env.GetBoolParam(string("ssaoUseFullResolution"), ssaoUseFullResolution);
+
 		//env.GetStringParam(string("modelPath"), model_path);
 		//env.GetIntParam(string("numSssaoSamples"), numSsaoSamples);
@@ -426,4 +431,5 @@
 		cout << "sample intensity: " << ssaoSampleIntensity << endl;
 		cout << "kernel radius: " << ssaoKernelRadius << endl;
+		cout << "ssao full resolution: " << ssaoUseFullResolution << endl;
 
 		//cout << "model path: " << model_path << endl;
@@ -1186,5 +1192,5 @@
 
 		if (!deferredShader) deferredShader = 
-			new DeferredRenderer(texWidth, texHeight, camera);
+			new DeferredRenderer(texWidth, texHeight, camera, ssaoUseFullResolution);
 		
 		DeferredRenderer::SHADING_METHOD shadingMethod;
@@ -1198,5 +1204,7 @@
 		}
 		else
+		{
 			shadingMethod = DeferredRenderer::DEFAULT;
+		}
 
 		deferredShader->SetSunVisiblePixels(sunVisiblePixels);
@@ -1205,4 +1213,5 @@
 		deferredShader->SetKernelRadius(ssaoKernelRadius);
 		deferredShader->SetSampleIntensity(ssaoSampleIntensity);
+		deferredShader->SetSsaoFilterRadius(ssaoFilterRadius);
 		deferredShader->SetUseTemporalCoherence(useTemporalCoherence);
 		deferredShader->SetSortSamples(sortSamples);
@@ -1320,19 +1329,33 @@
 	case '7':
 		ssaoTempCohFactor *= 0.5f;
+		cout << "new temporal coherence factor: " << ssaoTempCohFactor << endl;
 		break;
 	case '8':
 		ssaoTempCohFactor *= 2.0f;
+		cout << "new temporal coherence factor: " << ssaoTempCohFactor << endl;
 		break;
 	case '9':
 		ssaoKernelRadius *= 0.8f;
+		cout << "new ssao kernel radius: " << ssaoKernelRadius << endl;
 		break;
 	case '0':
 		ssaoKernelRadius *= 1.2f;
+		cout << "new ssao kernel radius: " << ssaoKernelRadius << endl;
 		break;
 	case 'n':
 		ssaoSampleIntensity *= 0.9f;
+		cout << "new ssao sample intensity: " << ssaoSampleIntensity << endl;
 		break;
 	case 'N':
 		ssaoSampleIntensity *= 1.1f;
+		cout << "new ssao sample intensity: " << ssaoSampleIntensity << endl;
+		break;
+	case 'o':
+		ssaoFilterRadius *= 0.9f;
+		cout << "new ssao filter radius: " << ssaoFilterRadius << endl;
+		break;
+	case 'O':
+		ssaoFilterRadius *= 1.1f;
+		cout << "new ssao filter radius: " << ssaoFilterRadius << endl;
 		break;
 	case 'l':
@@ -1340,4 +1363,5 @@
 		useLODs = !useLODs;
 		SceneEntity::SetUseLODs(useLODs);
+		cout << "using LODs: " << useLODs << endl;
 		break;
 	case 'P':
@@ -1358,9 +1382,11 @@
 		useTemporalCoherence = !useTemporalCoherence;
 		break;
-	case 'o':
+/*	case 'o':
 	case 'O':
 		useOptimization = !useOptimization;
+		// chc optimization of using the objects instead of 
+		// the bounding boxes for querying previously visible nodes
 		traverser->SetUseOptimization(useOptimization);
-		break;
+		break;*/
 	case 'a':
 	case 'A':
@@ -1413,4 +1439,5 @@
 		useLenseFlare = !useLenseFlare;
 		break;
+	
 	default:
 		return;
Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.cpp
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.cpp	(revision 3215)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.cpp	(revision 3216)
@@ -318,5 +318,7 @@
 
 
-DeferredRenderer::DeferredRenderer(int w, int h, PerspectiveCamera *cam):
+DeferredRenderer::DeferredRenderer(int w, int h, 
+								   PerspectiveCamera *cam,
+								   bool ssaoUseFullResolution):
 mWidth(w), mHeight(h), 
 mCamera(cam),
@@ -328,4 +330,5 @@
 mSortSamples(true),
 mKernelRadius(1e-8f),
+mSsaoFilterRadius(12.0f),
 mSampleIntensity(0.2f),
 mSunVisiblePixels(0)
@@ -334,8 +337,20 @@
 	//-- the flip-flop fbos
 
-	//const int dsw = w / 2; const int dsh = h / 2;
+	int downSampledWidth, downSampledHeight;
+
+	if (ssaoUseFullResolution)
+	{
+		downSampledWidth = w; downSampledHeight = h;
+		cout << "using full resolution ssao" << endl;
+	}
+	else
+	{
+		downSampledWidth = w / 2; downSampledHeight = h / 2;
+		cout << "using half resolution ssao" << endl;
+	}
+
 	const int dsw = w; const int dsh = h;
 
-	mIllumFbo = new FrameBufferObject(dsw, dsh, FrameBufferObject::DEPTH_NONE);
+	mIllumFbo = new FrameBufferObject(downSampledWidth, downSampledHeight, FrameBufferObject::DEPTH_NONE);
 	//mIllumFbo = new FrameBufferObject(w, h, FrameBufferObject::DEPTH_NONE);
 
@@ -400,15 +415,15 @@
 	ShaderManager *sm = ShaderManager::GetSingleton();
 
-	sCgDeferredProgram = sm->CreateFragmentProgram("deferred", "main", "deferredFrag");
-	sCgDeferredShadowProgram = sm->CreateFragmentProgram("deferred", "main_shadow", "deferredFragShader");
-	sCgSsaoProgram = sm->CreateFragmentProgram("ssao", "main", "ssaoFrag");
-	sCgGiProgram = sm->CreateFragmentProgram("globillum", "main", "giFrag");
-	sCgCombineIllumProgram = sm->CreateFragmentProgram("globillum", "combine", "combineGi");
-	sCgCombineSsaoProgram = sm->CreateFragmentProgram("combineSsao", "combine", "combineSsao");
-	sCgAntiAliasingProgram = sm->CreateFragmentProgram("antialiasing", "main", "antiAliasing");
-	sCgToneProgram = sm->CreateFragmentProgram("tonemap", "ToneMap", "toneMap");
+	sCgDeferredProgram = sm->CreateFragmentProgram("deferred", "main", "DeferredFrag");
+	sCgDeferredShadowProgram = sm->CreateFragmentProgram("deferred", "main_shadow", "DeferredFragShadow");
+	sCgSsaoProgram = sm->CreateFragmentProgram("ssao", "main", "SsaoFrag");
+	sCgGiProgram = sm->CreateFragmentProgram("globillum", "main", "GiFrag");
+	sCgCombineIllumProgram = sm->CreateFragmentProgram("globillum", "combine", "CombineGi");
+	sCgCombineSsaoProgram = sm->CreateFragmentProgram("combineSsao", "CombineSsaoHalfRes", "CombineSsao");
+	sCgAntiAliasingProgram = sm->CreateFragmentProgram("antialiasing", "main", "AntiAliasing");
+	sCgToneProgram = sm->CreateFragmentProgram("tonemap", "ToneMap", "ToneMap");
 	sCgDownSampleProgram = sm->CreateFragmentProgram("deferred", "Output", "Output");
 	sCgScaleDepthProgram = sm->CreateFragmentProgram("deferred", "ScaleDepth", "ScaleDepth");
-	sCgLogLumProgram = sm->CreateFragmentProgram("tonemap", "CalcAvgLogLum", "avgLogLum");
+	sCgLogLumProgram = sm->CreateFragmentProgram("tonemap", "CalcAvgLogLum", "AvgLogLum");
 	sCgPrepareSsaoProgram = sm->CreateFragmentProgram("deferred", "PrepareSsao", "PrepareSsao");
 	sCgLenseFlareProgram = sm->CreateFragmentProgram("lenseFlare", "LenseFlare", "LenseFlare");
@@ -451,7 +466,8 @@
 
 	string combineSsaoParams[] = 
-		{"colorsTex", "normalsTex", "ssaoTex", "filterOffs", 
-		 "filterWeights", "modelViewProj", "bl", "br", "tl", "tr", "w", "h"};
-	sCgCombineSsaoProgram->AddParameters(combineSsaoParams, 0, 12);
+		{"colorsTex", "normalsTex", "ssaoTex", "filterOffs", "filterWeights", 
+		"ssaoFilterRadius", "modelViewProj", "bl", "br", "tl", 
+		"tr", "w", "h"};
+	sCgCombineSsaoProgram->AddParameters(combineSsaoParams, 0, 13);
 
 	//////////////
@@ -503,24 +519,5 @@
 	//-- prepare filters for ssao
 
-
-	const float filterWidth = 1.0f;
-
-	PoissonDiscSampleGenerator2 poisson(NUM_SSAO_FILTER_SAMPLES, 1.0f);
-	poisson.Generate((float *)ssaoFilterOffsets);
-
-	const float xoffs = (float)filterWidth / mWidth;
-	const float yoffs = (float)filterWidth / mHeight;
-
-	for (int i = 0; i < NUM_SSAO_FILTER_SAMPLES; ++ i)
-	{
-		float x = ssaoFilterOffsets[2 * i + 0];
-		float y = ssaoFilterOffsets[2 * i + 1];
-
-		ssaoFilterWeights[i] = GaussianDistribution(x, y, 1.0f);
-		//ssaoFilterWeights[i] = 1.0f;
-
-		ssaoFilterOffsets[2 * i + 0] *= xoffs;
-		ssaoFilterOffsets[2 * i + 1] *= yoffs;
-	}
+	PrepareSsaoFilter();
 
 
@@ -615,4 +612,27 @@
 
 
+void DeferredRenderer::PrepareSsaoFilter()
+{
+	const float filterWidth = 1.0f;
+
+	PoissonDiscSampleGenerator2 poisson(NUM_SSAO_FILTER_SAMPLES, 1.0f);
+	poisson.Generate((float *)ssaoFilterOffsets);
+
+	const float xoffs = (float)filterWidth / mWidth;
+	const float yoffs = (float)filterWidth / mHeight;
+
+	for (int i = 0; i < NUM_SSAO_FILTER_SAMPLES; ++ i)
+	{
+		float x = ssaoFilterOffsets[2 * i + 0];
+		float y = ssaoFilterOffsets[2 * i + 1];
+
+		ssaoFilterWeights[i] = GaussianDistribution(x, y, 1.0f);
+		//ssaoFilterWeights[i] = 1.0f;
+
+		ssaoFilterOffsets[2 * i + 0] *= xoffs;
+		ssaoFilterOffsets[2 * i + 1] *= yoffs;
+	}
+}
+
 
 static inline float SqrMag(const Sample2 &s)
@@ -934,5 +954,6 @@
 	sCgCombineSsaoProgram->SetArray2f(i ++, (float *)ssaoFilterOffsets, NUM_SSAO_FILTER_SAMPLES);
 	sCgCombineSsaoProgram->SetArray1f(i ++, (float *)ssaoFilterWeights, NUM_SSAO_FILTER_SAMPLES);
-	
+	sCgCombineSsaoProgram->SetValue1f(i ++, mSsaoFilterRadius);
+
 	sCgCombineSsaoProgram->SetMatrix(i++, mProjViewMatrix);
 
@@ -1320,4 +1341,10 @@
 
 
+void DeferredRenderer::SetSsaoFilterRadius(float ssaoFilterRadius)
+{
+	mSsaoFilterRadius = ssaoFilterRadius;
+}
+
+
 void DeferredRenderer::SetSortSamples(bool sortSamples) 
 {
Index: /GTP/trunk/App/Demos/Vis/FriendlyCulling/default.env
===================================================================
--- /GTP/trunk/App/Demos/Vis/FriendlyCulling/default.env	(revision 3215)
+++ /GTP/trunk/App/Demos/Vis/FriendlyCulling/default.env	(revision 3216)
@@ -61,12 +61,9 @@
 # shader options for deferred rendering
 
-# ssao temporal coherence factor
-tempCohFactor=1000.0f
-
 # tone mapping
 useHDR=0
 
 # use antialiasing
-useAA=1
+useAA=0
 
 # show lense flare
@@ -79,5 +76,17 @@
 turbitity=3.0f
 
+
+###############
+## ssao options
+
+# use full resolution ssao (vs. half resoltion)
+ssaoUseFullResolution=0
+
+# ssao kernel radius
 ssaoKernelRadius=8e-1f
-
+# ssao sample intensity
 ssaoSampleIntensity=0.2f
+# ssao temporal coherence factor
+tempCohFactor=1000.0f
+# ssao filter radius
+ssaoFilterRadius=12.0f
