diff options
Diffstat (limited to 'src/demos/es2/perftst')
18 files changed, 1096 insertions, 0 deletions
diff --git a/src/demos/es2/perftst/PerfModule.java b/src/demos/es2/perftst/PerfModule.java new file mode 100644 index 0000000..1a6cda1 --- /dev/null +++ b/src/demos/es2/perftst/PerfModule.java @@ -0,0 +1,95 @@ +package demos.es2.perftst; + +import java.nio.*; +import javax.media.opengl.*; + +import com.sun.opengl.util.*; +import com.sun.opengl.util.glsl.*; + +public abstract class PerfModule { + + public abstract void initShaderState(GL2ES2 gl); + + public abstract void run(GLAutoDrawable drawable, int loops); + + ShaderState st = null; + + public void initShaderState(GL2ES2 gl, String vShaderName, String fShaderName) { + if(st!=null) return; + + long t0, t1; + + st = new ShaderState(); + + // Create & Compile the shader objects + ShaderCode vp = ShaderCode.create(gl, gl.GL_VERTEX_SHADER, 1, Perftst.class, + "shader", "shader/bin", vShaderName); + ShaderCode fp = ShaderCode.create(gl, gl.GL_FRAGMENT_SHADER, 1, Perftst.class, + "shader", "shader/bin", fShaderName); + + // Create & Link the shader program + ShaderProgram sp = new ShaderProgram(); + sp.add(vp); + sp.add(fp); + + t0 = System.currentTimeMillis(); + + if(!sp.link(gl, System.err)) { + throw new GLException("Couldn't link program: "+sp); + } + + t1 = System.currentTimeMillis(); + + long dt = t1-t0; + + System.out.println("shader creation: "+dt+" ms"); + + // Let's manage all our states using ShaderState. + st.attachShaderProgram(gl, sp); + + st.glUseProgram(gl, true); + } + + public static final void put(Buffer buffer, int type, float v) { + switch (type) { + case GL.GL_UNSIGNED_BYTE: + ((ByteBuffer)buffer).put((byte)(v*(float)0xFF)); + break; + case GL.GL_BYTE: + ((ByteBuffer)buffer).put((byte)(v*(float)0x7F)); + break; + case GL.GL_UNSIGNED_SHORT: + ((ShortBuffer)buffer).put((short)(v*(float)0xFFFF)); + break; + case GL.GL_SHORT: + ((ShortBuffer)buffer).put((short)(v*(float)0x7FFF)); + break; + case GL.GL_FLOAT: + ((FloatBuffer)buffer).put(v); + break; + case GL.GL_FIXED: + ((IntBuffer)buffer).put(FixedPoint.toFixed(v)); + break; + } + } + + public static final String getTypeName(int type) { + switch (type) { + case GL.GL_UNSIGNED_BYTE: + return "GL_UNSIGNED_BYTE"; + case GL.GL_BYTE: + return "GL_BYTE"; + case GL.GL_UNSIGNED_SHORT: + return "GL_UNSIGNED_SHORT"; + case GL.GL_SHORT: + return "GL_SHORT"; + case GL.GL_FLOAT: + return "GL_FLOAT"; + case GL.GL_FIXED: + return "GL_FIXED"; + } + return null; + } + +} + diff --git a/src/demos/es2/perftst/PerfTextLoad.java b/src/demos/es2/perftst/PerfTextLoad.java new file mode 100755 index 0000000..55aad9a --- /dev/null +++ b/src/demos/es2/perftst/PerfTextLoad.java @@ -0,0 +1,219 @@ +package demos.es2.perftst; + +import java.nio.*; +import java.io.*; +import java.net.*; +import javax.media.opengl.*; +import com.sun.opengl.util.*; +import com.sun.opengl.util.texture.*; + +import com.sun.javafx.newt.*; +import com.sun.javafx.newt.opengl.*; + +public class PerfTextLoad extends PerfModule { + static final int MAX_TEXTURE_ENGINES = 8; + + public PerfTextLoad() { + } + + public void initShaderState(GL2ES2 gl) { + initShaderState(gl, "vbo-vert-text", "ftext"); + } + + Texture[] textures = null; + TextureData[] textDatas = null; + + protected void runOneSet(GLAutoDrawable drawable, String textBaseName, int numObjs, int numTextures, int loops) { + GL2ES2 gl = drawable.getGL().getGL2ES2(); + + if(numTextures>MAX_TEXTURE_ENGINES) { + throw new GLException("numTextures must be within 1.."+MAX_TEXTURE_ENGINES); + } + + String textName = null; + textDatas = new TextureData[numObjs]; + textures = new Texture[numTextures]; + try { + for(int i=0; i<numObjs; i++) { + textName = "data/"+textBaseName+"."+(i+1)+".tga"; + URL urlText = Locator.getResource(Perftst.class, textName); + if(urlText==null) { + throw new RuntimeException("couldn't fetch "+textName); + } + textDatas[i] = TextureIO.newTextureData(urlText.openStream(), false, TextureIO.TGA); + System.out.println(textBaseName+": "+textDatas[i]); + } + + for(int i=0; i<numTextures; i++) { + gl.glActiveTexture(i); + textures[i] = new Texture(GL.GL_TEXTURE_2D); + } + } catch (IOException ioe) { + System.err.println("couldn't fetch "+textName); + throw new RuntimeException(ioe); + } + + // + // Vertices Data setup + // + + st.glUseProgram(gl, true); + + GLArrayDataServer vertices = GLArrayDataServer.createGLSL(gl, "mgl_Vertex", 2, GL.GL_FLOAT, true, 4, GL.GL_STATIC_DRAW); + { + FloatBuffer vb = (FloatBuffer)vertices.getBuffer(); + vb.put(0f); vb.put(0f); + vb.put(1f); vb.put(0f); + vb.put(0f); vb.put(1f); + vb.put(1f); vb.put(1f); + } + vertices.seal(gl, true); + + GLArrayDataServer texCoords = GLArrayDataServer.createGLSL(gl, "mgl_MultiTexCoord0", 2, GL.GL_FLOAT, true, 4, GL.GL_STATIC_DRAW); + { + FloatBuffer cb = (FloatBuffer)texCoords.getBuffer(); + cb.put(0f); cb.put(0f); + cb.put(1f); cb.put(0f); + cb.put(0f); cb.put(1f); + cb.put(1f); cb.put(1f); + } + texCoords.seal(gl, true); + + // + // texture setup + // + long[] tU = new long[numObjs+1]; + tU[0] = System.currentTimeMillis(); + for(int j=0; j<numTextures; j++) { + gl.glActiveTexture(j); + textures[j].updateImage(textDatas[0]); + tU[j+1] = System.currentTimeMillis(); + } + + GLUniformData activeTexture = new GLUniformData("mgl_ActiveTexture", 0); + st.glUniform(gl, activeTexture); + + // + // run loops + // + + long dtC, dt, dt2, dt3, dtF, dtS, dtT; + long[][] tC = new long[loops][numObjs]; + long[][] t0 = new long[loops][numObjs]; + long[][][] t1 = new long[loops][numObjs][numTextures]; + long[][][] t2 = new long[loops][numObjs][numTextures]; + long[][][] t3 = new long[loops][numObjs][numTextures]; + long[][] tF = new long[loops][numObjs]; + long[][] tS = new long[loops][numObjs]; + + for(int i=0; i<loops; i++) { + for(int j=0; j<numObjs; j++) { + tC[i][j] = System.currentTimeMillis(); + + gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT); + + t0[i][j] = System.currentTimeMillis(); + + for(int k=0; k<numTextures; k++) { + gl.glActiveTexture(GL.GL_TEXTURE0+k); + textures[k].enable(); + textures[k].bind(); + activeTexture.setData(k); + st.glUniform(gl, activeTexture); + + t1[i][j][k] = System.currentTimeMillis(); + + textures[k].updateSubImage(textDatas[j], 0, 0, 0); + + t2[i][j][k] = System.currentTimeMillis(); + + gl.glDrawArrays(GL.GL_TRIANGLE_STRIP, 0, vertices.getElementNumber()); + + t3[i][j][k] = System.currentTimeMillis(); + } + gl.glFinish(); + + tF[i][j] = System.currentTimeMillis(); + + drawable.swapBuffers(); + + tS[i][j] = System.currentTimeMillis(); + + /*try { + Thread.sleep(100); + } catch (Exception e) {} */ + } + + } + + int textBytes = 0; + for(int j=0; j<numObjs; j++) { + textBytes += textDatas[j].getEstimatedMemorySize(); + } + textBytes*=numTextures; + + dt = 0; + for(int i=1; i<loops; i++) { + for(int j=0; j<numObjs; j++) { + dt += tS[i][j] - tC[i][j]; + } + } + + System.out.println(""); + System.out.println("Texture "+textBaseName+", loops "+loops+", textures "+numTextures+", objects "+numObjs+ + ", total bytes "+textBytes+", total time: "+dt + + "ms, fps(-1): "+(((loops-1)*numObjs*1000)/dt)+ + ",\n text kB/s: " + ( ((double)(loops*textBytes)/1024.0) / ((double)dt/1000.0) ) ); + + for(int i=0; i<loops; i++) { + dtC = 0; + dtF = 0; + dtS = 0; + dtT = 0; + for(int j=0; j<numObjs; j++) { + dtC += t0[i][j] - tC[i][j]; + dtF += tF[i][j] - t3[i][j][numTextures-1]; + dtS += tS[i][j] - tF[i][j]; + dtT += tS[i][j] - tC[i][j]; + } + if(dtT<=0) dtT=1; + System.out.println("\tloop "+i+": clear "+dtC+"ms, finish "+dtF+", swap "+dtS+"ms, total: "+ dtT+"ms, fps "+(numObjs*1000)/dtT); + /* + for(int j=0; j<dummyUni.length; j++) { + dt = t1[i][j] - t0[i]; + dt2= t2[i][j] - t1[i][j]; + dt3= t3[i][j] - t2[i][j]; + dtT= dt+dt2+dt3; + System.out.println("\t\tobj "+j+": setup "+dt +"ms, update "+dt2 +"ms, draw "+dt3+"ms, total: "+ dtT); + } */ + } + System.out.println("*****************************************************************"); + + st.glUseProgram(gl, false); + + for(int i=0; i<numTextures; i++) { + textures[i].disable(); + textures[i].dispose(); + textures[i]=null; + } + for(int i=0; i<numObjs; i++) { + textDatas[i] = null; + } + textures=null; + textDatas=null; + System.gc(); + try { + Thread.sleep(100); + } catch (Exception e) {} + System.gc(); + } + + public void run(GLAutoDrawable drawable, int loops) { + runOneSet(drawable, "bob2.64x64", 33, 1, loops); + runOneSet(drawable, "bob2.128x128", 33, 1, loops); + runOneSet(drawable, "bob2.128x128", 4, 1, loops); + runOneSet(drawable, "bob2.256x256", 4, 1, loops); + runOneSet(drawable, "bob2.512x512", 4, 1, loops); + } + +} diff --git a/src/demos/es2/perftst/PerfUniLoad.java b/src/demos/es2/perftst/PerfUniLoad.java new file mode 100755 index 0000000..a87d386 --- /dev/null +++ b/src/demos/es2/perftst/PerfUniLoad.java @@ -0,0 +1,189 @@ +package demos.es2.perftst; + +import java.nio.*; +import javax.media.opengl.*; +import com.sun.opengl.util.*; + +import com.sun.javafx.newt.*; +import com.sun.javafx.newt.opengl.*; + +public class PerfUniLoad extends PerfModule { + static final int MAX_ARRAYS = 12; + static final int MAX_ARRAY_ELEM = 16; + + GLUniformData[] dummyA, dummyB, dummyC; + final int dataType=GL.GL_FLOAT; + + public PerfUniLoad() { + } + + public void initShaderState(GL2ES2 gl) { + initShaderState(gl, "uni-vert-col", "fcolor"); + } + + protected void runOneSet(GLAutoDrawable drawable, int numObjs, int numArrayElem, int loops) { + GL2ES2 gl = drawable.getGL().getGL2ES2(); + + // + // Vertices Data setup + // + + if(numObjs>MAX_ARRAYS) { + throw new GLException("numObjs must be within 0.."+MAX_ARRAYS); + } + + if(numArrayElem>MAX_ARRAY_ELEM) { + throw new GLException("numArrayElem must be within 0.."+MAX_ARRAY_ELEM); + } + + st.glUseProgram(gl, true); + + GLArrayDataServer vertices = GLArrayDataServer.createGLSL(gl, "mgl_Vertex", 3, GL.GL_FLOAT, true, 4, GL.GL_STATIC_DRAW); + { + FloatBuffer vb = (FloatBuffer)vertices.getBuffer(); + vb.put(0f); vb.put(0f); vb.put(0f); + vb.put(1f); vb.put(0f); vb.put(0f); + vb.put(0f); vb.put(1f); vb.put(0f); + vb.put(1f); vb.put(1f); vb.put(0f); + } + vertices.seal(gl, true); + + GLArrayDataServer colors = GLArrayDataServer.createGLSL(gl, "mgl_Color", 4, GL.GL_FLOAT, true, 4, GL.GL_STATIC_DRAW); + { + FloatBuffer cb = (FloatBuffer)colors.getBuffer(); + cb.put(0f); cb.put(0f); cb.put(0f); cb.put(1f); + cb.put(1f); cb.put(0f); cb.put(0f); cb.put(1f); + cb.put(0f); cb.put(1f); cb.put(0f); cb.put(1f); + cb.put(0f); cb.put(0f); cb.put(1f); cb.put(1f); + } + colors.seal(gl, true); + + // + // Uniform Data setup + // + + GLUniformData[] dummyUni = new GLUniformData[numObjs]; + + float x=0f, y=0f, z=0f, w=0f; + + for(int i=0; i<numObjs; i++) { + FloatBuffer fb = BufferUtil.newFloatBuffer(4*numArrayElem); + + for(int j=0; j<numArrayElem; j++) { + // Fill them up + fb.put(x); + fb.put(y); + fb.put(z); + fb.put(w); + if(x==0f) x=1f; + else if(x==1f) { x=0f; y+=0.01f; } + if(y>1f) { x=0f; y=0f; z+=0.01f; } + } + fb.flip(); + + dummyUni[i] = new GLUniformData("mgl_Dummy"+i, 4, fb); + } + + // + // run loops + // + + long dtC, dt, dt2, dt3, dtF, dtS, dtT; + long[] tC = new long[loops]; + long[] t0 = new long[loops]; + long[][] t1 = new long[loops][numObjs]; + long[][] t2 = new long[loops][numObjs]; + long[] tF = new long[loops]; + long[] tS = new long[loops]; + + for(int i=0; i<loops; i++) { + tC[i] = System.currentTimeMillis(); + + gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT); + + t0[i] = System.currentTimeMillis(); + + for(int j=0; j<numObjs; j++) { + st.glUniform(gl, dummyUni[j]); + + t1[i][j] = System.currentTimeMillis(); + + gl.glDrawArrays(GL.GL_LINE_STRIP, 0, vertices.getElementNumber()); + + t2[i][j] = System.currentTimeMillis(); + } + + gl.glFinish(); + + tF[i] = System.currentTimeMillis(); + + drawable.swapBuffers(); + + tS[i] = System.currentTimeMillis(); + } + + int uniElements = numObjs * numArrayElem ; + int uniBytes = uniElements * BufferUtil.SIZEOF_FLOAT; + + dt = 0; + for(int i=1; i<loops; i++) { + dt += tS[i] - tC[i]; + } + + System.out.println(""); + System.out.println("Loops "+loops+", uniform arrays "+dummyUni.length+", type FLOAT"+ + ", uniforms array size "+numArrayElem+ + ",\n total elements "+uniElements+ + ", total bytes "+uniBytes+", total time: "+dt + + "ms, fps(-1): "+(((loops-1)*1000)/dt)+ + ",\n uni elem/s: " + ((double)(loops*uniElements)/((double)dt/1000.0))); + + for(int i=0; i<loops; i++) { + dtC= t0[i] - tC[i]; + dtF= tF[i] - t2[i][dummyUni.length-1]; + dtS= tS[i] - tF[i]; + dtT= tS[i] - tC[i]; + if(dtT<=0) dtT=1; + System.out.println("\tloop "+i+": clear "+dtC+"ms, finish "+dtF+", swap "+dtS+"ms, total: "+ dtT+"ms, fps "+1000/dtT); + /* + for(int j=0; j<dummyUni.length; j++) { + dt = t1[i][j] - t0[i]; + dt2= t2[i][j] - t1[i][j]; + dtT= dt+dt2; + System.out.println("\t\tobj "+j+": uniform "+dt +"ms, draw "+dt2+"ms, total: "+ dtT); + } */ + } + System.out.println("*****************************************************************"); + + + st.glUseProgram(gl, false); + + try { + Thread.sleep(100); + } catch (Exception e) {} + } + + public void run(GLAutoDrawable drawable, int loops) { + runOneSet(drawable, 1, 1, loops); + + runOneSet(drawable, 4, 1, loops); + runOneSet(drawable, 1, 4, loops); + + runOneSet(drawable, 8, 1, loops); + runOneSet(drawable, 1, 8, loops); + + if(MAX_ARRAYS>8) { + runOneSet(drawable, MAX_ARRAYS, 1, loops); + runOneSet(drawable, 1, MAX_ARRAYS, loops); + } + runOneSet(drawable, 1, 16, loops); + + runOneSet(drawable, 2, 16, loops); + runOneSet(drawable, 4, 16, loops); + runOneSet(drawable, 8, 16, loops); + if(MAX_ARRAYS>8) { + runOneSet(drawable, MAX_ARRAYS, 16, loops); + } + } + +} diff --git a/src/demos/es2/perftst/PerfVBOLoad.java b/src/demos/es2/perftst/PerfVBOLoad.java new file mode 100755 index 0000000..376ab0a --- /dev/null +++ b/src/demos/es2/perftst/PerfVBOLoad.java @@ -0,0 +1,239 @@ +package demos.es2.perftst; + +import java.nio.*; +import javax.media.opengl.*; +import com.sun.opengl.util.*; + +import com.sun.javafx.newt.*; +import com.sun.javafx.newt.opengl.*; + +public class PerfVBOLoad extends PerfModule { + + public PerfVBOLoad() { + } + + public void initShaderState(GL2ES2 gl) { + initShaderState(gl, "vbo-vert-col", "fcolor"); + } + + protected void runOneSet(GLAutoDrawable drawable, int dataType, int numObjs, int numVertices, int loops, boolean useVBO) { + GL2ES2 gl = drawable.getGL().getGL2ES2(); + + // + // data setup + // + + GLArrayDataServer[] vertices = new GLArrayDataServer[numObjs]; + GLArrayDataServer[] colors = new GLArrayDataServer[numObjs]; + + float x=0f, y=0f, z=0f; + float r=1f, g=1f, b=1f; + + for(int i=0; i<numObjs; i++) { + vertices[i] = GLArrayDataServer.createGLSL(gl, "mgl_Vertex", 3, dataType, true, numVertices, GL.GL_STATIC_DRAW); + vertices[i].setVBOUsage(useVBO); + { + Buffer verticeb = vertices[i].getBuffer(); + for(int j=0; j<numVertices; j++) { + // Fill them up + put(verticeb, dataType, x); + put(verticeb, dataType, y); + put(verticeb, dataType, z); + if(x==0f) x=1f; + else if(x==1f) { x=0f; y+=0.01f; } + if(y>1f) { x=0f; y=0f; z+=0.01f; } + } + } + colors[i] = GLArrayDataServer.createGLSL(gl, "mgl_Color", 4, dataType, true, numVertices, GL.GL_STATIC_DRAW); + colors[i].setVBOUsage(useVBO); + { + // Fill them up + Buffer colorb = colors[i].getBuffer(); + for(int j =0; j<numVertices; j++) { + put(colorb, dataType, r); + put(colorb, dataType, g); + put(colorb, dataType, b); + put(colorb, dataType, 1f-(float)i/10); + if(r<=1f) r+=0.01f; + else if(g<=1f) g+=0.01f; + else if(b<=1f) b+=0.01f; + else { r=0f; g=0f; b=0f; } + } + } + } + + // + // run loops + // + + long dtC, dt, dt2, dt3, dtF, dtS, dtT; + long[] tC = new long[loops]; + long[] t0 = new long[loops]; + long[][] t1 = new long[loops][numObjs]; + long[][] t2 = new long[loops][numObjs]; + long[][] t3 = new long[loops][numObjs]; + long[] tF = new long[loops]; + long[] tS = new long[loops]; + + // Push the 1st uniform down the path + st.glUseProgram(gl, true); + + for(int i=0; i<loops; i++) { + tC[i] = System.currentTimeMillis(); + + gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT); + + t0[i] = System.currentTimeMillis(); + + for(int j=0; j<numObjs; j++) { + if(i==0) { + vertices[j].seal(gl, true); + } else if(numObjs>1) { + // we need to re-enable the buffer, + // incl. the vertex attribute refresh + // in case we switch to another buffer + vertices[j].enableBuffer(gl, true); + } + + t1[i][j] = System.currentTimeMillis(); + + if(i==0) { + colors[j].seal(gl, true); + } else { + colors[j].enableBuffer(gl, true); + } + + t2[i][j] = System.currentTimeMillis(); + + gl.glDrawArrays(GL.GL_LINE_STRIP, 0, vertices[j].getElementNumber()); + + if(numObjs>1) { + vertices[j].enableBuffer(gl, false); + colors[j].enableBuffer(gl, false); + } + + t3[i][j] = System.currentTimeMillis(); + } + + gl.glFinish(); + + tF[i] = System.currentTimeMillis(); + + drawable.swapBuffers(); + + tS[i] = System.currentTimeMillis(); + } + + if(numObjs==1) { + vertices[0].enableBuffer(gl, false); + colors[0].enableBuffer(gl, false); + } + + int verticesElements = vertices[0].getElementNumber() * numObjs; + int verticesBytes = verticesElements * vertices[0].getComponentSize()* vertices[0].getComponentNumber(); + int colorsElements = colors[0].getElementNumber() * colors.length; + int colorsBytes = colorsElements * colors[0].getComponentSize()* colors[0].getComponentNumber(); + + dt = 0; + for(int i=1; i<loops; i++) { + dt += tS[i] - tC[i]; + } + + System.out.println(""); + System.out.println("Loops "+loops+", useVBO "+useVBO+", objects "+numObjs+", type "+getTypeName(dataType)+ + ", vertices p.o. "+vertices[0].getElementNumber()+ + ", colors p.o. "+colors[0].getElementNumber()+ + ",\n total elements "+(verticesElements+colorsElements)+ + ", total bytes "+(verticesBytes+colorsBytes)+", total time: "+dt + + "ms, fps(-1): "+(((loops-1)*1000)/dt)+ + ",\n col.vert./s: " + ((double)(loops*verticesElements)/((double)dt/1000.0))); + + for(int i=0; i<loops; i++) { + dtC= t0[i] - tC[i]; + dtF= tF[i] - t3[i][numObjs-1]; + dtS= tS[i] - tF[i]; + dtT= tS[i] - tC[i]; + if(dtT<=0) dtT=1; + System.out.println("\tloop "+i+": clear "+dtC+"ms, finish "+dtF+", swap "+dtS+"ms, total: "+ dtT+"ms, fps "+1000/dtT); + /* + for(int j=0; j<numObjs; j++) { + dt = t1[i][j] - t0[i]; + dt2= t2[i][j] - t1[i][j]; + dt3= t3[i][j] - t2[i][j]; + dtT= dt+dt2+dt3; + System.out.println("\t\tobj "+j+": vertices "+dt +"ms, colors "+dt2+"ms, draw "+dt3+"ms, total: "+ dtT); + } */ + } + System.out.println("*****************************************************************"); + + st.glUseProgram(gl, false); + + for(int i=0; i<numObjs; i++) { + vertices[i].destroy(gl); + colors[i].destroy(gl); + vertices[i]=null; + colors[i]=null; + } + vertices=null; + colors=null; + System.gc(); + + try { + Thread.sleep(100); + } catch (Exception e) {} + } + + protected void runOneSet(GLAutoDrawable drawable, int numObjs, int numVertices, int loops) { + runOneSet(drawable, GL.GL_UNSIGNED_BYTE, numObjs, numVertices, loops, true); + runOneSet(drawable, GL.GL_UNSIGNED_BYTE, numObjs, numVertices, loops, false); + runOneSet(drawable, GL.GL_BYTE, numObjs, numVertices, loops, true); + runOneSet(drawable, GL.GL_BYTE, numObjs, numVertices, loops, false); + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, numObjs, numVertices, loops, true); + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, numObjs, numVertices, loops, false); + runOneSet(drawable, GL.GL_SHORT, numObjs, numVertices, loops, true); + runOneSet(drawable, GL.GL_SHORT, numObjs, numVertices, loops, false); + runOneSet(drawable, GL.GL_FLOAT, numObjs, numVertices, loops, true); + runOneSet(drawable, GL.GL_FLOAT, numObjs, numVertices, loops, false); + + GL2ES2 gl = drawable.getGL().getGL2ES2(); + if(gl.isGLES2()) { + runOneSet(drawable, GL.GL_FIXED, numObjs, numVertices, loops, true); + runOneSet(drawable, GL.GL_FIXED, numObjs, numVertices, loops, false); + } + } + + public void run(GLAutoDrawable drawable, int loops) { + runOneSet(drawable, 1, 100, loops); + runOneSet(drawable, 3, 100, loops); + + runOneSet(drawable, 1, 1000, loops); + runOneSet(drawable, 3, 1000, loops); + + runOneSet(drawable, 1, 10000, loops); + runOneSet(drawable, 3, 10000, loops); + + runOneSet(drawable, 1, 100000, loops); + runOneSet(drawable, 3, 100000, loops); + + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 10, 150, loops, true); + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 10, 150, loops, false); + + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 20, 150, loops, true); + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 20, 150, loops, false); + + /* + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 30, 150, loops, true); + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 30, 150, loops, false); + + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 40, 150, loops, true); + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 40, 150, loops, false); + + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 50, 150, loops, true); + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 50, 150, loops, false); + + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 60, 150, loops, true); + runOneSet(drawable, GL.GL_UNSIGNED_SHORT, 60, 150, loops, false); + */ + } + +} diff --git a/src/demos/es2/perftst/Perftst.java b/src/demos/es2/perftst/Perftst.java new file mode 100755 index 0000000..f023e4d --- /dev/null +++ b/src/demos/es2/perftst/Perftst.java @@ -0,0 +1,185 @@ +package demos.es2.perftst; + +import java.nio.*; +import javax.media.opengl.*; +import javax.media.nativewindow.*; + +import com.sun.opengl.util.*; +import com.sun.opengl.util.glsl.*; + +import com.sun.javafx.newt.*; +import com.sun.javafx.newt.opengl.*; + +public class Perftst implements MouseListener, GLEventListener { + + private GLWindow window; + private boolean quit = false; + + private PerfModule pmod; + private ShaderState st; + private PMVMatrix pmvMatrix; + + + public void mouseClicked(MouseEvent e) { + quit=true; + } + public void mouseEntered(MouseEvent e) { + } + public void mouseExited(MouseEvent e) { + } + public void mousePressed(MouseEvent e) { + } + public void mouseReleased(MouseEvent e) { + } + public void mouseMoved(MouseEvent e) { + } + public void mouseDragged(MouseEvent e) { + } + public void mouseWheelMoved(MouseEvent e) { + } + + private void run(int type, PerfModule pm) { + int width = 800; + int height = 480; + pmod = pm; + System.err.println("Perftst.run()"); + try { + GLCapabilities caps = new GLCapabilities(GLProfile.getGL2ES2()); + // For emulation library, use 16 bpp + caps.setRedBits(5); + caps.setGreenBits(6); + caps.setBlueBits(5); + caps.setDepthBits(16); + + Window nWindow = null; + if(0!=(type&USE_AWT)) { + Display nDisplay = NewtFactory.createDisplay(NativeWindowFactory.TYPE_AWT, null); // local display + Screen nScreen = NewtFactory.createScreen(NativeWindowFactory.TYPE_AWT, nDisplay, 0); // screen 0 + nWindow = NewtFactory.createWindow(NativeWindowFactory.TYPE_AWT, nScreen, caps); + } + window = GLWindow.create(nWindow, caps); + + window.addMouseListener(this); + window.addGLEventListener(this); + // window.setEventHandlerMode(GLWindow.EVENT_HANDLER_GL_CURRENT); // default + // window.setEventHandlerMode(GLWindow.EVENT_HANDLER_GL_NONE); // no current .. + + // Size OpenGL to Video Surface + window.setSize(width, height); + window.setFullscreen(true); + window.setVisible(true); + + window.display(); + + // Shut things down cooperatively + window.destroy(); + window.getFactory().shutdown(); + System.out.println("Perftst shut down cleanly."); + } catch (Throwable t) { + t.printStackTrace(); + } + } + + public void init(GLAutoDrawable drawable) { + drawable.setAutoSwapBufferMode(false); + + GL2ES2 gl = drawable.getGL().getGL2ES2(); + System.err.println("Entering initialization"); + System.err.println("GL_VERSION=" + gl.glGetString(gl.GL_VERSION)); + System.err.println("GL_EXTENSIONS:"); + System.err.println(" " + gl.glGetString(gl.GL_EXTENSIONS)); + + pmvMatrix = new PMVMatrix(); + + pmod.initShaderState(gl); + st = ShaderState.getCurrent(); + + // Push the 1st uniform down the path + st.glUseProgram(gl, true); + + pmvMatrix.glMatrixMode(pmvMatrix.GL_PROJECTION); + pmvMatrix.glLoadIdentity(); + pmvMatrix.glMatrixMode(pmvMatrix.GL_MODELVIEW); + pmvMatrix.glLoadIdentity(); + + if(!st.glUniform(gl, new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf()))) { + throw new GLException("Error setting PMVMatrix in shader: "+st); + } + + // OpenGL Render Settings + gl.glClearColor(0, 0, 0, 1); + gl.glEnable(GL2ES2.GL_DEPTH_TEST); + + st.glUseProgram(gl, false); + + // Let's show the completed shader state .. + System.out.println(st); + } + + public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { + GL2ES2 gl = drawable.getGL().getGL2ES2(); + + st.glUseProgram(gl, true); + + // Set location in front of camera + pmvMatrix.glMatrixMode(pmvMatrix.GL_PROJECTION); + pmvMatrix.glLoadIdentity(); + pmvMatrix.glOrthof(0f, 1.0f, 0.0f, 1.0f, 1.0f, 100.0f); + + pmvMatrix.glMatrixMode(pmvMatrix.GL_MODELVIEW); + pmvMatrix.glLoadIdentity(); + pmvMatrix.glTranslatef(0, 0, -10); + + GLUniformData ud = st.getUniform("mgl_PMVMatrix"); + if(null!=ud) { + // same data object + st.glUniform(gl, ud); + } + + st.glUseProgram(gl, false); + } + + public void dispose(GLAutoDrawable drawable) { + GL2ES2 gl = drawable.getGL().getGL2ES2(); + + st.destroy(gl); + st=null; + pmvMatrix.destroy(); + pmvMatrix=null; + quit=true; + } + + + public void display(GLAutoDrawable drawable) { + pmod.run(drawable, 10); + } + + public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) { + } + + public static int USE_NEWT = 0; + public static int USE_AWT = 1 << 0; + + public static void main(String[] args) { + int type = USE_NEWT ; + String tstName = "demos.es2.perftst.PerfVBOLoad"; // default + + for(int i=args.length-1; i>=0; i--) { + if(args[i].equals("-awt")) { + type |= USE_AWT; + } + if(args[i].equals("-test") && i+1<args.length ) { + tstName = args[i+1]; + } + } + + try { + PerfModule pmod = (PerfModule) Class.forName(tstName).newInstance(); + new Perftst().run(type, pmod); + System.exit(0); + } catch (Exception e) { + e.printStackTrace(); + System.exit(1); + } + } +} diff --git a/src/demos/es2/perftst/data/bob2.gif b/src/demos/es2/perftst/data/bob2.gif Binary files differnew file mode 100644 index 0000000..2faba51 --- /dev/null +++ b/src/demos/es2/perftst/data/bob2.gif diff --git a/src/demos/es2/perftst/data/gif2tgas.sh b/src/demos/es2/perftst/data/gif2tgas.sh new file mode 100644 index 0000000..2fd184b --- /dev/null +++ b/src/demos/es2/perftst/data/gif2tgas.sh @@ -0,0 +1,28 @@ +#! /bin/sh + +rm -rf tmp +mkdir -p tmp + +function gif2tga() +{ + bname=$1 + shift + images=$1 + shift + xysize=$1 + shift + + i=1 ; + while [ $i -le $images ] ; do + giftopnm -image $i $bname.gif > tmp/$bname.$i.pnm + pamscale -xsize=$xysize -ysize=$xysize tmp/$bname.$i.pnm > tmp/$bname.$xysize"x"$xysize.$i.pam + pamtotga -rgb -norle tmp/$bname.$xysize"x"$xysize.$i.pam > $bname.$xysize"x"$xysize.$i.tga + let i=$i+1 + done +} + +gif2tga bob2 33 64 +gif2tga bob2 33 128 +gif2tga bob2 33 256 +gif2tga bob2 33 512 + diff --git a/src/demos/es2/perftst/shader/bin/nvidia/fcolor.bfp b/src/demos/es2/perftst/shader/bin/nvidia/fcolor.bfp Binary files differnew file mode 100755 index 0000000..454354c --- /dev/null +++ b/src/demos/es2/perftst/shader/bin/nvidia/fcolor.bfp diff --git a/src/demos/es2/perftst/shader/bin/nvidia/ftext.bfp b/src/demos/es2/perftst/shader/bin/nvidia/ftext.bfp Binary files differnew file mode 100755 index 0000000..2807387 --- /dev/null +++ b/src/demos/es2/perftst/shader/bin/nvidia/ftext.bfp diff --git a/src/demos/es2/perftst/shader/bin/nvidia/uni-vert-col.bvp b/src/demos/es2/perftst/shader/bin/nvidia/uni-vert-col.bvp Binary files differnew file mode 100755 index 0000000..b89137d --- /dev/null +++ b/src/demos/es2/perftst/shader/bin/nvidia/uni-vert-col.bvp diff --git a/src/demos/es2/perftst/shader/bin/nvidia/vbo-vert-col.bvp b/src/demos/es2/perftst/shader/bin/nvidia/vbo-vert-col.bvp Binary files differnew file mode 100755 index 0000000..ba0c982 --- /dev/null +++ b/src/demos/es2/perftst/shader/bin/nvidia/vbo-vert-col.bvp diff --git a/src/demos/es2/perftst/shader/bin/nvidia/vbo-vert-text.bvp b/src/demos/es2/perftst/shader/bin/nvidia/vbo-vert-text.bvp Binary files differnew file mode 100755 index 0000000..9fe8667 --- /dev/null +++ b/src/demos/es2/perftst/shader/bin/nvidia/vbo-vert-text.bvp diff --git a/src/demos/es2/perftst/shader/fcolor.fp b/src/demos/es2/perftst/shader/fcolor.fp new file mode 100644 index 0000000..a94f705 --- /dev/null +++ b/src/demos/es2/perftst/shader/fcolor.fp @@ -0,0 +1,16 @@ + +#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/demos/es2/perftst/shader/ftext.fp b/src/demos/es2/perftst/shader/ftext.fp new file mode 100644 index 0000000..726cc43 --- /dev/null +++ b/src/demos/es2/perftst/shader/ftext.fp @@ -0,0 +1,17 @@ + +#ifdef GL_ES + #define MEDIUMP mediump + #define HIGHP highp +#else + #define MEDIUMP + #define HIGHP +#endif + +varying vec4 mgl_TexCoord0; +uniform sampler2D mgl_ActiveTexture; + +void main (void) +{ + gl_FragColor = vec4(texture2D(mgl_ActiveTexture, mgl_TexCoord0.st).rgb, 1.0); +} + diff --git a/src/demos/es2/perftst/shader/scripts/nvidia-apx/glslc-ff.bat b/src/demos/es2/perftst/shader/scripts/nvidia-apx/glslc-ff.bat new file mode 100755 index 0000000..bf184f9 --- /dev/null +++ b/src/demos/es2/perftst/shader/scripts/nvidia-apx/glslc-ff.bat @@ -0,0 +1,9 @@ +REM +REM You have to call it from the 'shader' directory, e.g.: +REM scripts\nvidia-apx\glslc-ff.bat +REM +IF !"%JOGLDIR%"==""! GOTO YESPATH +set JOGLDIR=..\lib +:YESPATH + +java -cp %JOGLDIR%\jogl.core.jar;%JOGLDIR%\jogl.gles2.jar;%JOGLDIR%\jogl.fixed.jar;%JOGLDIR%\jogl.sdk.jar javax.media.opengl.sdk.glsl.CompileShaderNVidia fcolor.fp vbo-vert-col.vp uni-vert-col.vp ftext.fp vbo-vert-text.vp diff --git a/src/demos/es2/perftst/shader/uni-vert-col.vp b/src/demos/es2/perftst/shader/uni-vert-col.vp new file mode 100644 index 0000000..0550a8f --- /dev/null +++ b/src/demos/es2/perftst/shader/uni-vert-col.vp @@ -0,0 +1,61 @@ + +#ifdef GL_ES + #define MEDIUMP mediump + #define HIGHP highp +#else + #define MEDIUMP + #define HIGHP +#endif + +uniform MEDIUMP mat4 mgl_PMVMatrix[2]; +uniform MEDIUMP vec4 mgl_Dummy0[16]; +uniform MEDIUMP vec4 mgl_Dummy1[16]; +uniform MEDIUMP vec4 mgl_Dummy2[16]; +uniform MEDIUMP vec4 mgl_Dummy3[16]; +uniform MEDIUMP vec4 mgl_Dummy4[16]; +uniform MEDIUMP vec4 mgl_Dummy5[16]; +uniform MEDIUMP vec4 mgl_Dummy6[16]; +uniform MEDIUMP vec4 mgl_Dummy7[16]; +uniform MEDIUMP vec4 mgl_Dummy8[16]; +uniform MEDIUMP vec4 mgl_Dummy9[16]; +uniform MEDIUMP vec4 mgl_Dummy10[16]; +uniform MEDIUMP vec4 mgl_Dummy11[16]; +/* +uniform MEDIUMP vec4 mgl_Dummy12[16]; +uniform MEDIUMP vec4 mgl_Dummy13[16]; +uniform MEDIUMP vec4 mgl_Dummy14[16]; +uniform MEDIUMP vec4 mgl_Dummy15[16]; + */ +attribute HIGHP vec4 mgl_Vertex; +attribute HIGHP vec4 mgl_Color; +varying HIGHP vec4 frontColor; + +void main(void) +{ + int i; + vec4 val=vec4(0); + + for(i=0; i<16; i++) { + val += mgl_Dummy0[i]; + val += mgl_Dummy1[i]; + val += mgl_Dummy2[i]; + val += mgl_Dummy3[i]; + val += mgl_Dummy4[i]; + val += mgl_Dummy5[i]; + val += mgl_Dummy6[i]; + val += mgl_Dummy7[i]; + val += mgl_Dummy8[i]; + val += mgl_Dummy9[i]; + val += mgl_Dummy10[i]; + val += mgl_Dummy11[i]; + /* + val += mgl_Dummy12[i]; + val += mgl_Dummy13[i]; + val += mgl_Dummy14[i]; + val += mgl_Dummy15[i]; + */ + } + + frontColor=mgl_Color+val; + gl_Position = mgl_PMVMatrix[0] * mgl_PMVMatrix[1] * mgl_Vertex; +} diff --git a/src/demos/es2/perftst/shader/vbo-vert-col.vp b/src/demos/es2/perftst/shader/vbo-vert-col.vp new file mode 100644 index 0000000..0348e90 --- /dev/null +++ b/src/demos/es2/perftst/shader/vbo-vert-col.vp @@ -0,0 +1,19 @@ + +#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/demos/es2/perftst/shader/vbo-vert-text.vp b/src/demos/es2/perftst/shader/vbo-vert-text.vp new file mode 100644 index 0000000..283d676 --- /dev/null +++ b/src/demos/es2/perftst/shader/vbo-vert-text.vp @@ -0,0 +1,19 @@ + +#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_MultiTexCoord0; +varying vec4 mgl_TexCoord0; + +void main(void) +{ + mgl_TexCoord0 = mgl_MultiTexCoord0; + gl_Position = mgl_PMVMatrix[0] * mgl_PMVMatrix[1] * mgl_Vertex; +} |
