X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=_Mappings.pde;h=bb5c4384df1e3cae2f8f57d7f8b554fac168b767;hb=e037f60f518373c3bb952f79a2ae66950e55a52f;hp=e42f6d7063341c6609c674e00dfd172f72ee902a;hpb=f0cc0ba566c8d933eefe780ea1ae921fa5c385bd;p=SugarCubes.git diff --git a/_Mappings.pde b/_Mappings.pde index e42f6d7..bb5c438 100644 --- a/_Mappings.pde +++ b/_Mappings.pde @@ -15,14 +15,21 @@ public Model buildModel() { - final float BASS_FLOOR = BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH; - // Shorthand helpers for specifying wiring more quickly final Cube.Wiring WFL = Cube.Wiring.FRONT_LEFT; final Cube.Wiring WFR = Cube.Wiring.FRONT_RIGHT; final Cube.Wiring WRL = Cube.Wiring.REAR_LEFT; final Cube.Wiring WRR = Cube.Wiring.REAR_RIGHT; + // Utility value if you need the height of a cube shorthand + final float CH = Cube.EDGE_HEIGHT; + final float CW = Cube.EDGE_WIDTH ; + + // Positions for the bass box + final float BBY = BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH; + final float BBX = 56; + final float BBZ = 2; + // The model is represented as an array of towers. The cubes in the tower // are represenented relatively. Each tower has an x, y, z reference position, // which is typically the base cube's bottom left corner. @@ -36,221 +43,174 @@ public Model buildModel() { // y-axis. // // The cubes automatically increment their y-position by Cube.EDGE_HEIGHT. - TowerMapping[] towerCubes = new TowerMapping[] { - - new TowerMapping(50, 0, 80, new CubeMapping[] { - new CubeMapping(0, 0, WFL), - }), - - }; - + + // To-Do: (Mark Slee, Alex Green, or Ben Morrow): The Cube # is determined by the order in this list. + // "raw object index" is serialized by running through towermapping and then individual cube mapping below. + // We can do better than this. The raw object index should be obvious from the code-- looking through the + // rendered simulation and counting through cubes in mapping mode is grossly inefficient. + // Single cubes can be constructed directly here if you need them Cube[] singleCubes = new Cube[] { + // new Cube(15, int( Cube.EDGE_HEIGHT), 39, 0, 10, 0, WRL), // Back left channel behind speaker // new Cube(x, y, z, rx, ry, rz, wiring), + // new Cube(0,0,0,0,225,0, WRR), }; // The bass box! - BassBox bassBox = new BassBox(56, 0, 2); + BassBox bassBox = BassBox.noBassBox(); // no bass box at all // The speakers! List speakers = Arrays.asList(new Speaker[] { - new Speaker(-12, 6, 0, 15), - new Speaker(TRAILER_WIDTH - Speaker.EDGE_WIDTH, 6, 6, -15) - }); - - // These guts just convert the shorthand mappings into usable objects - ArrayList towerList = new ArrayList(); - ArrayList tower; - Cube[] cubes = new Cube[80]; - int cubeIndex = 1; - float px, pz, ny; - for (TowerMapping tm : towerCubes) { - px = tm.x; - ny = tm.y; - pz = tm.z; - tower = new ArrayList(); - for (CubeMapping cm : tm.cubeMappings) { - tower.add(cubes[cubeIndex++] = new Cube(px = px + cm.dx, ny, pz = pz + cm.dz, 0, cm.ry, 0, cm.wiring)); - ny += Cube.EDGE_HEIGHT; - } - towerList.add(new Tower(tower)); - } - for (Cube cube : singleCubes) { - cubes[cubeIndex++] = cube; + // Each speaker parameter is x, y, z, rotation, the left speaker comes first + // new Speaker(TRAILER_WIDTH - Speaker.EDGE_WIDTH + 8, 6, 3, -15) } + ); + + List scubes = new ArrayList(); + + float[] pos = new float[3]; + pos[0] = 50; + pos[2] = 100; + scubes.add(new StaggeredTower(//tower 1 + pos[0], // x + 0, // y + pos[2], // z + 0, 4, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); - return new Model(towerList, cubes, bassBox, speakers); -} -public PandaMapping[] buildPandaList() { - return new PandaMapping[] { - new PandaMapping( - "10.200.1.28", new ChannelMapping[] { - new ChannelMapping(ChannelMapping.MODE_BASS), - new ChannelMapping(ChannelMapping.MODE_FLOOR), - new ChannelMapping(ChannelMapping.MODE_SPEAKER, 0), - new ChannelMapping(ChannelMapping.MODE_SPEAKER, 1), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 1 }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - }), + pos[0] += 25; + pos[2] -= 10; + scubes.add(new StaggeredTower(// tower 2 + pos[0], // x + 15, // y + pos[2], // z + 0, 4, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); + + pos[0] += 25; + pos[2] += -12.5; + scubes.add(new StaggeredTower(//tower 3 + pos[0], // x + 0, // y + pos[2], // z + 0, 5, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); + + pos[0] += -32.75; + pos[2] += -13; + scubes.add(new StaggeredTower(//tower 4 + pos[0], // x + 0, // y + pos[2], // z + 0, 6, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); + + pos[0] += 26; + pos[2] += -16; + scubes.add(new StaggeredTower(//tower 5 + pos[0], // x + 15, // y + pos[2], // z + 0, 6, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); + + pos[0] += 26; + pos[2] += -4.5; + scubes.add(new StaggeredTower(//tower 6 + pos[0], // x + 0, // y + pos[2], // z + 0, 6, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); + + pos[0] += -56.5; + pos[2] += -6.5; + scubes.add(new StaggeredTower(// tower 7 + pos[0], // x + 15, // y + pos[2], // z + 0, 4, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); + + pos[0] += 26; + pos[2] += -16.5; + scubes.add(new StaggeredTower(//tower 8 + pos[0], // x + 0, // y + pos[2], // z + 0, 5, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); + + pos[0] += 27; + pos[2] += -4.5; + scubes.add(new StaggeredTower(//tower 9 + pos[0], // x + 15, // y + pos[2], // z + 0, 5, new Cube.Wiring[] { + WRR, WRR, WRR, WRR, WRR, WRR + } + )); - new PandaMapping( - "10.200.1.29", new ChannelMapping[] { - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { }), - }), - }; -} -class TowerMapping { - public final float x, y, z; - public final CubeMapping[] cubeMappings; - - TowerMapping(float x, float y, float z, CubeMapping[] cubeMappings) { - this.x = x; - this.y = y; - this.z = z; - this.cubeMappings = cubeMappings; - } -} + ////////////////////////////////////////////////////////////////////// + // BENEATH HERE SHOULD NOT REQUIRE ANY MODIFICATION!!!! // + ////////////////////////////////////////////////////////////////////// -class CubeMapping { - public final float dx, dz, ry; - public final Cube.Wiring wiring; - - CubeMapping(float dx, float dz, Cube.Wiring wiring) { - this(dx, dz, 0, wiring); - } + // These guts just convert the shorthand mappings into usable objects + List towerList = new ArrayList(); + List tower; + Cube[] cubes = new Cube[200]; + int cubeIndex = 1; - CubeMapping(float dx, float dz, float ry) { - this(dz, dz, ry, Cube.Wiring.FRONT_LEFT); - } - - CubeMapping(float dx, float dz, float ry, Cube.Wiring wiring) { - this.dx = dx; - this.dz = dz; - this.ry = ry; - this.wiring = wiring; + for (Cube cube : singleCubes) { + cubes[cubeIndex++] = cube; } -} - -/** - * Each panda board has an IP address and a fixed number of channels. The channels - * each have a fixed number of pixels on them. Whether or not that many physical - * pixels are connected to the channel, we still send it that much data. - */ -class PandaMapping { - - // How many channels are on the panda board - public final static int CHANNELS_PER_BOARD = 13; - - // How many total pixels on the whole board - public final static int PIXELS_PER_BOARD = ChannelMapping.PIXELS_PER_CHANNEL * CHANNELS_PER_BOARD; - - final String ip; - final ChannelMapping[] channelList = new ChannelMapping[CHANNELS_PER_BOARD]; - - PandaMapping(String ip, ChannelMapping[] rawChannelList) { - this.ip = ip; - - // Ensure our array is the right length and has all valid items in it - for (int i = 0; i < channelList.length; ++i) { - channelList[i] = (i < rawChannelList.length) ? rawChannelList[i] : new ChannelMapping(); - if (channelList[i] == null) { - channelList[i] = new ChannelMapping(); - } + for (StaggeredTower st : scubes) { + tower = new ArrayList(); + for (int i = 0; i < st.n; i++) { + Cube.Wiring w = (i < st.wiring.length) ? st.wiring[i] : WRR; + tower.add(cubes[cubeIndex++] = new Cube(st.x, st.y + CH* 4/3.*i, st.z, 0, st.r, 0, w)); } - } -} - -/** - * Each channel on a pandaboard can be mapped in a number of modes. The typial is - * to a series of connected cubes, but we also have special mappings for the bass box, - * the speaker enclosures, and the DJ booth floor. - * - * This class is just the mapping meta-data. It sanitizes the input to make sure - * that the cubes and objects being referenced actually exist in the model. - * - * The logic for how to encode the pixels is contained in the PandaDriver. - */ -class ChannelMapping { + towerList.add(new Tower(tower)); + } - // How many cubes per channel xc_PB is configured for - public final static int CUBES_PER_CHANNEL = 4; + return new Model(towerList, cubes, bassBox, speakers); +} - // How many total pixels on each channel - public final static int PIXELS_PER_CHANNEL = Cube.POINTS_PER_CUBE * CUBES_PER_CHANNEL; - - public static final int MODE_NULL = 0; - public static final int MODE_CUBES = 1; - public static final int MODE_BASS = 2; - public static final int MODE_SPEAKER = 3; - public static final int MODE_FLOOR = 4; - public static final int MODE_INVALID = 5; - - public static final int NO_OBJECT = -1; - - final int mode; - final int[] objectIndices = new int[CUBES_PER_CHANNEL]; - - ChannelMapping() { - this(MODE_NULL); - } - - ChannelMapping(int mode) { - this(mode, new int[]{}); - } - - ChannelMapping(int mode, int rawObjectIndex) { - this(mode, new int[]{ rawObjectIndex }); - } - - ChannelMapping(int mode, int[] rawObjectIndices) { - if (mode < 0 || mode >= MODE_INVALID) { - throw new RuntimeException("Invalid channel mapping mode: " + mode); - } - if (mode == MODE_SPEAKER) { - if (rawObjectIndices.length != 1) { - throw new RuntimeException("Speaker channel mapping mode must specify one speaker index"); - } - int speakerIndex = rawObjectIndices[0]; - if (speakerIndex < 0 || speakerIndex >= glucose.model.speakers.size()) { - throw new RuntimeException("Invalid speaker channel mapping: " + speakerIndex); - } - } else if ((mode == MODE_FLOOR) || (mode == MODE_BASS) || (mode == MODE_NULL)) { - if (rawObjectIndices.length > 0) { - throw new RuntimeException("Bass/floor/null mappings cannot specify object indices"); - } - } else if (mode == MODE_CUBES) { - for (int rawCubeIndex : rawObjectIndices) { - if (glucose.model.getCubeByRawIndex(rawCubeIndex) == null) { - throw new RuntimeException("Non-existing cube specified in cube mapping: " + rawCubeIndex); - } - } - } - - this.mode = mode; - for (int i = 0; i < objectIndices.length; ++i) { - objectIndices[i] = (i < rawObjectIndices.length) ? rawObjectIndices[i] : NO_OBJECT; +class StaggeredTower { + public final float x, y, z, r; + public final int n; + public final Cube.Wiring[] wiring; + StaggeredTower(float _x, float _y, float _z, float _r, int _n) { + this(_x, _y, _z, _r, _n, new Cube.Wiring[] { } + ); + } + StaggeredTower(float _x, float _y, float _z, float _r, int _n, Cube.Wiring[] _wiring) { + x=_x; + y=_y; + z=_z; + r=_r; + n=_n; + wiring=_wiring; } }