public TRIANGLE(int pie, TRIANGLE t) {
normal = new Vector3(t.normal.x,t.normal.y, t.normal.z);
for (int i = 0; i < 3; i++) {
position.Add(new Vector3());
normals.Add(new Vector3());
tex.Add(new Vector3());
colors.Add(new Color32());
position[i] = new Vector3(t.position[i].x,t.position[i].y, t.position[i].z);
colors[i] = new Color32(255,255,255,255);
}
}
static void Main(string[] args)
{
double A, B, C, pi = 3.14159;
double TRIANGLE, CIRCLE, TRAPEZIUM, SQUARE, RECTANGLE;
string[] values = Console.ReadLine().Split(' ');
A = double.Parse(values[0], CultureInfo.InvariantCulture);
B = double.Parse(values[1], CultureInfo.InvariantCulture);
C = double.Parse(values[2], CultureInfo.InvariantCulture);
TRIANGLE = A * C / 2.0;
CIRCLE = pi * C * C;
TRAPEZIUM = (A + B) / 2.0 * C;
SQUARE = B * B;
RECTANGLE = A * B;
Console.WriteLine("TRIANGULO: " + TRIANGLE.ToString("F3", CultureInfo.InvariantCulture));
Console.WriteLine("CIRCULO: " + CIRCLE.ToString("F3", CultureInfo.InvariantCulture));
Console.WriteLine("TRAPEZIO: " + TRAPEZIUM.ToString("F3", CultureInfo.InvariantCulture));
Console.WriteLine("QUADRADO: " + SQUARE.ToString("F3", CultureInfo.InvariantCulture));
Console.WriteLine("RETANGULO: " + RECTANGLE.ToString("F3", CultureInfo.InvariantCulture));
}
//Build a unity mesh from a distance function
public static Mesh BuildUnityMesh(Vector3 fieldMin, float fieldSize, int gridDims, DistanceFunction func)
{
//calc size of 1 cell
float cellSize = fieldSize / gridDims;
//allocate and initialize position / value for every grid vertex
int vertDims = gridDims + 1;
Vector3[] gridVertPos = new Vector3[vertDims * vertDims * vertDims];
float[] gridVertVal = new float[vertDims * vertDims * vertDims];
for (int x = 0; x < vertDims; x++)
{
for (int y = 0; y < vertDims; y++)
{
for (int z = 0; z < vertDims; z++)
{
int idx = x + (y + vertDims * z) * vertDims;
Vector3 pos = new Vector3(x, y, z);
gridVertPos[idx] = pos * cellSize + fieldMin;
gridVertVal[idx] = func(gridVertPos[idx]);
}
}
}
//vertices and indices we build
List <Vector3> vertices = new List <Vector3>();
List <int> indices = new List <int>();
//buffer to contain the generated triangles
TRIANGLE[] tempTriangles = new TRIANGLE[5];
//iterate over cells
GRIDCELL[] cells = new GRIDCELL[gridDims * gridDims * gridDims];
for (int x = 0; x < gridDims; x++)
{
for (int y = 0; y < gridDims; y++)
{
for (int z = 0; z < gridDims; z++)
{
//calc cell index
int idx = x + (y + z * gridDims) * gridDims;
Vector3i cellCoord = new Vector3i(x, y, z);
//fill cell with corners of unit cube
GRIDCELL cell = new GRIDCELL();
//transform cell corners + calculate field values
cell.p = new Vector3[8];
cell.val = new float[cell.p.Length];
for (int i = 0; i < cell.p.Length; i++)
{
int globalVertIdx = CellVertToGlobalVert(gridDims, cellCoord, i);
cell.p[i] = gridVertPos[globalVertIdx];
cell.val[i] = gridVertVal[globalVertIdx];
}
//polygonise and store vertices (note: had to tweak winding order to make unity happy!)
int numTriangles = Polygonise(cell, 0.0f, tempTriangles);
for (int i = 0; i < numTriangles; i++)
{
int vidx = vertices.Count;
indices.Add(vidx + 0);
indices.Add(vidx + 1);
indices.Add(vidx + 2);
vertices.Add(tempTriangles[i].p[0]);
vertices.Add(tempTriangles[i].p[1]);
vertices.Add(tempTriangles[i].p[2]);
}
}
}
}
//build normals using central differences of field
float epsilon = 0.0001f;
Vector3 xd = Vector3.right * epsilon;
Vector3 yd = Vector3.up * epsilon;
Vector3 zd = Vector3.forward * epsilon;
List <Vector3> normals = new List <Vector3>(vertices.Count);
for (int i = 0; i < vertices.Count; i++)
{
Vector3 n = new Vector3(
func(vertices[i] + xd) - func(vertices[i] - xd),
func(vertices[i] + yd) - func(vertices[i] - yd),
func(vertices[i] + zd) - func(vertices[i] - zd));
normals.Add(n.normalized);
}
//fill and return unity mesh
Mesh m = new Mesh();
m.Clear();
m.SetVertices(vertices);
m.SetNormals(normals);
m.SetIndices(indices.ToArray(), MeshTopology.Triangles, 0);
return(m);
}
