Another change I made was for the “PhysicsManager”. If you have a quad core processor, this will now add 3 threads to the “PhysicsManager”. Vigrid pointed out that he had been burnt in the past by allocating a thread for all processors, so rather than learn the hard-way, it’s been to re-allocated

We’ll start with the new “PhysicsManager” class. In the “Core” folder, add a new class called “PhysicsManager” and include the following namespaces:

using BEPUphysics;
using BEPUphysics.Constraints;
using BEPUphysics.Settings;
using Microsoft.Xna.Framework;
using ProjectVanquish.Models;

Add the following variables:

private Space space;
private IList<PhysicsObject> physicsObjects; 

PhysicsObject doesn’t exist yet, so you’ll have to fight with Visual Studio for the time being with regards the Intellisense. Let’s create the constructor:

public PhysicsManager(Vector3 gravity)
{
    space = new Space();
    space.ForceUpdater.Gravity = gravity;
    SolverSettings.DefaultMinimumIterations = 2;
    MotionSettings.DefaultPositionUpdateMode = BEPUphysics.PositionUpdating.PositionUpdateMode.Continuous;
    MotionSettings.UseExtraExpansionForContinuousBoundingBoxes = true;
    MotionSettings.CoreShapeScaling = 0.99f;
    space.Solver.IterationLimit = 20;

    // Check if we can use mutli-threading
    if (Environment.ProcessorCount > 1)
    {
        for (int i = 0; i < Environment.ProcessorCount; i++)
            space.ThreadManager.AddThread();

        space.BroadPhase.AllowMultithreading = true;
    }

    physicsObjects = new List<PhysicsObject>();
} 

In the constructor we are instantiating a new BEPU physics object and setting some default values. We also check to see if we can use multi-threading that the BEPU engine now supports. Straight forward enough. We’ll add some properties:

public IList<PhysicsObject> PhysicsObjects 
{ 
    get { return physicsObjects; } 
}

public Space Space 
{ 
    get { return space; } 
} 

This will be used in the “SceneManager” class. Lastly, we just need an “Update” method:

public void Update(GameTime gameTime)
{
    space.Update((float)gameTime.ElapsedGameTime.TotalSeconds);
} 

Excellent. That is our “PhysicsManager” class complete. Let’s extend our “SceneManager” class to use this new class. Open the “SceneManager” class and declare a new variable:

static PhysicsManager physicsManager;

In the constructor, we’ll instantiate it:

physicsManager = new PhysicsManager(new Vector3(0, -9.81f, 0));

This will create an earth-like gravity. We’ll create a static property so we can access this from the “PhysicsManager” class:

public static PhysicsManager PhysicsManager 
{ 
    get { return physicsManager; } 
}

The last part of the “SceneManager” class is to update the “PhysicsManager” in the “Update” method:

physicsManager.Update(gameTime);

That’s all we need to do with the “SceneManager”. The last thing on the check-list is the new “PhysicsObject” class. Add a new class in the “Models” folder called “PhysicsObject” and add in the following namespaces:

using BEPUphysics.Entities;
using BEPUphysics.Entities.Prefabs;
using BEPUphysics.MathExtensions;
using Microsoft.Xna.Framework;
using ProjectVanquish.Core;

Make the class public abstract:

public abstract class PhysicsObject

Declare the following variables:

bool movable = false;
Entity entity;
float mass = 1f;

Add a constructor:

public PhysicsObject(bool isMovable)
{
    movable = isMovable;
    InitializeEntity();
} 

In the constructor, we are declaring if the object is movable or static. We are also calling the “InitializeEntity” method. We have 2 methods to add:

protected void InitializeEntity()
{
    entity = new Box(Vector3.Zero, 0f, 0f, 0f, mass);
    SceneManager.PhysicsManager.PhysicsObjects.Add(this);
}

public void Remove()
{
    entity.Space.Remove(entity);
    SceneManager.PhysicsManager.PhysicsObjects.Remove(this);
}

The first initializes a new “Box” object entity and adds it to the “PhysicsManager” list, whilst the second removes the object. That’s all for now with this class. We will be returning to it to add properties later on, but for now, you have successfully integrated BEPU Physics into the engine.

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

interface IEntity
{
    BoundingBox BoundingBox { get; }

    Model Model { get; set; }

    Vector3 Position { get; set; }

    Vector3 Rotation { get; set; }

    Vector3 Scale { get; set; }
}

That’s all we need for the interface. Now we just need to hook that up with the “Actor” class. Open the “Actor” class and change the class declaration to:

public class Actor : IEntity

We need to add in the new properties from the interface into our “Actor” class:

public BoundingBox BoundingBox 
{ 
    get { return new BoundingBox(Position - Scale / 2f, Position + Scale / 2f); }
}

