Science Fact Work of Ben Johnson

Hardware Geometry Instancing in XNA 4

The Reason

First let me give you a bit of a back story on why my game uses hardware geometry instancing. Recently while developing my game I have come across the need for a little bit more detailed objects than cubes. Such as grass, tables and lanterns. The nature of my game means that players can spam the world full of these objects. Which in turn means I need a pretty fast way to draw many of the same meshes at different positions and some other object specific attributes such as lighting data. Without the massive performance loss from drawing them all individually. Drawing them individually would be slow because it would be a draw call per object. If I have 1000 copies of this object on screen. That is 1000 draw calls for drawing that one object in many places, which is a lot of resending of data to the GPU. Now, before I tried hardware instancing. I tried a bit of a different method that was a lot more memory intensive for both GPU and RAM but reduces the draw calls dramatically. Essentially what I did was per chunk(my game world is split into 32x32 chunks) have a vertex buffer and index buffer for each unique object(i.e. grass, lanterns, ducks statues) and store all the vertices and indices for each location where the object was positioned. This meant that drawing a unique mesh on each Chunk was one draw call. But it was also storing  many copies of the models vertices and indices to display the object in many different places. On top of this it was quite slow to rebuild the buffer when I wanted to add or remove a location for the mesh to be shown. As it would have to re-offset many indices and add/remove many of the vertices for either operation. This fast became a terrible idea.

So I began to look at a better instancing method to display thousands of copies of meshes with as little data and draw calls as possible. With some research I found Shawn Shawn Hargreaves's post on the DrawInstancedPrimitives method within XNA. This was added in XNA 4.0 and makes Hardware instancing a much nicer affair within XNA than it was in preceding versions. Essentially what it allows you to do is send two vertex buffers bound together to the GPU rather than one. Why would you want to do that? Well the second vertex buffer contains attributes that are unique per instance. Rather than per vertex. They come through to your Effect in the same way with the rest of the vertex data(like Position, TextureCoords etc) which makes it really simple on the Effect side of things. On a basic level you can send a list of world matrices in the second buffer and transform the vertex positions from the first buffer to position many different instances around your world. As DrawInstancedPrimitives basically runs through the number of instances supplied and assigns the vertex data from the second buffer to that instance.

The Tutorial

