/// <summary>
        /// Creates a geometry element for a single fog plane
        /// </summary>
        /// <param name="index">Index of the fog plane to create a geometry element for</param>
        /// <returns></returns>
        void CreateFogPlaneGeometry(int index)
        {
            H1.Tags.structure_bsp_group definition = tagManager.TagDefinition as H1.Tags.structure_bsp_group;

            List <Vertex> common_vertices = new List <Vertex>();

            foreach (var vertex in definition.FogPlanes[index].Vertices)
            {
                common_vertices.Add(new Vertex(vertex.Value.ToPoint3D(100)));
            }

            List <Part> common_parts = new List <Part>();

            // we only have one part since it only has one material
            Part common_part = new Part("fogplanes");

            common_part.AddIndices(BuildFaceIndices(definition.FogPlanes[index].Vertices.Count));
            common_parts.Add(common_part);

            // create the geometry element
            CreateGeometry("fogplane-" + index.ToString(), 0, VertexComponent.POSITION,
                           common_vertices, common_parts);
        }
Example #2
0
        /// <summary>
        /// Creates a geometry element for a single cluster portal
        /// </summary>
        /// <param name="portal_index">Index of the portal to create a geometry element for</param>
        /// <returns></returns>
        void CreatePortalsGeometry(int index)
        {
            H2.Tags.scenario_structure_bsp_group definition = tagManager.TagDefinition as H2.Tags.scenario_structure_bsp_group;

            List <Vertex> common_vertices = new List <Vertex>();

            // add the vertex position information to the position source
            foreach (var vertex in definition.ClusterPortals[index].Vertices)
            {
                common_vertices.Add(new Vertex(vertex.Point.ToPoint3D(100)));
            }

            List <Part> common_parts = new List <Part>();

            // only one part is needed since one one material is used
            Part common_part = new Part("portals");

            common_part.AddIndices(BuildFaceIndices(definition.ClusterPortals[index].Vertices.Count));
            common_parts.Add(common_part);

            // create the geometry element
            CreateGeometry("portal-" + index.ToString(), 0, VertexComponent.POSITION,
                           common_vertices, common_parts);
        }
        /// <summary>
        /// Creates a geometry element for a BSP lightmap
        /// </summary>
        /// <param name="index">The lightmap index to create a geometry from</param>
        /// <returns></returns>
        void CreateRenderGeometry(int index)
        {
            H1.Tags.structure_bsp_group definition = tagManager.TagDefinition as H1.Tags.structure_bsp_group;

            List <Vertex> common_vertices = new List <Vertex>();

            // add all of the vertices used in the render geometry
            foreach (var material in definition.Lightmaps[index].Materials)
            {
                // read vertex information from the uncompressed vertex data
                System.IO.BinaryReader uncompressed_reader = new System.IO.BinaryReader(
                    new System.IO.MemoryStream(material.UncompressedVertices.Value));

                int vertex_count = material.VertexBuffersCount1;

                for (int vertex_index = 0; vertex_index < vertex_count; vertex_index++)
                {
                    Vertex common_vertex = new Vertex(
                        //RealPoint3D position
                        new LowLevel.Math.real_point3d(
                            uncompressed_reader.ReadSingle() * 100,
                            uncompressed_reader.ReadSingle() * 100,
                            uncompressed_reader.ReadSingle() * 100),
                        //RealVector3D  normal
                        new LowLevel.Math.real_vector3d(
                            uncompressed_reader.ReadSingle(),
                            uncompressed_reader.ReadSingle(),
                            uncompressed_reader.ReadSingle()),
                        //RealVector3D  binormal
                        new LowLevel.Math.real_vector3d(
                            uncompressed_reader.ReadSingle(),
                            uncompressed_reader.ReadSingle(),
                            uncompressed_reader.ReadSingle()),
                        //RealVector3D  tangent
                        new LowLevel.Math.real_vector3d(
                            uncompressed_reader.ReadSingle(),
                            uncompressed_reader.ReadSingle(),
                            uncompressed_reader.ReadSingle()));

                    //RealPoint2D   texcoord0
                    common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
                                                  uncompressed_reader.ReadSingle(),
                                                  (uncompressed_reader.ReadSingle() * -1) + 1));

                    //RealPoint2D   texcoord1
                    if (material.VertexBuffersCount2 != 0)
                    {
                        int position = (int)uncompressed_reader.BaseStream.Position;
                        uncompressed_reader.BaseStream.Position = (material.VertexBuffersCount1 * 56) + (vertex_index * 20) + 12;

                        common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
                                                      uncompressed_reader.ReadSingle(),
                                                      (uncompressed_reader.ReadSingle() * -1) + 1));

                        uncompressed_reader.BaseStream.Position = position;
                    }
                    else
                    {
                        common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(0, 1));
                    }

                    common_vertices.Add(common_vertex);
                }
                ;
            }

            List <Part> common_parts = new List <Part>();

            // add part definitions for the lightmap materials
            // an index offset is necessary since the vertex list is global for this geometry, rather than local to each material
            int index_offset = 0;

            foreach (var material in definition.Lightmaps[index].Materials)
            {
                Part common_part = new Part(Path.GetFileNameWithoutExtension(material.Shader.ToString()));
                common_part.AddIndices(CreateIndicesBSP(definition, material.Surfaces, material.SurfaceCount, index_offset));

                index_offset += material.VertexBuffersCount1;

                common_parts.Add(common_part);
            }

            // create the geometry element
            CreateGeometry(ColladaUtilities.FormatName(tagName, " ", "_") + "-" + definition.Lightmaps[index].Bitmap.ToString(), 2,
                           VertexComponent.POSITION | VertexComponent.NORMAL | VertexComponent.BINORMAL | VertexComponent.TANGENT | VertexComponent.TEXCOORD,
                           common_vertices, common_parts);
        }
        /// <summary>
        /// Creates a geometry element for a Halo geometry section
        /// </summary>
        /// <param name="name">The name for the geometry</param>
        /// <param name="is_skinned">Controls whether the strip indices should be treated as a triangle strip or a triangle list</param>
        /// <param name="section">The geometry section to create an element for</param>
        /// <param name="shader_names">A string list containing all of the shader names</param>
        protected void CreateGeometryHalo2(string name, bool is_skinned,
                                           H2.Tags.global_geometry_section_info_struct section_info, H2.Tags.global_geometry_section_struct section,
                                           List <string> shader_names)
        {
            List <Vertex> common_vertices = new List <Vertex>();

            // create a generic list of vertices
            foreach (var vertex in section.RawVertices)
            {
                Vertex common_vertex = new Vertex(
                    vertex.Point.Position.ToPoint3D(100),
                    vertex.Normal.ToVector3D(),
                    vertex.Binormal.ToVector3D(),
                    vertex.Tangent.ToVector3D());

                common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
                                              vertex.Texcoord.X,
                                              (vertex.Texcoord.Y * -1) + 1));
                common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
                                              vertex.SecondaryTexcoord.X,
                                              (vertex.SecondaryTexcoord.Y * -1) + 1));
                common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
                                              vertex.PrimaryLightmapTexcoord.X,
                                              (vertex.PrimaryLightmapTexcoord.Y * -1) + 1));

                common_vertices.Add(common_vertex);
            }

            List <Part> commom_parts = new List <Part>();

            // create the generic part definition list
            for (int part_index = 0; part_index < section.Parts.Count; part_index++)
            {
                string shader_name;
                if (shader_names.Count == 0)
                {
                    shader_name = "";
                }
                else
                {
                    shader_name = shader_names[section.Parts[part_index].Material];
                }

                Part common_part = new Part(shader_name);

                if (is_skinned)
                {
                    common_part.AddIndices(CreateIndicesSkinned(section, part_index));
                }
                else
                {
                    common_part.AddIndices(CreateIndicesWorldSpace(section, part_index));
                }

                commom_parts.Add(common_part);
            }

            // create the geometry element
            CreateGeometry(name, 3,
                           VertexComponent.POSITION | VertexComponent.NORMAL | VertexComponent.BINORMAL | VertexComponent.TANGENT | VertexComponent.TEXCOORD,
                           common_vertices, commom_parts);
        }
