picrate 1.2.3-java → 2.1.0-java

data/src/main/java/processing/opengl/PGraphicsOpenGL.java

@@ -47,13 +47,17 @@ public class PGraphicsOpenGL extends PGraphics {
   /** Font cache for texture objects. */
   protected WeakHashMap<PFont, FontTexture> fontMap;
 
+  // Blocking save
+  protected volatile Object saveBlocker;
+  private volatile Optional<String> saveTargetMaybe;
+
   // ........................................................
 
   // Disposal of native resources
   // Using the technique alternative to finalization described in:
   // http://www.oracle.com/technetwork/articles/java/finalization-137655.html
   private static final ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
-  private static final List<Disposable<? extends Object>> reachableWeakReferences =
+  private static final List<Disposable<?>> reachableWeakReferences =
     new LinkedList<>();
 
   static final private int MAX_DRAIN_GLRES_ITERATIONS = 10;
@@ -61,8 +65,8 @@ public class PGraphicsOpenGL extends PGraphics {
   static void drainRefQueueBounded() {
     int iterations = 0;
     while (iterations < MAX_DRAIN_GLRES_ITERATIONS) {
-      Disposable<? extends Object> res =
-        (Disposable<? extends Object>) refQueue.poll();
+      Disposable<?> res =
+        (Disposable<?>) refQueue.poll();
       if (res == null) {
         break;
       }
@@ -568,6 +572,9 @@ public class PGraphicsOpenGL extends PGraphics {
   public PGraphicsOpenGL() {
     pgl = createPGL(this);
 
+    saveTargetMaybe = Optional.empty();
+    saveBlocker = new Object();
+
     if (intBuffer == null) {
       intBuffer = PGL.allocateIntBuffer(2);
       floatBuffer = PGL.allocateFloatBuffer(2);
@@ -709,7 +716,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
   // Factory method
   protected PGL createPGL(PGraphicsOpenGL pg) {
-    return new PJOGL(pg);
+    return new PJOGL(pg, () -> { onRender(); });
 //    return new PGLES(pg);
   }
 
@@ -751,22 +758,35 @@ public class PGraphicsOpenGL extends PGraphics {
   }
 
 
+  @Override
   public boolean saveImpl(String filename) {
 //    return super.save(filename); // ASYNC save frame using PBOs not yet available on Android
 
     if (getHint(DISABLE_ASYNC_SAVEFRAME)) {
-      // Act as an opaque surface for the purposes of saving.
-      if (primaryGraphics) {
-        int prevFormat = format;
-        format = RGB;
-        boolean result = super.save(filename);
-        format = prevFormat;
-        return result;
+      saveTargetMaybe = Optional.of(filename);
+
+      if (!drawing) {
+        beginDraw();
       }
+      flush();
+      updatePixelSize();
+      endDraw(); // Briefly stop drawing
 
-      return super.save(filename);
+      synchronized(saveBlocker) {
+        try {
+          while (saveTargetMaybe.isPresent()) {
+            saveBlocker.wait();
+          }
+          beginDraw(); // Resume drawing
+          return true;
+        } catch (InterruptedException e) {
+          return false;
+        }
+      }
     }
 
+    boolean needEndDraw = false;
+
     if (asyncImageSaver == null) {
       asyncImageSaver = new AsyncImageSaver();
     }
@@ -780,7 +800,6 @@ public class PGraphicsOpenGL extends PGraphics {
     }
 
     if (asyncPixelReader != null && !loaded) {
-      boolean needEndDraw = false;
       if (!drawing) {
         beginDraw();
         needEndDraw = true;
@@ -809,6 +828,21 @@ public class PGraphicsOpenGL extends PGraphics {
   }
 
 
+  private void onRender() {
+    if (saveTargetMaybe.isEmpty()) {
+      return; // Nothing to save
+    }
+
+    PImage outputImage = pgl.screenshot();
+    outputImage.save(saveTargetMaybe.get());
+    saveTargetMaybe = Optional.empty();
+
+    synchronized(saveBlocker) {
+      saveBlocker.notify();
+    }
+  }
+
+
   //////////////////////////////////////////////////////////////
 
   // IMAGE METADATA FOR THIS RENDERER
@@ -919,7 +953,7 @@ public class PGraphicsOpenGL extends PGraphics {
     int glId;
 
     private PGL pgl;
-    private int context;
+    private final int context;
 
     public GLResourceVertexBuffer(VertexBuffer vbo) {
       super(vbo);
@@ -970,7 +1004,7 @@ public class PGraphicsOpenGL extends PGraphics {
     int glFragment;
 
     private PGL pgl;
-    private int context;
+    private final int context;
 
     public GLResourceShader(PShader sh) {
       super(sh);
@@ -1190,7 +1224,7 @@ public class PGraphicsOpenGL extends PGraphics {
     if (!polyBuffersCreated || polyBuffersContextIsOutdated()) {
       polyBuffersContext = pgl.getCurrentContext();
 
-      bufPolyVertex = new VertexBuffer(this, PGL.ARRAY_BUFFER, 3, PGL.SIZEOF_FLOAT);
+      bufPolyVertex = new VertexBuffer(this, PGL.ARRAY_BUFFER, 4, PGL.SIZEOF_FLOAT);
       bufPolyColor = new VertexBuffer(this, PGL.ARRAY_BUFFER, 1, PGL.SIZEOF_INT);
       bufPolyNormal = new VertexBuffer(this, PGL.ARRAY_BUFFER, 3, PGL.SIZEOF_FLOAT);
       bufPolyTexcoord = new VertexBuffer(this, PGL.ARRAY_BUFFER, 2, PGL.SIZEOF_FLOAT);
@@ -2390,8 +2424,8 @@ public class PGraphicsOpenGL extends PGraphics {
 
   protected void flushPolys() {
     boolean customShader = polyShader != null;
-    boolean needNormals = customShader ? polyShader.accessNormals() : false;
-    boolean needTexCoords = customShader ? polyShader.accessTexCoords() : false;
+    boolean needNormals = customShader && polyShader.accessNormals();
+    boolean needTexCoords = customShader && polyShader.accessTexCoords();
 
     updatePolyBuffers(lights, texCache.hasTextures, needNormals, needTexCoords);
 
@@ -2464,8 +2498,8 @@ public class PGraphicsOpenGL extends PGraphics {
 
   protected void flushSortedPolys() {
     boolean customShader = polyShader != null;
-    boolean needNormals = customShader ? polyShader.accessNormals() : false;
-    boolean needTexCoords = customShader ? polyShader.accessTexCoords() : false;
+    boolean needNormals = customShader && polyShader.accessNormals();
+    boolean needTexCoords = customShader && polyShader.accessTexCoords();
 
     sorter.sort(tessGeo);
 
@@ -3516,7 +3550,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
 
   @Override
-  protected float textWidthImpl(char buffer[], int start, int stop) {
+  protected float textWidthImpl(char[] buffer, int start, int stop) {
     if (textFont == null) defaultFontOrDeath("textWidth");
     Object font = textFont.getNative();
     float twidth = 0;
@@ -3541,7 +3575,7 @@ public class PGraphicsOpenGL extends PGraphics {
    * Implementation of actual drawing for a line of text.
    */
   @Override
-  protected void textLineImpl(char buffer[], int start, int stop,
+  protected void textLineImpl(char[] buffer, int start, int stop,
                               float x, float y) {
 
     if (textMode == SHAPE && textFont.getNative() == null) {
@@ -3685,7 +3719,7 @@ public class PGraphicsOpenGL extends PGraphics {
     PGL.FontOutline outline = pgl.createFontOutline(ch, textFont.getNative());
 
     // six element array received from the Java2D path iterator
-    float textPoints[] = new float[6];
+    float[] textPoints = new float[6];
     float lastX = 0;
     float lastY = 0;
 
@@ -3803,6 +3837,13 @@ public class PGraphicsOpenGL extends PGraphics {
   }
 
 
+  static protected void invTranslate(PMatrix2D matrix,
+                                     float tx, float ty) {
+    matrix.preApply(1, 0, -tx,
+                    0, 1, -ty);
+  }
+
+
   static protected float matrixScale(PMatrix matrix) {
     // Volumetric scaling factor that is associated to the given
     // transformation matrix, which is given by the absolute value of its
@@ -3888,8 +3929,8 @@ public class PGraphicsOpenGL extends PGraphics {
   }
 
 
-  static private void invRotate(PMatrix3D matrix, float angle,
-                                float v0, float v1, float v2) {
+  static protected void invRotate(PMatrix3D matrix, float angle,
+                                  float v0, float v1, float v2) {
     float c = PApplet.cos(-angle);
     float s = PApplet.sin(-angle);
     float t = 1.0f - c;
@@ -3901,6 +3942,11 @@ public class PGraphicsOpenGL extends PGraphics {
   }
 
 
+  static protected void invRotate(PMatrix2D matrix, float angle) {
+    matrix.rotate(-angle);
+  }
+
+
   /**
    * Same as scale(s, s, s).
    */
@@ -3942,6 +3988,11 @@ public class PGraphicsOpenGL extends PGraphics {
   }
 
 
+  static protected void invScale(PMatrix2D matrix, float x, float y) {
+    matrix.preApply(1/x, 0, 0, 1/y, 0, 0);
+  }
+
+
   @Override
   public void shearX(float angle) {
     float t = (float) Math.tan(angle);
@@ -4580,6 +4631,8 @@ public class PGraphicsOpenGL extends PGraphics {
    * against) the current perspective matrix.
    * <P>
    * Implementation based on the explanation in the OpenGL blue book.
+   * @param znear
+   * @param zfar
    */
   @Override
   public void frustum(float left, float right, float bottom, float top,
@@ -5352,9 +5405,9 @@ public class PGraphicsOpenGL extends PGraphics {
   // showWarning() and showException() available from PGraphics.
 
   /**
-   * Report on anything from glError().Don't use this inside glBegin/glEnd 
-   * otherwise it'll throw an GL_INVALID_OPERATION error.
-   * @param where
+   * Report on anything from glError().
+   * Don't use this inside glBegin/glEnd otherwise it'll
+   * throw an GL_INVALID_OPERATION error.
    */
   protected void report(String where) {
     if (!hints[DISABLE_OPENGL_ERRORS]) {
@@ -6366,11 +6419,10 @@ public class PGraphicsOpenGL extends PGraphics {
 
 
   /**
-   * Not an approved function, this will change or be removed in the future.This 
-   * utility method returns the texture associated to the renderer's. drawing 
-   * surface, making sure is updated to reflect the current contents off the 
-   * screen (or offscreen drawing surface).
-   * @return 
+   * Not an approved function, this will change or be removed in the future.
+   * This utility method returns the texture associated to the renderer's.
+   * drawing surface, making sure is updated to reflect the current contents
+   * off the screen (or offscreen drawing surface).
    */
   public Texture getTexture() {
     return getTexture(true);
@@ -6379,8 +6431,6 @@ public class PGraphicsOpenGL extends PGraphics {
 
   /**
    * Not an approved function either, don't use it.
-   * @param load
-   * @return 
    */
   public Texture getTexture(boolean load) {
     if (load) loadTexture();
@@ -6389,11 +6439,11 @@ public class PGraphicsOpenGL extends PGraphics {
 
 
   /**
-   * Not an approved function, this will change or be removed in the future.This utility method returns the texture associated to the image.
+   * Not an approved function, this will change or be removed in the future.
+   * This utility method returns the texture associated to the image.
    * creating and/or updating it if needed.
    *
    * @param img the image to have a texture metadata associated to it
-   * @return 
    */
   public Texture getTexture(PImage img) {
     Texture tex = (Texture)initCache(img);
@@ -6419,7 +6469,6 @@ public class PGraphicsOpenGL extends PGraphics {
   /**
    * Not an approved function, test its use in libraries to grab the FB objects
    * for offscreen PGraphics.
-   * @return 
    */
   public FrameBuffer getFrameBuffer() {
     return getFrameBuffer(false);
@@ -6444,9 +6493,16 @@ public class PGraphicsOpenGL extends PGraphics {
     if (tex == null || tex.contextIsOutdated()) {
       tex = addTexture(img);
       if (tex != null) {
+        boolean dispose = img.pixels == null;
         img.loadPixels();
         tex.set(img.pixels, img.format);
         img.setModified();
+        if (dispose) {
+          // We only used the pixels to load the image into the texture and the user did not request
+          // to load the pixels, so we should dispose the pixels array to avoid wasting memory
+          img.pixels = null;
+          img.loaded = false;
+        }
       }
     }
     return tex;
@@ -6478,7 +6534,6 @@ public class PGraphicsOpenGL extends PGraphics {
    * This utility method creates a texture for the provided image, and adds it
    * to the metadata cache of the image.
    * @param img the image to have a texture metadata associated to it
-   * @return 
    */
   protected Texture addTexture(PImage img) {
     Texture.Parameters params =
@@ -6830,6 +6885,9 @@ public class PGraphicsOpenGL extends PGraphics {
       } else {
         // offscreen surfaces are transparent by default.
         background((backgroundColor & 0xFFFFFF));
+
+        // Recreate offscreen FBOs
+        restartPGL();
       }
 
       // Sets the default projection and camera (initializes modelview).
@@ -6915,30 +6973,16 @@ public class PGraphicsOpenGL extends PGraphics {
     maxTextureSize = intBuffer.get(0);
 
     // work around runtime exceptions in Broadcom's VC IV driver
-    if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {
-      pgl.getIntegerv(PGL.MAX_SAMPLES, intBuffer);
-      maxSamples = intBuffer.get(0);
-    }
+   // if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {
+    pgl.getIntegerv(PGL.MAX_SAMPLES, intBuffer);
+    maxSamples = intBuffer.get(0);
+   // }
 
     if (anisoSamplingSupported) {
       pgl.getFloatv(PGL.MAX_TEXTURE_MAX_ANISOTROPY, floatBuffer);
       maxAnisoAmount = floatBuffer.get(0);
     }
 
-    // overwrite the default shaders with vendor specific versions
-    // if needed
-    if (OPENGL_RENDERER.equals("VideoCore IV HW")) {  // Broadcom's binary driver for Raspberry Pi
-        defLightShaderVertURL =
-          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-brcm.glsl");
-        defTexlightShaderVertURL =
-          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightVert-brcm.glsl");
-    } else if (OPENGL_RENDERER.contains("VC4")) {     // Mesa driver for same hardware
-        defLightShaderVertURL =
-          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-vc4.glsl");
-        defTexlightShaderVertURL =
-          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightVert-vc4.glsl");
-    }
-
     glParamsRead = true;
   }
 
@@ -7943,61 +7987,61 @@ public class PGraphicsOpenGL extends PGraphics {
     // Expand arrays
 
     void expandVertices(int n) {
-      float temp[] = new float[3 * n];
+      float[] temp = new float[3 * n];
       PApplet.arrayCopy(vertices, 0, temp, 0, 3 * vertexCount);
       vertices = temp;
     }
 
     void expandColors(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(colors, 0, temp, 0, vertexCount);
       colors = temp;
     }
 
     void expandNormals(int n) {
-      float temp[] = new float[3 * n];
+      float[] temp = new float[3 * n];
       PApplet.arrayCopy(normals, 0, temp, 0, 3 * vertexCount);
       normals = temp;
     }
 
     void expandTexCoords(int n) {
-      float temp[] = new float[2 * n];
+      float[] temp = new float[2 * n];
       PApplet.arrayCopy(texcoords, 0, temp, 0, 2 * vertexCount);
       texcoords = temp;
     }
 
     void expandStrokeColors(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(strokeColors, 0, temp, 0, vertexCount);
       strokeColors = temp;
     }
 
     void expandStrokeWeights(int n) {
-      float temp[] = new float[n];
+      float[] temp = new float[n];
       PApplet.arrayCopy(strokeWeights, 0, temp, 0, vertexCount);
       strokeWeights = temp;
     }
 
     void expandAmbient(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(ambient, 0, temp, 0, vertexCount);
       ambient = temp;
     }
 
     void expandSpecular(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(specular, 0, temp, 0, vertexCount);
       specular = temp;
     }
 
     void expandEmissive(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(emissive, 0, temp, 0, vertexCount);
       emissive = temp;
     }
 
     void expandShininess(int n) {
-      float temp[] = new float[n];
+      float[] temp = new float[n];
       PApplet.arrayCopy(shininess, 0, temp, 0, vertexCount);
       shininess = temp;
     }
@@ -8016,33 +8060,33 @@ public class PGraphicsOpenGL extends PGraphics {
 
     void expandFloatAttrib(VertexAttribute attrib, int n) {
       float[] values = fattribs.get(attrib.name);
-      float temp[] = new float[attrib.size * n];
+      float[] temp = new float[attrib.size * n];
       PApplet.arrayCopy(values, 0, temp, 0, attrib.size * vertexCount);
       fattribs.put(attrib.name, temp);
     }
 
     void expandIntAttrib(VertexAttribute attrib, int n) {
       int[] values = iattribs.get(attrib.name);
-      int temp[] = new int[attrib.size * n];
+      int[] temp = new int[attrib.size * n];
       PApplet.arrayCopy(values, 0, temp, 0, attrib.size * vertexCount);
       iattribs.put(attrib.name, temp);
     }
 
     void expandBoolAttrib(VertexAttribute attrib, int n) {
       byte[] values = battribs.get(attrib.name);
-      byte temp[] = new byte[attrib.size * n];
+      byte[] temp = new byte[attrib.size * n];
       PApplet.arrayCopy(values, 0, temp, 0, attrib.size * vertexCount);
       battribs.put(attrib.name, temp);
     }
 
     void expandCodes(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(codes, 0, temp, 0, codeCount);
       codes = temp;
     }
 
     void expandEdges(int n) {
-      int temp[][] = new int[n][3];
+      int[][] temp = new int[n][3];
       PApplet.arrayCopy(edges, 0, temp, 0, edgeCount);
       edges = temp;
     }
@@ -8076,73 +8120,73 @@ public class PGraphicsOpenGL extends PGraphics {
     }
 
     void trimVertices() {
-      float temp[] = new float[3 * vertexCount];
+      float[] temp = new float[3 * vertexCount];
       PApplet.arrayCopy(vertices, 0, temp, 0, 3 * vertexCount);
       vertices = temp;
     }
 
     void trimColors() {
-      int temp[] = new int[vertexCount];
+      int[] temp = new int[vertexCount];
       PApplet.arrayCopy(colors, 0, temp, 0, vertexCount);
       colors = temp;
     }
 
     void trimNormals() {
-      float temp[] = new float[3 * vertexCount];
+      float[] temp = new float[3 * vertexCount];
       PApplet.arrayCopy(normals, 0, temp, 0, 3 * vertexCount);
       normals = temp;
     }
 
     void trimTexCoords() {
-      float temp[] = new float[2 * vertexCount];
+      float[] temp = new float[2 * vertexCount];
       PApplet.arrayCopy(texcoords, 0, temp, 0, 2 * vertexCount);
       texcoords = temp;
     }
 
     void trimStrokeColors() {
-      int temp[] = new int[vertexCount];
+      int[] temp = new int[vertexCount];
       PApplet.arrayCopy(strokeColors, 0, temp, 0, vertexCount);
       strokeColors = temp;
     }
 
     void trimStrokeWeights() {
-      float temp[] = new float[vertexCount];
+      float[] temp = new float[vertexCount];
       PApplet.arrayCopy(strokeWeights, 0, temp, 0, vertexCount);
       strokeWeights = temp;
     }
 
     void trimAmbient() {
-      int temp[] = new int[vertexCount];
+      int[] temp = new int[vertexCount];
       PApplet.arrayCopy(ambient, 0, temp, 0, vertexCount);
       ambient = temp;
     }
 
     void trimSpecular() {
-      int temp[] = new int[vertexCount];
+      int[] temp = new int[vertexCount];
       PApplet.arrayCopy(specular, 0, temp, 0, vertexCount);
       specular = temp;
     }
 
     void trimEmissive() {
-      int temp[] = new int[vertexCount];
+      int[] temp = new int[vertexCount];
       PApplet.arrayCopy(emissive, 0, temp, 0, vertexCount);
       emissive = temp;
     }
 
     void trimShininess() {
-      float temp[] = new float[vertexCount];
+      float[] temp = new float[vertexCount];
       PApplet.arrayCopy(shininess, 0, temp, 0, vertexCount);
       shininess = temp;
     }
 
     void trimCodes() {
-      int temp[] = new int[codeCount];
+      int[] temp = new int[codeCount];
       PApplet.arrayCopy(codes, 0, temp, 0, codeCount);
       codes = temp;
     }
 
     void trimEdges() {
-      int temp[][] = new int[edgeCount][3];
+      int[][] temp = new int[edgeCount][3];
       PApplet.arrayCopy(edges, 0, temp, 0, edgeCount);
       edges = temp;
     }
@@ -8161,21 +8205,21 @@ public class PGraphicsOpenGL extends PGraphics {
 
     void trimFloatAttrib(VertexAttribute attrib) {
       float[] values = fattribs.get(attrib.name);
-      float temp[] = new float[attrib.size * vertexCount];
+      float[] temp = new float[attrib.size * vertexCount];
       PApplet.arrayCopy(values, 0, temp, 0, attrib.size * vertexCount);
       fattribs.put(attrib.name, temp);
     }
 
     void trimIntAttrib(VertexAttribute attrib) {
       int[] values = iattribs.get(attrib.name);
-      int temp[] = new int[attrib.size * vertexCount];
+      int[] temp = new int[attrib.size * vertexCount];
       PApplet.arrayCopy(values, 0, temp, 0, attrib.size * vertexCount);
       iattribs.put(attrib.name, temp);
     }
 
     void trimBoolAttrib(VertexAttribute attrib) {
       byte[] values = battribs.get(attrib.name);
-      byte temp[] = new byte[attrib.size * vertexCount];
+      byte[] temp = new byte[attrib.size * vertexCount];
       PApplet.arrayCopy(values, 0, temp, 0, attrib.size * vertexCount);
       battribs.put(attrib.name, temp);
     }
@@ -8394,7 +8438,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
         vert[SR] = ((strokeColors[i] >> 16) & 0xFF) / 255.0f;
         vert[SG] = ((strokeColors[i] >>  8) & 0xFF) / 255.0f;
-        vert[SB] = ((strokeColors[i]) & 0xFF) / 255.0f;
+        vert[SB] = ((strokeColors[i] >>  0) & 0xFF) / 255.0f;
         vert[SA] = ((strokeColors[i] >> 24) & 0xFF) / 255.0f;
 
         vert[SW] = strokeWeights[i];
@@ -8797,8 +8841,8 @@ public class PGraphicsOpenGL extends PGraphics {
       idx0 = pidx = idx = 0;
       float val = 0;
       for (int i = 0; i < accuracy; i++) {
-        idx = addVertex(centerX + COS_LUT[(int) val] * radiusH,
-                        centerY + SIN_LUT[(int) val] * radiusV,
+        idx = addVertex(centerX + cosLUT[(int) val] * radiusH,
+                        centerY + sinLUT[(int) val] * radiusV,
                         VERTEX, i == 0 && !fill);
         val = (val + inc) % SINCOS_LENGTH;
 
@@ -8811,8 +8855,8 @@ public class PGraphicsOpenGL extends PGraphics {
         pidx = idx;
       }
       // Back to the beginning
-      addVertex(centerX + COS_LUT[0] * radiusH,
-                centerY + SIN_LUT[0] * radiusV,
+      addVertex(centerX + cosLUT[0] * radiusH,
+                centerY + sinLUT[0] * radiusV,
                 VERTEX, false);
       if (stroke) {
         addEdge(idx, idx0, false, false);
@@ -8857,8 +8901,8 @@ public class PGraphicsOpenGL extends PGraphics {
       if (arcMode == CHORD || arcMode == OPEN) {
         // move center to the middle of flat side
         // to properly display arcs smaller than PI
-        float relX = (COS_LUT[startLUT] + COS_LUT[stopLUT]) * 0.5f * hr;
-        float relY = (SIN_LUT[startLUT] + SIN_LUT[stopLUT]) * 0.5f * vr;
+        float relX = (cosLUT[startLUT] + cosLUT[stopLUT]) * 0.5f * hr;
+        float relY = (sinLUT[startLUT] + sinLUT[stopLUT]) * 0.5f * vr;
         idx0 = addVertex(centerX + relX, centerY + relY, VERTEX, true);
       } else {
         idx0 = addVertex(centerX, centerY, VERTEX, true);
@@ -8895,8 +8939,8 @@ public class PGraphicsOpenGL extends PGraphics {
         if (ii >= SINCOS_LENGTH) ii -= SINCOS_LENGTH;
 
         pidx = idx;
-        idx = addVertex(centerX + COS_LUT[ii] * hr,
-                        centerY + SIN_LUT[ii] * vr,
+        idx = addVertex(centerX + cosLUT[ii] * hr,
+                        centerY + sinLUT[ii] * vr,
                         VERTEX, i == 0 && !fill);
 
         if (stroke) {
@@ -9250,7 +9294,7 @@ public class PGraphicsOpenGL extends PGraphics {
     //
     // Allocate/dispose
 
-    final void allocate() {
+    void allocate() {
       polyVertices = new float[4 * PGL.DEFAULT_TESS_VERTICES];
       polyColors = new int[PGL.DEFAULT_TESS_VERTICES];
       polyNormals = new float[3 * PGL.DEFAULT_TESS_VERTICES];
@@ -9717,56 +9761,56 @@ public class PGraphicsOpenGL extends PGraphics {
     // Expand arrays
 
     void expandPolyVertices(int n) {
-      float temp[] = new float[4 * n];
+      float[] temp = new float[4 * n];
       PApplet.arrayCopy(polyVertices, 0, temp, 0, 4 * polyVertexCount);
       polyVertices = temp;
       polyVerticesBuffer = PGL.allocateFloatBuffer(polyVertices);
     }
 
     void expandPolyColors(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(polyColors, 0, temp, 0, polyVertexCount);
       polyColors = temp;
       polyColorsBuffer = PGL.allocateIntBuffer(polyColors);
     }
 
     void expandPolyNormals(int n) {
-      float temp[] = new float[3 * n];
+      float[] temp = new float[3 * n];
       PApplet.arrayCopy(polyNormals, 0, temp, 0, 3 * polyVertexCount);
       polyNormals = temp;
       polyNormalsBuffer = PGL.allocateFloatBuffer(polyNormals);
     }
 
     void expandPolyTexCoords(int n) {
-      float temp[] = new float[2 * n];
+      float[] temp = new float[2 * n];
       PApplet.arrayCopy(polyTexCoords, 0, temp, 0, 2 * polyVertexCount);
       polyTexCoords = temp;
       polyTexCoordsBuffer = PGL.allocateFloatBuffer(polyTexCoords);
     }
 
     void expandPolyAmbient(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(polyAmbient, 0, temp, 0, polyVertexCount);
       polyAmbient = temp;
       polyAmbientBuffer = PGL.allocateIntBuffer(polyAmbient);
     }
 
     void expandPolySpecular(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(polySpecular, 0, temp, 0, polyVertexCount);
       polySpecular = temp;
       polySpecularBuffer = PGL.allocateIntBuffer(polySpecular);
     }
 
     void expandPolyEmissive(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(polyEmissive, 0, temp, 0, polyVertexCount);
       polyEmissive = temp;
       polyEmissiveBuffer = PGL.allocateIntBuffer(polyEmissive);
     }
 
     void expandPolyShininess(int n) {
-      float temp[] = new float[n];
+      float[] temp = new float[n];
       PApplet.arrayCopy(polyShininess, 0, temp, 0, polyVertexCount);
       polyShininess = temp;
       polyShininessBuffer = PGL.allocateFloatBuffer(polyShininess);
@@ -9786,7 +9830,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
     void expandFloatAttribute(VertexAttribute attrib, int n) {
       float[] array = fpolyAttribs.get(attrib.name);
-      float temp[] = new float[attrib.tessSize * n];
+      float[] temp = new float[attrib.tessSize * n];
       PApplet.arrayCopy(array, 0, temp, 0, attrib.tessSize * polyVertexCount);
       fpolyAttribs.put(attrib.name, temp);
       polyAttribBuffers.put(attrib.name, PGL.allocateFloatBuffer(temp));
@@ -9794,7 +9838,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
     void expandIntAttribute(VertexAttribute attrib, int n) {
       int[] array = ipolyAttribs.get(attrib.name);
-      int temp[] = new int[attrib.tessSize * n];
+      int[] temp = new int[attrib.tessSize * n];
       PApplet.arrayCopy(array, 0, temp, 0, attrib.tessSize * polyVertexCount);
       ipolyAttribs.put(attrib.name, temp);
       polyAttribBuffers.put(attrib.name, PGL.allocateIntBuffer(temp));
@@ -9802,70 +9846,70 @@ public class PGraphicsOpenGL extends PGraphics {
 
     void expandBoolAttribute(VertexAttribute attrib, int n) {
       byte[] array = bpolyAttribs.get(attrib.name);
-      byte temp[] = new byte[attrib.tessSize * n];
+      byte[] temp = new byte[attrib.tessSize * n];
       PApplet.arrayCopy(array, 0, temp, 0, attrib.tessSize * polyVertexCount);
       bpolyAttribs.put(attrib.name, temp);
       polyAttribBuffers.put(attrib.name, PGL.allocateByteBuffer(temp));
     }
 
     void expandPolyIndices(int n) {
-      short temp[] = new short[n];
+      short[] temp = new short[n];
       PApplet.arrayCopy(polyIndices, 0, temp, 0, polyIndexCount);
       polyIndices = temp;
       polyIndicesBuffer = PGL.allocateShortBuffer(polyIndices);
     }
 
     void expandLineVertices(int n) {
-      float temp[] = new float[4 * n];
+      float[] temp = new float[4 * n];
       PApplet.arrayCopy(lineVertices, 0, temp, 0, 4 * lineVertexCount);
       lineVertices = temp;
       lineVerticesBuffer = PGL.allocateFloatBuffer(lineVertices);
     }
 
     void expandLineColors(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(lineColors, 0, temp, 0, lineVertexCount);
       lineColors = temp;
       lineColorsBuffer = PGL.allocateIntBuffer(lineColors);
     }
 
     void expandLineDirections(int n) {
-      float temp[] = new float[4 * n];
+      float[] temp = new float[4 * n];
       PApplet.arrayCopy(lineDirections, 0, temp, 0, 4 * lineVertexCount);
       lineDirections = temp;
       lineDirectionsBuffer = PGL.allocateFloatBuffer(lineDirections);
     }
 
     void expandLineIndices(int n) {
-      short temp[] = new short[n];
+      short[] temp = new short[n];
       PApplet.arrayCopy(lineIndices, 0, temp, 0, lineIndexCount);
       lineIndices = temp;
       lineIndicesBuffer = PGL.allocateShortBuffer(lineIndices);
     }
 
     void expandPointVertices(int n) {
-      float temp[] = new float[4 * n];
+      float[] temp = new float[4 * n];
       PApplet.arrayCopy(pointVertices, 0, temp, 0, 4 * pointVertexCount);
       pointVertices = temp;
       pointVerticesBuffer = PGL.allocateFloatBuffer(pointVertices);
     }
 
     void expandPointColors(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(pointColors, 0, temp, 0, pointVertexCount);
       pointColors = temp;
       pointColorsBuffer = PGL.allocateIntBuffer(pointColors);
     }
 
     void expandPointOffsets(int n) {
-      float temp[] = new float[2 * n];
+      float[] temp = new float[2 * n];
       PApplet.arrayCopy(pointOffsets, 0, temp, 0, 2 * pointVertexCount);
       pointOffsets = temp;
       pointOffsetsBuffer = PGL.allocateFloatBuffer(pointOffsets);
     }
 
     void expandPointIndices(int n) {
-      short temp[] = new short[n];
+      short[] temp = new short[n];
       PApplet.arrayCopy(pointIndices, 0, temp, 0, pointIndexCount);
       pointIndices = temp;
       pointIndicesBuffer = PGL.allocateShortBuffer(pointIndices);
@@ -9914,56 +9958,56 @@ public class PGraphicsOpenGL extends PGraphics {
     }
 
     void trimPolyVertices() {
-      float temp[] = new float[4 * polyVertexCount];
+      float[] temp = new float[4 * polyVertexCount];
       PApplet.arrayCopy(polyVertices, 0, temp, 0, 4 * polyVertexCount);
       polyVertices = temp;
       polyVerticesBuffer = PGL.allocateFloatBuffer(polyVertices);
     }
 
     void trimPolyColors() {
-      int temp[] = new int[polyVertexCount];
+      int[] temp = new int[polyVertexCount];
       PApplet.arrayCopy(polyColors, 0, temp, 0, polyVertexCount);
       polyColors = temp;
       polyColorsBuffer = PGL.allocateIntBuffer(polyColors);
     }
 
     void trimPolyNormals() {
-      float temp[] = new float[3 * polyVertexCount];
+      float[] temp = new float[3 * polyVertexCount];
       PApplet.arrayCopy(polyNormals, 0, temp, 0, 3 * polyVertexCount);
       polyNormals = temp;
       polyNormalsBuffer = PGL.allocateFloatBuffer(polyNormals);
     }
 
     void trimPolyTexCoords() {
-      float temp[] = new float[2 * polyVertexCount];
+      float[] temp = new float[2 * polyVertexCount];
       PApplet.arrayCopy(polyTexCoords, 0, temp, 0, 2 * polyVertexCount);
       polyTexCoords = temp;
       polyTexCoordsBuffer = PGL.allocateFloatBuffer(polyTexCoords);
     }
 
     void trimPolyAmbient() {
-      int temp[] = new int[polyVertexCount];
+      int[] temp = new int[polyVertexCount];
       PApplet.arrayCopy(polyAmbient, 0, temp, 0, polyVertexCount);
       polyAmbient = temp;
       polyAmbientBuffer = PGL.allocateIntBuffer(polyAmbient);
     }
 
     void trimPolySpecular() {
-      int temp[] = new int[polyVertexCount];
+      int[] temp = new int[polyVertexCount];
       PApplet.arrayCopy(polySpecular, 0, temp, 0, polyVertexCount);
       polySpecular = temp;
       polySpecularBuffer = PGL.allocateIntBuffer(polySpecular);
     }
 
     void trimPolyEmissive() {
-      int temp[] = new int[polyVertexCount];
+      int[] temp = new int[polyVertexCount];
       PApplet.arrayCopy(polyEmissive, 0, temp, 0, polyVertexCount);
       polyEmissive = temp;
       polyEmissiveBuffer = PGL.allocateIntBuffer(polyEmissive);
     }
 
     void trimPolyShininess() {
-      float temp[] = new float[polyVertexCount];
+      float[] temp = new float[polyVertexCount];
       PApplet.arrayCopy(polyShininess, 0, temp, 0, polyVertexCount);
       polyShininess = temp;
       polyShininessBuffer = PGL.allocateFloatBuffer(polyShininess);
@@ -9983,7 +10027,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
     void trimFloatAttribute(VertexAttribute attrib) {
       float[] array = fpolyAttribs.get(attrib.name);
-      float temp[] = new float[attrib.tessSize * polyVertexCount];
+      float[] temp = new float[attrib.tessSize * polyVertexCount];
       PApplet.arrayCopy(array, 0, temp, 0, attrib.tessSize * polyVertexCount);
       fpolyAttribs.put(attrib.name, temp);
       polyAttribBuffers.put(attrib.name, PGL.allocateFloatBuffer(temp));
@@ -9991,7 +10035,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
     void trimIntAttribute(VertexAttribute attrib) {
       int[] array = ipolyAttribs.get(attrib.name);
-      int temp[] = new int[attrib.tessSize * polyVertexCount];
+      int[] temp = new int[attrib.tessSize * polyVertexCount];
       PApplet.arrayCopy(array, 0, temp, 0, attrib.tessSize * polyVertexCount);
       ipolyAttribs.put(attrib.name, temp);
       polyAttribBuffers.put(attrib.name, PGL.allocateIntBuffer(temp));
@@ -9999,70 +10043,70 @@ public class PGraphicsOpenGL extends PGraphics {
 
     void trimBoolAttribute(VertexAttribute attrib) {
       byte[] array = bpolyAttribs.get(attrib.name);
-      byte temp[] = new byte[attrib.tessSize * polyVertexCount];
+      byte[] temp = new byte[attrib.tessSize * polyVertexCount];
       PApplet.arrayCopy(array, 0, temp, 0, attrib.tessSize * polyVertexCount);
       bpolyAttribs.put(attrib.name, temp);
       polyAttribBuffers.put(attrib.name, PGL.allocateByteBuffer(temp));
     }
 
     void trimPolyIndices() {
-      short temp[] = new short[polyIndexCount];
+      short[] temp = new short[polyIndexCount];
       PApplet.arrayCopy(polyIndices, 0, temp, 0, polyIndexCount);
       polyIndices = temp;
       polyIndicesBuffer = PGL.allocateShortBuffer(polyIndices);
     }
 
     void trimLineVertices() {
-      float temp[] = new float[4 * lineVertexCount];
+      float[] temp = new float[4 * lineVertexCount];
       PApplet.arrayCopy(lineVertices, 0, temp, 0, 4 * lineVertexCount);
       lineVertices = temp;
       lineVerticesBuffer = PGL.allocateFloatBuffer(lineVertices);
     }
 
     void trimLineColors() {
-      int temp[] = new int[lineVertexCount];
+      int[] temp = new int[lineVertexCount];
       PApplet.arrayCopy(lineColors, 0, temp, 0, lineVertexCount);
       lineColors = temp;
       lineColorsBuffer = PGL.allocateIntBuffer(lineColors);
     }
 
     void trimLineDirections() {
-      float temp[] = new float[4 * lineVertexCount];
+      float[] temp = new float[4 * lineVertexCount];
       PApplet.arrayCopy(lineDirections, 0, temp, 0, 4 * lineVertexCount);
       lineDirections = temp;
       lineDirectionsBuffer = PGL.allocateFloatBuffer(lineDirections);
     }
 
     void trimLineIndices() {
-      short temp[] = new short[lineIndexCount];
+      short[] temp = new short[lineIndexCount];
       PApplet.arrayCopy(lineIndices, 0, temp, 0, lineIndexCount);
       lineIndices = temp;
       lineIndicesBuffer = PGL.allocateShortBuffer(lineIndices);
     }
 
     void trimPointVertices() {
-      float temp[] = new float[4 * pointVertexCount];
+      float[] temp = new float[4 * pointVertexCount];
       PApplet.arrayCopy(pointVertices, 0, temp, 0, 4 * pointVertexCount);
       pointVertices = temp;
       pointVerticesBuffer = PGL.allocateFloatBuffer(pointVertices);
     }
 
     void trimPointColors() {
-      int temp[] = new int[pointVertexCount];
+      int[] temp = new int[pointVertexCount];
       PApplet.arrayCopy(pointColors, 0, temp, 0, pointVertexCount);
       pointColors = temp;
       pointColorsBuffer = PGL.allocateIntBuffer(pointColors);
     }
 
     void trimPointOffsets() {
-      float temp[] = new float[2 * pointVertexCount];
+      float[] temp = new float[2 * pointVertexCount];
       PApplet.arrayCopy(pointOffsets, 0, temp, 0, 2 * pointVertexCount);
       pointOffsets = temp;
       pointOffsetsBuffer = PGL.allocateFloatBuffer(pointOffsets);
     }
 
     void trimPointIndices() {
-      short temp[] = new short[pointIndexCount];
+      short[] temp = new short[pointIndexCount];
       PApplet.arrayCopy(pointIndices, 0, temp, 0, pointIndexCount);
       pointIndices = temp;
       pointIndicesBuffer = PGL.allocateShortBuffer(pointIndices);
@@ -10616,28 +10660,26 @@ public class PGraphicsOpenGL extends PGraphics {
                           polyVertices, 4 * tessIdx, 3);
         polyVertices[4 * tessIdx + 3] = 1;
 
-        polyAttribs.keySet().forEach((name) -> {
+        for (String name: polyAttribs.keySet()) {
           VertexAttribute attrib = polyAttribs.get(name);
-          if (!(!attrib.isPosition())) {
-            float[] inValues = in.fattribs.get(name);
-            float[] tessValues = fpolyAttribs.get(name);
-            PApplet.arrayCopy(inValues, 3 * inIdx,
-              tessValues, 4 * tessIdx, 3);
-            tessValues[4 * tessIdx + 3] = 1;
-          }
-        });
+          if (!attrib.isPosition()) continue;
+          float[] inValues = in.fattribs.get(name);
+          float[] tessValues = fpolyAttribs.get(name);
+          PApplet.arrayCopy(inValues, 3 * inIdx,
+                            tessValues, 4 * tessIdx, 3);
+          tessValues[4 * tessIdx + 3] = 1;
+        }
       }
       PApplet.arrayCopy(in.normals, 3 * i0,
                         polyNormals, 3 * firstPolyVertex, 3 * nvert);
-      polyAttribs.keySet().forEach((name) -> {
+      for (String name: polyAttribs.keySet()) {
         VertexAttribute attrib = polyAttribs.get(name);
-        if (!(!attrib.isNormal())) {
-          float[] inValues = in.fattribs.get(name);
-          float[] tessValues = fpolyAttribs.get(name);
-          PApplet.arrayCopy(inValues, 3 * i0,
-            tessValues, 3 * firstPolyVertex, 3 * nvert);
-        }
-      });
+        if (!attrib.isNormal()) continue;
+        float[] inValues = in.fattribs.get(name);
+        float[] tessValues = fpolyAttribs.get(name);
+        PApplet.arrayCopy(inValues, 3 * i0,
+                          tessValues, 3 * firstPolyVertex, 3 * nvert);
+      }
     }
 
     // Just copy attributes one by one.
@@ -11176,9 +11218,9 @@ public class PGraphicsOpenGL extends PGraphics {
         float inc = (float) SINCOS_LENGTH / perim;
         for (int k = 0; k < perim; k++) {
           tess.pointOffsets[2 * attribIdx + 0] =
-            0.5f * COS_LUT[(int) val] * transformScale() * strokeWeight;
+            0.5f * cosLUT[(int) val] * transformScale() * strokeWeight;
           tess.pointOffsets[2 * attribIdx + 1] =
-            0.5f * SIN_LUT[(int) val] * transformScale() * strokeWeight;
+            0.5f * sinLUT[(int) val] * transformScale() * strokeWeight;
           val = (val + inc) % SINCOS_LENGTH;
           attribIdx++;
         }
@@ -11228,8 +11270,8 @@ public class PGraphicsOpenGL extends PGraphics {
         vertIdx++;
         for (int k = 0; k < perim; k++) {
           tess.setPolyVertex(vertIdx,
-                             x0 + 0.5f * COS_LUT[(int) val] * strokeWeight,
-                             y0 + 0.5f * SIN_LUT[(int) val] * strokeWeight,
+                             x0 + 0.5f * cosLUT[(int) val] * strokeWeight,
+                             y0 + 0.5f * sinLUT[(int) val] * strokeWeight,
                              0, rgba, false);
           vertIdx++;
           val = (val + inc) % SINCOS_LENGTH;
@@ -12492,7 +12534,7 @@ public class PGraphicsOpenGL extends PGraphics {
       if (dupIndices.length == dupCount) {
         int n = dupCount << 1;
 
-        int temp[] = new int[n];
+        int[] temp = new int[n];
         PApplet.arrayCopy(dupIndices, 0, temp, 0, dupCount);
         dupIndices = temp;
       }
@@ -12539,7 +12581,7 @@ public class PGraphicsOpenGL extends PGraphics {
     }
 
     void expandRawIndices(int n) {
-      int temp[] = new int[n];
+      int[] temp = new int[n];
       PApplet.arrayCopy(rawIndices, 0, temp, 0, rawSize);
       rawIndices = temp;
     }
@@ -12642,23 +12684,18 @@ public class PGraphicsOpenGL extends PGraphics {
             }
           }
 
-          switch (code) {
-            case BEZIER_VERTEX:
-              addBezierVertex(i);
-              i += 3;
-              break;
-            case QUADRATIC_VERTEX:
-              addQuadraticVertex(i);
-              i += 2;
-              break;
-            case CURVE_VERTEX:
-              addCurveVertex(i);
-              i++;
-              break;
-            default:
-              addVertex(i);
-              i++;
-              break;
+          if (code == BEZIER_VERTEX) {
+            addBezierVertex(i);
+            i += 3;
+          } else if (code == QUADRATIC_VERTEX) {
+            addQuadraticVertex(i);
+            i += 2;
+          } else if (code == CURVE_VERTEX) {
+            addCurveVertex(i);
+            i++;
+          } else {
+            addVertex(i);
+            i++;
           }
         }
         if (stroke) {
@@ -12916,7 +12953,7 @@ public class PGraphicsOpenGL extends PGraphics {
       r[j++] = (fcol >> 24) & 0xFF; // fa
       r[j++] = (fcol >> 16) & 0xFF; // fr
       r[j++] = (fcol >>  8) & 0xFF; // fg
-      r[j++] = (fcol >>  0) & 0xFF; // fb
+      r[j++] = (fcol) & 0xFF; // fb
 
       r[j++] = in.normals[3*i + 0]; // nx
       r[j++] = in.normals[3*i + 1]; // ny
@@ -12929,19 +12966,19 @@ public class PGraphicsOpenGL extends PGraphics {
       r[j++] = (acol >> 24) & 0xFF; // aa
       r[j++] = (acol >> 16) & 0xFF; // ar
       r[j++] = (acol >>  8) & 0xFF; // ag
-      r[j++] = (acol >>  0) & 0xFF; // ab
+      r[j++] = (acol) & 0xFF; // ab
 
       int scol = in.specular[i];
       r[j++] = (scol >> 24) & 0xFF; // sa
       r[j++] = (scol >> 16) & 0xFF; // sr
       r[j++] = (scol >>  8) & 0xFF; // sg
-      r[j++] = (scol >>  0) & 0xFF; // sb
+      r[j++] = (scol) & 0xFF; // sb
 
       int ecol = in.emissive[i];
       r[j++] = (ecol >> 24) & 0xFF; // ea
       r[j++] = (ecol >> 16) & 0xFF; // er
       r[j++] = (ecol >>  8) & 0xFF; // eg
-      r[j++] = (ecol >>  0) & 0xFF; // eb
+      r[j++] = (ecol) & 0xFF; // eb
 
       r[j++] = in.shininess[i]; // sh
 
@@ -12989,15 +13026,15 @@ public class PGraphicsOpenGL extends PGraphics {
       if (pathVertexCount == pathVertices.length / 3) {
         int newSize = pathVertexCount << 1;
 
-        float vtemp[] = new float[3 * newSize];
+        float[] vtemp = new float[3 * newSize];
         PApplet.arrayCopy(pathVertices, 0, vtemp, 0, 3 * pathVertexCount);
         pathVertices = vtemp;
 
-        int ctemp[] = new int[newSize];
+        int[] ctemp = new int[newSize];
         PApplet.arrayCopy(pathColors, 0, ctemp, 0, pathVertexCount);
         pathColors = ctemp;
 
-        float wtemp[] = new float[newSize];
+        float[] wtemp = new float[newSize];
         PApplet.arrayCopy(pathWeights, 0, wtemp, 0, pathVertexCount);
         pathWeights = wtemp;
       }
@@ -13160,6 +13197,7 @@ public class PGraphicsOpenGL extends PGraphics {
         else if (type == PGL.TRIANGLES) primitive = TRIANGLES;
       }
 
+      @Override
       public void end() {
         if (PGL.MAX_VERTEX_INDEX1 <= vertFirst + vertCount) {
           // We need a new index block for the new batch of
@@ -13235,6 +13273,7 @@ public class PGraphicsOpenGL extends PGraphics {
                             vertFirst + vertOffset + tessIdx2);
       }
 
+      @Override
       public void vertex(Object data) {
         if (data instanceof double[]) {
           double[] d = (double[]) data;