So lets jump right in and see how this works in code. If my above explanation didn't make it very clear, don't worry hopefully this will! But fair warning this tutorial is meant for those who have at least some experience in 3D rendering with XNA. First of all you'll want to create a new project to try this in. Since we're drawing things in 3D we'll need a basic camera class so we can supply the view and projection matrices properly to our mesh. You'll probably have your own camera class but if you don't here's a very simple one you can drop into your project to use:

    public class FreeCamera
    {
        protected Matrix ViewMatrix;
        protected Matrix ProjectionMatrix;
        protected Matrix RotationMatrix;
        protected GraphicsDevice Device;
        Vector3 _Target;
        Vector3 _Position;
        Vector3 _Rotation;
        Vector3 _Up;
        protected float Speed;
        float _Near;
        float _Far;

        public Matrix View { get { return ViewMatrix; } }
        public Matrix Projection { get { return ProjectionMatrix; } }
        public float NearClip { get { return _Near; } }
        public float FarClip { get { return _Far; } }

        MouseState OriginalMouse;

        public FreeCamera(GraphicsDevice device, Vector3 position, Vector3 target, float aspectRatio, float near, float far)
        {
            Position = position;
            Rotation = new Vector3(0, 0, 0);
            Target = target;
            Speed = 30;
            _Near = near;
            _Far = far;
            Device = device;
            _Up = new Vector3(0, 1, 0);

            Speed = 100f;
            Rotation = new Vector3(0, 0, 0);
            OriginalMouse = Mouse.GetState();

            // Setup FOV, aspect ratio and clipping planes
            ProjectionMatrix = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, near, far);

            UpdateView();
        }

        // On changing position change viewmatrix
        public Vector3 Position
        {
            get { return _Position; }
            set
            {
                _Position = value;
                UpdateView();
            }
        }

        public Vector3 Target
        {
            get { return _Target; }
            set
            {
                _Target = value;
                ViewMatrix = Matrix.CreateLookAt(Position, Target, new Vector3(0, 1, 0));
            }
        }

        public Vector3 Rotation
        {
            get { return _Rotation; }
            set
            {
                _Rotation = value;
                RotationMatrix = Matrix.CreateRotationX(_Rotation.X) * Matrix.CreateRotationY(_Rotation.Y);
                UpdateView();
            }
        }

        public Matrix World
        {
            get
            {
                return Matrix.CreateTranslation(Position.X, Position.Y, Position.Z)
               * Matrix.CreateRotationX(_Rotation.X)
               * Matrix.CreateRotationY(_Rotation.Y)
               * Matrix.CreateRotationZ(_Rotation.Z);
            }
        }

        public void UpdateView()
        {
            Vector3 cameraOriginalTarget = new Vector3(0, 0, -1);
            Vector3 cameraRotatedTarget = Vector3.Transform(cameraOriginalTarget, RotationMatrix);
            Vector3 cameraFinalTarget = Position + cameraRotatedTarget;

            Vector3 cameraRotatedUpVector = Vector3.Transform(_Up, RotationMatrix);

            ViewMatrix = Matrix.CreateLookAt(Position, cameraFinalTarget, cameraRotatedUpVector);
        }

        public virtual void Move(Vector3 vector)
        {
            // Move the cameras position based on the way its facing
            Vector3 rotatedVector = Vector3.Transform(vector, RotationMatrix);
            Position += Speed * rotatedVector;
        }

        public virtual void Update(GameTime time)
        {
            // Free movement
            float dt = (float)time.ElapsedGameTime.Milliseconds / 1000f;
            // Rotation
            MouseState currentMouseState = Mouse.GetState();
            if (currentMouseState != OriginalMouse && Keyboard.GetState().IsKeyDown(Keys.Space))
            {
                Vector3 rotation = Rotation;
                float xDifference = currentMouseState.X - OriginalMouse.X;
                float yDifference = currentMouseState.Y - OriginalMouse.Y;
                rotation.Y -= 0.3f * xDifference * dt;
                rotation.X += 0.3f * yDifference * dt;
                Mouse.SetPosition(Device.Viewport.Width / 2, Device.Viewport.Height / 2);

                Rotation = rotation;
            }
            OriginalMouse = Mouse.GetState();

            // Key press movement
            KeyboardState keyboard = Keyboard.GetState();
            Vector3 direction = Vector3.Zero;
            if (Keyboard.GetState().IsKeyDown(Keys.W))
                Move(new Vector3(0, 0, -1) * dt);

            if (Keyboard.GetState().IsKeyDown(Keys.S))
                Move(new Vector3(0, 0, 1) * dt);

            if (Keyboard.GetState().IsKeyDown(Keys.A))
                Move(new Vector3(-1, 0, 0) * dt);

            if (Keyboard.GetState().IsKeyDown(Keys.D))
                Move(new Vector3(1, 0, 0) * dt);
        }

        public virtual string DebugInfo()
        {
            return "Camera Position: " + Position.ToString();
        }
    }

So with the camera class added we need to create a instance of the Camera within our Game1 class. If your using my Camera class just add it as a member to the Game1 class and initialize it in LoadContent() with:

Camera = new FreeCamera(GraphicsDevice, new Vector3(0, 10, 0), Vector3.Zero, GraphicsDevice.Viewport.AspectRatio, 0.1f, 1000f);

As well as adding Camera.Update(gameTime) to Game1's Update method. This is the camera setup and ready to go.