Example #5
0
		/// <summary>
		/// Creates a geometry element for a single cluster portal
		/// </summary>
		/// <param name="portal_index">Index of the portal to create a geometry element for</param>
		/// <returns></returns>
		void CreatePortalsGeometry(int index)
		{
			H2.Tags.scenario_structure_bsp_group definition = tagManager.TagDefinition as H2.Tags.scenario_structure_bsp_group;

			List<Vertex> common_vertices = new List<Vertex>();
			// add the vertex position information to the position source
			foreach(var vertex in definition.ClusterPortals[index].Vertices)
				common_vertices.Add(new Vertex(vertex.Point.ToPoint3D(100)));

			List<Part> common_parts = new List<Part>();

			// only one part is needed since one one material is used
			Part common_part = new Part("portals");
			common_part.AddIndices(BuildFaceIndices(definition.ClusterPortals[index].Vertices.Count));
			common_parts.Add(common_part);

			// create the geometry element
			CreateGeometry("portal-" + index.ToString(), 0, VertexComponent.POSITION,
				common_vertices, common_parts);
		}
Example #6
0
        /// <summary>
        /// Creates geometry elements for all of the included geometry blocks
        /// </summary>
        void CreateGeometryList()
        {
            H1.Tags.gbxmodel_group definition = tagManager.TagDefinition as H1.Tags.gbxmodel_group;

            // create a list contining the names of all the shaders being used
            List <string> shader_names = new List <string>();

            foreach (var shader in definition.Shaders)
            {
                shader_names.Add(Path.GetFileNameWithoutExtension(shader.Shader.ToString()));
            }

            for (int i = 0; i < modelInfo.GetGeometryCount(); i++)
            {
                string name = ColladaUtilities.FormatName(modelInfo.GetGeometryName(i), " ", "_");

                List <Vertex> common_vertices = new List <Vertex>();

                H1.Tags.gbxmodel_group.model_geometry_block geometry = definition.Geometries[modelInfo.GetGeometryIndex(i)];

                // collect the vertices for all of the geometries parts
                foreach (var part in geometry.Parts)
                {
                    foreach (var vertex in part.UncompressedVertices)
                    {
                        Vertex common_vertex = new Vertex(vertex.Position.ToPoint3D(100),
                                                          vertex.Normal.ToVector3D(),
                                                          vertex.Binormal.ToVector3D(),
                                                          vertex.Tangent.ToVector3D());

                        // if the texture coordinate scale is 0.0, default to 1.0
                        float u_scale = (definition.BaseMapUScale.Value == 0.0f ? 1.0f : definition.BaseMapUScale.Value);
                        float v_scale = (definition.BaseMapVScale.Value == 0.0f ? 1.0f : definition.BaseMapVScale.Value);

                        // add the texture coordinate data
                        common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
                                                      vertex.TextureCoords.X * u_scale,
                                                      ((vertex.TextureCoords.Y * v_scale) * -1) + 1));

                        common_vertices.Add(common_vertex);
                    }
                }

                List <Part> common_parts = new List <Part>();
                // create a new Part for each geometry part
                int index_offset = 0;
                foreach (var part in geometry.Parts)
                {
                    Part common_part = new Part(shader_names[part.ShaderIndex]);
                    common_part.AddIndices(CreateIndicesModel(part, index_offset));

                    index_offset += part.UncompressedVertices.Count;

                    common_parts.Add(common_part);
                }

                // create the geometry element
                CreateGeometry(name, 1,
                               VertexComponent.POSITION | VertexComponent.NORMAL | VertexComponent.BINORMAL | VertexComponent.TANGENT | VertexComponent.TEXCOORD,
                               common_vertices, common_parts);
            }
        }
