initial PShape implementation for JAVA2D

galsasson · galsasson · commit 056bbaedd331 · 2014-08-07T14:37:07.000-04:00
diff --git a/core/src/processing/core/PGraphicsJava2D.java b/core/src/processing/core/PGraphicsJava2D.java
@@ -470,7 +470,118 @@ public void hint(int which) {
   // SHAPES
 
 
-  //public void beginShape(int kind)
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE CREATION
+
+
+//  @Override
+//  public PShape createShape(PShape source) {
+//    return PShapeOpenGL.createShape2D(this, source);
+//  }
+
+
+  @Override
+  public PShape createShape() {
+    return createShape(PShape.GEOMETRY);
+  }
+
+
+  @Override
+  public PShape createShape(int type) {
+    return createShapeImpl(this, type);
+  }
+
+
+  @Override
+  public PShape createShape(int kind, float... p) {
+    return createShapeImpl(this, kind, p);
+  }
+
+
+  static protected PShape createShapeImpl(PGraphicsJava2D pg, int type) {
+    PShape shape = null;
+    if (type == PConstants.GROUP) {
+      shape = new PShape(pg, PConstants.GROUP);
+    } else if (type == PShape.PATH) {
+      shape = new PShape(pg, PShape.PATH);
+    } else if (type == PShape.GEOMETRY) {
+      shape = new PShape(pg, PShape.GEOMETRY);
+    }
+    shape.is3D(false);
+    return shape;
+  }
+
+
+  static protected PShape createShapeImpl(PGraphicsJava2D pg,
+                                                int kind, float... p) {
+    PShape shape = null;
+    int len = p.length;
+
+    if (kind == POINT) {
+      if (len != 2) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShape(pg, PShape.PRIMITIVE);
+      shape.setKind(POINT);
+    } else if (kind == LINE) {
+      if (len != 4) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShape(pg, PShape.PRIMITIVE);
+      shape.setKind(LINE);
+    } else if (kind == TRIANGLE) {
+      if (len != 6) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShape(pg, PShape.PRIMITIVE);
+      shape.setKind(TRIANGLE);
+    } else if (kind == QUAD) {
+      if (len != 8) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShape(pg, PShape.PRIMITIVE);
+      shape.setKind(QUAD);
+    } else if (kind == RECT) {
+      if (len != 4 && len != 5 && len != 8 && len != 9) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShape(pg, PShape.PRIMITIVE);
+      shape.setKind(RECT);
+    } else if (kind == ELLIPSE) {
+      if (len != 4 && len != 5) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShape(pg, PShape.PRIMITIVE);
+      shape.setKind(ELLIPSE);
+    } else if (kind == ARC) {
+      if (len != 6 && len != 7) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShape(pg, PShape.PRIMITIVE);
+      shape.setKind(ARC);
+    } else if (kind == BOX) {
+      showWarning("Primitive not supported in 2D");
+    } else if (kind == SPHERE) {
+      showWarning("Primitive not supported in 2D");
+    } else {
+      showWarning("Unrecognized primitive type");
+    }
+
+    if (shape != null) {
+      shape.setParams(p);
+    }
+
+    shape.is3D(false);
+    return shape;
+  }
 
 
   @Override
diff --git a/core/src/processing/core/PShape.java b/core/src/processing/core/PShape.java
@@ -25,6 +25,7 @@
 import java.util.HashMap;
 
 import processing.core.PApplet;
+import processing.core.PGraphicsJava2D;
 
 
 /**
@@ -274,6 +275,97 @@ public PShape(int family) {
     this.family = family;
   }
 
+  public PShape(PGraphicsJava2D pg, int family) {
+//    this.g = pg;
+//    pgl = pg.pgl;
+//    context = pgl.createEmptyContext();
+
+//    glPolyVertex = 0;
+//    glPolyColor = 0;
+//    glPolyNormal = 0;
+//    glPolyTexcoord = 0;
+//    glPolyAmbient = 0;
+//    glPolySpecular = 0;
+//    glPolyEmissive = 0;
+//    glPolyShininess = 0;
+//    glPolyIndex = 0;
+//
+//    glLineVertex = 0;
+//    glLineColor = 0;
+//    glLineAttrib = 0;
+//    glLineIndex = 0;
+//
+//    glPointVertex = 0;
+//    glPointColor = 0;
+//    glPointAttrib = 0;
+//    glPointIndex = 0;
+//
+//    this.tessellator = PGraphicsOpenGL.tessellator;
+    this.family = family;
+//    this.root = this;
+    this.parent = null;
+//    this.tessellated = false;
+
+//    if (family == GEOMETRY || family == PRIMITIVE || family == PATH) {
+//      inGeo = PGraphicsOpenGL.newInGeometry(pg, PGraphicsOpenGL.RETAINED);
+//    }
+
+    // Style parameters are retrieved from the current values in the renderer.
+    textureMode = pg.textureMode;
+
+    colorMode(pg.colorMode,
+              pg.colorModeX, pg.colorModeY, pg.colorModeZ, pg.colorModeA);
+
+    // Initial values for fill, stroke and tint colors are also imported from
+    // the renderer. This is particular relevant for primitive shapes, since is
+    // not possible to set their color separately when creating them, and their
+    // input vertices are actually generated at rendering time, by which the
+    // color configuration of the renderer might have changed.
+    fill = pg.fill;
+    fillColor = pg.fillColor;
+
+    stroke = pg.stroke;
+    strokeColor = pg.strokeColor;
+    strokeWeight = pg.strokeWeight;
+    strokeCap = pg.strokeCap;
+    strokeJoin = pg.strokeJoin;
+
+    tint = pg.tint;
+    tintColor = pg.tintColor;
+
+    setAmbient = pg.setAmbient;
+    ambientColor = pg.ambientColor;
+    specularColor = pg.specularColor;
+    emissiveColor = pg.emissiveColor;
+    shininess = pg.shininess;
+
+    sphereDetailU = pg.sphereDetailU;
+    sphereDetailV = pg.sphereDetailV;
+
+//    bezierDetail = pg.bezierDetail;
+//    curveDetail = pg.curveDetail;
+//    curveTightness = pg.curveTightness;
+
+    // The rect and ellipse modes are set to CORNER since it is the expected
+    // mode for svg shapes.
+    rectMode = CORNER;
+    ellipseMode = CORNER;
+
+//    normalX = normalY = 0;
+//    normalZ = 1;
+//
+//    normalMode = NORMAL_MODE_AUTO;
+
+    // To make sure that the first vertex is marked as a break.
+    // Same behavior as in the immediate mode.
+//    breakShape = false;
+
+    if (family == GROUP) {
+      // GROUP shapes are always marked as ended.
+//      shapeCreated = true;
+    }
+  }
+
 
   public void setKind(int kind) {
     this.kind = kind;