The first thing we're going to need is an actual mesh to instance. For this tutorial I'll be using a Christmas Duck created by Harm Delva. Which you can download at the end of the tutorial in the finished project (HardwareInstancingExample). Once you have your mesh, add it and it's texture to the Content project. The next step is to load the mesh in and grab all its vertices and indices and put them in a vertex and index buffer of our own. This way we can get at them easily when it comes down to sending it to the GPU to be instanced rather than cycling through mesh parts. To do this you can use the following method I wrote which will work on meshes with 16bit indices. Such as our example Duck. We also want to create a seperate class called InstancedModel so its easily reusable on different Models. So create a new Class file called "InstancedModel.cs" in your project and drop the below code inside:

    class InstancedModel
    {
        VertexBuffer VertexBuffer;
        IndexBuffer IndexBuffer;
        Texture2D Texture;

        public InstancedModel(Model model, Texture2D texture, GraphicsDevice device)
        {
            Texture = texture;

            // Get array of vertices and indices from model
            VertexPositionNormalTexture[] vertices = null;
            ushort[] indices = null;

            GetModelVerticesAndIndices(model, out vertices, out indices);

            // Create buffers from them to use when drawing
            VertexBuffer = new VertexBuffer(device, VertexPositionNormalTexture.VertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
            VertexBuffer.SetData (vertices);
            IndexBuffer = new IndexBuffer(device, IndexElementSize.SixteenBits, indices.Length, BufferUsage.WriteOnly);
            IndexBuffer.SetData(indices);
        }

        public void Update()
        {

        }

        public void Draw(Matrix view, Matrix projection)
        {

        }

        ///
<summary> /// Gets vertices and indices making up a Model.
 /// </summary>
        ///
        ///
        ///
        private void GetModelVerticesAndIndices(Model model, out VertexPositionNormalTexture[] vertices, out ushort[] indices)
        {
            List verticesList = new List();
            List indicesList = new List();

            foreach (ModelMesh mesh in model.Meshes)
                foreach (ModelMeshPart part in mesh.MeshParts)
                {
                    // Go through mesh parts building up a list of vertices and indices used for each part.
                    VertexPositionNormalTexture[] partVerts = new VertexPositionNormalTexture[part.VertexBuffer.VertexCount];
                    part.VertexBuffer.GetData(partVerts);

                    ushort[] partIndices = new ushort[part.IndexBuffer.IndexCount];
                    part.IndexBuffer.GetData(partIndices);
                    indicesList.AddRange(partIndices);

                    verticesList.AddRange(partVerts);

                }

            vertices = verticesList.ToArray();
            indices = indicesList.ToArray();
        }
    }

Nothing crazey going on here. We are just defining the class for our Instanced Models. We have a vertex and index buffer ready for the models information and a method to get them from the model. With a constructor that populates the data for us and an Update and Draw method that we will fill up shortly. But before we go any further we need to create a instance of this in our Game1 class so go ahead and create a member called InstancedModel InstanceMode in the Game1 class and initialize it in the LoadContent method like so:

        ///
<summary> /// LoadContent will be called once per game and is the place to load
 /// all of your content.
 /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            Camera = new FreeCamera(GraphicsDevice, new Vector3(1.5f, 0, -10), Vector3.Zero, GraphicsDevice.Viewport.AspectRatio, 0.01f, 1000f);
            Camera.Target = new Vector3(1.5f, 0, 0);

            // TODO: use this.Content to load your game content here
            Model duckModel = Content.Load("snowduck");
            Texture2D texture = Content.Load("christmas");
            InstancedModel = new InstancedModel(duckModel, texture, GraphicsDevice);

        }

Also take this time to add InstancedModel.Update() and InstanceModel.Draw(Camera.View, Camera.Projection) to Game1's Update() and Draw() methods. This is probably a good time to compile and make sure there is no mistakes if you are following a long and not using the completed project. When running it will not show anything as we haven't started displaying our instances yet. Now onto the actual instancing. The first thing we need is a new custom vertex format. This will store data relevant to each instance of the model. For this tutorial I am simply going to store a World matrix and a Colour for each instance. So create a new class file called InstanceDataVertex and inside it paste this:

    public struct InstanceDataVertex
    {
        public Matrix World;
        public Color Colour;

        public InstanceDataVertex(Matrix world, Color colour)
        {
            World = world;
           Colour = colour;
        }

        public readonly static VertexDeclaration VertexDeclaration = new VertexDeclaration
            (
                // World Matrix Data
                 new VertexElement(0, VertexElementFormat.Vector4, VertexElementUsage.TextureCoordinate, 5),
                 new VertexElement(sizeof(float) * 4, VertexElementFormat.Vector4, VertexElementUsage.TextureCoordinate, 6),
                 new VertexElement(sizeof(float) * 8, VertexElementFormat.Vector4, VertexElementUsage.TextureCoordinate, 7),
                 new VertexElement(sizeof(float) * 12, VertexElementFormat.Vector4, VertexElementUsage.TextureCoordinate, 8),
                 //Colour Data
                 new VertexElement(sizeof(float) * 16, VertexElementFormat.Color, VertexElementUsage.Color, 0)

            );
    }