Example #7
0
		/// <summary>
		/// Creates a geometry element for a single fog plane
		/// </summary>
		/// <param name="index">Index of the fog plane to create a geometry element for</param>
		/// <returns></returns>
		void CreateFogPlaneGeometry(int index)
		{
			H1.Tags.structure_bsp_group definition = tagManager.TagDefinition as H1.Tags.structure_bsp_group;

			List<Vertex> common_vertices = new List<Vertex>();

			foreach (var vertex in definition.FogPlanes[index].Vertices)
				common_vertices.Add(new Vertex(vertex.Value.ToPoint3D(100)));

			List<Part> common_parts = new List<Part>();

			// we only have one part since it only has one material
			Part common_part = new Part("fogplanes");
			common_part.AddIndices(BuildFaceIndices(definition.FogPlanes[index].Vertices.Count));
			common_parts.Add(common_part);

			// create the geometry element
			CreateGeometry("fogplane-" + index.ToString(), 0, VertexComponent.POSITION,
				common_vertices, common_parts);
		}
Example #8
0
		/// <summary>
		/// Creates a geometry element for a BSP lightmap
		/// </summary>
		/// <param name="index">The lightmap index to create a geometry from</param>
		/// <returns></returns>
		void CreateRenderGeometry(int index)
		{
			H1.Tags.structure_bsp_group definition = tagManager.TagDefinition as H1.Tags.structure_bsp_group;

			List<Vertex> common_vertices = new List<Vertex>();

			// add all of the vertices used in the render geometry
			foreach (var material in definition.Lightmaps[index].Materials)
			{
				// read vertex information from the uncompressed vertex data
				System.IO.BinaryReader uncompressed_reader = new System.IO.BinaryReader(
					new System.IO.MemoryStream(material.UncompressedVertices.Value));

				int vertex_count = material.VertexBuffersCount1;

				for (int vertex_index = 0; vertex_index < vertex_count; vertex_index++)
				{
					Vertex common_vertex = new Vertex(
						//RealPoint3D position
						new LowLevel.Math.real_point3d(
							uncompressed_reader.ReadSingle() * 100,
							uncompressed_reader.ReadSingle() * 100,
							uncompressed_reader.ReadSingle() * 100),
						//RealVector3D  normal
						new LowLevel.Math.real_vector3d(
							uncompressed_reader.ReadSingle(),
							uncompressed_reader.ReadSingle(),
							uncompressed_reader.ReadSingle()),
						//RealVector3D  binormal
						new LowLevel.Math.real_vector3d(
							uncompressed_reader.ReadSingle(),
							uncompressed_reader.ReadSingle(),
							uncompressed_reader.ReadSingle()),
						//RealVector3D  tangent
						new LowLevel.Math.real_vector3d(
							uncompressed_reader.ReadSingle(),
							uncompressed_reader.ReadSingle(),
							uncompressed_reader.ReadSingle()));

					//RealPoint2D   texcoord0
					common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
						uncompressed_reader.ReadSingle(),
						(uncompressed_reader.ReadSingle() * -1) + 1));

					//RealPoint2D   texcoord1
					if (material.VertexBuffersCount2 != 0)
					{
						int position = (int)uncompressed_reader.BaseStream.Position;
						uncompressed_reader.BaseStream.Position = (material.VertexBuffersCount1 * 56) + (vertex_index * 20) + 12;

						common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
							uncompressed_reader.ReadSingle(),
							(uncompressed_reader.ReadSingle() * -1) + 1));

						uncompressed_reader.BaseStream.Position = position;
					}
					else
						common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(0, 1));

					common_vertices.Add(common_vertex);
				};
			}

			List<Part> common_parts = new List<Part>();

			// add part definitions for the lightmap materials
			// an index offset is necessary since the vertex list is global for this geometry, rather than local to each material
			int index_offset = 0;
			foreach (var material in definition.Lightmaps[index].Materials)
			{
				Part common_part = new Part(Path.GetFileNameWithoutExtension(material.Shader.ToString()));
				common_part.AddIndices(CreateIndicesBSP(definition, material.Surfaces, material.SurfaceCount, index_offset));

				index_offset += material.VertexBuffersCount1;

				common_parts.Add(common_part);
			}

			// create the geometry element
			CreateGeometry(ColladaUtilities.FormatName(tagName, " ", "_") + "-" + definition.Lightmaps[index].Bitmap.ToString(), 2,
				VertexComponent.POSITION | VertexComponent.NORMAL | VertexComponent.BINORMAL | VertexComponent.TANGENT | VertexComponent.TEXCOORD,
				common_vertices, common_parts);
		}
