summaryrefslogtreecommitdiffstats
path: root/src/jogl/classes
diff options
context:
space:
mode:
Diffstat (limited to 'src/jogl/classes')
-rw-r--r--src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java425
-rw-r--r--src/jogl/classes/jogamp/opengl/ProjectFloat.java36
2 files changed, 271 insertions, 190 deletions
diff --git a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
index aba6c90a7..a86a2f435 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
@@ -45,7 +45,30 @@ import javax.media.opengl.fixedfunc.GLMatrixFunc;
public class PMVMatrix implements GLMatrixFunc {
+ protected final float[] matrixBufferArray;
+
+ /**
+ * Creates an instance of PMVMatrix {@link #PMVMatrix(boolean) PMVMatrix(boolean useBackingArray)},
+ * with <code>useBackingArray = true</code>.
+ */
public PMVMatrix() {
+ this(true);
+ }
+
+ /**
+ * Creates an instance of PMVMatrix.
+ *
+ * @param useBackingArray <code>true</code> for non direct NIO Buffers with guaranteed backing array,
+ * which allows faster access in Java computation.
+ * <p><code>false</code> for direct NIO buffers w/o a guaranteed backing array.
+ * In most Java implementations, direct NIO buffers have no backing array
+ * and hence the Java computation will be throttled down by direct IO get/put
+ * operations.</p>
+ * <p>Depending on the application, ie. weather the Java computation or
+ * JNI invocation and hence native data transfer part is heavier,
+ * this flag shall be set to <code>true</code> or <code>false</code></p>.
+ */
+ public PMVMatrix(boolean useBackingArray) {
projectFloat = new ProjectFloat();
// I Identity
@@ -54,33 +77,43 @@ public class PMVMatrix implements GLMatrixFunc {
// Mv ModelView
// Mvi Modelview-Inverse
// Mvit Modelview-Inverse-Transpose
- matrixBuffer = Buffers.newDirectByteBuffer(12*16 * Buffers.SIZEOF_FLOAT);
- // I + T + P + Mv + Mvi + Mvit + Local
- matrixIdent = slice2Float(matrixBuffer, 0*16, 1*16); // I
- matrixTex = slice2Float(matrixBuffer, 1*16, 1*16); // T
- matrixPMvMvit = slice2Float(matrixBuffer, 2*16, 4*16); // P + Mv + Mvi + Mvit
- matrixPMvMvi = slice2Float(matrixBuffer, 2*16, 3*16); // P + Mv + Mvi
- matrixPMv = slice2Float(matrixBuffer, 2*16, 2*16); // P + Mv
- matrixP = slice2Float(matrixBuffer, 2*16, 1*16); // P
- matrixMv = slice2Float(matrixBuffer, 3*16, 1*16); // Mv
- matrixMvi = slice2Float(matrixBuffer, 4*16, 1*16); // Mvi
- matrixMvit = slice2Float(matrixBuffer, 5*16, 1*16); // Mvit
- matrixMult = slice2Float(matrixBuffer, 6*16, 1*16);
- matrixTrans = slice2Float(matrixBuffer, 7*16, 1*16);
- matrixRot = slice2Float(matrixBuffer, 8*16, 1*16);
- matrixScale = slice2Float(matrixBuffer, 9*16, 1*16);
- matrixOrtho = slice2Float(matrixBuffer, 10*16, 1*16);
- matrixFrustum = slice2Float(matrixBuffer, 11*16, 1*16);
- matrixBuffer.rewind();
+ if(useBackingArray) {
+ matrixBufferArray = new float[6*16];
+ matrixBuffer = null;
+ // matrixBuffer = FloatBuffer.wrap(new float[12*16]);
+ } else {
+ matrixBufferArray = null;
+ matrixBuffer = Buffers.newDirectByteBuffer(6*16 * Buffers.SIZEOF_FLOAT);
+ matrixBuffer.mark();
+ }
+ matrixIdent = slice2Float(matrixBuffer, matrixBufferArray, 0*16, 1*16); // I
+ matrixTex = slice2Float(matrixBuffer, matrixBufferArray, 1*16, 1*16); // T
+ matrixPMvMvit = slice2Float(matrixBuffer, matrixBufferArray, 2*16, 4*16); // P + Mv + Mvi + Mvit
+ matrixPMvMvi = slice2Float(matrixBuffer, matrixBufferArray, 2*16, 3*16); // P + Mv + Mvi
+ matrixPMv = slice2Float(matrixBuffer, matrixBufferArray, 2*16, 2*16); // P + Mv
+ matrixP = slice2Float(matrixBuffer, matrixBufferArray, 2*16, 1*16); // P
+ matrixMv = slice2Float(matrixBuffer, matrixBufferArray, 3*16, 1*16); // Mv
+ matrixMvi = slice2Float(matrixBuffer, matrixBufferArray, 4*16, 1*16); // Mvi
+ matrixMvit = slice2Float(matrixBuffer, matrixBufferArray, 5*16, 1*16); // Mvit
+
+ if(null != matrixBuffer) {
+ matrixBuffer.reset();
+ }
ProjectFloat.gluMakeIdentityf(matrixIdent);
- ProjectFloat.gluMakeIdentityf(matrixTrans);
- ProjectFloat.gluMakeIdentityf(matrixRot);
- ProjectFloat.gluMakeIdentityf(matrixScale);
- ProjectFloat.gluMakeIdentityf(matrixOrtho);
- ProjectFloat.gluMakeZero(matrixFrustum);
-
- vec3f=new float[3];
+
+ vec3f = new float[3];
+ matrixMult = new float[16];
+ matrixTrans = new float[16];
+ matrixRot = new float[16];
+ matrixScale = new float[16];
+ matrixOrtho = new float[16];
+ matrixFrustum = new float[16];
+ ProjectFloat.gluMakeIdentityf(matrixTrans, 0);
+ ProjectFloat.gluMakeIdentityf(matrixRot, 0);
+ ProjectFloat.gluMakeIdentityf(matrixScale, 0);
+ ProjectFloat.gluMakeIdentityf(matrixOrtho, 0);
+ ProjectFloat.gluMakeZero(matrixFrustum, 0);
matrixPStack = new ArrayList<float[]>();
matrixMvStack= new ArrayList<float[]>();
@@ -101,27 +134,30 @@ public class PMVMatrix implements GLMatrixFunc {
projectFloat.destroy(); projectFloat=null;
}
- if(null!=matrixBuffer) {
- matrixBuffer.clear(); matrixBuffer=null;
- }
-
+ matrixBuffer=null;
+ matrixBuffer=null; matrixPMvMvit=null; matrixPMvMvi=null; matrixPMv=null;
+ matrixP=null; matrixTex=null; matrixMv=null; matrixMvi=null; matrixMvit=null;
+
+ vec3f = null;
+ matrixMult = null;
+ matrixTrans = null;
+ matrixRot = null;
+ matrixScale = null;
+ matrixOrtho = null;
+ matrixFrustum = null;
+
if(null!=matrixPStack) {
matrixPStack.clear(); matrixPStack=null;
}
- vec3f=null;
if(null!=matrixMvStack) {
matrixMvStack.clear(); matrixMvStack=null;
}
if(null!=matrixPStack) {
- matrixPStack.clear(); matrixPStack=null;
+ matrixPStack.clear(); matrixPStack=null;
}
if(null!=matrixTStack) {
matrixTStack.clear(); matrixTStack=null;
}
-
- matrixBuffer=null; matrixPMvMvit=null; matrixPMvMvi=null; matrixPMv=null;
- matrixP=null; matrixTex=null; matrixMv=null; matrixMvi=null; matrixMvit=null;
- matrixMult=null; matrixTrans=null; matrixRot=null; matrixScale=null; matrixOrtho=null; matrixFrustum=null;
}
@@ -133,14 +169,33 @@ public class PMVMatrix implements GLMatrixFunc {
* This bug is resolved at least in Android 3.2.
*
* @param buf source ByteBuffer
+ * @param backing source float array
* @param posFloat {@link Buffers#SIZEOF_FLOAT} position
* @param lenFloat {@link Buffers#SIZEOF_FLOAT} size
* @return FloatBuffer w/ native byte order as given ByteBuffer
*/
- private static FloatBuffer slice2Float(ByteBuffer buf, int posFloat, int lenFloat) {
- buf.position( posFloat * Buffers.SIZEOF_FLOAT );
- buf.limit( (posFloat + lenFloat) * Buffers.SIZEOF_FLOAT );
- return buf.slice().order(buf.order()).asFloatBuffer(); // slice and duplicate may change byte order
+ private static FloatBuffer slice2Float(Buffer buf, float[] backing, int posFloat, int lenFloat) {
+ if(buf instanceof ByteBuffer) {
+ ByteBuffer bb = (ByteBuffer) buf;
+ bb.position( posFloat * Buffers.SIZEOF_FLOAT );
+ bb.limit( (posFloat + lenFloat) * Buffers.SIZEOF_FLOAT );
+ FloatBuffer fb = bb.slice().order(bb.order()).asFloatBuffer(); // slice and duplicate may change byte order
+ fb.mark();
+ return fb;
+ } else if(null != backing) {
+ FloatBuffer fb = FloatBuffer.wrap(backing, posFloat, lenFloat);
+ fb.mark();
+ return fb;
+ } else if(buf instanceof FloatBuffer) {
+ FloatBuffer fb = (FloatBuffer) buf;
+ fb.position( posFloat );
+ fb.limit( posFloat + lenFloat );
+ FloatBuffer fb0 = fb.slice(); // slice and duplicate may change byte order
+ fb0.mark();
+ return fb0;
+ } else {
+ throw new InternalError("XXX");
+ }
}
public static final boolean isMatrixModeName(final int matrixModeName) {
@@ -231,7 +286,6 @@ public class PMVMatrix implements GLMatrixFunc {
if(0==modified) return false;
final int res = modified;
- // int res = DIRTY_MODELVIEW | DIRTY_PROJECTION ;
if( (res&DIRTY_MODELVIEW)!=0 ) {
setMviMvit();
}
@@ -255,11 +309,8 @@ public class PMVMatrix implements GLMatrixFunc {
return matrixMv;
}
- public final FloatBuffer glGetPMvMvitMatrixf() {
- return matrixPMvMvit;
- }
-
public final FloatBuffer glGetPMvMviMatrixf() {
+ usesMviMvit |= 1;
return matrixPMvMvi;
}
@@ -268,9 +319,20 @@ public class PMVMatrix implements GLMatrixFunc {
}
public final FloatBuffer glGetMviMatrixf() {
+ usesMviMvit |= 1;
return matrixMvi;
}
+ public final FloatBuffer glGetPMvMvitMatrixf() {
+ usesMviMvit |= 1 | 2;
+ return matrixPMvMvit;
+ }
+
+ public final FloatBuffer glGetMvitMatrixf() {
+ usesMviMvit |= 1 | 2;
+ return matrixMvit;
+ }
+
/*
* @return the current matrix
*/
@@ -302,22 +364,27 @@ public class PMVMatrix implements GLMatrixFunc {
glFrustumf(left, right, bottom, top, zNear, zFar);
}
- public static final void glMultMatrixf(final FloatBuffer a, final FloatBuffer b, FloatBuffer p) {
+ public static final void glMultMatrixf(final FloatBuffer a, final FloatBuffer b, FloatBuffer d) {
+ final int aP = a.position();
+ final int bP = b.position();
+ final int dP = d.position();
for (int i = 0; i < 4; i++) {
- final float ai0=a.get(i+0*4), ai1=a.get(i+1*4), ai2=a.get(i+2*4), ai3=a.get(i+3*4);
- p.put(i+0*4 , ai0 * b.get(0+0*4) + ai1 * b.get(1+0*4) + ai2 * b.get(2+0*4) + ai3 * b.get(3+0*4) );
- p.put(i+1*4 , ai0 * b.get(0+1*4) + ai1 * b.get(1+1*4) + ai2 * b.get(2+1*4) + ai3 * b.get(3+1*4) );
- p.put(i+2*4 , ai0 * b.get(0+2*4) + ai1 * b.get(1+2*4) + ai2 * b.get(2+2*4) + ai3 * b.get(3+2*4) );
- p.put(i+3*4 , ai0 * b.get(0+3*4) + ai1 * b.get(1+3*4) + ai2 * b.get(2+3*4) + ai3 * b.get(3+3*4) );
+ final float ai0=a.get(aP+i+0*4), ai1=a.get(aP+i+1*4), ai2=a.get(aP+i+2*4), ai3=a.get(aP+i+3*4);
+ d.put(dP+i+0*4 , ai0 * b.get(bP+0+0*4) + ai1 * b.get(bP+1+0*4) + ai2 * b.get(bP+2+0*4) + ai3 * b.get(bP+3+0*4) );
+ d.put(dP+i+1*4 , ai0 * b.get(bP+0+1*4) + ai1 * b.get(bP+1+1*4) + ai2 * b.get(bP+2+1*4) + ai3 * b.get(bP+3+1*4) );
+ d.put(dP+i+2*4 , ai0 * b.get(bP+0+2*4) + ai1 * b.get(bP+1+2*4) + ai2 * b.get(bP+2+2*4) + ai3 * b.get(bP+3+2*4) );
+ d.put(dP+i+3*4 , ai0 * b.get(bP+0+3*4) + ai1 * b.get(bP+1+3*4) + ai2 * b.get(bP+2+3*4) + ai3 * b.get(bP+3+3*4) );
}
}
- public static final void glMultMatrixf(final FloatBuffer a, final float[] b, int b_off, FloatBuffer p) {
+ public static final void glMultMatrixf(final FloatBuffer a, final float[] b, int b_off, FloatBuffer d) {
+ final int aP = a.position();
+ final int dP = d.position();
for (int i = 0; i < 4; i++) {
- final float ai0=a.get(i+0*4), ai1=a.get(i+1*4), ai2=a.get(i+2*4), ai3=a.get(i+3*4);
- p.put(i+0*4 , ai0 * b[b_off+0+0*4] + ai1 * b[b_off+1+0*4] + ai2 * b[b_off+2+0*4] + ai3 * b[b_off+3+0*4] );
- p.put(i+1*4 , ai0 * b[b_off+0+1*4] + ai1 * b[b_off+1+1*4] + ai2 * b[b_off+2+1*4] + ai3 * b[b_off+3+1*4] );
- p.put(i+2*4 , ai0 * b[b_off+0+2*4] + ai1 * b[b_off+1+2*4] + ai2 * b[b_off+2+2*4] + ai3 * b[b_off+3+2*4] );
- p.put(i+3*4 , ai0 * b[b_off+0+3*4] + ai1 * b[b_off+1+3*4] + ai2 * b[b_off+2+3*4] + ai3 * b[b_off+3+3*4] );
+ final float ai0=a.get(aP+i+0*4), ai1=a.get(aP+i+1*4), ai2=a.get(aP+i+2*4), ai3=a.get(aP+i+3*4);
+ d.put(dP+i+0*4 , ai0 * b[b_off+0+0*4] + ai1 * b[b_off+1+0*4] + ai2 * b[b_off+2+0*4] + ai3 * b[b_off+3+0*4] );
+ d.put(dP+i+1*4 , ai0 * b[b_off+0+1*4] + ai1 * b[b_off+1+1*4] + ai2 * b[b_off+2+1*4] + ai3 * b[b_off+3+1*4] );
+ d.put(dP+i+2*4 , ai0 * b[b_off+0+2*4] + ai1 * b[b_off+1+2*4] + ai2 * b[b_off+2+2*4] + ai3 * b[b_off+3+2*4] );
+ d.put(dP+i+3*4 , ai0 * b[b_off+0+3*4] + ai1 * b[b_off+1+3*4] + ai2 * b[b_off+2+3*4] + ai3 * b[b_off+3+3*4] );
}
}
@@ -343,8 +410,8 @@ public class PMVMatrix implements GLMatrixFunc {
params.put((float)matrixMode);
} else {
FloatBuffer matrix = glGetMatrixf(matrixGetName2MatrixModeName(matrixGetName));
- params.put(matrix);
- matrix.rewind();
+ params.put(matrix); // matrix -> params
+ matrix.reset();
}
params.position(pos);
}
@@ -353,8 +420,8 @@ public class PMVMatrix implements GLMatrixFunc {
params[params_offset]=(float)matrixMode;
} else {
FloatBuffer matrix = glGetMatrixf(matrixGetName2MatrixModeName(matrixGetName));
- matrix.get(params, params_offset, 16);
- matrix.rewind();
+ matrix.get(params, params_offset, 16); // matrix -> params
+ matrix.reset();
}
}
public void glGetIntegerv(int pname, IntBuffer params) {
@@ -377,19 +444,16 @@ public class PMVMatrix implements GLMatrixFunc {
public final void glLoadMatrixf(final float[] values, final int offset) {
int len = values.length-offset;
if(matrixMode==GL_MODELVIEW) {
- matrixMv.clear();
matrixMv.put(values, offset, len);
- matrixMv.rewind();
+ matrixMv.reset();
modified |= DIRTY_MODELVIEW ;
} else if(matrixMode==GL_PROJECTION) {
- matrixP.clear();
matrixP.put(values, offset, len);
- matrixP.rewind();
+ matrixP.reset();
modified |= DIRTY_PROJECTION ;
} else if(matrixMode==GL.GL_TEXTURE) {
- matrixTex.clear();
matrixTex.put(values, offset, len);
- matrixTex.rewind();
+ matrixTex.reset();
modified |= DIRTY_TEXTURE ;
}
}
@@ -397,19 +461,16 @@ public class PMVMatrix implements GLMatrixFunc {
public final void glLoadMatrixf(java.nio.FloatBuffer m) {
int spos = m.position();
if(matrixMode==GL_MODELVIEW) {
- matrixMv.clear();
matrixMv.put(m);
- matrixMv.rewind();
+ matrixMv.reset();
modified |= DIRTY_MODELVIEW ;
} else if(matrixMode==GL_PROJECTION) {
- matrixP.clear();
matrixP.put(m);
- matrixP.rewind();
+ matrixP.reset();
modified |= DIRTY_PROJECTION ;
} else if(matrixMode==GL.GL_TEXTURE) {
- matrixTex.clear();
matrixTex.put(m);
- matrixTex.rewind();
+ matrixTex.reset();
modified |= DIRTY_TEXTURE ;
}
m.position(spos);
@@ -431,85 +492,60 @@ public class PMVMatrix implements GLMatrixFunc {
float[] stackEntry = new float[1*16];
if(matrixMode==GL_MODELVIEW) {
matrixMv.get(stackEntry);
- matrixMv.rewind();
+ matrixMv.reset();
matrixMvStack.add(0, stackEntry);
} else if(matrixMode==GL_PROJECTION) {
matrixP.get(stackEntry);
- matrixP.rewind();
+ matrixP.reset();
matrixPStack.add(0, stackEntry);
} else if(matrixMode==GL.GL_TEXTURE) {
matrixTex.get(stackEntry);
- matrixTex.rewind();
+ matrixTex.reset();
matrixTStack.add(0, stackEntry);
}
}
public final void glLoadIdentity() {
if(matrixMode==GL_MODELVIEW) {
- matrixMv.clear();
matrixMv.put(matrixIdent);
- matrixMv.rewind();
- matrixIdent.rewind();
+ matrixMv.reset();
modified |= DIRTY_MODELVIEW ;
} else if(matrixMode==GL_PROJECTION) {
- matrixP.clear();
matrixP.put(matrixIdent);
- matrixP.rewind();
- matrixIdent.rewind();
+ matrixP.reset();
modified |= DIRTY_PROJECTION ;
} else if(matrixMode==GL.GL_TEXTURE) {
- matrixTex.clear();
matrixTex.put(matrixIdent);
- matrixTex.rewind();
- matrixIdent.rewind();
+ matrixTex.reset();
modified |= DIRTY_TEXTURE ;
}
+ matrixIdent.reset();
}
public final void glMultMatrixf(final FloatBuffer m) {
if(matrixMode==GL_MODELVIEW) {
- glMultMatrixf(matrixMv, m, matrixMult);
- matrixMv.clear();
- matrixMv.put(matrixMult);
- matrixMv.rewind();
+ glMultMatrixf(matrixMv, m, matrixMv);
modified |= DIRTY_MODELVIEW ;
} else if(matrixMode==GL_PROJECTION) {
- glMultMatrixf(matrixP, m, matrixMult);
- matrixP.clear();
- matrixP.put(matrixMult);
- matrixP.rewind();
+ glMultMatrixf(matrixP, m, matrixP);
modified |= DIRTY_PROJECTION ;
} else if(matrixMode==GL.GL_TEXTURE) {
- glMultMatrixf(matrixTex, m, matrixMult);
- matrixTex.clear();
- matrixTex.put(matrixMult);
- matrixTex.rewind();
+ glMultMatrixf(matrixTex, m, matrixTex);
modified |= DIRTY_TEXTURE ;
}
- matrixMult.rewind();
}
public void glMultMatrixf(float[] m, int m_offset) {
if(matrixMode==GL_MODELVIEW) {
- glMultMatrixf(matrixMv, m, m_offset, matrixMult);
- matrixMv.clear();
- matrixMv.put(matrixMult);
- matrixMv.rewind();
+ glMultMatrixf(matrixMv, m, m_offset, matrixMv);
modified |= DIRTY_MODELVIEW ;
} else if(matrixMode==GL_PROJECTION) {
- glMultMatrixf(matrixP, m, m_offset, matrixMult);
- matrixP.clear();
- matrixP.put(matrixMult);
- matrixP.rewind();
+ glMultMatrixf(matrixP, m, m_offset, matrixP);
modified |= DIRTY_PROJECTION ;
} else if(matrixMode==GL.GL_TEXTURE) {
- glMultMatrixf(matrixTex, m, m_offset, matrixMult);
- matrixTex.clear();
- matrixTex.put(matrixMult);
- matrixTex.rewind();
+ glMultMatrixf(matrixTex, m, m_offset, matrixTex);
modified |= DIRTY_TEXTURE ;
}
- matrixMult.rewind();
}
public final void glTranslatef(final float x, final float y, final float z) {
@@ -518,17 +554,17 @@ public class PMVMatrix implements GLMatrixFunc {
// 0 1 0 y
// 0 0 1 z
// 0 0 0 1
- matrixTrans.put(0+4*3, x);
- matrixTrans.put(1+4*3, y);
- matrixTrans.put(2+4*3, z);
- glMultMatrixf(matrixTrans);
+ matrixTrans[0+4*3] = x;
+ matrixTrans[1+4*3] = y;
+ matrixTrans[2+4*3] = z;
+ glMultMatrixf(matrixTrans, 0);
}
public final void glRotatef(final float angdeg, float x, float y, float z) {
- float angrad = angdeg * (float) Math.PI / 180.0f;
- float c = (float)Math.cos(angrad);
- float ic= 1.0f - c;
- float s = (float)Math.sin(angrad);
+ final float angrad = angdeg * (float) Math.PI / 180.0f;
+ final float c = (float)Math.cos(angrad);
+ final float ic= 1.0f - c;
+ final float s = (float)Math.sin(angrad);
vec3f[0]=x; vec3f[1]=y; vec3f[2]=z;
ProjectFloat.normalize(vec3f);
@@ -539,25 +575,25 @@ public class PMVMatrix implements GLMatrixFunc {
// xy(1−c)-zs yy(1−c)+c yz(1−c)+xs 0
// xz(1−c)+ys yz(1−c)-xs zz(1−c)+c 0
// 0 0 0 1
- float xy = x*y;
- float xz = x*z;
- float xs = x*s;
- float ys = y*s;
- float yz = y*z;
- float zs = z*s;
- matrixRot.put(0*4+0, x*x*ic+c);
- matrixRot.put(0*4+1, xy*ic+zs);
- matrixRot.put(0*4+2, xz*ic-ys);
+ final float xy = x*y;
+ final float xz = x*z;
+ final float xs = x*s;
+ final float ys = y*s;
+ final float yz = y*z;
+ final float zs = z*s;
+ matrixRot[0*4+0] = x*x*ic+c;
+ matrixRot[0*4+1] = xy*ic+zs;
+ matrixRot[0*4+2] = xz*ic-ys;
- matrixRot.put(1*4+0, xy*ic-zs);
- matrixRot.put(1*4+1, y*y*ic+c);
- matrixRot.put(1*4+2, yz*ic+xs);
+ matrixRot[1*4+0] = xy*ic-zs;
+ matrixRot[1*4+1] = y*y*ic+c;
+ matrixRot[1*4+2] = yz*ic+xs;
- matrixRot.put(2*4+0, xz*ic+ys);
- matrixRot.put(2*4+1, yz*ic-xs);
- matrixRot.put(2*4+2, z*z*ic+c);
+ matrixRot[2*4+0] = xz*ic+ys;
+ matrixRot[2*4+1] = yz*ic-xs;
+ matrixRot[2*4+2] = z*z*ic+c;
- glMultMatrixf(matrixRot);
+ glMultMatrixf(matrixRot, 0);
}
public final void glScalef(final float x, final float y, final float z) {
@@ -566,11 +602,11 @@ public class PMVMatrix implements GLMatrixFunc {
// 0 y 0 0
// 0 0 z 0
// 0 0 0 1
- matrixScale.put(0+4*0, x);
- matrixScale.put(1+4*1, y);
- matrixScale.put(2+4*2, z);
+ matrixScale[0+4*0] = x;
+ matrixScale[1+4*1] = y;
+ matrixScale[2+4*2] = z;
- glMultMatrixf(matrixScale);
+ glMultMatrixf(matrixScale, 0);
}
public final void glOrthof(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) {
@@ -579,21 +615,21 @@ public class PMVMatrix implements GLMatrixFunc {
// 0 2/dy 0 ty
// 0 0 2/dz tz
// 0 0 0 1
- float dx=right-left;
- float dy=top-bottom;
- float dz=zFar-zNear;
- float tx=-1.0f*(right+left)/dx;
- float ty=-1.0f*(top+bottom)/dy;
- float tz=-1.0f*(zFar+zNear)/dz;
+ final float dx=right-left;
+ final float dy=top-bottom;
+ final float dz=zFar-zNear;
+ final float tx=-1.0f*(right+left)/dx;
+ final float ty=-1.0f*(top+bottom)/dy;
+ final float tz=-1.0f*(zFar+zNear)/dz;
- matrixOrtho.put(0+4*0, 2.0f/dx);
- matrixOrtho.put(1+4*1, 2.0f/dy);
- matrixOrtho.put(2+4*2, -2.0f/dz);
- matrixOrtho.put(0+4*3, tx);
- matrixOrtho.put(1+4*3, ty);
- matrixOrtho.put(2+4*3, tz);
+ matrixOrtho[0+4*0] = 2.0f/dx;
+ matrixOrtho[1+4*1] = 2.0f/dy;
+ matrixOrtho[2+4*2] = -2.0f/dz;
+ matrixOrtho[0+4*3] = tx;
+ matrixOrtho[1+4*3] = ty;
+ matrixOrtho[2+4*3] = tz;
- glMultMatrixf(matrixOrtho);
+ glMultMatrixf(matrixOrtho, 0);
}
public final void glFrustumf(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) {
@@ -608,52 +644,87 @@ public class PMVMatrix implements GLMatrixFunc {
// 0 2*zNear/dy B 0
// 0 0 C D
// 0 0 −1 0
- float zNear2 = 2.0f*zNear;
- float dx=right-left;
- float dy=top-bottom;
- float dz=zFar-zNear;
- float A=(right+left)/dx;
- float B=(top+bottom)/dy;
- float C=-1.0f*(zFar+zNear)/dz;
- float D=-2.0f*(zFar*zNear)/dz;
+ final float zNear2 = 2.0f*zNear;
+ final float dx=right-left;
+ final float dy=top-bottom;
+ final float dz=zFar-zNear;
+ final float A=(right+left)/dx;
+ final float B=(top+bottom)/dy;
+ final float C=-1.0f*(zFar+zNear)/dz;
+ final float D=-2.0f*(zFar*zNear)/dz;
- matrixFrustum.put(0+4*0, zNear2/dx);
- matrixFrustum.put(1+4*1, zNear2/dy);
- matrixFrustum.put(2+4*2, C);
+ matrixFrustum[0+4*0] = zNear2/dx;
+ matrixFrustum[1+4*1] = zNear2/dy;
+ matrixFrustum[2+4*2] = C;
- matrixFrustum.put(0+4*2, A);
- matrixFrustum.put(1+4*2, B);
+ matrixFrustum[0+4*2] = A;
+ matrixFrustum[1+4*2] = B;
- matrixFrustum.put(2+4*3, D);
- matrixFrustum.put(3+4*2, -1.0f);
+ matrixFrustum[2+4*3] = D;
+ matrixFrustum[3+4*2] = -1.0f;
- glMultMatrixf(matrixFrustum);
+ glMultMatrixf(matrixFrustum, 0);
}
//
// private
//
+ private int nioBackupArraySupported = 0; // -1 not supported, 0 - TBD, 1 - supported
+ private final String msgCantComputeInverse = "Invalid source Mv matrix, can't compute inverse";
private final void setMviMvit() {
- if(!projectFloat.gluInvertMatrixf(matrixMv, matrixMvi)) {
- throw new GLException("Invalid source Mv matrix, can't compute inverse");
+ if( 0 != (usesMviMvit & 1) ) {
+ if(nioBackupArraySupported>=0) {
+ try {
+ setMviMvitNIOBackupArray();
+ nioBackupArraySupported = 1;
+ return;
+ } catch(UnsupportedOperationException uoe) {
+ nioBackupArraySupported = -1;
+ }
+ }
+ setMviMvitNIODirectAccess();
}
-
- // transpose matrix
- for (int i = 0; i < 4; i++) {
- for (int j = 0; j < 4; j++) {
- matrixMvit.put(j+i*4, matrixMvi.get(i+j*4));
+ }
+ private final void setMviMvitNIOBackupArray() {
+ final float[] _matrixMvi = matrixMvi.array();
+ final int _matrixMviOffset = matrixMvi.position();
+ if(!projectFloat.gluInvertMatrixf(matrixMv.array(), matrixMv.position(), _matrixMvi, _matrixMviOffset)) {
+ throw new GLException(msgCantComputeInverse);
+ }
+ if( 0 != (usesMviMvit & 2) ) {
+ // transpose matrix
+ final float[] _matrixMvit = matrixMvit.array();
+ final int _matrixMvitOffset = matrixMvit.position();
+ for (int i = 0; i < 4; i++) {
+ for (int j = 0; j < 4; j++) {
+ _matrixMvit[_matrixMvitOffset+j+i*4] = _matrixMvi[_matrixMviOffset+i+j*4];
+ }
}
+ }
+ }
+
+ private final void setMviMvitNIODirectAccess() {
+ if(!projectFloat.gluInvertMatrixf(matrixMv, matrixMvi)) {
+ throw new GLException(msgCantComputeInverse);
}
+ if( 0 != (usesMviMvit & 2) ) {
+ // transpose matrix
+ for (int i = 0; i < 4; i++) {
+ for (int j = 0; j < 4; j++) {
+ matrixMvit.put(j+i*4, matrixMvi.get(i+j*4));
+ }
+ }
+ }
}
- protected ByteBuffer matrixBuffer;
+ protected Buffer matrixBuffer;
protected FloatBuffer matrixIdent, matrixPMvMvit, matrixPMvMvi, matrixPMv, matrixP, matrixTex, matrixMv, matrixMvi, matrixMvit;
- protected FloatBuffer matrixMult, matrixTrans, matrixRot, matrixScale, matrixOrtho, matrixFrustum;
- protected float[] vec3f;
+ protected float[] matrixMult, matrixTrans, matrixRot, matrixScale, matrixOrtho, matrixFrustum, vec3f;
protected List<float[]> matrixTStack, matrixPStack, matrixMvStack;
protected int matrixMode = GL_MODELVIEW;
protected int modified = 0;
+ protected int usesMviMvit = 0; // 0 - none, 1 - Mvi, 2 - Mvit, 3 - MviMvit (ofc no Mvit w/o Mvi!)
protected ProjectFloat projectFloat;
public static final int DIRTY_MODELVIEW = 1 << 0;
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;
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-12 15:39:25 +0000