If you've not dealt with custom vertex formats before this will look like a bit of a strange beast. Vertex formats allow you to store your own data per vertex in order to send to your shader. Normally they would hold Position, Normal and Texture Coordinates but in this case we are holding the World matrix and colour of an instance. The VertexDeclaration basically tells XNA and the GPU what your vertices contain and the given offset within the vertex data in bytes to get to them. However there is no VertexElementFormat for 4x4 matrices. So instead we declare 4 vector4's which we will bring back into a Matrix within the Effect itself. If you'd like to know more about custom Vertex Formats in XNA you can look here for a nice explanation of them.
Now we have a format for our instances we need a second Vertex Buffer in our InstancedModel class. Which will hold the instance data vertices. We will also add some temporary vertex data so we know it is working when we come to draw it. So add these additions to the top of your InstancedModel class and you should get something like so:

        VertexBuffer VertexBuffer;
        IndexBuffer IndexBuffer;
        DynamicVertexBuffer InstancedVertexBuffer;
        Texture2D Texture;

        public InstancedModel(Model model, Texture2D texture, GraphicsDevice device)
        {
            Texture = texture;

            // Get array of vertices and indices from model
            VertexPositionNormalTexture[] vertices = null;
            ushort[] indices = null;

            GetModelVerticesAndIndices(model, out vertices, out indices);

            // Create buffers from them to use when drawing
            VertexBuffer = new VertexBuffer(device, VertexPositionNormalTexture.VertexDeclaration, vertices.Length, BufferUsage.WriteOnly);
            IndexBuffer = new IndexBuffer(device, IndexElementSize.SixteenBits, indices.Length, BufferUsage.WriteOnly);

            // Create temporary data
            // Duck is massive so create scale matrix
            Matrix scale = Matrix.CreateScale(0.2f, 0.2f, 0.2f);

            InstanceDataVertex[] data = new InstanceDataVertex[]
            {
                new InstanceDataVertex(scale * Matrix.CreateTranslation(new Vector3(0,0,0)), Color.Red),
                new InstanceDataVertex(scale * Matrix.CreateTranslation(new Vector3(1,0,0)), Color.Green),
                new InstanceDataVertex(scale * Matrix.CreateTranslation(new Vector3(2,0,0)), Color.Blue)
            };

            // Create instanced VertexBuffer with some temporary data
            InstancedVertexBuffer = new DynamicVertexBuffer(device, InstanceDataVertex.VertexDeclaration, data.Length, BufferUsage.None);
            InstancedVertexBuffer.SetData(data);
        }

All I am doing here is creating another vertex buffer as discussed above and populating it with some instance data. I create a matrix for this data giving each instance a  smaller scale as the model is fairly big, and giving them each a separate position and colour, so later we know they have different attributes. It is important to note also that I use a DynamicVertexBuffer rather than an ordinary VertexBuffer. This is because with a DynamicVertexBuffer you can use Set multiple times if you have the same amount of elements in your vertex data and it is much faster to recreate the buffer entirely when you add or remove an element. So we now have our two vertex buffers, one with the model's vertices, one with instance data and a index buffer of the model's indices. What's next? We need to write an Effect(or Shader) for it. So create a new Effect file in your Content project and call it InstanceEffect.fx. This effect will be very simple and be the following:

float4x4 View;
float4x4 Projection;

Texture Texture;
sampler TextureSampler = sampler_state { texture = ; magfilter = LINEAR; minfilter = LINEAR; mipfilter= LINEAR; AddressU = wrap; AddressV = wrap;};

struct VertexShaderInput
{
	// PER VERTEX DATA
    float4 Position : POSITION0;
	//float3 Normal : NORMAL0;
	float2 TextureCoords : TEXCOORD0;

	// PER INSTANCE DATA
	float4x4 World : TEXCOORD5;
	float4 Colour : COLOR0;
};

