Bug 801: Add MSAA_RENDERING_BIT ; VBAA: Uses GL_NEAREST (good result) ; Demos: Use local GLRegion for uncached text (perf.) ..

11 files changed, 555 insertions, 25 deletions

diff --git a/src/jogl/classes/com/jogamp/graph/curve/Region.java b/src/jogl/classes/com/jogamp/graph/curve/Region.java
index 9d6e339f2..8e68b7913 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/Region.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/Region.java
@@ -30,7 +30,8 @@ package com.jogamp.graph.curve;
 import java.util.ArrayList;
 import java.util.List;
 
-import jogamp.graph.curve.opengl.VBORegion2PES2;
+import jogamp.graph.curve.opengl.VBORegion2PVBAAES2;
+import jogamp.graph.curve.opengl.VBORegion2PMSAAES2;
 import jogamp.graph.curve.opengl.VBORegionSPES2;
 import jogamp.graph.geom.plane.AffineTransform;
 import jogamp.opengl.Debug;
@@ -52,18 +53,25 @@ public abstract class Region {
     public static final boolean DEBUG_INSTANCE = Debug.debug("graph.curve.instance");
 
     /**
-     * View based Anti-Aliasing, A Two pass region rendering, slower and more
+     * MSAA based Anti-Aliasing, a two pass region rendering, slower and more
+     * resource hungry (FBO), but providing fast MSAA in case
+     * the whole scene is not rendered with MSAA.
+     */
+    public static final int MSAA_RENDERING_BIT        = 1 << 0;
+
+    /**
+     * View based Anti-Aliasing, a two pass region rendering, slower and more
      * resource hungry (FBO), but AA is perfect. Otherwise the default fast one
      * pass MSAA region rendering is being used.
      */
-    public static final int VBAA_RENDERING_BIT = 1 << 0;
+    public static final int VBAA_RENDERING_BIT        = 1 << 1;
 
     /**
      * Use non uniform weights [0.0 .. 1.9] for curve region rendering.
      * Otherwise the default weight 1.0 for uniform curve region rendering is
      * being applied.
      */
-    public static final int VARIABLE_CURVE_WEIGHT_BIT = 1 << 1;
+    public static final int VARIABLE_CURVE_WEIGHT_BIT = 1 << 8;
 
     public static final int TWO_PASS_DEFAULT_TEXTURE_UNIT = 0;
 
@@ -75,6 +83,18 @@ public abstract class Region {
     public static boolean isVBAA(int renderModes) {
         return 0 != (renderModes & Region.VBAA_RENDERING_BIT);
     }
+    public static boolean isMSAA(int renderModes) {
+        return 0 != (renderModes & Region.MSAA_RENDERING_BIT);
+    }
+    public static String getRenderModeString(int renderModes) {
+        if( Region.isVBAA(renderModes) ) {
+            return "vbaa";
+        } else if( Region.isMSAA(renderModes) ) {
+            return "msaa";
+        } else {
+            return "norm" ;
+        }
+    }
 
     /**
      * Check if render mode capable of non uniform weights
@@ -98,10 +118,11 @@ public abstract class Region {
      * @param renderModes bit-field of modes, e.g. {@link Region#VARIABLE_CURVE_WEIGHT_BIT}, {@link Region#VBAA_RENDERING_BIT}
      */
     public static GLRegion create(int renderModes) {
-        if( 0 != ( Region.VBAA_RENDERING_BIT & renderModes ) ){
-            return new VBORegion2PES2(renderModes, Region.TWO_PASS_DEFAULT_TEXTURE_UNIT);
-        }
-        else{
+        if( isVBAA(renderModes) ) {
+            return new VBORegion2PVBAAES2(renderModes, Region.TWO_PASS_DEFAULT_TEXTURE_UNIT);
+        } else if( isMSAA(renderModes) ) {
+            return new VBORegion2PMSAAES2(renderModes, Region.TWO_PASS_DEFAULT_TEXTURE_UNIT);
+        } else {
             return new VBORegionSPES2(renderModes);
         }
     }
@@ -136,6 +157,13 @@ public abstract class Region {
     }
 
     /**
+     * Return  true if capable of two pass rendering - MSAA, otherwise false.
+     */
+    public final boolean isMSAA() {
+        return isMSAA(renderModes);
+    }
+
+    /**
      * Return true if capable of nonuniform weights, otherwise false.
      */
     public final boolean isNonUniformWeight() {
diff --git a/src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java b/src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java
index 92fa084cd..7e0c17eb9 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java
@@ -294,7 +294,14 @@ public abstract class RegionRenderer {
 
     protected String getFragmentShaderName() {
         final String version = getImplVersion();
-        final String pass = Region.isVBAA(renderModes) ? "-2pass" : "-1pass" ;
+        final String pass;
+        if( Region.isVBAA(renderModes) ) {
+            pass = "-2pass_vbaa";
+        } else if( Region.isMSAA(renderModes) ) {
+            pass = "-2pass_msaa";
+        } else {
+            pass = "-1pass_norm" ;
+        }
         final String weight = Region.isNonUniformWeight(renderModes) ? "-weight" : "" ;
         return "curverenderer" + version + pass + weight;
     }
diff --git a/src/jogl/classes/com/jogamp/opengl/FBObject.java b/src/jogl/classes/com/jogamp/opengl/FBObject.java
index 90a8dc073..33751eab9 100644
--- a/src/jogl/classes/com/jogamp/opengl/FBObject.java
+++ b/src/jogl/classes/com/jogamp/opengl/FBObject.java
@@ -2316,8 +2316,8 @@ public class FBObject {
         return "FBO[name r/w "+fbName+"/"+getReadFramebuffer()+", init "+initialized+", bound "+bound+", size "+width+"x"+height+
                ", samples "+samples+"/"+maxSamples+", depth "+depth+", stencil "+stencil+
                ", color attachments: "+colorAttachmentCount+"/"+maxColorAttachments+
-               ": "+caps+", msaa-sink "+samplingSinkTexture+", hasSamplesSink "+(null != samplingSink)+
-               ", state "+getStatusString()+", obj "+toHexString(objectHashCode())+"]";
+               ": "+caps+", msaa["+samplingSinkTexture+", hasSink "+(null != samplingSink)+
+               ", dirty "+samplingSinkDirty+"], state "+getStatusString()+", obj "+toHexString(objectHashCode())+"]";
     }
 
     private final void updateStatus(GL gl) {
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PMSAAES2.java b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PMSAAES2.java
new file mode 100644
index 000000000..cac55f6db
--- /dev/null
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PMSAAES2.java
@@ -0,0 +1,366 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+package jogamp.graph.curve.opengl;
+
+import javax.media.opengl.GL2ES2;
+// FIXME: Subsume GL2GL3.GL_DRAW_FRAMEBUFFER -> GL2ES2.GL_DRAW_FRAMEBUFFER !
+import javax.media.opengl.GL;
+import javax.media.opengl.GLUniformData;
+import javax.media.opengl.fixedfunc.GLMatrixFunc;
+
+import jogamp.graph.curve.opengl.shader.AttributeNames;
+import jogamp.graph.curve.opengl.shader.UniformNames;
+
+import com.jogamp.graph.curve.Region;
+import com.jogamp.graph.curve.opengl.GLRegion;
+import com.jogamp.graph.curve.opengl.RegionRenderer;
+import com.jogamp.graph.curve.opengl.RenderState;
+import com.jogamp.opengl.FBObject;
+import com.jogamp.opengl.FBObject.Attachment;
+import com.jogamp.opengl.util.GLArrayDataServer;
+import com.jogamp.opengl.util.PMVMatrix;
+import com.jogamp.opengl.util.glsl.ShaderState;
+
+public class VBORegion2PMSAAES2  extends GLRegion {
+    private static final boolean DEBUG_FBO_1 = false;
+    private static final boolean DEBUG_FBO_2 = false;
+    private GLArrayDataServer verticeTxtAttr;
+    private GLArrayDataServer texCoordTxtAttr;
+    private GLArrayDataServer indicesTxtBuffer;
+    private GLArrayDataServer verticeFboAttr;
+    private GLArrayDataServer texCoordFboAttr;
+    private GLArrayDataServer indicesFbo;
+
+    private FBObject fbo;
+    private final PMVMatrix fboPMVMatrix;
+    GLUniformData mgl_fboPMVMatrix;
+
+    private int fboWidth = 0;
+    private int fboHeight = 0;
+    GLUniformData mgl_ActiveTexture;
+    GLUniformData mgl_TextureSize; // if GLSL < 1.30
+
+    final int[] maxTexSize = new int[] { -1 } ;
+
+    public VBORegion2PMSAAES2(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
+    protected 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
+    protected 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
+    protected final void pushIndex(int idx) {
+        indicesTxtBuffer.puts((short)idx);
+    }
+
+    @Override
+    protected void update(final GL2ES2 gl, final RegionRenderer renderer) {
+        if(null == indicesFbo) {
+            final ShaderState st = renderer.getShaderState();
+
+            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, 4, GL.GL_STATIC_DRAW);
+            st.ownAttribute(texCoordFboAttr, true);
+            texCoordFboAttr.putf(5); texCoordFboAttr.putf(5);
+            texCoordFboAttr.putf(5); texCoordFboAttr.putf(6);
+            texCoordFboAttr.putf(6); texCoordFboAttr.putf(6);
+            texCoordFboAttr.putf(6); texCoordFboAttr.putf(5);
+            texCoordFboAttr.seal(true);
+
+            verticeFboAttr = GLArrayDataServer.createGLSL(AttributeNames.VERTEX_ATTR_NAME, 3, GL2ES2.GL_FLOAT,
+                                                          false, 4, GL.GL_STATIC_DRAW);
+            st.ownAttribute(verticeFboAttr, true);
+
+            st.ownAttribute(verticeTxtAttr, true);
+            st.ownAttribute(texCoordTxtAttr, true);
+
+            if(Region.DEBUG_INSTANCE) {
+                System.err.println("VBORegion2PES2 Create: " + this);
+            }
+        }
+        // seal buffers
+        indicesTxtBuffer.seal(gl, true);
+        indicesTxtBuffer.enableBuffer(gl, false);
+        texCoordTxtAttr.seal(gl, true);
+        texCoordTxtAttr.enableBuffer(gl, false);
+        verticeTxtAttr.seal(gl, true);
+        verticeTxtAttr.enableBuffer(gl, false);
+
+        // update all bbox related data
+        verticeFboAttr.seal(gl, false);
+        verticeFboAttr.rewind();
+        verticeFboAttr.putf(box.getLow()[0]);  verticeFboAttr.putf(box.getLow()[1]);  verticeFboAttr.putf(box.getLow()[2]);
+        verticeFboAttr.putf(box.getLow()[0]);  verticeFboAttr.putf(box.getHigh()[1]); verticeFboAttr.putf(box.getLow()[2]);
+        verticeFboAttr.putf(box.getHigh()[0]); verticeFboAttr.putf(box.getHigh()[1]); verticeFboAttr.putf(box.getLow()[2]);
+        verticeFboAttr.putf(box.getHigh()[0]); verticeFboAttr.putf(box.getLow()[1]);  verticeFboAttr.putf(box.getLow()[2]);
+        verticeFboAttr.seal(gl, true);
+        verticeFboAttr.enableBuffer(gl, false);
+
+        fboPMVMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
+        fboPMVMatrix.glLoadIdentity();
+        fboPMVMatrix.glOrthof(box.getLow()[0], box.getHigh()[0], box.getLow()[1], box.getHigh()[1], -1, 1);
+
+        // push data 2 GPU ..
+        indicesFbo.seal(gl, true);
+        indicesFbo.enableBuffer(gl, false);
+
+        // trigger renderRegion2FBO !
+        fboHeight = 0;
+        fboWidth = 0;
+        // the buffers were disabled, since due to real/fbo switching and other vbo usage
+    }
+
+    @Override
+    protected void drawImpl(final GL2ES2 gl, final RegionRenderer renderer, final int[/*1*/] sampleCount) {
+        final int width = renderer.getWidth();
+        final int height = renderer.getHeight();
+        if(width <=0 || height <= 0 || null==sampleCount || sampleCount[0] <= 0){
+            renderRegion(gl);
+        } else {
+            if(0 > maxTexSize[0]) {
+                gl.glGetIntegerv(GL.GL_MAX_TEXTURE_SIZE, maxTexSize, 0);
+            }
+            final RenderState rs = renderer.getRenderState();
+            int targetFboWidth, targetFboHeight;
+            {
+                // Calculate perspective pixel width/height for FBO,
+                // considering the sampleCount.
+                final int[] view = new int[] { 0, 0, width, height };
+                final float objZ = 0f;
+
+                final float[] winPosSzMin = new float[3];
+                final float[] winPosSzMax = new float[3];
+                final PMVMatrix pmv = renderer.getMatrix();
+                pmv.gluProject(box.getMinX(), box.getMinY(), objZ, view, 0, winPosSzMin, 0);
+                pmv.gluProject(box.getMaxX(), box.getMaxY(), objZ, view, 0, winPosSzMax, 0);
+                targetFboWidth = Math.round(Math.abs(winPosSzMax[0] - winPosSzMin[0]));
+                targetFboHeight = Math.round(Math.abs(winPosSzMax[1] - winPosSzMin[1]));
+                if( DEBUG_FBO_2 ) {
+                    System.err.printf("XXX.MinMax1 min [%.1f, %.1f -> %.3f, %.3f, %.3f]"+
+                                      ", max [%.1f, %.1f -> %.3f, %.3f, %.3f], view[%d, %d] -> [%d x %d], msaa %d%n",
+                            box.getMinX(), box.getMinY(), winPosSzMin[0], winPosSzMin[1], winPosSzMin[2],
+                            box.getMaxX(), box.getMaxY(), winPosSzMax[0], winPosSzMax[1], winPosSzMax[2],
+                            view[2], view[3], targetFboWidth, targetFboHeight, sampleCount[0]);
+                }
+            }
+            final int deltaFboWidth = Math.abs(targetFboWidth-fboWidth);
+            final int deltaFboHeight = Math.abs(targetFboHeight-fboHeight);
+            final int maxDeltaFbo, maxLengthFbo;
+            if( deltaFboWidth >= deltaFboHeight ) {
+                maxDeltaFbo = deltaFboWidth;
+                maxLengthFbo = fboWidth > 0 ? fboWidth : 1;
+            } else {
+                maxDeltaFbo = deltaFboHeight;
+                maxLengthFbo = fboHeight > 0 ? fboHeight : 1;
+            }
+            final float pctFboDelta = (float)maxDeltaFbo / (float)maxLengthFbo;
+            if( DEBUG_FBO_2 ) {
+                System.err.printf("XXX.maxDelta: %d / %d = %.3f%n", maxDeltaFbo, maxLengthFbo, pctFboDelta);
+            }
+            if( pctFboDelta > 0.1f || ( fbo != null && fbo.getNumSamples() != sampleCount[0] ) ) { // more than 10% !
+                if( DEBUG_FBO_1 ) {
+                    System.err.printf("XXX.maxDelta: %d / %d = %.3f%n", maxDeltaFbo, maxLengthFbo, pctFboDelta);
+                    System.err.printf("XXX.MSAA %d, %d x %d%n",
+                            sampleCount[0], targetFboWidth, targetFboHeight);
+                }
+                // FIXME: maxTexSize test not correct
+                if( targetFboWidth > maxTexSize[0] ) {
+                    targetFboWidth = maxTexSize[0];
+                }
+                if( targetFboHeight > maxTexSize[0] ) {
+                    targetFboHeight = maxTexSize[0];
+                }
+                if( DEBUG_FBO_1 ) {
+                    System.err.printf("XXX.Rescale (MAX): %d %d x %d%n",
+                            sampleCount[0], targetFboWidth, targetFboHeight);
+                }
+                renderRegion2FBO(gl, rs, targetFboWidth, targetFboHeight, sampleCount);
+            }
+            // System.out.println("Scale: " + matrix.glGetMatrixf().get(1+4*3) +" " + matrix.glGetMatrixf().get(2+4*3));
+            renderFBO(gl, rs, width, height);
+        }
+    }
+
+    private void renderFBO(final GL2ES2 gl, final RenderState rs, final int width, final int hight) {
+        final ShaderState st = rs.getShaderState();
+
+        gl.glViewport(0, 0, width, hight);
+        st.uniform(gl, mgl_ActiveTexture);
+        gl.glActiveTexture(GL.GL_TEXTURE0 + mgl_ActiveTexture.intValue());
+
+        fbo.use(gl, fbo.getSamplingSink());
+        verticeFboAttr.enableBuffer(gl, true);
+        texCoordFboAttr.enableBuffer(gl, true);
+        indicesFbo.bindBuffer(gl, true); // keeps VBO binding
+
+        gl.glDrawElements(GL2ES2.GL_TRIANGLES, indicesFbo.getElementCount() * indicesFbo.getComponentCount(), GL2ES2.GL_UNSIGNED_SHORT, 0);
+
+        indicesFbo.bindBuffer(gl, false);
+        texCoordFboAttr.enableBuffer(gl, false);
+        verticeFboAttr.enableBuffer(gl, false);
+        fbo.unuse(gl);
+
+        // setback: gl.glActiveTexture(currentActiveTextureEngine[0]);
+    }
+
+    private void renderRegion2FBO(final GL2ES2 gl, final RenderState rs, final int targetFboWidth, final int targetFboHeight, int[] sampleCount) {
+        final ShaderState st = rs.getShaderState();
+
+        if( 0 >= targetFboWidth || 0 >= targetFboHeight ) {
+            throw new IllegalArgumentException("fboSize must be greater than 0: "+targetFboWidth+"x"+targetFboHeight);
+        }
+
+        if(null == fbo) {
+            fboWidth  = targetFboWidth;
+            fboHeight  = targetFboHeight;
+            fbo = new FBObject();
+            fbo.reset(gl, fboWidth, fboHeight, sampleCount[0], false);
+            sampleCount[0] = fbo.getNumSamples();
+            fbo.attachColorbuffer(gl, 0, true);
+            fbo.attachRenderbuffer(gl, Attachment.Type.DEPTH, 24);
+            final FBObject ssink = new FBObject();
+            {
+                ssink.reset(gl, fboWidth, fboHeight);
+                // FIXME: shall not use bilinear (GL_LINEAR), due to MSAA ???
+                // ssink.attachTexture2D(gl, 0, true, GL2ES2.GL_LINEAR, GL2ES2.GL_LINEAR, GL2ES2.GL_CLAMP_TO_EDGE, GL2ES2.GL_CLAMP_TO_EDGE);
+                ssink.attachTexture2D(gl, 0, true, GL2ES2.GL_NEAREST, GL2ES2.GL_NEAREST, GL2ES2.GL_CLAMP_TO_EDGE, GL2ES2.GL_CLAMP_TO_EDGE);
+                ssink.attachRenderbuffer(gl, Attachment.Type.DEPTH, 24);
+            }
+            fbo.setSamplingSink(ssink);
+            fbo.resetSamplingSink(gl); // validate
+            if( DEBUG_FBO_1 ) {
+                System.err.printf("XXX.createFBO: %dx%d%n%s%n", fboWidth, fboHeight, fbo.toString());
+            }
+        } else if( targetFboWidth != fboWidth || targetFboHeight != fboHeight || fbo.getNumSamples() != sampleCount[0] ) {
+            fbo.reset(gl, targetFboWidth, targetFboHeight, sampleCount[0], true /* resetSamplingSink */);
+            sampleCount[0] = fbo.getNumSamples();
+            if( DEBUG_FBO_1 ) {
+                System.err.printf("XXX.resetFBO: %dx%d -> %dx%d%n%s%n", fboWidth, fboHeight, targetFboWidth, targetFboHeight, fbo );
+            }
+            fboWidth  = targetFboWidth;
+            fboHeight  = targetFboHeight;
+        }
+        fbo.bind(gl);
+
+        //render texture
+        gl.glViewport(0, 0, fboWidth, fboHeight);
+        st.uniform(gl, mgl_fboPMVMatrix); // use orthogonal matrix
+
+        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+        gl.glClear(GL2ES2.GL_COLOR_BUFFER_BIT | GL2ES2.GL_DEPTH_BUFFER_BIT);
+        renderRegion(gl);
+        fbo.unbind(gl);
+
+        st.uniform(gl, rs.getPMVMatrix()); // switch back to real PMV matrix
+    }
+
+    private void renderRegion(final GL2ES2 gl) {
+        verticeTxtAttr.enableBuffer(gl, true);
+        texCoordTxtAttr.enableBuffer(gl, true);
+        indicesTxtBuffer.bindBuffer(gl, true); // keeps VBO binding
+
+        gl.glDrawElements(GL2ES2.GL_TRIANGLES, indicesTxtBuffer.getElementCount() * indicesTxtBuffer.getComponentCount(), GL2ES2.GL_UNSIGNED_SHORT, 0);
+
+        indicesTxtBuffer.bindBuffer(gl, false);
+        texCoordTxtAttr.enableBuffer(gl, false);
+        verticeTxtAttr.enableBuffer(gl, false);
+    }
+
+    @Override
+    protected void destroyImpl(final GL2ES2 gl, final RegionRenderer renderer) {
+        if(DEBUG_INSTANCE) {
+            System.err.println("VBORegion2PES2 Destroy: " + this);
+        }
+        final ShaderState st = renderer.getShaderState();
+        if(null != fbo) {
+            fbo.destroy(gl);
+            fbo = null;
+        }
+        if(null != verticeTxtAttr) {
+            st.ownAttribute(verticeTxtAttr, false);
+            verticeTxtAttr.destroy(gl);
+            verticeTxtAttr = null;
+        }
+        if(null != texCoordTxtAttr) {
+            st.ownAttribute(texCoordTxtAttr, false);
+            texCoordTxtAttr.destroy(gl);
+            texCoordTxtAttr = null;
+        }
+        if(null != indicesTxtBuffer) {
+            indicesTxtBuffer.destroy(gl);
+            indicesTxtBuffer = null;
+        }
+        if(null != verticeFboAttr) {
+            st.ownAttribute(verticeFboAttr, false);
+            verticeFboAttr.destroy(gl);
+            verticeFboAttr = null;
+        }
+        if(null != texCoordFboAttr) {
+            st.ownAttribute(texCoordFboAttr, false);
+            texCoordFboAttr.destroy(gl);
+            texCoordFboAttr = null;
+        }
+        if(null != indicesFbo) {
+            indicesFbo.destroy(gl);
+            indicesFbo = null;
+        }
+    }
+}
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PES2.java b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PVBAAES2.java
index 11309290d..aeb8501ec 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PES2.java
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PVBAAES2.java
@@ -50,7 +50,7 @@ import com.jogamp.opengl.util.GLArrayDataServer;
 import com.jogamp.opengl.util.PMVMatrix;
 import com.jogamp.opengl.util.glsl.ShaderState;
 
-public class VBORegion2PES2  extends GLRegion {
+public class VBORegion2PVBAAES2  extends GLRegion {
     private static final boolean DEBUG_FBO_1 = false;
     private static final boolean DEBUG_FBO_2 = false;
     private GLArrayDataServer verticeTxtAttr;
@@ -72,7 +72,7 @@ public class VBORegion2PES2  extends GLRegion {
 
     final int[] maxTexSize = new int[] { -1 } ;
 
-    public VBORegion2PES2(final int renderModes, final int textureUnit) {
+    public VBORegion2PVBAAES2(final int renderModes, final int textureUnit) {
         super(renderModes);
         final int initialElementCount = 256;
         fboPMVMatrix = new PMVMatrix();
@@ -227,7 +227,7 @@ public class VBORegion2PES2  extends GLRegion {
             if( pctFboDelta > 0.1f ) { // more than 10% !
                 if( DEBUG_FBO_1 ) {
                     System.err.printf("XXX.maxDelta: %d / %d = %.3f%n", maxDeltaFbo, maxLengthFbo, pctFboDelta);
-                    System.err.printf("XXX.Scale %d * [%f x %f]: %dx%d%n",
+                    System.err.printf("XXX.Scale %d * [%f x %f]: %d x %d%n",
                             sampleCount[0], winWidth, winHeight, targetFboWidth, targetFboHeight);
                 }
                 final int maxLength = Math.max(targetFboWidth, targetFboHeight);
@@ -240,9 +240,14 @@ public class VBORegion2PES2  extends GLRegion {
                     targetFboWidth = Math.round(winWidth*sampleCount[0]);
                     targetFboHeight= Math.round(winHeight*sampleCount[0]);
                     if( DEBUG_FBO_1 ) {
-                        System.err.printf("XXX.Rescale (MAX): %d * [%f x %f]: %dx%d%n",
+                        System.err.printf("XXX.Rescale (MAX): %d * [%f x %f]: %d x %d%n",
                                 sampleCount[0], winWidth, winHeight, targetFboWidth, targetFboHeight);
                     }
+                    if( sampleCount[0] <= 0 ) {
+                        // Last way out!
+                        renderRegion(gl);
+                        return;
+                    }
                 }
                 renderRegion2FBO(gl, rs, targetFboWidth, targetFboHeight);
             }
@@ -286,9 +291,9 @@ public class VBORegion2PES2  extends GLRegion {
             fboHeight  = targetFboHeight;
             fbo = new FBObject();
             fbo.reset(gl, fboWidth, fboHeight);
-            // FIXME: shall not use bilinear, due to own AA ? However, w/o bilinear result is not smooth
-            texA = fbo.attachTexture2D(gl, 0, true, GL2ES2.GL_LINEAR, GL2ES2.GL_LINEAR, GL2ES2.GL_CLAMP_TO_EDGE, GL2ES2.GL_CLAMP_TO_EDGE);
-            // texA = fbo.attachTexture2D(gl, 0, GL2ES2.GL_NEAREST, GL2ES2.GL_NEAREST, GL2ES2.GL_CLAMP_TO_EDGE, GL2ES2.GL_CLAMP_TO_EDGE);
+            // FIXME: shall not use bilinear (GL_LINEAR), due to own VBAA. Seems result is smooth w/o it now!
+            // texA = fbo.attachTexture2D(gl, 0, true, GL2ES2.GL_LINEAR, GL2ES2.GL_LINEAR, GL2ES2.GL_CLAMP_TO_EDGE, GL2ES2.GL_CLAMP_TO_EDGE);
+            texA = fbo.attachTexture2D(gl, 0, true, GL2ES2.GL_NEAREST, GL2ES2.GL_NEAREST, GL2ES2.GL_CLAMP_TO_EDGE, GL2ES2.GL_CLAMP_TO_EDGE);
             fbo.attachRenderbuffer(gl, Attachment.Type.DEPTH, 24);
             if( DEBUG_FBO_1 ) {
                 System.err.printf("XXX.createFBO: %dx%d%n%s%n", fboWidth, fboHeight, fbo.toString());
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-1pass-weight.fp b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-1pass_norm-weight.fp
index 2248792cb..2248792cb 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-1pass-weight.fp
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-1pass_norm-weight.fp
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-1pass.fp b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-1pass_norm.fp
index 94e551832..94e551832 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-1pass.fp
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-1pass_norm.fp
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_msaa-weight.fp b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_msaa-weight.fp
new file mode 100644
index 000000000..a4c547939
--- /dev/null
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_msaa-weight.fp
@@ -0,0 +1,69 @@
+//Copyright 2010 JogAmp Community. All rights reserved.

+ 

+//

+// 2-pass shader w/ weight

+//

+

+#if __VERSION__ >= 130

+  #define varying in

+  out vec4 mgl_FragColor;

+  #define texture2D texture

+#else

+  #define mgl_FragColor gl_FragColor

+#endif

+

+#include uniforms.glsl

+#include varyings.glsl

+

+void main (void)

+{

+    vec2 rtex = vec2(abs(gcv_TexCoord.x),abs(gcv_TexCoord.y));

+    vec3 c = gcu_ColorStatic.rgb;

+    

+    float alpha = 0.0;

+    

+    if((gcv_TexCoord.x == 0.0) && (gcv_TexCoord.y == 0.0)) {

+         alpha = gcu_Alpha;

+    }

+    else if((gcv_TexCoord.x >= 5.0)) {

+        rtex -= 5.0;

+        vec4 t = texture2D(gcu_TextureUnit, rtex);

+

+        #if 0

+        if(t.w == 0.0) {

+            discard; // discard freezes NV tegra2 compiler

+        }

+        #endif

+        

+        c = t.xyz;

+        alpha = gcu_Alpha * t.w;

+    }

+    ///////////////////////////////////////////////////////////

+    else if ((gcv_TexCoord.x > 0.0) && (rtex.y > 0.0 || rtex.x == 1.0)) {

+        rtex.y -= 0.1;

+        

+        if(rtex.y < 0.0 && gcv_TexCoord.y < 0.0) {

+            // discard; // freezes NV tegra2 compiler

+            alpha = 0.0;

+        } else {

+            rtex.y = max(rtex.y, 0.0);

+

+            vec2 dtx = dFdx(rtex);

+            vec2 dty = dFdy(rtex);

+              

+            float w = gcu_Weight;

+            float pd = ((2.0 - (2.0*w))*rtex.x*rtex.x) + 2.0*(w-1.0)*rtex.x + 1.0;

+            float position = rtex.y - ((w*rtex.x*(1.0 - rtex.x))/pd);

+

+            float aph = 2.0 - 2.0*w;

+            

+            float gd = (aph*rtex.x*rtex.x + 2.0*rtex.x + 1.0)*(aph*rtex.x*rtex.x + 2.0*rtex.x + 1.0);

+            vec2 f = vec2((dtx.y - (w*dtx.x*(1.0 - 2.0*rtex.x))/gd), (dty.y - (w*dty.x*(1.0 - 2.0*rtex.x))/gd));

+

+            float a = clamp(0.5 - ( position/length(f) ) * sign(gcv_TexCoord.y), 0.0, 1.0);

+            alpha = gcu_Alpha * a;

+        }

+    }

+

+    mgl_FragColor = vec4(c, alpha);

+}

diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_msaa.fp b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_msaa.fp
new file mode 100644
index 000000000..21cd9de71
--- /dev/null
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_msaa.fp
@@ -0,0 +1,62 @@
+//Copyright 2010 JogAmp Community. All rights reserved.
+
+//
+// 2-pass shader w/o weight
+//
+
+#if __VERSION__ >= 130
+  #define varying in
+  out vec4 mgl_FragColor;
+  #define texture2D texture
+#else
+  #define mgl_FragColor gl_FragColor
+#endif
+
+#include uniforms.glsl
+#include varyings.glsl
+
+void main (void)
+{
+    vec2 rtex = vec2(abs(gcv_TexCoord.x),abs(gcv_TexCoord.y));
+    vec3 c = gcu_ColorStatic.rgb;
+
+    float alpha = 0.0;
+    
+    if((gcv_TexCoord.x == 0.0) && (gcv_TexCoord.y == 0.0)) {
+         alpha = gcu_Alpha;
+    }
+    else if((gcv_TexCoord.x >= 5.0)) {
+        rtex -= 5.0;
+        vec4 t = texture2D(gcu_TextureUnit, rtex);
+        
+        #if 0
+        if(t.w == 0.0) {
+            discard; // discard freezes NV tegra2 compiler
+        }
+        #endif
+        
+        c = t.xyz;
+        alpha = gcu_Alpha * t.w;
+    }
+    else if ((gcv_TexCoord.x > 0.0) && (rtex.y > 0.0 || rtex.x == 1.0)) {
+        rtex.y -= 0.1;
+          
+        if(rtex.y < 0.0 && gcv_TexCoord.y < 0.0) {
+            // discard; // freezes NV tegra2 compiler
+            alpha = 0.0;
+        } else {
+            rtex.y = max(rtex.y, 0.0);
+
+            vec2 dtx = dFdx(rtex);
+            vec2 dty = dFdy(rtex);
+              
+            vec2 f = vec2((dtx.y - dtx.x + 2.0*rtex.x*dtx.x), (dty.y - dty.x + 2.0*rtex.x*dty.x));
+            float position = rtex.y - (rtex.x * (1.0 - rtex.x));
+
+            float a = clamp(0.5 - ( position/length(f) ) * sign(gcv_TexCoord.y), 0.0, 1.0);
+            alpha = gcu_Alpha * a;
+        }
+    }
+
+    mgl_FragColor = vec4(c, alpha);
+}
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass-weight.fp b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_vbaa-weight.fp
index e60556bc6..c048254df 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass-weight.fp
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_vbaa-weight.fp
@@ -28,9 +28,6 @@ void main (void)
          alpha = gcu_Alpha;

     }

     else if((gcv_TexCoord.x >= 5.0)) {

-        vec2 dfx = dFdx(gcv_TexCoord);

-        vec2 dfy = dFdy(gcv_TexCoord);

-        

         vec2 size = 1.0/gcu_TextureSize;

 

         rtex -= 5.0;

diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass.fp b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_vbaa.fp
index 0cf4cf88f..0e590a102 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass.fp
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/shader/curverenderer01-2pass_vbaa.fp
@@ -23,15 +23,11 @@ void main (void)
     vec3 c = gcu_ColorStatic.rgb;
 
     float alpha = 0.0;
-    float enable = 1.0;
     
     if((gcv_TexCoord.x == 0.0) && (gcv_TexCoord.y == 0.0)) {
          alpha = gcu_Alpha;
     }
     else if((gcv_TexCoord.x >= 5.0)) {
-        vec2 dfx = dFdx(gcv_TexCoord);
-        vec2 dfy = dFdy(gcv_TexCoord);
-        
         vec2 size = 1.0/gcu_TextureSize;
 
         rtex -= 5.0;