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