more matrix work, and adding pvector

benfry · benfry · commit 128abfe58a9f · 2008-09-29T15:27:26.000Z
diff --git a/core/src/processing/core/PConstants.java b/core/src/processing/core/PConstants.java
@@ -213,16 +213,21 @@ public interface PConstants {
   // shape drawing modes
 
   /** Draw mode convention to use (x, y) to (width, height) */
-  static final int CORNER        = 0;
+  static final int CORNER   = 0;
   /** Draw mode convention to use (x1, y1) to (x2, y2) coordinates */
-  static final int CORNERS       = 1;
-  /** @deprecated Use RADIUS instead (as of 0125) */
-  static final int CENTER_RADIUS = 2;
+  static final int CORNERS  = 1;
   /** Draw mode from the center, and using the radius */
-  static final int RADIUS        = 2;
-  /** Draw from the center, using second pair of values as the diameter.
-      Formerly called CENTER_DIAMETER in alpha releases */
-  static final int CENTER        = 3;
+  static final int RADIUS   = 2;
+  /** 
+   * Draw from the center, using second pair of values as the diameter.
+   * Formerly called CENTER_DIAMETER in alpha releases.
+   */
+  static final int CENTER   = 3;
+  /** 
+   * Synonym for the CENTER constant. Draw from the center, 
+   * using second pair of values as the diameter.
+   */
+  static final int DIAMETER = 3;
 
 
   // vertically alignment modes for text
diff --git a/core/src/processing/core/PGraphics.java b/core/src/processing/core/PGraphics.java
@@ -740,9 +740,7 @@ protected void defaultSettings() {  // ignore
     matrixStackDepth = 0;
 
     rectMode(CORNER);
-    ellipseMode(CENTER);
-    //arcMode(CENTER);
-    //angleMode(RADIANS);
+    ellipseMode(DIAMETER);
 
     // no current font
     textFont = null;
diff --git a/core/src/processing/core/PMatrix2D.java b/core/src/processing/core/PMatrix2D.java
@@ -25,7 +25,7 @@
 
 
 /**
- * 4x4 matrix implementation.
+ * 3x2 affine matrix implementation.
  */
 public final class PMatrix2D implements PConstants {
 
@@ -110,9 +110,20 @@ public void translate(float tx, float ty) {
     m12 = tx*m10 + ty*m11 + m12;
   }
 
-
+  
+  // Implementation roughly based on AffineTransform.
   public void rotate(float angle) {
-    // TODO fixme
+    float s = sin(angle);
+    float c = cos(angle);
+
+    float temp1 = m00;
+    float temp2 = m01;
+    m00 =  c * temp1 + s * temp2;
+    m01 = -s * temp1 + c * temp2;
+    temp1 = m10;
+    temp2 = m11;
+    m10 =  c * temp1 + s * temp2;
+    m11 = -s * temp1 + c * temp2;
   }
 
 
@@ -199,14 +210,15 @@ public void preApply(float n00, float n01, float n02,
     t0 = m01;
     t1 = m11;
     m01 = t0 * n00 + t1 * n01;
-    m11 = t0 * n10 + t1 * n11;  }
+    m11 = t0 * n10 + t1 * n11;  
+  }
 
 
   //////////////////////////////////////////////////////////////
 
 
   /** 
-   * Multiply a four element vector against this matrix. 
+   * Multiply a two element vector against this matrix. 
    * If out is null or not length four, a new float array will be returned.
    * The values for vec and out can be the same (though that's less efficient). 
    */
diff --git a/core/src/processing/core/PMatrix3D.java b/core/src/processing/core/PMatrix3D.java
@@ -34,11 +34,6 @@ public final class PMatrix3D implements PConstants {
   public float m20, m21, m22, m23;
   public float m30, m31, m32, m33;
 
-//  final static int DEFAULT_STACK_DEPTH = 0;
-//  int maxStackDepth;
-//  int stackPointer = 0;
-//  float stack[][];
-
 
   // locally allocated version to avoid creating new memory
   protected PMatrix3D inverseCopy;
@@ -49,20 +44,12 @@ public PMatrix3D() {
   }
 
 
-//  public PMatrix(int stackDepth) {
-//    set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
-//    stack = new float[stackDepth][16];
-//    maxStackDepth = stackDepth;
-//  }
-
-
   public PMatrix3D(float m00, float m01, float m02, 
                    float m10, float m11, float m12) {
     set(m00, m01, m02, 0,
         m10, m11, m12, 0,
         0,   0,   1,   0,
         0,   0,   0,   1);
-//    maxStackDepth = DEFAULT_STACK_DEPTH;
   }
   
   
@@ -74,87 +61,17 @@ public PMatrix3D(float m00, float m01, float m02, float m03,
         m10, m11, m12, m13,
         m20, m21, m22, m23,
         m30, m31, m32, m33);
-//    maxStackDepth = DEFAULT_STACK_DEPTH;
   }
 
 
-  // Make a copy of a matrix. We copy the stack depth,
-  // but we don't make a copy of the stack or the stack pointer.
-//  public PMatrix(PMatrix src) {
-//    set(src);
-////    maxStackDepth = src.maxStackDepth;
-////    stack = new float[maxStackDepth][16];
-//  }
-
-
   public void reset() {
     set(1, 0, 0, 0,
         0, 1, 0, 0,
         0, 0, 1, 0,
         0, 0, 0, 1);
   }
-
-
-//  public void clearStack() {
-//    stackPointer = 0;
-//  }
-
-
-//  public boolean push() {
-//    if (stackPointer == maxStackDepth) return false;
-//
-//    stack[stackPointer][0] = m00;
-//    stack[stackPointer][1] = m01;
-//    stack[stackPointer][2] = m02;
-//    stack[stackPointer][3] = m03;
-//
-//    stack[stackPointer][4] = m10;
-//    stack[stackPointer][5] = m11;
-//    stack[stackPointer][6] = m12;
-//    stack[stackPointer][7] = m13;
-//
-//    stack[stackPointer][8] = m20;
-//    stack[stackPointer][9] = m21;
-//    stack[stackPointer][10] = m22;
-//    stack[stackPointer][11] = m23;
-//
-//    stack[stackPointer][12] = m30;
-//    stack[stackPointer][13] = m31;
-//    stack[stackPointer][14] = m32;
-//    stack[stackPointer][15] = m33;
-//
-//    stackPointer++;
-//    return true;
-//  }
-
-
-//  public boolean pop() {
-//    if (stackPointer == 0) return false;
-//    stackPointer--;
-//
-//    m00 = stack[stackPointer][0];
-//    m01 = stack[stackPointer][1];
-//    m02 = stack[stackPointer][2];
-//    m03 = stack[stackPointer][3];
-//
-//    m10 = stack[stackPointer][4];
-//    m11 = stack[stackPointer][5];
-//    m12 = stack[stackPointer][6];
-//    m13 = stack[stackPointer][7];
-//
-//    m20 = stack[stackPointer][8];
-//    m21 = stack[stackPointer][9];
-//    m22 = stack[stackPointer][10];
-//    m23 = stack[stackPointer][11];
-//
-//    m30 = stack[stackPointer][12];
-//    m31 = stack[stackPointer][13];
-//    m32 = stack[stackPointer][14];
-//    m33 = stack[stackPointer][15];
-//
-//    return true;
-//  }
-
+  
+  
   /**
    * Returns a copy of this PMatrix.
    */
