예제 #1
0
파일: Circle.cs 프로젝트: ulisses177/Work
        public static Mesh GetMesh(int discretisation)
        {
            StandardMesh smesh = new StandardMesh();

            for (int i = 0; i < discretisation; i++)
            {
                float angleVal = 2.0f * 3.141592f * ( float )i / ( float )discretisation;

                StandardVertex svertex = new StandardVertex(
                    new Vector3(
                        ( float )Math.Cos(angleVal),
                        0.0f,
                        ( float )Math.Sin(angleVal)

                        ));

                smesh.AddVertex(svertex);
            }

            for (int i = 0; i < discretisation - 1; i++)
            {
                smesh.AddFace(0, i, i + 1);
            }

            smesh.ComputeNormals();
            smesh.ComputeTangents();
            return(smesh.ReturnMesh());
        }
예제 #2
0
        // Public

        // Static Methods

        /// <summary>
        /// Retourne un cylindre, la valeur passé en paramètre détermine le niveau de
        /// détail du cylindre
        /// </summary>
        public static Mesh GetMesh(int discretisation)
        {
            StandardMesh smesh = new StandardMesh();

            // On commence par crée les points du cercle qui forme la base du cylindre
            for (int i = 0; i < discretisation; i++)
            {
                float angleVal = 2.0f * 3.141592f * (float)i / (float)discretisation;

                StandardVertex svertex = new StandardVertex(
                    new Vector3(
                        (float)Math.Cos(angleVal),
                        0.0f,
                        (float)Math.Sin(angleVal)

                        ));

                smesh.AddVertex(svertex);
            }

            for (int i = 0; i < discretisation - 1; i++)
            {
                smesh.AddFace(0, i, i + 1);
            }

            int meshOffset = smesh.GetVertexCount();

            // On commence par crée un deuxième cercle en haut du cylindre
            for (int i = 0; i < discretisation; i++)
            {
                float angleVal = 2.0f * 3.141592f * (float)i / (float)discretisation;

                StandardVertex svertex = new StandardVertex(
                    new Vector3(
                        (float)Math.Cos(angleVal),
                        1.0f,
                        (float)Math.Sin(angleVal)

                        ));

                smesh.AddVertex(svertex);
            }

            for (int i = 0; i < discretisation - 1; i++)
            {
                smesh.AddFace(meshOffset, meshOffset + i + 1, meshOffset + i);
            }

            meshOffset = smesh.GetVertexCount();

            // On Crée encore une fois le cercle à la base et en haut du cylindre pour éviter les souscis de normales
            for (int i = 0; i < discretisation; i++)
            {
                float angleVal = 2.0f * 3.141592f * (float)i / (float)discretisation;

                StandardVertex svertex = new StandardVertex(
                    new Vector3(
                        (float)Math.Cos(angleVal),
                        0.0f,
                        (float)Math.Sin(angleVal)

                        ));

                smesh.AddVertex(svertex);
            }
            // On Crée encore une fois le cercle à la base et en haut du cylindre pour éviter les souscis de normales
            for (int i = 0; i < discretisation; i++)
            {
                float angleVal = 2.0f * 3.141592f * (float)i / (float)discretisation;

                StandardVertex svertex = new StandardVertex(
                    new Vector3(
                        (float)Math.Cos(angleVal),
                        1.0f,
                        (float)Math.Sin(angleVal)

                        ));

                smesh.AddVertex(svertex);
            }


            for (int i = 0; i < discretisation - 1; i++)
            {
                smesh.AddFace(meshOffset + i, meshOffset + discretisation + i, meshOffset + i + 1);
                smesh.AddFace(meshOffset + i + 1, meshOffset + discretisation + i, meshOffset + discretisation + i + 1);
            }

            smesh.AddFace(meshOffset + discretisation - 1, meshOffset + discretisation + discretisation - 1, meshOffset);
            smesh.AddFace(meshOffset, meshOffset + discretisation + discretisation - 1, meshOffset + discretisation);
            //smesh.AddFace(meshOffset + i + 1, meshOffset + discretisation + i, meshOffset + discretisation + i + 1);

            smesh.ComputeNormals();
            smesh.ComputeTangents();
            return(smesh.ReturnMesh());
        }
