In this tutorial we are going to create a component predicate, a class used to determine whether or not a component will be used for an action. This is useful for things like special drawing, for example when drawing shadows we only want shadow casters to draw when creating the shadow map.

Side note: I apologize ahead of time but nothing cool is going to happen during this tutorial. By the end of this tutorial, you will have exactly the same results. But they will be better.

// Provides a way for the engine to let the game tell it what to
// draw, instead of the somewhat limited ComponentType
public abstract class ComponentPredicate
{
    // Decides whether the specified component is eligible for the
    // action being done
    public abstract bool IsComponentEligible(Component Component);
}

// Basic ComponentPredicate that uses ComponentType to determine
// what components to use
public class ComponentTypePredicate : ComponentPredicate
{
    // The type of component to accept
    ComponentType Type;

    // Accepts a ComponentType to use to determine what
    // components will be accepted
    public ComponentTypePredicate(ComponentType Type)
    {
        this.Type = Type;
    }

    public override bool IsComponentEligible(Component Component)
    {
        if (Type == ComponentType.Both)
        {
            // If the render type is both, we will use all 2D or
            // 3D components
            if (Component is I2DComponent || Component is I3DComponent)
                return true;
        }
        else if (Type == ComponentType.Component2D)
        {
            // If the render type is 2D, we will only use 2D
            // components
            if (Component is I2DComponent)
                return true;
        }
        else if (Type == ComponentType.Component3D)
        {
            // If the render type is 3D, we will only use 3D
            // components
            if (Component is I3DComponent)
                return true;
        }
        else
        {
            // Otherwise, we will use every component regardless of type
            return true;
        }

        // If the conditions have not been met, we will not use the
        // component
        return false;
    }
}

Now we can update GameScreen to use it:

// Draw the screen and its components. Accepts a ComponentPredicate
// to tell us what kind of components to draw.
public virtual void Draw(ComponentPredicate DrawPredicate)
{
    // Temporary list of components to draw
    List<Component> drawing = new List<Component>();

    foreach (Component component in Components.InDrawOrder)
        if (DrawPredicate.IsComponentEligible(component))
            drawing.Add(component);

    // Keep a list of components that are 2D so we can draw them on top
    // of the 3D components
    List<Component> defer2D = new List<Component>();

    foreach (Component component in drawing)
        if (component.Visible && component.Initialized)
            // If the component is visible
            if (component is I2DComponent)
                // If it is 2D, wait to draw
                defer2D.Add(component);
            else
                // otherwise, draw immediately
                component.Draw();

    // Draw 2D components
    foreach (Component component in defer2D)
        component.Draw();
}

And finally update Engine to use it:

// ComponentType to render
public static void Draw(GameTime gameTime, ComponentPredicate DrawPredicate)
{
    // Update the time, create a temp list
    Engine.GameTime = gameTime;
    List<GameScreen> drawing = new List<GameScreen>();

    // Clear the back buffer
    GraphicsDevice.Clear(Color.CornflowerBlue);

    // Populate the temp list if the screen is visible
    foreach (GameScreen screen in GameScreens)
        if (screen.Visible)
            drawing.Add(screen);

    // BlocksDraw and OverrideDrawBlocked logic
    for (int i = GameScreens.Count - 1; i >= 0; i--)
        if (GameScreens[i].BlocksDraw)
        {
            if (i > 0)
                for (int j = i - 1; j >= 0; j--)
                {
                    if (!GameScreens[j].OverrideDrawBlocked)
                        drawing.Remove(GameScreens[j]);
                }

            break;
        }

    // Draw the remaining screens
    foreach (GameScreen screen in drawing)
        if (screen.Initialized)
            screen.Draw(DrawPredicate);
}

public static void Draw(GameTime gameTime, ComponentType DrawType)
{
    Draw(gameTime, new ComponentTypePredicate(DrawType));
}

Now run it and you should see that nothing changed at all. At least, hopefully you do. If not, something went wrong.

The second part of this tutorial is on materials. A material defines how an object should be drawn. They define properties like specularity, texture, color, emmisive light, bump map, etc. The materials we will make right now only define texture, but they can be expanded in the future. Here is the base Material class:

