public static void create(string name, List <Vector2> verticesList, float zOffset)
{
Material sideMaterial;
GeometryLoader gl = GameObject.Find("GeometryLoader").GetComponent <GeometryLoader>();
sideMaterial = gl.theme.getWallsMaterialST();
GameObject floor = new GameObject(name, typeof(MeshFilter), typeof(MeshRenderer));
MeshFilter mesh_filter = floor.GetComponent <MeshFilter>();
Mesh mesh = mesh_filter.mesh;
floor.GetComponent <Renderer>().material = sideMaterial;
mesh.Clear();
floor.GetComponent <Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
floor.GetComponent <Renderer>().material = sideMaterial;
Vector2[] vertices2D = verticesList.ToArray();
Triangulator tr = new Triangulator(vertices2D);
int[] indices = tr.Triangulate();
// Create the Vector3 vertices
Vector3[] vertices = new Vector3[vertices2D.Length];
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = new Vector3(vertices2D[i].x, zOffset + 0.05f, vertices2D[i].y);
}
// Create the mesh
mesh = TangentHelper.TangentSolver(mesh);
mesh.vertices = vertices;
mesh.triangles = indices;
mesh.RecalculateBounds();
}
public static void create(string name, List <Vector2> coordFirst, List <Vector2> coordSecond, float A_x, float B_y, float C_z, float pxUp, float pyUp, float pxDown, float pyDown)
{
Material topMaterial;
GeometryLoader gl = GameObject.Find("GeometryLoader").GetComponent <GeometryLoader>();
topMaterial = gl.theme.getWallsMaterial();
GameObject stair = new GameObject(name, typeof(MeshFilter), typeof(MeshRenderer));
MeshFilter mesh_filter = stair.GetComponent <MeshFilter>();
Mesh mesh = mesh_filter.mesh;
mesh.Clear();
stair.GetComponent <Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
stair.GetComponent <Renderer>().material = topMaterial;
#region Vertices
Vector2 origin = new Vector2((pxDown + pxUp) / 2, (pyDown + pyUp) / 2);
Vector2[] pointsArray = new Vector2[]
{
coordFirst[0],
coordFirst[1],
coordSecond[0],
coordSecond[1]
};
float[] angles = angleToOrigin(pointsArray, origin).ToArray();
Array.Sort(angles, pointsArray);
Vector3[] p = generateEdges(pointsArray, A_x, B_y, C_z).ToArray();
Vector3[] vertices = new Vector3[]
{
// Bottom
p[0], p[1], p[2], p[3],
// Left
p[7], p[4], p[0], p[3],
// Front
p[4], p[5], p[1], p[0],
// Back
p[6], p[7], p[3], p[2],
// Right
p[5], p[6], p[2], p[1],
// Top
p[7], p[6], p[5], p[4]
};
#endregion
#region Normals
Vector3 up = Vector3.up;
Vector3 down = Vector3.down;
Vector3 front = Vector3.forward;
Vector3 back = Vector3.back;
Vector3 left = Vector3.left;
Vector3 right = Vector3.right;
Vector3[] normals = new Vector3[]
{
// Bottom
down, down, down, down,
// Left
left, left, left, left,
// Front
front, front, front, front,
// Back
back, back, back, back,
// Right
right, right, right, right,
// Top
up, up, up, up
};
#endregion
#region UVs
float lenghtRelX = 1; //(float) Math.Sqrt(Math.Pow(p[1].x - p[0].x, 2) + Math.Pow(p[1].y - p[0].y, 2)); //calculate actual length of stairs for correct texture mapping
float lenghtRelY = 1; //(float) Math.Sqrt(Math.Pow(p[2].z - p[1].z, 2) + Math.Pow(p[2].y - p[1].y, 2));
//Debug.Log(lenghtRelX + " " + lenghtRelY);
Vector2 _00 = new Vector2(0f, 0f);
Vector2 _10 = new Vector2(lenghtRelX, 0f);
Vector2 _01 = new Vector2(0f, lenghtRelY);
Vector2 _11 = new Vector2(lenghtRelX, lenghtRelY);
Vector2[] uvs = new Vector2[]
{
// Bottom
_11, _01, _00, _10,
// Left
_11, _01, _00, _10,
// Front
_11, _01, _00, _10,
// Back
_11, _01, _00, _10,
// Right
_11, _01, _00, _10,
// Top
_11, _01, _00, _10,
};
#endregion
#region Triangles
int[] triangles = new int[]
{
// Bottom
3, 1, 0,
3, 2, 1,
// Left
3 + 4 * 1, 1 + 4 * 1, 0 + 4 * 1,
3 + 4 * 1, 2 + 4 * 1, 1 + 4 * 1,
// Front
3 + 4 * 2, 1 + 4 * 2, 0 + 4 * 2,
3 + 4 * 2, 2 + 4 * 2, 1 + 4 * 2,
// Back
3 + 4 * 3, 1 + 4 * 3, 0 + 4 * 3,
3 + 4 * 3, 2 + 4 * 3, 1 + 4 * 3,
// Right
3 + 4 * 4, 1 + 4 * 4, 0 + 4 * 4,
3 + 4 * 4, 2 + 4 * 4, 1 + 4 * 4,
// Top
3 + 4 * 5, 1 + 4 * 5, 0 + 4 * 5,
3 + 4 * 5, 2 + 4 * 5, 1 + 4 * 5,
};
#endregion
mesh = TangentHelper.TangentSolver(mesh);
mesh.vertices = vertices;
mesh.normals = normals;
mesh.uv = uvs;
mesh.triangles = triangles;
mesh.RecalculateBounds();
}
public static void create(string name, List <Vector2> verticesList, float height, float zOffset, Material topMaterial, Material sideMaterial)
{
GameObject obstacle = new GameObject(name, typeof(MeshFilter), typeof(MeshRenderer));
MeshFilter mesh_filter = obstacle.GetComponent <MeshFilter> ();
//Shadows currently disabled for TopMaterial -> switch on by ShadowCastingMode.On
obstacle.GetComponent <Renderer>().shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
obstacle.GetComponent <Renderer>().material = topMaterial;
Vector2[] vertices2D = verticesList.ToArray();
// Use the triangulator to get indices for creating triangles
Triangulator tr = new Triangulator(vertices2D);
int[] indicesArray = tr.Triangulate();
List <int> indices = new List <int>();
for (int i = 0; i < indicesArray.Length; i++)
{
indices.Add(indicesArray[i]);
}
// Create the Vector3 vertices
List <Vector3> vertices = new List <Vector3>();
for (int i = 0; i < vertices2D.Length; i++)
{
vertices.Add(new Vector3(vertices2D[i].x, zOffset + height, vertices2D[i].y));
}
// Create the mesh
Mesh mesh = new Mesh();
GameObject walls = new GameObject(name + "_side", typeof(MeshFilter), typeof(MeshRenderer));
MeshFilter mesh_filter_walls = walls.GetComponent <MeshFilter> ();
walls.GetComponent <Renderer>().material = sideMaterial;
List <Vector2> uvs_walls = new List <Vector2>();
List <Vector3> vertices_walls = new List <Vector3>();
List <int> indices_walls = new List <int>();
foreach (Vector3 v in vertices)
{
vertices_walls.Add(new Vector3(v.x, zOffset, v.z));
vertices_walls.Add(new Vector3(v.x, zOffset, v.z));
vertices_walls.Add(new Vector3(v.x, height + zOffset, v.z));
vertices_walls.Add(new Vector3(v.x, height + zOffset, v.z));
}
for (int i = 1; i <= vertices_walls.Count; i = i + 4)
{
indices_walls.Add(i);
indices_walls.Add((i + 3) % vertices_walls.Count);
indices_walls.Add(i + 2);
indices_walls.Add(i + 2);
indices_walls.Add((i + 3) % vertices_walls.Count);
indices_walls.Add((i + 5) % vertices_walls.Count);
}
//double sided walls
int indices_walls_count = indices_walls.Count;
for (int i = indices_walls_count - 1; i >= 0; i--)
{
indices_walls.Add(indices_walls[i]);
}
for (int i = 0; i < vertices_walls.Count; i++)
{
float uv_height = height;
int a = i - 3;
if (a < 0)
{
a = a + vertices_walls.Count;
}
float uv_width = Vector3.Distance(vertices_walls[i], vertices_walls[a]);
if ((i - 1) % 4 == 0)
{
uvs_walls.Add(new Vector2(0, 0));
}
else if ((i - 3) % 4 == 0)
{
uvs_walls.Add(new Vector2(0, uv_height));
}
else if (i % 4 == 0)
{
uvs_walls.Add(new Vector2(uv_width, 0));
}
else
{
uvs_walls.Add(new Vector2(uv_width, uv_height));
}
}
Mesh mesh_walls = new Mesh();
mesh_walls.vertices = vertices_walls.ToArray();
mesh_walls.uv = uvs_walls.ToArray();
mesh_walls.triangles = indices_walls.ToArray();
mesh_walls.RecalculateNormals();
mesh_walls.RecalculateBounds();
mesh_walls = TangentHelper.TangentSolver(mesh_walls);
mesh_filter_walls.mesh = mesh_walls;
mesh.vertices = vertices.ToArray();
mesh.uv = verticesList.ToArray();
mesh.triangles = indices.ToArray();
mesh.RecalculateNormals();
mesh.RecalculateBounds();
//flip if needed
if (mesh.normals [0].y == -1)
{
indices.Reverse();
mesh.triangles = indices.ToArray();
mesh.RecalculateNormals();
}
mesh = TangentHelper.TangentSolver(mesh);
mesh_filter.mesh = mesh;
}
