/// <summary>
        /// Fuse 2 model
        /// </summary>
        /// <param name="a">A</param>
        /// <param name="b">B</param>
        /// <returns>Sum</returns>
        public static WaveFrontModel operator +(WaveFrontModel a, WaveFrontModel b)
        {
            WaveFrontModel c = new WaveFrontModel();

            c.Name = a.Name;
            c.VertexData.AddRange(a.VertexData);
            c.VertexData.AddRange(b.VertexData);
            c.IndexData.AddRange(a.IndexData);

            c.IndexData.AddRange((from i in b.IndexData select(i + a.VertexData.Count)).ToArray());
            c.MeshMaterial.AddRange(a.MeshMaterial);
            c.MeshMaterial.AddRange(b.MeshMaterial);

            int tot = 0;

            foreach (int i in a.FaceCounts)
            {
                c.FaceCounts.Add(i + tot);
                tot += i;
            }

            foreach (int i in b.FaceCounts)
            {
                c.FaceCounts.Add(i + tot);
                tot += i;
            }

            return(c);
        }
Beispiel #2
0
        /// <summary>
        /// Create a mesh from wavefront obj file format using Tangent and Binormal vertex format
        /// </summary>
        /// <param name="device">Device</param>
        /// <param name="filename">Filename</param>
        /// <returns>Mesh</returns>
        public static SharpMesh CreateNormalMappedFromObj(SharpDevice device, string filename)
        {
            SharpMesh mesh = new SharpMesh(device);

            WaveFrontModel[] modelParts = WaveFrontModel.CreateFromObj(filename);
            mesh.Device  = device;
            mesh.SubSets = new List <SharpSubSet>();

            List <TangentVertex> vertices = new List <TangentVertex>();
            List <int>           indices  = new List <int>();

            int vcount = 0;
            int icount = 0;

            foreach (WaveFrontModel model in modelParts)
            {
                vertices.AddRange(model.TangentData);
                indices.AddRange(model.IndexData.Select(i => i + vcount));

                var mate = model.MeshMaterial.First();


                ShaderResourceView tex  = null;
                ShaderResourceView ntex = null;

                if (!string.IsNullOrEmpty(mate.DiffuseMap))
                {
                    string textureFile = Path.GetDirectoryName(filename) + "\\" + Path.GetFileName(mate.DiffuseMap);
                    tex = device.LoadTextureFromFile(textureFile);

                    string normalMap = Path.GetDirectoryName(textureFile) + "\\" + Path.GetFileNameWithoutExtension(textureFile) + "N" + Path.GetExtension(textureFile);
                    ntex = device.LoadTextureFromFile(normalMap);
                }

                mesh.SubSets.Add(new SharpSubSet()
                {
                    IndexCount = model.IndexData.Count,
                    StartIndex = icount,
                    DiffuseMap = tex,
                    NormalMap  = ntex
                });

                vcount += model.VertexData.Count;
                icount += model.IndexData.Count;
            }

            mesh.VertexBuffer = Buffer11.Create <TangentVertex>(device.Device, BindFlags.VertexBuffer, vertices.ToArray());
            mesh.IndexBuffer  = Buffer11.Create(device.Device, BindFlags.IndexBuffer, indices.ToArray());
            mesh.VertexSize   = SharpDX.Utilities.SizeOf <TangentVertex>();

            return(mesh);
        }
        /// <summary>
        /// Fuse 2 model
        /// </summary>
        /// <param name="a">A</param>
        /// <param name="b">B</param>
        /// <returns>Sum</returns>
        public static WaveFrontModel operator +(WaveFrontModel a, WaveFrontModel b)
        {
            WaveFrontModel c = new WaveFrontModel();

            c.Name = a.Name;
            c.VertexData.AddRange(a.VertexData);
            c.VertexData.AddRange(b.VertexData);
            c.IndexData.AddRange(a.IndexData);

            c.IndexData.AddRange((from i in b.IndexData select (i + a.VertexData.Count)).ToArray());
            c.MeshMaterial.AddRange(a.MeshMaterial);
            c.MeshMaterial.AddRange(b.MeshMaterial);

            int tot = 0;
            foreach (int i in a.FaceCounts)
            {
                c.FaceCounts.Add(i + tot);
                tot += i;
            }

            foreach (int i in b.FaceCounts)
            {
                c.FaceCounts.Add(i + tot);
                tot += i;
            }

            return c;
        }
        private static WaveFrontModel CreateGeom(string name, List<Vector3> position, List<Vector3> normals, List<Vector2> texture, List<int> faces, Material mate)
        {
            WaveFrontModel geom = new WaveFrontModel();
            geom.Name = name;
            geom.VertexData = new List<StaticVertex>();
            geom.IndexData = new List<int>();

            int stride = 0;

            if (position.Count > 0)
                stride++;

            if (normals.Count > 0)
                stride++;

            if (texture.Count > 0)
                stride++;

            int vertexCount = faces.Count / stride;

            int k = 0;

            for (int i = 0; i < vertexCount; i++)
            {
                StaticVertex v = new StaticVertex();
                if (position.Count > 0)
                {
                    v.Position = position[faces[k] - 1];
                    k++;
                }

                if (texture.Count > 0)
                {
                    v.TextureCoordinate = texture[faces[k] - 1];
                    k++;
                }

                if (normals.Count > 0)
                {
                    v.Normal = normals[faces[k] - 1];
                    k++;
                }
                geom.VertexData.Add(v);

            }

            for (int i = 0; i < (geom.VertexData.Count); i++)
            {
                geom.IndexData.Add((short)i);
            }

            geom.MeshMaterial.Add(mate);
            geom.FaceCounts.Add(geom.IndexData.Count);
            return geom;
        }
        private static WaveFrontModel Create(StreamReader reader)
        {
            WaveFrontModel geom = new WaveFrontModel();

            return geom;
        }
        private static WaveFrontModel Create(StreamReader reader)
        {
            WaveFrontModel geom = new WaveFrontModel();

            return(geom);
        }
        private static WaveFrontModel CreateGeom(string name, List <Vector3> position, List <Vector3> normals, List <Vector2> texture, List <int> faces, Material mate)
        {
            WaveFrontModel geom = new WaveFrontModel();

            geom.Name       = name;
            geom.VertexData = new List <StaticVertex>();
            geom.IndexData  = new List <int>();

            int stride = 0;


            if (position.Count > 0)
            {
                stride++;
            }


            if (normals.Count > 0)
            {
                stride++;
            }


            if (texture.Count > 0)
            {
                stride++;
            }


            int vertexCount = faces.Count / stride;

            int k = 0;


            for (int i = 0; i < vertexCount; i++)
            {
                StaticVertex v = new StaticVertex();
                if (position.Count > 0)
                {
                    v.Position = position[faces[k] - 1];
                    k++;
                }

                if (texture.Count > 0)
                {
                    v.TextureCoordinate = texture[faces[k] - 1];
                    k++;
                }

                if (normals.Count > 0)
                {
                    v.Normal = normals[faces[k] - 1];
                    k++;
                }
                geom.VertexData.Add(v);
            }

            for (int i = 0; i < (geom.VertexData.Count); i++)
            {
                geom.IndexData.Add((short)i);
            }

            geom.MeshMaterial.Add(mate);
            geom.FaceCounts.Add(geom.IndexData.Count);
            return(geom);
        }