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());
}
public static void Front(StandardMesh mesh)
{
mesh.AddVertex(
new StandardVertex(
new Vector3(-0.5f, -0.5f, -0.5f),
new Vector3(0.0f, 0.0f, -1.0f),
new Vector2(0.0f, 0.0f)
)
);
mesh.AddVertex(
new StandardVertex(
new Vector3(0.5f, -0.5f, -0.5f),
new Vector3(0.0f, 0.0f, -1.0f),
new Vector2(1.0f, 0.0f)
)
);
mesh.AddVertex(
new StandardVertex(
new Vector3(-0.5f, 0.5f, -0.5f),
new Vector3(0.0f, 0.0f, -1.0f),
new Vector2(0.0f, 1.0f)
)
);
mesh.AddVertex(
new StandardVertex(
new Vector3(0.5f, 0.5f, -0.5f),
new Vector3(0.0f, 0.0f, -1.0f),
new Vector2(1.0f, 1.0f)
)
);
}
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);
}
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);
}
private static void Bottom(StandardMesh mesh)
{
mesh.AddVertex(
new StandardVertex(
new Vector3(-0.5f, -0.5f, 0.5f),
new Vector3(0.0f, -1.0f, 0.0f),
new Vector2(0.0f, 1.0f)
)
);
mesh.AddVertex(
new StandardVertex(
new Vector3(0.5f, -0.5f, 0.5f),
new Vector3(0.0f, -1.0f, 0.0f),
new Vector2(0.0f, 0.0f)
)
);
mesh.AddVertex(
new StandardVertex(
new Vector3(-0.5f, -0.5f, -0.5f),
new Vector3(0.0f, -1.0f, 0.0f),
new Vector2(0.0f, 1.0f)
)
);
mesh.AddVertex(
new StandardVertex(
new Vector3(0.5f, -0.5f, -0.5f),
new Vector3(0.0f, -1.0f, 0.0f),
new Vector2(1.0f, 1.0f)
)
);
}
/// <summary>
/// Construit le mesh "inverse", c'est à dire celui dont les faces
/// pointent vers l'intérieur du cube
/// </summary>
private static void BuildReverseMesh()
{
StandardMesh mesh = new StandardMesh();
Front(mesh);
Back(mesh);
Left(mesh);
Right(mesh);
Bottom(mesh);
Top(mesh);
ReverseTriangles(mesh);
mesh.ComputeNormals();
mesh.ComputeTangents();
m_reverseCubeMesh = mesh.ReturnMesh();
}
// 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());
}
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());
}
// 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());
}
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());
}