struct VertexShaderOutput
{
    float4 Position : POSITION0;
	float4 Colour : COLOR0;
	float2 TextureCoords: TEXCOORD0;
};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
    VertexShaderOutput output;

	// Use per instance World matrix to get World Pos
    float4 worldPosition = mul(input.Position, transpose(input.World));

	// Transform with camera view and projection to get screen pos
    float4 viewPosition = mul(worldPosition, View);
    output.Position = mul(viewPosition, Projection);

	// Send texture coords and per instance colour to pixel shader
	output.Colour =  input.Colour;
	output.TextureCoords = input.TextureCoords;

    return output;
}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
    // Get texture pixel
	float4 colour = tex2D(TextureSampler, input.TextureCoords);

	// Multiply by per instance colour value
	colour *= input.Colour;
    return colour;
}

technique Technique1
{
    pass Pass1
    {
        // TODO: set renderstates here.

        VertexShader = compile vs_3_0 VertexShaderFunction();
        PixelShader = compile ps_3_0 PixelShaderFunction();
    }
}

As you may notice there is a few changes between the default effect file and this one. So lets run through the changes top to bottom. First of all I have removed the World matrix parameter as the World matrix will be coming through our vertex data and not as a parameter. I have also added a Texture and TextureSampler which will receive the duck's texture and allow us to texture our instances with it.

VertexShaderInput has had a few parts added. As you can see I've split it into data that comes from the vertices of the model and data that comes from the InstanceVertexBuffer. We receive the Position, Normal and Texture Coordinates as you normally would with an Effect. However we also receive extra data from the InstanceVertexBuffer. Which is our per instance data. In this case we've sent through our World matrix(Remember all those texture coordinates in our Vertex Format? Well here they are back into a Matrix) and a colour for each instance of our ducky. With VertexShaderOutput we simply send relevant data to the PixelShader for it to do its work. Which is the colour and Texture Coordinates. For the vertex shader function the main thing that's changed is we now use input.World matrix to transform our vertex rather than a World matrix sent as a parameter. We also setup the output so our pixel shader gets the texture coordinates and colour it needs in order to correctly texture the mesh.

Forthe pixel shader we simply get the pixel we want from the texture then multiply it to get our per instance colour. Since we set each Instance data to have a different colour. The multiplying of the texture  colour with the colour will allow us to see different coloured instances. The last important part of this effect is vs_3_0 and ps_3_0. It is important to note that this kind of instancing requires shader model 3 in order to receive the combined vertex buffers. Now we're almost ready to draw! We just need to flesh out the draw method.

Before we write anything in the draw method. We must load the effect file we have just created. Simply create an Effect member called "Effect' in the InstancedModel class and load it in the Game1 class then pass it through InstancedModel's constructor with an extra parameter. The first and most simple thing we need to do in our InstancedModel's Draw method  is setup our shader parameters. Since their is only three. We only need to add the following which is the camera's view and projection matrices and the texture we want to apply to the mesh.

        public void Draw(Matrix view, Matrix projection)
        {
            // Setup effect parameters
            Effect.Parameters["View"].SetValue(view);
            Effect.Parameters["Projection"].SetValue(projection);
            Effect.Parameters["Texture"].SetValue(Texture);

            foreach (EffectPass pass in Effect.CurrentTechnique.Passes)
                pass.Apply();
        }

Now we need to set our vertex and index buffers for the GraphicsDevice. Since we have two vertex buffers we need to use VertexBufferBinding when setting the Devices vertex buffer. This binds their data together in order to be drawn on the per instance basis.

        public void Draw(Matrix view, Matrix projection)
        {
            // Setup effect parameters
            Effect.Parameters["View"].SetValue(view);
            Effect.Parameters["Projection"].SetValue(projection);
            Effect.Parameters["Texture"].SetValue(Texture);

            foreach (EffectPass pass in Effect.CurrentTechnique.Passes)
                pass.Apply();

            // Setup vertex buffers and index buffers for the device.
            GraphicsDevice device = Effect.GraphicsDevice;

            device.SetVertexBuffers(VertexBuffer, new VertexBufferBinding(InstancedVertexBuffer, 0, 1));
            device.Indices = IndexBuffer;

        }

