Bug 801: Graph TextRenderer Cleanup Part-3: Region.addOutlineShape(..) Push GL data directly incl. all index validations

Region:
  - Remove redundant methods to make
    OutlineShape the unique source.
    - addVertex(..)
    - addTriangles(..)

  - Perform all index validations in addOutlineShape(..)

  - Push OutlineShape's vertex data
    and it's triangle indices directly to VBO.

GLRegion: Add clear(..) method, allowing to clear the region
          for new data, i.e. OutlineShapes

3 files changed, 115 insertions, 126 deletions

diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PES2.java b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PES2.java
index 22364c373..9c3e3f2c2 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PES2.java
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PES2.java
@@ -39,8 +39,6 @@ import jogamp.graph.curve.opengl.shader.AttributeNames;
 import jogamp.graph.curve.opengl.shader.UniformNames;
 
 import com.jogamp.common.nio.Buffers;
-import com.jogamp.graph.geom.Triangle;
-import com.jogamp.graph.geom.Vertex;
 import com.jogamp.graph.curve.opengl.GLRegion;
 import com.jogamp.graph.curve.opengl.RegionRenderer;
 import com.jogamp.graph.curve.opengl.RenderState;
@@ -54,12 +52,11 @@ import com.jogamp.opengl.util.glsl.ShaderState;
 public class VBORegion2PES2  extends GLRegion {
     private GLArrayDataServer verticeTxtAttr;
     private GLArrayDataServer texCoordTxtAttr;
-    private GLArrayDataServer indicesTxt;
+    private GLArrayDataServer indicesTxtBuffer;
     private GLArrayDataServer verticeFboAttr;
     private GLArrayDataServer texCoordFboAttr;
     private GLArrayDataServer indicesFbo;
 
-
     private FBObject fbo;
     private TextureAttachment texA;
     private final PMVMatrix fboPMVMatrix;
@@ -72,24 +69,58 @@ public class VBORegion2PES2  extends GLRegion {
 
     public VBORegion2PES2(final int renderModes, final int textureUnit) {
         super(renderModes);
+        final int initialElementCount = 256;
         fboPMVMatrix = new PMVMatrix();
         mgl_fboPMVMatrix = new GLUniformData(UniformNames.gcu_PMVMatrix, 4, 4, fboPMVMatrix.glGetPMvMatrixf());
         mgl_ActiveTexture = new GLUniformData(UniformNames.gcu_TextureUnit, textureUnit);
+
+        indicesTxtBuffer = GLArrayDataServer.createData(3, GL2ES2.GL_SHORT, initialElementCount, GL.GL_STATIC_DRAW, GL.GL_ELEMENT_ARRAY_BUFFER);
+        verticeTxtAttr = GLArrayDataServer.createGLSL(AttributeNames.VERTEX_ATTR_NAME, 3, GL2ES2.GL_FLOAT,
+                                                      false, initialElementCount, GL.GL_STATIC_DRAW);
+        texCoordTxtAttr = GLArrayDataServer.createGLSL(AttributeNames.TEXCOORD_ATTR_NAME, 2, GL2ES2.GL_FLOAT,
+                                                       false, initialElementCount, GL.GL_STATIC_DRAW);
+    }
+
+    @Override
+    public final void clearImpl(final GL2ES2 gl, final RegionRenderer renderer) {
+        indicesTxtBuffer.seal(gl, false);
+        indicesTxtBuffer.rewind();
+        verticeTxtAttr.seal(gl, false);
+        verticeTxtAttr.rewind();
+        texCoordTxtAttr.seal(gl, false);
+        texCoordTxtAttr.rewind();
+    }
+
+    @Override
+    public final boolean usesIndices() { return true; }
+
+    @Override
+    public final void pushVertex(float[] coords, float[] texParams) {
+        verticeTxtAttr.putf(coords[0]);
+        verticeTxtAttr.putf(coords[1]);
+        verticeTxtAttr.putf(coords[2]);
+
+        texCoordTxtAttr.putf(texParams[0]);
+        texCoordTxtAttr.putf(texParams[1]);
+    }
+
+    @Override
+    public final void pushIndex(int idx) {
+        indicesTxtBuffer.puts((short)idx);
     }
 
     @Override
     public void update(final GL2ES2 gl, final RegionRenderer renderer) {
         if(null == indicesFbo) {
-            final int initialElementCount = 256;
             final ShaderState st = renderer.getShaderState();
 
-            indicesFbo = GLArrayDataServer.createData(3, GL2ES2.GL_SHORT, initialElementCount, GL.GL_STATIC_DRAW, GL.GL_ELEMENT_ARRAY_BUFFER);
+            indicesFbo = GLArrayDataServer.createData(3, GL2ES2.GL_SHORT, 2, GL.GL_STATIC_DRAW, GL.GL_ELEMENT_ARRAY_BUFFER);
             indicesFbo.puts((short) 0); indicesFbo.puts((short) 1); indicesFbo.puts((short) 3);
             indicesFbo.puts((short) 1); indicesFbo.puts((short) 2); indicesFbo.puts((short) 3);
             indicesFbo.seal(true);
 
             texCoordFboAttr = GLArrayDataServer.createGLSL(AttributeNames.TEXCOORD_ATTR_NAME, 2, GL2ES2.GL_FLOAT,
-                                                           false, initialElementCount, GL.GL_STATIC_DRAW);
+                                                           false, 4, GL.GL_STATIC_DRAW);
             st.ownAttribute(texCoordFboAttr, true);
             texCoordFboAttr.putf(5); texCoordFboAttr.putf(5);
             texCoordFboAttr.putf(5); texCoordFboAttr.putf(6);
@@ -98,60 +129,19 @@ public class VBORegion2PES2  extends GLRegion {
             texCoordFboAttr.seal(true);
 
             verticeFboAttr = GLArrayDataServer.createGLSL(AttributeNames.VERTEX_ATTR_NAME, 3, GL2ES2.GL_FLOAT,
-                                                          false, initialElementCount, GL.GL_STATIC_DRAW);
+                                                          false, 4, GL.GL_STATIC_DRAW);
             st.ownAttribute(verticeFboAttr, true);
 
-
-            indicesTxt = GLArrayDataServer.createData(3, GL2ES2.GL_SHORT, initialElementCount, GL.GL_STATIC_DRAW, GL.GL_ELEMENT_ARRAY_BUFFER);
-
-            verticeTxtAttr = GLArrayDataServer.createGLSL(AttributeNames.VERTEX_ATTR_NAME, 3, GL2ES2.GL_FLOAT,
-                                                          false, initialElementCount, GL.GL_STATIC_DRAW);
             st.ownAttribute(verticeTxtAttr, true);
-
-            texCoordTxtAttr = GLArrayDataServer.createGLSL(AttributeNames.TEXCOORD_ATTR_NAME, 2, GL2ES2.GL_FLOAT,
-                                                           false, initialElementCount, GL.GL_STATIC_DRAW);
             st.ownAttribute(texCoordTxtAttr, true);
 
             if(DEBUG_INSTANCE) {
                 System.err.println("VBORegion2PES2 Create: " + this);
             }
         }
-        validateIndices();
-        // process triangles
-        indicesTxt.seal(gl, false);
-        indicesTxt.rewind();
-        for(int i=0; i<triangles.size(); i++) {
-            final Triangle t = triangles.get(i);
-            final Vertex[] t_vertices = t.getVertices();
-
-            if(t_vertices[0].getId() == Integer.MAX_VALUE){
-                throw new RuntimeException("Ooops Triangle #"+i+" - has unindexed vertices");
-            } else {
-                indicesTxt.puts((short) t_vertices[0].getId());
-                indicesTxt.puts((short) t_vertices[1].getId());
-                indicesTxt.puts((short) t_vertices[2].getId());
-            }
-        }
-        indicesTxt.seal(gl, true);
-        indicesTxt.enableBuffer(gl, false);
-
-        // process vertices and update bbox
-        box.reset();
-        verticeTxtAttr.seal(gl, false);
-        verticeTxtAttr.rewind();
-        texCoordTxtAttr.seal(gl, false);
-        texCoordTxtAttr.rewind();
-        for(int i=0; i<vertices.size(); i++) {
-            final Vertex v = vertices.get(i);
-            verticeTxtAttr.putf(v.getX());
-            verticeTxtAttr.putf(v.getY());
-            verticeTxtAttr.putf(v.getZ());
-            box.resize(v.getX(), v.getY(), v.getZ());
-
-            final float[] tex = v.getTexCoord();
-            texCoordTxtAttr.putf(tex[0]);
-            texCoordTxtAttr.putf(tex[1]);
-        }
+        // seal buffers
+        indicesTxtBuffer.seal(gl, true);
+        indicesTxtBuffer.enableBuffer(gl, false);
         texCoordTxtAttr.seal(gl, true);
         texCoordTxtAttr.enableBuffer(gl, false);
         verticeTxtAttr.seal(gl, true);
@@ -276,11 +266,11 @@ public class VBORegion2PES2  extends GLRegion {
     private void renderRegion(final GL2ES2 gl) {
         verticeTxtAttr.enableBuffer(gl, true);
         texCoordTxtAttr.enableBuffer(gl, true);
-        indicesTxt.bindBuffer(gl, true); // keeps VBO binding
+        indicesTxtBuffer.bindBuffer(gl, true); // keeps VBO binding
 
-        gl.glDrawElements(GL2ES2.GL_TRIANGLES, indicesTxt.getElementCount() * indicesTxt.getComponentCount(), GL2ES2.GL_UNSIGNED_SHORT, 0);
+        gl.glDrawElements(GL2ES2.GL_TRIANGLES, indicesTxtBuffer.getElementCount() * indicesTxtBuffer.getComponentCount(), GL2ES2.GL_UNSIGNED_SHORT, 0);
 
-        indicesTxt.bindBuffer(gl, false);
+        indicesTxtBuffer.bindBuffer(gl, false);
         texCoordTxtAttr.enableBuffer(gl, false);
         verticeTxtAttr.enableBuffer(gl, false);
     }
@@ -306,9 +296,9 @@ public class VBORegion2PES2  extends GLRegion {
             texCoordTxtAttr.destroy(gl);
             texCoordTxtAttr = null;
         }
-        if(null != indicesTxt) {
-            indicesTxt.destroy(gl);
-            indicesTxt = null;
+        if(null != indicesTxtBuffer) {
+            indicesTxtBuffer.destroy(gl);
+            indicesTxtBuffer = null;
         }
         if(null != verticeFboAttr) {
             st.ownAttribute(verticeFboAttr, false);
@@ -324,7 +314,5 @@ public class VBORegion2PES2  extends GLRegion {
             indicesFbo.destroy(gl);
             indicesFbo = null;
         }
-        triangles.clear();
-        vertices.clear();
     }
 }
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegionSPES2.java b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegionSPES2.java
index f7b9e73af..af0c4c980 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegionSPES2.java
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegionSPES2.java
@@ -34,8 +34,6 @@ import jogamp.graph.curve.opengl.shader.AttributeNames;
 
 import com.jogamp.graph.curve.opengl.GLRegion;
 import com.jogamp.graph.curve.opengl.RegionRenderer;
-import com.jogamp.graph.geom.Vertex;
-import com.jogamp.graph.geom.Triangle;
 import com.jogamp.opengl.util.GLArrayDataServer;
 import com.jogamp.opengl.util.glsl.ShaderState;
 
@@ -43,79 +41,68 @@ public class VBORegionSPES2 extends GLRegion {
     private GLArrayDataServer verticeAttr = null;
     private GLArrayDataServer texCoordAttr = null;
     private GLArrayDataServer indicesBuffer = null;
+    private boolean buffersAttached = false;
 
     public VBORegionSPES2(final int renderModes) {
         super(renderModes);
+        final int initialElementCount = 256;
+        indicesBuffer = GLArrayDataServer.createData(3, GL2ES2.GL_SHORT, initialElementCount, GL.GL_STATIC_DRAW, GL.GL_ELEMENT_ARRAY_BUFFER);
+
+        verticeAttr = GLArrayDataServer.createGLSL(AttributeNames.VERTEX_ATTR_NAME, 3, GL2ES2.GL_FLOAT,
+                                                   false, initialElementCount, GL.GL_STATIC_DRAW);
+
+        texCoordAttr = GLArrayDataServer.createGLSL(AttributeNames.TEXCOORD_ATTR_NAME, 2, GL2ES2.GL_FLOAT,
+                                                    false, initialElementCount, GL.GL_STATIC_DRAW);
     }
 
     @Override
-    public void update(final GL2ES2 gl, final RegionRenderer renderer) {
-        if(null == indicesBuffer) {
-            final int initialElementCount = 256;
-            final ShaderState st = renderer.getShaderState();
+    public final void clearImpl(final GL2ES2 gl, final RegionRenderer renderer) {
+        indicesBuffer.seal(gl, false);
+        indicesBuffer.rewind();
+        verticeAttr.seal(gl, false);
+        verticeAttr.rewind();
+        texCoordAttr.seal(gl, false);
+        texCoordAttr.rewind();
+    }
 
-            indicesBuffer = GLArrayDataServer.createData(3, GL2ES2.GL_SHORT, initialElementCount, GL.GL_STATIC_DRAW, GL.GL_ELEMENT_ARRAY_BUFFER);
+    @Override
+    public final boolean usesIndices() { return true; }
 
-            verticeAttr = GLArrayDataServer.createGLSL(AttributeNames.VERTEX_ATTR_NAME, 3, GL2ES2.GL_FLOAT,
-                    false, initialElementCount, GL.GL_STATIC_DRAW);
-            st.ownAttribute(verticeAttr, true);
+    @Override
+    public final void pushVertex(float[] coords, float[] texParams) {
+        verticeAttr.putf(coords[0]);
+        verticeAttr.putf(coords[1]);
+        verticeAttr.putf(coords[2]);
 
-            texCoordAttr = GLArrayDataServer.createGLSL(AttributeNames.TEXCOORD_ATTR_NAME, 2, GL2ES2.GL_FLOAT,
-                    false, initialElementCount, GL.GL_STATIC_DRAW);
-            st.ownAttribute(texCoordAttr, true);
+        texCoordAttr.putf(texParams[0]);
+        texCoordAttr.putf(texParams[1]);
+    }
 
-            if(DEBUG_INSTANCE) {
-                System.err.println("VBORegionSPES2 Create: " + this);
-            }
-        }
+    @Override
+    public final void pushIndex(int idx) {
+        indicesBuffer.puts((short)idx);
+    }
 
-        if(DEBUG_INSTANCE) {
-            System.err.println("VBORegionSPES2 Indices of "+triangles.size()+", triangles");
-        }
-        validateIndices();
-        // process triangles
-        indicesBuffer.seal(gl, false);
-        indicesBuffer.rewind();
-        for(int i=0; i<triangles.size(); i++) {
-            final Triangle t = triangles.get(i);
-            final Vertex[] t_vertices = t.getVertices();
-
-            if(t_vertices[0].getId() == Integer.MAX_VALUE){
-                throw new RuntimeException("Ooops Triangle #"+i+" - has unindexed vertices");
-            } else {
-                indicesBuffer.puts((short) t_vertices[0].getId());
-                indicesBuffer.puts((short) t_vertices[1].getId());
-                indicesBuffer.puts((short) t_vertices[2].getId());
-                if(DEBUG_INSTANCE) {
-                    System.err.println("VBORegionSPES2.Indices.2: "+
-                            t_vertices[0].getId()+", "+t_vertices[1].getId()+", "+t_vertices[2].getId());
-                }
-            }
+    @Override
+    public void update(final GL2ES2 gl, final RegionRenderer renderer) {
+        if( !buffersAttached ) {
+            final ShaderState st = renderer.getShaderState();
+            st.ownAttribute(verticeAttr, true);
+            st.ownAttribute(texCoordAttr, true);
+            buffersAttached = true;
         }
+        // seal buffers
         indicesBuffer.seal(gl, true);
         indicesBuffer.enableBuffer(gl, false);
-
-        // process vertices and update bbox
-        box.reset();
-        verticeAttr.seal(gl, false);
-        verticeAttr.rewind();
-        texCoordAttr.seal(gl, false);
-        texCoordAttr.rewind();
-        for(int i=0; i<vertices.size(); i++) {
-            final Vertex v = vertices.get(i);
-            verticeAttr.putf(v.getX());
-            verticeAttr.putf(v.getY());
-            verticeAttr.putf(v.getZ());
-            box.resize(v.getX(), v.getY(), v.getZ());
-
-            final float[] tex = v.getTexCoord();
-            texCoordAttr.putf(tex[0]);
-            texCoordAttr.putf(tex[1]);
-        }
         verticeAttr.seal(gl, true);
         verticeAttr.enableBuffer(gl, false);
         texCoordAttr.seal(gl, true);
         texCoordAttr.enableBuffer(gl, false);
+        if(DEBUG_INSTANCE) {
+            System.err.println("VBORegionSPES2 idx "+indicesBuffer);
+            System.err.println("VBORegionSPES2 ver "+verticeAttr);
+            System.err.println("VBORegionSPES2 tex "+texCoordAttr);
+        }
     }
 
     @Override
diff --git a/src/jogl/classes/jogamp/graph/geom/plane/AffineTransform.java b/src/jogl/classes/jogamp/graph/geom/plane/AffineTransform.java
index f5cf8dd95..5953ea89b 100644
--- a/src/jogl/classes/jogamp/graph/geom/plane/AffineTransform.java
+++ b/src/jogl/classes/jogamp/graph/geom/plane/AffineTransform.java
@@ -403,17 +403,17 @@ public class AffineTransform implements Cloneable, Serializable {
         );
     }
 
-    public Vertex transform(Vertex src, Vertex dst) {
+    public final Vertex transform(final Vertex src, Vertex dst) {
         if (dst == null) {
             dst = pointFactory.create(src.getId(), src.isOnCurve(), src.getTexCoord());
         }
         final float x = src.getX();
         final float y = src.getY();
-        dst.setCoord(x * m00 + y * m01 + m02, x * m10 + y * m11 + m12, 0f);
+        dst.setCoord(x * m00 + y * m01 + m02, x * m10 + y * m11 + m12, src.getZ());
         return dst;
     }
 
-    public void transform(Vertex[] src, int srcOff, Vertex[] dst, int dstOff, int length) {
+    public final void transform(Vertex[] src, int srcOff, Vertex[] dst, int dstOff, int length) {
         while (--length >= 0) {
             Vertex srcPoint = src[srcOff++];
             Vertex dstPoint = dst[dstOff];
@@ -422,12 +422,26 @@ public class AffineTransform implements Cloneable, Serializable {
             }
             final float x = srcPoint.getX();
             final float y = srcPoint.getY();
-            dstPoint.setCoord(x * m00 + y * m01 + m02, x * m10 + y * m11 + m12, 0f);
+            dstPoint.setCoord(x * m00 + y * m01 + m02, x * m10 + y * m11 + m12, srcPoint.getZ());
             dst[dstOff++] = dstPoint;
         }
     }
 
-    public void transform(float[] src, int srcOff, float[] dst, int dstOff, int length) {
+    public final void transform(final float[] src, final float[] dst) {
+        final float x = src[0];
+        final float y = src[1];
+        dst[0] = x * m00 + y * m01 + m02;
+        dst[1] = x * m10 + y * m11 + m12;
+    }
+
+    public final void transform(final float[] src, final int srcOff, final float[] dst, final int dstOff) {
+        final float x = src[srcOff + 0];
+        final float y = src[srcOff + 1];
+        dst[dstOff + 0] = x * m00 + y * m01 + m02;
+        dst[dstOff + 1] = x * m10 + y * m11 + m12;
+    }
+
+    public final void transform(final float[] src, int srcOff, final float[] dst, int dstOff, int length) {
         int step = 2;
         if (src == dst && srcOff < dstOff && dstOff < srcOff + length * 2) {
             srcOff = srcOff + length * 2 - 2;
@@ -435,8 +449,8 @@ public class AffineTransform implements Cloneable, Serializable {
             step = -2;
         }
         while (--length >= 0) {
-            float x = src[srcOff + 0];
-            float y = src[srcOff + 1];
+            final float x = src[srcOff + 0];
+            final float y = src[srcOff + 1];
             dst[dstOff + 0] = x * m00 + y * m01 + m02;
             dst[dstOff + 1] = x * m10 + y * m11 + m12;
             srcOff += step;
@@ -450,7 +464,7 @@ public class AffineTransform implements Cloneable, Serializable {
         }
         final float x = src.getX();
         final float y = src.getY();
-        dst.setCoord(x * m00 + y * m01, x * m10 + y * m11, 0f);
+        dst.setCoord(x * m00 + y * m01, x * m10 + y * m11, src.getZ());
         return dst;
     }
 
@@ -473,7 +487,7 @@ public class AffineTransform implements Cloneable, Serializable {
         }
         final float x = src.getX() - m02;
         final float y = src.getY() - m12;
-        dst.setCoord((x * m11 - y * m01) / det, (y * m00 - x * m10) / det, 0f);
+        dst.setCoord((x * m11 - y * m01) / det, (y * m00 - x * m10) / det, src.getZ());
         return dst;
     }