budnhead/org.niclasundharald.engine/graphics/Model3D.cs

using System;

using OpenTK.Graphics.OpenGL;
using OpenTK;

namespace org.niclasundharald.engine.graphics {
	
	public class Model3D {

		protected int	vao,
			vbo,    // Vertex Buffer
			cbo,    // Color Buffer
			nbo;    // Normals Buffer

		protected int nTriangles;

		Vector3[]	vertexes;
		Vector4[]	colors;
		Vector3[]	normals;


		protected Model3D(){
			vao = GL.GenVertexArray();
			nTriangles = 0;

			prepare();
		}

		protected void prepare(){
			vbo = GL.GenBuffer();
			cbo = GL.GenBuffer();
			nbo = GL.GenBuffer();

			GL.BindVertexArray(vao);

			GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
			GL.VertexAttribPointer(0,
			                       3,
			                       VertexAttribPointerType.Float,
			                       false,
			                       0,
			                       0);

			GL.BindBuffer(BufferTarget.ArrayBuffer, cbo);
			GL.VertexAttribPointer(1,
			                       4,
			                       VertexAttribPointerType.Float,
			                       false,
			                       0,
			                       0);

			GL.BindBuffer(BufferTarget.ArrayBuffer, nbo);
			GL.VertexAttribPointer(2,
			                       3,
			                       VertexAttribPointerType.Float,
			                       false,
			                       0,
			                       0);

			GL.BindVertexArray(0);
		}

		protected void rebind(){
			
		}

		protected void bind(Vector3[] vertexes){
			bind( vertexes, null, null, null );
		}

		protected void bind(Vector3[] vertexes,Vector4[] colors){
			bind( vertexes, colors, null, null );
		}

		protected void bind(Vector3[] vertexes,Vector4[] colors,Vector3[] normals){
			bind( vertexes, colors, normals, null );
		}

		protected void bind(Vector3[] vertexes,Vector4[] colors,Vector3[] normals,Vector2[] uvs){
/*			float[] fv = new float[vertexes.Length * 3];

			for (int n=0;n<vertexes.Length;n++){
				fv[(n * 3)    ] = vertexes[n].X;
				fv[(n * 3) + 1] = vertexes[n].Y;
				fv[(n * 3) + 2] = vertexes[n].Z;
			}
*/
			GL.BindVertexArray(vao);

			GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
			//			GL.BufferData(BufferTarget.ArrayBuffer, 4 * fv.Length, fv, BufferUsageHint.StaticDraw);
			GL.BufferData(BufferTarget.ArrayBuffer, 12 * vertexes.Length, vertexes, BufferUsageHint.StaticDraw);

			GL.EnableVertexAttribArray(0);

			nTriangles = vertexes.Length / 3;

			if (colors == null){
				colors = new Vector4[ vertexes.Length ];

				for (int n=0;n<colors.Length;n++){
					colors[n] = new Vector4(0.5f,0.9f,0.9f,1.0f);
				}

			}

			GL.BindBuffer(BufferTarget.ArrayBuffer, cbo);
			GL.BufferData(BufferTarget.ArrayBuffer, 16 * colors.Length, colors, BufferUsageHint.StaticDraw);

			GL.EnableVertexAttribArray(1);

			if (normals == null){
				normals = computeNormals(vertexes);
			}
/*
			float[] fn = v3aToArray(normals);
*/
			GL.BindBuffer(BufferTarget.ArrayBuffer, nbo);
			GL.BufferData(BufferTarget.ArrayBuffer, 12 * normals.Length, normals, BufferUsageHint.StaticDraw);

			GL.EnableVertexAttribArray(2);
		}

		public virtual void draw(){
			GL.BindVertexArray(this.vao);
			GL.DrawArrays(PrimitiveType.Triangles, 0, nTriangles * 3);
			GL.BindVertexArray(0);
		}


		public static void setTriangle(Vector3[] vertexes,int n, Vector3 a, Vector3 b, Vector3 c)
		{
			vertexes[(3 * n)] = a;
			vertexes[(3 * n)+1] = b;
			vertexes[(3 * n)+2] = c;
		}

		public static Vector3[] computeNormals(Vector3[] vertexes){
			Vector3[] normals = new Vector3[ vertexes.Length ];

			for (int n=0;n<vertexes.Length-2;n+=3){
				Vector3 normal = Vector3.Cross( vertexes[n+1] - vertexes[n], vertexes[n+2] - vertexes[n] );
				normal.Normalize();
/*
				Console.WriteLine("Normal Length: {0} Normal: {1}",normal.Length, normal);

				if (normal.Length != 1){
					Console.WriteLine("!!! Broken Normal !!!");
					Console.WriteLine("Triangle: {0} {1} {2}",vertexes[n],vertexes[n+1],vertexes[n+2]);

				}
*/
				normals[(n)    ] = normal;
				normals[(n) + 1] = normal;
				normals[(n) + 2] = normal;
			}

			return normals;
		}

		public static float[] v3aToArray(Vector3[] v3a){
			float[] a = new float[ v3a.Length * 3];

			for (int n=0;n<v3a.Length;n++){
				a[ (3 * n)    ] = v3a[n].X;
				a[ (3 * n) + 1] = v3a[n].Y;
				a[ (3 * n) + 2] = v3a[n].Z;
			}

			return a;
		}


		public static Model3D loadObjFile(string filename,float scale){
			return new LoadedModel(filename,scale);
		}

	}
}