Now we have the vertex buffers set. All we need to is draw it with DrawInstancedPrimitives(). Which is pretty similar to most of the other GraphicsDevice.Draw() methods except it takes an extra parameter on the end which is the amount of instances to be drawn. Which will be the vertex count of your InstancedVertexBuffer since that contains the data for each instance in it's stored vertices. So add the following code and you're ready to run!

        public void Draw(Matrix view, Matrix projection)
        {
            // Setup effect parameters
            Effect.Parameters["View"].SetValue(view);
            Effect.Parameters["Projection"].SetValue(projection);
            Effect.Parameters["Texture"].SetValue(Texture);

            // Setup vertex buffers and index buffers for the device.
            GraphicsDevice device = Effect.GraphicsDevice;

            device.SetVertexBuffers(VertexBuffer, new VertexBufferBinding(InstancedVertexBuffer, 0, 1));
            device.Indices = IndexBuffer;
            device.RasterizerState = RasterizerState.CullCounterClockwise;
            device.BlendState = BlendState.Opaque;

            foreach (EffectPass pass in Effect.CurrentTechnique.Passes)
                pass.Apply();

            device.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0, VertexBuffer.VertexCount, 0, IndexBuffer.IndexCount / 3, InstancedVertexBuffer.VertexCount);
        }

You should see 3 ducks which are tinted red, green and blue! If you have any problems, it'd be a good idea to scroll to the bottom and download the finished project and see what differs between your version and the finished one. Note if you used my camera class you can rotate the camera by holding space  while moving the mouse . You can also move the camera with WASD.

So we've got some ducks displaying with some unique properties. Colour and Translation. However the point of instancing is that you can have many meshes. As it only keeps the data for one copy of the mesh and a the individual data of each instance. So lets go ahead and add a couple of thousand more ducks in. Earlier we created the data for the instances like this:

            // Create temporary data
            // Duck is massive so create scale matrix
            Matrix scale = Matrix.CreateScale(0.08f, 0.08f, 0.08f);

            InstanceDataVertex[] data = new InstanceDataVertex[]
            {
                new InstanceDataVertex(scale * Matrix.CreateTranslation(new Vector3(0,0,0)), Color.Red),
                new InstanceDataVertex(scale * Matrix.CreateTranslation(new Vector3(1,0,0)), Color.Green),
                new InstanceDataVertex(scale * Matrix.CreateTranslation(new Vector3(2,0,0)), Color.Blue)

            };

But this time we're going to replace this and create us an army of ducks/meshes. Its worth noting that I am not going to cover making any kind of manager for instancing. As how you add and remove instances is really up to you. But since we use a DynamicVertexBuffer you can recreate it for changes in size of the Vertex array and just use Set() and Get() to retrieve and alter it. Anyway on to creating an army of ducks. Simply replacing the above with:

            int width = 80, depth = 80;
            InstanceDataVertex[] data = new InstanceDataVertex[width * depth];
            for (int x = 0; x < width; x++)
                for (int z = 0; z < depth; z++)
                    data[(z * width) + x] = new InstanceDataVertex(scale * Matrix.CreateTranslation(new Vector3(x * 2, 0, z * 2)),Color.White);

            // Create instanced VertexBuffer with some temporary data
            InstancedVertexBuffer = new DynamicVertexBuffer(device, InstanceDataVertex.VertexDeclaration, data.Length, BufferUsage.None);
            InstancedVertexBuffer.SetData(data);

This gives us an army of 6400 ducks. Each duck is 1843 triangles. That's 6400 * 1843 = 11795200 triangles! Running at 60FPS. Depending on your GPU you could easily crank it up before you had a drop in frame rate as well.
Below you can find the finished project with an army of ducks at the ready and FPS counter so you can have a rough idea of performance. Thanks for reading now go implement it in your project!

If you have any questions please leave a comment and I'll get back to you as soon as I can.
Download: HardwareInstancingExample

Things to keep in mind:

