ShaderState: Validated impl./state-handling / Added comments

Capable of glBinAttribLocation(..)

Proper state check (has program, linked program, ..) for attrib/uniform methods.

6 files changed, 993 insertions, 0 deletions

diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader.fp b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader.fp
new file mode 100644
index 000000000..a41960ab8
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader.fp
@@ -0,0 +1,17 @@
+// Copyright 2010 JogAmp Community. All rights reserved.
+
+#ifdef GL_ES
+  #define MEDIUMP mediump
+  #define HIGHP highp
+#else
+  #define MEDIUMP
+  #define HIGHP
+#endif
+
+varying   HIGHP vec4    frontColor;
+
+void main (void)
+{
+    gl_FragColor = frontColor;
+}
+
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader.vp b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader.vp
new file mode 100644
index 000000000..a785b086c
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader.vp
@@ -0,0 +1,21 @@
+// Copyright 2010 JogAmp Community. All rights reserved.
+
+#ifdef GL_ES
+  #define MEDIUMP mediump
+  #define HIGHP highp
+#else
+  #define MEDIUMP
+  #define HIGHP
+#endif
+
+uniform MEDIUMP mat4    mgl_PMVMatrix[2];
+attribute HIGHP vec4    mgl_Vertex;
+attribute HIGHP vec4    mgl_Color;
+varying   HIGHP vec4    frontColor;
+
+void main(void)
+{
+  frontColor=mgl_Color;
+  gl_Position = mgl_PMVMatrix[0] * mgl_PMVMatrix[1] * mgl_Vertex;
+}
+
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader2.fp b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader2.fp
new file mode 100644
index 000000000..7c8bd56f1
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/demos/es2/shader/RedSquareShader2.fp
@@ -0,0 +1,17 @@
+// Copyright 2010 JogAmp Community. All rights reserved.
+
+#ifdef GL_ES
+  #define MEDIUMP mediump
+  #define HIGHP highp
+#else
+  #define MEDIUMP
+  #define HIGHP
+#endif
+
+varying   HIGHP vec4    frontColor;
+
+void main (void)
+{
+    gl_FragColor = frontColor.bgra;
+}
+
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/glsl/GLSLMiscHelper.java b/src/test/com/jogamp/opengl/test/junit/jogl/glsl/GLSLMiscHelper.java
new file mode 100644
index 000000000..de6b91242
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/glsl/GLSLMiscHelper.java
@@ -0,0 +1,197 @@
+/**
+ * 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 com.jogamp.opengl.test.junit.jogl.glsl;
+
+import com.jogamp.newt.opengl.GLWindow;
+import com.jogamp.opengl.util.GLArrayDataServer;
+import com.jogamp.opengl.util.glsl.ShaderState;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLProfile;
+
+import org.junit.Assert;
+
+public class GLSLMiscHelper {
+    public static GLWindow createWindow() {
+        GLProfile glp = GLProfile.get(GLProfile.GL2ES2);
+        GLCapabilities caps = new GLCapabilities(glp);
+        GLWindow window = GLWindow.create(caps);
+        window.setSize(800, 600);
+        window.setVisible(true);
+        Assert.assertTrue(window.isNativeValid());
+        window.display();
+        Assert.assertTrue(window.isRealized());
+        Assert.assertTrue(window.getContext().isCreated());        
+        return window;
+    }
+    
+    public static void validateGLArrayDataServerState(GL2ES2 gl, GLArrayDataServer data) {
+        int[] qi = new int[1];
+        gl.glGetVertexAttribiv(data.getLocation(), GL2ES2.GL_VERTEX_ATTRIB_ARRAY_ENABLED, qi, 0);
+        Assert.assertEquals(data.enabled()?GL.GL_TRUE:GL.GL_FALSE, qi[0]);
+        gl.glGetVertexAttribiv(data.getLocation(), GL2ES2.GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, qi, 0);
+        Assert.assertEquals(data.getVBOName(), qi[0]);  
+        Assert.assertEquals(data.getByteSize(), gl.glGetBufferSize(data.getVBOName()));        
+    }
+
+    public static void pause(long ms) throws InterruptedException {
+        long t0 = System.currentTimeMillis();
+        while( System.currentTimeMillis() - t0 < ms) {
+            Thread.sleep(ms);
+        }        
+    }
+    
+    public static void displayVCArrays(GLWindow window, GL2ES2 gl, boolean preEnable, GLArrayDataServer vertices, GLArrayDataServer colors, boolean postDisable, int num, long postDelay) throws InterruptedException {
+        System.err.println("screen #"+num);
+        if(preEnable) {
+            vertices.enableBuffer(gl, true);
+            Assert.assertEquals(vertices.getVBOName(), gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER));
+            colors.enableBuffer(gl, true);
+            Assert.assertEquals(colors.getVBOName(), gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER));
+        }
+        Assert.assertTrue(vertices.enabled());
+        Assert.assertTrue(colors.enabled());
+        
+        validateGLArrayDataServerState(gl, vertices);
+        validateGLArrayDataServerState(gl, colors);
+        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+        gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, 4);        
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        if(postDisable) {
+            vertices.enableBuffer(gl, false);
+            colors.enableBuffer(gl, false);
+            Assert.assertTrue(!vertices.enabled());
+            Assert.assertTrue(!colors.enabled());
+        }
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        window.swapBuffers();
+        if(postDelay>0) { pause(postDelay); }        
+    }
+    
+    public static void displayVCArraysNoChecks(GLWindow window, GL2ES2 gl, boolean preEnable, GLArrayDataServer vertices, GLArrayDataServer colors, boolean postDisable) throws InterruptedException {
+        if(preEnable) {
+            vertices.enableBuffer(gl, true);
+            colors.enableBuffer(gl, true);
+        }
+        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+        gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, 4);        
+        if(postDisable) {
+            vertices.enableBuffer(gl, false);
+            colors.enableBuffer(gl, false);
+        }
+        window.swapBuffers();
+    }
+    
+    public static GLArrayDataServer createRSVertices0(GL2ES2 gl, ShaderState st, int location) {        
+        // Allocate Vertex Array0
+        GLArrayDataServer vertices0 = GLArrayDataServer.createGLSL(st, "mgl_Vertex", 3, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW);
+        if(0<=location) {
+            st.glBindAttribLocation(gl, location, vertices0);
+        }
+        Assert.assertTrue(vertices0.isVBO());
+        Assert.assertTrue(vertices0.isVertexAttribute());
+        Assert.assertTrue(!vertices0.isVBOWritten());
+        Assert.assertTrue(!vertices0.sealed());
+        vertices0.putf(-2); vertices0.putf(2);  vertices0.putf(0);
+        vertices0.putf(2);  vertices0.putf(2);  vertices0.putf(0);
+        vertices0.putf(-2); vertices0.putf(-2); vertices0.putf(0);
+        vertices0.putf(2);  vertices0.putf(-2); vertices0.putf(0);
+        vertices0.seal(gl, true);
+        Assert.assertTrue(vertices0.isVBOWritten());
+        Assert.assertTrue(vertices0.sealed());
+        Assert.assertEquals(4, vertices0.getElementNumber());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());        
+        Assert.assertEquals(vertices0, st.getAttribute("mgl_Vertex"));
+        Assert.assertEquals(vertices0.getVBOName(), gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER));
+        validateGLArrayDataServerState(gl, vertices0);
+        return vertices0;
+    }
+        
+    public static GLArrayDataServer createRSVertices1(GL2ES2 gl, ShaderState st) {        
+        GLArrayDataServer vertices1 = GLArrayDataServer.createGLSL(st, "mgl_Vertex", 3, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW); 
+        Assert.assertTrue(vertices1.isVBO());
+        Assert.assertTrue(vertices1.isVertexAttribute());
+        Assert.assertTrue(!vertices1.isVBOWritten());
+        Assert.assertTrue(!vertices1.sealed());
+        vertices1.putf(-2); vertices1.putf(1);  vertices1.putf(0);
+        vertices1.putf(2);  vertices1.putf(1);  vertices1.putf(0);
+        vertices1.putf(-2); vertices1.putf(-1); vertices1.putf(0);
+        vertices1.putf(2);  vertices1.putf(-1); vertices1.putf(0);
+        vertices1.seal(gl, true);
+        Assert.assertTrue(vertices1.isVBOWritten());
+        Assert.assertTrue(vertices1.sealed());
+        Assert.assertEquals(4, vertices1.getElementNumber());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertEquals(vertices1, st.getAttribute("mgl_Vertex"));
+        Assert.assertEquals(vertices1.getVBOName(), gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER));
+        validateGLArrayDataServerState(gl, vertices1);
+        return vertices1;
+    }
+        
+    public static GLArrayDataServer createRSColors0(GL2ES2 gl, ShaderState st, int location) {        
+        GLArrayDataServer colors0 = GLArrayDataServer.createGLSL(st, "mgl_Color", 4, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW);
+        if(0<=location) {
+            st.glBindAttribLocation(gl, location, colors0);
+        }        
+        colors0.putf(1); colors0.putf(0); colors0.putf(0); colors0.putf(1);
+        colors0.putf(0); colors0.putf(0); colors0.putf(1); colors0.putf(1);
+        colors0.putf(1); colors0.putf(0); colors0.putf(0); colors0.putf(1);
+        colors0.putf(1); colors0.putf(0); colors0.putf(0); colors0.putf(1);
+        colors0.seal(gl, true);
+        Assert.assertTrue(colors0.isVBO());
+        Assert.assertTrue(colors0.isVertexAttribute());
+        Assert.assertTrue(colors0.isVBOWritten());
+        Assert.assertTrue(colors0.sealed());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertEquals(colors0, st.getAttribute("mgl_Color"));
+        Assert.assertEquals(colors0.getVBOName(), gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER));
+        validateGLArrayDataServerState(gl, colors0);
+        return colors0;
+    }
+    
+    public static GLArrayDataServer createRSColors1(GL2ES2 gl, ShaderState st) {        
+        // Allocate Color Array1
+        GLArrayDataServer colors1 = GLArrayDataServer.createGLSL(st, "mgl_Color", 4, GL.GL_FLOAT, false, 4, GL.GL_STATIC_DRAW);
+        colors1.putf(1); colors1.putf(0); colors1.putf(1); colors1.putf(1);
+        colors1.putf(0); colors1.putf(1); colors1.putf(0); colors1.putf(1);
+        colors1.putf(1); colors1.putf(0); colors1.putf(1); colors1.putf(1);
+        colors1.putf(1); colors1.putf(0); colors1.putf(1); colors1.putf(1);
+        colors1.seal(gl, true);
+        Assert.assertTrue(colors1.isVBO());
+        Assert.assertTrue(colors1.isVertexAttribute());
+        Assert.assertTrue(colors1.isVBOWritten());
+        Assert.assertTrue(colors1.sealed());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertEquals(colors1, st.getAttribute("mgl_Color"));
+        Assert.assertEquals(colors1.getVBOName(), gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER));
+        validateGLArrayDataServerState(gl, colors1);
+        return colors1;        
+    }    
+}
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/glsl/TestGLSLShaderState01NEWT.java b/src/test/com/jogamp/opengl/test/junit/jogl/glsl/TestGLSLShaderState01NEWT.java
new file mode 100644
index 000000000..09e6f4e8c
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/glsl/TestGLSLShaderState01NEWT.java
@@ -0,0 +1,395 @@
+/**
+ * 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 com.jogamp.opengl.test.junit.jogl.glsl;
+
+import com.jogamp.newt.opengl.GLWindow;
+import com.jogamp.opengl.util.GLArrayDataServer;
+import com.jogamp.opengl.util.PMVMatrix;
+import com.jogamp.opengl.util.glsl.ShaderCode;
+import com.jogamp.opengl.util.glsl.ShaderProgram;
+import com.jogamp.opengl.util.glsl.ShaderState;
+import com.jogamp.opengl.test.junit.jogl.demos.es2.RedSquare0;
+import com.jogamp.opengl.test.junit.util.MiscUtils;
+import com.jogamp.opengl.test.junit.util.UITestCase;
+
+import java.io.IOException;
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLUniformData;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Testing different vertex attribute (VA) data sets on one shader
+ * and shader state in general.
+ */
+public class TestGLSLShaderState01NEWT extends UITestCase {
+    static long durationPerTest = 10; // ms
+    static int frames_perftest =  5000; // frames
+    static int frames_warmup   =   100; // frames
+
+    static final int vertices0_loc = 1;
+    static final int colors0_loc = 2;
+    
+    @Test
+    public void testShaderState01Validation() throws InterruptedException {
+        // preset ..
+        GLWindow window = GLSLMiscHelper.createWindow();
+        GLContext context = window.getContext();
+        context.setSynchronized(true);
+        context.makeCurrent();
+        GL2ES2 gl = context.getGL().getGL2ES2();
+
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        // test code ..        
+        ShaderState st = new ShaderState();
+        
+        ShaderCode rsVp = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+        ShaderCode rsFp = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+
+        ShaderProgram sp = new ShaderProgram();
+        sp.add(rsVp);
+        sp.add(rsFp);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        Assert.assertTrue(0>sp.program());        
+        sp.init(gl);
+        Assert.assertTrue(0<=sp.program()); 
+        Assert.assertTrue(!sp.inUse());
+        Assert.assertTrue(!sp.linked());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        st.attachShaderProgram(gl, sp);
+        
+        // Allocate Vertex Array0
+        GLArrayDataServer vertices0 = GLSLMiscHelper.createRSVertices0(gl, st, vertices0_loc);
+        System.err.println("vertices0: " + vertices0);        
+        vertices0.enableBuffer(gl, false);
+        Assert.assertEquals(vertices0_loc, vertices0.getLocation());
+        
+        // Allocate Color Array0
+        GLArrayDataServer colors0 = GLSLMiscHelper.createRSColors0(gl, st, colors0_loc);
+        System.err.println("colors0: " + colors0);
+        colors0.enableBuffer(gl, false);
+        Assert.assertEquals(colors0_loc, colors0.getLocation());
+                               
+        Assert.assertTrue(sp.link(gl, System.err));
+        Assert.assertTrue(sp.linked());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        Assert.assertEquals(vertices0_loc, vertices0.getLocation());
+        Assert.assertEquals(vertices0_loc, st.glGetAttribLocation(gl, vertices0.getName()));
+        Assert.assertEquals(vertices0_loc, gl.glGetAttribLocation(st.shaderProgram().program(), vertices0.getName()));
+        
+        Assert.assertEquals(colors0_loc, colors0.getLocation());
+        Assert.assertEquals(colors0_loc, st.glGetAttribLocation(gl, colors0.getName()));
+        Assert.assertEquals(colors0_loc, gl.glGetAttribLocation(st.shaderProgram().program(), colors0.getName()));
+        
+        Assert.assertEquals(null, ShaderState.getShaderState(gl));
+        st.glUseProgram(gl, true);
+        Assert.assertTrue(sp.inUse());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertEquals(st, ShaderState.getShaderState(gl));        
+        
+        // setup mgl_PMVMatrix
+        PMVMatrix pmvMatrix = new PMVMatrix();
+        GLUniformData pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        st.glUniform(gl, pmvMatrixUniform);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertEquals(pmvMatrixUniform, st.getUniform("mgl_PMVMatrix"));
+        
+        // Allocate Vertex Array1
+        GLArrayDataServer vertices1 = GLSLMiscHelper.createRSVertices1(gl, st);
+        System.err.println("vertices1: " + vertices1);
+        vertices1.enableBuffer(gl, false);
+        
+        // Allocate Color Array1
+        GLArrayDataServer colors1 = GLSLMiscHelper.createRSColors1(gl, st);
+        System.err.println("colors1: " + colors1);
+        colors1.enableBuffer(gl, false);
+        
+        // misc GL setup
+        gl.glClearColor(0, 0, 0, 1);
+        gl.glEnable(GL2ES2.GL_DEPTH_TEST);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+
+        // reshape
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_PROJECTION);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.gluPerspective(45.0F, (float) window.getWidth() / (float) window.getHeight(), 1.0F, 100.0F);
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_MODELVIEW);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.glTranslatef(0, 0, -10);
+        st.glUniform(gl, pmvMatrixUniform);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        // display #1 vertices0 / colors0 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices0, colors0, true, 1, durationPerTest);
+
+        // display #2 #1 vertices1 / colors1 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices1, colors1, true, 2, durationPerTest);
+        
+        // display #3 vertices0 / colors0 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices0, colors0, true, 3, durationPerTest);
+        
+        // cleanup
+        vertices1.destroy(gl);
+        vertices0.destroy(gl);
+        colors0.destroy(gl);
+        colors1.destroy(gl);
+        st.glUseProgram(gl, false);
+        sp.release(gl, true);
+        context.release();
+        window.destroy();        
+    }
+
+    @Test
+    public void testShaderState00PerformanceSingleKeepEnabled() throws InterruptedException {
+        testShaderState00PerformanceSingle(false);
+    }
+    @Test
+    public void testShaderState00PerformanceSingleToggleEnable() throws InterruptedException {
+        testShaderState00PerformanceSingle(true);
+    }
+    
+    void testShaderState00PerformanceSingle(boolean toggleEnable) throws InterruptedException {
+        // preset ..
+        GLWindow window = GLSLMiscHelper.createWindow();
+        GLContext context = window.getContext();
+        context.setSynchronized(true);
+        context.makeCurrent();
+        GL2ES2 gl = context.getGL().getGL2ES2();
+
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        // test code ..        
+        ShaderState st = new ShaderState();
+        
+        ShaderCode rsVp = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+        ShaderCode rsFp = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+
+        ShaderProgram sp = new ShaderProgram();
+        sp.add(rsVp);
+        sp.add(rsFp);
+        
+        sp.init(gl);
+        Assert.assertTrue(sp.link(gl, System.err));
+        
+        st.attachShaderProgram(gl, sp);        
+        st.glUseProgram(gl, true);
+        
+        // setup mgl_PMVMatrix
+        PMVMatrix pmvMatrix = new PMVMatrix();
+        GLUniformData pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf());        
+        st.glUniform(gl, pmvMatrixUniform);
+        
+        // Allocate Vertex Array0
+        GLArrayDataServer vertices0 = GLSLMiscHelper.createRSVertices0(gl, st, -1);
+        vertices0.enableBuffer(gl, toggleEnable ? false : true);
+        
+        // Allocate Color Array0
+        GLArrayDataServer colors0 = GLSLMiscHelper.createRSColors0(gl, st, -1);
+        colors0.enableBuffer(gl, toggleEnable ? false : true);
+        
+        // misc GL setup
+        gl.glClearColor(0, 0, 0, 1);
+        gl.glEnable(GL2ES2.GL_DEPTH_TEST);
+
+        // reshape
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_PROJECTION);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.gluPerspective(45.0F, (float) window.getWidth() / (float) window.getHeight(), 1.0F, 100.0F);
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_MODELVIEW);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.glTranslatef(0, 0, -10);
+        st.glUniform(gl, pmvMatrixUniform);
+
+        long t0 = System.currentTimeMillis();
+        int frames;
+        
+        // validation ..
+        GLSLMiscHelper.displayVCArrays(window, gl, toggleEnable, vertices0, colors0, toggleEnable, 1, 0);
+        
+        // warmup ..
+        for(frames=0; frames<frames_warmup; frames++) {
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, toggleEnable, vertices0, colors0, toggleEnable);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, toggleEnable, vertices0, colors0, toggleEnable);
+        }        
+        // measure ..
+        for(frames=0; frames<frames_perftest; frames++) {
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, toggleEnable, vertices0, colors0, toggleEnable);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, toggleEnable, vertices0, colors0, toggleEnable);
+        }        
+        final long t1 = System.currentTimeMillis();
+        final long dt = t1 - t0;        
+        final double fps = ( frames * 1000.0 ) / (double) dt;
+        final String fpsS = String.valueOf(fps);        
+        final int fpsSp = fpsS.indexOf('.');        
+        System.err.println("testShaderState00PerformanceSingle toggleEnable "+toggleEnable+": "+dt/1000.0 +"s: "+ frames + "f, " + fpsS.substring(0, fpsSp+2) + " fps, "+dt/frames+" ms/f");        
+        
+        // cleanup
+        st.glUseProgram(gl, false);
+        sp.release(gl, true);
+        vertices0.destroy(gl);
+        colors0.destroy(gl);
+        context.release();
+        window.destroy();        
+    }
+    
+    @Test
+    public void testShaderState01PerformanceDouble() throws InterruptedException {
+        // preset ..
+        GLWindow window = GLSLMiscHelper.createWindow();
+        GLContext context = window.getContext();
+        context.setSynchronized(true);
+        context.makeCurrent();
+        GL2ES2 gl = context.getGL().getGL2ES2();
+
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        // test code ..        
+        ShaderState st = new ShaderState();
+        
+        ShaderCode rsVp = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+        ShaderCode rsFp = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+
+        ShaderProgram sp = new ShaderProgram();
+        sp.add(rsVp);
+        sp.add(rsFp);
+        
+        sp.init(gl);
+        Assert.assertTrue(sp.link(gl, System.err));
+        
+        st.attachShaderProgram(gl, sp);        
+        st.glUseProgram(gl, true);
+        
+        // setup mgl_PMVMatrix
+        PMVMatrix pmvMatrix = new PMVMatrix();
+        GLUniformData pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf());        
+        st.glUniform(gl, pmvMatrixUniform);
+        
+        // Allocate Vertex Array0
+        GLArrayDataServer vertices0 = GLSLMiscHelper.createRSVertices0(gl, st, -1); 
+        vertices0.enableBuffer(gl, false);
+        
+        // Allocate Vertex Array1
+        GLArrayDataServer vertices1 = GLSLMiscHelper.createRSVertices1(gl, st); 
+        vertices1.enableBuffer(gl, false);
+        
+        // Allocate Color Array0
+        GLArrayDataServer colors0 = GLSLMiscHelper.createRSColors0(gl, st, -1);
+        colors0.enableBuffer(gl, false);
+        
+        // Allocate Color Array1
+        GLArrayDataServer colors1 = GLSLMiscHelper.createRSColors1(gl, st);
+        colors1.enableBuffer(gl, false);
+        
+        // misc GL setup
+        gl.glClearColor(0, 0, 0, 1);
+        gl.glEnable(GL2ES2.GL_DEPTH_TEST);
+
+        // reshape
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_PROJECTION);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.gluPerspective(45.0F, (float) window.getWidth() / (float) window.getHeight(), 1.0F, 100.0F);
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_MODELVIEW);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.glTranslatef(0, 0, -10);
+        st.glUniform(gl, pmvMatrixUniform);
+
+        // validation ..
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices0, colors0, true, 1, 0);
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices1, colors1, true, 2, 0);
+        
+        long t0 = System.currentTimeMillis();
+        int frames;
+        // warmup ..
+        for(frames=0; frames<frames_warmup; frames++) {
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices0, colors0, true);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices1, colors1, true);
+        }        
+        // measure ..
+        for(frames=0; frames<frames_perftest; frames++) {
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices0, colors0, true);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices1, colors1, true);
+        }        
+        final long t1 = System.currentTimeMillis();
+        final long dt = t1 - t0;        
+        final double fps = ( frames * 1000.0 ) / (double) dt;
+        final String fpsS = String.valueOf(fps);        
+        final int fpsSp = fpsS.indexOf('.');        
+        System.err.println("testShaderState01PerformanceDouble: "+dt/1000.0 +"s: "+ frames + "f, " + fpsS.substring(0, fpsSp+2) + " fps, "+dt/frames+" ms/f");        
+        
+        // cleanup
+        st.glUseProgram(gl, false);
+        sp.release(gl, true);
+        vertices1.destroy(gl);
+        vertices0.destroy(gl);
+        colors0.destroy(gl);
+        colors1.destroy(gl);
+        context.release();
+        window.destroy();        
+    }
+    
+    public static void main(String args[]) throws IOException {
+        System.err.println("main - start");
+        boolean wait = false;
+        for(int i=0; i<args.length; i++) {
+            if(args[i].equals("-time")) {
+                durationPerTest = MiscUtils.atoi(args[++i], (int)durationPerTest);
+            }
+            if(args[i].equals("-wait")) {
+                wait = true;
+            }
+        }
+        if(wait) {
+            while(-1 == System.in.read()) ;
+            TestGLSLShaderState01NEWT tst = new TestGLSLShaderState01NEWT();
+            try {
+                tst.testShaderState01PerformanceDouble();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        } else {
+            String tstname = TestGLSLShaderState01NEWT.class.getName();
+            org.junit.runner.JUnitCore.main(tstname);
+        }
+        System.err.println("main - end");
+    }    
+}
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/glsl/TestGLSLShaderState02NEWT.java b/src/test/com/jogamp/opengl/test/junit/jogl/glsl/TestGLSLShaderState02NEWT.java
new file mode 100644
index 000000000..7f41dbf30
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/glsl/TestGLSLShaderState02NEWT.java
@@ -0,0 +1,346 @@
+/**
+ * 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 com.jogamp.opengl.test.junit.jogl.glsl;
+
+import com.jogamp.newt.opengl.GLWindow;
+import com.jogamp.opengl.util.GLArrayDataServer;
+import com.jogamp.opengl.util.PMVMatrix;
+import com.jogamp.opengl.util.glsl.ShaderCode;
+import com.jogamp.opengl.util.glsl.ShaderProgram;
+import com.jogamp.opengl.util.glsl.ShaderState;
+import com.jogamp.opengl.test.junit.jogl.demos.es2.RedSquare0;
+import com.jogamp.opengl.test.junit.util.MiscUtils;
+import com.jogamp.opengl.test.junit.util.UITestCase;
+
+import java.io.IOException;
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLUniformData;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Testing different vertex attribute (VA) data sets on one shader
+ * and shader state in general.
+ */
+public class TestGLSLShaderState02NEWT extends UITestCase {
+    static long durationPerTest = 10; // ms
+    static int frames_perftest =  5000; // frames
+    static int frames_warmup   =   100; // frames
+
+    static final int vertices0_loc = 1;
+    static final int colors0_loc = 2;
+    
+    @Test
+    public void testShaderState01Validation() throws InterruptedException {
+        // preset ..
+        GLWindow window = GLSLMiscHelper.createWindow();
+        GLContext context = window.getContext();
+        context.setSynchronized(true);
+        context.makeCurrent();
+        GL2ES2 gl = context.getGL().getGL2ES2();
+
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        // test code ..        
+        ShaderState st = new ShaderState();
+        
+        ShaderCode rsVp0 = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+        ShaderCode rsFp0 = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+        ShaderCode rsFp1 = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader2");
+
+        ShaderProgram sp1 = new ShaderProgram();
+        sp1.add(rsVp0);
+        sp1.add(rsFp1);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertTrue(0>sp1.program());        
+        sp1.init(gl);
+        Assert.assertTrue(0<=sp1.program()); 
+        Assert.assertTrue(!sp1.inUse());
+        Assert.assertTrue(!sp1.linked());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertTrue(sp1.link(gl, System.err));
+        Assert.assertTrue(sp1.linked());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        ShaderProgram sp0 = new ShaderProgram();        
+        sp0.add(rsVp0);
+        sp0.add(rsFp0);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        Assert.assertTrue(0>sp0.program());        
+        sp0.init(gl);
+        Assert.assertTrue(0<=sp0.program()); 
+        Assert.assertTrue(!sp0.inUse());
+        Assert.assertTrue(!sp0.linked());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());        
+                
+        st.attachShaderProgram(gl, sp0);
+        
+        // Allocate Vertex Array0
+        GLArrayDataServer vertices0 = GLSLMiscHelper.createRSVertices0(gl, st, vertices0_loc);
+        System.err.println("vertices0: " + vertices0);        
+        vertices0.enableBuffer(gl, false);
+        Assert.assertEquals(vertices0_loc, vertices0.getLocation());
+        
+        // Allocate Color Array0
+        GLArrayDataServer colors0 = GLSLMiscHelper.createRSColors0(gl, st, colors0_loc);
+        System.err.println("colors0: " + colors0);
+        colors0.enableBuffer(gl, false);
+        Assert.assertEquals(colors0_loc, colors0.getLocation());
+                               
+        Assert.assertTrue(sp0.link(gl, System.err));
+        Assert.assertTrue(sp0.linked());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        Assert.assertEquals(vertices0_loc, vertices0.getLocation());
+        Assert.assertEquals(vertices0_loc, st.glGetAttribLocation(gl, vertices0.getName()));
+        Assert.assertEquals(vertices0_loc, gl.glGetAttribLocation(st.shaderProgram().program(), vertices0.getName()));
+        
+        Assert.assertEquals(colors0_loc, colors0.getLocation());
+        Assert.assertEquals(colors0_loc, st.glGetAttribLocation(gl, colors0.getName()));
+        Assert.assertEquals(colors0_loc, gl.glGetAttribLocation(st.shaderProgram().program(), colors0.getName()));
+        
+        Assert.assertEquals(null, ShaderState.getShaderState(gl));
+        st.glUseProgram(gl, true);
+        Assert.assertTrue(sp0.inUse());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertEquals(st, ShaderState.getShaderState(gl));        
+        
+        // setup mgl_PMVMatrix
+        PMVMatrix pmvMatrix = new PMVMatrix();
+        GLUniformData pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf());
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        st.glUniform(gl, pmvMatrixUniform);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertEquals(pmvMatrixUniform, st.getUniform("mgl_PMVMatrix"));
+        
+        // Allocate Vertex Array1
+        GLArrayDataServer vertices1 = GLSLMiscHelper.createRSVertices1(gl, st);
+        System.err.println("vertices1: " + vertices1);
+        vertices1.enableBuffer(gl, false);
+        
+        // Allocate Color Array1
+        GLArrayDataServer colors1 = GLSLMiscHelper.createRSColors1(gl, st);
+        System.err.println("colors1: " + colors1);
+        colors1.enableBuffer(gl, false);
+        
+        // misc GL setup
+        gl.glClearColor(0, 0, 0, 1);
+        gl.glEnable(GL2ES2.GL_DEPTH_TEST);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+
+        // reshape
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_PROJECTION);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.gluPerspective(45.0F, (float) window.getWidth() / (float) window.getHeight(), 1.0F, 100.0F);
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_MODELVIEW);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.glTranslatef(0, 0, -10);
+        st.glUniform(gl, pmvMatrixUniform);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        // display #1 vertices0 / colors0 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices0, colors0, true, 1, durationPerTest);
+
+        // display #2 #1 vertices1 / colors1 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices1, colors1, true, 2, durationPerTest);
+        
+        // display #3 vertices0 / colors0 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices0, colors0, true, 3, durationPerTest);
+
+        // SP1
+        // both are currently not attached to ShaderState, hence we have to reset their location as well
+        vertices0.setLocation(-1);
+        colors0.setLocation(-1);
+        
+        st.attachShaderProgram(gl, sp1);
+        
+        // display #1 vertices0 / colors0 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices0, colors0, true, 10, durationPerTest);
+
+        // display #2 #1 vertices1 / colors1 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices1, colors1, true, 20, durationPerTest);
+        
+        // display #3 vertices0 / colors0 (post-disable)
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices0, colors0, true, 30, durationPerTest);
+        
+        // cleanup
+        vertices1.destroy(gl);
+        vertices0.destroy(gl);
+        colors0.destroy(gl);
+        colors1.destroy(gl);
+        st.glUseProgram(gl, false);
+        sp0.release(gl, true);
+        context.release();
+        window.destroy();        
+    }
+
+    @Test
+    public void testShaderState01PerformanceDouble() throws InterruptedException {
+        // preset ..
+        GLWindow window = GLSLMiscHelper.createWindow();
+        GLContext context = window.getContext();
+        context.setSynchronized(true);
+        context.makeCurrent();
+        GL2ES2 gl = context.getGL().getGL2ES2();
+
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        
+        // test code ..        
+        ShaderState st = new ShaderState();
+        
+        ShaderCode rsVp0 = ShaderCode.create(gl, GL2ES2.GL_VERTEX_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+        ShaderCode rsFp0 = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader");
+        ShaderCode rsFp1 = ShaderCode.create(gl, GL2ES2.GL_FRAGMENT_SHADER, 1, RedSquare0.class,
+                "shader", "shader/bin", "RedSquareShader2");
+
+        ShaderProgram sp1 = new ShaderProgram();
+        sp1.add(rsVp0);
+        sp1.add(rsFp1);
+        Assert.assertEquals(GL.GL_NO_ERROR, gl.glGetError());
+        Assert.assertTrue(0>sp1.program());        
+        sp1.init(gl);
+        Assert.assertTrue(sp1.link(gl, System.err));
+        
+        ShaderProgram sp0 = new ShaderProgram();
+        sp0.add(rsVp0);
+        sp0.add(rsFp0);
+        
+        sp0.init(gl);
+        Assert.assertTrue(sp0.link(gl, System.err));
+        
+        st.attachShaderProgram(gl, sp0);        
+        st.glUseProgram(gl, true);
+        
+        // setup mgl_PMVMatrix
+        PMVMatrix pmvMatrix = new PMVMatrix();
+        GLUniformData pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf());        
+        st.glUniform(gl, pmvMatrixUniform);
+        
+        // Allocate Vertex Array0
+        GLArrayDataServer vertices0 = GLSLMiscHelper.createRSVertices0(gl, st, -1); 
+        vertices0.enableBuffer(gl, false);
+        
+        // Allocate Vertex Array1
+        GLArrayDataServer vertices1 = GLSLMiscHelper.createRSVertices1(gl, st); 
+        vertices1.enableBuffer(gl, false);
+        
+        // Allocate Color Array0
+        GLArrayDataServer colors0 = GLSLMiscHelper.createRSColors0(gl, st, -1);
+        colors0.enableBuffer(gl, false);
+        
+        // Allocate Color Array1
+        GLArrayDataServer colors1 = GLSLMiscHelper.createRSColors1(gl, st);
+        colors1.enableBuffer(gl, false);
+        
+        // misc GL setup
+        gl.glClearColor(0, 0, 0, 1);
+        gl.glEnable(GL2ES2.GL_DEPTH_TEST);
+
+        // reshape
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_PROJECTION);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.gluPerspective(45.0F, (float) window.getWidth() / (float) window.getHeight(), 1.0F, 100.0F);
+        pmvMatrix.glMatrixMode(PMVMatrix.GL_MODELVIEW);
+        pmvMatrix.glLoadIdentity();
+        pmvMatrix.glTranslatef(0, 0, -10);
+        st.glUniform(gl, pmvMatrixUniform);
+
+        // validation ..
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices0, colors0, true, 1, 0);
+        GLSLMiscHelper.displayVCArrays(window, gl, true, vertices1, colors1, true, 2, 0);
+        
+        long t0 = System.currentTimeMillis();
+        int frames;
+        // warmup ..
+        for(frames=0; frames<frames_warmup; frames++) {
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices0, colors0, true);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices1, colors1, true);
+        }        
+        // measure ..
+        for(frames=0; frames<frames_perftest; frames+=2) {
+            // SP0
+            vertices0.setLocation(-1);
+            colors0.setLocation(-1);        
+            st.attachShaderProgram(gl, sp0);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices0, colors0, true);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices1, colors1, true);
+            // SP1
+            vertices0.setLocation(-1);
+            colors0.setLocation(-1);        
+            st.attachShaderProgram(gl, sp1);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices0, colors0, true);
+            GLSLMiscHelper.displayVCArraysNoChecks(window, gl, true, vertices1, colors1, true);
+        }
+        
+        final long t1 = System.currentTimeMillis();
+        final long dt = t1 - t0;        
+        final double fps = ( frames * 1000.0 ) / (double) dt;
+        final String fpsS = String.valueOf(fps);        
+        final int fpsSp = fpsS.indexOf('.');        
+        System.err.println("testShaderState01PerformanceDouble: "+dt/1000.0 +"s: "+ frames + "f, " + fpsS.substring(0, fpsSp+2) + " fps, "+dt/frames+" ms/f");        
+        
+        // cleanup
+        st.glUseProgram(gl, false);
+        sp0.release(gl, true);
+        vertices1.destroy(gl);
+        vertices0.destroy(gl);
+        colors0.destroy(gl);
+        colors1.destroy(gl);
+        context.release();
+        window.destroy();        
+    }
+    
+    public static void main(String args[]) throws IOException {
+        System.err.println("main - start");
+        boolean wait = false;
+        for(int i=0; i<args.length; i++) {
+            if(args[i].equals("-time")) {
+                durationPerTest = MiscUtils.atoi(args[++i], (int)durationPerTest);
+            }
+            if(args[i].equals("-wait")) {
+                wait = true;
+            }
+        }
+        if(wait) {
+            while(-1 == System.in.read()) ;
+        }
+        String tstname = TestGLSLShaderState02NEWT.class.getName();
+        org.junit.runner.JUnitCore.main(tstname);
+        System.err.println("main - end");
+    }    
+}