/// <summary>
		/// Loads the GL objects into OpenGL buffer.
		/// </summary>
		/// <returns>The GL objects.</returns>
		/// <param name="objects">Objects.</param>
		/// <param name="nObject">N object.</param>
		public static int[][] LoadGLObjects(
			LoadResult[][] objects,
			PhysicsEngineMathUtility.Vector3[][] translate,
			int nObject,
			bool GLM_TEXTURE = false, 
			bool GLM_FLAT = false,
			bool GLM_SMOOTH = false )
		{
			int[][] displayList = new int[nObject][]; 

			for (int i = 0; i < nObject; i++) 
			{
                displayList[i] = new int[objects[i].Length];

                for (int j = 0; j < objects[i].Length; j++)
                {
                    displayList[i][j] = GL.GenLists(1);

                    GL.NewList(displayList[i][j], ListMode.CompileAndExecute);

                    GLDrawSolid(objects[i][j], translate[i][j], GLM_TEXTURE, GLM_FLAT, GLM_SMOOTH);

                    GL.EndList();
                }
			}

			return displayList;
		}
        public IList<Mesh> Convert(LoadResult loadResult)
        {
            _loadResult = loadResult;

            _meshes = new List<Mesh>();

            ConvertGroups();

            return _meshes;
        }
Example #3
0
 private LoadResult CreateResult()
 {
     var result = new LoadResult
                      {
                          Vertices = _dataStore.Vertices,
                          Textures = _dataStore.Textures,
                          Normals = _dataStore.Normals,
                          Groups = _dataStore.Groups,
                          Materials = _dataStore.Materials
                      };
     return result;
 }
Example #4
0
        private LoadResult CreateResult()
        {
            var result = new LoadResult
            {
                Vertices  = _dataStore.Vertices,
                Textures  = _dataStore.Textures,
                Normals   = _dataStore.Normals,
                Groups    = _dataStore.Groups,
                Materials = _dataStore.Materials
            };

            return(result);
        }