• This sort of instancing requires the user to have a Shader Model 3 graphics card. Some people still don't have these. Although if they are playing games on their PC. It's most likely they do.
• To implement this in your own game. You'll want to write some kind of manager that allows you to add and remove instances easily.
• You can add any properties you want per instance into the custom vertex format we created during the tutorial. But the more properties you have the more memory is used. This is especially a concern when you have tens of thousands of instances.
• It was pointed out to me by a friend that TEXCOORD8 doesn't actually exist as it only goes to 7. So you actually lose the end row matrix data in the effect. However this isn't hugely a problem for the transforms used within the example and you can simply move each TEXCOORD index down in the effect and vertex format.

    class Map
    {
        List Tiles;
        Block[,] Blocks;

        int Width;
        int Depth;

        public Map(ContentManager content, int width, int depth)
        {
            Width = width;
            Depth = depth;

            // Populate your tiles list with your textures here
            Tiles = new List();
            Tiles.Add(content.Load("sampleblock"));

            //  Initialise block 2D array
            Blocks = new Block[Width, Depth];

        }

        ///
        /// Called during Game update method to update
        /// map and input.
        ///
        public void Update()
        {

        }

        ///
        /// Draws map
        ///
        /// <param name="batch" />
        public void Draw(SpriteBatch batch)
        {

        }

        ///
        /// Destroys resources used by map
        ///
        public void Close()
        {

        }

    }

    class Block
    {
        public byte Tile;
        public Rectangle Position;

        public Block(byte tile, Rectangle position)
        {
            Tile = tile;
            Position = position;
        }

    }

            //  Initialise block 2D array
            Blocks = new Block[Width, Depth];

            // Used as a base width and height for varying sized tiles
            int baseWidth = 128;
            int baseHeight = 64;

            // Position blocks
            Rectangle position = new Rectangle(0, 0, Tiles[0].Width, Tiles[0].Height);
            for (int x = 0; x < width; x++)
            {
                position.X = (baseWidth / 2) * x;
                position.Y = (baseHeight / 2) * x;

                for (int z = 0; z < depth; z++)
                {

                    Blocks[x, z] = new Block(0, position);
                    position.Y -= (baseHeight / 2);
                    position.X += (baseWidth / 2);

                }

            }

        ///
        /// Draws map
        ///
        /// <param name="batch" />
        public void Draw(SpriteBatch batch)
        {
            for (int x = 0; x < Width; x++)
                for (int z = Depth - 1; z > -1; z--)
                {
                    Block block = Blocks[x,z];
                    batch.Draw(Tiles[block.Tile], block.Position, Color.White);
                }
        }

        ///
        /// Draws map
        ///
        /// <param name="batch" />
        public void Draw(SpriteBatch batch)
        {
            Rectangle drawPosition;

            for (int x = 0; x < Width; x++)                 for (int z = Depth - 1; z > -1; z--)
                {
                    Block block = Blocks[x,z];
                    drawPosition = block.Position;
                    drawPosition.X += Offset.X;
                    drawPosition.Y += Offset.Y;
                    batch.Draw(Tiles[block.Tile], drawPosition, Color.White);
                }
        }

        ///
        /// Called during Game update method to update
        /// map and input.
        ///
        public void Update()
        {
            // Move offset according to key press
            KeyboardState state = Keyboard.GetState();
            int speed = 10;

            if (state.IsKeyDown(Keys.W))
            {
                Offset.Y += speed;
            }

            if (state.IsKeyDown(Keys.S))
            {
                Offset.Y -= speed;
            }

            if (state.IsKeyDown(Keys.A))
            {
                Offset.X += speed;
            }

            if (state.IsKeyDown(Keys.D))
            {
                Offset.X -= speed;

            }
        }

    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Map Map;
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            graphics.PreferredBackBufferWidth = 800;
            graphics.PreferredBackBufferHeight = 600;

            Content.RootDirectory = "Content";
        }

        ///
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        ///
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        ///
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        ///
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            Map = new Map(Content, 128, 128);
            // TODO: use this.Content to load your game content here
        }

        ///
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        ///
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        ///
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        ///
        /// <param name="gameTime" />Provides a snapshot of timing values.
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            // TODO: Add your update logic here
            Map.Update();
            base.Update(gameTime);
        }

        ///
        /// This is called when the game should draw itself.
        ///
        /// <param name="gameTime" />Provides a snapshot of timing values.
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here
            spriteBatch.Begin();

            Map.Draw(spriteBatch);

            spriteBatch.End();
            base.Draw(gameTime);
        }
    }

            for(int y = 0; y < height; y++)
                for (int x = 0; x < width; x++)
                {
                    position.X = (baseWidth / 2) * x;
                    position.Y = ((baseHeight / 2) * x) - (baseHeight * y); ;

                    for (int z = 0; z < depth; z++)
                    {

                        Blocks[x, y, z] = new Block(0, position);
                        position.Y -= (baseHeight / 2);
                        position.X += (baseWidth / 2);

                    }

                }