_Mappings.pde

   1 /**
   2  *     DOUBLE BLACK DIAMOND        DOUBLE BLACK DIAMOND
   3  *
   4  *         //\\   //\\                 //\\   //\\
   5  *        ///\\\ ///\\\               ///\\\ ///\\\
   6  *        \\\/// \\\///               \\\/// \\\///
   7  *         \\//   \\//                 \\//   \\//
   8  *
   9  *        EXPERTS ONLY!!              EXPERTS ONLY!!
  10  *
  11  * This file implements the mapping functions needed to lay out the physical
  12  * cubes and the output ports on the panda board. It should only be modified
  13  * when physical changes or tuning is being done to the structure.
  14  */
  15
  16 class TowerMapping {
  17   public final float x, y, z;
  18   public final float[][] cubePositions;
  19
  20   TowerMapping(float x, float y, float z, float[][] cubePositions) {
  21     this.x = x;
  22     this.y = y;
  23     this.z = z;
  24     this.cubePositions = cubePositions;
  25   }
  26 }
  27
  28 public Model buildModel() {
  29   // The model is represented as an array of towers. The cubes in the tower
  30   // are represenented relatively. Each tower has an x, y, z reference position,
  31   // which is typically the base cube's bottom left corner.
  32   //
  33   // Following that is an array of floats. A 2-d array contains an x-offset
  34   // and a z-offset from the reference position. Typically the first cube
  35   // will just be {0, 0}.
  36   //
  37   // A 3-d array contains an x-offset, a z-offset, and a rotation about the
  38   // y-axis.
  39   //
  40   // The cubes automatically increment their y-position by Cube.EDGE_HEIGHT.
  41
  42   final float STACKED_RELATIVE = 1;
  43   final float STACKED_REL_SPIN = 2;
  44   final float BASS_DEPTH = BassBox.EDGE_DEPTH + 4;
  45
  46   TowerMapping[] mapping = new TowerMapping[] {
  47
  48       // Front left cubes
  49 //    new TowerMapping(0, 0, 0, new float[][] {
  50 //      {STACKED_RELATIVE, 0, 0},
  51 //      {STACKED_RELATIVE, 5, -10, 20},
  52 //      {STACKED_RELATIVE, 0, -6},
  53 //      {STACKED_RELATIVE, -5, -2, -20},
  54 //    }),
  55 //
  56 //    new TowerMapping(Cube.EDGE_WIDTH + 2, 0, 0, new float[][] {
  57 //      {STACKED_RELATIVE, 0, 0},
  58 //      {STACKED_RELATIVE, 0, 5, 10},
  59 //      {STACKED_RELATIVE, 0, 2, 20},
  60 //      {STACKED_RELATIVE, 0, 0, 30},
  61 //    }),
  62
  63     // Back Cubes behind DJ platform (in order of increasing x)
  64     new TowerMapping(50, 5, BASS_DEPTH, new float[][] {
  65       {STACKED_RELATIVE, 0, 0},
  66       {STACKED_RELATIVE, 2, 0, 20},
  67       {STACKED_RELATIVE, -2, 10},
  68       {STACKED_RELATIVE, -5, 15, -20},
  69       {STACKED_RELATIVE, -2, 13},
  70     }),
  71
  72     new TowerMapping(79, 5, BASS_DEPTH, new float[][] {
  73       {STACKED_RELATIVE, 0, 0},
  74       {STACKED_RELATIVE, 2, 0, 20},
  75       {STACKED_RELATIVE, 4, 10},
  76       {STACKED_RELATIVE, 2, 15, -20},
  77       {STACKED_RELATIVE, 0, 13},
  78     }),
  79
  80     new TowerMapping(107, 5, BASS_DEPTH, new float[][] {
  81       {STACKED_RELATIVE, 0, 0},
  82       {STACKED_RELATIVE, 4, 0, 20},
  83       {STACKED_RELATIVE, 6, 10},
  84       {STACKED_RELATIVE, 3, 15, -20},
  85       // {STACKED_RELATIVE, 8,  13},
  86     }),
  87
  88     new TowerMapping(133, 5, BASS_DEPTH, new float[][] {
  89       {STACKED_RELATIVE, 0, 0},
  90       {STACKED_RELATIVE, -2, 0, 20},
  91       {STACKED_RELATIVE, 0, 10},
  92       {STACKED_RELATIVE, 2, 15, -20},
  93       // {STACKED_RELATIVE, 4, 13}
  94     }),
  95
  96     new TowerMapping(165, 5, BASS_DEPTH, new float[][] {
  97       {STACKED_RELATIVE, 0, 0},
  98       {STACKED_RELATIVE, -1, 20},
  99       {STACKED_RELATIVE, 2, 10},
 100       {STACKED_RELATIVE, -2, 15, -20},
 101       {STACKED_RELATIVE, 3, 13},
 102     }),
 103
 104     // front DJ cubes
 105     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2, BassBox.EDGE_HEIGHT, 10, new float[][] {
 106       {STACKED_RELATIVE, 0, 0},
 107       {STACKED_RELATIVE, 0, -10, 20},
 108     }),
 109
 110     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + Cube.EDGE_HEIGHT, BassBox.EDGE_HEIGHT, 10, new float[][] {
 111       {STACKED_RELATIVE, 3, 0},
 112       {STACKED_RELATIVE, 2, -10, 20},
 113     }),
 114
 115     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 2*Cube.EDGE_HEIGHT + 5, BassBox.EDGE_HEIGHT, 10, new float[][] {
 116       {STACKED_RELATIVE, 0, 0},
 117       {STACKED_RELATIVE, 1, 0, 10},
 118     }),
 119
 120     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 3*Cube.EDGE_HEIGHT + 9, BassBox.EDGE_HEIGHT, 10, new float[][] {
 121       {STACKED_RELATIVE, 0, 0},
 122       {STACKED_RELATIVE, -1, 0},
 123     }),
 124
 125     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 4*Cube.EDGE_HEIGHT + 15, BassBox.EDGE_HEIGHT, 10, new float[][] {
 126       {STACKED_RELATIVE, 0, 0},
 127       {STACKED_RELATIVE, -1, 0},
 128     }),
 129
 130     // left dj cubes
 131     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2, BassBox.EDGE_HEIGHT, Cube.EDGE_HEIGHT + 2, new float[][] {
 132       {STACKED_RELATIVE, 0, 0},
 133       {STACKED_RELATIVE, 0, 2, 20},
 134     }),
 135
 136     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2, BassBox.EDGE_HEIGHT, 2*Cube.EDGE_HEIGHT + 4, new float[][] {
 137       {STACKED_RELATIVE, 0, 0},
 138       {STACKED_RELATIVE, 0, 2, 20},
 139     }),
 140
 141     // right dj cubes
 142     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 4*Cube.EDGE_HEIGHT + 15, BassBox.EDGE_HEIGHT, Cube.EDGE_HEIGHT + 2, new float[][] {
 143       {STACKED_RELATIVE, 0, 0},
 144       {STACKED_RELATIVE, 0, 2, 20},
 145     }),
 146
 147     new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 4*Cube.EDGE_HEIGHT + 15, BassBox.EDGE_HEIGHT, 2*Cube.EDGE_HEIGHT + 4, new float[][] {
 148       {STACKED_RELATIVE, 0, 0},
 149       {STACKED_RELATIVE, 0, 2, 20},
 150     }),
 151
 152 //    new TowerMapping(200, 0, 0, new float[][] {
 153 //      {STACKED_RELATIVE, 0, 10},
 154 //      {STACKED_RELATIVE, 5, 0, 20},
 155 //      {STACKED_RELATIVE, 0, 4},
 156 //      {STACKED_RELATIVE, -5, 8, -20},
 157 //      {STACKED_RELATIVE, 0, 3},
 158 //    }),
 159
 160 //    new TowerMapping(0, 0, Cube.EDGE_HEIGHT + 10, new float[][] {
 161 //      {STACKED_RELATIVE, 10, 0, 40},
 162 //      {STACKED_RELATIVE, 3, -2, 20},
 163 //      {STACKED_RELATIVE, 0, 0, 40},
 164 //      {STACKED_RELATIVE, 0, 0, 60},
 165 //      {STACKED_RELATIVE, 0, 0, 40},
 166 //    }),
 167
 168     new TowerMapping(20, 0, 2*Cube.EDGE_HEIGHT + 18, new float[][] {
 169       {STACKED_RELATIVE, 0, 0, 40},
 170       {STACKED_RELATIVE, 10, 0, 20},
 171       {STACKED_RELATIVE, 5, 0, 40},
 172       {STACKED_RELATIVE, 10, 0, 60},
 173       {STACKED_RELATIVE, 12, 0, 40},
 174     }),
 175
 176 //    new TowerMapping(210, 0, Cube.EDGE_HEIGHT + 15, new float[][] {
 177 //      {STACKED_RELATIVE, 0, 0, 40},
 178 //      {STACKED_RELATIVE, 5, 0, 20},
 179 //      {STACKED_RELATIVE, 8, 0, 40},
 180 //      {STACKED_RELATIVE, 3, 0, 60},
 181 //      {STACKED_RELATIVE, 0, 0, 40},
 182 //    }),
 183
 184     new TowerMapping(210, 0, 2*Cube.EDGE_HEIGHT + 25, new float[][] {
 185       {STACKED_RELATIVE, 0, 0, 40},
 186       {STACKED_RELATIVE, 5, 0, 20},
 187       {STACKED_RELATIVE, 2, 0, 40},
 188       {STACKED_RELATIVE, 5, 0, 60},
 189       {STACKED_RELATIVE, 0, 0, 40},
 190     }),
 191
 192   };
 193
 194   ArrayList<Tower> towerList = new ArrayList<Tower>();
 195   ArrayList<Cube> tower;
 196   Cube[] cubes = new Cube[79];
 197   int cubeIndex = 1;
 198   float tx, ty, tz, px, pz, ny, dx, dz, ry;
 199   for (TowerMapping tm : mapping) {
 200     tower = new ArrayList<Cube>();
 201     px = tx = tm.x;
 202     ny = ty = tm.y;
 203     pz = tz = tm.z;
 204     int ti = 0;
 205     for (float[] cp : tm.cubePositions) {
 206       float mode = cp[0];
 207       if (mode == STACKED_RELATIVE) {
 208         dx = cp[1];
 209         dz = cp[2];
 210         ry = (cp.length >= 4) ? cp[3] : 0;
 211         tower.add(cubes[cubeIndex++] = new Cube(px = tx + dx, ny, pz = tz + dz, 0, ry, 0));
 212         ny += Cube.EDGE_HEIGHT;
 213       } else if (mode == STACKED_REL_SPIN) {
 214         // Same as above but the front left of this cube is actually its back right for wiring
 215         // TODO(mcslee): implement this
 216       }
 217     }
 218     towerList.add(new Tower(tower));
 219   }
 220
 221   BassBox bassBox = new BassBox(56, 0, 2);
 222
 223   List<Speaker> speakers = new ArrayList<Speaker>();
 224   speakers.add(new Speaker(-12, 6, 0, 15));
 225   speakers.add(new Speaker(TRAILER_WIDTH - Speaker.EDGE_WIDTH, 6, 6, -15));
 226
 227   return new Model(towerList, cubes, bassBox, speakers);
 228 }
 229
 230 public PandaMapping[] buildPandaList() {
 231   return new PandaMapping[] {
 232     new PandaMapping(
 233       "10.200.1.28", new int[][] {
 234       {  1,  2,  3,  4 }, // ch1
 235       {  5,  6,  7,  8 }, // ch2
 236       {  9, 10, 11, 12 }, // ch3
 237       { 13, 14, 15, 16 }, // ch4
 238       { 17, 18, 19, 20 }, // ch5
 239       { 21, 22, 23, 24 }, // ch6
 240       { 25, 26, 27, 28 }, // ch7
 241       { 29, 30, 31, 32 }, // ch8
 242     }),
 243
 244     new PandaMapping(
 245       "10.200.1.29", new int[][] {
 246       { 33, 34, 35, 36 }, // ch9
 247       { 37, 38, 39, 40 }, // ch10
 248       { 41, 42, 43, 44 }, // ch11
 249       { 45, 46, 47, 48 }, // ch12
 250       { 33, 34, 35, 36 }, // ch13
 251       { 37, 38, 39, 40 }, // ch14
 252       { 41, 42, 43, 44 }, // ch15
 253       { 45, 46, 47, 48 }, // ch16
 254     }),
 255
 256   };
 257 }
 258
 259 class PandaMapping {
 260
 261   // How many channels are on the panda board
 262   public final static int CHANNELS_PER_BOARD = 8;
 263
 264   // How many cubes per channel xc_PB is configured for
 265   public final static int CUBES_PER_CHANNEL = 4;
 266
 267   // How many total pixels on each channel
 268   public final static int PIXELS_PER_CHANNEL = Cube.POINTS_PER_CUBE * CUBES_PER_CHANNEL;
 269
 270   // How many total pixels on the whole board
 271   public final static int PIXELS_PER_BOARD = PIXELS_PER_CHANNEL * CHANNELS_PER_BOARD;
 272
 273   final String ip;
 274   final int[][] channelList = new int[CHANNELS_PER_BOARD][CUBES_PER_CHANNEL];
 275
 276   PandaMapping(String ip, int[][] rawChannelList) {
 277     this.ip = ip;
 278     for (int chi = 0; chi < CHANNELS_PER_BOARD; ++chi) {
 279       int[] cubes = (chi < rawChannelList.length) ? rawChannelList[chi] : new int[]{};
 280       for (int cui = 0; cui < CUBES_PER_CHANNEL; ++cui) {
 281         channelList[chi][cui] = (cui < cubes.length) ? cubes[cui] : 0;
 282       }
 283     }
 284   }
 285 }
 286
 287