예제 #3
0
        public static Mesh LoadObj(string file)
        {
            string filename = "E:\\dev\\c#\\Work\\Resources\\" + file;

            StreamReader stream = new StreamReader(filename);

            List <float>      Vertices     = new List <float>();
            List <float>      Normals      = new List <float>();
            List <float>      Textures     = new List <float>();
            List <MeshVertex> meshVertices = new List <MeshVertex>();



            List <FaceObj> ObjFaces = new List <FaceObj>();


            // On commence par lire l'intégrité du fichier. Dans le processus, on récupère les informations
            // sur les sommets et les faces
            while (!stream.EndOfStream)
            {
                string line = stream.ReadLine();

                if (line.Count() > 0)
                {
                    if (line[0] != ' ' && line[0] != '#')
                    {
                        char[] chars =
                        {
                            ' ',
                            '\t'
                        };

                        line = line.Trim();
                        RegexOptions options = RegexOptions.None;

                        // { 2,} signifie 2 fois au moins
                        // [] est un ensemble de caractère
                        Regex regex = new Regex(@"[ ]{2,}", options);
                        line = regex.Replace(line, @" ");

                        string[] splits = line.Split(' ');

                        // Si la ligne débute par v, on ajoute un sommet
                        if (splits[0] == "v")
                        {
                            for (int i = 1; i < splits.Count(); i++)
                            {
                                Vertices.Add(float.Parse(splits[i].Replace('.', ',')));
                            }
                        }
                        // Si la ligne débute par vn, on ajoute une normale
                        if (splits[0] == "vn")
                        {
                            for (int i = 1; i < splits.Count(); i++)
                            {
                                Normals.Add(float.Parse(splits[i].Replace('.', ',')));
                            }
                        }

                        // Si la ligne débute par vt, on ajoute une coordonnée de texture
                        if (splits[0] == "vt")
                        {
                            for (int i = 1; i < splits.Count(); i++)
                            {
                                Textures.Add(float.Parse(splits[i].Replace('.', ',')));
                            }
                        }

                        // Si la ligne débute par f, on ajoute une face
                        if (splits[0] == "f")
                        {
                            FaceObj fobj = new FaceObj();
                            ObjFaces.Add(fobj);

                            for (int i = 1; i < splits.Count(); i++)
                            {
                                string[] secondsplit = splits[i].Split('/');
                                int[]    vertex      = new int[secondsplit.Length];

                                for (int j = 0; j < secondsplit.Count(); j++)
                                {
                                    // Position
                                    if (j == 0)
                                    {
                                        int result;
                                        if (int.TryParse(secondsplit[j], out result))
                                        {
                                            fobj.IndexesVertice.Add(result);
                                        }
                                    }
                                    // Textures
                                    if (j == 1)
                                    {
                                        int result;
                                        if (int.TryParse(secondsplit[j], out result))
                                        {
                                            fobj.IndexesTexture.Add(result);
                                        }
                                        else
                                        {
                                            //fobj.IndexesNormal.Add( -1 );
                                        }
                                    }
                                    // Normals
                                    if (j == 2)
                                    {
                                        int result;
                                        if (int.TryParse(secondsplit[j], out result))
                                        {
                                            fobj.IndexesNormal.Add(result);
                                        }
                                        else
                                        {
                                            // fobj.IndexesTexture.Add( -1 );
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            StandardMesh mesh = new StandardMesh();

            for (int i = 0; i < ObjFaces.Count; i++)
            {
                // On va construire les sommets à partir des indices
                // Tout en essayant de ne pas dupliquer les sommets
                for (int j = 0; j < ObjFaces[i].IndexesVertice.Count; j++)
                {
                    Vector3 normal = new Vector3(0.0f, 0.0f, 0.0F);
                    Vector2 tex    = new Vector2(0.0f, 0.0f);

                    int vertexIndex  = ObjFaces[i].IndexesVertice[j] - 1;
                    int normalIndex  = -1;
                    int textureIndex = -1;

                    if (ObjFaces[i].IndexesNormal.Count > 0)
                    {
                        normalIndex = ObjFaces[i].IndexesNormal[j] - 1;
                        normal      = new Vector3(Normals[normalIndex * 3], Normals[normalIndex * 3 + 1], Normals[normalIndex * 3 + 2]);
                    }

                    if (ObjFaces[i].IndexesTexture.Count > 0)
                    {
                        textureIndex = ObjFaces[i].IndexesTexture[j] - 1;
                        tex          = new Vector2(Textures[textureIndex * 2], Textures[textureIndex * 2 + 1]);
                    }
                    MeshVertex mv    = new MeshVertex(vertexIndex, normalIndex, textureIndex);
                    int        index = MeshVertex.Exist(meshVertices, mv);
                    // Si on a pas déjà eu cette combinaison d'indice, on ajoute un nouveau sommet
                    if (index == -1)
                    {
                        meshVertices.Add(mv);
                        mesh.AddVertex
                        (
                            new StandardVertex
                            (
                                new Vector3(Vertices[vertexIndex * 3], Vertices[vertexIndex * 3 + 1], Vertices[vertexIndex * 3 + 2]),
                                normal,
                                tex
                            )
                        );
                        ObjFaces[i].RealIndex.Add(meshVertices.Count - 1);
                    }
                    else
                    {
                        ObjFaces[i].RealIndex.Add(index);
                    }
                }
            }

            // Pour le moment je ne gère que les obj contenant des triangles ou des carrés
            for (int i = 0; i < ObjFaces.Count; i++)
            {
                mesh.AddFace(ObjFaces[i].RealIndex[0], ObjFaces[i].RealIndex[1], ObjFaces[i].RealIndex[2]);

                if (ObjFaces[i].IndexesVertice.Count == 4)
                {
                    mesh.AddFace(ObjFaces[i].RealIndex[0], ObjFaces[i].RealIndex[2], ObjFaces[i].RealIndex[3]);
                }
            }

            if (Normals.Count == 0)
            {
                mesh.ComputeNormals();
            }

            return(mesh.ReturnMesh());
        }
예제 #4
0
파일: Cone.cs 프로젝트: ulisses177/Work
        // Public

        // Static Methods

        /// <summary>
        /// Crée un nouveau cône dont le cercle de base est composé du nombre
        /// de sommet passé en paramètre
        /// </summary>
        /// <param name="discretisation"></param>
        /// <returns></returns>
        public static Mesh GetMesh(int discretisation)
        {
            StandardMesh smesh = new StandardMesh();

            // On commence par crée les points du cercle qui forme la base du cône
            for (int i = 0; i < discretisation; i++)
            {
                float angleVal = 2.0f * 3.141592f * (float)i / (float)discretisation;

                StandardVertex svertex = new StandardVertex(
                    new Vector3(
                        (float)Math.Cos(angleVal),
                        0.0f,
                        (float)Math.Sin(angleVal)

                        ));

                smesh.AddVertex(svertex);
            }

            smesh.AddVertex(new StandardVertex(new Vector3(0.0f, 1.0f, 0.0f)));


            for (int i = 0; i < discretisation - 1; i++)
            {
                smesh.AddFace(i + 1, i, smesh.GetVertexCount() - 1);
            }

            smesh.AddFace(0, smesh.GetVertexCount() - 2, smesh.GetVertexCount() - 1);

            // On construit la base


            int startSecondCircle = smesh.GetVertexCount();

            // On Crée une deuxième fois les sommets à la base du cone pour éviter les problèmes
            // de normales (comme le cube par exemple)
            for (int i = 0; i < discretisation; i++)
            {
                float angleVal = 2.0f * 3.141592f * (float)i / (float)discretisation;

                StandardVertex svertex = new StandardVertex(
                    new Vector3(
                        (float)Math.Cos(angleVal),
                        0.0f,
                        (float)Math.Sin(angleVal)

                        ));

                smesh.AddVertex(svertex);
            }


            for (int i = 0; i < discretisation - 1; i++)
            {
                smesh.AddFace(startSecondCircle, startSecondCircle + i, startSecondCircle + i + 1);
            }

            smesh.ComputeNormals();
            smesh.ComputeTangents();

            return(smesh.ReturnMesh());
        }
예제 #5
0
        public static Mesh Mesh(float radius, int xdiscretisation, int ydiscretisation)
        {
            StandardMesh mesh = new StandardMesh();

            List <StandardVertex> vertices = new List <StandardVertex>();
            List <int>            indices_ = new List <int>();

            // Création des sommets

            mesh.AddVertex(new StandardVertex(
                               new Vector3(0.0f, -radius, 0.0f),
                               new Vector3(0.0f, -1.0f, 0.0f),
                               new Vector2(0.0f, 0.0f)
                               ));

            for (int i = 0; i < ydiscretisation; ++i)
            {
                for (int j = 0; j < xdiscretisation; ++j)
                {
                    float val = (float)Math.PI * (float)i / (float)ydiscretisation;
                    val = -(float)Math.Cos(val);

                    Vector3 position = new Vector3(
                        (float)Math.Sin(Math.PI * i / (float)ydiscretisation) * (float)Math.Cos(2.0f * Math.PI * j / xdiscretisation) * radius,
                        val * radius,
                        (float)Math.Sin(Math.PI * i / (float)ydiscretisation) * (float)Math.Sin(2.0f * Math.PI * j / xdiscretisation) * radius);

                    Vector3 normal = position;
                    normal.Normalize();
                    mesh.AddVertex(
                        new StandardVertex(
                            position,
                            normal,
                            new Vector2((float)j / (float)xdiscretisation, (float)i / (float)ydiscretisation)
                            ));
                }
            }

            mesh.AddVertex(new StandardVertex(
                               new Vector3(0.0f, radius, 0.0f),
                               new Vector3(0.0f, 1.0f, 0.0f),
                               new Vector2(0.0f, 1.0f)
                               ));

            // Création des faces
            for (int i = 0; i < xdiscretisation - 1; i++)
            {
                indices_.Add(0);
                indices_.Add(i + 1);
                indices_.Add(i + 2);
            }


            indices_.Add(0);
            indices_.Add(xdiscretisation);
            indices_.Add(1);

            for (int i = 0; i < ydiscretisation - 1; i++)
            {
                for (int j = 0; j < xdiscretisation - 1; j++)
                {
                    mesh.AddFace(
                        1 + xdiscretisation * i + j,        // 1
                        1 + xdiscretisation * (i + 1) + j,  // 5
                        1 + xdiscretisation * i + j + 1);   // 2

                    mesh.AddFace(
                        (1 + xdiscretisation * i + j + 1),        // 2
                        (1 + xdiscretisation * (i + 1) + j),      // 5
                        (1 + xdiscretisation * (i + 1) + j + 1)); // 6
                }

                mesh.AddFace(
                    (1 + xdiscretisation * (i + 1) - 1), // 4
                    (1 + xdiscretisation * (i + 1)),     // 5
                    (1 + xdiscretisation * i));          // 1

                mesh.AddFace(
                    (1 + xdiscretisation * (i + 1) - 1),                   // 4
                    (1 + xdiscretisation * (i + 1) + xdiscretisation - 1), // 5
                    (1 + xdiscretisation * (i + 1)));                      // 5
            }

            for (int i = 1; i < xdiscretisation; i++)
            {
                mesh.AddFace(
                    (mesh.GetVertexCount() - i - 2),
                    (mesh.GetVertexCount() - 1),
                    (mesh.GetVertexCount() - i - 1));
            }

            mesh.AddFace(
                (mesh.GetVertexCount() - 2),
                (mesh.GetVertexCount() - 1),
                (mesh.GetVertexCount() - xdiscretisation - 1));

            //mesh.ComputeNormals();
            mesh.ComputeTangents();



            return(mesh.ReturnMesh());
        }
예제 #6
0
파일: Cube.cs 프로젝트: ulisses177/Work
        private static void ReverseTriangles(StandardMesh mesh)
        {
            // front
            mesh.AddFace(0, 3, 2);
            mesh.AddFace(0, 1, 3);

            // Back
            mesh.AddFace(5, 6, 7);
            mesh.AddFace(5, 4, 6);

            // Left
            mesh.AddFace(9, 8, 10);
            mesh.AddFace(9, 10, 11);

            // Right
            mesh.AddFace(12, 15, 14);
            mesh.AddFace(12, 13, 15);

            // Bottom
            mesh.AddFace(16, 19, 18);
            mesh.AddFace(16, 17, 19);

            // top

            mesh.AddFace(20, 23, 22);
            mesh.AddFace(20, 21, 23);
        }
예제 #7
0
파일: Cube.cs 프로젝트: ulisses177/Work
        private static void Triangles(StandardMesh mesh)
        {
            // front
            mesh.AddFace(0, 2, 3);
            mesh.AddFace(0, 3, 1);

            // Back
            mesh.AddFace(5, 7, 6);
            mesh.AddFace(5, 6, 4);

            // Left
            mesh.AddFace(9, 10, 8);
            mesh.AddFace(9, 11, 10);

            // Right
            mesh.AddFace(12, 14, 15);
            mesh.AddFace(12, 15, 13);

            // Bottom
            mesh.AddFace(16, 18, 19);
            mesh.AddFace(16, 19, 17);

            // top

            mesh.AddFace(20, 22, 23);
            mesh.AddFace(20, 23, 21);
        }