picrate 0.5.0-java → 0.6.0-java

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

@@ -60,17 +60,36 @@ import processing.core.PGraphics;
 import processing.core.PMatrix3D;
 import processing.core.PSurface;
 
-
+/**
+ *
+ * @author Martin Prout
+ */
 public class PJOGL extends PGL {
   // OpenGL profile to use (2, 3 or 4)
+
+    /**
+     *
+     */
   public static int profile = 2;
 
   // User-provided icons to override defaults
+
+    /**
+     *
+     */
   protected static String[] icons = null;
 
   // The two windowing toolkits available to use in JOGL:
+
+    /**
+     *
+     */
   public static final int AWT  = 0; // http://jogamp.org/wiki/index.php/Using_JOGL_in_AWT_SWT_and_Swing
-  public static final int NEWT = 1; // http://jogamp.org/jogl/doc/NEWT-Overview.html
+
+    /**
+     *
+     */
+    public static final int NEWT = 1; // http://jogamp.org/jogl/doc/NEWT-Overview.html
 
   // ........................................................
 
@@ -124,8 +143,16 @@ public class PJOGL extends PGL {
 
   // Utility arrays to copy projection/modelview matrices to GL
 
+    /**
+     *
+     */
+
   protected float[] projMatrix;
-  protected float[] mvMatrix;
+
+    /**
+     *
+     */
+    protected float[] mvMatrix;
 
   // ........................................................
 
@@ -142,36 +169,57 @@ public class PJOGL extends PGL {
 
   // Initialization, finalization
 
+    /**
+     *
+     * @param pg
+     */
+
 
   public PJOGL(PGraphicsOpenGL pg) {
     super(pg);
     glu = new GLU();
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   public Object getNative() {
     return sketch.getSurface().getNative();
   }
 
-
-  @Override
+    /**
+     *
+     * @param fps
+     */
+    @Override
   protected void setFrameRate(float fps) {}
 
-
-  @Override
+    /**
+     *
+     * @param antialias
+     */
+    @Override
   protected void initSurface(int antialias) {}
 
-
-  @Override
+    /**
+     *
+     */
+    @Override
   protected void reinitSurface() {}
 
-
-  @Override
+    /**
+     *
+     */
+    @Override
   protected void registerListeners() {}
 
-
-  static public void setIcon(String... icons) {
+    /**
+     *
+     * @param icons
+     */
+    static public void setIcon(String... icons) {
     PJOGL.icons = new String[icons.length];
     PApplet.arrayCopy(icons, PJOGL.icons);
   }
@@ -181,19 +229,30 @@ public class PJOGL extends PGL {
 
   // Public methods to get/set renderer's properties
 
+    /**
+     *
+     * @param caps
+     */
+
 
   public void setCaps(GLCapabilities caps) {
     reqNumSamples = caps.getNumSamples();
     capabilities = caps;
   }
 
-
-  public GLCapabilitiesImmutable getCaps() {
+    /**
+     *
+     * @return
+     */
+    public GLCapabilitiesImmutable getCaps() {
     return capabilities;
   }
 
-
-  public void setFps(float fps) {
+    /**
+     *
+     * @param fps
+     */
+    public void setFps(float fps) {
     if (!setFps || targetFps != fps) {
       if (60 < fps) {
         // Disables v-sync
@@ -208,20 +267,29 @@ public class PJOGL extends PGL {
     }
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   protected int getDepthBits() {
     return capabilities.getDepthBits();
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   protected int getStencilBits() {
     return capabilities.getStencilBits();
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   protected float getPixelScale() {
     PSurface surf = sketch.getSurface();
     if (surf == null) {
@@ -233,8 +301,11 @@ public class PJOGL extends PGL {
     }
   }
 
-
-  @Override
+    /**
+     *
+     * @param pgl
+     */
+    @Override
   protected void getGL(PGL pgl) {
     PJOGL pjogl = (PJOGL)pgl;
 
@@ -250,8 +321,11 @@ public class PJOGL extends PGL {
     this.gl3es3 = pjogl.gl3es3;
   }
 
-
-  public void getGL(GLAutoDrawable glDrawable) {
+    /**
+     *
+     * @param glDrawable
+     */
+    public void getGL(GLAutoDrawable glDrawable) {
     context = glDrawable.getContext();
     glContext = context.hashCode();
     setThread(Thread.currentThread());
@@ -275,27 +349,38 @@ public class PJOGL extends PGL {
     }
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   protected boolean canDraw() { return true; }
 
-
-  @Override
+    /**
+     *
+     */
+    @Override
   protected  void requestFocus() {}
 
-
-  @Override
+    /**
+     *
+     */
+    @Override
   protected  void requestDraw() {}
 
-
-  @Override
+    /**
+     *
+     */
+    @Override
   protected void swapBuffers()  {
     PSurfaceJOGL surf = (PSurfaceJOGL)sketch.getSurface();
     surf.window.swapBuffers();
   }
 
-
-  @Override
+    /**
+     *
+     */
+    @Override
   protected void initFBOLayer() {
     if (0 < sketch.frameCount) {
       if (isES()) initFBOLayerES();
@@ -355,8 +440,10 @@ public class PJOGL extends PGL {
     bindFramebufferImpl(FRAMEBUFFER, 0);
   }
 
-
-  @Override
+    /**
+     *
+     */
+    @Override
   protected void beginGL() {
     PMatrix3D proj = graphics.projection;
     PMatrix3D mdl = graphics.modelview;
@@ -407,22 +494,31 @@ public class PJOGL extends PGL {
     }
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   protected boolean hasFBOs() {
     if (context.hasBasicFBOSupport()) return true;
     else return super.hasFBOs();
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   protected boolean hasShaders() {
     if (context.hasGLSL()) return true;
     else return super.hasShaders();
   }
 
-
-  public void init(GLAutoDrawable glDrawable) {
+    /**
+     *
+     * @param glDrawable
+     */
+    public void init(GLAutoDrawable glDrawable) {
     capabilities = glDrawable.getChosenGLCapabilities();
     if (!hasFBOs()) {
       throw new RuntimeException(MISSING_FBO_ERROR);
@@ -437,6 +533,11 @@ public class PJOGL extends PGL {
 
   // Utility functions
 
+    /**
+     *
+     * @param target
+     */
+
 
   @Override
   protected void enableTexturing(int target) {
@@ -447,8 +548,11 @@ public class PJOGL extends PGL {
     }
   }
 
-
-  @Override
+    /**
+     *
+     * @param target
+     */
+    @Override
   protected void disableTexturing(int target) {
     if (target == TEXTURE_2D) {
       texturingTargets[0] = false;
@@ -476,20 +580,35 @@ public class PJOGL extends PGL {
     return getFontMetrics(font).getFontRenderContext();
   }
 
-
-  @Override
+    /**
+     *
+     * @param font
+     * @return
+     */
+    @Override
   protected int getFontAscent(Object font) {
     return getFontMetrics((Font) font).getAscent();
   }
 
-
-  @Override
+    /**
+     *
+     * @param font
+     * @return
+     */
+    @Override
   protected int getFontDescent(Object font) {
     return getFontMetrics((Font) font).getDescent();
   }
 
-
-  @Override
+    /**
+     *
+     * @param font
+     * @param buffer
+     * @param start
+     * @param stop
+     * @return
+     */
+    @Override
   protected int getTextWidth(Object font, char[] buffer, int start, int stop) {
     // maybe should use one of the newer/fancier functions for this?
     int length = stop - start;
@@ -497,21 +616,32 @@ public class PJOGL extends PGL {
     return metrics.charsWidth(buffer, start, length);
   }
 
-
-  @Override
+    /**
+     *
+     * @param font
+     * @param size
+     * @return
+     */
+    @Override
   protected Object getDerivedFont(Object font, float size) {
     return ((Font) font).deriveFont(size);
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   protected int getGLSLVersion() {
     VersionNumber vn = context.getGLSLVersionNumber();
     return vn.getMajor() * 100 + vn.getMinor();
   }
 
-
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   protected String getGLSLVersionSuffix() {
     VersionNumber vn = context.getGLSLVersionNumber();
     if (context.isGLESProfile() && 1 < vn.getMajor()) {
@@ -521,46 +651,80 @@ public class PJOGL extends PGL {
     }
   }
 
-
-  @Override
+    /**
+     *
+     * @param filename
+     * @return
+     */
+    @Override
   protected String[] loadVertexShader(String filename) {
     return loadVertexShader(filename, getGLSLVersion(), getGLSLVersionSuffix());
   }
 
-
-  @Override
+    /**
+     *
+     * @param filename
+     * @return
+     */
+    @Override
   protected String[] loadFragmentShader(String filename) {
     return loadFragmentShader(filename, getGLSLVersion(), getGLSLVersionSuffix());
   }
 
-
-  @Override
+    /**
+     *
+     * @param url
+     * @return
+     */
+    @Override
   protected String[] loadVertexShader(URL url) {
     return loadVertexShader(url, getGLSLVersion(), getGLSLVersionSuffix());
   }
 
-
-  @Override
+    /**
+     *
+     * @param url
+     * @return
+     */
+    @Override
   protected String[] loadFragmentShader(URL url) {
     return loadFragmentShader(url, getGLSLVersion(), getGLSLVersionSuffix());
   }
 
-
-  @Override
+    /**
+     *
+     * @param filename
+     * @param version
+     * @param versionSuffix
+     * @return
+     */
+    @Override
   protected String[] loadFragmentShader(String filename, int version, String versionSuffix) {
     String[] fragSrc0 = sketch.loadStrings(filename);
     return preprocessFragmentSource(fragSrc0, version, versionSuffix);
   }
 
-
-  @Override
+    /**
+     *
+     * @param filename
+     * @param version
+     * @param versionSuffix
+     * @return
+     */
+    @Override
   protected String[] loadVertexShader(String filename, int version, String versionSuffix) {
     String[] vertSrc0 = sketch.loadStrings(filename);
     return preprocessVertexSource(vertSrc0, version, versionSuffix);
   }
 
-
-  @Override
+    /**
+     *
+     * @param url
+     * @param version
+     * @param versionSuffix
+     * @return
+     */
+    @Override
   protected String[] loadFragmentShader(URL url, int version, String versionSuffix) {
     try {
       String[] fragSrc0 = PApplet.loadStrings(url.openStream());
@@ -571,8 +735,14 @@ public class PJOGL extends PGL {
     return null;
   }
 
-
-  @Override
+    /**
+     *
+     * @param url
+     * @param version
+     * @param versionSuffix
+     * @return
+     */
+    @Override
   protected String[] loadVertexShader(URL url, int version, String versionSuffix) {
     try {
       String[] vertSrc0 = PApplet.loadStrings(url.openStream());
@@ -588,19 +758,43 @@ public class PJOGL extends PGL {
 
   // Tessellator
 
+    /**
+     *
+     * @param callback
+     * @return
+     */
+
 
   @Override
   protected Tessellator createTessellator(TessellatorCallback callback) {
     return new Tessellator(callback);
   }
 
+    /**
+     *
+     */
+    protected static class Tessellator implements PGL.Tessellator {
+
+      /**
+       *
+       */
+      protected GLUtessellator tess;
+
+      /**
+       *
+       */
+      protected TessellatorCallback callback;
 
-  protected static class Tessellator implements PGL.Tessellator {
-    protected GLUtessellator tess;
-    protected TessellatorCallback callback;
-    protected GLUCallback gluCallback;
+      /**
+       *
+       */
+      protected GLUCallback gluCallback;
 
-    public Tessellator(TessellatorCallback callback) {
+      /**
+       *
+       * @param callback
+       */
+      public Tessellator(TessellatorCallback callback) {
       this.callback = callback;
       tess = GLU.gluNewTess();
       gluCallback = new GLUCallback();
@@ -612,86 +806,155 @@ public class PJOGL extends PGL {
       GLU.gluTessCallback(tess, GLU.GLU_TESS_ERROR, gluCallback);
     }
 
-    @Override
+      /**
+       *
+       * @param flag
+       */
+      @Override
     public void setCallback(int flag) {
       GLU.gluTessCallback(tess, flag, gluCallback);
     }
 
-    @Override
+      /**
+       *
+       * @param rule
+       */
+      @Override
     public void setWindingRule(int rule) {
       setProperty(GLU.GLU_TESS_WINDING_RULE, rule);
     }
 
-    public void setProperty(int property, int value) {
+      /**
+       *
+       * @param property
+       * @param value
+       */
+      public void setProperty(int property, int value) {
       GLU.gluTessProperty(tess, property, value);
     }
 
-    @Override
+      /**
+       *
+       */
+      @Override
     public void beginPolygon() {
       beginPolygon(null);
     }
 
-    @Override
+      /**
+       *
+       * @param data
+       */
+      @Override
     public void beginPolygon(Object data) {
       GLU.gluTessBeginPolygon(tess, data);
     }
 
-    @Override
+      /**
+       *
+       */
+      @Override
     public void endPolygon() {
       GLU.gluTessEndPolygon(tess);
     }
 
-    @Override
+      /**
+       *
+       */
+      @Override
     public void beginContour() {
       GLU.gluTessBeginContour(tess);
     }
 
-    @Override
+      /**
+       *
+       */
+      @Override
     public void endContour() {
       GLU.gluTessEndContour(tess);
     }
 
-    @Override
+      /**
+       *
+       * @param v
+       */
+      @Override
     public void addVertex(double[] v) {
       addVertex(v, 0, v);
     }
 
-    @Override
+      /**
+       *
+       * @param v
+       * @param n
+       * @param data
+       */
+      @Override
     public void addVertex(double[] v, int n, Object data) {
       GLU.gluTessVertex(tess, v, n, data);
     }
 
-    protected class GLUCallback extends GLUtessellatorCallbackAdapter {
-      @Override
+      /**
+       *
+       */
+      protected class GLUCallback extends GLUtessellatorCallbackAdapter {
+
+          /**
+           *
+           * @param type
+           */
+          @Override
       public void begin(int type) {
         callback.begin(type);
       }
 
-      @Override
+          /**
+           *
+           */
+          @Override
       public void end() {
         callback.end();
       }
 
-      @Override
+          /**
+           *
+           * @param data
+           */
+          @Override
       public void vertex(Object data) {
         callback.vertex(data);
       }
 
-      @Override
+        /**
+         *
+         * @param coords
+         * @param data
+         * @param weight
+         * @param outData
+         */
+        @Override
       public void combine(double[] coords, Object[] data,
                           float[] weight, Object[] outData) {
         callback.combine(coords, data, weight, outData);
       }
 
-      @Override
+          /**
+           *
+           * @param errnum
+           */
+          @Override
       public void error(int errnum) {
         callback.error(errnum);
       }
     }
   }
 
-
-  @Override
+    /**
+     *
+     * @param err
+     * @return
+     */
+    @Override
   protected String tessError(int err) {
     return glu.gluErrorString(err);
   }
@@ -711,17 +974,29 @@ public class PJOGL extends PGL {
     SEG_CLOSE   = PathIterator.SEG_CLOSE;
   }
 
-
-  @Override
+    /**
+     *
+     * @param ch
+     * @param font
+     * @return
+     */
+    @Override
   protected FontOutline createFontOutline(char ch, Object font) {
     return new FontOutline(ch, (Font) font);
   }
 
-
-  protected class FontOutline implements PGL.FontOutline {
+    /**
+     *
+     */
+    protected class FontOutline implements PGL.FontOutline {
     PathIterator iter;
 
-    public FontOutline(char ch, Font font) {
+      /**
+       *
+       * @param ch
+       * @param font
+       */
+      public FontOutline(char ch, Font font) {
       char textArray[] = new char[] { ch };
       FontRenderContext frc = getFontRenderContext(font);
       GlyphVector gv = font.createGlyphVector(frc, textArray);
@@ -729,15 +1004,27 @@ public class PJOGL extends PGL {
       iter = shp.getPathIterator(null);
     }
 
-    public boolean isDone() {
+      /**
+       *
+       * @return
+       */
+      public boolean isDone() {
       return iter.isDone();
     }
 
-    public int currentSegment(float coords[]) {
+      /**
+       *
+       * @param coords
+       * @return
+       */
+      public int currentSegment(float coords[]) {
       return iter.currentSegment(coords);
     }
 
-    public void next() {
+      /**
+       *
+       */
+      public void next() {
       iter.next();
     }
   }
@@ -1047,17 +1334,29 @@ public class PJOGL extends PGL {
 
   // Special Functions
 
+    /**
+     *
+     */
+
   @Override
   public void flush() {
     gl.glFlush();
   }
 
-  @Override
+    /**
+     *
+     */
+    @Override
   public void finish() {
     gl.glFinish();
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param hint
+     */
+    @Override
   public void hint(int target, int hint) {
     gl.glHint(target, hint);
   }
@@ -1066,6 +1365,11 @@ public class PJOGL extends PGL {
 
   // State and State Requests
 
+    /**
+     *
+     * @param value
+     */
+
   @Override
   public void enable(int value) {
     if (-1 < value) {
@@ -1073,14 +1377,23 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param value
+     */
+    @Override
   public void disable(int value) {
     if (-1 < value) {
       gl.glDisable(value);
     }
   }
 
-  @Override
+    /**
+     *
+     * @param value
+     * @param data
+     */
+    @Override
   public void getBooleanv(int value, IntBuffer data) {
     if (-1 < value) {
       if (byteBuffer.capacity() < data.capacity()) {
@@ -1095,7 +1408,12 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param value
+     * @param data
+     */
+    @Override
   public void getIntegerv(int value, IntBuffer data) {
     if (-1 < value) {
       gl.glGetIntegerv(value, data);
@@ -1104,7 +1422,12 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param value
+     * @param data
+     */
+    @Override
   public void getFloatv(int value, FloatBuffer data) {
     if (-1 < value) {
       gl.glGetFloatv(value, data);
@@ -1113,12 +1436,22 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param value
+     * @return
+     */
+    @Override
   public boolean isEnabled(int value) {
     return gl.glIsEnabled(value);
   }
 
-  @Override
+    /**
+     *
+     * @param name
+     * @return
+     */
+    @Override
   public String getString(int name) {
     return gl.glGetString(name);
   }
@@ -1127,12 +1460,22 @@ public class PJOGL extends PGL {
 
   // Error Handling
 
+    /**
+     *
+     * @return
+     */
+
   @Override
   public int getError() {
     return gl.glGetError();
   }
 
-  @Override
+    /**
+     *
+     * @param err
+     * @return
+     */
+    @Override
   public String errorString(int err) {
     return glu.gluErrorString(err);
   }
@@ -1141,47 +1484,101 @@ public class PJOGL extends PGL {
 
   // Buffer Objects
 
+    /**
+     *
+     * @param n
+     * @param buffers
+     */
+
   @Override
   public void genBuffers(int n, IntBuffer buffers) {
     gl.glGenBuffers(n, buffers);
   }
 
-  @Override
+    /**
+     *
+     * @param n
+     * @param buffers
+     */
+    @Override
   public void deleteBuffers(int n, IntBuffer buffers) {
     gl.glDeleteBuffers(n, buffers);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param buffer
+     */
+    @Override
   public void bindBuffer(int target, int buffer) {
     gl.glBindBuffer(target, buffer);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param size
+     * @param data
+     * @param usage
+     */
+    @Override
   public void bufferData(int target, int size, Buffer data, int usage) {
     gl.glBufferData(target, size, data, usage);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param offset
+     * @param size
+     * @param data
+     */
+    @Override
   public void bufferSubData(int target, int offset, int size, Buffer data) {
     gl.glBufferSubData(target, offset, size, data);
   }
 
-  @Override
+    /**
+     *
+     * @param buffer
+     */
+    @Override
   public void isBuffer(int buffer) {
     gl.glIsBuffer(buffer);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param value
+     * @param data
+     */
+    @Override
   public void getBufferParameteriv(int target, int value, IntBuffer data) {
     gl.glGetBufferParameteriv(target, value, data);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param access
+     * @return
+     */
+    @Override
   public ByteBuffer mapBuffer(int target, int access) {
     return gl2.glMapBuffer(target, access);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param offset
+     * @param length
+     * @param access
+     * @return
+     */
+    @Override
   public ByteBuffer mapBufferRange(int target, int offset, int length, int access) {
     if (gl2x != null) {
       return gl2x.glMapBufferRange(target, offset, length, access);
@@ -1192,7 +1589,11 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     */
+    @Override
   public void unmapBuffer(int target) {
     gl2.glUnmapBuffer(target);
   }
@@ -1201,6 +1602,13 @@ public class PJOGL extends PGL {
 
   // Synchronization
 
+    /**
+     *
+     * @param condition
+     * @param flags
+     * @return
+     */
+
   @Override
   public long fenceSync(int condition, int flags) {
     if (gl3es3 != null) {
@@ -1210,7 +1618,11 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param sync
+     */
+    @Override
   public void deleteSync(long sync) {
     if (gl3es3 != null) {
       gl3es3.glDeleteSync(sync);
@@ -1219,7 +1631,14 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param sync
+     * @param flags
+     * @param timeout
+     * @return
+     */
+    @Override
   public int clientWaitSync(long sync, int flags, long timeout) {
     if (gl3es3 != null) {
       return gl3es3.glClientWaitSync(sync, flags, timeout);
@@ -1232,18 +1651,38 @@ public class PJOGL extends PGL {
 
   // Viewport and Clipping
 
+    /**
+     *
+     * @param n
+     * @param f
+     */
+
   @Override
   public void depthRangef(float n, float f) {
     gl.glDepthRangef(n, f);
   }
 
-  @Override
+    /**
+     *
+     * @param x
+     * @param y
+     * @param w
+     * @param h
+     */
+    @Override
   public void viewport(int x, int y, int w, int h) {
     float scale = getPixelScale();
     viewportImpl((int)scale * x, (int)(scale * y), (int)(scale * w), (int)(scale * h));
   }
 
-  @Override
+    /**
+     *
+     * @param x
+     * @param y
+     * @param w
+     * @param h
+     */
+    @Override
   protected void viewportImpl(int x, int y, int w, int h) {
     gl.glViewport(x, y, w, h);
   }
@@ -1252,12 +1691,33 @@ public class PJOGL extends PGL {
 
   // Reading Pixels
 
+    /**
+     *
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * @param format
+     * @param type
+     * @param buffer
+     */
+
   @Override
   protected void readPixelsImpl(int x, int y, int width, int height, int format, int type, Buffer buffer) {
     gl.glReadPixels(x, y, width, height, format, type, buffer);
   }
 
-  @Override
+    /**
+     *
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * @param format
+     * @param type
+     * @param offset
+     */
+    @Override
   protected void readPixelsImpl(int x, int y, int width, int height, int format, int type, long offset) {
     gl.glReadPixels(x, y, width, height, format, type, 0);
   }
@@ -1266,67 +1726,144 @@ public class PJOGL extends PGL {
 
   // Vertices
 
+    /**
+     *
+     * @param index
+     * @param value
+     */
+
   @Override
   public void vertexAttrib1f(int index, float value) {
     gl2.glVertexAttrib1f(index, value);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param value0
+     * @param value1
+     */
+    @Override
   public void vertexAttrib2f(int index, float value0, float value1) {
     gl2.glVertexAttrib2f(index, value0, value1);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param value0
+     * @param value1
+     * @param value2
+     */
+    @Override
   public void vertexAttrib3f(int index, float value0, float value1, float value2) {
     gl2.glVertexAttrib3f(index, value0, value1, value2);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param value0
+     * @param value1
+     * @param value2
+     * @param value3
+     */
+    @Override
   public void vertexAttrib4f(int index, float value0, float value1, float value2, float value3) {
     gl2.glVertexAttrib4f(index, value0, value1, value2, value3);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param values
+     */
+    @Override
   public void vertexAttrib1fv(int index, FloatBuffer values) {
     gl2.glVertexAttrib1fv(index, values);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param values
+     */
+    @Override
   public void vertexAttrib2fv(int index, FloatBuffer values) {
     gl2.glVertexAttrib2fv(index, values);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param values
+     */
+    @Override
   public void vertexAttrib3fv(int index, FloatBuffer values) {
     gl2.glVertexAttrib3fv(index, values);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param values
+     */
+    @Override
   public void vertexAttrib4fv(int index, FloatBuffer values) {
     gl2.glVertexAttrib4fv(index, values);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param size
+     * @param type
+     * @param normalized
+     * @param stride
+     * @param offset
+     */
+    @Override
   public void vertexAttribPointer(int index, int size, int type, boolean normalized, int stride, int offset) {
     gl2.glVertexAttribPointer(index, size, type, normalized, stride, offset);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     */
+    @Override
   public void enableVertexAttribArray(int index) {
     gl2.glEnableVertexAttribArray(index);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     */
+    @Override
   public void disableVertexAttribArray(int index) {
     gl2.glDisableVertexAttribArray(index);
   }
 
-  @Override
+    /**
+     *
+     * @param mode
+     * @param first
+     * @param count
+     */
+    @Override
   public void drawArraysImpl(int mode, int first, int count) {
     gl.glDrawArrays(mode, first, count);
   }
 
-  @Override
+    /**
+     *
+     * @param mode
+     * @param count
+     * @param type
+     * @param offset
+     */
+    @Override
   public void drawElementsImpl(int mode, int count, int type, int offset) {
     gl.glDrawElements(mode, count, type, offset);
   }
@@ -1335,22 +1872,40 @@ public class PJOGL extends PGL {
 
   // Rasterization
 
+    /**
+     *
+     * @param width
+     */
+
   @Override
   public void lineWidth(float width) {
     gl.glLineWidth(width);
   }
 
-  @Override
+    /**
+     *
+     * @param dir
+     */
+    @Override
   public void frontFace(int dir) {
     gl.glFrontFace(dir);
   }
 
-  @Override
+    /**
+     *
+     * @param mode
+     */
+    @Override
   public void cullFace(int mode) {
     gl.glCullFace(mode);
   }
 
-  @Override
+    /**
+     *
+     * @param factor
+     * @param units
+     */
+    @Override
   public void polygonOffset(float factor, float units) {
     gl.glPolygonOffset(factor, units);
   }
@@ -1359,6 +1914,12 @@ public class PJOGL extends PGL {
 
   // Pixel Rectangles
 
+    /**
+     *
+     * @param pname
+     * @param param
+     */
+
   @Override
   public void pixelStorei(int pname, int param) {
     gl.glPixelStorei(pname, param);
@@ -1368,92 +1929,226 @@ public class PJOGL extends PGL {
 
   // Texturing
 
+    /**
+     *
+     * @param target
+     * @param level
+     * @param internalFormat
+     * @param width
+     * @param height
+     * @param border
+     * @param format
+     * @param type
+     * @param data
+     */
+
   @Override
   public void texImage2D(int target, int level, int internalFormat, int width, int height, int border, int format, int type, Buffer data) {
     gl.glTexImage2D(target, level, internalFormat, width, height, border, format, type, data);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param level
+     * @param internalFormat
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * @param border
+     */
+    @Override
   public void copyTexImage2D(int target, int level, int internalFormat, int x, int y, int width, int height, int border) {
     gl.glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param level
+     * @param xOffset
+     * @param yOffset
+     * @param width
+     * @param height
+     * @param format
+     * @param type
+     * @param data
+     */
+    @Override
   public void texSubImage2D(int target, int level, int xOffset, int yOffset, int width, int height, int format, int type, Buffer data) {
     gl.glTexSubImage2D(target, level, xOffset, yOffset, width, height, format, type, data);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param level
+     * @param xOffset
+     * @param yOffset
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     */
+    @Override
   public void copyTexSubImage2D(int target, int level, int xOffset, int yOffset, int x, int y, int width, int height) {
     gl.glCopyTexSubImage2D(target, level, x, y, xOffset, yOffset, width, height);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param level
+     * @param internalFormat
+     * @param width
+     * @param height
+     * @param border
+     * @param imageSize
+     * @param data
+     */
+    @Override
   public void compressedTexImage2D(int target, int level, int internalFormat, int width, int height, int border, int imageSize, Buffer data) {
     gl.glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param level
+     * @param xOffset
+     * @param yOffset
+     * @param width
+     * @param height
+     * @param format
+     * @param imageSize
+     * @param data
+     */
+    @Override
   public void compressedTexSubImage2D(int target, int level, int xOffset, int yOffset, int width, int height, int format, int imageSize, Buffer data) {
     gl.glCompressedTexSubImage2D(target, level, xOffset, yOffset, width, height, format, imageSize, data);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param pname
+     * @param param
+     */
+    @Override
   public void texParameteri(int target, int pname, int param) {
     gl.glTexParameteri(target, pname, param);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param pname
+     * @param param
+     */
+    @Override
   public void texParameterf(int target, int pname, float param) {
     gl.glTexParameterf(target, pname, param);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param pname
+     * @param params
+     */
+    @Override
   public void texParameteriv(int target, int pname, IntBuffer params) {
     gl.glTexParameteriv(target, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param pname
+     * @param params
+     */
+    @Override
   public void texParameterfv(int target, int pname, FloatBuffer params) {
     gl.glTexParameterfv(target, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     */
+    @Override
   public void generateMipmap(int target) {
     gl.glGenerateMipmap(target);
   }
 
-  @Override
+    /**
+     *
+     * @param n
+     * @param textures
+     */
+    @Override
   public void genTextures(int n, IntBuffer textures) {
     gl.glGenTextures(n, textures);
   }
 
-  @Override
+    /**
+     *
+     * @param n
+     * @param textures
+     */
+    @Override
   public void deleteTextures(int n, IntBuffer textures) {
     gl.glDeleteTextures(n, textures);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param pname
+     * @param params
+     */
+    @Override
   public void getTexParameteriv(int target, int pname, IntBuffer params) {
     gl.glGetTexParameteriv(target, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param pname
+     * @param params
+     */
+    @Override
   public void getTexParameterfv(int target, int pname, FloatBuffer params) {
     gl.glGetTexParameterfv(target, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param texture
+     * @return
+     */
+    @Override
   public boolean isTexture(int texture) {
     return gl.glIsTexture(texture);
   }
 
-  @Override
+    /**
+     *
+     * @param texture
+     */
+    @Override
   protected void activeTextureImpl(int texture) {
     gl.glActiveTexture(texture);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param texture
+     */
+    @Override
   protected void bindTextureImpl(int target, int texture) {
     gl.glBindTexture(target, texture);
   }
@@ -1462,67 +2157,131 @@ public class PJOGL extends PGL {
 
   // Shaders and Programs
 
+    /**
+     *
+     * @param type
+     * @return
+     */
+
   @Override
   public int createShader(int type) {
     return gl2.glCreateShader(type);
   }
 
-  @Override
+    /**
+     *
+     * @param shader
+     * @param source
+     */
+    @Override
   public void shaderSource(int shader, String source) {
     gl2.glShaderSource(shader, 1, new String[] { source }, (int[]) null, 0);
   }
 
-  @Override
+    /**
+     *
+     * @param shader
+     */
+    @Override
   public void compileShader(int shader) {
     gl2.glCompileShader(shader);
   }
 
-  @Override
+    /**
+     *
+     */
+    @Override
   public void releaseShaderCompiler() {
     gl2.glReleaseShaderCompiler();
   }
 
-  @Override
+    /**
+     *
+     * @param shader
+     */
+    @Override
   public void deleteShader(int shader) {
     gl2.glDeleteShader(shader);
   }
 
-  @Override
+    /**
+     *
+     * @param count
+     * @param shaders
+     * @param binaryFormat
+     * @param binary
+     * @param length
+     */
+    @Override
   public void shaderBinary(int count, IntBuffer shaders, int binaryFormat, Buffer binary, int length) {
     gl2.glShaderBinary(count, shaders, binaryFormat, binary, length);
   }
 
-  @Override
+    /**
+     *
+     * @return
+     */
+    @Override
   public int createProgram() {
     return gl2.glCreateProgram();
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param shader
+     */
+    @Override
   public void attachShader(int program, int shader) {
     gl2.glAttachShader(program, shader);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param shader
+     */
+    @Override
   public void detachShader(int program, int shader) {
     gl2.glDetachShader(program, shader);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     */
+    @Override
   public void linkProgram(int program) {
     gl2.glLinkProgram(program);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     */
+    @Override
   public void useProgram(int program) {
     gl2.glUseProgram(program);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     */
+    @Override
   public void deleteProgram(int program) {
     gl2.glDeleteProgram(program);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param index
+     * @param size
+     * @param type
+     * @return
+     */
+    @Override
   public String getActiveAttrib(int program, int index, IntBuffer size, IntBuffer type) {
     int[] tmp = {0, 0, 0};
     byte[] namebuf = new byte[1024];
@@ -1533,22 +2292,48 @@ public class PJOGL extends PGL {
     return name;
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param name
+     * @return
+     */
+    @Override
   public int getAttribLocation(int program, String name) {
     return gl2.glGetAttribLocation(program, name);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param index
+     * @param name
+     */
+    @Override
   public void bindAttribLocation(int program, int index, String name) {
     gl2.glBindAttribLocation(program, index, name);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param name
+     * @return
+     */
+    @Override
   public int getUniformLocation(int program, String name) {
     return gl2.glGetUniformLocation(program, name);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param index
+     * @param size
+     * @param type
+     * @return
+     */
+    @Override
   public String getActiveUniform(int program, int index, IntBuffer size, IntBuffer type) {
     int[] tmp= {0, 0, 0};
     byte[] namebuf = new byte[1024];
@@ -1559,122 +2344,270 @@ public class PJOGL extends PGL {
     return name;
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param value
+     */
+    @Override
   public void uniform1i(int location, int value) {
     gl2.glUniform1i(location, value);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param value0
+     * @param value1
+     */
+    @Override
   public void uniform2i(int location, int value0, int value1) {
     gl2.glUniform2i(location, value0, value1);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param value0
+     * @param value1
+     * @param value2
+     */
+    @Override
   public void uniform3i(int location, int value0, int value1, int value2) {
     gl2.glUniform3i(location, value0, value1, value2);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param value0
+     * @param value1
+     * @param value2
+     * @param value3
+     */
+    @Override
   public void uniform4i(int location, int value0, int value1, int value2, int value3) {
     gl2.glUniform4i(location, value0, value1, value2, value3);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param value
+     */
+    @Override
   public void uniform1f(int location, float value) {
     gl2.glUniform1f(location, value);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param value0
+     * @param value1
+     */
+    @Override
   public void uniform2f(int location, float value0, float value1) {
     gl2.glUniform2f(location, value0, value1);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param value0
+     * @param value1
+     * @param value2
+     */
+    @Override
   public void uniform3f(int location, float value0, float value1, float value2) {
     gl2.glUniform3f(location, value0, value1, value2);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param value0
+     * @param value1
+     * @param value2
+     * @param value3
+     */
+    @Override
   public void uniform4f(int location, float value0, float value1, float value2, float value3) {
     gl2.glUniform4f(location, value0, value1, value2, value3);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param v
+     */
+    @Override
   public void uniform1iv(int location, int count, IntBuffer v) {
     gl2.glUniform1iv(location, count, v);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param v
+     */
+    @Override
   public void uniform2iv(int location, int count, IntBuffer v) {
     gl2.glUniform2iv(location, count, v);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param v
+     */
+    @Override
   public void uniform3iv(int location, int count, IntBuffer v) {
     gl2.glUniform3iv(location, count, v);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param v
+     */
+    @Override
   public void uniform4iv(int location, int count, IntBuffer v) {
     gl2.glUniform4iv(location, count, v);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param v
+     */
+    @Override
   public void uniform1fv(int location, int count, FloatBuffer v) {
     gl2.glUniform1fv(location, count, v);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param v
+     */
+    @Override
   public void uniform2fv(int location, int count, FloatBuffer v) {
     gl2.glUniform2fv(location, count, v);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param v
+     */
+    @Override
   public void uniform3fv(int location, int count, FloatBuffer v) {
     gl2.glUniform3fv(location, count, v);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param v
+     */
+    @Override
   public void uniform4fv(int location, int count, FloatBuffer v) {
     gl2.glUniform4fv(location, count, v);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param transpose
+     * @param mat
+     */
+    @Override
   public void uniformMatrix2fv(int location, int count, boolean transpose, FloatBuffer mat) {
     gl2.glUniformMatrix2fv(location, count, transpose, mat);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param transpose
+     * @param mat
+     */
+    @Override
   public void uniformMatrix3fv(int location, int count, boolean transpose, FloatBuffer mat) {
     gl2.glUniformMatrix3fv(location, count, transpose, mat);
   }
 
-  @Override
+    /**
+     *
+     * @param location
+     * @param count
+     * @param transpose
+     * @param mat
+     */
+    @Override
   public void uniformMatrix4fv(int location, int count, boolean transpose, FloatBuffer mat) {
     gl2.glUniformMatrix4fv(location, count, transpose, mat);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     */
+    @Override
   public void validateProgram(int program) {
     gl2.glValidateProgram(program);
   }
 
-  @Override
+    /**
+     *
+     * @param shader
+     * @return
+     */
+    @Override
   public boolean isShader(int shader) {
     return gl2.glIsShader(shader);
   }
 
-  @Override
+    /**
+     *
+     * @param shader
+     * @param pname
+     * @param params
+     */
+    @Override
   public void getShaderiv(int shader, int pname, IntBuffer params) {
     gl2.glGetShaderiv(shader, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param maxCount
+     * @param count
+     * @param shaders
+     */
+    @Override
   public void getAttachedShaders(int program, int maxCount, IntBuffer count, IntBuffer shaders) {
     gl2.glGetAttachedShaders(program, maxCount, count, shaders);
   }
 
-  @Override
+    /**
+     *
+     * @param shader
+     * @return
+     */
+    @Override
   public String getShaderInfoLog(int shader) {
     int[] val = { 0 };
     gl2.glGetShaderiv(shader, GL2ES2.GL_INFO_LOG_LENGTH, val, 0);
@@ -1685,7 +2618,12 @@ public class PJOGL extends PGL {
     return new String(log);
   }
 
-  @Override
+    /**
+     *
+     * @param shader
+     * @return
+     */
+    @Override
   public String getShaderSource(int shader) {
     int[] len = {0};
     byte[] buf = new byte[1024];
@@ -1693,47 +2631,100 @@ public class PJOGL extends PGL {
     return new String(buf, 0, len[0]);
   }
 
-  @Override
+    /**
+     *
+     * @param shaderType
+     * @param precisionType
+     * @param range
+     * @param precision
+     */
+    @Override
   public void getShaderPrecisionFormat(int shaderType, int precisionType, IntBuffer range, IntBuffer precision) {
     gl2.glGetShaderPrecisionFormat(shaderType, precisionType, range, precision);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param pname
+     * @param params
+     */
+    @Override
   public void getVertexAttribfv(int index, int pname, FloatBuffer params) {
     gl2.glGetVertexAttribfv(index, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param pname
+     * @param params
+     */
+    @Override
   public void getVertexAttribiv(int index, int pname, IntBuffer params) {
     gl2.glGetVertexAttribiv(index, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param index
+     * @param pname
+     * @param data
+     */
+    @Override
   public void getVertexAttribPointerv(int index, int pname, ByteBuffer data) {
     throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glGetVertexAttribPointerv()"));
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param location
+     * @param params
+     */
+    @Override
   public void getUniformfv(int program, int location, FloatBuffer params) {
     gl2.glGetUniformfv(program, location, params);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param location
+     * @param params
+     */
+    @Override
   public void getUniformiv(int program, int location, IntBuffer params) {
     gl2.glGetUniformiv(program, location, params);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @return
+     */
+    @Override
   public boolean isProgram(int program) {
     return gl2.glIsProgram(program);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @param pname
+     * @param params
+     */
+    @Override
   public void getProgramiv(int program, int pname, IntBuffer params) {
     gl2.glGetProgramiv(program, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param program
+     * @return
+     */
+    @Override
   public String getProgramInfoLog(int program) {
     int[] val = { 0 };
     gl2.glGetProgramiv(program, GL2ES2.GL_INFO_LOG_LENGTH, val, 0);
@@ -1752,6 +2743,14 @@ public class PJOGL extends PGL {
 
   // Per-Fragment Operations
 
+    /**
+     *
+     * @param x
+     * @param y
+     * @param w
+     * @param h
+     */
+
   @Override
   public void scissor(int x, int y, int w, int h) {
     float scale = getPixelScale();
@@ -1759,57 +2758,120 @@ public class PJOGL extends PGL {
 //    gl.glScissor(x, y, w, h);
   }
 
-  @Override
+    /**
+     *
+     * @param value
+     * @param invert
+     */
+    @Override
   public void sampleCoverage(float value, boolean invert) {
     gl2.glSampleCoverage(value, invert);
   }
 
-  @Override
+    /**
+     *
+     * @param func
+     * @param ref
+     * @param mask
+     */
+    @Override
   public void stencilFunc(int func, int ref, int mask) {
     gl2.glStencilFunc(func, ref, mask);
   }
 
-  @Override
+    /**
+     *
+     * @param face
+     * @param func
+     * @param ref
+     * @param mask
+     */
+    @Override
   public void stencilFuncSeparate(int face, int func, int ref, int mask) {
     gl2.glStencilFuncSeparate(face, func, ref, mask);
   }
 
-  @Override
+    /**
+     *
+     * @param sfail
+     * @param dpfail
+     * @param dppass
+     */
+    @Override
   public void stencilOp(int sfail, int dpfail, int dppass) {
     gl2.glStencilOp(sfail, dpfail, dppass);
   }
 
-  @Override
+    /**
+     *
+     * @param face
+     * @param sfail
+     * @param dpfail
+     * @param dppass
+     */
+    @Override
   public void stencilOpSeparate(int face, int sfail, int dpfail, int dppass) {
     gl2.glStencilOpSeparate(face, sfail, dpfail, dppass);
   }
 
-  @Override
+    /**
+     *
+     * @param func
+     */
+    @Override
   public void depthFunc(int func) {
     gl.glDepthFunc(func);
   }
 
-  @Override
+    /**
+     *
+     * @param mode
+     */
+    @Override
   public void blendEquation(int mode) {
     gl.glBlendEquation(mode);
   }
 
-  @Override
+    /**
+     *
+     * @param modeRGB
+     * @param modeAlpha
+     */
+    @Override
   public void blendEquationSeparate(int modeRGB, int modeAlpha) {
     gl.glBlendEquationSeparate(modeRGB, modeAlpha);
   }
 
-  @Override
+    /**
+     *
+     * @param src
+     * @param dst
+     */
+    @Override
   public void blendFunc(int src, int dst) {
     gl.glBlendFunc(src, dst);
   }
 
-  @Override
+    /**
+     *
+     * @param srcRGB
+     * @param dstRGB
+     * @param srcAlpha
+     * @param dstAlpha
+     */
+    @Override
   public void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
     gl.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
   }
 
-  @Override
+    /**
+     *
+     * @param red
+     * @param green
+     * @param blue
+     * @param alpha
+     */
+    @Override
   public void blendColor(float red, float green, float blue, float alpha) {
     gl2.glBlendColor(red, green, blue, alpha);
   }
@@ -1818,42 +2880,82 @@ public class PJOGL extends PGL {
 
   // Whole Framebuffer Operations
 
+    /**
+     *
+     * @param r
+     * @param g
+     * @param b
+     * @param a
+     */
+
   @Override
   public void colorMask(boolean r, boolean g, boolean b, boolean a) {
     gl.glColorMask(r, g, b, a);
   }
 
-  @Override
+    /**
+     *
+     * @param mask
+     */
+    @Override
   public void depthMask(boolean mask) {
     gl.glDepthMask(mask);
   }
 
-  @Override
+    /**
+     *
+     * @param mask
+     */
+    @Override
   public void stencilMask(int mask) {
     gl.glStencilMask(mask);
   }
 
-  @Override
+    /**
+     *
+     * @param face
+     * @param mask
+     */
+    @Override
   public void stencilMaskSeparate(int face, int mask) {
     gl2.glStencilMaskSeparate(face, mask);
   }
 
-  @Override
+    /**
+     *
+     * @param r
+     * @param g
+     * @param b
+     * @param a
+     */
+    @Override
   public void clearColor(float r, float g, float b, float a) {
     gl.glClearColor(r, g, b, a);
   }
 
-  @Override
+    /**
+     *
+     * @param d
+     */
+    @Override
   public void clearDepth(float d) {
     gl.glClearDepth(d);
   }
 
-  @Override
+    /**
+     *
+     * @param s
+     */
+    @Override
   public void clearStencil(int s) {
     gl.glClearStencil(s);
   }
 
-  @Override
+    /**
+     *
+     * @param buf
+     */
+    @Override
   public void clear(int buf) {
     gl.glClear(buf);
   }
@@ -1862,77 +2964,171 @@ public class PJOGL extends PGL {
 
   // Framebuffers Objects
 
+    /**
+     *
+     * @param target
+     * @param framebuffer
+     */
+
   @Override
   protected void bindFramebufferImpl(int target, int framebuffer) {
     gl.glBindFramebuffer(target, framebuffer);
   }
 
-  @Override
+    /**
+     *
+     * @param n
+     * @param framebuffers
+     */
+    @Override
   public void deleteFramebuffers(int n, IntBuffer framebuffers) {
     gl.glDeleteFramebuffers(n, framebuffers);
   }
 
-  @Override
+    /**
+     *
+     * @param n
+     * @param framebuffers
+     */
+    @Override
   public void genFramebuffers(int n, IntBuffer framebuffers) {
     gl.glGenFramebuffers(n, framebuffers);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param renderbuffer
+     */
+    @Override
   public void bindRenderbuffer(int target, int renderbuffer) {
     gl.glBindRenderbuffer(target, renderbuffer);
   }
 
-  @Override
+    /**
+     *
+     * @param n
+     * @param renderbuffers
+     */
+    @Override
   public void deleteRenderbuffers(int n, IntBuffer renderbuffers) {
     gl.glDeleteRenderbuffers(n, renderbuffers);
   }
 
-  @Override
+    /**
+     *
+     * @param n
+     * @param renderbuffers
+     */
+    @Override
   public void genRenderbuffers(int n, IntBuffer renderbuffers) {
     gl.glGenRenderbuffers(n, renderbuffers);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param internalFormat
+     * @param width
+     * @param height
+     */
+    @Override
   public void renderbufferStorage(int target, int internalFormat, int width, int height) {
     gl.glRenderbufferStorage(target, internalFormat, width, height);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param attachment
+     * @param rendbuferfTarget
+     * @param renderbuffer
+     */
+    @Override
   public void framebufferRenderbuffer(int target, int attachment, int rendbuferfTarget, int renderbuffer) {
     gl.glFramebufferRenderbuffer(target, attachment, rendbuferfTarget, renderbuffer);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param attachment
+     * @param texTarget
+     * @param texture
+     * @param level
+     */
+    @Override
   public void framebufferTexture2D(int target, int attachment, int texTarget, int texture, int level) {
     gl.glFramebufferTexture2D(target, attachment, texTarget, texture, level);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @return
+     */
+    @Override
   public int checkFramebufferStatus(int target) {
     return gl.glCheckFramebufferStatus(target);
   }
 
-  @Override
+    /**
+     *
+     * @param framebuffer
+     * @return
+     */
+    @Override
   public boolean isFramebuffer(int framebuffer) {
     return gl2.glIsFramebuffer(framebuffer);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param attachment
+     * @param pname
+     * @param params
+     */
+    @Override
   public void getFramebufferAttachmentParameteriv(int target, int attachment, int pname, IntBuffer params) {
     gl2.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param renderbuffer
+     * @return
+     */
+    @Override
   public boolean isRenderbuffer(int renderbuffer) {
     return gl2.glIsRenderbuffer(renderbuffer);
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param pname
+     * @param params
+     */
+    @Override
   public void getRenderbufferParameteriv(int target, int pname, IntBuffer params) {
     gl2.glGetRenderbufferParameteriv(target, pname, params);
   }
 
-  @Override
+    /**
+     *
+     * @param srcX0
+     * @param srcY0
+     * @param srcX1
+     * @param srcY1
+     * @param dstX0
+     * @param dstY0
+     * @param dstX1
+     * @param dstY1
+     * @param mask
+     * @param filter
+     */
+    @Override
   public void blitFramebuffer(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter) {
     if (gl2x != null) {
       gl2x.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
@@ -1945,7 +3141,15 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param target
+     * @param samples
+     * @param format
+     * @param width
+     * @param height
+     */
+    @Override
   public void renderbufferStorageMultisample(int target, int samples, int format, int width, int height) {
     if (gl2x != null) {
       gl2x.glRenderbufferStorageMultisample(target, samples, format, width, height);
@@ -1958,7 +3162,11 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param buf
+     */
+    @Override
   public void readBuffer(int buf) {
     if (gl2x != null) {
       gl2x.glReadBuffer(buf);
@@ -1971,7 +3179,11 @@ public class PJOGL extends PGL {
     }
   }
 
-  @Override
+    /**
+     *
+     * @param buf
+     */
+    @Override
   public void drawBuffer(int buf) {
     if (gl2x != null) {
       gl2x.glDrawBuffer(buf);