// Base Material class keeps track of an effect and handles basic
// properties for it
public class Material : Component
{
    // The effect to handle
    Effect effect;

    public virtual Effect Effect
    {
        get { return effect; }
        set { effect = value; }
    }

    // Sets up the material from the values embedded in a MeshPart
    public virtual Material CreateFromMeshPart(ModelMeshPart MeshPart)
    {
        this.effect = MeshPart.Effect;
        return this;
    }

    // Set World, View, and Projection values
    public virtual void Prepare3DDraw(Matrix World)
    {
        effect.Parameters["World"].SetValue(World);
        effect.Parameters["View"].SetValue(
            Engine.Services.GetService<Camera>().View);
        effect.Parameters["Projection"].SetValue(
            Engine.Services.GetService<Camera>().Projection);
    }
}

Now we will expand this to make a material that supports texturing called TexturedMaterial:

// Material that handles a texture
public class TexturedMaterial : Material
{
    // The texture to keep track of
    Texture2D texture;

    // Set accesor sets the texture to the underlying effect
    public virtual Texture2D Texture
    {
        get { return texture; }
        set { texture = value; SetTextureToEffect(Effect, texture); }
    }

    public override Effect Effect
    {
        get { return base.Effect; }
        set
        {
            SetTextureToEffect(value, GetTextureFromEffect(base.Effect));
            base.Effect = value;
        }
    }

    // Override gets the texture from the MeshPart
    public override Material CreateFromMeshPart(ModelMeshPart MeshPart)
    {
        base.CreateFromMeshPart(MeshPart);
        this.texture = GetTextureFromEffect(MeshPart.Effect);
        return this;
    }

    // Method to get texture from various types of effect
    internal static Texture2D GetTextureFromEffect(Effect Effect)
    {
        if (Effect == null)
            return null;

        if (Effect is BasicEffect)
            return ((BasicEffect)Effect).Texture;
        else if (Effect.Parameters["Texture"] != null)
            return Effect.Parameters["Texture"].GetValueTexture2D();

        return null;
    }

    // Method to set the texture to various types of effect
    internal static void SetTextureToEffect(Effect Effect, Texture2D Texture)
    {
        if (Effect == null)
            return;

        if (Effect is BasicEffect)
            ((BasicEffect)Effect).Texture = Texture;
        else if (Effect.Parameters["Texture"] != null)
            Effect.Parameters["Texture"].SetValue(Texture);
    }
}

The final material we will make is called MeshPartMaterial. This class can be used by classes like Actor to handle the material properties of a ModelMeshPart, contained in a Model:

// Handles setting effect and texture to a MeshPart
public class MeshPartMaterial : TexturedMaterial
{
    ModelMeshPart meshPart;

    public ModelMeshPart MeshPart
    {
        get { return meshPart; }
        set { meshPart = value; value.Effect = Effect; }
    }

    public override Effect Effect
    {
        get { return base.Effect; }
        set { SetTextureToEffect(value, GetTextureFromEffect(base.Effect)); base.Effect = value; MeshPart.Effect = value; }
    }

    public override Material CreateFromMeshPart(ModelMeshPart MeshPart)
    {
        base.CreateFromMeshPart(MeshPart);
        this.meshPart = MeshPart;
        return this;
    }
}

Now we can update the Actor class to use MeshPartMaterial:

// In the top of the class:

public Dictionary<ModelMeshPart, Material> Materials = new Dictionary<ModelMeshPart, Material>();

// In Setup()

foreach (ModelMesh mesh in Model.Meshes)
    foreach (ModelMeshPart part in mesh.MeshParts)
        Materials.Add(part, new MeshPartMaterial().CreateFromMeshPart(part));

// In the Draw() method:

// Loop through meshes and effects and set them up to draw
foreach (ModelMesh mesh in model.Meshes)
{
    foreach (ModelMeshPart part in mesh.MeshParts)
        Materials[part].Prepare3DDraw(world);

    // Draw the mesh
    mesh.Draw();
}