Example #9
0
		/// <summary>
		/// Creates a geometry element for a Halo geometry section
		/// </summary>
		/// <param name="name">The name for the geometry</param>
		/// <param name="is_skinned">Controls whether the strip indices should be treated as a triangle strip or a triangle list</param>
		/// <param name="section">The geometry section to create an element for</param>
		/// <param name="shader_names">A string list containing all of the shader names</param>
		protected void CreateGeometryHalo2(string name, bool is_skinned, 
			H2.Tags.global_geometry_section_info_struct section_info, H2.Tags.global_geometry_section_struct section, 
			List<string> shader_names)
		{
			List<Vertex> common_vertices = new List<Vertex>();
			// create a generic list of vertices
			foreach (var vertex in section.RawVertices)
			{
				Vertex common_vertex = new Vertex(
					vertex.Point.Position.ToPoint3D(100),
					vertex.Normal.ToVector3D(),
					vertex.Binormal.ToVector3D(),
					vertex.Tangent.ToVector3D());

				common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
					vertex.Texcoord.X,
					(vertex.Texcoord.Y * -1) + 1));
				common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
					vertex.SecondaryTexcoord.X,
					(vertex.SecondaryTexcoord.Y * -1) + 1));
				common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
					vertex.PrimaryLightmapTexcoord.X,
					(vertex.PrimaryLightmapTexcoord.Y * -1) + 1));

				common_vertices.Add(common_vertex);
			}

			List<Part> commom_parts = new List<Part>();
			// create the generic part definition list
			for (int part_index = 0; part_index < section.Parts.Count; part_index++)
			{
				string shader_name;
				if (shader_names.Count == 0)
					shader_name = "";
				else
					shader_name = shader_names[section.Parts[part_index].Material];

				Part common_part = new Part(shader_name);

				if(is_skinned)
					common_part.AddIndices(CreateIndicesSkinned(section, part_index));
				else
					common_part.AddIndices(CreateIndicesWorldSpace(section, part_index));

				commom_parts.Add(common_part);
			}

			// create the geometry element
			CreateGeometry(name, 3,
				VertexComponent.POSITION | VertexComponent.NORMAL | VertexComponent.BINORMAL | VertexComponent.TANGENT | VertexComponent.TEXCOORD,
				common_vertices, commom_parts);
		}
