Neodroid  0.2.0
Machine Learning Environment Prototyping Tool
Meshes.cs
Go to the documentation of this file.
1 using UnityEngine;
2 
3 namespace droid.Runtime.Utilities.GameObjects.Plotting {
4  public class Meshes {
5  public static Mesh ConeMesh() {
6  var mesh = new Mesh();
7  mesh.Clear();
8 
9  const float height = 1f;
10  const float bottom_radius = .25f;
11  const float top_radius = .05f;
12  const int nb_sides = 18;
13  const int nb_height_seg = 1; // Not implemented yet
14 
15  const int nb_vertices_cap = nb_sides + 1;
16 
17  #region Vertices
18 
19 // bottom + top + sides
20  var vertices = new Vector3[nb_vertices_cap + nb_vertices_cap + nb_sides * nb_height_seg * 2 + 2];
21  var vert = 0;
22  const float _2_pi = Mathf.PI * 2f;
23 
24 // Bottom cap
25  vertices[vert++] = new Vector3(0f, 0f, 0f);
26  while (vert <= nb_sides) {
27  var rad = (float)vert / nb_sides * _2_pi;
28  vertices[vert] = new Vector3(Mathf.Cos(rad) * bottom_radius, 0f, Mathf.Sin(rad) * bottom_radius);
29  vert++;
30  }
31 
32 // Top cap
33  vertices[vert++] = new Vector3(0f, height, 0f);
34  while (vert <= nb_sides * 2 + 1) {
35  var rad = (float)(vert - nb_sides - 1) / nb_sides * _2_pi;
36  vertices[vert] = new Vector3(Mathf.Cos(rad) * top_radius, height, Mathf.Sin(rad) * top_radius);
37  vert++;
38  }
39 
40 // Sides
41  var v = 0;
42  while (vert <= vertices.Length - 4) {
43  var rad = (float)v / nb_sides * _2_pi;
44  vertices[vert] = new Vector3(Mathf.Cos(rad) * top_radius, height, Mathf.Sin(rad) * top_radius);
45  vertices[vert + 1] = new Vector3(Mathf.Cos(rad) * bottom_radius, 0, Mathf.Sin(rad) * bottom_radius);
46  vert += 2;
47  v++;
48  }
49 
50  vertices[vert] = vertices[nb_sides * 2 + 2];
51  vertices[vert + 1] = vertices[nb_sides * 2 + 3];
52 
53  #endregion
54 
55  #region Normales
56 
57 // bottom + top + sides
58  var normales = new Vector3[vertices.Length];
59  vert = 0;
60 
61 // Bottom cap
62  while (vert <= nb_sides) {
63  normales[vert++] = Vector3.down;
64  }
65 
66 // Top cap
67  while (vert <= nb_sides * 2 + 1) {
68  normales[vert++] = Vector3.up;
69  }
70 
71 // Sides
72  v = 0;
73  while (vert <= vertices.Length - 4) {
74  var rad = (float)v / nb_sides * _2_pi;
75  var cos = Mathf.Cos(rad);
76  var sin = Mathf.Sin(rad);
77 
78  normales[vert] = new Vector3(cos, 0f, sin);
79  normales[vert + 1] = normales[vert];
80 
81  vert += 2;
82  v++;
83  }
84 
85  normales[vert] = normales[nb_sides * 2 + 2];
86  normales[vert + 1] = normales[nb_sides * 2 + 3];
87 
88  #endregion
89 
90  #region UVs
91 
92  var uvs = new Vector2[vertices.Length];
93 
94 // Bottom cap
95  var u = 0;
96  uvs[u++] = new Vector2(0.5f, 0.5f);
97  while (u <= nb_sides) {
98  var rad = (float)u / nb_sides * _2_pi;
99  uvs[u] = new Vector2(Mathf.Cos(rad) * .5f + .5f, Mathf.Sin(rad) * .5f + .5f);
100  u++;
101  }
102 
103 // Top cap
104  uvs[u++] = new Vector2(0.5f, 0.5f);
105  while (u <= nb_sides * 2 + 1) {
106  var rad = (float)u / nb_sides * _2_pi;
107  uvs[u] = new Vector2(Mathf.Cos(rad) * .5f + .5f, Mathf.Sin(rad) * .5f + .5f);
108  u++;
109  }
110 
111 // Sides
112  var u_sides = 0;
113  while (u <= uvs.Length - 4) {
114  var t = (float)u_sides / nb_sides;
115  uvs[u] = new Vector3(t, 1f);
116  uvs[u + 1] = new Vector3(t, 0f);
117  u += 2;
118  u_sides++;
119  }
120 
121  uvs[u] = new Vector2(1f, 1f);
122  uvs[u + 1] = new Vector2(1f, 0f);
123 
124  #endregion
125 
126  #region Triangles
127 
128  var nb_triangles = nb_sides + nb_sides + nb_sides * 2;
129  var triangles = new int[nb_triangles * 3 + 3];
130 
131 // Bottom cap
132  var tri = 0;
133  var i = 0;
134  while (tri < nb_sides - 1) {
135  triangles[i] = 0;
136  triangles[i + 1] = tri + 1;
137  triangles[i + 2] = tri + 2;
138  tri++;
139  i += 3;
140  }
141 
142  triangles[i] = 0;
143  triangles[i + 1] = tri + 1;
144  triangles[i + 2] = 1;
145  tri++;
146  i += 3;
147 
148 // Top cap
149 //tri++;
150  while (tri < nb_sides * 2) {
151  triangles[i] = tri + 2;
152  triangles[i + 1] = tri + 1;
153  triangles[i + 2] = nb_vertices_cap;
154  tri++;
155  i += 3;
156  }
157 
158  triangles[i] = nb_vertices_cap + 1;
159  triangles[i + 1] = tri + 1;
160  triangles[i + 2] = nb_vertices_cap;
161  tri++;
162  i += 3;
163  tri++;
164 
165 // Sides
166  while (tri <= nb_triangles) {
167  triangles[i] = tri + 2;
168  triangles[i + 1] = tri + 1;
169  triangles[i + 2] = tri + 0;
170  tri++;
171  i += 3;
172 
173  triangles[i] = tri + 1;
174  triangles[i + 1] = tri + 2;
175  triangles[i + 2] = tri + 0;
176  tri++;
177  i += 3;
178  }
179 
180  #endregion
181 
182  mesh.vertices = vertices;
183  mesh.normals = normales;
184  mesh.uv = uvs;
185  mesh.triangles = triangles;
186 
187  mesh.RecalculateBounds();
188 //mesh.Optimize();
189 
190  return mesh;
191  }
192 
193  public static Mesh SphereMesh() {
194  var mesh = new Mesh();
195  mesh.Clear();
196 
197  var radius = 1f;
198 // Longitude |||
199  var nb_long = 24;
200 // Latitude ---
201  var nb_lat = 16;
202 
203  #region Vertices
204 
205  var vertices = new Vector3[(nb_long + 1) * nb_lat + 2];
206  const float pi = Mathf.PI;
207  const float _2_pi = pi * 2f;
208 
209  vertices[0] = Vector3.up * radius;
210  for (var lat = 0; lat < nb_lat; lat++) {
211  var a1 = pi * (lat + 1) / (nb_lat + 1);
212  var sin1 = Mathf.Sin(a1);
213  var cos1 = Mathf.Cos(a1);
214 
215  for (var lon = 0; lon <= nb_long; lon++) {
216  var a2 = _2_pi * (lon == nb_long ? 0 : lon) / nb_long;
217  var sin2 = Mathf.Sin(a2);
218  var cos2 = Mathf.Cos(a2);
219 
220  vertices[lon + lat * (nb_long + 1) + 1] = new Vector3(sin1 * cos2, cos1, sin1 * sin2) * radius;
221  }
222  }
223 
224  vertices[vertices.Length - 1] = Vector3.up * -radius;
225 
226  #endregion
227 
228  #region Normales
229 
230  var normales = new Vector3[vertices.Length];
231  for (var n = 0; n < vertices.Length; n++) {
232  normales[n] = vertices[n].normalized;
233  }
234 
235  #endregion
236 
237  #region UVs
238 
239  var uvs = new Vector2[vertices.Length];
240  uvs[0] = Vector2.up;
241  uvs[uvs.Length - 1] = Vector2.zero;
242  for (var lat = 0; lat < nb_lat; lat++) {
243  for (var lon = 0; lon <= nb_long; lon++) {
244  uvs[lon + lat * (nb_long + 1) + 1] =
245  new Vector2((float)lon / nb_long, 1f - (float)(lat + 1) / (nb_lat + 1));
246  }
247  }
248 
249  #endregion
250 
251  #region Triangles
252 
253  var nb_faces = vertices.Length;
254  var nb_triangles = nb_faces * 2;
255  var nb_indexes = nb_triangles * 3;
256  var triangles = new int[nb_indexes];
257 
258 //Top Cap
259  var i = 0;
260  for (var lon = 0; lon < nb_long; lon++) {
261  triangles[i++] = lon + 2;
262  triangles[i++] = lon + 1;
263  triangles[i++] = 0;
264  }
265 
266 //Middle
267  for (var lat = 0; lat < nb_lat - 1; lat++) {
268  for (var lon = 0; lon < nb_long; lon++) {
269  var current = lon + lat * (nb_long + 1) + 1;
270  var next = current + nb_long + 1;
271 
272  triangles[i++] = current;
273  triangles[i++] = current + 1;
274  triangles[i++] = next + 1;
275 
276  triangles[i++] = current;
277  triangles[i++] = next + 1;
278  triangles[i++] = next;
279  }
280  }
281 
282 //Bottom Cap
283  for (var lon = 0; lon < nb_long; lon++) {
284  triangles[i++] = vertices.Length - 1;
285  triangles[i++] = vertices.Length - (lon + 2) - 1;
286  triangles[i++] = vertices.Length - (lon + 1) - 1;
287  }
288 
289  #endregion
290 
291  mesh.vertices = vertices;
292  mesh.normals = normales;
293  mesh.uv = uvs;
294  mesh.triangles = triangles;
295 
296  mesh.RecalculateBounds();
297  return mesh;
298  }
299  }
300 }