public Vector3 Position 
{ 
    get { return position; } 
    set { position = value; } 
}

public Vector3 Rotation 
{ 
    get { return rotation; } 
    set { rotation = value; } 
}

public Vector3 Scale 
{ 
    get { return scale; } 
    set { scale = value; } 
}

That’s it. We now have a calculated BoundingBox for our model which will come in handy when we introduce the Physics part of the engine.

SSAO Off:

SSAO On:

The idea behind the “CameraManager” class was to allow multiple cameras to be instantiated and used. Before, everything was hard-coded to a “FirstPersonCamera” and now the camera classes inherit from a new “ICamera” interface. This allows for a camera class to be passed through the engine without actually knowing what type of camera it is. The new “CameraManager” class sits inside of the “Core” folder. It has 4 simple methods which allow you to add, remove, set and get a camera. The “SceneManager” class has been altered to automatically create a “FirstPersonCamera” and assigns a name of “Default”. I’ll quickly run through the new methods:

public static void AddCamera(string name, ICamera camera);

“AddCamera” allows you to add a new camera. As it’s a static method (and so are the other methods), you use it like:

CameraManager.AddCamera("Camera1", new PerspectiveCamera(MathHelper.PiOver2, 
                                                         GraphicsDevice.Viewport.AspectRatio, 
                                                         1.0f, 100.0f)); 

public static ICamera GetActiveCamera();

“GetActiveCamera” does exactly what it says, it will return the camera that is currently set as active. If no camera is found, then it will throw an exception.

public static void RemoveCamera(string name);

“RemoveCamera” will remove the camera with the specified name.

public static void SetActiveCamera(string name);

“SetActiveCamera” will assign the active camera to the specified name. If the specified camera name does not exist in the camera collection, it will throw an exception.

That is pretty much it. Just a quick summary post of the new class. I would download the latest changeset to see the implications that the new class has had on the structure of the engine. Thanks to the new interface “ICamera”, passing cameras between renderers is now a lot easier.

In the “ProjectVanquish” project, create a new folder called “Models” and in there create a new class called “Actor”. Make the class public. Also, add the following namespaces:

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

We’ll add a couple of variables:

Model model;
Vector3 position, rotation, scale; 

So, we’ll store a Model and its position, rotation and scale. Simple enough. We’ll add a default constructor:

public Actor(Model model)
{
    this.model = model;
    position = Vector3.Zero;
    rotation = Vector3.Zero;
    scale = Vector3.One;
}

We’ll use this in our “SceneManager” class, but we’ll be adding 3 more constructor for completeness.

public Actor(Model model, Vector3 position)
{
    this.model = model;
    this.position = position;
    rotation = Vector3.Zero;
    scale = Vector3.One;
} 

public Actor(Model model, Vector3 position, Vector3 rotation)
{
    this.model = model;
    this.position = position;
    this.rotation = rotation;
    scale = Vector3.One;
} 

public Actor(Model model, Vector3 position, Vector3 rotation, Vector3 scale)
{
    this.model = model;
    this.position = position;
    this.rotation = rotation;
    this.scale = scale;
} 

So, you can see that we are allowing for the alterations of the Position, Rotation and Scale. I would like to have used Optional Parameters, but I can’t use Vector3.Zero as it’s a runtime constant and not compile-time.

To finish the class, we’ll add a couple of properties:

public Model Model
{
    get { return model; }
}

public Matrix World
{
    get
    {
        return Matrix.CreateTranlsation(position) * Matrix.CreateScale(scale)
             * Matrix.CreateRotationX(rotation.X) * Matrix.CreateRotationY(rotation.Y)
             * Matrix.CreateRotationZ(rotation.Z);
    }
}

That’s the new “Actor” class finished for the time being. All that is left is to alter the “SceneManager” class to cater for the new class. We will need to add our new namespace:

using ProjectVanquish.Models;

Then we’ll start with the Models variable:

static IList<Actor> models;

Amend the declaration in the constructor:

models = new List<Actor>();

We need to modify the Property:

public IList<Actor> Models
{
    get { return models; }
}

Now, we just need to modify the Members and we finished with the “ProjectVanquish” project:

public static void AddModel(Model model)
{
    models.Add(new Actor(model));
}

public void Draw()
{
    // RenderStates etc. here

    foreach (Actor actor in models)
        DrawModel(actor.Model, actor.World, camera);
}

The last change to make is to the Draw with Effect member. The change is basically going from:

for (int j = 0; j < models[i].Meshes.Count; j++)


Model mesh = models[i].Meshes[j];

to

for (int j = 0; j < models[i].Model.Meshes.Count; j++)


Model mesh = models[i].Model.Meshes[j];

Lastly, there is the Matrix that will need to be altered:

Matrix world = models[i].World;

That’s all. We have enabled 4 constructors in the “Actor” class, but we don’t have any means of using 3 of them. We’ll create the “AddModel” methods in the “SceneManager” class, just copy and paste the below:

public static void AddModel(Model model, Vector3 position)
{
    models.Add(new Actor(model, position));
}

public static void AddModel(Model model, Vector3 position, Vector3 rotation)
{
    models.Add(new Actor(model, position, rotation));
}

public static void AddModel(Model model, Vector3 position, Vector3 rotation, Vector3 scale)
{
    models.Add(new Actor(model, position, rotation, scale));
}

You’ll be able to use these new methods in the “Game1″ class. That’s all for now. Will carry on banging head against keyboard until Shadow Mapping is working.

Project Vanquish on Codeplex

I had a slight tidy up of the source code as well. I’ve also altered the way that you add a Model. The “SceneManager” class is now public and “AddModel” is now static, allowing you to add a model using the following code:

SceneManager.AddModel(Content.Load<Model>("Models/Sponza"));

I’ll carry on implementing new things whilst tidying up some more. One point that has been highlighted from the tidy up, is the need for a Model class. I’ll think about doing this next, but would love to get the shadows working first.

Some planned items for the future are to include physics, some form of Anti-Aliasing and some more post processing such as Depth of Field.

Now that’s out of the way, let’s create the “Bloom” class. Add a new class to the “PostProcessing” folder in the “ProjectVanquish” project and name it “Bloom”.

Add the following namespaces:

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

Now we can add our variables:

Effect bloomEffect, blurEffect, finalEffect;
RenderTarget2D bloomRT, blurHRT, blurVRT;
QuadRenderer fullscreenQuad;

Nothing out of the ordinary there. Moving onto the constructor, we will instantiate these new variables ready for use in the “Draw” method:

public Bloom(GraphicsDevice device, ContentManager content)
{
    bloomEffect = content.Load<Effect>("Shaders/PostProcessing/Bloom/Bloom");
    blurEffect = content.Load<Effect>("Shaders/PostProcessing/Bloom/Blur");
    finalEffect = content.Load<Effect>("Shaders/PostProcessing/Bloom/Final");

    bloomRT = new RenderTarget2D(device, device.PresentationParameters.BackBufferWidth,
                             device.PresentationParameters.BackBufferHeight,
                             false, SurfaceFormat.Color, DepthFormat.None);
    blurHRT = new RenderTarget2D(device, device.PresentationParameters.BackBufferWidth, 
                             device.PresentationParameters.BackBufferHeight,
                             false, SurfaceFormat.Color, DepthFormat.None);
    blurVRT = new RenderTarget2D(device, device.PresentationParameters.BackBufferWidth, 
                             device.PresentationParameters.BackBufferHeight,
                             false, SurfaceFormat.Color, DepthFormat.None);

    fullscreenQuad = new QuadRenderer(device);
}

We’ll finish off the class before we create our new Effects. We’ll create our last method for the class, “Draw”. In this code, we’ll take our RenderTarget output from the “SSAORenderer” and we’ll apply a two pass blur and then combine the final result:

public void Draw(GraphicsDevice device, RenderTarget2D sceneRT)
{
    // Bloom pass
    device.SetRenderTarget(bloomRT);
    device.Clear(Color.Black);
    device.Textures[0] = sceneRT;
    bloomEffect.CurrentTechnique.Passes[0].Apply();
    fullscreenQuad.Draw();
    device.SetRenderTarget(null);

    // Horizontal pass
    device.SetRenderTarget(blurHRT);
    device.Clear(Color.Black);
    device.Textures[0] = bloomRT;
    blurEffect.CurrentTechnique.Passes[0].Apply();
    fullscreenQuad.Draw();
    device.SetRenderTarget(null);

    // Vertical pass
    device.SetRenderTarget(blurVRT);
    device.Clear(Color.Black);
    device.Textures[0] = blurHRT;
    blurEffect.CurrentTechnique.Passes[0].Apply();
    fullscreenQuad.Draw();
    device.SetRenderTarget(null);

    // Final pass
    device.Clear(Color.Black);
    device.Textures[0] = blurVRT;
    finalEffect.Parameters["ColorMap"].SetValue(sceneRT);
    finalEffect.CurrentTechnique.Passes[0].Apply();
    fullscreenQuad.Draw();
}

That is the “Bloom” class complete. We’ll quickly add this to the “DeferredRenderer” class so we can then move onto the Effects. In the “DeferredRenderer” class, declare the namespace:

using ProjectVanquish.Renderers.PostProcessing;

Now we can declare two new variables:

RenderTarget2D bloomRT;
Bloom bloom;