Example #10
0
		/// <summary>
		/// Creates geometry elements for all of the included geometry blocks
		/// </summary>
		void CreateGeometryList()
		{
			H1.Tags.gbxmodel_group definition = tagManager.TagDefinition as H1.Tags.gbxmodel_group;

			// create a list contining the names of all the shaders being used
			List<string> shader_names = new List<string>();
			foreach (var shader in definition.Shaders)
				shader_names.Add(Path.GetFileNameWithoutExtension(shader.Shader.ToString()));

			for (int i = 0; i < modelInfo.GetGeometryCount(); i++)
			{
				string name = ColladaUtilities.FormatName(modelInfo.GetGeometryName(i), " ", "_");
				
				List<Vertex> common_vertices = new List<Vertex>();

				H1.Tags.gbxmodel_group.model_geometry_block geometry = definition.Geometries[modelInfo.GetGeometryIndex(i)];

				// collect the vertices for all of the geometries parts
				foreach(var part in geometry.Parts)
				{
					foreach(var vertex in part.UncompressedVertices)
					{
						Vertex common_vertex = new Vertex(vertex.Position.ToPoint3D(100),
							vertex.Normal.ToVector3D(),
							vertex.Binormal.ToVector3D(),
							vertex.Tangent.ToVector3D());

						// if the texture coordinate scale is 0.0, default to 1.0
						float u_scale = (definition.BaseMapUScale.Value == 0.0f ? 1.0f : definition.BaseMapUScale.Value);
						float v_scale = (definition.BaseMapVScale.Value == 0.0f ? 1.0f : definition.BaseMapVScale.Value);

						// add the texture coordinate data
						common_vertex.AddTexcoord(new LowLevel.Math.real_point2d(
							vertex.TextureCoords.X * u_scale,
							((vertex.TextureCoords.Y * v_scale) * -1) + 1));

						common_vertices.Add(common_vertex);
					}
				}
				
				List<Part> common_parts = new List<Part>();
				// create a new Part for each geometry part
				int index_offset = 0;
				foreach(var part in geometry.Parts)
				{
					Part common_part = new Part(shader_names[part.ShaderIndex]);
					common_part.AddIndices(CreateIndicesModel(part, index_offset));

					index_offset += part.UncompressedVertices.Count;

					common_parts.Add(common_part);
				}

				// create the geometry element
				CreateGeometry(name, 1,
					VertexComponent.POSITION | VertexComponent.NORMAL | VertexComponent.BINORMAL | VertexComponent.TANGENT | VertexComponent.TEXCOORD,
					common_vertices, common_parts);
			}
		}