added jogl library

java/libraries/jogl/.gitignore

@@ -0,0 +1 @@
+bin

java/libraries/jogl/examples/LargeStage/LargeStage.pde

@@ -0,0 +1,13 @@
+import processing.jogl.*;
+
+void setup() {
+  size(4000, 2000, JOGL.P3D);
+}
+  
+void draw() {
+  background(255, 0, 0);
+  line(0, 0, width, height);
+  line(0, height, width, 0);    
+  println(mouseX, mouseY);
+  ellipse(mouseX, mouseY, 50, 50);
+}

java/libraries/jogl/examples/OffscreenTest/OffscreenTest.pde

@@ -0,0 +1,31 @@
+import processing.jogl.*;
+
+PGraphics pg;
+
+void setup() {
+  size(400, 400, JOGL.P2D);
+
+  pg = createGraphics(400, 400, JOGL.P2D);
+  pg.smooth(4);
+}
+
+void draw() {
+  background(0);
+
+  pg.beginDraw();
+  pg.background(255, 0, 0);
+  pg.ellipse(mouseX, mouseY, 100, 100);
+  pg.endDraw();
+
+  image(pg, 0, 0, 400, 400);
+}
+
+void keyPressed() {
+  if (key == '1') pg.smooth(1);
+  else if (key == '2') pg.smooth(2);
+  else if (key == '3') pg.smooth(4);
+  else if (key == '4') pg.smooth(8);
+  else if (key == '5') pg.smooth(16);
+  else if (key == '6') pg.smooth(32); 
+}
+

java/libraries/jogl/examples/RestartTest/RestartTest.pde

@@ -0,0 +1,28 @@
+import processing.jogl.*;
+
+PShape cube;
+
+void setup() {
+  size(400, 400, JOGL.P3D);
+  smooth();
+
+  cube = createShape(BOX, 100);
+}
+
+void draw() {
+  background(120);
+    
+  lights();
+    
+  translate(mouseX, mouseY);
+  rotateX(frameCount * 0.01f);
+  rotateY(frameCount * 0.01f);
+    
+  shape(cube);    
+}
+
+void keyPressed() {
+  // Changing the smooth configuration restarts the OpenGL surface. 
+  // Automatically recreates all the current GL resources.
+  noSmooth();
+}

java/libraries/jogl/library/export.txt

@@ -0,0 +1,10 @@
+# If you want to support more platforms, visit jogamp.org to get the 
+# natives libraries for the platform in question (i.e. Solaris). 
+
+name = OpenGL
+
+application.macosx=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-macosx-universal.jar,gluegen-rt-natives-macosx-universal.jar
+application.windows32=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-windows-i586.jar,gluegen-rt-natives-windows-i586.jar
+application.windows64=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-windows-amd64.jar,gluegen-rt-natives-windows-amd64.jar
+application.linux32=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-linux-i586.jar,gluegen-rt-natives-linux-i586.jar
+application.linux64=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-linux-amd64.jar,gluegen-rt-natives-linux-amd64.jar

java/libraries/jogl/src/processing/jogl/PGraphics2D.java