In the constructor, we can instantiate the new class:

bloomRT = new RenderTarget2D(device, backbufferWidth, backbufferHeight, false, 
                             SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
bloom = new Bloom(device, content);

Lastly, we just need to add the “Draw” call in the “Draw” method. We also need to alter the “SSAORenderer” call:

ssaoRenderer.Draw(device, renderTargets, sceneRT, sceneManager, bloomRT);
bloom.Draw(device, bloomRT);

That’s all of the class code complete. Now we can move onto the Shaders, starting with the “Bloom”. Create a new Effect file in the “Bloom” folder called “Bloom”. Remove all default contents and replace with the following:

sampler TextureSampler : register(s0);

float Threshold = 0.3;

float4 PixelShaderFunction(float2 texCoord : TEXCOORD0) : COLOR0
{
    float4 Color = tex2D(TextureSampler, texCoord);
    
    // Get the bright areas that is brighter than Threshold and return it.
    return saturate((Color - Threshold) / (1 - Threshold));
}

technique Bloom
{
    pass Pass1
    {
        PixelShader = compile ps_3_0 PixelShaderFunction();
    }
}

Quite straight forward. It gets the bright areas that are brighter than the Threshold and saturates it. Create a new file called “Blur” and remove the default contents. Replace with:

// The blur amount( how far away from our texel will we look up neighbour texels? )
float BlurDistance = 0.003f;

// This will use the texture bound to the object( like from the sprite batch ).
sampler ColorMapSampler : register(s0);
 
float4 PixelShaderFunction(float2 Tex: TEXCOORD0) : COLOR
{
    float4 Color;
 
    // Get the texel from ColorMapSampler using a modified texture coordinate. This
    // gets the texels at the neighbour texels and adds it to Color.
	Color  = tex2D( ColorMapSampler, float2(Tex.x+BlurDistance, Tex.y+BlurDistance));
	Color += tex2D( ColorMapSampler, float2(Tex.x-BlurDistance, Tex.y-BlurDistance));
	Color += tex2D( ColorMapSampler, float2(Tex.x+BlurDistance, Tex.y-BlurDistance));
	Color += tex2D( ColorMapSampler, float2(Tex.x-BlurDistance, Tex.y+BlurDistance));
    // We need to devide the color with the amount of times we added
    // a color to it, in this case 4, to get the avg. color
    Color = Color / 4; 
 
    // returned the blurred color
    return Color;
}

technique Blur
{
	pass Pass1
	{
		PixelShader = compile ps_3_0 PixelShaderFunction();
	}
}

This will apply a Blur effect to the RenderTarget. Lastly, we create a new Effect file called “Final”. Once again, remove the default contents and replace with:

sampler BloomSampler : register(s0);

// Our original SceneTexture
texture ColorMap;

// Create a sampler for the ColorMap texture using lianear filtering and clamping
sampler ColorMapSampler = sampler_state
{
   Texture = <ColorMap>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;   
   AddressU  = Clamp;
   AddressV  = Clamp;
};

// Controls the Intensity of the bloom texture
float BloomIntensity = 1.3;

// Controls the Intensity of the original scene texture
float OriginalIntensity = 1.0;

// Saturation amount on bloom
float BloomSaturation = 1.0;

// Saturation amount on original scene
float OriginalSaturation = 1.0;

float4 AdjustSaturation(float4 color, float saturation)
{
    // We define gray as the same color we used in the grayscale shader
    float grey = dot(color, float3(0.3, 0.59, 0.11));
    
    return lerp(grey, color, saturation);
}

float4 PixelShaderFunction(float2 texCoord : TEXCOORD0) : COLOR0
{
	// Get our bloom pixel from bloom texture
	float4 bloomColor = tex2D(BloomSampler, texCoord);

	// Get our original pixel from ColorMap
	float4 originalColor = tex2D(ColorMapSampler, texCoord);
    
    // Adjust color saturation and intensity based on the input variables to the shader
	bloomColor = AdjustSaturation(bloomColor, BloomSaturation) * BloomIntensity;
	originalColor = AdjustSaturation(originalColor, OriginalSaturation) * OriginalIntensity;
    
    // make the originalColor darker in very bright areas, avoiding these areas look burned-out
    originalColor *= (1 - saturate(bloomColor));
    
    // Combine the two images.
    return originalColor + bloomColor;
}

technique BloomFinal
{
    pass Pass1
    {
        PixelShader = compile ps_3_0 PixelShaderFunction();
    }
}

This combines the bloom texture with the original scene texture. BloomIntensity, OriginalIntensity, BloomSaturation and OriginalSaturation is used to control the blooming effect. This Bloom effect is based on the sample found at create.msdn.com.

In the screenshot below, I’ve added an extra 2 Point Lights: