Merge branch 'master' of https://github.com/sugarcubes/SugarCubes into realmapping

diff --git a/SugarCubes.pde b/SugarCubes.pde
index b7a5be6ad39a1be0d49838c547f4ab8ede12a3ab..ab81e307cc8357ddc7a8385fac9c800f97035c7d 100644 (file)
--- a/SugarCubes.pde
+++ b/SugarCubes.pde
@@ -27,10 +27,10 @@ LXPattern[] patterns(GLucose glucose) {
   return new LXPattern[] {
     
     // Slee
-    new ShiftingPlane(glucose),
-    new AskewPlanes(glucose),
     new Swarm(glucose),
     new SpaceTime(glucose),
+    new ShiftingPlane(glucose),
+    new AskewPlanes(glucose),
     new Blinders(glucose),
     new CrossSections(glucose),
     new Psychedelia(glucose),

diff --git a/TestPatterns.pde b/TestPatterns.pde
index bdaa78ac563b916aacd84974cb4a79c2c4d973c3..e47651af4271f4cdf8618190fb2ac8326e142816 100644 (file)
--- a/TestPatterns.pde
+++ b/TestPatterns.pde
@@ -256,7 +256,7 @@ class MappingTool extends TestPattern {
     if (activeChannel.mode == ChannelMapping.MODE_CUBES) {
       int i = 1;
       for (int index : activeChannel.objectIndices) {
-        if (c == model.getCubeByRawIndex(index)) {
+        if ((index >= 0) && (c == model.getCubeByRawIndex(index))) {
           return i;
         }
         ++i;
@@ -359,10 +359,7 @@ class MappingTool extends TestPattern {
   }
   
   public void decChannel() {
-    --channelIndex;
-    if (channelIndex < 0) {
-      channelIndex += numChannels;
-    }
+    channelIndex = (channelIndex + numChannels - 1) % numChannels;
     setChannel();    
   }
   
@@ -371,10 +368,7 @@ class MappingTool extends TestPattern {
   }
   
   public void decStrip() {
-    --stripIndex;
-    if (stripIndex < 0) {
-      stripIndex += Cube.STRIPS_PER_CUBE;
-    }
+    stripIndex = (stripIndex + Cube.STRIPS_PER_CUBE - 1) % Cube.STRIPS_PER_CUBE;
   }
   
   public void keyPressed() {

diff --git a/_Mappings.pde b/_Mappings.pde
index 1c62ed129a7e4089df1ed2b180cc0c65e66c90df..73e1fe2a152bb4f77ab1e03e4f5fb5ab3c611817 100644 (file)
--- a/_Mappings.pde
+++ b/_Mappings.pde
@@ -13,248 +13,163 @@
  * when physical changes or tuning is being done to the structure.
  */
 
-class TowerMapping {
-  public final float x, y, z;
-  public final float[][] cubePositions;
+public Model buildModel() {
+
   
-  TowerMapping(float x, float y, float z, float[][] cubePositions) {
-    this.x = x;
-    this.y = y;
-    this.z = z;
-    this.cubePositions = cubePositions;
-  }
-}
+  // 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;
+  
+  final float CH = Cube.EDGE_HEIGHT;
+  
+  final float BBY = BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH;
+  final float BBX = 56;
+  final float BBZ = 2;
+
 
-public Model buildModel() {
   // 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.
   //
   // Following that is an array of floats. A 2-d array contains an x-offset
-  // and a z-offset from the reference position. Typically the first cube
-  // will just be {0, 0}.
+  // and a z-offset from the previous reference position. Typically the first cube
+  // will just be {0, 0}. Each successive cube uses the position of the previous
+  // cube as its reference.
   //
   // A 3-d array contains an x-offset, a z-offset, and a rotation about the
   // y-axis.
   //
   // The cubes automatically increment their y-position by Cube.EDGE_HEIGHT.
-  
-  final float STACKED_RELATIVE = 1;
-  final float STACKED_REL_SPIN = 2;
-  final float BASS_DEPTH = BassBox.EDGE_DEPTH + 4;
-  
-  TowerMapping[] mapping = new TowerMapping[] {
-
-      // Front left cubes
-//    new TowerMapping(0, 0, 0, new float[][] {
-//      {STACKED_RELATIVE, 0, 0},
-//      {STACKED_RELATIVE, 5, -10, 20},
-//      {STACKED_RELATIVE, 0, -6},
-//      {STACKED_RELATIVE, -5, -2, -20},
-//    }),
-//
-//    new TowerMapping(Cube.EDGE_WIDTH + 2, 0, 0, new float[][] {
-//      {STACKED_RELATIVE, 0, 0},
-//      {STACKED_RELATIVE, 0, 5, 10},
-//      {STACKED_RELATIVE, 0, 2, 20},
-//      {STACKED_RELATIVE, 0, 0, 30},
-//    }),
-    
-    // Back Cubes behind DJ platform (in order of increasing x)
-    new TowerMapping(50, 5, BASS_DEPTH, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 2, 0, 20},
-      {STACKED_RELATIVE, -2, 10},
-      {STACKED_RELATIVE, -5, 15, -20},
-      {STACKED_RELATIVE, -2, 13},
-    }),
-    
-    new TowerMapping(79, 5, BASS_DEPTH, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 2, 0, 20},
-      {STACKED_RELATIVE, 4, 10},
-      {STACKED_RELATIVE, 2, 15, -20},
-      {STACKED_RELATIVE, 0, 13},
-    }),
+  TowerMapping[] towerCubes = new TowerMapping[] {
     
-    new TowerMapping(107, 5, BASS_DEPTH, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 4, 0, 20},
-      {STACKED_RELATIVE, 6, 10},
-      {STACKED_RELATIVE, 3, 15, -20},
-      // {STACKED_RELATIVE, 8,  13},
+    // DJ booth, from left to right
+    new TowerMapping(BBX, BBY, BBZ, new CubeMapping[] {
+      new CubeMapping(-7.25, 7.5, -25, WFR),
+      new CubeMapping(7.5, -15.75, 12, WRL),
     }),
-    
-    new TowerMapping(133, 5, BASS_DEPTH, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, -2, 0, 20},
-      {STACKED_RELATIVE, 0, 10},
-      {STACKED_RELATIVE, 2, 15, -20},
-      // {STACKED_RELATIVE, 4, 13}
-    }),
-    
-    new TowerMapping(165, 5, BASS_DEPTH, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, -1, 20},
-      {STACKED_RELATIVE, 2, 10},
-      {STACKED_RELATIVE, -2, 15, -20},
-      {STACKED_RELATIVE, 3, 13},
-    }),
-    
-    // front DJ cubes
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, 10, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 0, -10, 20},
-    }),
-    
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + Cube.EDGE_HEIGHT, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, 10, new float[][] {
-      {STACKED_RELATIVE, 3, 0},
-      {STACKED_RELATIVE, 2, -10, 20},
-    }),
-    
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 2*Cube.EDGE_HEIGHT + 5, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, 10, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 1, 0, 10},
-    }),
-    
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 3*Cube.EDGE_HEIGHT + 9, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, 10, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, -1, 0},
-    }),
-    
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 4*Cube.EDGE_HEIGHT + 15, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, 10, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, -1, 0},
-    }),
-    
-    // left dj cubes    
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, Cube.EDGE_HEIGHT + 2, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 0, 2, 20},
+    new TowerMapping(BBX, BBY, BBZ, new CubeMapping[] {
+      new CubeMapping(19.625, 5.375, -22, WFR),
+      new CubeMapping(8, -14.5, 10, WRR),
     }),
-    
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, 2*Cube.EDGE_HEIGHT + 4, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 0, 2, 20},
+    new TowerMapping(BBX, BBY, BBZ, new CubeMapping[] {
+      new CubeMapping(48, 4.75, -35, WRL),
+      new CubeMapping(8, -15, 10, WRR),
     }),
-    
-    // right dj cubes    
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 4*Cube.EDGE_HEIGHT + 15, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, Cube.EDGE_HEIGHT + 2, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 0, 2, 20},
-    }),
-    
-    new TowerMapping((TRAILER_WIDTH - BassBox.EDGE_WIDTH)/2 + 4*Cube.EDGE_HEIGHT + 15, BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH, 2*Cube.EDGE_HEIGHT + 4, new float[][] {
-      {STACKED_RELATIVE, 0, 0},
-      {STACKED_RELATIVE, 0, 2, 20},
-    }),
-
-//    new TowerMapping(200, 0, 0, new float[][] {
-//      {STACKED_RELATIVE, 0, 10},
-//      {STACKED_RELATIVE, 5, 0, 20},
-//      {STACKED_RELATIVE, 0, 4},
-//      {STACKED_RELATIVE, -5, 8, -20},
-//      {STACKED_RELATIVE, 0, 3},
-//    }),
-    
-//    new TowerMapping(0, 0, Cube.EDGE_HEIGHT + 10, new float[][] {
-//      {STACKED_RELATIVE, 10, 0, 40},
-//      {STACKED_RELATIVE, 3, -2, 20},
-//      {STACKED_RELATIVE, 0, 0, 40},
-//      {STACKED_RELATIVE, 0, 0, 60},
-//      {STACKED_RELATIVE, 0, 0, 40},
-//    }),
-    
-    new TowerMapping(20, 0, 2*Cube.EDGE_HEIGHT + 18, new float[][] {
-      {STACKED_RELATIVE, 0, 0, 40},
-      {STACKED_RELATIVE, 10, 0, 20},
-      {STACKED_RELATIVE, 5, 0, 40},
-      {STACKED_RELATIVE, 10, 0, 60},
-      {STACKED_RELATIVE, 12, 0, 40},
-    }),
-    
-//    new TowerMapping(210, 0, Cube.EDGE_HEIGHT + 15, new float[][] {
-//      {STACKED_RELATIVE, 0, 0, 40},
-//      {STACKED_RELATIVE, 5, 0, 20},
-//      {STACKED_RELATIVE, 8, 0, 40},
-//      {STACKED_RELATIVE, 3, 0, 60},
-//      {STACKED_RELATIVE, 0, 0, 40},
-//    }),
-    
-    new TowerMapping(210, 0, 2*Cube.EDGE_HEIGHT + 25, new float[][] {
-      {STACKED_RELATIVE, 0, 0, 40},
-      {STACKED_RELATIVE, 5, 0, 20},
-      {STACKED_RELATIVE, 2, 0, 40},
-      {STACKED_RELATIVE, 5, 0, 60},
-      {STACKED_RELATIVE, 0, 0, 40},
+    new TowerMapping(BBX, BBY, BBZ, new CubeMapping[] {
+      new CubeMapping(78.75, 3.75, -28, WRR),
+      new CubeMapping(8, -15, 10, WRR),
     }),
+    new TowerMapping(BBX, BBY, BBZ, new CubeMapping[] {
+      new CubeMapping(104.75, 0, -27, WRL),
+      new CubeMapping(8, -15, 10, WFL),      
+    }),    
     
   };
+  
+  // Single cubes can be constructed directly here if you need them
+  Cube[] singleCubes = new Cube[] {
+    // new Cube(x, y, z, rx, ry, rz, wiring),
+  };
+
+  // The bass box!
+  BassBox bassBox = new BassBox(BBX, 0, BBZ);
+
+  // The speakers!
+  List<Speaker> speakers = Arrays.asList(new Speaker[] {
+    new Speaker(-12, 6, 0, 15),
+    new Speaker(TRAILER_WIDTH - Speaker.EDGE_WIDTH + 8, 6, 3, -15)
+  });
 
+  // These guts just convert the shorthand mappings into usable objects
   ArrayList<Tower> towerList = new ArrayList<Tower>();
   ArrayList<Cube> tower;
-  Cube[] cubes = new Cube[79];
+  Cube[] cubes = new Cube[80];
   int cubeIndex = 1;  
-  float tx, ty, tz, px, pz, ny, dx, dz, ry;
-  for (TowerMapping tm : mapping) {
+  float px, pz, ny;
+  for (TowerMapping tm : towerCubes) {
+    px = tm.x;
+    ny = tm.y;
+    pz = tm.z;
     tower = new ArrayList<Cube>();
-    px = tx = tm.x;
-    ny = ty = tm.y;
-    pz = tz = tm.z;
-    int ti = 0;
-    for (float[] cp : tm.cubePositions) {
-      float mode = cp[0];
-      if (mode == STACKED_RELATIVE) {
-        dx = cp[1];
-        dz = cp[2];
-        ry = (cp.length >= 4) ? cp[3] : 0;
-        tower.add(cubes[cubeIndex++] = new Cube(px = tx + dx, ny, pz = tz + dz, 0, ry, 0));
-        ny += Cube.EDGE_HEIGHT;
-      } else if (mode == STACKED_REL_SPIN) {
-        // Same as above but the front left of this cube is actually its back right for wiring
-        // TODO(mcslee): implement this
-      }
+    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));
   }
-
-  BassBox bassBox = new BassBox(56, 0, 2);
-
-  List<Speaker> speakers = new ArrayList<Speaker>();
-  speakers.add(new Speaker(-12, 6, 0, 15));
-  speakers.add(new Speaker(TRAILER_WIDTH - Speaker.EDGE_WIDTH, 6, 6, -15));
+  for (Cube cube : singleCubes) {
+    cubes[cubeIndex++] = cube;
+  }
 
   return new Model(towerList, cubes, bassBox, speakers);
 }
 
 public PandaMapping[] buildPandaList() {
   return new PandaMapping[] {
+    new PandaMapping(
+      "10.200.1.29", new ChannelMapping[] {
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 5, 6, 4, 3 }),
+    }),
+
     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,  2,  3,  4 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] {  5,  6,  7,  8 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] {  9, 10, 11, 12 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 13, 14, 15, 16 }),
-    }),
-
-    new PandaMapping(
-      "10.200.1.29", new ChannelMapping[] {
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 17, 18, 19, 20 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 21, 22, 23, 24 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 25, 26, 27, 28 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 29, 30, 31, 32 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 33, 34, 35, 36 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 37, 38, 39, 40 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 41, 42, 43, 44 }),
-        new ChannelMapping(ChannelMapping.MODE_CUBES, new int[] { 45, 46, 47, 48 }),
     }),
   };
 }
 
+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;
+  }
+}
+
+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);
+  }
+
+  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;
+  }
+}
+
 /**
  * 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
@@ -263,7 +178,7 @@ public PandaMapping[] buildPandaList() {
 class PandaMapping {
   
   // How many channels are on the panda board
-  public final static int CHANNELS_PER_BOARD = 8;
+  public final static int CHANNELS_PER_BOARD = 16;
   
   // How many total pixels on the whole board
   public final static int PIXELS_PER_BOARD = ChannelMapping.PIXELS_PER_CHANNEL * CHANNELS_PER_BOARD;

diff --git a/_Overlay.pde b/_Overlay.pde
index 0950b91c03b93e61beb8fafc545143bddf738b0f..50c037c1b46baf489faa4c21321a2c21d5da89ae 100644 (file)
--- a/_Overlay.pde
+++ b/_Overlay.pde
@@ -757,11 +757,11 @@ class MappingUI extends OverlayUI {
 class DebugUI {
   
   final ChannelMapping[] channelList;
-  final int debugX = 10;
-  final int debugY = 42;
+  final int debugX = 5;
+  final int debugY = 5;
   final int debugXSpacing = 28;
-  final int debugYSpacing = 22;
-  final int[][] debugState = new int[17][6];
+  final int debugYSpacing = 21;
+  final int[][] debugState;
   
   final int DEBUG_STATE_ANIM = 0;
   final int DEBUG_STATE_WHITE = 1;
@@ -769,6 +769,8 @@ class DebugUI {
   
   DebugUI(PandaMapping[] pandaMappings) {
     int totalChannels = pandaMappings.length * PandaMapping.CHANNELS_PER_BOARD;
+    debugState = new int[totalChannels+1][ChannelMapping.CUBES_PER_CHANNEL+1];
+    
     channelList = new ChannelMapping[totalChannels];
     int channelIndex = 0;
     for (PandaMapping pm : pandaMappings) {
@@ -788,8 +790,8 @@ class DebugUI {
     int xBase = debugX;
     int yPos = debugY;
     
-    fill(color(0, 0, 0, 80));
-    rect(4, 32, 172, 388);
+    fill(#000000);
+    rect(0, 0, debugX + 5*debugXSpacing, height);
     
     int channelNum = 0;
     for (ChannelMapping channel : channelList) {
@@ -943,7 +945,7 @@ class DebugUI {
     if ((dy >= 0) && (dy < debugState.length)) {
       if ((dx >= 0) && (dx < debugState[dy].length)) {
         int newState = debugState[dy][dx] = (debugState[dy][dx] + 1) % 3;
-        if (dy == 16) {
+        if (dy == debugState.length-1) {
           for (int[] states : debugState) {
             for (int i = 0; i < states.length; ++i) {
               states[i] = newState;

diff --git a/_PandaDriver.pde b/_PandaDriver.pde
index 62d4c94b46dc1ffe3438d96e7940132ceb819e6f..cd85e9b05e9738d051492aef097ec123dae857a3 100644 (file)
--- a/_PandaDriver.pde
+++ b/_PandaDriver.pde
@@ -14,7 +14,7 @@ import oscP5.*;
  * This class implements the output function to the Panda Boards. It
  * will be moved into GLucose once stabilized.
  */
-public class PandaDriver {
+public static class PandaDriver {
 
   // IP address
   public final String ip;
@@ -50,18 +50,73 @@ public class PandaDriver {
     }
   }
 
+  private final static int FORWARD = -1;
+  private final static int BACKWARD = -2;
+
   /**
    * These constant arrays indicate the order in which the strips of a cube
    * are wired. There are four different options, depending on which bottom
    * corner of the cube the data wire comes in.
    */
-  private final int[][] CUBE_STRIP_ORDERINGS = new int[][] {
+  private final static int[][] CUBE_STRIP_ORDERINGS = new int[][] {
     {  2,  1,  0,  3, 13, 12, 15, 14,  4,  7,  6,  5, 11, 10,  9,  8 }, // FRONT_LEFT
     {  6,  5,  4,  7,  1,  0,  3,  2,  8, 11, 10,  9, 15, 14, 13, 12 }, // FRONT_RIGHT
     { 14, 13, 12, 15,  9,  8, 11, 10,  0,  3,  2,  1,  7,  6,  5,  4 }, // REAR_LEFT
     { 10,  9,  8, 11,  5,  4,  7,  6, 12, 15, 14, 13,  3,  2,  1,  0 }, // REAR_RIGHT
   };
-
+  
+  private final static int[][] BASS_STRIP_ORDERING = {
+    {0, FORWARD },
+    {1, FORWARD },
+    {2, FORWARD },
+    {3, FORWARD },
+    {4, FORWARD },
+    {5, FORWARD },
+    {6, FORWARD },
+    {7, FORWARD },
+    {8, FORWARD },
+    {9, FORWARD },
+    {10, FORWARD },
+    {11, FORWARD },
+    {12, FORWARD },
+    {13, FORWARD },
+    {14, FORWARD },
+    {15, FORWARD },
+    {16, FORWARD },
+    {17, FORWARD },
+    {18, FORWARD },
+    {19, FORWARD },
+    {20, FORWARD },
+    {21, FORWARD },
+    {22, FORWARD },            
+  };
+  
+  private final static int[][] FLOOR_STRIP_ORDERING = {
+    {0, FORWARD},
+    {1, FORWARD},
+    {2, FORWARD},
+    {3, FORWARD},
+  };
+  
+  private final static int[][] SPEAKER_STRIP_ORDERING = {
+    {0, FORWARD },
+    {1, FORWARD },
+    {2, FORWARD },
+    {3, FORWARD },
+    {4, FORWARD },
+    {5, FORWARD },
+    {6, FORWARD },
+    {7, FORWARD },
+    {8, FORWARD },
+    {9, FORWARD },
+    {10, FORWARD },
+    {11, FORWARD },
+    {12, FORWARD },
+    {13, FORWARD },
+    {14, FORWARD },
+    {15, FORWARD },
+  };
+  
   public PandaDriver(String ip, Model model, PandaMapping pm) {
     this(ip);
 
@@ -99,25 +154,29 @@ public class PandaDriver {
               for (int stripIndex : CUBE_STRIP_ORDERINGS[stripOrderIndex]) {
                 // We go backwards here... in the model strips go clockwise, but
                 // the physical wires are run counter-clockwise
-                Strip s = cube.strips.get(stripIndex);
-                for (int j = s.points.size() - 1; j >= 0; --j) {
-                  points[pi++] = s.points.get(j).index;
-                }
+                pi = mapStrip(cube.strips.get(stripIndex), BACKWARD, points, pi);
               }
             }
           }
           break;
           
         case ChannelMapping.MODE_BASS:
-          // TODO(mapping): figure out how we end up connecting the bass cabinet
+          for (int[] config : BASS_STRIP_ORDERING) {
+            pi = mapStrip(model.bassBox.strips.get(config[0]), config[1], points, pi);
+          }
           break;
           
-        case ChannelMapping.MODE_FLOOR:        
-          // TODO(mapping): figure out how these strips are wired
+        case ChannelMapping.MODE_FLOOR:
+          for (int[] config : FLOOR_STRIP_ORDERING) {
+            pi = mapStrip(model.boothFloor.strips.get(config[0]), config[1], points, pi);
+          }
           break;
           
         case ChannelMapping.MODE_SPEAKER:
-          // TODO(mapping): figure out how these strips are wired
+          for (int[] config : SPEAKER_STRIP_ORDERING) {
+            Speaker speaker = model.speakers.get(channel.objectIndices[0]);
+            pi = mapStrip(speaker.strips.get(config[0]), config[1], points, pi);
+          }
           break;
           
         case ChannelMapping.MODE_NULL:
@@ -130,6 +189,21 @@ public class PandaDriver {
 
     }
   }
+  
+  private int mapStrip(Strip s, int direction, int[] points, int pi) {
+    if (direction == FORWARD) {
+      for (Point p : s.points) {
+        points[pi++] = p.index;
+      }
+    } else if (direction == BACKWARD) {
+      for (int i = s.points.size()-1; i >= 0; --i) {
+        points[pi++] = s.points.get(i).index;
+      }
+    } else {
+      throw new RuntimeException("Unidentified strip mapping direction: " + direction);
+    }
+    return pi;
+  }
 
   public void toggle() {
     enabled = !enabled;