Example #5
0
        private static void PrintResult(LoadResult result)
        {
            var sb = new StringBuilder();

            sb.AppendLine("Load result:");
            sb.Append("Vertices: ");
            sb.AppendLine(result.Vertices.Count.ToString(CultureInfo.InvariantCulture));
            sb.Append("Textures: ");
            sb.AppendLine(result.Textures.Count.ToString(CultureInfo.InvariantCulture));
            sb.Append("Normals: ");
            sb.AppendLine(result.Normals.Count.ToString(CultureInfo.InvariantCulture));
            sb.AppendLine();
            sb.AppendLine("Groups: ");

            foreach (var loaderGroup in result.Groups)
            {
                sb.AppendLine(loaderGroup.Name);
                sb.Append("Faces: ");
                sb.AppendLine(loaderGroup.Faces.Count.ToString(CultureInfo.InvariantCulture));
            }

            Console.WriteLine(sb);
        }
		public static float UnitizeObject(ref LoadResult obj)
		{
			float xMax, xMin, yMax, yMin, zMax, zMin;
			float cx, cy, cz, w, h, d;
			float scale;

			xMax = obj.Vertices [0].X;
			xMin = obj.Vertices [0].X;
			yMax = obj.Vertices [0].Y;
			yMin = obj.Vertices [0].Y;
			zMax = obj.Vertices [0].Z;
			zMin = obj.Vertices [0].Z;

			for (int i = 1; i < obj.Vertices.Count; i++) 
			{
				if (xMax < obj.Vertices [i].X)
					xMax = obj.Vertices [i].X;
				if (xMin > obj.Vertices [i].X)
					xMin = obj.Vertices [i].X;

				if (yMax < obj.Vertices [i].Y)
					yMax = obj.Vertices [i].Y;
				if (yMin > obj.Vertices [i].Y)
					yMin = obj.Vertices [i].Y;

				if (zMax < obj.Vertices [i].Z)
					zMax = obj.Vertices [i].Z;
				if (zMin > obj.Vertices [i].Z)
					zMin = obj.Vertices [i].Z;
			}

			/* calculate model width, height, and depth */
			w = Math.Abs (xMax) + Math.Abs (xMin);
			h = Math.Abs (yMax) + Math.Abs (yMin);
			d = Math.Abs (zMax) + Math.Abs (zMin);

			/* calculate center of the model */
			cx = (xMax + xMin) / 2.0f;
			cy = (yMax + yMin) / 2.0f;
			cz = (zMax + zMin) / 2.0f;

			scale = 2.0f / Math.Max (Math.Max (w, h), d);

			/* translate around center then scale */
			for (int i = 0; i < obj.Vertices.Count; i++) 
			{
				var vertex = new ObjLoader.Loader.Data.VertexData.Vertex (
					(obj.Vertices [i].X - cx) * scale,
					(obj.Vertices [i].Y - cy) * scale,
					(obj.Vertices [i].Z - cz) * scale);

				obj.Vertices [i] = vertex;
			}

			return scale;
		}
		/// <summary>
		/// GL draw solid.
		/// </summary>
		/// <param name="solid">Solid.</param>
		/// <param name="GLM_TEXTURE">If set to <c>true</c> GL add texture coordinates.</param>
		/// <param name="GLM_FLAT">If set to <c>true</c> GL add plane normal.</param>
		private static void GLDrawSolid(
			LoadResult solid,
			PhysicsEngineMathUtility.Vector3 translate,
			bool GLM_TEXTURE, 
			bool GLM_FLAT,
			bool GLM_SMOOTH)
		{
			int[] indicedata = new int[solid.Groups [0].Faces.Count * 3];
			int[] textureData = new int[solid.Groups [0].Faces.Count * 3];
			int[] normalData = new int[solid.Groups [0].Faces.Count * 3]; 

			GL.Begin (PrimitiveType.Triangles);

			for (int i = 0; i < solid.Groups [0].Faces.Count; i++) 
			{
				int index = i * 3;
				indicedata [index] = solid.Groups [0].Faces [i] [0].VertexIndex - 1;
				indicedata [index + 1] = solid.Groups [0].Faces [i] [1].VertexIndex - 1;
				indicedata [index + 2] = solid.Groups [0].Faces [i] [2].VertexIndex - 1;

				textureData [index] = solid.Groups [0].Faces [i] [0].TextureIndex - 1;
				textureData [index + 1] = solid.Groups [0].Faces [i] [1].TextureIndex - 1;
				textureData [index + 2] = solid.Groups [0].Faces [i] [2].TextureIndex - 1;

				normalData [index] = solid.Groups [0].Faces [i] [0].NormalIndex - 1;
				normalData [index + 1] = solid.Groups [0].Faces [i] [1].NormalIndex - 1;
				normalData [index + 2] = solid.Groups [0].Faces [i] [2].NormalIndex - 1;

				if (GLM_FLAT) 
				{
					var a = new PhysicsEngineMathUtility.Vector3 (
						solid.Vertices [indicedata [index]].X, 
						solid.Vertices [indicedata [index]].Y, 
						solid.Vertices [indicedata [index]].Z);
					
					var b = new PhysicsEngineMathUtility.Vector3 (
						solid.Vertices [indicedata [index + 1]].X, 
						solid.Vertices [indicedata [index + 1]].Y, 
						solid.Vertices [indicedata [index + 1]].Z);

					var c = new PhysicsEngineMathUtility.Vector3 (
						solid.Vertices [indicedata [index + 2]].X, 
						solid.Vertices [indicedata [index + 2]].Y, 
						solid.Vertices [indicedata [index + 2]].Z);

					PhysicsEngineMathUtility.Vector3 normal = 
						PhysicsEngineMathUtility.GeometryUtilities.CalculateNormal (a, b, c);

					GL.Normal3 (normal.x, normal.y, normal.z);	
				}

				if (GLM_SMOOTH)
					GL.Normal3 (solid.Normals[normalData[index]].X, 
						solid.Normals[normalData[index]].Y, 
						solid.Normals[normalData[index]].Z);

				if (GLM_TEXTURE && solid.Textures.Count > 0)
					GL.TexCoord2 (solid.Textures [textureData [index]].X,
						solid.Textures [textureData [index]].Y);

				GL.Vertex3 (solid.Vertices [indicedata [index]].X - translate.x, 
					solid.Vertices [indicedata [index]].Y - translate.y,
					solid.Vertices [indicedata [index]].Z - translate.z);

				if (GLM_SMOOTH)
					GL.Normal3 (solid.Normals[normalData[index + 1]].X, 
						solid.Normals[normalData[index + 1]].Y, 
						solid.Normals[normalData[index + 1]].Z);

				if (GLM_TEXTURE && solid.Textures.Count > 0)
					GL.TexCoord2 (solid.Textures [textureData [index + 1]].X,
						solid.Textures [textureData [index + 1]].Y);

				GL.Vertex3 (solid.Vertices [indicedata [index + 1]].X - translate.x, 
					solid.Vertices [indicedata [index + 1]].Y - translate.y,
					solid.Vertices [indicedata [index + 1]].Z - translate.z);

				if (GLM_SMOOTH)
					GL.Normal3 (solid.Normals[normalData[index + 2]].X, 
						solid.Normals[normalData[index + 2]].Y, 
						solid.Normals[normalData[index + 2]].Z);

				if (GLM_TEXTURE && solid.Textures.Count > 0)
					GL.TexCoord2 (solid.Textures [textureData [index + 2]].X,
						solid.Textures [textureData [index + 2]].Y);

				GL.Vertex3 (solid.Vertices [indicedata [index + 2]].X - translate.x, 
					solid.Vertices [indicedata [index + 2]].Y - translate.y,
					solid.Vertices [indicedata [index + 2]].Z - translate.z);

			}

			GL.End ();
		}
		public static void ScaleObject(
			ref LoadResult obj, 
			float scale)
		{
			for (int i = 0; i < obj.Vertices.Count; i++) 
			{
				var vertex = new ObjLoader.Loader.Data.VertexData.Vertex (
					(obj.Vertices [i].X) * scale,
					(obj.Vertices [i].Y) * scale,
					(obj.Vertices [i].Z) * scale);

				obj.Vertices [i] = vertex;
			}
		}
Example #9
0
        private void Load()
        {
            var objectStream = CreateMemoryStreamFromString(ObjectFileString);

            _loadResult = _loader.Load(objectStream);
        }
Example #10
0
 static Catapult()
 {
     CatapultBase = ModelsLoader.Load("catapult.obj");
     CatapultHand = ModelsLoader.Load("hand.obj");
 }
Example #11
0
 static Flower()
 {
     FlowerModel = ModelsLoader.Load("flower.obj");
 }
Example #12
0
		public int[][] GetOpenGLObjectList()
		{
			var xmlDoc = new XmlDocument();
			xmlDoc.Load(FileNameObjectProperties);

			XmlNodeList xmlList = xmlDoc.SelectNodes(nodePathObjects);

			LoadResult[][] loadObjects = new LoadResult[xmlList.Count][];

            Vector3[][] translate = new Vector3[xmlList.Count][];

			for (int i = 0; i < xmlList.Count; i++) 
			{
                XmlNodeList xmlGeometryList = xmlList[i].SelectNodes(nodePathGeometry);

                translate[i] = new Vector3[xmlGeometryList.Count];
                loadObjects[i] = new LoadResult[xmlGeometryList.Count];

                for (int j = 0; j < xmlGeometryList.Count; j++)
                {
                    //Object geometry file name
                    string geometryFileName = xmlGeometryList[j][objectGeometryAttribute].InnerText;

                    //Scale
                    float scale = Convert.ToSingle(xmlGeometryList[j][scaleAttribute].InnerText);

                    loadObjects[i][j] = LoadObjSolid(geometryFileName, scale);
                }

                    
			}

			return OpenGLUtilities.LoadGLObjects (
				loadObjects,
				translate,
				xmlList.Count,
				true,
				false,
				true);
		}