protected override void OnProcess(RenderContext context) { context.ThrowIfCameraMissing(); context.ThrowIfGBuffer0Missing(); var graphicsDevice = GraphicsService.GraphicsDevice; var renderTargetPool = GraphicsService.RenderTargetPool; var source = context.SourceTexture; var target = context.RenderTarget; var viewport = context.Viewport; // Get temporary render targets. var sourceSize = new Vector2F(source.Width, source.Height); var isFloatingPointFormat = TextureHelper.IsFloatingPointFormat(source.Format); var sceneFormat = new RenderTargetFormat(source.Width, source.Height, false, source.Format, DepthFormat.None); var maskedScene = renderTargetPool.Obtain2D(sceneFormat); var rayFormat = new RenderTargetFormat( Math.Max(1, (int)(sourceSize.X / DownsampleFactor)), Math.Max(1, (int)(sourceSize.Y / DownsampleFactor)), false, source.Format, DepthFormat.None); var rayImage0 = renderTargetPool.Obtain2D(rayFormat); var rayImage1 = renderTargetPool.Obtain2D(rayFormat); // Get view and view-projection transforms. var cameraNode = context.CameraNode; Matrix44F projection = cameraNode.Camera.Projection.ToMatrix44F(); Matrix44F view = cameraNode.View; Matrix44F viewProjection = projection * view; // We simply place the light source "far away" in opposite light ray direction. Vector4F lightPositionWorld = new Vector4F(-LightDirection * 10000, 1); // Convert to clip space. Vector4F lightPositionProj = viewProjection * lightPositionWorld; Vector3F lightPositionClip = Vector4F.HomogeneousDivide(lightPositionProj); // Convert from clip space [-1, 1] to texture space [0, 1]. Vector2 lightPosition = new Vector2(lightPositionClip.X * 0.5f + 0.5f, -lightPositionClip.Y * 0.5f + 0.5f); // We use dot²(forward, -LightDirection) as a smooth S-shaped attenuation // curve to reduce the god ray effect when we look orthogonal or away from the sun. var lightDirectionView = view.TransformDirection(LightDirection); float z = Math.Max(0, lightDirectionView.Z); float attenuation = z * z; // Common effect parameters. _parameters0Parameter.SetValue(new Vector4(lightPosition.X, lightPosition.Y, LightRadius * LightRadius, Scale)); _parameters1Parameter.SetValue(new Vector2(Softness, graphicsDevice.Viewport.AspectRatio)); _intensityParameter.SetValue((Vector3)Intensity * attenuation); _numberOfSamplesParameter.SetValue(NumberOfSamples); _gBuffer0Parameter.SetValue(context.GBuffer0); // First, create a scene image where occluders are black. graphicsDevice.SetRenderTarget(maskedScene); _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _sourceTextureParameter.SetValue(source); graphicsDevice.SamplerStates[0] = isFloatingPointFormat ? SamplerState.PointClamp : SamplerState.LinearClamp; graphicsDevice.SamplerStates[1] = SamplerState.PointClamp; // G-Buffer 0. _createMaskPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // Downsample image. context.SourceTexture = maskedScene; context.RenderTarget = rayImage0; context.Viewport = new Viewport(0, 0, rayImage0.Width, rayImage0.Height); _downsampleFilter.Process(context); // Compute light shafts. _viewportSizeParameter.SetValue(new Vector2(context.Viewport.Width, context.Viewport.Height)); graphicsDevice.SamplerStates[0] = isFloatingPointFormat ? SamplerState.PointClamp : SamplerState.LinearClamp; for (int i = 0; i < NumberOfPasses; i++) { graphicsDevice.SetRenderTarget(rayImage1); _sourceTextureParameter.SetValue(rayImage0); _blurPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // Put the current result in variable rayImage0. MathHelper.Swap(ref rayImage0, ref rayImage1); } // Combine light shaft image with scene. graphicsDevice.SetRenderTarget(target); graphicsDevice.Viewport = viewport; _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _sourceTextureParameter.SetValue(source); _rayTextureParameter.SetValue(rayImage0); graphicsDevice.SamplerStates[0] = isFloatingPointFormat ? SamplerState.PointClamp : SamplerState.LinearClamp; graphicsDevice.SamplerStates[1] = isFloatingPointFormat ? SamplerState.PointClamp : SamplerState.LinearClamp; _combinePass.Apply(); graphicsDevice.DrawFullScreenQuad(); // Clean-up _sourceTextureParameter.SetValue((Texture2D)null); _gBuffer0Parameter.SetValue((Texture2D)null); _rayTextureParameter.SetValue((Texture2D)null); renderTargetPool.Recycle(maskedScene); renderTargetPool.Recycle(rayImage0); renderTargetPool.Recycle(rayImage1); context.SourceTexture = source; context.RenderTarget = target; context.Viewport = viewport; }
protected override void OnProcess(RenderContext context) { var graphicsDevice = GraphicsService.GraphicsDevice; var renderTargetPool = GraphicsService.RenderTargetPool; var source = context.SourceTexture; var target = context.RenderTarget; var viewport = context.Viewport; int downsampledWidth = Math.Max(1, source.Width / DownsampleFactor); int downsampledHeight = Math.Max(1, source.Height / DownsampleFactor); // ----- Get temporary render targets. var sourceDownsampled = renderTargetPool.Obtain2D(new RenderTargetFormat( downsampledWidth, downsampledHeight, false, source.Format, DepthFormat.None)); var bloom = renderTargetPool.Obtain2D(new RenderTargetFormat( downsampledWidth, downsampledHeight, false, SurfaceFormat.Color, DepthFormat.None)); // ----- Downsample scene. context.RenderTarget = sourceDownsampled; context.Viewport = new Viewport(0, 0, sourceDownsampled.Width, sourceDownsampled.Height); _downsampleFilter.Process(context); // ----- Compute luminance. context.SourceTexture = sourceDownsampled; context.RenderTarget = _luminanceTarget; context.Viewport = new Viewport(0, 0, _luminanceTarget.Width, _luminanceTarget.Height); _luminance.Process(context); // ----- Create bloom image. graphicsDevice.SetRenderTarget(bloom); _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _bloomThresholdParameter.SetValue(BloomThreshold); _middleGrayParameter.SetValue(MiddleGray); _minExposureParameter.SetValue(MinExposure); _maxExposureParameter.SetValue(MaxExposure); _bloomIntensityParameter.SetValue(BloomIntensity); _sceneTextureParameter.SetValue(sourceDownsampled); _luminanceTextureParameter.SetValue(_luminanceTarget); _brightnessPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // sourceDownsampled is not needed anymore. renderTargetPool.Recycle(sourceDownsampled); // We make a two-pass blur, so source can be equal to target. context.SourceTexture = bloom; context.RenderTarget = bloom; context.Viewport = new Viewport(0, 0, bloom.Width, bloom.Height); _blur.Process(context); // ----- Combine scene and bloom. graphicsDevice.SetRenderTarget(target); graphicsDevice.Viewport = viewport; _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _sceneTextureParameter.SetValue(source); _bloomTextureParameter.SetValue(bloom); _luminanceTextureParameter.SetValue(_luminanceTarget); _middleGrayParameter.SetValue(MiddleGray); if (EnableBlueShift) { _blueShiftColorParameter.SetValue((Vector3)BlueShiftColor); _blueShiftParameter.SetValue(new Vector2(1 / BlueShiftCenter, 1 / BlueShiftRange)); _combineWithBlueShiftPass.Apply(); } else { _combinePass.Apply(); } graphicsDevice.DrawFullScreenQuad(); // ----- Clean-up _sceneTextureParameter.SetValue((Texture2D)null); _luminanceTextureParameter.SetValue((Texture2D)null); _bloomTextureParameter.SetValue((Texture2D)null); renderTargetPool.Recycle(bloom); context.SourceTexture = source; context.RenderTarget = target; context.Viewport = viewport; }
protected override void OnProcess(RenderContext context) { context.ThrowIfCameraMissing(); var graphicsDevice = GraphicsService.GraphicsDevice; var renderTargetPool = GraphicsService.RenderTargetPool; var source = context.SourceTexture; var target = context.RenderTarget; var viewport = context.Viewport; RenderTarget2D temp128x128 = renderTargetPool.Obtain2D( new RenderTargetFormat(128, 128, false, SurfaceFormat.HalfVector4, DepthFormat.None)); RenderTarget2D temp64x64 = renderTargetPool.Obtain2D( new RenderTargetFormat(64, 64, false, SurfaceFormat.HalfVector4, DepthFormat.None)); RenderTarget2D luminance = renderTargetPool.Obtain2D( new RenderTargetFormat(1, 1, false, SurfaceFormat.HalfVector4, DepthFormat.None)); // ----- Downsample scene into temp128x128. context.RenderTarget = temp128x128; context.Viewport = new Viewport(0, 0, temp128x128.Width, temp128x128.Height); _downsampleFilter.Process(context); _useGeometricMeanParameter.SetValue(UseGeometricMean); // Get view-dependent information stored in camera node. var cameraNode = context.CameraNode; object dummy; cameraNode.ViewDependentData.TryGetValue(this, out dummy); var data = dummy as ViewDependentData; if (data == null) { data = new ViewDependentData(GraphicsService); cameraNode.ViewDependentData[this] = data; } if (UseAdaption) { // Use adaption if required by user and if we already have luminance info. _useAdaptionParameter.SetValue(data.LastLuminance != null); _deltaTimeParameter.SetValue((float)context.DeltaTime.TotalSeconds); _adaptionSpeedParameter.SetValue(AdaptionSpeed); _lastLuminanceTextureParameter.SetValue(data.LastLuminance); } else { _useAdaptionParameter.SetValue(false); _lastLuminanceTextureParameter.SetValue((Texture2D)null); // Reset old luminance info. data.Dispose(); } // ----- First downsample temp128x128 into temp64x64 and create luminance info. graphicsDevice.SetRenderTarget(temp64x64); _textureParameter.SetValue(temp128x128); _sourceSizeParameter.SetValue(new Vector2(temp128x128.Width, temp128x128.Height)); _targetSizeParameter.SetValue(new Vector2(temp64x64.Width, temp64x64.Height)); _createPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // temp128x128 is not needed anymore. renderTargetPool.Recycle(temp128x128); // ----- Downsample luminance info. RenderTarget2D last = temp64x64; while (last.Width > 2) { Debug.Assert(last.Width == last.Height, "The render target must be quadratic"); RenderTarget2D temp = renderTargetPool.Obtain2D( new RenderTargetFormat(last.Width / 2, last.Height / 2, false, last.Format, DepthFormat.None)); graphicsDevice.SetRenderTarget(temp); _textureParameter.SetValue(last); _sourceSizeParameter.SetValue(new Vector2(last.Width, last.Height)); _targetSizeParameter.SetValue(new Vector2(temp.Width, temp.Height)); _downsamplePass.Apply(); graphicsDevice.DrawFullScreenQuad(); renderTargetPool.Recycle(last); last = temp; } // ----- Sample 'last' and store final info in 'luminance'. graphicsDevice.SetRenderTarget(luminance); _textureParameter.SetValue(last); _sourceSizeParameter.SetValue(new Vector2(last.Width, last.Height)); _targetSizeParameter.SetValue(new Vector2(luminance.Width, luminance.Height)); _finalPass.Apply(); graphicsDevice.DrawFullScreenQuad(); renderTargetPool.Recycle(last); // ----- Copy luminance to original context.RenderTarget. context.SourceTexture = luminance; context.RenderTarget = target; context.Viewport = viewport; _copyFilter.Process(context); // ----- Store luminance for next frame. renderTargetPool.Recycle(data.LastLuminance); data.LastLuminance = luminance; // Restore original context. context.SourceTexture = source; _textureParameter.SetValue((Texture2D)null); }
protected override void OnProcess(RenderContext context) { if (TextureHelper.IsFloatingPointFormat(context.SourceTexture.Format)) { throw new GraphicsException("Source texture format must not be a floating-point format."); } var graphicsDevice = GraphicsService.GraphicsDevice; var renderTargetPool = GraphicsService.RenderTargetPool; var source = context.SourceTexture; var target = context.RenderTarget; var viewport = context.Viewport; int downsampledWidth = Math.Max(1, source.Width / DownsampleFactor); int downsampledHeight = Math.Max(1, source.Height / DownsampleFactor); // ----- Get temporary render targets. var bloomFormat = new RenderTargetFormat(downsampledWidth, downsampledHeight, false, SurfaceFormat.Color, DepthFormat.None); RenderTarget2D bloom0 = renderTargetPool.Obtain2D(bloomFormat); RenderTarget2D bloom1 = renderTargetPool.Obtain2D(bloomFormat); // ----- Downsample scene to bloom0. context.RenderTarget = bloom0; context.Viewport = new Viewport(0, 0, bloom0.Width, bloom0.Height); _downsampleFilter.Process(context); // ----- Create bloom image graphicsDevice.SetRenderTarget(bloom1); _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _bloomThresholdParameter.SetValue(Threshold); _bloomIntensityParameter.SetValue(Intensity); _bloomSaturationParameter.SetValue(Saturation); _sceneTextureParameter.SetValue(bloom0); _brightnessPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // bloom0 is not needed anymore. renderTargetPool.Recycle(bloom0); // We make a two-pass blur, so source can be equal to target. context.SourceTexture = bloom1; context.RenderTarget = bloom1; _blur.Process(context); // ----- Combine scene and bloom. graphicsDevice.SetRenderTarget(target); graphicsDevice.Viewport = viewport; _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _sceneTextureParameter.SetValue(source); _bloomTextureParameter.SetValue(bloom1); _combinePass.Apply(); graphicsDevice.DrawFullScreenQuad(); // ----- Clean-up _sceneTextureParameter.SetValue((Texture2D)null); _bloomTextureParameter.SetValue((Texture2D)null); renderTargetPool.Recycle(bloom1); // Restore original context. context.SourceTexture = source; context.RenderTarget = target; context.Viewport = viewport; }
protected override void OnProcess(RenderContext context) { context.ThrowIfCameraMissing(); context.ThrowIfGBuffer0Missing(); var graphicsDevice = GraphicsService.GraphicsDevice; var cameraNode = context.CameraNode; var renderTargetPool = GraphicsService.RenderTargetPool; var source = context.SourceTexture; var target = context.RenderTarget; var viewport = context.Viewport; var sourceSize = new Vector2F(source.Width, source.Height); int width = (int)sourceSize.X; int height = (int)sourceSize.Y; int downsampledWidth = Math.Max(1, width / DownsampleFactor); int downsampledHeight = Math.Max(1, height / DownsampleFactor); if (TextureHelper.IsFloatingPointFormat(source.Format)) { graphicsDevice.SamplerStates[0] = SamplerState.PointClamp; InitializeGaussianBlur(new Vector2F(downsampledWidth, downsampledHeight), false); } else { graphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; InitializeGaussianBlur(new Vector2F(downsampledWidth, downsampledHeight), true); } // Get temporary render targets. var downsampleFormat = new RenderTargetFormat(downsampledWidth, downsampledHeight, false, source.Format, DepthFormat.None); RenderTarget2D blurredScene0 = renderTargetPool.Obtain2D(downsampleFormat); RenderTarget2D blurredScene1 = renderTargetPool.Obtain2D(downsampleFormat); var blurredDepthFormat = new RenderTargetFormat(downsampledWidth, downsampledHeight, false, context.GBuffer0.Format, DepthFormat.None); RenderTarget2D blurredDepth0 = renderTargetPool.Obtain2D(blurredDepthFormat); var cocFormat = new RenderTargetFormat(width, height, false, SurfaceFormat.Single, DepthFormat.None); RenderTarget2D cocImage = renderTargetPool.Obtain2D(cocFormat); var downSampledCocFormat = new RenderTargetFormat(downsampledWidth, downsampledHeight, false, cocFormat.SurfaceFormat, DepthFormat.None); RenderTarget2D cocImageBlurred = renderTargetPool.Obtain2D(downSampledCocFormat); // ----- Create CoC map. _effect.CurrentTechnique = _effect.Techniques[0]; graphicsDevice.SetRenderTarget(cocImage); _screenSizeParameter.SetValue(new Vector2(cocImage.Width, cocImage.Height)); _depthTextureParameter.SetValue(context.GBuffer0); _nearBlurDistanceParameter.SetValue(NearBlurDistance); _nearFocusDistanceParameter.SetValue(NearFocusDistance); _farFocusDistanceParameter.SetValue(FarFocusDistance); _farBlurDistanceParameter.SetValue(FarBlurDistance); _farParameter.SetValue(cameraNode.Camera.Projection.Far); _circleOfConfusionPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // ----- Downsample cocImage to cocImageBlurred. context.SourceTexture = cocImage; context.RenderTarget = cocImageBlurred; context.Viewport = new Viewport(0, 0, cocImageBlurred.Width, cocImageBlurred.Height); _downsampleFilter.Process(context); renderTargetPool.Recycle(cocImage); // ----- Downsample source to blurredScene0. context.SourceTexture = source; context.RenderTarget = blurredScene0; context.Viewport = new Viewport(0, 0, blurredScene0.Width, blurredScene0.Height); _downsampleFilter.Process(context); // ----- Downsample depth texture to blurredDepth0. context.SourceTexture = context.GBuffer0; context.RenderTarget = blurredDepth0; context.Viewport = new Viewport(0, 0, blurredDepth0.Width, blurredDepth0.Height); _downsampleFilter.Process(context); // ----- Blur scene. // Horizontal blur graphicsDevice.SetRenderTarget(blurredScene1); _screenSizeParameter.SetValue(new Vector2(blurredScene0.Width, blurredScene0.Height)); _blurTextureParameter.SetValue(blurredScene0); _downsampledDepthTextureParameter.SetValue(blurredDepth0); _downsampledCocTextureParameter.SetValue(cocImageBlurred); _offsetsParameter.SetValue(_horizontalOffsets); _weightsParameter.SetValue(_weights); _blurPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // Vertical blur. graphicsDevice.SetRenderTarget(blurredScene0); _blurTextureParameter.SetValue(blurredScene1); _offsetsParameter.SetValue(_verticalOffsets); _blurPass.Apply(); graphicsDevice.DrawFullScreenQuad(); renderTargetPool.Recycle(blurredScene1); // ----- Blur cocImageBlurred. context.SourceTexture = cocImageBlurred; context.RenderTarget = cocImageBlurred; context.Viewport = new Viewport(0, 0, cocImageBlurred.Width, cocImageBlurred.Height); _cocBlur.Process(context); // We make a two pass blur, so context.SourceTexture can be equal to context.RenderTarget. // ----- Blur depth. context.SourceTexture = blurredDepth0; context.RenderTarget = blurredDepth0; context.Viewport = new Viewport(0, 0, blurredDepth0.Width, blurredDepth0.Height); _cocBlur.Process(context); // ----- Create final DoF image. _effect.CurrentTechnique = _effect.Techniques[0]; graphicsDevice.SetRenderTarget(target); graphicsDevice.Viewport = viewport; _screenSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _sceneTextureParameter.SetValue(source); _blurTextureParameter.SetValue(blurredScene0); _depthTextureParameter.SetValue(context.GBuffer0); _downsampledDepthTextureParameter.SetValue(blurredDepth0); _downsampledCocTextureParameter.SetValue(cocImageBlurred); _depthOfFieldPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // ----- Clean-up _depthTextureParameter.SetValue((Texture2D)null); _blurTextureParameter.SetValue((Texture2D)null); _downsampledDepthTextureParameter.SetValue((Texture2D)null); _downsampledCocTextureParameter.SetValue((Texture2D)null); _sceneTextureParameter.SetValue((Texture2D)null); renderTargetPool.Recycle(blurredScene0); renderTargetPool.Recycle(blurredDepth0); renderTargetPool.Recycle(cocImageBlurred); context.SourceTexture = source; context.RenderTarget = target; context.Viewport = viewport; }
protected override void OnProcess(RenderContext context) { context.ThrowIfCameraMissing(); var graphicsDevice = GraphicsService.GraphicsDevice; var renderTargetPool = GraphicsService.RenderTargetPool; var cameraNode = context.CameraNode; var source = context.SourceTexture; var target = context.RenderTarget; var viewport = context.Viewport; if (Quality == 0) { // No ambient occlusion. if (!CombineWithSource) { // CombineWithSource is not set. --> Simply clear the render target to white. graphicsDevice.SetRenderTarget(target); graphicsDevice.Viewport = viewport; graphicsDevice.Clear(Color.White); } else { // Copy source image to target. _copyFilter.Process(context); } return; } // Try to get downsampled depth buffer from render context. // If we cannot find it in the render context, we downsample it manually. Texture2D downsampledDepthTexture = null; RenderTarget2D downsampledDepthTarget = null; if (DownsampleFactor == 2) { object dummy; if (context.Data.TryGetValue(RenderContextKeys.DepthBufferHalf, out dummy)) { downsampledDepthTexture = dummy as Texture2D; } } if (downsampledDepthTexture == null) { context.ThrowIfGBuffer0Missing(); if (DownsampleFactor == 1) { downsampledDepthTexture = context.GBuffer0; } else { // Downsample manually. // If we do not downsample the depth target, we get artifacts (strange horizontal and vertical // lines). TODO: Check what causes the artifacts and try to remove the downsampling. downsampledDepthTarget = renderTargetPool.Obtain2D(new RenderTargetFormat( context.GBuffer0.Width / DownsampleFactor, context.GBuffer0.Height / DownsampleFactor, false, context.GBuffer0.Format, DepthFormat.None)); context.SourceTexture = context.GBuffer0; context.RenderTarget = downsampledDepthTarget; context.Viewport = new Viewport(0, 0, downsampledDepthTarget.Width, downsampledDepthTarget.Height); _downsampleFilter.Process(context); downsampledDepthTexture = downsampledDepthTarget; } } // We use two temporary render targets. // We do not use a floating point format because float textures cannot use hardware filtering. RenderTarget2D temp0; if (!CombineWithSource && target != null && target.Width == context.GBuffer0.Width / DownsampleFactor && target.Height == context.GBuffer0.Height / DownsampleFactor && Strength < 1) { // If we do not have to combine the AO result with the source image, and if the target // image has the half resolution, then we can use the target image directly and do not // need a temporary render target. // Also, a Strength > 1 is always applied in a separate pass because applying a Strength // > 1 before the blur has no effect. temp0 = target; } else { temp0 = renderTargetPool.Obtain2D(new RenderTargetFormat( context.GBuffer0.Width / DownsampleFactor, context.GBuffer0.Height / DownsampleFactor, false, SurfaceFormat.Color, DepthFormat.None)); } // Create SSAO. graphicsDevice.SetRenderTarget(temp0); _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _farParameter.SetValue(cameraNode.Camera.Projection.Far); _radiusParameter.SetValue((Vector2)Radii); _maxDistancesParameter.SetValue((Vector2)MaxDistances); _strengthParameter.SetValue(Strength < 1 ? Strength : 1); _gBuffer0Parameter.SetValue(downsampledDepthTexture); if (Quality == 1) { _createLinesAPass.Apply(); } else { _createLinesBPass.Apply(); } graphicsDevice.DrawFullScreenQuad(); if (UseEdgeAwareBlur) { RenderTarget2D temp1 = renderTargetPool.Obtain2D(new RenderTargetFormat( context.GBuffer0.Width / DownsampleFactor, context.GBuffer0.Height / DownsampleFactor, false, SurfaceFormat.Color, DepthFormat.None)); for (int i = 0; i < NumberOfBlurPasses; i++) { // Blur horizontally. // Note: We use a bilateral filter which is not separable - but the results are still ok // if we use separate the horizontal and vertical blur. graphicsDevice.SetRenderTarget(temp1); _occlusionTextureParameter.SetValue(temp0); _blurHorizontalPass.Apply(); graphicsDevice.DrawFullScreenQuad(); // Blur vertically. graphicsDevice.SetRenderTarget(temp0); _occlusionTextureParameter.SetValue(temp1); _blurVerticalPass.Apply(); graphicsDevice.DrawFullScreenQuad(); } // A few render targets are not needed anymore. renderTargetPool.Recycle(downsampledDepthTarget); renderTargetPool.Recycle(temp1); } else { // A few render targets are not needed anymore. renderTargetPool.Recycle(downsampledDepthTarget); context.SourceTexture = temp0; context.RenderTarget = temp0; context.Viewport = new Viewport(0, 0, temp0.Width, temp0.Height); for (int i = 0; i < NumberOfBlurPasses; i++) { _blur.Process(context); } } _strengthParameter.SetValue(Strength > 1 ? Strength : 1); if (CombineWithSource) { if (TextureHelper.IsFloatingPointFormat(source.Format)) { graphicsDevice.SamplerStates[0] = SamplerState.PointClamp; } else { graphicsDevice.SamplerStates[0] = SamplerState.LinearClamp; } // Combine with scene. graphicsDevice.SetRenderTarget(target); graphicsDevice.Viewport = viewport; _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _occlusionTextureParameter.SetValue(temp0); _sourceTextureParameter.SetValue(source); _combinePass.Apply(); graphicsDevice.DrawFullScreenQuad(); } else { if (temp0 != target) { graphicsDevice.SetRenderTarget(target); graphicsDevice.Viewport = viewport; _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height)); _occlusionTextureParameter.SetValue(temp0); _copyPass.Apply(); graphicsDevice.DrawFullScreenQuad(); } } // Clean-up if (temp0 != target) { renderTargetPool.Recycle(temp0); } _sourceTextureParameter.SetValue((Texture2D)null); _gBuffer0Parameter.SetValue((Texture2D)null); _occlusionTextureParameter.SetValue((Texture2D)null); context.SourceTexture = source; context.RenderTarget = target; context.Viewport = viewport; }