diff options
Diffstat (limited to 'src/jogl/classes/com')
6 files changed, 292 insertions, 264 deletions
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java index 221385cc6..d80d398aa 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java +++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java @@ -35,8 +35,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData * On profile ES2 the fixed function emulation will transform these calls to * EnableVertexAttribArray and VertexAttribPointer calls, * and a predefined vertex attribute variable name will be chosen. - * - * @param gl the current GL instance + * * @param index The GL array index * @param name The optional custom name for the GL array index, maybe null. * If null, the default name mapping will be used, see 'getPredefinedArrayIndexName(int)'. @@ -48,11 +47,9 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData * * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int) */ - public static GLArrayDataClient createFixed(GL gl, int index, String name, int comps, int dataType, boolean normalized, - int initialSize) + public static GLArrayDataClient createFixed(int index, String name, int comps, int dataType, boolean normalized, int initialSize) throws GLException { - gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true); GLArrayDataClient adc = new GLArrayDataClient(); GLArrayHandler glArrayHandler = new GLFixedArrayHandler(adc); adc.init(name, index, comps, dataType, normalized, 0, null, initialSize, false, glArrayHandler, -1, -1, -1, -1); @@ -67,8 +64,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData * On profile ES2 the fixed function emulation will transform these calls to * EnableVertexAttribArray and VertexAttribPointer calls, * and a predefined vertex attribute variable name will be chosen. - * - * @param gl the current GL instance + * * @param index The GL array index * @param name The optional custom name for the GL array index, maybe null. * If null, the default name mapping will be used, see 'getPredefinedArrayIndexName(int)'. @@ -81,11 +77,10 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData * * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int) */ - public static GLArrayDataClient createFixed(GL gl, int index, String name, int comps, int dataType, boolean normalized, - int stride, Buffer buffer) + public static GLArrayDataClient createFixed(int index, String name, int comps, int dataType, boolean normalized, int stride, + Buffer buffer) throws GLException { - gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true); GLArrayDataClient adc = new GLArrayDataClient(); GLArrayHandler glArrayHandler = new GLFixedArrayHandler(adc); adc.init(name, index, comps, dataType, normalized, stride, buffer, comps*comps, false, glArrayHandler, -1, -1, -1, -1); @@ -95,25 +90,20 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData /** * Create a client side buffer object, using a custom GLSL array attribute name * and starting with a new created Buffer object with initialSize size - * - * @param gl the current GL instance + * + * @param st The ShaderState managing the state of the used shader program, vertex attributes and uniforms * @param name The custom name for the GL attribute. * @param comps The array component number * @param dataType The array index GL data type * @param normalized Whether the data shall be normalized * @param initialSize */ - public static GLArrayDataClient createGLSL(GL gl, String name, int comps, int dataType, boolean normalized, - int initialSize) + public static GLArrayDataClient createGLSL(ShaderState st, String name, + int comps, int dataType, boolean normalized, int initialSize) throws GLException { - if(!gl.hasGLSL()) { - throw new GLException("GLArrayDataClient.GLSL not supported: "+gl); - } - gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true); - GLArrayDataClient adc = new GLArrayDataClient(); - GLArrayHandler glArrayHandler = new GLSLArrayHandler(adc); + GLArrayHandler glArrayHandler = new GLSLArrayHandler(st, adc); adc.init(name, -1, comps, dataType, normalized, 0, null, initialSize, true, glArrayHandler, -1, -1, -1, -1); return adc; } @@ -121,8 +111,8 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData /** * Create a client side buffer object, using a custom GLSL array attribute name * and starting with a given Buffer object incl it's stride - * - * @param gl the current GL instance + * + * @param st The ShaderState managing the state of the used shader program, vertex attributes and uniforms * @param name The custom name for the GL attribute. * @param comps The array component number * @param dataType The array index GL data type @@ -130,17 +120,13 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData * @param stride * @param buffer the user define data */ - public static GLArrayDataClient createGLSL(GL gl, String name, int comps, int dataType, boolean normalized, - int stride, Buffer buffer) + public static GLArrayDataClient createGLSL(ShaderState st, String name, + int comps, int dataType, boolean normalized, int stride, + Buffer buffer) throws GLException { - if(!gl.hasGLSL()) { - throw new GLException("GLArrayDataClient.GLSL not supported: "+gl); - } - gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true); - GLArrayDataClient adc = new GLArrayDataClient(); - GLArrayHandler glArrayHandler = new GLSLArrayHandler(adc); + GLArrayHandler glArrayHandler = new GLSLArrayHandler(st, adc); adc.init(name, -1, comps, dataType, normalized, stride, buffer, comps*comps, true, glArrayHandler, -1, -1, -1, -1); return adc; } @@ -152,6 +138,8 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData public final boolean isVBOWritten() { return bufferWritten; } public final boolean sealed() { return sealed; } + + public final boolean enabled() { return bufferEnabled; } // // Data and GL state modification .. @@ -161,8 +149,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData public void destroy(GL gl) { reset(gl); - buffer=null; - valid=false; + super.destroy(gl); } public void reset(GL gl) { @@ -170,28 +157,17 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData reset(); } - public void seal(GL gl, boolean seal) - { + public void seal(GL gl, boolean seal) { seal(seal); - if(sealedGL==seal) return; - sealedGL = seal; - if(seal) { - init_vbo(gl); - - enableBuffer(gl, true); - } else { - enableBuffer(gl, false); - } + enableBuffer(gl, seal); } public void enableBuffer(GL gl, boolean enable) { - if( enableBufferAlways || bufferEnabled != enable || - getVBOName() != gl.glGetBoundBuffer(getVBOTarget()) ) { + if( enableBufferAlways || bufferEnabled != enable ) { if(enable) { checkSeal(true); - if(null!=buffer) { - buffer.rewind(); - } + // init/generate VBO name if not done yet + init_vbo(gl); } glArrayHandler.enableBuffer(gl, enable); bufferEnabled = enable; @@ -219,16 +195,14 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData { if(sealed==seal) return; sealed = seal; + bufferWritten=false; if(seal) { - bufferWritten=false; if (null!=buffer) { buffer.flip(); } - } else { - if (null!=buffer) { - buffer.position(buffer.limit()); - buffer.limit(buffer.capacity()); - } + } else if (null!=buffer) { + buffer.position(buffer.limit()); + buffer.limit(buffer.capacity()); } } @@ -254,7 +228,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData * The arguments remaining elements must be a multiple of this arrays element stride. */ public void put(Buffer v) { - if ( buffer==null || sealed ) return; + if ( sealed ) return; if(0!=(v.remaining() % strideL)) { throw new GLException("Buffer length ("+v.remaining()+") is not a multiple of component-stride:\n\t"+this); } @@ -263,19 +237,19 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData } public void putb(byte v) { - if ( buffer==null || sealed ) return; + if ( sealed ) return; growBufferIfNecessary(1); Buffers.putb(buffer, v); } public void puts(short v) { - if ( buffer==null || sealed ) return; + if ( sealed ) return; growBufferIfNecessary(1); Buffers.puts(buffer, v); } public void puti(int v) { - if ( buffer==null || sealed ) return; + if ( sealed ) return; growBufferIfNecessary(1); Buffers.puti(buffer, v); } @@ -285,7 +259,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData } public void putf(float v) { - if ( buffer==null || sealed ) return; + if ( sealed ) return; growBufferIfNecessary(1); Buffers.putf(buffer, v); } @@ -295,8 +269,8 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData ", index "+index+ ", location "+location+ ", isVertexAttribute "+isVertexAttribute+ - ", dataType "+dataType+ - ", bufferClazz "+clazz+ + ", dataType "+componentType+ + ", bufferClazz "+componentClazz+ ", elements "+getElementNumber()+ ", components "+components+ ", stride "+stride+"u "+strideB+"b "+strideL+"c"+ @@ -305,7 +279,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData ", bufferEnabled "+bufferEnabled+ ", bufferWritten "+bufferWritten+ ", buffer "+buffer+ - ", valid "+valid+ + ", alive "+alive+ "]"; } @@ -320,7 +294,7 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData } protected final void growBuffer(int additional) { - if(!valid || sealed) { + if(!alive || sealed) { throw new GLException("Invalid state: "+this); } @@ -328,28 +302,28 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData additional += (additional/components)*(strideL-components); int osize = (buffer!=null)?buffer.capacity():0; - if(clazz==ByteBuffer.class) { + if(componentClazz==ByteBuffer.class) { ByteBuffer newBBuffer = Buffers.newDirectByteBuffer( (osize+additional) * components ); if(buffer!=null) { buffer.flip(); newBBuffer.put((ByteBuffer)buffer); } buffer = newBBuffer; - } else if(clazz==ShortBuffer.class) { + } else if(componentClazz==ShortBuffer.class) { ShortBuffer newSBuffer = Buffers.newDirectShortBuffer( (osize+additional) * components ); if(buffer!=null) { buffer.flip(); newSBuffer.put((ShortBuffer)buffer); } buffer = newSBuffer; - } else if(clazz==IntBuffer.class) { + } else if(componentClazz==IntBuffer.class) { IntBuffer newIBuffer = Buffers.newDirectIntBuffer( (osize+additional) * components ); if(buffer!=null) { buffer.flip(); newIBuffer.put((IntBuffer)buffer); } buffer = newIBuffer; - } else if(clazz==FloatBuffer.class) { + } else if(componentClazz==FloatBuffer.class) { FloatBuffer newFBuffer = Buffers.newDirectFloatBuffer( (osize+additional) * components ); if(buffer!=null) { buffer.flip(); @@ -357,12 +331,12 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData } buffer = newFBuffer; } else { - throw new GLException("Given Buffer Class not supported: "+clazz+":\n\t"+this); + throw new GLException("Given Buffer Class not supported: "+componentClazz+":\n\t"+this); } } protected final void checkSeal(boolean test) throws GLException { - if(!valid) { + if(!alive) { throw new GLException("Invalid state: "+this); } if(sealed!=test) { @@ -385,7 +359,6 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData this.initialSize = initialSize; this.glArrayHandler = handler; this.sealed=false; - this.sealedGL=false; this.bufferEnabled=false; this.enableBufferAlways=false; this.bufferWritten=false; @@ -394,11 +367,18 @@ public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayData } } - protected void init_vbo(GL gl) {} + private boolean isValidated = false; + + protected void init_vbo(GL gl) { + if(!isValidated ) { + isValidated = true; + validate(gl.getGLProfile(), true); + } + } protected GLArrayDataClient() { } - protected boolean sealed, sealedGL; + protected boolean sealed; protected boolean bufferEnabled; protected boolean bufferWritten; protected boolean enableBufferAlways; diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataEditable.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataEditable.java index 32fc5a2a2..0da7d1171 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataEditable.java +++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataEditable.java @@ -14,6 +14,8 @@ import java.nio.*; public interface GLArrayDataEditable extends GLArrayData { public boolean sealed(); + + public boolean enabled(); /** * Is the buffer written to the VBO ? @@ -34,29 +36,27 @@ public interface GLArrayDataEditable extends GLArrayData { public void reset(GL gl); /** - * If seal is true, it - * disable write operations to the buffer. - * Calls flip, ie limit:=position and position:=0. - * Also enables the buffer for OpenGL, and passes the data. - * - * If seal is false, it - * enable write operations continuing - * at the buffer position, where you left off at seal(true), - * ie position:=limit and limit:=capacity. - * Also disables the buffer for OpenGL. + * Convenience method calling {@link #seal(boolean)} and {@link #enableBuffer(GL, boolean)}. * * @see #seal(boolean) + * @see #enableBuffer(GL, boolean) + * */ public void seal(GL gl, boolean seal); /** - * Enables/disables the buffer, which implies - * the client state, binding the VBO - * and transfering the data if not done yet. + * <p>Enables/disables the buffer, + * sets the client state, binds the VBO if used + * and transfers the data if necessary.</p> + * + * <p>The action will only be executed, + * if the internal enable state differs, + * or 'setEnableAlways' was called with 'true'.</b> * - * The above will only be executed, - * if the buffer is disabled, - * or 'setEnableAlways' was called with 'true'. + * <p>It is up to the user to enable/disable the array properly, + * ie in case of multiple data sets for the same vertex attribute (VA). + * Meaning in such case usage of one set while expecting another one + * to be used for the same VA implies decorating each usage with enable/disable.</p> * * @see #setEnableAlways(boolean) */ @@ -67,8 +67,9 @@ public interface GLArrayDataEditable extends GLArrayData { * * The default is 'false' * - * This is usefull when you mix up - * GLArrayData usage with conventional GL array calls. + * This is useful when you mix up + * GLArrayData usage with conventional GL array calls + * or in case of a buggy GL VBO implementation. * * @see #enableBuffer(GL, boolean) */ @@ -81,16 +82,17 @@ public interface GLArrayDataEditable extends GLArrayData { public void reset(); /** - * If seal is true, it - * disable write operations to the buffer. - * Calls flip, ie limit:=position and position:=0. + * <p>If <i>seal</i> is true, it + * disables write operations to the buffer. + * Calls flip, ie limit:=position and position:=0.</p> * - * If seal is false, it + * <p>If <i>seal</i> is false, it * enable write operations continuing * at the buffer position, where you left off at seal(true), - * ie position:=limit and limit:=capacity. + * ie position:=limit and limit:=capacity.</p> * - */ + * @see #seal(boolean) + */ public void seal(boolean seal); public void rewind(); diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java index 8504aeae3..23c237909 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java +++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java @@ -21,32 +21,28 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE * On profile ES2 the fixed function emulation will transform these calls to * EnableVertexAttribArray and VertexAttribPointer calls, * and a predefined vertex attribute variable name will be chosen. - * - * @param gl the current GL instance + * * @param index The GL array index * @param name The optional custom name for the GL array index, maybe null. - * If null, the default name mapping will be used, see 'getPredefinedArrayIndexName(int)'. - * This name might be used as the shader attribute name. + * If null, the default name mapping will be used, see 'getPredefinedArrayIndexName(int)'. + * This name might be used as the shader attribute name. * @param comps The array component number * @param dataType The array index GL data type * @param normalized Whether the data shall be normalized * @param stride * @param buffer the user define data * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW} - * @param vboTarget either {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER} * * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int) */ - public static GLArrayDataServer createFixed(GL gl, int index, String name, int comps, int dataType, boolean normalized, - int stride, Buffer buffer, int vboUsage, int vboTarget) + public static GLArrayDataServer createFixed(int index, String name, int comps, int dataType, boolean normalized, int stride, + Buffer buffer, int vboUsage) throws GLException { - gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true); - GLArrayDataServer ads = new GLArrayDataServer(); GLArrayHandler glArrayHandler = new GLFixedArrayHandler(ads); - ads.init(gl, name, index, comps, dataType, normalized, stride, buffer, buffer.limit(), false, glArrayHandler, - 0, 0, vboUsage, vboTarget); + ads.init(name, index, comps, dataType, normalized, stride, buffer, buffer.limit(), false, glArrayHandler, + 0, 0, vboUsage, GL.GL_ARRAY_BUFFER); return ads; } @@ -58,103 +54,126 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE * On profile ES2 the fixed function emulation will transform these calls to * EnableVertexAttribArray and VertexAttribPointer calls, * and a predefined vertex attribute variable name will be chosen. - * - * @param gl the current GL instance + * * @param index The GL array index * @param name The optional custom name for the GL array index, maybe null. - * If null, the default name mapping will be used, see 'getPredefinedArrayIndexName(int)'. - * This name might be used as the shader attribute name. + * If null, the default name mapping will be used, see 'getPredefinedArrayIndexName(int)'. + * This name might be used as the shader attribute name. * @param comps The array component number * @param dataType The array index GL data type * @param normalized Whether the data shall be normalized * @param initialSize * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW} - * @param vboTarget either {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER} * * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int) */ - public static GLArrayDataServer createFixed(GL gl, int index, String name, int comps, int dataType, boolean normalized, - int initialSize, int vboUsage, int vboTarget) + public static GLArrayDataServer createFixed(int index, String name, int comps, int dataType, boolean normalized, int initialSize, + int vboUsage) throws GLException { - gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true); - - GLArrayDataServer ads = new GLArrayDataServer(); - GLArrayHandler glArrayHandler = new GLFixedArrayHandler(ads); - ads.init(gl, name, index, comps, dataType, normalized, 0, null, initialSize, false, glArrayHandler, - 0, 0, vboUsage, vboTarget); + GLArrayDataServer ads = new GLArrayDataServer(); + GLArrayHandler glArrayHandler = new GLFixedArrayHandler(ads); + ads.init(name, index, comps, dataType, normalized, 0, null, initialSize, false, glArrayHandler, + 0, 0, vboUsage, GL.GL_ARRAY_BUFFER); return ads; } /** * Create a VBO, using a custom GLSL array attribute name * and starting with a new created Buffer object with initialSize size - * - * @param gl the current GL instance + * + * @param st The ShaderState managing the state of the used shader program, vertex attributes and uniforms * @param name The custom name for the GL attribute, maybe null if gpuBufferTarget is {@link GL#GL_ELEMENT_ARRAY_BUFFER} * @param comps The array component number * @param dataType The array index GL data type * @param normalized Whether the data shall be normalized * @param initialSize * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW} - * @param vboTarget either {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER} */ - public static GLArrayDataServer createGLSL(GL gl, String name, int comps, int dataType, boolean normalized, - int initialSize, int vboUsage, int vboTarget) - throws GLException + public static GLArrayDataServer createGLSL(ShaderState st, String name, + int comps, int dataType, boolean normalized, int initialSize, + int vboUsage) + throws GLException { - if(!gl.hasGLSL()) { - throw new GLException("GLArrayDataServer.GLSL not supported: "+gl); - } - gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true); - GLArrayDataServer ads = new GLArrayDataServer(); - GLArrayHandler glArrayHandler; - if( GL.GL_ELEMENT_ARRAY_BUFFER == vboTarget ) { - glArrayHandler = new GLDataArrayHandler(ads); - } else { - glArrayHandler = new GLSLArrayHandler(ads); - } - ads.init(gl, name, -1, comps, dataType, normalized, 0, null, initialSize, true, glArrayHandler, - 0, 0, vboUsage, vboTarget); + GLArrayHandler glArrayHandler = new GLSLArrayHandler(st, ads); + ads.init(name, -1, comps, dataType, normalized, 0, null, initialSize, + true, glArrayHandler, 0, 0, vboUsage, GL.GL_ARRAY_BUFFER); return ads; - } - + } + /** * Create a VBO, using a custom GLSL array attribute name * and starting with a given Buffer object incl it's stride - * - * @param gl the current GL instance - * @param name The custom name for the GL attribute, maybe null if gpuBufferTarget is {@link GL#GL_ELEMENT_ARRAY_BUFFER} + * + * @param st The ShaderState managing the state of the used shader program, vertex attributes and uniforms + * @param name The custom name for the GL attribute, maybe null if gpuBufferTarget is * @param comps The array component number * @param dataType The array index GL data type * @param normalized Whether the data shall be normalized * @param stride * @param buffer the user define data * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW} - * @param vboTarget either {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER} */ - public static GLArrayDataServer createGLSL(GL gl, String name, int comps, int dataType, boolean normalized, - int stride, Buffer buffer, int vboUsage, int vboTarget) + public static GLArrayDataServer createGLSL(ShaderState st, String name, + int comps, int dataType, boolean normalized, int stride, + Buffer buffer, int vboUsage) throws GLException { - if(!gl.hasGLSL()) { - throw new GLException("GLArrayDataServer.GLSL not supported: "+gl); - } - gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true); + GLArrayDataServer ads = new GLArrayDataServer(); + GLArrayHandler glArrayHandler = new GLSLArrayHandler(st, ads); + ads.init(name, -1, comps, dataType, normalized, stride, buffer, buffer.limit(), true, glArrayHandler, + 0, 0, vboUsage, GL.GL_ARRAY_BUFFER); + return ads; + } + + /** + * Create a VBO data object for any target w/o render pipeline association, ie {@link GL#GL_ELEMENT_ARRAY_BUFFER}. + * + * Hence no index, name for a fixed function pipeline nor vertex attribute is given. + * + * @param comps The array component number + * @param dataType The array index GL data type + * @param stride + * @param buffer the user define data + * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW} + * @param vboTarget {@link GL#GL_ELEMENT_ARRAY_BUFFER}, .. + * {@link GL#glGenBuffers(int, int[], int) + */ + public static GLArrayDataServer createData(int comps, int dataType, int stride, + Buffer buffer, int vboUsage, int vboTarget) + throws GLException + { + GLArrayDataServer ads = new GLArrayDataServer(); + GLArrayHandler glArrayHandler = new GLDataArrayHandler(ads); + ads.init(null, -1, comps, dataType, false, stride, buffer, buffer.limit(), false, glArrayHandler, + 0, 0, vboUsage, vboTarget); + return ads; + } + /** + * Create a VBO data object for any target w/o render pipeline association, ie {@link GL#GL_ELEMENT_ARRAY_BUFFER}. + * + * Hence no index, name for a fixed function pipeline nor vertex attribute is given. + * + * @param comps The array component number + * @param dataType The array index GL data type + * @param initialSize + * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW} + * @param vboTarget {@link GL#GL_ELEMENT_ARRAY_BUFFER}, .. + */ + public static GLArrayDataServer createData(int comps, int dataType, int initialSize, + int vboUsage, int vboTarget) + throws GLException + { GLArrayDataServer ads = new GLArrayDataServer(); - GLArrayHandler glArrayHandler; - if( GL.GL_ELEMENT_ARRAY_BUFFER == vboTarget ) { - glArrayHandler = new GLDataArrayHandler(ads); - } else { - glArrayHandler = new GLSLArrayHandler(ads); - } - ads.init(gl, name, -1, comps, dataType, normalized, stride, buffer, buffer.limit(), true, glArrayHandler, + GLArrayHandler glArrayHandler = new GLDataArrayHandler(ads); + ads.init(null, -1, comps, dataType, false, 0, null, initialSize, false, glArrayHandler, 0, 0, vboUsage, vboTarget); return ads; } + // // Data matters GLArrayData // @@ -192,8 +211,8 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE ", index "+index+ ", location "+location+ ", isVertexAttribute "+isVertexAttribute+ - ", dataType "+dataType+ - ", bufferClazz "+clazz+ + ", dataType "+componentType+ + ", bufferClazz "+componentClazz+ ", elements "+getElementNumber()+ ", components "+components+ ", stride "+stride+"u "+strideB+"b "+strideL+"c"+ @@ -207,7 +226,7 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE ", bufferWritten "+bufferWritten+ ", buffer "+buffer+ ", offset "+vboOffset+ - ", valid "+valid+ + ", alive "+alive+ "]"; } @@ -215,7 +234,7 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE // non public matters .. // - protected void init(GL gl, String name, int index, int comps, int dataType, boolean normalized, + protected void init(String name, int index, int comps, int dataType, boolean normalized, int stride, Buffer data, int initialSize, boolean isVertexAttribute, GLArrayHandler glArrayHandler, int vboName, long vboOffset, int vboUsage, int vboTarget) @@ -228,6 +247,7 @@ public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataE } protected void init_vbo(GL gl) { + super.init_vbo(gl); if(vboEnabled && vboName==0) { int[] tmp = new int[1]; gl.glGenBuffers(1, tmp, 0); diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java index f2694d39c..735bd11f7 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java +++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java @@ -12,7 +12,6 @@ public class GLArrayDataWrapper implements GLArrayData { /** * Create a VBO, using a predefined fixed function array index, wrapping the given data. * - * @param gl the current GL instance * @param index The GL array index * @param comps The array component number * @param dataType The array index GL data type @@ -22,26 +21,25 @@ public class GLArrayDataWrapper implements GLArrayData { * @param vboName * @param vboOffset * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW} - * @param vboTarget either {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER} + * * @return the new create instance + * * @throws GLException */ - public static GLArrayDataWrapper createFixed(GL gl, int index, int comps, int dataType, boolean normalized, - int stride, Buffer buffer, - int vboName, long vboOffset, int vboUsage, int vboTarget) + public static GLArrayDataWrapper createFixed(int index, int comps, int dataType, boolean normalized, int stride, + Buffer buffer, int vboName, + long vboOffset, int vboUsage) throws GLException { - gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true); GLArrayDataWrapper adc = new GLArrayDataWrapper(); adc.init(null, index, comps, dataType, normalized, stride, buffer, false, - vboName, vboOffset, vboUsage, vboTarget); + vboName, vboOffset, vboUsage, GL.GL_ARRAY_BUFFER); return adc; } /** * Create a VBO, using a custom GLSL array attribute name, wrapping the given data. * - * @param gl the current GL instance * @param name The custom name for the GL attribute, maybe null if gpuBufferTarget is {@link GL#GL_ELEMENT_ARRAY_BUFFER} * @param comps The array component number * @param dataType The array index GL data type @@ -51,26 +49,45 @@ public class GLArrayDataWrapper implements GLArrayData { * @param vboName * @param vboOffset * @param vboUsage {@link GL2ES2#GL_STREAM_DRAW}, {@link GL#GL_STATIC_DRAW} or {@link GL#GL_DYNAMIC_DRAW} - * @param vboTarget either {@link GL#GL_ARRAY_BUFFER} or {@link GL#GL_ELEMENT_ARRAY_BUFFER} + * * @return the new create instance * @throws GLException */ - public static GLArrayDataWrapper createGLSL(GL gl, String name, int comps, int dataType, boolean normalized, - int stride, Buffer buffer, - int vboName, long vboOffset, int vboUsage, int vboTarget) + public static GLArrayDataWrapper createGLSL(String name, int comps, int dataType, boolean normalized, int stride, + Buffer buffer, int vboName, + long vboOffset, int vboUsage) throws GLException { - if(!gl.hasGLSL()) { - throw new GLException("GLArrayDataWrapper.GLSL not supported: "+gl); - } - gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true); - GLArrayDataWrapper adc = new GLArrayDataWrapper(); adc.init(name, -1, comps, dataType, normalized, stride, buffer, true, - vboName, vboOffset, vboUsage, vboTarget); + vboName, vboOffset, vboUsage, GL.GL_ARRAY_BUFFER); return adc; } + /** + * Validates this instance's parameter. Called automatically by {@link GLArrayDataClient} and {@link GLArrayDataServer}. + * {@link GLArrayDataWrapper} does not validate it's instance by itself. + * + * @param glp the GLProfile to use + * @param throwException whether to throw an exception if this instance has invalid parameter or not + * @return true if this instance has invalid parameter, otherwise false + */ + public final boolean validate(GLProfile glp, boolean throwException) { + if(!alive) { + if(throwException) { + throw new GLException("Instance !alive "+this); + } + return false; + } + if(this.isVertexAttribute() && !glp.hasGLSL()) { + if(throwException) { + throw new GLException("GLSL not supported on "+glp+", "+this); + } + return false; + } + return glp.isValidArrayDataType(getIndex(), getComponentNumber(), getComponentType(), isVertexAttribute(), throwException); + } + // // Data read access // @@ -99,41 +116,31 @@ public class GLArrayDataWrapper implements GLArrayData { public final int getComponentNumber() { return components; } - public final int getComponentType() { return dataType; } - - public final int getComponentSize() { - if(clazz==ByteBuffer.class) { - return GLBuffers.SIZEOF_BYTE; - } - if(clazz==ShortBuffer.class) { - return GLBuffers.SIZEOF_SHORT; - } - if(clazz==IntBuffer.class) { - return GLBuffers.SIZEOF_INT; - } - if(clazz==FloatBuffer.class) { - return GLBuffers.SIZEOF_FLOAT; - } - throw new GLException("Given Buffer Class not supported: "+clazz+":\n\t"+this); - } + public final int getComponentType() { return componentType; } + public final int getComponentSize() { return componentSize; } + public final int getElementNumber() { if(null==buffer) return 0; return ( buffer.position()==0 ) ? ( buffer.limit() / components ) : ( buffer.position() / components ) ; } - + public final int getByteSize() { + if(null==buffer) return 0; + return ( buffer.position()==0 ) ? ( buffer.limit() * componentSize ) : ( buffer.position() * componentSize ) ; + } + public final boolean getNormalized() { return normalized; } public final int getStride() { return stride; } - public final Class getBufferClass() { return clazz; } + public final Class getBufferClass() { return componentClazz; } public void destroy(GL gl) { buffer = null; vboName=0; vboEnabled=false; vboOffset=-1; - valid = false; + alive = false; } public String toString() { @@ -141,8 +148,8 @@ public class GLArrayDataWrapper implements GLArrayData { ", index "+index+ ", location "+location+ ", isVertexAttribute "+isVertexAttribute+ - ", dataType "+dataType+ - ", bufferClazz "+clazz+ + ", dataType "+componentType+ + ", bufferClazz "+componentClazz+ ", elements "+getElementNumber()+ ", components "+components+ ", stride "+stride+"u "+strideB+"b "+strideL+"c"+ @@ -152,7 +159,7 @@ public class GLArrayDataWrapper implements GLArrayData { ", vboTarget 0x"+Integer.toHexString(vboTarget)+ ", vboEnabled "+vboEnabled+ ", vboName "+vboName+ - ", valid "+valid+ + ", alive "+alive+ "]"; } @@ -210,7 +217,8 @@ public class GLArrayDataWrapper implements GLArrayData { this.vboTarget = vboTarget; } - protected void init(String name, int index, int comps, int dataType, boolean normalized, int stride, Buffer data, + protected void init(String name, int index, int components, int componentType, + boolean normalized, int stride, Buffer data, boolean isVertexAttribute, int vboName, long vboOffset, int vboUsage, int vboTarget) throws GLException @@ -232,35 +240,38 @@ public class GLArrayDataWrapper implements GLArrayData { throw new GLException("Invalid GPUBuffer target: 0x"+Integer.toHexString(vboTarget)); } - this.dataType = dataType; - this.clazz = getBufferClass(dataType); - switch(dataType) { + this.componentType = componentType; + componentClazz = getBufferClass(componentType); + switch(componentType) { case GL.GL_BYTE: case GL.GL_UNSIGNED_BYTE: case GL.GL_SHORT: case GL.GL_UNSIGNED_SHORT: - case GL2ES1.GL_FIXED: + case GL.GL_FIXED: this.normalized = normalized; break; default: this.normalized = false; } + componentSize = GLBuffers.sizeOfGLType(componentType); + if(0 > componentSize) { + throw new GLException("Given componentType not supported: "+componentType+":\n\t"+this); + } + if(0 >= components) { + throw new GLException("Invalid number of components: " + components); + } + this.components = components; - int bpc = getComponentSize(); - if(0<stride && stride<comps*bpc) { - throw new GLException("stride ("+stride+") lower than component bytes, "+comps+" * "+bpc); + if(0<stride && stride<components*componentSize) { + throw new GLException("stride ("+stride+") lower than component bytes, "+components+" * "+componentSize); } - if(0<stride && stride%bpc!=0) { - throw new GLException("stride ("+stride+") not a multiple of bpc "+bpc); + if(0<stride && stride%componentSize!=0) { + throw new GLException("stride ("+stride+") not a multiple of bpc "+componentSize); } this.buffer = data; - if(0 >= comps) { - throw new GLException("Invalid number of components: " + comps); - } - this.components = comps; this.stride=stride; - this.strideB=(0==stride)?comps*bpc:stride; - this.strideL=(0==stride)?comps:strideB/bpc; + this.strideB=(0==stride)?components*componentSize:stride; + this.strideL=(0==stride)?components:strideB/componentSize; this.vboName=vboName; this.vboEnabled=vboName>0; this.vboOffset=vboOffset; @@ -284,22 +295,23 @@ public class GLArrayDataWrapper implements GLArrayData { } this.vboUsage=vboUsage; this.vboTarget=vboTarget; - this.valid=true; + this.alive=true; } protected GLArrayDataWrapper() { } - protected boolean valid; + protected boolean alive; protected int index; protected int location; protected String name; protected int components; - protected int dataType; + protected int componentType; + protected Class componentClazz; + protected int componentSize; protected boolean normalized; protected int stride; // user given stride protected int strideB; // stride in bytes protected int strideL; // stride in logical components - protected Class clazz; protected Buffer buffer; protected boolean isVertexAttribute; diff --git a/src/jogl/classes/com/jogamp/opengl/util/ImmModeSink.java b/src/jogl/classes/com/jogamp/opengl/util/ImmModeSink.java index be15dfb59..cb9e4cce5 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/ImmModeSink.java +++ b/src/jogl/classes/com/jogamp/opengl/util/ImmModeSink.java @@ -2,6 +2,8 @@ package com.jogamp.opengl.util; import com.jogamp.common.util.*; +import com.jogamp.opengl.util.glsl.ShaderState; + import javax.media.opengl.*; import javax.media.opengl.fixedfunc.*; import java.nio.*; @@ -36,7 +38,7 @@ public class ImmModeSink { * * @see #draw(GL, boolean) * @see com.jogamp.opengl.util.glsl.ShaderState#glUseProgram(GL2ES2, boolean) - * @see com.jogamp.opengl.util.glsl.ShaderState#getCurrent() + * @see com.jogamp.opengl.util.glsl.ShaderState#getCurrentShaderState() */ public static ImmModeSink createGLSL(GL gl, int glBufferUsage, int initialSize, int vComps, int vDataType, @@ -745,11 +747,11 @@ public class ImmModeSink { } public void enableBufferGLSL(GL gl, boolean enable) { - GL2ES2 glsl = gl.getGL2ES2(); - com.jogamp.opengl.util.glsl.ShaderState st = com.jogamp.opengl.util.glsl.ShaderState.getCurrent(); + ShaderState st = ShaderState.getShaderState(gl); if(null==st) { - throw new GLException("No ShaderState current"); - } + throw new GLException("No ShaderState in "+gl); + } + GL2ES2 glsl = gl.getGL2ES2(); if(enable) { glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, vboName); @@ -760,35 +762,35 @@ public class ImmModeSink { } if(vComps>0) { - st.glEnableVertexAttribArray(glsl, vArrayData.getName()); + st.glEnableVertexAttribArray(glsl, vArrayData); st.glVertexAttribPointer(glsl, vArrayData); } if(cComps>0) { - st.glEnableVertexAttribArray(glsl, cArrayData.getName()); + st.glEnableVertexAttribArray(glsl, cArrayData); st.glVertexAttribPointer(glsl, cArrayData); } if(nComps>0) { - st.glEnableVertexAttribArray(glsl, nArrayData.getName()); + st.glEnableVertexAttribArray(glsl, nArrayData); st.glVertexAttribPointer(glsl, nArrayData); } if(tComps>0) { - st.glEnableVertexAttribArray(glsl, tArrayData.getName()); + st.glEnableVertexAttribArray(glsl, tArrayData); st.glVertexAttribPointer(glsl, tArrayData); } glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); } else { if(vComps>0) { - st.glDisableVertexAttribArray(glsl, vArrayData.getName()); + st.glDisableVertexAttribArray(glsl, vArrayData); } if(cComps>0) { - st.glDisableVertexAttribArray(glsl, cArrayData.getName()); + st.glDisableVertexAttribArray(glsl, cArrayData); } if(nComps>0) { - st.glDisableVertexAttribArray(glsl, nArrayData.getName()); + st.glDisableVertexAttribArray(glsl, nArrayData); } if(tComps>0) { - st.glDisableVertexAttribArray(glsl, tArrayData.getName()); + st.glDisableVertexAttribArray(glsl, tArrayData); } } } @@ -860,26 +862,26 @@ public class ImmModeSink { buffer.flip(); if(vComps>0) { - vArrayData = GLArrayDataWrapper.createFixed(gl, GLPointerFunc.GL_VERTEX_ARRAY, vComps, vDataType, false, - 0, vertexArray, 0, vOffset, GL.GL_STATIC_DRAW, GL.GL_ARRAY_BUFFER); + vArrayData = GLArrayDataWrapper.createFixed(GLPointerFunc.GL_VERTEX_ARRAY, vComps, vDataType, false, 0, + vertexArray, 0, vOffset, GL.GL_STATIC_DRAW); } else { vArrayData = null; } if(cComps>0) { - cArrayData = GLArrayDataWrapper.createFixed(gl, GLPointerFunc.GL_COLOR_ARRAY, cComps, cDataType, false, - 0, colorArray, 0, cOffset, GL.GL_STATIC_DRAW, GL.GL_ARRAY_BUFFER); + cArrayData = GLArrayDataWrapper.createFixed(GLPointerFunc.GL_COLOR_ARRAY, cComps, cDataType, false, 0, + colorArray, 0, cOffset, GL.GL_STATIC_DRAW); } else { cArrayData = null; } if(nComps>0) { - nArrayData = GLArrayDataWrapper.createFixed(gl, GLPointerFunc.GL_NORMAL_ARRAY, nComps, nDataType, false, - 0, normalArray, 0, nOffset, GL.GL_STATIC_DRAW, GL.GL_ARRAY_BUFFER); + nArrayData = GLArrayDataWrapper.createFixed(GLPointerFunc.GL_NORMAL_ARRAY, nComps, nDataType, false, 0, + normalArray, 0, nOffset, GL.GL_STATIC_DRAW); } else { nArrayData = null; } if(tComps>0) { - tArrayData = GLArrayDataWrapper.createFixed(gl, GLPointerFunc.GL_TEXTURE_COORD_ARRAY, tComps, tDataType, false, - 0, textCoordArray, 0, tOffset, GL.GL_STATIC_DRAW, GL.GL_ARRAY_BUFFER); + tArrayData = GLArrayDataWrapper.createFixed(GLPointerFunc.GL_TEXTURE_COORD_ARRAY, tComps, tDataType, false, 0, + textCoordArray, 0, tOffset, GL.GL_STATIC_DRAW); } else { tArrayData = null; } diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/GLSLArrayHandler.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/GLSLArrayHandler.java index 1ce39d557..f771ea019 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/glsl/GLSLArrayHandler.java +++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/GLSLArrayHandler.java @@ -28,56 +28,68 @@ package com.jogamp.opengl.util.glsl; -import javax.media.opengl.*; -import com.jogamp.opengl.util.*; -import java.nio.*; +import java.nio.Buffer; + +import javax.media.opengl.GL; +import javax.media.opengl.GL2ES2; +import javax.media.opengl.GLException; +import com.jogamp.opengl.util.GLArrayDataEditable; +import com.jogamp.opengl.util.GLArrayHandler; public class GLSLArrayHandler implements GLArrayHandler { + private static final boolean DEBUG = ShaderState.DEBUG; private GLArrayDataEditable ad; + private ShaderState st; - public GLSLArrayHandler(GLArrayDataEditable ad) { + public GLSLArrayHandler(ShaderState st, GLArrayDataEditable ad) { + this.st = st; this.ad = ad; } - private final void passVertexAttribPointer(GL2ES2 gl, ShaderState st) { - st.glVertexAttribPointer(gl, ad); - } - public void enableBuffer(GL gl, boolean enable) { if(!gl.isGL2ES2()) { throw new GLException("GLSLArrayHandler expects a GL2ES2 implementation"); } GL2ES2 glsl = gl.getGL2ES2(); - ShaderState st = ShaderState.getCurrent(); - if(null==st) { - throw new GLException("No ShaderState current"); - } if(enable) { - st.glEnableVertexAttribArray(glsl, ad.getName()); + st.glEnableVertexAttribArray(glsl, ad); Buffer buffer = ad.getBuffer(); if(ad.isVBO()) { - // always bind and refresh the VBO mgr, - // in case more than one gl*Pointer objects are in use - glsl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName()); + // bind and refresh the VBO / vertex-attr only if necessary if(!ad.isVBOWritten()) { + if(DEBUG) { + System.err.println("XXX VA "+ad.getName()+" VBO write: "+ad.getVBOName()); + } + glsl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName()); if(null!=buffer) { - glsl.glBufferData(ad.getVBOTarget(), buffer.limit() * ad.getComponentSize(), buffer, ad.getVBOUsage()); + glsl.glBufferData(ad.getVBOTarget(), ad.getByteSize(), buffer, ad.getVBOUsage()); } ad.setVBOWritten(true); + st.glVertexAttribPointer(glsl, ad); + } else { + // didn't experience a performance hit on this query .. + int[] qi = new int[1]; + glsl.glGetVertexAttribiv(ad.getLocation(), GL2ES2.GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, qi, 0); + if(ad.getVBOName() != qi[0]) { + if(DEBUG) { + System.err.println("XXX VA "+ad.getName()+" VBO rebind: "+qi[0]+" -> "+ad.getVBOName()); + } + glsl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName()); + st.glVertexAttribPointer(glsl, ad); + } } - passVertexAttribPointer(glsl, st); } else if(null!=buffer) { - passVertexAttribPointer(glsl, st); + st.glVertexAttribPointer(glsl, ad); ad.setVBOWritten(true); } } else { if(ad.isVBO()) { glsl.glBindBuffer(ad.getVBOTarget(), 0); } - st.glDisableVertexAttribArray(glsl, ad.getName()); + st.glDisableVertexAttribArray(glsl, ad); } } |