[StructLayout(LayoutKind.Sequential)]
public struct PositionColoredTextured4
{
	public Maths.Vector3 Position;
	public int Color;
	public TextureCoord Texture0;
	public TextureCoord Texture1;
	public TextureCoord Texture2;
	public TextureCoord Texture3;
	public static readonly VertexFormat Format = VertexFormat.Position | VertexFormat.Diffuse | VertexFormat.Texture4;
	public static readonly int StrideSize = Marshal.SizeOf(typeof(PositionColoredTextured4));
}

public void SetTexture0Rect(Rectangle rect, float pixelTrim)
{
	if(m_texture0 == null)
		return;

	m_pixelTrim0 = pixelTrim;
	SizeF ratio = new SizeF(1f / (float)m_texture0.Width, 1f / (float)m_texture0.Height);
	m_texture0Rect = new RectangleF(rect.X * ratio.Width, rect.Y * ratio.Height, rect.Width * ratio.Width, rect.Height * ratio.Height);

	topLeft.Tu = ((rect.X + m_pixelTrim0) / m_texture0.Width);
	topLeft.Tv = ((rect.Y + m_pixelTrim0) / m_texture0.Height);

	topRight.Tu = ((rect.X + rect.Width - m_pixelTrim0) / m_texture0.Width);
	topRight.Tv = ((rect.Y + m_pixelTrim0) / m_texture0.Height);

	bottomLeft.Tu = ((rect.X + m_pixelTrim0) / m_texture0.Width);
	bottomLeft.Tv = ((rect.Y + rect.Height - m_pixelTrim0) / m_texture0.Height);

	bottomRight.Tu = ((rect.X + rect.Width - m_pixelTrim0) / m_texture0.Width);
	bottomRight.Tv = ((rect.Y + rect.Height - m_pixelTrim0) / m_texture0.Height);

	if ((m_flipFlags & FlipFlags.Horizontal) != 0)
	{
		m_vertices[0].Texture0.Tu = bottomRight.Tu;
		m_vertices[1].Texture0.Tu = topRight.Tu;
		m_vertices[2].Texture0.Tu = topLeft.Tu;
		m_vertices[3].Texture0.Tu = bottomLeft.Tu;
		m_vertices[4].Texture0.Tu = bottomRight.Tu;
		m_vertices[5].Texture0.Tu = topLeft.Tu;
	}
	else
	{
		m_vertices[0].Texture0.Tu = bottomLeft.Tu;
		m_vertices[1].Texture0.Tu = topLeft.Tu;
		m_vertices[2].Texture0.Tu = topRight.Tu;
		m_vertices[3].Texture0.Tu = bottomRight.Tu;
		m_vertices[4].Texture0.Tu = bottomLeft.Tu;
		m_vertices[5].Texture0.Tu = topRight.Tu;
	}

	if ((m_flipFlags & FlipFlags.Vertical) != 0)
	{
		m_vertices[0].Texture0.Tv = topLeft.Tv;
		m_vertices[1].Texture0.Tv = bottomLeft.Tv;
		m_vertices[2].Texture0.Tv = bottomRight.Tv;
		m_vertices[3].Texture0.Tv = topRight.Tv;
		m_vertices[4].Texture0.Tv = topLeft.Tv;
		m_vertices[5].Texture0.Tv = bottomRight.Tv;
	}
	else
	{
		m_vertices[0].Texture0.Tv = bottomLeft.Tv;
		m_vertices[1].Texture0.Tv = topLeft.Tv;
		m_vertices[2].Texture0.Tv = topRight.Tv;
		m_vertices[3].Texture0.Tv = bottomRight.Tv;
		m_vertices[4].Texture0.Tv = bottomLeft.Tv;
		m_vertices[5].Texture0.Tv = topRight.Tv;
	}
}

Sure, but providing an indexer (or simple method) to make the textures look like an array would probably be clearer and faster.

I was just about to suggest something like this, too. Your solution is much better, because my idea would have involved a work-around for not having pointers. :)

Sure, but providing an indexer (or simple method) to make the textures look like an array would probably be clearer and faster.

[StructLayout(LayoutKind.Sequential)]
public struct PositionColored2Textured
{
	public Maths.Vector3 Position;
	public int Color;
	[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
	public TextureCoord[] Texture;
	public static readonly VertexFormat Format = VertexFormat.Position | VertexFormat.Diffuse | VertexFormat.Texture2;
	public static readonly int StrideSize = Marshal.SizeOf(typeof(PositionColored2Textured));
}

public void SetTextureCoordTu(int textureIndex, float tu)
{
	switch (textureIndex)
	{
		case 0:
			this.Texture0.Tu = tu;
			break;
		case 1:
			this.Texture1.Tu = tu;
			break;
		case 2:
			this.Texture2.Tu = tu;
			break;
		case 3:
			this.Texture3.Tu = tu;
			break;
	}
}

public void SetTextureCoordTv(int textureIndex, float tv)
{
	switch (textureIndex)
	{
		case 0:
			this.Texture0.Tv = tv;
			break;
		case 1:
			this.Texture1.Tv = tv;
			break;
		case 2:
			this.Texture2.Tv = tv;
			break;
		case 3:
			this.Texture3.Tv = tv;
			break;
	}
}

I'm thinking of a function that returns a reference to the correct TextureCoord object, something like (if it is valid C#):

public TextureCoord GetTexture(int textureIndex)
{
	switch (textureIndex)
	{
		case 0:
			return this.Texture0;
		case 1:
			return this.Texture1;
		case 2:
			return this.Texture2;
		case 3:
			return this.Texture3;
	}
}

And then have a function SetTextureRect() that loops from 0 to 3, getting each TextureCoord instance and operating on it from the above function.

C# doesn't support returning a reference to a value type. You can pass a reference to a value type as a function parameter, but not return one.

Hm... Then perhaps a lower function that works on each TextureCoord object alone, and you call it four times from the publicly visible function, passing each instance one at a time? This feels like a dirty solution, and I'm sure someone more familiar with the language can do a better job.