@@ -0,0 +1,594 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012 Ben Fry and Casey Reas
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+ */
+
+package processing.opengl;
+
+import java.io.InputStream;
+import java.util.zip.GZIPInputStream;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PGraphics;
+import processing.core.PMatrix3D;
+import processing.core.PShape;
+import processing.core.PShapeSVG;
+import processing.data.XML;
+
+public class PGraphics2D extends PGraphicsOpenGL {
+
+  public PGraphics2D() {
+    super();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // RENDERER SUPPORT QUERIES
+
+
+  @Override
+  public boolean is2D() {
+    return true;
+  }
+
+
+  @Override
+  public boolean is3D() {
+    return false;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // HINTS
+
+
+  @Override
+  public void hint(int which) {
+    if (which == ENABLE_STROKE_PERSPECTIVE) {
+      showWarning("Strokes cannot be perspective-corrected in 2D.");
+      return;
+    }
+    super.hint(which);
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // PROJECTION
+
+
+  @Override
+  public void ortho() {
+    showMethodWarning("ortho");
+  }
+
+
+  @Override
+  public void ortho(float left, float right,
+                    float bottom, float top) {
+    showMethodWarning("ortho");
+  }
+
+
+  @Override
+  public void ortho(float left, float right,
+                    float bottom, float top,
+                    float near, float far) {
+    showMethodWarning("ortho");
+  }
+
+
+  @Override
+  public void perspective() {
+    showMethodWarning("perspective");
+  }
+
+
+  @Override
+  public void perspective(float fov, float aspect, float zNear, float zFar) {
+    showMethodWarning("perspective");
+  }
+
+
+  @Override
+  public void frustum(float left, float right, float bottom, float top,
+                      float znear, float zfar) {
+    showMethodWarning("frustum");
+  }
+
+
+  @Override
+  protected void defaultPerspective() {
+    super.ortho(0, width, -height, 0, -1, +1);
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CAMERA
+
+
+  @Override
+  public void beginCamera() {
+    showMethodWarning("beginCamera");
+  }
+
+
+  @Override
+  public void endCamera() {
+    showMethodWarning("endCamera");
+  }
+
+
+  @Override
+  public void camera() {
+    showMethodWarning("camera");
+  }
+
+
+  @Override
+  public void camera(float eyeX, float eyeY, float eyeZ,
+                     float centerX, float centerY, float centerZ,
+                     float upX, float upY, float upZ) {
+    showMethodWarning("camera");
+  }
+
+
+  @Override
+  protected void defaultCamera() {
+    cameraEyeX = cameraEyeY = cameraEyeZ = 0;
+    resetMatrix();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX MORE!
+
+
+  @Override
+  protected void begin2D() {
+    pushProjection();
+    defaultPerspective();
+    pushMatrix();
+    defaultCamera();
+  }
+
+
+  @Override
+  protected void end2D() {
+    popMatrix();
+    popProjection();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE
+
+
+  @Override
+  public void shape(PShape shape) {
+    if (shape.is2D()) {
+      super.shape(shape);
+    } else {
+      showWarning("The shape object is not 2D, cannot be displayed with " +
+                  "this renderer");
+    }
+  }
+
+
+  @Override
+  public void shape(PShape shape, float x, float y) {
+    if (shape.is2D()) {
+      super.shape(shape, x, y);
+    } else {
+      showWarning("The shape object is not 2D, cannot be displayed with " +
+                  "this renderer");
+    }
+  }
+
+
+  @Override
+  public void shape(PShape shape, float a, float b, float c, float d) {
+    if (shape.is2D()) {
+      super.shape(shape, a, b, c, d);
+    } else {
+      showWarning("The shape object is not 2D, cannot be displayed with " +
+                  "this renderer");
+    }
+  }
+
+
+  @Override
+  public void shape(PShape shape, float x, float y, float z) {
+    showDepthWarningXYZ("shape");
+  }
+
+
+  @Override
+  public void shape(PShape shape, float x, float y, float z,
+                    float c, float d, float e) {
+    showDepthWarningXYZ("shape");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE I/O
+
+
+  static protected boolean isSupportedExtension(String extension) {
+    return extension.equals("svg") || extension.equals("svgz");
+  }
+
+
+  static protected PShape loadShapeImpl(PGraphics pg, String filename,
+                                                      String extension) {
+    PShapeSVG svg = null;
+
+    if (extension.equals("svg")) {
+      svg = new PShapeSVG(pg.parent.loadXML(filename));
+
+    } else if (extension.equals("svgz")) {
+      try {
+        InputStream input =
+          new GZIPInputStream(pg.parent.createInput(filename));
+        XML xml = new XML(PApplet.createReader(input));
+        svg = new PShapeSVG(xml);
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    }
+
+    if (svg != null) {
+      PShapeOpenGL p2d = PShapeOpenGL.createShape2D((PGraphicsOpenGL)pg, svg);
+      return p2d;
+    } else {
+      return null;
+    }
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // 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 PShapeOpenGL createShapeImpl(PGraphicsOpenGL pg, int type) {
+    PShapeOpenGL shape = null;
+    if (type == PConstants.GROUP) {
+      shape = new PShapeOpenGL(pg, PConstants.GROUP);
+    } else if (type == PShape.PATH) {
+      shape = new PShapeOpenGL(pg, PShape.PATH);
+    } else if (type == PShape.GEOMETRY) {
+      shape = new PShapeOpenGL(pg, PShape.GEOMETRY);
+    }
+    shape.set3D(false);
+    return shape;
+  }
+
+
+  static protected PShapeOpenGL createShapeImpl(PGraphicsOpenGL pg,
+                                                int kind, float... p) {
+    PShapeOpenGL shape = null;
+    int len = p.length;
+
+    if (kind == POINT) {
+      if (len != 2) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(POINT);
+    } else if (kind == LINE) {
+      if (len != 4) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(LINE);
+    } else if (kind == TRIANGLE) {
+      if (len != 6) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(TRIANGLE);
+    } else if (kind == QUAD) {
+      if (len != 8) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(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 PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(RECT);
+    } else if (kind == ELLIPSE) {
+      if (len != 4 && len != 5) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(ELLIPSE);
+    } else if (kind == ARC) {
+      if (len != 6 && len != 7) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(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.set3D(false);
+    return shape;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BEZIER VERTICES
+
+
+  @Override
+  public void bezierVertex(float x2, float y2, float z2,
+                           float x3, float y3, float z3,
+                           float x4, float y4, float z4) {
+    showDepthWarningXYZ("bezierVertex");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // QUADRATIC BEZIER VERTICES
+
+
+  @Override
+  public void quadraticVertex(float x2, float y2, float z2,
+                         float x4, float y4, float z4) {
+    showDepthWarningXYZ("quadVertex");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CURVE VERTICES
+
+
+  @Override
+  public void curveVertex(float x, float y, float z) {
+    showDepthWarningXYZ("curveVertex");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BOX
+
+
+  @Override
+  public void box(float w, float h, float d) {
+    showMethodWarning("box");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SPHERE
+
+
+  @Override
+  public void sphere(float r) {
+    showMethodWarning("sphere");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // VERTEX SHAPES
+
+
+  @Override
+  public void vertex(float x, float y, float z) {
+    showDepthWarningXYZ("vertex");
+  }
+
+  @Override
+  public void vertex(float x, float y, float z, float u, float v) {
+    showDepthWarningXYZ("vertex");
+  }
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX TRANSFORMATIONS
+
+  @Override
+  public void translate(float tx, float ty, float tz) {
+    showDepthWarningXYZ("translate");
+  }
+
+  @Override
+  public void rotateX(float angle) {
+    showDepthWarning("rotateX");
+  }
+
+  @Override
+  public void rotateY(float angle) {
+    showDepthWarning("rotateY");
+  }
+
+  @Override
+  public void rotateZ(float angle) {
+    showDepthWarning("rotateZ");
+  }
+
+  @Override
+  public void rotate(float angle, float vx, float vy, float vz) {
+    showVariationWarning("rotate");
+  }
+
+  @Override
+  public void applyMatrix(PMatrix3D source) {
+    showVariationWarning("applyMatrix");
+  }
+
+  @Override
+  public void applyMatrix(float n00, float n01, float n02, float n03,
+                          float n10, float n11, float n12, float n13,
+                          float n20, float n21, float n22, float n23,
+                          float n30, float n31, float n32, float n33) {
+    showVariationWarning("applyMatrix");
+  }
+
+  @Override
+  public void scale(float sx, float sy, float sz) {
+    showDepthWarningXYZ("scale");
+  }
+
+  //////////////////////////////////////////////////////////////
+
+  // SCREEN AND MODEL COORDS
+
+  @Override
+  public float screenX(float x, float y, float z) {
+    showDepthWarningXYZ("screenX");
+    return 0;
+  }
+
+  @Override
+  public float screenY(float x, float y, float z) {
+    showDepthWarningXYZ("screenY");
+    return 0;
+  }
+
+  @Override
+  public float screenZ(float x, float y, float z) {
+    showDepthWarningXYZ("screenZ");
+    return 0;
+  }
+
+  @Override
+  public PMatrix3D getMatrix(PMatrix3D target) {
+    showVariationWarning("getMatrix");
+    return target;
+  }
+
+  @Override
+  public void setMatrix(PMatrix3D source) {
+    showVariationWarning("setMatrix");
+  }
+
+  //////////////////////////////////////////////////////////////
+
+  // LIGHTS
+
+  @Override
+  public void lights() {
+    showMethodWarning("lights");
+  }
+
+  @Override
+  public void noLights() {
+    showMethodWarning("noLights");
+  }
+
+  @Override
+  public void ambientLight(float red, float green, float blue) {
+    showMethodWarning("ambientLight");
+  }
+
+  @Override
+  public void ambientLight(float red, float green, float blue,
+                           float x, float y, float z) {
+    showMethodWarning("ambientLight");
+  }
+
+  @Override
+  public void directionalLight(float red, float green, float blue,
+                               float nx, float ny, float nz) {
+    showMethodWarning("directionalLight");
+  }
+
+  @Override
+  public void pointLight(float red, float green, float blue,
+                         float x, float y, float z) {
+    showMethodWarning("pointLight");
+  }
+
+  @Override
+  public void spotLight(float red, float green, float blue,
+                        float x, float y, float z,
+                        float nx, float ny, float nz,
+                        float angle, float concentration) {
+    showMethodWarning("spotLight");
+  }
+
+  @Override
+  public void lightFalloff(float constant, float linear, float quadratic) {
+    showMethodWarning("lightFalloff");
+  }
+
+  @Override
+  public void lightSpecular(float v1, float v2, float v3) {
+    showMethodWarning("lightSpecular");
+  }
+}

java/libraries/jogl/src/processing/jogl/PGraphics2D2X.java

@@ -0,0 +1,595 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012 Ben Fry and Casey Reas
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+ */
+
+package processing.opengl;
+
+import java.io.InputStream;
+import java.util.zip.GZIPInputStream;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PGraphics;
+import processing.core.PMatrix3D;
+import processing.core.PShape;
+import processing.core.PShapeSVG;
+import processing.data.XML;
+
+public class PGraphics2D2X extends PGraphicsOpenGL {
+
+  public PGraphics2D2X() {
+    super();
+    pixelFactor = 2;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // RENDERER SUPPORT QUERIES
+
+
+  @Override
+  public boolean is2D() {
+    return true;
+  }
+
+
+  @Override
+  public boolean is3D() {
+    return false;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // HINTS
+
+
+  @Override
+  public void hint(int which) {
+    if (which == ENABLE_STROKE_PERSPECTIVE) {
+      showWarning("Strokes cannot be perspective-corrected in 2D.");
+      return;
+    }
+    super.hint(which);
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // PROJECTION
+
+
+  @Override
+  public void ortho() {
+    showMethodWarning("ortho");
+  }
+
+
+  @Override
+  public void ortho(float left, float right,
+                    float bottom, float top) {
+    showMethodWarning("ortho");
+  }
+
+
+  @Override
+  public void ortho(float left, float right,
+                    float bottom, float top,
+                    float near, float far) {
+    showMethodWarning("ortho");
+  }
+
+
+  @Override
+  public void perspective() {
+    showMethodWarning("perspective");
+  }
+
+
+  @Override
+  public void perspective(float fov, float aspect, float zNear, float zFar) {
+    showMethodWarning("perspective");
+  }
+
+
+  @Override
+  public void frustum(float left, float right, float bottom, float top,
+                      float znear, float zfar) {
+    showMethodWarning("frustum");
+  }
+
+
+  @Override
+  protected void defaultPerspective() {
+    super.ortho(0, width, -height, 0, -1, +1);
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CAMERA
+
+
+  @Override
+  public void beginCamera() {
+    showMethodWarning("beginCamera");
+  }
+
+
+  @Override
+  public void endCamera() {
+    showMethodWarning("endCamera");
+  }
+
+
+  @Override
+  public void camera() {
+    showMethodWarning("camera");
+  }
+
+
+  @Override
+  public void camera(float eyeX, float eyeY, float eyeZ,
+                     float centerX, float centerY, float centerZ,
+                     float upX, float upY, float upZ) {
+    showMethodWarning("camera");
+  }
+
+
+  @Override
+  protected void defaultCamera() {
+    cameraEyeX = cameraEyeY = cameraEyeZ = 0;
+    resetMatrix();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX MORE!
+
+
+  @Override
+  protected void begin2D() {
+    pushProjection();
+    defaultPerspective();
+    pushMatrix();
+    defaultCamera();
+  }
+
+
+  @Override
+  protected void end2D() {
+    popMatrix();
+    popProjection();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE
+
+
+  @Override
+  public void shape(PShape shape) {
+    if (shape.is2D()) {
+      super.shape(shape);
+    } else {
+      showWarning("The shape object is not 2D, cannot be displayed with " +
+                  "this renderer");
+    }
+  }
+
+
+  @Override
+  public void shape(PShape shape, float x, float y) {
+    if (shape.is2D()) {
+      super.shape(shape, x, y);
+    } else {
+      showWarning("The shape object is not 2D, cannot be displayed with " +
+                  "this renderer");
+    }
+  }
+
+
+  @Override
+  public void shape(PShape shape, float a, float b, float c, float d) {
+    if (shape.is2D()) {
+      super.shape(shape, a, b, c, d);
+    } else {
+      showWarning("The shape object is not 2D, cannot be displayed with " +
+                  "this renderer");
+    }
+  }
+
+
+  @Override
+  public void shape(PShape shape, float x, float y, float z) {
+    showDepthWarningXYZ("shape");
+  }
+
+
+  @Override
+  public void shape(PShape shape, float x, float y, float z,
+                    float c, float d, float e) {
+    showDepthWarningXYZ("shape");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE I/O
+
+
+  static protected boolean isSupportedExtension(String extension) {
+    return extension.equals("svg") || extension.equals("svgz");
+  }
+
+
+  static protected PShape loadShapeImpl(PGraphics pg, String filename,
+                                                      String extension) {
+    PShapeSVG svg = null;
+
+    if (extension.equals("svg")) {
+      svg = new PShapeSVG(pg.parent.loadXML(filename));
+
+    } else if (extension.equals("svgz")) {
+      try {
+        InputStream input =
+          new GZIPInputStream(pg.parent.createInput(filename));
+        XML xml = new XML(PApplet.createReader(input));
+        svg = new PShapeSVG(xml);
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    }
+
+    if (svg != null) {
+      PShapeOpenGL p2d = PShapeOpenGL.createShape2D((PGraphicsOpenGL)pg, svg);
+      return p2d;
+    } else {
+      return null;
+    }
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // 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 PShapeOpenGL createShapeImpl(PGraphicsOpenGL pg, int type) {
+    PShapeOpenGL shape = null;
+    if (type == PConstants.GROUP) {
+      shape = new PShapeOpenGL(pg, PConstants.GROUP);
+    } else if (type == PShape.PATH) {
+      shape = new PShapeOpenGL(pg, PShape.PATH);
+    } else if (type == PShape.GEOMETRY) {
+      shape = new PShapeOpenGL(pg, PShape.GEOMETRY);
+    }
+    shape.set3D(false);
+    return shape;
+  }
+
+
+  static protected PShapeOpenGL createShapeImpl(PGraphicsOpenGL pg,
+                                                int kind, float... p) {
+    PShapeOpenGL shape = null;
+    int len = p.length;
+
+    if (kind == POINT) {
+      if (len != 2) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(POINT);
+    } else if (kind == LINE) {
+      if (len != 4) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(LINE);
+    } else if (kind == TRIANGLE) {
+      if (len != 6) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(TRIANGLE);
+    } else if (kind == QUAD) {
+      if (len != 8) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(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 PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(RECT);
+    } else if (kind == ELLIPSE) {
+      if (len != 4 && len != 5) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(ELLIPSE);
+    } else if (kind == ARC) {
+      if (len != 6 && len != 7) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(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.set3D(false);
+    return shape;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BEZIER VERTICES
+
+
+  @Override
+  public void bezierVertex(float x2, float y2, float z2,
+                           float x3, float y3, float z3,
+                           float x4, float y4, float z4) {
+    showDepthWarningXYZ("bezierVertex");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // QUADRATIC BEZIER VERTICES
+
+
+  @Override
+  public void quadraticVertex(float x2, float y2, float z2,
+                         float x4, float y4, float z4) {
+    showDepthWarningXYZ("quadVertex");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CURVE VERTICES
+
+
+  @Override
+  public void curveVertex(float x, float y, float z) {
+    showDepthWarningXYZ("curveVertex");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BOX
+
+
+  @Override
+  public void box(float w, float h, float d) {
+    showMethodWarning("box");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SPHERE
+
+
+  @Override
+  public void sphere(float r) {
+    showMethodWarning("sphere");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // VERTEX SHAPES
+
+
+  @Override
+  public void vertex(float x, float y, float z) {
+    showDepthWarningXYZ("vertex");
+  }
+
+  @Override
+  public void vertex(float x, float y, float z, float u, float v) {
+    showDepthWarningXYZ("vertex");
+  }
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX TRANSFORMATIONS
+
+  @Override
+  public void translate(float tx, float ty, float tz) {
+    showDepthWarningXYZ("translate");
+  }
+
+  @Override
+  public void rotateX(float angle) {
+    showDepthWarning("rotateX");
+  }
+
+  @Override
+  public void rotateY(float angle) {
+    showDepthWarning("rotateY");
+  }
+
+  @Override
+  public void rotateZ(float angle) {
+    showDepthWarning("rotateZ");
+  }
+
+  @Override
+  public void rotate(float angle, float vx, float vy, float vz) {
+    showVariationWarning("rotate");
+  }
+
+  @Override
+  public void applyMatrix(PMatrix3D source) {
+    showVariationWarning("applyMatrix");
+  }
+
+  @Override
+  public void applyMatrix(float n00, float n01, float n02, float n03,
+                          float n10, float n11, float n12, float n13,
+                          float n20, float n21, float n22, float n23,
+                          float n30, float n31, float n32, float n33) {
+    showVariationWarning("applyMatrix");
+  }
+
+  @Override
+  public void scale(float sx, float sy, float sz) {
+    showDepthWarningXYZ("scale");
+  }
+
+  //////////////////////////////////////////////////////////////
+
+  // SCREEN AND MODEL COORDS
+
+  @Override
+  public float screenX(float x, float y, float z) {
+    showDepthWarningXYZ("screenX");
+    return 0;
+  }
+
+  @Override
+  public float screenY(float x, float y, float z) {
+    showDepthWarningXYZ("screenY");
+    return 0;
+  }
+
+  @Override
+  public float screenZ(float x, float y, float z) {
+    showDepthWarningXYZ("screenZ");
+    return 0;
+  }
+
+  @Override
+  public PMatrix3D getMatrix(PMatrix3D target) {
+    showVariationWarning("getMatrix");
+    return target;
+  }
+
+  @Override
+  public void setMatrix(PMatrix3D source) {
+    showVariationWarning("setMatrix");
+  }
+
+  //////////////////////////////////////////////////////////////
+
+  // LIGHTS
+
+  @Override
+  public void lights() {
+    showMethodWarning("lights");
+  }
+
+  @Override
+  public void noLights() {
+    showMethodWarning("noLights");
+  }
+
+  @Override
+  public void ambientLight(float red, float green, float blue) {
+    showMethodWarning("ambientLight");
+  }
+
+  @Override
+  public void ambientLight(float red, float green, float blue,
+                           float x, float y, float z) {
+    showMethodWarning("ambientLight");
+  }
+
+  @Override
+  public void directionalLight(float red, float green, float blue,
+                               float nx, float ny, float nz) {
+    showMethodWarning("directionalLight");
+  }
+
+  @Override
+  public void pointLight(float red, float green, float blue,
+                         float x, float y, float z) {
+    showMethodWarning("pointLight");
+  }
+
+  @Override
+  public void spotLight(float red, float green, float blue,
+                        float x, float y, float z,
+                        float nx, float ny, float nz,
+                        float angle, float concentration) {
+    showMethodWarning("spotLight");
+  }
+
+  @Override
+  public void lightFalloff(float constant, float linear, float quadratic) {
+    showMethodWarning("lightFalloff");
+  }
+
+  @Override
+  public void lightSpecular(float v1, float v2, float v3) {
+    showMethodWarning("lightSpecular");
+  }
+}

java/libraries/jogl/src/processing/jogl/PGraphics3D.java

@@ -0,0 +1,278 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012 Ben Fry and Casey Reas
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+ */
+
+package processing.opengl;
+
+import java.io.InputStream;
+import java.util.zip.GZIPInputStream;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PGraphics;
+import processing.core.PShape;
+import processing.core.PShapeOBJ;
+
+public class PGraphics3D extends PGraphicsOpenGL {
+
+  public PGraphics3D() {
+    super();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // RENDERER SUPPORT QUERIES
+
+
+  @Override
+  public boolean is2D() {
+    return false;
+  }
+
+
+  @Override
+  public boolean is3D() {
+    return true;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // PROJECTION
+
+
+  @Override
+  protected void defaultPerspective() {
+    perspective();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CAMERA
+
+
+  @Override
+  protected void defaultCamera() {
+    camera();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX MORE!
+
+
+  @Override
+  protected void begin2D() {
+    pushProjection();
+    ortho(0, width, 0, height, -1, +1);
+    pushMatrix();
+
+    // Set camera for 2D rendering, it simply centers at (width/2, height/2)
+    float centerX = width/2;
+    float centerY = height/2;
+    modelview.reset();
+    modelview.translate(-centerX, -centerY);
+
+    modelviewInv.set(modelview);
+    modelviewInv.invert();
+
+    camera.set(modelview);
+    cameraInv.set(modelviewInv);
+
+    updateProjmodelview();
+  }
+
+
+  @Override
+  protected void end2D() {
+    popMatrix();
+    popProjection();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE I/O
+
+
+  static protected boolean isSupportedExtension(String extension) {
+    return extension.equals("obj");
+  }
+
+
+  static protected PShape loadShapeImpl(PGraphics pg, String filename,
+                                                      String extension) {
+    PShapeOBJ obj = null;
+
+    if (extension.equals("obj")) {
+      obj = new PShapeOBJ(pg.parent, filename);
+
+    } else if (extension.equals("objz")) {
+      try {
+        // TODO: The obj file can be read from the gzip, but if it refers to
+        // a materials file and texture images, those must be contained in the
+        // data folder, cannot be inside the gzip.
+        InputStream input =
+          new GZIPInputStream(pg.parent.createInput(filename));
+        obj = new PShapeOBJ(pg.parent, PApplet.createReader(input));
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    }
+
+    if (obj != null) {
+      int prevTextureMode = pg.textureMode;
+      pg.textureMode = NORMAL;
+      PShapeOpenGL p3d = PShapeOpenGL.createShape3D((PGraphicsOpenGL)pg, obj);
+      pg.textureMode = prevTextureMode;
+      return p3d;
+    } else {
+      return null;
+    }
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE CREATION
+
+
+  @Override
+  public PShape createShape(PShape source) {
+    return PShapeOpenGL.createShape3D(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 PShapeOpenGL createShapeImpl(PGraphicsOpenGL pg, int type) {
+    PShapeOpenGL shape = null;
+    if (type == PConstants.GROUP) {
+      shape = new PShapeOpenGL(pg, PConstants.GROUP);
+    } else if (type == PShape.PATH) {
+      shape = new PShapeOpenGL(pg, PShape.PATH);
+    } else if (type == PShape.GEOMETRY) {
+      shape = new PShapeOpenGL(pg, PShape.GEOMETRY);
+    }
+    shape.set3D(true);
+    return shape;
+  }
+
+
+  static protected PShapeOpenGL createShapeImpl(PGraphicsOpenGL pg,
+                                                int kind, float... p) {
+    PShapeOpenGL shape = null;
+    int len = p.length;
+
+    if (kind == POINT) {
+      if (len != 2 && len != 3) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(POINT);
+    } else if (kind == LINE) {
+      if (len != 4 && len != 6) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(LINE);
+    } else if (kind == TRIANGLE) {
+      if (len != 6) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(TRIANGLE);
+    } else if (kind == QUAD) {
+      if (len != 8) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(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 PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(RECT);
+    } else if (kind == ELLIPSE) {
+      if (len != 4 && len != 5) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(ELLIPSE);
+    } else if (kind == ARC) {
+      if (len != 6 && len != 7) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(ARC);
+    } else if (kind == BOX) {
+      if (len != 1 && len != 3) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(BOX);
+    } else if (kind == SPHERE) {
+      if (len < 1 || 3 < len) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(SPHERE);
+    } else {
+      showWarning("Unrecognized primitive type");
+    }
+
+    if (shape != null) {
+      shape.setParams(p);
+    }
+
+    shape.set3D(true);
+    return shape;
+  }
+}

java/libraries/jogl/src/processing/jogl/PGraphics3D2X.java

@@ -0,0 +1,279 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012 Ben Fry and Casey Reas
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+ */
+
+package processing.opengl;
+
+import java.io.InputStream;
+import java.util.zip.GZIPInputStream;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PGraphics;
+import processing.core.PShape;
+import processing.core.PShapeOBJ;
+
+public class PGraphics3D2X extends PGraphicsOpenGL {
+
+  public PGraphics3D2X() {
+    super();
+    pixelFactor = 2;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // RENDERER SUPPORT QUERIES
+
+
+  @Override
+  public boolean is2D() {
+    return false;
+  }
+
+
+  @Override
+  public boolean is3D() {
+    return true;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // PROJECTION
+
+
+  @Override
+  protected void defaultPerspective() {
+    perspective();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CAMERA
+
+
+  @Override
+  protected void defaultCamera() {
+    camera();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX MORE!
+
+
+  @Override
+  protected void begin2D() {
+    pushProjection();
+    ortho(0, width, 0, height, -1, +1);
+    pushMatrix();
+
+    // Set camera for 2D rendering, it simply centers at (width/2, height/2)
+    float centerX = width/2;
+    float centerY = height/2;
+    modelview.reset();
+    modelview.translate(-centerX, -centerY);
+
+    modelviewInv.set(modelview);
+    modelviewInv.invert();
+
+    camera.set(modelview);
+    cameraInv.set(modelviewInv);
+
+    updateProjmodelview();
+  }
+
+
+  @Override
+  protected void end2D() {
+    popMatrix();
+    popProjection();
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE I/O
+
+
+  static protected boolean isSupportedExtension(String extension) {
+    return extension.equals("obj");
+  }
+
+
+  static protected PShape loadShapeImpl(PGraphics pg, String filename,
+                                                      String extension) {
+    PShapeOBJ obj = null;
+
+    if (extension.equals("obj")) {
+      obj = new PShapeOBJ(pg.parent, filename);
+
+    } else if (extension.equals("objz")) {
+      try {
+        // TODO: The obj file can be read from the gzip, but if it refers to
+        // a materials file and texture images, those must be contained in the
+        // data folder, cannot be inside the gzip.
+        InputStream input =
+          new GZIPInputStream(pg.parent.createInput(filename));
+        obj = new PShapeOBJ(pg.parent, PApplet.createReader(input));
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    }
+
+    if (obj != null) {
+      int prevTextureMode = pg.textureMode;
+      pg.textureMode = NORMAL;
+      PShapeOpenGL p3d = PShapeOpenGL.createShape3D((PGraphicsOpenGL)pg, obj);
+      pg.textureMode = prevTextureMode;
+      return p3d;
+    } else {
+      return null;
+    }
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE CREATION
+
+
+  @Override
+  public PShape createShape(PShape source) {
+    return PShapeOpenGL.createShape3D(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 PShapeOpenGL createShapeImpl(PGraphicsOpenGL pg, int type) {
+    PShapeOpenGL shape = null;
+    if (type == PConstants.GROUP) {
+      shape = new PShapeOpenGL(pg, PConstants.GROUP);
+    } else if (type == PShape.PATH) {
+      shape = new PShapeOpenGL(pg, PShape.PATH);
+    } else if (type == PShape.GEOMETRY) {
+      shape = new PShapeOpenGL(pg, PShape.GEOMETRY);
+    }
+    shape.set3D(true);
+    return shape;
+  }
+
+
+  static protected PShapeOpenGL createShapeImpl(PGraphicsOpenGL pg,
+                                                int kind, float... p) {
+    PShapeOpenGL shape = null;
+    int len = p.length;
+
+    if (kind == POINT) {
+      if (len != 2 && len != 3) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(POINT);
+    } else if (kind == LINE) {
+      if (len != 4 && len != 6) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(LINE);
+    } else if (kind == TRIANGLE) {
+      if (len != 6) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(TRIANGLE);
+    } else if (kind == QUAD) {
+      if (len != 8) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(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 PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(RECT);
+    } else if (kind == ELLIPSE) {
+      if (len != 4 && len != 5) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(ELLIPSE);
+    } else if (kind == ARC) {
+      if (len != 6 && len != 7) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(ARC);
+    } else if (kind == BOX) {
+      if (len != 1 && len != 3) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(BOX);
+    } else if (kind == SPHERE) {
+      if (len < 1 || 3 < len) {
+        showWarning("Wrong number of parameters");
+        return null;
+      }
+      shape = new PShapeOpenGL(pg, PShape.PRIMITIVE);
+      shape.setKind(SPHERE);
+    } else {
+      showWarning("Unrecognized primitive type");
+    }
+
+    if (shape != null) {
+      shape.setParams(p);
+    }
+
+    shape.set3D(true);
+    return shape;
+  }
+}

java/libraries/jogl/src/processing/jogl/PSurfaceNEWT.java

@@ -0,0 +1,713 @@
+package processing.opengl;
+
+import java.awt.Canvas;
+import java.awt.Color;
+import java.awt.EventQueue;
+import java.awt.Frame;
+import java.awt.Rectangle;
+//import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+
+import javax.media.nativewindow.NativeSurface;
+import javax.media.nativewindow.ScalableSurface;
+import javax.media.opengl.GLAnimatorControl;
+import javax.media.opengl.GLAutoDrawable;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLEventListener;
+import javax.media.opengl.GLException;
+import javax.media.opengl.GLProfile;
+
+import com.jogamp.nativewindow.MutableGraphicsConfiguration;
+import com.jogamp.newt.Display;
+import com.jogamp.newt.MonitorDevice;
+import com.jogamp.newt.NewtFactory;
+import com.jogamp.newt.Screen;
+import com.jogamp.newt.awt.NewtCanvasAWT;
+import com.jogamp.newt.event.InputEvent;
+import com.jogamp.newt.event.WindowAdapter;
+import com.jogamp.newt.event.WindowEvent;
+import com.jogamp.newt.opengl.GLWindow;
+import com.jogamp.opengl.util.FPSAnimator;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PGraphics;
+import processing.core.PImage;
+import processing.core.PSurface;
+import processing.event.KeyEvent;
+import processing.event.MouseEvent;
+
+public class PSurfaceNEWT implements PSurface {
+  /** Selected GL profile */
+  public static GLProfile profile;
+
+  PJOGL pgl;
+
+  GLWindow window;
+  Frame frame;
+  FPSAnimator animator;
+  Rectangle screenRect;
+
+  PApplet sketch;
+  PGraphics graphics;
+
+  int sketchWidth;
+  int sketchHeight;
+
+  MonitorDevice displayDevice;
+  Throwable drawException;
+  Object waitObject = new Object();
+
+  public PSurfaceNEWT(PGraphics graphics) {
+    this.graphics = graphics;
+    this.pgl = (PJOGL) ((PGraphicsOpenGL)graphics).pgl;
+  }
+
+  public void initOffscreen() {
+    // TODO Auto-generated method stub
+
+  }
+
+  public Canvas initCanvas(PApplet sketch) {
+    this.sketch = sketch;
+
+    sketchWidth = sketch.sketchWidth();
+    sketchHeight = sketch.sketchHeight();
+
+    if (window != null) {
+      NewtCanvasAWT canvas = new NewtCanvasAWT(window);
+      canvas.setBounds(0, 0, window.getWidth(), window.getHeight());
+//      canvas.setBackground(new Color(pg.backgroundColor, true));
+      canvas.setFocusable(true);
+
+      return canvas;
+    }
+
+    return null;
+  }
+
+  public Frame initFrame(PApplet sketch, Color backgroundColor,
+                         int deviceIndex, boolean fullScreen,
+                         boolean spanDisplays) {
+    this.sketch = sketch;
+
+    Display display = NewtFactory.createDisplay(null);
+    display.addReference();
+    Screen screen = NewtFactory.createScreen(display, 0);
+    screen.addReference();
+
+    ArrayList<MonitorDevice> monitors = new ArrayList<MonitorDevice>();
+    for (int i = 0; i < screen.getMonitorDevices().size(); i++) {
+      MonitorDevice monitor = screen.getMonitorDevices().get(i);
+      System.out.println("Monitor " + monitor.getId() + " ************");
+      System.out.println(monitor.toString());
+      System.out.println(monitor.getViewportInWindowUnits());
+      System.out.println(monitor.getViewport());
+
+      monitors.add(monitor);
+    }
+    System.out.println("*******************************");
+
+    if (deviceIndex >= 0) {  // if -1, use the default device
+      if (deviceIndex < monitors.size()) {
+        displayDevice = monitors.get(deviceIndex);
+      } else {
+        System.err.format("Display %d does not exist, " +
+          "using the default display instead.", deviceIndex);
+        for (int i = 0; i < monitors.size(); i++) {
+          System.err.format("Display %d is %s\n", i, monitors.get(i));
+        }
+      }
+    }
+
+    if (profile == null) {
+      if (PJOGL.PROFILE == 2) {
+        try {
+          profile = GLProfile.getGL2ES1();
+        } catch (GLException ex) {
+          profile = GLProfile.getMaxFixedFunc(true);
+        }
+      } else if (PJOGL.PROFILE == 3) {
+        try {
+          profile = GLProfile.getGL2GL3();
+        } catch (GLException ex) {
+          profile = GLProfile.getMaxProgrammable(true);
+        }
+        if (!profile.isGL3()) {
+          PGraphics.showWarning("Requested profile GL3 but is not available, got: " + profile);
+        }
+      } else if (PJOGL.PROFILE == 4) {
+        try {
+          profile = GLProfile.getGL4ES3();
+        } catch (GLException ex) {
+          profile = GLProfile.getMaxProgrammable(true);
+        }
+        if (!profile.isGL4()) {
+          PGraphics.showWarning("Requested profile GL4 but is not available, got: " + profile);
+        }
+      } else throw new RuntimeException(PGL.UNSUPPORTED_GLPROF_ERROR);
+    }
+
+    // Setting up the desired capabilities;
+    GLCapabilities caps = new GLCapabilities(profile);
+    caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);
+    caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS);
+    caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS);
+
+//    caps.setPBuffer(false);
+//    caps.setFBO(false);
+
+    pgl.reqNumSamples = graphics.quality;
+    caps.setSampleBuffers(true);
+    caps.setNumSamples(pgl.reqNumSamples);
+    caps.setBackgroundOpaque(true);
+    caps.setOnscreen(true);
+    pgl.capabilities = caps;
+    System.err.println("0. create window");
+    window = GLWindow.create(screen, caps);
+
+    sketchWidth = sketch.sketchWidth();
+    sketchHeight = sketch.sketchHeight();
+
+    if (displayDevice == null) {
+      displayDevice = window.getMainMonitor();
+    }
+    int sketchX = displayDevice.getViewportInWindowUnits().getX();
+    int sketchY = displayDevice.getViewportInWindowUnits().getY();
+
+    int screenWidth = screen.getWidth();
+    int screenHeight = screen.getHeight();
+
+    screenRect = spanDisplays ? new Rectangle(0, 0, screen.getWidth(), screen.getHeight()) :
+                                new Rectangle(0, 0, displayDevice.getViewportInWindowUnits().getWidth(),
+                                                    displayDevice.getViewportInWindowUnits().getHeight());
+
+    // Sketch has already requested to be the same as the screen's
+    // width and height, so let's roll with full screen mode.
+    if (screenRect.width == sketchWidth &&
+        screenRect.height == sketchHeight) {
+      fullScreen = true;
+    }
+
+    if (fullScreen || spanDisplays) {
+      sketchWidth = screenRect.width;
+      sketchHeight = screenRect.height;
+    }
+
+//    window..setBackground(new Color(backgroundColor, true));
+    window.setPosition(sketchX, sketchY);
+    window.setSize(sketchWidth, sketchHeight);
+
+    System.out.println("deviceIndex: " + deviceIndex);
+    System.out.println(displayDevice);
+    System.out.println("Screen res " + screenWidth + "x" + screenHeight);
+
+    // This example could be useful:
+    // com.jogamp.opengl.test.junit.newt.mm.TestScreenMode01cNEWT
+    if (fullScreen) {
+      if (spanDisplays) {
+        window.setFullscreen(monitors);
+      } else {
+        window.setFullscreen(true);
+      }
+    }
+
+    int[] reqSurfacePixelScale;
+    if (graphics.is2X()) {
+       // Retina
+       reqSurfacePixelScale = new int[] { ScalableSurface.AUTOMAX_PIXELSCALE,
+                                          ScalableSurface.AUTOMAX_PIXELSCALE };
+       pgl.pixel_scale = 2;
+    } else {
+      // Non-retina
+      reqSurfacePixelScale = new int[] { ScalableSurface.IDENTITY_PIXELSCALE,
+                                         ScalableSurface.IDENTITY_PIXELSCALE };
+      pgl.pixel_scale = 1;
+    }
+    window.setSurfaceScale(reqSurfacePixelScale);
+
+    NEWTMouseListener mouseListener = new NEWTMouseListener();
+    window.addMouseListener(mouseListener);
+    NEWTKeyListener keyListener = new NEWTKeyListener();
+    window.addKeyListener(keyListener);
+    NEWTWindowListener winListener = new NEWTWindowListener();
+    window.addWindowListener(winListener);
+
+    DrawListener drawlistener = new DrawListener();
+    window.addGLEventListener(drawlistener);
+
+    System.err.println("0. create animator");
+    animator = new FPSAnimator(window, 60);
+    drawException = null;
+    animator.setUncaughtExceptionHandler(new GLAnimatorControl.UncaughtExceptionHandler() {
+      @Override
+      public void uncaughtException(final GLAnimatorControl animator,
+                                    final GLAutoDrawable drawable,
+                                    final Throwable cause) {
+        synchronized (waitObject) {
+//          System.err.println("Caught exception: " + cause.getMessage());
+          drawException = cause;
+          waitObject.notify();
+        }
+      }
+    });
+
+    (new Thread(new Runnable() {
+      public void run() {
+        synchronized (waitObject) {
+          try {
+            if (drawException == null) waitObject.wait();
+          } catch (InterruptedException e) {
+            e.printStackTrace();
+          }
+//          System.err.println("Caught exception: " + drawException.getMessage());
+          if (drawException instanceof RuntimeException) {
+            throw (RuntimeException)drawException.getCause();
+          } else {
+            throw new RuntimeException(drawException.getCause());
+          }
+        }
+      }
+    }
+    )).start();
+
+
+    /*
+    try {
+      EventQueue.invokeAndWait(new Runnable() {
+        public void run() {
+          while (true) {
+            try {
+              if (drawException != null) {
+                if (drawException instanceof RuntimeException) {
+                  throw (RuntimeException)drawException;
+                } else {
+                  throw new RuntimeException(drawException);
+                }
+              } else {
+                Thread.sleep(100);
+              }
+            } catch (InterruptedException e) { }
+          }
+      }});
+    } catch (Exception ex) {
+    }
+*/
+
+
+    window.addWindowListener(new WindowAdapter() {
+      @Override
+      public void windowDestroyNotify(final WindowEvent e) {
+        animator.stop();
+        PSurfaceNEWT.this.sketch.exit();
+        window.destroy();
+      }
+    });
+
+
+//  window.setVisible(true);
+    try {
+      EventQueue.invokeAndWait(new Runnable() {
+        public void run() {
+          window.setVisible(true);
+          System.err.println("1. set visible");
+      }});
+    } catch (Exception ex) {
+      // error setting the window visible, should quit...
+    }
+
+    frame = new DummyFrame();
+    return frame;
+  }
+
+  class DummyFrame extends Frame {
+
+    public DummyFrame() {
+      super();
+    }
+
+    @Override
+    public void setResizable(boolean resizable) {
+//      super.setResizable(resizable);
+    }
+
+    @Override
+    public void setVisible(boolean visible) {
+      window.setVisible(visible);
+    }
+
+    @Override
+    public void setTitle(String title) {
+      window.setTitle(title);
+    }
+  }
+
+
+  public void setTitle(String title) {
+    window.setTitle(title);
+  }
+
+  public void setVisible(boolean visible) {
+    window.setVisible(visible);
+  }
+
+  public void setResizable(boolean resizable) {
+    // TODO Auto-generated method stub
+
+  }
+
+  public void placeWindow(int[] location) {
+    // TODO Auto-generated method stub
+
+  }
+
+  public void placeWindow(int[] location, int[] editorLocation) {
+    // TODO Auto-generated method stub
+
+  }
+
+  public void placePresent(Color stopColor) {
+    // TODO Auto-generated method stub
+
+  }
+
+  public void setupExternalMessages() {
+    // TODO Auto-generated method stub
+
+  }
+
+  public void startThread() {
+    if (animator != null) {
+      System.err.println("2. start animator");
+      animator.start();
+      animator.getThread().setName("Processing-GL-draw");
+    }
+  }
+
+  public void pauseThread() {
+    if (animator != null) {
+      animator.pause();
+    }
+  }
+
+  public void resumeThread() {
+    if (animator != null) {
+      animator.resume();
+    }
+  }
+
+  public boolean stopThread() {
+    if (animator != null) {
+      return animator.stop();
+    } else {
+      return false;
+    }
+  }
+
+  public boolean isStopped() {
+    if (animator != null) {
+      return !animator.isAnimating();
+    } else {
+      return true;
+    }
+  }
+
+  public void setSize(int width, int height) {
+    if (frame != null) {
+      System.err.println("3. set size");
+      sketchWidth = sketch.width = width;
+      sketchHeight = sketch.height = height;
+      graphics.setSize(width, height);
+    }
+  }
+
+  public void setSmooth(int level) {
+    pgl.reqNumSamples = level;
+    GLCapabilities caps = new GLCapabilities(profile);
+    caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);
+    caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS);
+    caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS);
+    caps.setSampleBuffers(true);
+    caps.setNumSamples(pgl.reqNumSamples);
+    caps.setBackgroundOpaque(true);
+    caps.setOnscreen(true);
+    NativeSurface target = window.getNativeSurface();
+    MutableGraphicsConfiguration config = (MutableGraphicsConfiguration) target.getGraphicsConfiguration();
+    config.setChosenCapabilities(caps);
+  }
+
+  public void setFrameRate(float fps) {
+    if (animator != null) {
+      animator.stop();
+      animator.setFPS((int)fps);
+      pgl.setFps(fps);
+      animator.start();
+    }
+  }
+
+  public void requestFocus() {
+    window.requestFocus();
+
+  }
+
+  public void blit() {
+    // TODO Auto-generated method stub
+  }
+
+  class DrawListener implements GLEventListener {
+    public void display(GLAutoDrawable drawable) {
+      pgl.getGL(drawable);
+//      System.out.println(" - " + sketch.frameCount);
+      sketch.handleDraw();
+
+      if (sketch.frameCount == 1) {
+        requestFocus();
+      }
+    }
+    public void dispose(GLAutoDrawable drawable) {
+      pgl.getGL(drawable);
+      sketch.dispose();
+      if (sketch.exitCalled()) {
+        sketch.exitActual();
+      }
+    }
+    public void init(GLAutoDrawable drawable) {
+      pgl.init(drawable);
+      pgl.getGL(drawable);
+      sketch.start();
+
+      int c = graphics.backgroundColor;
+      pgl.clearColor(((c >> 16) & 0xff) / 255f,
+                     ((c >>  8) & 0xff) / 255f,
+                     ((c >>  0) & 0xff) / 255f,
+                     ((c >> 24) & 0xff) / 255f);
+      pgl.clear(PGL.COLOR_BUFFER_BIT);
+    }
+
+    public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) {
+      pgl.getGL(drawable);
+      setSize(w, h);
+    }
+  }
+
+  protected class NEWTWindowListener implements com.jogamp.newt.event.WindowListener {
+    public NEWTWindowListener() {
+      super();
+    }
+    @Override
+    public void windowGainedFocus(com.jogamp.newt.event.WindowEvent arg0) {
+//      pg.parent.focusGained(null);
+    }
+
+    @Override
+    public void windowLostFocus(com.jogamp.newt.event.WindowEvent arg0) {
+//      pg.parent.focusLost(null);
+    }
+
+    @Override
+    public void windowDestroyNotify(com.jogamp.newt.event.WindowEvent arg0) {
+    }
+
+    @Override
+    public void windowDestroyed(com.jogamp.newt.event.WindowEvent arg0) {
+    }
+
+    @Override
+    public void windowMoved(com.jogamp.newt.event.WindowEvent arg0) {
+    }
+
+    @Override
+    public void windowRepaint(com.jogamp.newt.event.WindowUpdateEvent arg0) {
+    }
+
+    @Override
+    public void windowResized(com.jogamp.newt.event.WindowEvent arg0) { }
+  }
+
+  // NEWT mouse listener
+  protected class NEWTMouseListener extends com.jogamp.newt.event.MouseAdapter {
+    public NEWTMouseListener() {
+      super();
+    }
+    @Override
+    public void mousePressed(com.jogamp.newt.event.MouseEvent e) {
+      nativeMouseEvent(e, MouseEvent.PRESS);
+    }
+    @Override
+    public void mouseReleased(com.jogamp.newt.event.MouseEvent e) {
+      nativeMouseEvent(e, MouseEvent.RELEASE);
+    }
+    @Override
+    public void mouseClicked(com.jogamp.newt.event.MouseEvent e) {
+      nativeMouseEvent(e, MouseEvent.CLICK);
+    }
+    @Override
+    public void mouseDragged(com.jogamp.newt.event.MouseEvent e) {
+      nativeMouseEvent(e, MouseEvent.DRAG);
+    }
+    @Override
+    public void mouseMoved(com.jogamp.newt.event.MouseEvent e) {
+      nativeMouseEvent(e, MouseEvent.MOVE);
+    }
+    @Override
+    public void mouseWheelMoved(com.jogamp.newt.event.MouseEvent e) {
+      nativeMouseEvent(e, MouseEvent.WHEEL);
+    }
+    @Override
+    public void mouseEntered(com.jogamp.newt.event.MouseEvent e) {
+      nativeMouseEvent(e, MouseEvent.ENTER);
+    }
+    @Override
+    public void mouseExited(com.jogamp.newt.event.MouseEvent e) {
+      nativeMouseEvent(e, MouseEvent.EXIT);
+    }
+  }
+
+  // NEWT key listener
+  protected class NEWTKeyListener extends com.jogamp.newt.event.KeyAdapter {
+    public NEWTKeyListener() {
+      super();
+    }
+    @Override
+    public void keyPressed(com.jogamp.newt.event.KeyEvent e) {
+      nativeKeyEvent(e, KeyEvent.PRESS);
+    }
+    @Override
+    public void keyReleased(com.jogamp.newt.event.KeyEvent e) {
+      nativeKeyEvent(e, KeyEvent.RELEASE);
+    }
+    public void keyTyped(com.jogamp.newt.event.KeyEvent e)  {
+      nativeKeyEvent(e, KeyEvent.TYPE);
+    }
+  }
+
+  protected void nativeMouseEvent(com.jogamp.newt.event.MouseEvent nativeEvent,
+                                  int peAction) {
+    int modifiers = nativeEvent.getModifiers();
+    int peModifiers = modifiers &
+                      (InputEvent.SHIFT_MASK |
+                       InputEvent.CTRL_MASK |
+                       InputEvent.META_MASK |
+                       InputEvent.ALT_MASK);
+
+    int peButton = 0;
+    if ((modifiers & InputEvent.BUTTON1_MASK) != 0) {
+      peButton = PConstants.LEFT;
+    } else if ((modifiers & InputEvent.BUTTON2_MASK) != 0) {
+      peButton = PConstants.CENTER;
+    } else if ((modifiers & InputEvent.BUTTON3_MASK) != 0) {
+      peButton = PConstants.RIGHT;
+    }
+
+    if (PApplet.platform == PConstants.MACOSX) {
+      //if (nativeEvent.isPopupTrigger()) {
+      if ((modifiers & InputEvent.CTRL_MASK) != 0) {
+        peButton = PConstants.RIGHT;
+      }
+    }
+
+    int peCount = 0;
+    if (peAction == MouseEvent.WHEEL) {
+      peCount = nativeEvent.isShiftDown() ? (int)nativeEvent.getRotation()[0] :
+                                            (int)nativeEvent.getRotation()[1];
+    } else {
+      peCount = nativeEvent.getClickCount();
+    }
+
+    MouseEvent me = new MouseEvent(nativeEvent, nativeEvent.getWhen(),
+                                   peAction, peModifiers,
+                                   nativeEvent.getX(), nativeEvent.getY(),
+                                   peButton,
+                                   peCount);
+
+    sketch.postEvent(me);
+  }
+
+  protected void nativeKeyEvent(com.jogamp.newt.event.KeyEvent nativeEvent,
+                                int peAction) {
+    int peModifiers = nativeEvent.getModifiers() &
+                      (InputEvent.SHIFT_MASK |
+                       InputEvent.CTRL_MASK |
+                       InputEvent.META_MASK |
+                       InputEvent.ALT_MASK);
+
+    short code = nativeEvent.getKeyCode();
+    char keyChar;
+    int keyCode;
+    if (isPCodedKey(code)) {
+      keyCode = mapToPConst(code);
+      keyChar = PConstants.CODED;
+    } else {
+      keyCode = code;
+      keyChar = nativeEvent.getKeyChar();
+    }
+
+    // From http://jogamp.org/deployment/v2.1.0/javadoc/jogl/javadoc/com/jogamp/newt/event/KeyEvent.html
+    // public final short getKeySymbol()
+    // Returns the virtual key symbol reflecting the current keyboard layout.
+    // public final short getKeyCode()
+    // Returns the virtual key code using a fixed mapping to the US keyboard layout.
+    // In contrast to key symbol, key code uses a fixed US keyboard layout and therefore is keyboard layout independent.
+    // E.g. virtual key code VK_Y denotes the same physical key regardless whether keyboard layout QWERTY or QWERTZ is active. The key symbol of the former is VK_Y, where the latter produces VK_Y.
+    KeyEvent ke = new KeyEvent(nativeEvent, nativeEvent.getWhen(),
+                               peAction, peModifiers,
+                               keyChar,
+                               keyCode);
+//                               nativeEvent.getKeySymbol());
+
+    sketch.postEvent(ke);
+  }
+
+  // Why do we need this mapping?
+  // Relevant discussion and links here:
+  // http://forum.jogamp.org/Newt-wrong-keycode-for-key-td4033690.html#a4033697
+  // (I don't think this is a complete solution).
+  private static int mapToPConst(short code) {
+    if (code == com.jogamp.newt.event.KeyEvent.VK_UP) {
+      return PConstants.UP;
+    } else if (code == com.jogamp.newt.event.KeyEvent.VK_DOWN) {
+      return PConstants.DOWN;
+    } else if (code == com.jogamp.newt.event.KeyEvent.VK_LEFT) {
+      return PConstants.LEFT;
+    } else if (code == com.jogamp.newt.event.KeyEvent.VK_RIGHT) {
+      return PConstants.RIGHT;
+    } else if (code == com.jogamp.newt.event.KeyEvent.VK_ALT) {
+      return PConstants.ALT;
+    } else if (code == com.jogamp.newt.event.KeyEvent.VK_CONTROL) {
+      return PConstants.CONTROL;
+    } else if (code == com.jogamp.newt.event.KeyEvent.VK_SHIFT) {
+      return PConstants.SHIFT;
+    }
+    return code;
+  }
+
+  private static boolean isPCodedKey(short code) {
+    return code == com.jogamp.newt.event.KeyEvent.VK_UP ||
+           code == com.jogamp.newt.event.KeyEvent.VK_DOWN ||
+           code == com.jogamp.newt.event.KeyEvent.VK_LEFT ||
+           code == com.jogamp.newt.event.KeyEvent.VK_RIGHT ||
+           code == com.jogamp.newt.event.KeyEvent.VK_ALT ||
+           code == com.jogamp.newt.event.KeyEvent.VK_CONTROL ||
+           code == com.jogamp.newt.event.KeyEvent.VK_SHIFT;
+  }
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+  public void setCursor(int kind) {
+    // TODO Auto-generated method stub
+
+  }
+
+  public void setCursor(PImage image, int hotspotX, int hotspotY) {
+    // TODO Auto-generated method stub
+
+  }
+
+  public void showCursor() {
+    window.setPointerVisible(true);
+  }
+
+  public void hideCursor() {
+    window.setPointerVisible(false);
+  }
+}