NewGamePhysics.GraphicalElements.BloomOverlay Class Reference

Inheritance diagram for NewGamePhysics.GraphicalElements.BloomOverlay:

List of all members.

Public Member Functions
	BloomOverlay (ScreenManager screenManager)
	Creates a bloom overay.
void	LoadContent ()
	Load effects, create textures and prepare filters.
void	UnloadContent ()
	Unload textures.
void	Draw (GameTime gameTime)
	This is where it all happens. Grabs a scene that has already been rendered, and uses postprocess magic to add a glowing bloom effect over the top of it.

---

Detailed Description

Definition at line 24 of file BloomOverlay.cs.

---

Constructor & Destructor Documentation

NewGamePhysics.GraphicalElements.BloomOverlay.BloomOverlay

(

ScreenManager

screenManager

)

Creates a bloom overay.

Parameters:

screenManager

The screen manager to use.

Definition at line 85 of file BloomOverlay.cs.

                                         : base(screenManager)
        {
        }

---

Member Function Documentation

void NewGamePhysics.GraphicalElements.BloomOverlay.Draw

(

GameTime

gameTime

)

This is where it all happens. Grabs a scene that has already been rendered, and uses postprocess magic to add a glowing bloom effect over the top of it.

Parameters:

gameTime

The current game time.

Definition at line 196 of file BloomOverlay.cs.

        {
            // Resolve the scene into a texture, so we can
            // use it as input data for the bloom processing.
            this.ScreenManager.GraphicsDevice.ResolveBackBuffer(resolveTarget);

            // Pass 1: draw the scene into rendertarget 1, using a
            // shader that extracts only the brightest parts of the image.
            this.extractEffect.Parameters["threshold"].SetValue(0.0f);
            DrawQuadWithEffect(resolveTarget, renderTarget1, this.extractEffect);

            // Pass 2: draw from rendertarget 1 into rendertarget 2,
            // using a shader to apply a horizontal gaussian blur filter.
            // Look up the sample weight and offset effect parameters.
            this.weightsParameter.SetValue(tapWeights);
            this.offsetsParameter.SetValue(horizontalTapOffsets);
            DrawQuadWithEffect(renderTarget1.GetTexture(), renderTarget2, this.filterEffect);
        
            // Pass 3: draw from rendertarget 2 back into rendertarget 1,
            // using a shader to apply a vertical gaussian blur filter.
            this.weightsParameter.SetValue(tapWeights);
            this.offsetsParameter.SetValue(verticalTapOffsets);
            DrawQuadWithEffect(renderTarget2.GetTexture(), renderTarget1, this.filterEffect);

            // Pass 4: draw both rendertarget 1 and the original scene
            // image back into the main backbuffer, using a shader that
            // combines them to produce the final bloomed result
            this.ScreenManager.GraphicsDevice.Textures[1] = resolveTarget;
            this.combineEffect.Parameters["CombineIntensity"].SetValue(2.0f);
            Viewport viewport = this.ScreenManager.GraphicsDevice.Viewport;
            this.ScreenManager.SpriteBatch.Begin(
                SpriteBlendMode.None,
                SpriteSortMode.Immediate,
                SaveStateMode.None);
            this.combineEffect.Begin();
            this.combineEffect.CurrentTechnique.Passes[0].Begin();
            this.ScreenManager.SpriteBatch.Draw(
                renderTarget1.GetTexture(),
                new Rectangle(0, 0, viewport.Width, viewport.Height),
                Color.White);
            this.ScreenManager.SpriteBatch.End();
            this.combineEffect.CurrentTechnique.Passes[0].End();
            this.combineEffect.End();
        }

void NewGamePhysics.GraphicalElements.BloomOverlay.LoadContent

(

)

Load effects, create textures and prepare filters.

Definition at line 93 of file BloomOverlay.cs.

        {
            this.extractEffect = 
                this.ScreenManager.Game.Content.Load<Effect>("Effects/ThresholdAndRescale");
            this.filterEffect = 
                this.ScreenManager.Game.Content.Load<Effect>("Effects/TapFilter15");
            this.combineEffect =
                this.ScreenManager.Game.Content.Load<Effect>("Effects/Combine");

            // Look up the resolution and format of our main backbuffer.
            PresentationParameters presentationParams = 
                this.ScreenManager.GraphicsDevice.PresentationParameters;
            int width = presentationParams.BackBufferWidth;
            int height = presentationParams.BackBufferHeight;
            SurfaceFormat format = presentationParams.BackBufferFormat;

            // Create a texture for reading back the backbuffer contents.
            this.resolveTarget = new ResolveTexture2D(
                this.ScreenManager.GraphicsDevice,
                width,
                height,
                1,
                format);

            // Create half-size bloom render targets
            width /= 2;
            height /= 2;
            renderTarget1 = new RenderTarget2D(
                this.ScreenManager.GraphicsDevice, 
                width, 
                height, 
                1,
                format,
                this.ScreenManager.GraphicsDevice.DepthStencilBuffer.MultiSampleType,
                this.ScreenManager.GraphicsDevice.PresentationParameters.MultiSampleQuality);
            renderTarget2 = new RenderTarget2D(
                this.ScreenManager.GraphicsDevice, 
                width, 
                height, 
                1,
                format,
                this.ScreenManager.GraphicsDevice.DepthStencilBuffer.MultiSampleType,
                this.ScreenManager.GraphicsDevice.PresentationParameters.MultiSampleQuality);

            // Get filter parameters
            this.weightsParameter = this.filterEffect.Parameters["TapWeights"];
            this.offsetsParameter = this.filterEffect.Parameters["TapOffsets"];

            // Calculate steps in filter
            int tapCount = weightsParameter.Elements.Count;
            int tapSteps = tapCount / 2;

            // Calculate tap filter weights and offsets
            this.tapWeights = new float[tapCount];
            this.horizontalTapOffsets = new Vector2[tapCount];
            this.verticalTapOffsets = new Vector2[tapCount];
            float dx = 1.0f / width;
            float dy = 1.0f / height;
            double size = 2.0;
            float weightSum = (float)Gaussian.DistributionValue(size, 0.0);
            this.tapWeights[0] = weightSum;
            this.verticalTapOffsets[0] = new Vector2();
            this.horizontalTapOffsets[0] = new Vector2();
            for (int i = 0; i < tapSteps; i++)
            {
                // Store weights for the positive and negative taps.
                float weight = (float)Gaussian.DistributionValue(size, (double)(i + 1));
                int left = i * 2 + 1;
                int right = i * 2 + 2;
                this.tapWeights[right] = weight;
                this.tapWeights[left] = weight;
                weightSum += (2.0f * weight);

                // Store Offsets
                float sampleOffset = right + 0.5f;
                this.horizontalTapOffsets[right] = new Vector2(dx, 0.0f) * sampleOffset;
                this.horizontalTapOffsets[left] = new Vector2(-dx, 0.0f) * sampleOffset;
                this.verticalTapOffsets[right] = new Vector2(0.0f, dy) * sampleOffset;
                this.verticalTapOffsets[left] = new Vector2(0.0f, -dy) * sampleOffset;
            }

            // Normalize weights
            for (int i = 1; i < tapCount; i++)
            {
                this.tapWeights[i] /= weightSum;
            }
        }

void NewGamePhysics.GraphicalElements.BloomOverlay.UnloadContent

(

)

Unload textures.

Definition at line 184 of file BloomOverlay.cs.

        {
            resolveTarget.Dispose();
            renderTarget1.Dispose();
            renderTarget2.Dispose();
        }

---

The documentation for this class was generated from the following file:

• C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/GraphicalElements/BloomOverlay.cs