diff options
Diffstat (limited to 'src/jogl/classes/jogamp')
10 files changed, 254 insertions, 43 deletions
diff --git a/src/jogl/classes/jogamp/opengl/ProjectFloat.java b/src/jogl/classes/jogamp/opengl/ProjectFloat.java index a6316b242..1c69fa370 100644 --- a/src/jogl/classes/jogamp/opengl/ProjectFloat.java +++ b/src/jogl/classes/jogamp/opengl/ProjectFloat.java @@ -235,9 +235,18 @@ public class ProjectFloat { /** * Make matrix an identity matrix */ - public static void gluMakeIdentityf(float[] m) { + public static void gluMakeIdentityf(float[] m, int offset) { for (int i = 0; i < 16; i++) { - m[i] = IDENTITY_MATRIX[i]; + m[i+offset] = IDENTITY_MATRIX[i]; + } + } + + /** + * Make matrix an zero matrix + */ + public static void gluMakeZero(float[] m, int offset) { + for (int i = 0; i < 16; i++) { + m[i+offset] = 0; } } @@ -280,21 +289,22 @@ public class ProjectFloat { /** * @param src + * @param srcOffset * @param inverse - * + * @param inverseOffset * @return */ - public boolean gluInvertMatrixf(float[] src, float[] inverse) { + public boolean gluInvertMatrixf(float[] src, int srcOffset, float[] inverse, int inverseOffset) { int i, j, k, swap; float t; float[][] temp = tempInvertMatrix; for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { - temp[i][j] = src[i*4+j]; + temp[i][j] = src[i*4+j+srcOffset]; } } - gluMakeIdentityf(inverse); + gluMakeIdentityf(inverse, inverseOffset); for (i = 0; i < 4; i++) { // @@ -316,9 +326,9 @@ public class ProjectFloat { temp[i][k] = temp[swap][k]; temp[swap][k] = t; - t = inverse[i*4+k]; - inverse[i*4+k] = inverse[swap*4+k]; - inverse[swap*4+k] = t; + t = inverse[i*4+k+inverseOffset]; + inverse[i*4+k+inverseOffset] = inverse[swap*4+k+inverseOffset]; + inverse[swap*4+k+inverseOffset] = t; } } @@ -333,14 +343,14 @@ public class ProjectFloat { t = temp[i][i]; for (k = 0; k < 4; k++) { temp[i][k] /= t; - inverse[i*4+k] /= t; + inverse[i*4+k+inverseOffset] /= t; } for (j = 0; j < 4; j++) { if (j != i) { t = temp[j][i]; for (k = 0; k < 4; k++) { temp[j][k] -= temp[i][k] * t; - inverse[j*4+k] -= inverse[i*4+k]*t; + inverse[j*4+k+inverseOffset] -= inverse[i*4+k+inverseOffset]*t; } } } @@ -781,7 +791,7 @@ public class ProjectFloat { gluMultMatricesf(modelMatrix, modelMatrix_offset, projMatrix, projMatrix_offset, matrix); - if (!gluInvertMatrixf(matrix, matrix)) + if (!gluInvertMatrixf(matrix, 0, matrix, 0)) return false; in[0] = winx; @@ -907,7 +917,7 @@ public class ProjectFloat { gluMultMatricesf(modelMatrix, modelMatrix_offset, projMatrix, projMatrix_offset, matrix); - if (!gluInvertMatrixf(matrix, matrix)) + if (!gluInvertMatrixf(matrix, 0, matrix, 0)) return false; in[0] = winx; diff --git a/src/jogl/classes/jogamp/opengl/util/GLArrayHandler.java b/src/jogl/classes/jogamp/opengl/util/GLArrayHandler.java index 4a570d3a7..22690b06d 100644 --- a/src/jogl/classes/jogamp/opengl/util/GLArrayHandler.java +++ b/src/jogl/classes/jogamp/opengl/util/GLArrayHandler.java @@ -63,7 +63,9 @@ public interface GLArrayHandler { * @param handler the sub handler * @throws UnsupportedOperationException if this array handler does not support interleaved arrays */ - public void addSubHandler(GLArrayHandler handler) throws UnsupportedOperationException; + public void addSubHandler(GLArrayHandlerFlat handler) throws UnsupportedOperationException; + public void setSubArrayVBOName(int vboName); + } diff --git a/src/jogl/classes/jogamp/opengl/util/GLArrayHandlerFlat.java b/src/jogl/classes/jogamp/opengl/util/GLArrayHandlerFlat.java new file mode 100644 index 000000000..dca9129ad --- /dev/null +++ b/src/jogl/classes/jogamp/opengl/util/GLArrayHandlerFlat.java @@ -0,0 +1,61 @@ +/** + * Copyright 2011 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ + +package jogamp.opengl.util; + +import javax.media.opengl.*; + +import com.jogamp.opengl.util.GLArrayDataWrapper; + +/** + * Handles consistency of interleaved array state. + */ +public interface GLArrayHandlerFlat { + + /** + * Implementation shall associate the data with the array + * + * @param gl current GL object + * @param enable true if array data shall be valid, otherwise false. + * @param force true force data association, bypassing optimization + * @param ext extension object allowing passing of an implementation detail + */ + public void syncData(GL gl, boolean enable, boolean force, Object ext); + + /** + * Implementation shall enable or disable the array state. + * + * @param gl current GL object + * @param enable true if array shall be enabled, otherwise false. + * @param ext extension object allowing passing of an implementation detail + */ + public void enableState(GL gl, boolean enable, Object ext); + + public GLArrayDataWrapper getData(); +} + diff --git a/src/jogl/classes/jogamp/opengl/util/GLArrayHandlerInterleaved.java b/src/jogl/classes/jogamp/opengl/util/GLArrayHandlerInterleaved.java index 8e813a79b..d31b41582 100644 --- a/src/jogl/classes/jogamp/opengl/util/GLArrayHandlerInterleaved.java +++ b/src/jogl/classes/jogamp/opengl/util/GLArrayHandlerInterleaved.java @@ -43,19 +43,25 @@ import com.jogamp.opengl.util.GLArrayDataEditable; */ public class GLArrayHandlerInterleaved implements GLArrayHandler { private GLArrayDataEditable ad; - private List<GLArrayHandler> subArrays = new ArrayList<GLArrayHandler>(); + private List<GLArrayHandlerFlat> subArrays = new ArrayList<GLArrayHandlerFlat>(); public GLArrayHandlerInterleaved(GLArrayDataEditable ad) { this.ad = ad; } - public final void addSubHandler(GLArrayHandler handler) { + public final void setSubArrayVBOName(int vboName) { + for(int i=0; i<subArrays.size(); i++) { + subArrays.get(i).getData().setVBOName(vboName); + } + } + + public final void addSubHandler(GLArrayHandlerFlat handler) { subArrays.add(handler); } - private final void syncSubData(GL gl, boolean enable, Object ext) { + private final void syncSubData(GL gl, boolean enable, boolean force, Object ext) { for(int i=0; i<subArrays.size(); i++) { - subArrays.get(i).syncData(gl, enable, ext); + subArrays.get(i).syncData(gl, enable, force, ext); } } @@ -74,9 +80,9 @@ public class GLArrayHandlerInterleaved implements GLArrayHandler { ad.setVBOWritten(true); } } - syncSubData(gl, true, ext); + syncSubData(gl, true, true, ext); } else { - syncSubData(gl, false, ext); + syncSubData(gl, false, true, ext); if(ad.isVBO()) { gl.glBindBuffer(ad.getVBOTarget(), 0); } diff --git a/src/jogl/classes/jogamp/opengl/util/GLDataArrayHandler.java b/src/jogl/classes/jogamp/opengl/util/GLDataArrayHandler.java index c91d6c93e..6c8e2e762 100644 --- a/src/jogl/classes/jogamp/opengl/util/GLDataArrayHandler.java +++ b/src/jogl/classes/jogamp/opengl/util/GLDataArrayHandler.java @@ -45,7 +45,11 @@ public class GLDataArrayHandler implements GLArrayHandler { this.ad = ad; } - public final void addSubHandler(GLArrayHandler handler) { + public final void setSubArrayVBOName(int vboName) { + throw new UnsupportedOperationException(); + } + + public final void addSubHandler(GLArrayHandlerFlat handler) { throw new UnsupportedOperationException(); } diff --git a/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandler.java b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandler.java index 8963b7985..d8939dc0f 100644 --- a/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandler.java +++ b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandler.java @@ -45,8 +45,12 @@ public class GLFixedArrayHandler implements GLArrayHandler { public GLFixedArrayHandler(GLArrayDataEditable ad) { this.ad = ad; } - - public final void addSubHandler(GLArrayHandler handler) { + + public final void setSubArrayVBOName(int vboName) { + throw new UnsupportedOperationException(); + } + + public final void addSubHandler(GLArrayHandlerFlat handler) { throw new UnsupportedOperationException(); } diff --git a/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerFlat.java b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerFlat.java index 81c782dab..2937cc720 100644 --- a/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerFlat.java +++ b/src/jogl/classes/jogamp/opengl/util/GLFixedArrayHandlerFlat.java @@ -29,27 +29,27 @@ package jogamp.opengl.util; import javax.media.opengl.GL; -import javax.media.opengl.GLArrayData; import javax.media.opengl.GLException; import javax.media.opengl.fixedfunc.GLPointerFunc; +import com.jogamp.opengl.util.GLArrayDataWrapper; /** * Used for interleaved fixed function arrays, i.e. where the buffer data itself is handled * separately and interleaves many arrays. */ -public class GLFixedArrayHandlerFlat implements GLArrayHandler { - private GLArrayData ad; +public class GLFixedArrayHandlerFlat implements GLArrayHandlerFlat { + private GLArrayDataWrapper ad; - public GLFixedArrayHandlerFlat(GLArrayData ad) { + public GLFixedArrayHandlerFlat(GLArrayDataWrapper ad) { this.ad = ad; } - public final void addSubHandler(GLArrayHandler handler) { - throw new UnsupportedOperationException(); + public GLArrayDataWrapper getData() { + return ad; } - public final void syncData(GL gl, boolean enable, Object ext) { + public final void syncData(GL gl, boolean enable, boolean force, Object ext) { if(enable) { final GLPointerFunc glp = gl.getGL2ES1(); switch(ad.getIndex()) { diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandler.java b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandler.java index 96bb02b19..602d283d6 100644 --- a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandler.java +++ b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandler.java @@ -34,6 +34,7 @@ import javax.media.opengl.GL; import javax.media.opengl.GL2ES2; import jogamp.opengl.util.GLArrayHandler; +import jogamp.opengl.util.GLArrayHandlerFlat; import com.jogamp.opengl.util.GLArrayDataEditable; import com.jogamp.opengl.util.glsl.ShaderState; @@ -48,8 +49,12 @@ public class GLSLArrayHandler implements GLArrayHandler { public GLSLArrayHandler(GLArrayDataEditable ad) { this.ad = ad; } - - public final void addSubHandler(GLArrayHandler handler) { + + public final void setSubArrayVBOName(int vboName) { + throw new UnsupportedOperationException(); + } + + public final void addSubHandler(GLArrayHandlerFlat handler) { throw new UnsupportedOperationException(); } diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerFlat.java b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerFlat.java index 0d6da7ba4..c4b761b13 100644 --- a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerFlat.java +++ b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerFlat.java @@ -30,31 +30,48 @@ package jogamp.opengl.util.glsl; import javax.media.opengl.GL; import javax.media.opengl.GL2ES2; -import javax.media.opengl.GLArrayData; -import jogamp.opengl.util.GLArrayHandler; +import jogamp.opengl.util.GLArrayHandlerFlat; +import com.jogamp.opengl.util.GLArrayDataWrapper; import com.jogamp.opengl.util.glsl.ShaderState; /** * Used for interleaved GLSL arrays, i.e. where the buffer data itself is handled * separately and interleaves many arrays. */ -public class GLSLArrayHandlerFlat implements GLArrayHandler { - private GLArrayData ad; +public class GLSLArrayHandlerFlat implements GLArrayHandlerFlat { + private GLArrayDataWrapper ad; - public GLSLArrayHandlerFlat(GLArrayData ad) { + public GLSLArrayHandlerFlat(GLArrayDataWrapper ad) { this.ad = ad; } - public final void addSubHandler(GLArrayHandler handler) { - throw new UnsupportedOperationException(); + public GLArrayDataWrapper getData() { + return ad; } - - public final void syncData(GL gl, boolean enable, Object ext) { - final ShaderState st = (ShaderState) ext; + + public final void syncData(GL gl, boolean enable, boolean force, Object ext) { if(enable) { - st.vertexAttribPointer(gl.getGL2ES2(), ad); + final GL2ES2 glsl = gl.getGL2ES2(); + final ShaderState st = (ShaderState) ext; + + st.vertexAttribPointer(glsl, ad); + /** + * Due to probable application VBO switching, this might not make any sense .. + * + if(force) { + st.vertexAttribPointer(glsl, ad); + } else if(st.getAttribLocation(glsl, ad) >= 0) { + final int[] qi = new int[1]; + glsl.glGetVertexAttribiv(ad.getLocation(), GL2ES2.GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, qi, 0); + if(ad.getVBOName() != qi[0]) { + System.err.println("XXX1: "+ad.getName()+", vbo ad "+ad.getVBOName()+", gl "+qi[0]+", "+ad); + st.vertexAttribPointer(glsl, ad); + } else { + System.err.println("XXX0: "+ad.getName()+", vbo ad "+ad.getVBOName()+", gl "+qi[0]+", "+ad); + } + }*/ } } diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerInterleaved.java b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerInterleaved.java new file mode 100644 index 000000000..f50429623 --- /dev/null +++ b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLArrayHandlerInterleaved.java @@ -0,0 +1,102 @@ +/** + * Copyright 2010 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ + +package jogamp.opengl.util.glsl; + +import java.nio.Buffer; +import java.util.ArrayList; +import java.util.List; + +import javax.media.opengl.GL; + +import jogamp.opengl.util.GLArrayHandler; +import jogamp.opengl.util.GLArrayHandlerFlat; + +import com.jogamp.opengl.util.GLArrayDataEditable; + +/** + * Interleaved fixed function arrays, i.e. where this buffer data + * represents many arrays. + */ +public class GLSLArrayHandlerInterleaved implements GLArrayHandler { + private GLArrayDataEditable ad; + private List<GLArrayHandlerFlat> subArrays = new ArrayList<GLArrayHandlerFlat>(); + + public GLSLArrayHandlerInterleaved(GLArrayDataEditable ad) { + this.ad = ad; + } + + public final void setSubArrayVBOName(int vboName) { + for(int i=0; i<subArrays.size(); i++) { + subArrays.get(i).getData().setVBOName(vboName); + } + } + + public final void addSubHandler(GLArrayHandlerFlat handler) { + subArrays.add(handler); + } + + private final void syncSubData(GL gl, boolean enable, boolean force, Object ext) { + for(int i=0; i<subArrays.size(); i++) { + subArrays.get(i).syncData(gl, enable, force, ext); + } + } + + public final void syncData(GL gl, boolean enable, Object ext) { + if(!ad.isVBO()) { + throw new InternalError("Interleaved handle is not VBO: "+ad); + } + + if(enable) { + final Buffer buffer = ad.getBuffer(); + final boolean vboWritten = ad.isVBOWritten(); + + // always bind and refresh the VBO mgr, + // in case more than one gl*Pointer objects are in use + gl.glBindBuffer(ad.getVBOTarget(), ad.getVBOName()); + if(!vboWritten) { + if(null!=buffer) { + gl.glBufferData(ad.getVBOTarget(), buffer.limit() * ad.getComponentSizeInBytes(), buffer, ad.getVBOUsage()); + } + ad.setVBOWritten(true); + } + // sub data will decide weather to update the vertex attrib pointer + syncSubData(gl, true, !vboWritten, ext); + } else { + // NOP on GLSL: syncSubData(gl, false, ext); + gl.glBindBuffer(ad.getVBOTarget(), 0); + } + } + + public final void enableState(GL gl, boolean enable, Object ext) { + for(int i=0; i<subArrays.size(); i++) { + subArrays.get(i).enableState(gl, enable, ext); + } + } +} + |