Now if you hit F5 and spawn a box (left click if you have been following the tutorials in order), you should see.. exactly the same thing. I know, not very exciting, but at least it’s working! We’ll get to more advanced stuff later.

Now lets do the same thing for Terrain:

// Material for a Terrain object
public class TerrainMaterial : TexturedMaterial
{
    public TerrainMaterial(Texture2D Texture)
        : base()
    {
        this.Effect = new BasicEffect(Engine.GraphicsDevice, null);
        this.Texture = Texture;

        SetupEffect();
    }

    // Setup BasicEffect
    private void SetupEffect()
    {
        BasicEffect basicEffect = (BasicEffect)this.Effect;

        basicEffect.Texture = Texture;
        basicEffect.TextureEnabled = true;
        basicEffect.EnableDefaultLighting();
        basicEffect.DirectionalLight0.Direction = new Vector3(1, -1, 1);
        basicEffect.DirectionalLight0.Enabled = true;
        basicEffect.AmbientLightColor = new Vector3(0.3f, 0.3f, 0.3f);
        basicEffect.DirectionalLight1.Enabled = false;
        basicEffect.DirectionalLight2.Enabled = false;
        basicEffect.SpecularColor = new Vector3(0, 0, 0);
    }

    public override void Prepare3DDraw(Matrix World)
    {
        base.Prepare3DDraw(World);

        Engine.GraphicsDevice.SamplerStates[0].AddressU = TextureAddressMode.Wrap;
        Engine.GraphicsDevice.SamplerStates[0].AddressV = TextureAddressMode.Wrap;
    }
}

All this does right now is keep track of the texture and create the effect, but we will extend it later on for effect like multitexturing. Now change terrain:

// Replaces Effect and Texture properties

// Material
public TerrainMaterial Material;

// Remove the following from Setup()

basicEffect = new BasicEffect(Engine.GraphicsDevice, null);
SetupEffect();

// Add to Setup()

Material = new TerrainMaterial(Texture);

private float[,] CreateTerrain(Texture2D heightMap, Texture2D texture)

// Becomes

private float[,] CreateTerrain(Texture2D heightMap)

// Remove from CreateTerrain()

this.texture = texture;

// Update the Draw() method

// Draw the terrain
public override void Draw()
{
    // Require the camera
    Camera camera = Engine.Services.GetService<Camera>();
    if (camera == null)
        throw new Exception("The engine services does not contain a "
        + "camera service. The terrain requires a camera to draw.");

    // Set effect values
    Material.Prepare3DDraw(MathUtil.CreateWorldMatrix(
        Position, Rotation, Scale));

    // Get width and height
    int width = heightData.GetLength(0);
    int height = heightData.GetLength(1);

    // Terrain uses different vertex winding than normal models,
    // so set the new one
    Engine.GraphicsDevice.RenderState.CullMode = CullMode.CullClockwiseFace;

    // Start the effect
    Material.Effect.Begin();

    // For each pass..
    foreach (EffectPass pass in Material.Effect.CurrentTechnique.Passes)
    {
        // Begin the pass
        pass.Begin();

        // Draw the terrain vertices and indices
        Engine.GraphicsDevice.Vertices[0].SetSource(terrainVertexBuffer, 0,
            VertexPositionNormalTexture.SizeInBytes);
        Engine.GraphicsDevice.Indices = terrainIndexBuffer;
        Engine.GraphicsDevice.VertexDeclaration = myVertexDeclaration;
        Engine.GraphicsDevice.DrawIndexedPrimitives(
            Microsoft.Xna.Framework.Graphics.PrimitiveType.TriangleStrip,
            0, 0, width * height, 0, width * 2 * (height - 1) - 2);

        // End the pass
        pass.End();
    }

    // End the effect
    Material.Effect.End();

    // Set the vertex winding back
    Engine.GraphicsDevice.RenderState.CullMode =
        CullMode.CullCounterClockwiseFace;
}

Now, run it, and again you should see the same thing you did before. Once, again, thrilling, but we’ll make it cooler in the future.

Thats it for this tutorial!

Download the Code for this Chapter
Back to Game Engine Tutorial Series