diff options
Diffstat (limited to 'src/test/com')
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"); + } +} |