Model Loaders

namespace OOGL.Animation
{
	[StructLayout (LayoutKind.Sequential)]
	public struct VertexStruct : IComparable<VertexStruct>
	{
		public float x;
		public float y;
		public float z;
		public float nX;
		public float nY;
		public float nZ;
		public int	boneIndex;
		public float s;
		public float t;
 
		public const int elementSize = sizeof(float);
		public const int strideElements = 9;
		public const int stride = strideElements * elementSize;
 
		public VertexStruct(float x, float y, float z, float nX, float nY, float nZ,  float s, float t, int boneIndex)
		{
			this.x = x;
			this.y = y;
			this.z = z;
			this.nX = nX;
			this.nY = nY;
			this.nZ = nZ;
			this.s = s;
			this.t = t;
			this.boneIndex = boneIndex;
		}
 
		public VertexStruct(Vector3 vertex, Vector3 normal,  float s, float t, int boneIndex)
		{
			this.x = vertex.X;
			this.y = vertex.Y;
			this.z = vertex.Z;
			this.nX = normal.X;
			this.nY = normal.Y;
			this.nZ = normal.Z;
			this.s = s;
			this.t = t;
			this.boneIndex = boneIndex;
		}
 
		public Vector3 Position
		{
			get
			{
				return new Vector3(x, y, z);
			}
			set
			{
				this.x = value.X;
				this.y = value.Y;
				this.z = value.Z;
			}
		}
 
		public Vector3 Normal
		{
			get
			{
				return new Vector3(nX, nY, nZ);
			}
			set
			{
				this.nX = value.X;
				this.nY = value.Y;
				this.nZ = value.Z;
			}
		}
 
		public Vector2 TextureCoordinate
		{
			get
			{
				return new Vector2(s, t);
			}
			set
			{
				this.s = value.X;
				this.t = value.Y;
			}
		}
 
		public int BoneIndex
		{
			get
			{
				return boneIndex;
			}
			set
			{
				boneIndex = value;
			}
		}
 
		public int CompareTo(VertexStruct other)
		{
			if(x > other.x) return 1;
			if(x < other.x) return -1;
			if(y > other.y) return 1;
			if(y < other.y) return -1;
			if(z > other.z) return 1;
			if(z < other.z) return -1;
 
			if(s > other.s) return 1;
			if(s < other.s) return -1;
			if(t > other.t) return 1;
			if(t < other.t) return -1;
 
			if(boneIndex > other.boneIndex) return 1;
			if(boneIndex < other.boneIndex) return -1;
 
			if(nX > other.nX) return 1;
			if(nX < other.nX) return -1;
			if(nY > other.nY) return 1;
			if(nY < other.nY) return -1;
			if(nZ > other.nZ) return 1;
			if(nZ < other.nZ) return -1;
 
			return 0;
		}
	}
}

namespace OOGL.Animation
{
	public class VertexBuffer : IDisposable
	{
		private int vertexHandle;
		private int indexHandle;
		private int numVerts;
		private int numIndices;
 
		private BufferUsageHint bufferUsage = BufferUsageHint.StaticDraw;
 
		private	const int vertexOffset = 0;
		private	const int normalOffset = 3 * VertexStruct.elementSize;
		private	const int vertexAttribOffset = 6 * VertexStruct.elementSize;
		private	const int texCoord0Offset = 7 * VertexStruct.elementSize;
 
		public VertexBuffer(VertexStruct[] vertices, ushort[] indices)
		{
			if(vertices == null) throw new ArgumentException("Vertices may not be null");
 
			this.numVerts = vertices.Length;
			this.numIndices = indices.Length;
 
			int[] handles = new int[2];
			GL.GenBuffers(2, handles);
			this.vertexHandle = handles[0];
			this.indexHandle = handles[1];
 
			GL.BindBuffer(BufferTarget.ArrayBuffer, this.vertexHandle);            
			GL.BindBuffer(BufferTarget.ElementArrayBuffer, this.indexHandle);
 
			int size = numVerts * VertexStruct.strideElements * VertexStruct.elementSize;									
			unsafe
			{
				fixed (float* pVertices = &vertices[0].x)
				{
					GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)size, (IntPtr)pVertices, bufferUsage);
				}
				fixed (ushort* pIndices = &indices[0])
				{
					GL.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)(numIndices * 2), (IntPtr)pIndices, bufferUsage);
				}
			}						
 
			GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
			GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
		}
 
		public void Draw(int boneAttribIndex)
		{						
			GL.BindBuffer(BufferTarget.ArrayBuffer, vertexHandle);
			GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexHandle);
 
			GL.ClientActiveTexture(TextureUnit.Texture0);
 
			GL.EnableClientState(EnableCap.VertexArray);
			GL.EnableClientState(EnableCap.NormalArray);
			GL.EnableClientState(EnableCap.TextureCoordArray);
			GL.EnableVertexAttribArray(boneAttribIndex);			
 
			GL.VertexPointer(3, VertexPointerType.Float, VertexStruct.stride, (IntPtr)vertexOffset);
			GL.NormalPointer(NormalPointerType.Float, VertexStruct.stride, (IntPtr)normalOffset);
			GL.TexCoordPointer(2, TexCoordPointerType.Float, VertexStruct.stride, (IntPtr)texCoord0Offset);
			GL.VertexAttribPointer(boneAttribIndex, 1, VertexAttribPointerType.Int, false, VertexStruct.stride, (IntPtr)vertexAttribOffset);
 
			GL.DrawElements(BeginMode.Triangles, numIndices, DrawElementsType.UnsignedShort, IntPtr.Zero); 
 
			GL.DisableClientState(EnableCap.VertexArray);
			GL.DisableClientState(EnableCap.NormalArray);
			GL.DisableClientState(EnableCap.TextureCoordArray);
			GL.DisableVertexAttribArray(boneAttribIndex);
 
			GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
			GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
		}
 
 
		public void Dispose()
		{
			int[] bufferHandles = new int[] { vertexHandle, indexHandle };
			GL.DeleteBuffers(2, bufferHandles);
		}
	}
}