Batch drawing with quadrangles. How can I use individual transform matrices?

        public void QuadBatchDraw(List<Quad> list_Quad, Effect effect_Current)
        {
            short[] quad_Indices = new short[list_Quad.Count * GameConstants.QUAD_NUMBER_OF_INDICES];
            VertexPositionNormalExtra[] quad_Vertices = new VertexPositionNormalExtra[list_Quad.Count * GameConstants.QUAD_NUMBER_OF_VERTICES];
 
            int index_Index = 0;
            int vertex_Index = 0;
 
            foreach (Quad quad in list_Quad)
            {
                quad_Indices[index_Index++] = (short)(0 + vertex_Index);
                quad_Indices[index_Index++] = (short)(1 + vertex_Index);
                quad_Indices[index_Index++] = (short)(2 + vertex_Index);
 
                quad_Indices[index_Index++] = (short)(1 + vertex_Index);
                quad_Indices[index_Index++] = (short)(3 + vertex_Index);
                quad_Indices[index_Index++] = (short)(2 + vertex_Index);
 
                quad_Vertices[vertex_Index++] = quad.Vertices[0];
                quad_Vertices[vertex_Index++] = quad.Vertices[1];
                quad_Vertices[vertex_Index++] = quad.Vertices[2];
                quad_Vertices[vertex_Index++] = quad.Vertices[3];
            }
 
            // Set technique
            effect_Current.CurrentTechnique = effect_Current.Techniques["Textured"];
 
            // Set parameters
            effect_Current.Parameters["xTexture0"].SetValue(texture_List[0]);
 
            // HERE LIES THE PROBLEM
            effect_Current.Parameters["xWorldViewProjection"].SetValue(Matrix.Identity * camera.ViewMatrix * camera.ProjectionMatrix);
 
            effect_Current.Begin(SaveStateMode.None);
            foreach (EffectPass pass in effect_Current.CurrentTechnique.Passes)
            {
                pass.Begin();
 
                // Divide the Index count by 3 because 3 Indices make 1 Triangle (The PrimitiveType is a TriangleList)
                graphics_Device.VertexDeclaration = new VertexDeclaration(graphics_Device, VertexPositionNormalExtra.VertexElements);
                graphics_Device.DrawUserIndexedPrimitives<VertexPositionNormalExtra>(PrimitiveType.TriangleList, quad_Vertices, 0, quad_Vertices.Length, quad_Indices, 0, quad_Indices.Length / 3);
 
                pass.End();
            }
            effect_Current.End();
        }

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace Cthonian
{
    // Vertices are used to store data you send from your XNA project to the shaders on your graphics card.
    // A Vertex Format conatins a desciption of the data stored in your vertices.
    // XNA comes with some default vertex formats, ranging from the simple VertexPositionColor to the VertexPositionNormalTexture format.
    // Packing each vertex with some extra data requires you to define a custom vertex format
    public struct VertexPositionNormalExtra
    {
        public Vector3 Position;
        public Vector3 Centre;
        public Vector3 Normal;
        public Vector2 TexCoords;
        public Vector3 Extra;       // Extra Information (x = Width, y = Height, z = Texture Sampler Number)
 
        public VertexPositionNormalExtra(Vector3 position, Vector3 centre, Vector3 normal, Vector2 texCoords, float textureSampler, float width, float height)
        {
            Position = position;
            Centre = centre;
            Normal = normal;
            TexCoords = texCoords;
            Extra.X = width;
            Extra.Y = height;
            Extra.Z = textureSampler;
        }
 
        public static readonly VertexElement[] VertexElements =
        {
            // Normal has offset of sizeof(float)*3 because Vector 3 takes up (4*3bytes)
            new VertexElement(0, 0, VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Position, 0),
            new VertexElement(0, sizeof(float)*(3), VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Position, 1),
            new VertexElement(0, sizeof(float)*(3+3), VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.Normal, 0),
            new VertexElement(0, sizeof(float)*(3+3+3), VertexElementFormat.Vector2, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 0),   
                 
            // I can pass my own custom data into HLSL using VertexElementUsage.TextureCoordinate, 0 or VertexElementUsage.TextureCoordinate, 1 etc.
            // It is seen as semantic TEXCOORD1 in HLSL (.fx file)
            new VertexElement(0, sizeof(float)*(3+3+3+2), VertexElementFormat.Vector3, VertexElementMethod.Default, VertexElementUsage.TextureCoordinate, 3),
        };
 
        // Imagine a stream of vertices is sent to the graphics card.
        // Your graphics card would have a pretty hard time trying to figure out where to split the stream of bytes into vertices.
        // It needs to know the number of bytes occupied by one vertex so it can cut the stream nicely into separate vertices.
        public static readonly int SizeInBytes = sizeof(float) * (3 + 3 + 3 + 2 + 3);    // E.G. Vector 3 (3) + Single (1) + Vector 4 (4) + Single (1) * 4 OR sizeof(float)
        // Since the information is the same for all vertices you create based on this strcut and you only need to read them.
        // You can make it a static readonly
    }
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50: