New LX UI
[SugarCubes.git] / Model.pde
1 /**
2 * DOUBLE BLACK DIAMOND DOUBLE BLACK DIAMOND
3 *
4 * //\\ //\\ //\\ //\\
5 * ///\\\ ///\\\ ///\\\ ///\\\
6 * \\\/// \\\/// \\\/// \\\///
7 * \\// \\// \\// \\//
8 *
9 * EXPERTS ONLY!! EXPERTS ONLY!!
10 *
11 * Contains the model definitions for the cube structures.
12 */
13
14 /**
15 * Top-level model of the entire sculpture. This contains a list of
16 * every cube on the sculpture, which forms a hierarchy of faces, strips
17 * and points.
18 */
19 public static class Model extends LXModel {
20
21 public final List<Tower> towers;
22 public final List<Cube> cubes;
23 public final List<Face> faces;
24 public final List<Strip> strips;
25
26 private final Cube[] _cubes;
27
28 public Model(List<Tower> towerList, Cube[] cubeArr) {
29 super(new Fixture(cubeArr));
30 Fixture fixture = (Fixture) this.fixtures.get(0);
31
32 _cubes = cubeArr;
33
34 // Make unmodifiable accessors to the model data
35 List<Cube> cubeList = new ArrayList<Cube>();
36 List<Face> faceList = new ArrayList<Face>();
37 List<Strip> stripList = new ArrayList<Strip>();
38 for (Cube cube : _cubes) {
39 if (cube != null) {
40 cubeList.add(cube);
41 for (Face face : cube.faces) {
42 faceList.add(face);
43 for (Strip strip : face.strips) {
44 stripList.add(strip);
45 }
46 }
47 }
48 }
49
50 this.towers = Collections.unmodifiableList(towerList);
51 this.cubes = Collections.unmodifiableList(cubeList);
52 this.faces = Collections.unmodifiableList(faceList);
53 this.strips = Collections.unmodifiableList(stripList);
54 }
55
56 private static class Fixture extends LXAbstractFixture {
57
58 private Fixture(Cube[] cubeArr) {
59 for (Cube cube : cubeArr) {
60 if (cube != null) {
61 for (LXPoint point : cube.points) {
62 this.points.add(point);
63 }
64 }
65 }
66 }
67 }
68
69 /**
70 * TODO(mcslee): figure out better solution
71 *
72 * @param index
73 * @return
74 */
75 public Cube getCubeByRawIndex(int index) {
76 return _cubes[index];
77 }
78 }
79
80 /**
81 * Model of a set of cubes stacked in a tower
82 */
83 public static class Tower extends LXModel {
84 /**
85 * Immutable list of cubes
86 */
87 public final List<Cube> cubes;
88
89 /**
90 * Immutable list of faces
91 */
92 public final List<Face> faces;
93
94 /**
95 * Immutable list of strips
96 */
97 public final List<Strip> strips;
98
99 /**
100 * Constructs a tower model from these cubes
101 *
102 * @param cubes Array of cubes
103 */
104 public Tower(List<Cube> cubes) {
105 super(cubes.toArray(new Cube[] {}));
106
107 List<Cube> cubeList = new ArrayList<Cube>();
108 List<Face> faceList = new ArrayList<Face>();
109 List<Strip> stripList = new ArrayList<Strip>();
110
111 for (Cube cube : cubes) {
112 cubeList.add(cube);
113 for (Face face : cube.faces) {
114 faceList.add(face);
115 for (Strip strip : face.strips) {
116 stripList.add(strip);
117 }
118 }
119 }
120 this.cubes = Collections.unmodifiableList(cubeList);
121 this.faces = Collections.unmodifiableList(faceList);
122 this.strips = Collections.unmodifiableList(stripList);
123 }
124 }
125
126 /**
127 * Model of a single cube, which has an orientation and position on the
128 * car. The position is specified in x,y,z coordinates with rotation. The
129 * x axis is left->right, y is bottom->top, and z is front->back.
130 *
131 * A cube's x,y,z position is specified as the left, bottom, front corner.
132 *
133 * Dimensions are all specified in real-world inches.
134 */
135 public static class Cube extends LXModel {
136
137 public final static int FACES_PER_CUBE = 4;
138 public static final int POINTS_PER_STRIP = 16;
139
140 public final static int STRIPS_PER_CUBE = FACES_PER_CUBE*Face.STRIPS_PER_FACE;
141 public final static int POINTS_PER_CUBE = STRIPS_PER_CUBE*POINTS_PER_STRIP;
142 public final static int POINTS_PER_FACE = Face.STRIPS_PER_FACE*POINTS_PER_STRIP;
143
144 public final static float EDGE_HEIGHT = 21.75f;
145 public final static float EDGE_WIDTH = 24.625f;
146 public final static float CHANNEL_WIDTH = 1.5f;
147
148 public final static Face.Metrics FACE_METRICS = new Face.Metrics(
149 new Strip.Metrics(EDGE_WIDTH, POINTS_PER_STRIP),
150 new Strip.Metrics(EDGE_HEIGHT, POINTS_PER_STRIP)
151 );
152
153 /**
154 * Immutable list of all cube faces
155 */
156 public final List<Face> faces;
157
158 /**
159 * Immutable list of all strips
160 */
161 public final List<Strip> strips;
162
163 /**
164 * Front left corner x coordinate
165 */
166 public final float x;
167
168 /**
169 * Front left corner y coordinate
170 */
171 public final float y;
172
173 /**
174 * Front left corner z coordinate
175 */
176 public final float z;
177
178 /**
179 * Rotation about the x-axis
180 */
181 public final float rx;
182
183 /**
184 * Rotation about the y-axis
185 */
186 public final float ry;
187
188 /**
189 * Rotation about the z-axis
190 */
191 public final float rz;
192
193 public Cube(double x, double y, double z, double rx, double ry, double rz) {
194 this((float) x, (float) y, (float) z, (float) rx, (float) ry, (float) rz);
195 }
196
197 public Cube(float x, float y, float z, float rx, float ry, float rz) {
198 super(new Fixture(x, y, z, rx, ry, rz));
199 Fixture fixture = (Fixture) this.fixtures.get(0);
200
201 while (rx < 0) rx += 360;
202 while (ry < 0) ry += 360;
203 while (rz < 0) rz += 360;
204 rx = rx % 360;
205 ry = ry % 360;
206 rz = rz % 360;
207
208 this.x = x;
209 this.y = y;
210 this.z = z;
211 this.rx = rx;
212 this.ry = ry;
213 this.rz = rz;
214
215 this.faces = Collections.unmodifiableList(fixture.faces);
216 this.strips = Collections.unmodifiableList(fixture.strips);
217 }
218
219 private static class Fixture extends LXAbstractFixture {
220
221 private final List<Face> faces = new ArrayList<Face>();
222 private final List<Strip> strips = new ArrayList<Strip>();
223
224 private Fixture(float x, float y, float z, float rx, float ry, float rz) {
225 LXTransform t = new LXTransform();
226 t.translate(x, y, z);
227 t.rotateX(rx * PI / 180.);
228 t.rotateY(ry * PI / 180.);
229 t.rotateZ(rz * PI / 180.);
230
231 for (int i = 0; i < FACES_PER_CUBE; i++) {
232 Face face = new Face(FACE_METRICS, (ry + 90*i) % 360, t);
233 this.faces.add(face);
234 for (Strip s : face.strips) {
235 this.strips.add(s);
236 }
237 for (LXPoint p : face.points) {
238 this.points.add(p);
239 }
240 t.translate(EDGE_WIDTH, 0, 0);
241 t.rotateY(HALF_PI);
242 }
243 }
244 }
245 }
246
247 /**
248 * A face is a component of a cube. It is comprised of four strips forming
249 * the lights on this side of a cube. A whole cube is formed by four faces.
250 */
251 public static class Face extends LXModel {
252
253 public final static int STRIPS_PER_FACE = 4;
254
255 public static class Metrics {
256 final Strip.Metrics horizontal;
257 final Strip.Metrics vertical;
258
259 public Metrics(Strip.Metrics horizontal, Strip.Metrics vertical) {
260 this.horizontal = horizontal;
261 this.vertical = vertical;
262 }
263 }
264
265 /**
266 * Immutable list of strips
267 */
268 public final List<Strip> strips;
269
270 /**
271 * Rotation of the face about the y-axis
272 */
273 public final float ry;
274
275 Face(Metrics metrics, float ry, LXTransform transform) {
276 super(new Fixture(metrics, ry, transform));
277 Fixture fixture = (Fixture) this.fixtures.get(0);
278 this.ry = ry;
279 this.strips = Collections.unmodifiableList(fixture.strips);
280 }
281
282 private static class Fixture extends LXAbstractFixture {
283
284 private final List<Strip> strips = new ArrayList<Strip>();
285
286 private Fixture(Metrics metrics, float ry, LXTransform transform) {
287 transform.push();
288 transform.translate(0, metrics.vertical.length, 0);
289 for (int i = 0; i < STRIPS_PER_FACE; i++) {
290 boolean isHorizontal = (i % 2 == 0);
291 Strip.Metrics stripMetrics = isHorizontal ? metrics.horizontal : metrics.vertical;
292 Strip strip = new Strip(stripMetrics, ry, transform, isHorizontal);
293 this.strips.add(strip);
294 transform.translate(isHorizontal ? metrics.horizontal.length : metrics.vertical.length, 0, 0);
295 transform.rotateZ(HALF_PI);
296 for (LXPoint p : strip.points) {
297 this.points.add(p);
298 }
299 }
300 transform.pop();
301 }
302 }
303 }
304
305 /**
306 * A strip is a linear run of points along a single edge of one cube.
307 */
308 public static class Strip extends LXModel {
309
310 public static final float POINT_SPACING = 18.625f / 15.f;
311
312 public static class Metrics {
313
314 public final float length;
315 public final int numPoints;
316
317 public Metrics(float length, int numPoints) {
318 this.length = length;
319 this.numPoints = numPoints;
320 }
321 }
322
323 public final Metrics metrics;
324
325 /**
326 * Whether this is a horizontal strip
327 */
328 public final boolean isHorizontal;
329
330 /**
331 * Rotation about the y axis
332 */
333 public final float ry;
334
335 public Object obj1 = null, obj2 = null;
336
337 Strip(Metrics metrics, float ry, List<LXPoint> points, boolean isHorizontal) {
338 super(points);
339 this.isHorizontal = isHorizontal;
340 this.metrics = metrics;
341 this.ry = ry;
342 }
343
344 Strip(Metrics metrics, float ry, LXTransform transform, boolean isHorizontal) {
345 super(new Fixture(metrics, ry, transform));
346 this.metrics = metrics;
347 this.isHorizontal = isHorizontal;
348 this.ry = ry;
349 }
350
351 private static class Fixture extends LXAbstractFixture {
352 private Fixture(Metrics metrics, float ry, LXTransform transform) {
353 float offset = (metrics.length - (metrics.numPoints - 1) * POINT_SPACING) / 2.f;
354 transform.push();
355 transform.translate(offset, -Cube.CHANNEL_WIDTH/2.f, 0);
356 for (int i = 0; i < metrics.numPoints; i++) {
357 LXPoint point = new LXPoint(transform.x(), transform.y(), transform.z());
358 this.points.add(point);
359 transform.translate(POINT_SPACING, 0, 0);
360 }
361 transform.pop();
362 }
363 }
364 }
365