API doc cleanup, add + refine math tests

API doc

21 files changed, 583 insertions, 29 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/GLAutoDrawable.java b/src/jogl/classes/com/jogamp/opengl/GLAutoDrawable.java
index 385acf082..b9ed73650 100644
--- a/src/jogl/classes/com/jogamp/opengl/GLAutoDrawable.java
+++ b/src/jogl/classes/com/jogamp/opengl/GLAutoDrawable.java
@@ -175,7 +175,7 @@ public interface GLAutoDrawable extends GLDrawable {
    *   <li>If the old context was current on this thread, it is being released after disassociating this auto-drawable.</li>
    *   <li>If the new context was current on this thread, it is being released before associating this auto-drawable
    *       and made current afterwards.</li>
-   *   <li>Implementation may issue {@link #makeCurrent()} and {@link #release()} while drawable reassociation.</li>
+   *   <li>Implementation may issue {@link GLContext#makeCurrent()} and {@link GLContext#release()} while drawable reassociation.</li>
    *   <li>The user shall take extra care of thread synchronization,
    *       i.e. lock the involved {@link GLAutoDrawable auto-drawable's}
    *       {@link GLAutoDrawable#getUpstreamLock() upstream-locks} and {@link GLAutoDrawable#getNativeSurface() surfaces}
diff --git a/src/jogl/classes/com/jogamp/opengl/GLEventListener.java b/src/jogl/classes/com/jogamp/opengl/GLEventListener.java
index 8c5dfd3b3..6b3786b0d 100644
--- a/src/jogl/classes/com/jogamp/opengl/GLEventListener.java
+++ b/src/jogl/classes/com/jogamp/opengl/GLEventListener.java
@@ -93,10 +93,10 @@ public interface GLEventListener extends EventListener {
    * </p>
    *
    * @param drawable the triggering {@link GLAutoDrawable}
-   * @param x viewport x-coord in pixel units
-   * @param y viewport y-coord in pixel units
-   * @param width viewport width in pixel units
-   * @param height viewport height in pixel units
+   * @param x lower left corner of the viewport rectangle in pixel units
+   * @param y lower left corner of the viewport rectangle in pixel units
+   * @param width width of the viewport rectangle in pixel units
+   * @param height height of the viewport rectangle in pixel units
    */
   public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height);
 }
diff --git a/src/jogl/classes/com/jogamp/opengl/GLRunnable.java b/src/jogl/classes/com/jogamp/opengl/GLRunnable.java
index 97a72d6cd..f8bd56fdc 100644
--- a/src/jogl/classes/com/jogamp/opengl/GLRunnable.java
+++ b/src/jogl/classes/com/jogamp/opengl/GLRunnable.java
@@ -41,6 +41,13 @@ package com.jogamp.opengl;
  * The OpenGL context is current while executing the GLRunnable.
  * </p>
  * <p>
+ * {@link GLRunnable#run(GLAutoDrawable)} shall return true to indicate
+ * that the GL [back] framebuffer remains intact by this runnable. <br/>
+ * If returning false {@link GLAutoDrawable} will call
+ * {@link GLEventListener#display(GLAutoDrawable) display(GLAutoDrawable)}
+ * of all registered {@link GLEventListener}s once more to reinstate the framebuffer.
+ * </p>
+ * <p>
  * This might be useful to inject OpenGL commands from an I/O event listener.
  * </p>
  */
diff --git a/src/jogl/classes/com/jogamp/opengl/math/FloatUtil.java b/src/jogl/classes/com/jogamp/opengl/math/FloatUtil.java
index 73244cb13..af1db0c1e 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/FloatUtil.java
+++ b/src/jogl/classes/com/jogamp/opengl/math/FloatUtil.java
@@ -1908,11 +1908,11 @@ public final class FloatUtil {
       final int a0 = aOffset + a.position();
       if(rowMajorOrder) {
           for(int c=0; c<columns; c++) {
-              sb.append( String.format((Locale)null, f+" ", a.get( a0 + row*columns + c ) ) );
+              sb.append( String.format((Locale)null, f+", ", a.get( a0 + row*columns + c ) ) );
           }
       } else {
           for(int r=0; r<columns; r++) {
-              sb.append( String.format((Locale)null, f+" ", a.get( a0 + row + r*rows ) ) );
+              sb.append( String.format((Locale)null, f+", ", a.get( a0 + row + r*rows ) ) );
           }
       }
       return sb;
@@ -1936,11 +1936,11 @@ public final class FloatUtil {
       }
       if(rowMajorOrder) {
           for(int c=0; c<columns; c++) {
-              sb.append( String.format((Locale)null, f+" ", a[ aOffset + row*columns + c ] ) );
+              sb.append( String.format((Locale)null, f+", ", a[ aOffset + row*columns + c ] ) );
           }
       } else {
           for(int r=0; r<columns; r++) {
-              sb.append( String.format((Locale)null, f+" ", a[ aOffset + row + r*rows ] ) );
+              sb.append( String.format((Locale)null, f+", ", a[ aOffset + row + r*rows ] ) );
           }
       }
       return sb;
@@ -1963,11 +1963,15 @@ public final class FloatUtil {
           sb = new StringBuilder();
       }
       final String prefix = ( null == rowPrefix ) ? "" : rowPrefix;
+      sb.append(prefix).append("{ ");
       for(int i=0; i<rows; i++) {
-          sb.append(prefix).append("[ ");
+          if( 0 < i ) {
+              sb.append(prefix).append("  ");
+          }
           matrixRowToString(sb, f, a, aOffset, rows, columns, rowMajorOrder, i);
-          sb.append("]").append(Platform.getNewline());
+          sb.append(Platform.getNewline());
       }
+      sb.append(prefix).append("}").append(Platform.getNewline());
       return sb;
   }
 
@@ -1988,11 +1992,15 @@ public final class FloatUtil {
           sb = new StringBuilder();
       }
       final String prefix = ( null == rowPrefix ) ? "" : rowPrefix;
+      sb.append(prefix).append("{ ");
       for(int i=0; i<rows; i++) {
-          sb.append(prefix).append("[ ");
+          if( 0 < i ) {
+              sb.append(prefix).append("  ");
+          }
           matrixRowToString(sb, f, a, aOffset, rows, columns, rowMajorOrder, i);
-          sb.append("]").append(Platform.getNewline());
+          sb.append(Platform.getNewline());
       }
+      sb.append(prefix).append("}").append(Platform.getNewline());
       return sb;
   }
 
@@ -2314,10 +2322,10 @@ public final class FloatUtil {
 
   /**
    * Returns orthogonal distance
-   * (1f/zNear-1f/orthoDist)/(1f/zNear-1f/zFar);
+   * (1f/zNear-1f/orthoZ) / (1f/zNear-1f/zFar);
    */
   public static float getOrthoWinZ(final float orthoZ, final float zNear, final float zFar) {
-      return (1f/zNear-1f/orthoZ)/(1f/zNear-1f/zFar);
+      return (1f/zNear-1f/orthoZ) / (1f/zNear-1f/zFar);
   }
 
 }
\ No newline at end of file
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Ray.java b/src/jogl/classes/com/jogamp/opengl/math/Ray.java
index 4d651d1c3..a528f0763 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Ray.java
+++ b/src/jogl/classes/com/jogamp/opengl/math/Ray.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2014 JogAmp Community. All rights reserved.
+ * Copyright 2014-2023 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:
@@ -53,6 +53,7 @@ public class Ray {
     /** Normalized direction vector of ray, float[3]. */
     public final float[] dir = new float[3];
 
+    @Override
     public String toString() {
         return "Ray[orig["+orig[0]+", "+orig[1]+", "+orig[2]+"], dir["+dir[0]+", "+dir[1]+", "+dir[2]+"]]";
     }
diff --git a/src/jogl/classes/com/jogamp/opengl/math/geom/AABBox.java b/src/jogl/classes/com/jogamp/opengl/math/geom/AABBox.java
index 5a14406b0..f858b1c0d 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/geom/AABBox.java
+++ b/src/jogl/classes/com/jogamp/opengl/math/geom/AABBox.java
@@ -596,6 +596,7 @@ public class AABBox {
      * @param size a constant float value
      * @param tmpV3 caller provided temporary 3-component vector
      * @return this AABBox for chaining
+     * @see #scale2(float, float[])
      */
     public final AABBox scale(final float size, final float[] tmpV3) {
         tmpV3[0] = high[0] - center[0];
@@ -622,6 +623,7 @@ public class AABBox {
      * @param size a constant float value
      * @param tmpV3 caller provided temporary 3-component vector
      * @return this AABBox for chaining
+     * @see #scale(float, float[])
      */
     public final AABBox scale2(final float size, final float[] tmpV3) {
         VectorUtil.scaleVec3(high, high, size); // in-place scale
diff --git a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
index 5383f91be..f8f1d3930 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
@@ -373,7 +373,7 @@ public final class PMVMatrix implements GLMatrixFunc {
         return frustum;
     }
 
-    /*
+    /**
      * @return the matrix of the current matrix-mode
      */
     public final FloatBuffer glGetMatrixf() {
diff --git a/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java b/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
index e4b5eae5c..2228d6977 100644
--- a/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
+++ b/src/jogl/classes/jogamp/opengl/GLDrawableHelper.java
@@ -225,7 +225,7 @@ public class GLDrawableHelper {
    *   <li>If the old context was current on this thread, it is being released after disassociating the drawable.</li>
    *   <li>If the new context was current on this thread, it is being released before associating the drawable
    *       and made current afterwards.</li>
-   *   <li>Implementation may issue {@link #makeCurrent()} and {@link #release()} while drawable reassociation.</li>
+   *   <li>Implementation may issue {@link GLContext#makeCurrent()} and {@link GLContext#release()} while drawable reassociation.</li>
    *   <li>The user shall take extra care of thread synchronization,
    *       i.e. lock the involved {@link GLDrawable#getNativeSurface() drawable's} {@link NativeSurface}s
    *       to avoid a race condition. In case {@link GLAutoDrawable auto-drawable's} are used,
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestBinary32NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestBinary32NOUI.java
index d2a9a92ce..ba59eddec 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestBinary32NOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestBinary32NOUI.java
@@ -31,9 +31,10 @@ package com.jogamp.opengl.test.junit.jogl.math;
 import org.junit.Assert;
 import org.junit.Test;
 
+import com.jogamp.junit.util.JunitTracer;
 import com.jogamp.opengl.math.Binary32;
 
-public class TestBinary32NOUI
+public class TestBinary32NOUI extends JunitTracer
 {
   @SuppressWarnings("static-method") @Test public void testInfinityExponent()
   {
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestBinary64NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestBinary64NOUI.java
index f16ea2bee..8e635f128 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestBinary64NOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestBinary64NOUI.java
@@ -31,9 +31,10 @@ package com.jogamp.opengl.test.junit.jogl.math;
 import org.junit.Assert;
 import org.junit.Test;
 
+import com.jogamp.junit.util.JunitTracer;
 import com.jogamp.opengl.math.Binary64;
 
-public class TestBinary64NOUI
+public class TestBinary64NOUI extends JunitTracer
 {
   @SuppressWarnings("static-method") @Test public void testInfinityExponent()
   {
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil01NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil01NOUI.java
index 0d156c42c..909b94a90 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil01NOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil01NOUI.java
@@ -36,10 +36,11 @@ import org.junit.Test;
 import org.junit.FixMethodOrder;
 import org.junit.runners.MethodSorters;

 

+import com.jogamp.junit.util.JunitTracer;

 import com.jogamp.opengl.math.FloatUtil;

 

 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class TestFloatUtil01NOUI {

+public class TestFloatUtil01NOUI extends JunitTracer {

     static final float MACH_EPSILON = FloatUtil.getMachineEpsilon();

 

     static boolean deltaMachEpsLEQEpsilon;

diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil02MatrixMatrixMultNOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil02MatrixMatrixMultNOUI.java
index 13285ac0b..72b4453c6 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil02MatrixMatrixMultNOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil02MatrixMatrixMultNOUI.java
@@ -33,10 +33,11 @@ import org.junit.Test;
 import org.junit.FixMethodOrder;
 import org.junit.runners.MethodSorters;
 
+import com.jogamp.junit.util.JunitTracer;
 import com.jogamp.opengl.math.FloatUtil;
 
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class TestFloatUtil02MatrixMatrixMultNOUI {
+public class TestFloatUtil02MatrixMatrixMultNOUI extends JunitTracer {
 
     final float[] m1 = new float[]{    1,    3,    4,    0,
                                        6,    7,    8,    5,
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil03InversionNOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil03InversionNOUI.java
index a2aa69863..eaca73579 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil03InversionNOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil03InversionNOUI.java
@@ -34,10 +34,11 @@ import org.junit.FixMethodOrder;
 import org.junit.runners.MethodSorters;

 

 import com.jogamp.common.os.Platform;

+import com.jogamp.junit.util.JunitTracer;

 import com.jogamp.opengl.math.FloatUtil;

 

 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class TestFloatUtil03InversionNOUI {

+public class TestFloatUtil03InversionNOUI extends JunitTracer {

 

     @Test

     public void test01Ident(){

diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtilProject01NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtilProject01NOUI.java
new file mode 100644
index 000000000..05126676d
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtilProject01NOUI.java
@@ -0,0 +1,306 @@
+/**
+ * Copyright 2014-2023 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+package com.jogamp.opengl.test.junit.jogl.math;
+
+import java.util.Arrays;
+
+import com.jogamp.common.nio.Buffers;
+import com.jogamp.junit.util.JunitTracer;
+import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
+import com.jogamp.opengl.glu.GLU;
+
+import jogamp.opengl.gl2.ProjectDouble;
+
+import com.jogamp.opengl.math.FloatUtil;
+import com.jogamp.opengl.util.PMVMatrix;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestFloatUtilProject01NOUI extends JunitTracer {
+
+    static final float epsilon = 0.00001f;
+
+    // Simple 10 x 10 view port
+    static final int[] viewport = new int[] { 0,0,10,10};
+
+    /**
+     * PMVMatrix FloatUtil.mapObjToWinCoords() w/ separate P + Mv, against FloatUtil.mapObjToWinCoords() w/ PMV
+     */
+    @Test
+    public void test01PMVMatrixToFloatUtil1() {
+        final float[] vec4Tmp1 = new float[4];
+        final float[] vec4Tmp2 = new float[4];
+
+        final float[] winA00 = new float[4];
+        final float[] winA01 = new float[4];
+        final float[] winA10 = new float[4];
+        final float[] winA11 = new float[4];
+        final float[] winB00 = new float[4];
+        final float[] winB01 = new float[4];
+        final float[] winB10 = new float[4];
+        final float[] winB11 = new float[4];
+
+        final PMVMatrix m = new PMVMatrix();
+        final float[] mat4PMv = new float[16];
+        m.multPMvMatrixf(mat4PMv, 0);
+        System.err.println(FloatUtil.matrixToString(null, "mat4PMv", "%10.5f", mat4PMv, 0, 4, 4, false /* rowMajorOrder */));
+
+        m.gluProject(1f, 0f, 0f, viewport, 0, winA00, 0);
+        System.err.println("A.0.0 - Project 1,0 -->" + Arrays.toString(winA00));
+        FloatUtil.mapObjToWinCoords(1f, 0f, 0f, mat4PMv, viewport, 0, winB00, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.0 - Project 1,0 -->" + Arrays.toString(winB00));
+
+        m.gluProject(0f, 0f, 0f, viewport, 0, winA01, 0);
+        System.err.println("A.0.1 - Project 0,0 -->" + Arrays.toString(winA01));
+        FloatUtil.mapObjToWinCoords(0f, 0f, 0f, mat4PMv, viewport, 0, winB01, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.1 - Project 0,0 -->" + Arrays.toString(winB01));
+
+        m.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
+        m.glOrthof(0, 10, 0, 10, 1, -1);
+        System.err.println("MATRIX - Ortho 0,0,10,10 - Locate the origin in the bottom left and scale");
+        System.err.println(m);
+        m.multPMvMatrixf(mat4PMv, 0);
+        System.err.println(FloatUtil.matrixToString(null, "mat4PMv", "%10.5f", mat4PMv, 0, 4, 4, false /* rowMajorOrder */));
+
+        m.gluProject(1f, 0f, 0f, viewport, 0, winA10, 0);
+        System.err.println("A.1.0 - Project 1,0 -->" +Arrays.toString(winA10));
+        FloatUtil.mapObjToWinCoords(1f, 0f, 0f, mat4PMv, viewport, 0, winB10, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.1.0 - Project 1,0 -->" +Arrays.toString(winB10));
+
+        m.gluProject(0f, 0f, 0f, viewport, 0, winA11, 0);
+        System.err.println("A.1.1 - Project 0,0 -->" +Arrays.toString(winA11));
+        FloatUtil.mapObjToWinCoords(0f, 0f, 0f, mat4PMv, viewport, 0, winB11, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.1.1 - Project 0,0 -->" +Arrays.toString(winB11));
+
+        Assert.assertArrayEquals("A/B 0.0 Project 1,0 failure", winB00, winA00, epsilon);
+        Assert.assertArrayEquals("A/B 0.1 Project 0,0 failure", winB01, winA01, epsilon);
+        Assert.assertArrayEquals("A/B 1.0 Project 1,0 failure", winB10, winA10, epsilon);
+        Assert.assertArrayEquals("A/B 1.1 Project 0,0 failure", winB11, winA11, epsilon);
+    }
+
+    /**
+     * Actually both using same FloatUtil.mapObjToWinCoords() w/ separate P + Mv
+     */
+    @Test
+    public void test01PMVMatrixToFloatUtil2() {
+        final float[] vec4Tmp1 = new float[4];
+        final float[] vec4Tmp2 = new float[4];
+
+        final float[] winA00 = new float[4];
+        final float[] winA01 = new float[4];
+        final float[] winA10 = new float[4];
+        final float[] winA11 = new float[4];
+        final float[] winB00 = new float[4];
+        final float[] winB01 = new float[4];
+        final float[] winB10 = new float[4];
+        final float[] winB11 = new float[4];
+
+        final PMVMatrix m = new PMVMatrix();
+        final float[] mat4Mv = new float[16];
+        final float[] mat4P = new float[16];
+
+        m.glGetFloatv(GLMatrixFunc.GL_MODELVIEW_MATRIX, mat4Mv, 0);
+        m.glGetFloatv(GLMatrixFunc.GL_PROJECTION_MATRIX, mat4P, 0);
+        System.err.println(FloatUtil.matrixToString(null, "mat4Mv", "%10.5f", mat4Mv, 0, 4, 4, false /* rowMajorOrder */));
+        System.err.println(FloatUtil.matrixToString(null, "mat4P ", "%10.5f", mat4P,  0, 4, 4, false /* rowMajorOrder */));
+
+        m.gluProject(1f, 0f, 0f, viewport, 0, winA00, 0);
+        System.err.println("A.0.0 - Project 1,0 -->" + Arrays.toString(winA00));
+        FloatUtil.mapObjToWinCoords(1f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB00, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.0 - Project 1,0 -->" + Arrays.toString(winB00));
+
+        m.gluProject(0f, 0f, 0f, viewport, 0, winA01, 0);
+        System.err.println("A.0.1 - Project 0,0 -->" + Arrays.toString(winA01));
+        FloatUtil.mapObjToWinCoords(0f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB01, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.1 - Project 0,0 -->" + Arrays.toString(winB01));
+
+        m.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
+        m.glOrthof(0, 10, 0, 10, 1, -1);
+        System.err.println("MATRIX - Ortho 0,0,10,10 - Locate the origin in the bottom left and scale");
+        System.err.println(m);
+        m.glGetFloatv(GLMatrixFunc.GL_MODELVIEW_MATRIX, mat4Mv, 0);
+        m.glGetFloatv(GLMatrixFunc.GL_PROJECTION_MATRIX, mat4P, 0);
+        System.err.println(FloatUtil.matrixToString(null, "mat4Mv", "%10.5f", mat4Mv, 0, 4, 4, false /* rowMajorOrder */));
+        System.err.println(FloatUtil.matrixToString(null, "mat4P ", "%10.5f", mat4P,  0, 4, 4, false /* rowMajorOrder */));
+
+        m.gluProject(1f, 0f, 0f, viewport, 0, winA10, 0);
+        System.err.println("A.1.0 - Project 1,0 -->" +Arrays.toString(winA10));
+        FloatUtil.mapObjToWinCoords(1f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB10, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.1.0 - Project 1,0 -->" +Arrays.toString(winB10));
+
+        m.gluProject(0f, 0f, 0f, viewport, 0, winA11, 0);
+        System.err.println("A.1.1 - Project 0,0 -->" +Arrays.toString(winA11));
+        FloatUtil.mapObjToWinCoords(0f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB11, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.1.1 - Project 0,0 -->" +Arrays.toString(winB11));
+
+        Assert.assertArrayEquals("A/B 0.0 Project 1,0 failure", winB00, winA00, epsilon);
+        Assert.assertArrayEquals("A/B 0.1 Project 0,0 failure", winB01, winA01, epsilon);
+        Assert.assertArrayEquals("A/B 1.0 Project 1,0 failure", winB10, winA10, epsilon);
+        Assert.assertArrayEquals("A/B 1.1 Project 0,0 failure", winB11, winA11, epsilon);
+    }
+
+    /**
+     * GLU ProjectFloat w/ same FloatUtil.mapObjToWinCoords() w/ separate P + Mv
+     */
+    @Test
+    public void test03GLUToFloatUtil2() {
+        final float[] vec4Tmp1 = new float[4];
+        final float[] vec4Tmp2 = new float[4];
+
+        final float[] winA00 = new float[4];
+        final float[] winA01 = new float[4];
+        final float[] winA10 = new float[4];
+        final float[] winA11 = new float[4];
+        final float[] winB00 = new float[4];
+        final float[] winB01 = new float[4];
+        final float[] winB10 = new float[4];
+        final float[] winB11 = new float[4];
+
+        final PMVMatrix m = new PMVMatrix();
+        final float[] mat4Mv = new float[16];
+        final float[] mat4P = new float[16];
+        final GLU glu = new GLU();
+
+        m.glGetFloatv(GLMatrixFunc.GL_MODELVIEW_MATRIX, mat4Mv, 0);
+        m.glGetFloatv(GLMatrixFunc.GL_PROJECTION_MATRIX, mat4P, 0);
+        System.err.println(FloatUtil.matrixToString(null, "mat4Mv", "%10.5f", mat4Mv, 0, 4, 4, false /* rowMajorOrder */));
+        System.err.println(FloatUtil.matrixToString(null, "mat4P ", "%10.5f", mat4P,  0, 4, 4, false /* rowMajorOrder */));
+
+        glu.gluProject(1f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winA00, 0);
+        System.err.println("A.0.0 - Project 1,0 -->" + Arrays.toString(winA00));
+        FloatUtil.mapObjToWinCoords(1f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB00, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.0 - Project 1,0 -->" + Arrays.toString(winB00));
+
+        glu.gluProject(0f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winA01, 0);
+        System.err.println("A.0.1 - Project 0,0 -->" + Arrays.toString(winA01));
+        FloatUtil.mapObjToWinCoords(0f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB01, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.1 - Project 0,0 -->" + Arrays.toString(winB01));
+
+        m.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
+        m.glOrthof(0, 10, 0, 10, 1, -1);
+        System.err.println("MATRIX - Ortho 0,0,10,10 - Locate the origin in the bottom left and scale");
+        System.err.println(m);
+        m.glGetFloatv(GLMatrixFunc.GL_MODELVIEW_MATRIX, mat4Mv, 0);
+        m.glGetFloatv(GLMatrixFunc.GL_PROJECTION_MATRIX, mat4P, 0);
+        System.err.println(FloatUtil.matrixToString(null, "mat4Mv", "%10.5f", mat4Mv, 0, 4, 4, false /* rowMajorOrder */));
+        System.err.println(FloatUtil.matrixToString(null, "mat4P ", "%10.5f", mat4P,  0, 4, 4, false /* rowMajorOrder */));
+
+        glu.gluProject(1f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winA10, 0);
+        System.err.println("A.1.0 - Project 1,0 -->" +Arrays.toString(winA10));
+        FloatUtil.mapObjToWinCoords(1f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB10, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.1.0 - Project 1,0 -->" +Arrays.toString(winB10));
+
+        glu.gluProject(0f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winA11, 0);
+        System.err.println("A.1.1 - Project 0,0 -->" +Arrays.toString(winA11));
+        FloatUtil.mapObjToWinCoords(0f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB11, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.1.1 - Project 0,0 -->" +Arrays.toString(winB11));
+
+        Assert.assertArrayEquals("A/B 0.0 Project 1,0 failure", winB00, winA00, epsilon);
+        Assert.assertArrayEquals("A/B 0.1 Project 0,0 failure", winB01, winA01, epsilon);
+        Assert.assertArrayEquals("A/B 1.0 Project 1,0 failure", winB10, winA10, epsilon);
+        Assert.assertArrayEquals("A/B 1.1 Project 0,0 failure", winB11, winA11, epsilon);
+    }
+
+    /**
+     * GLU ProjectDouble against FloatUtil.mapObjToWinCoords() w/ separate P + Mv
+     */
+    @Test
+    public void test04GLUDoubleToFloatUtil2() {
+        final float[] vec4Tmp1 = new float[4];
+        final float[] vec4Tmp2 = new float[4];
+
+        final double[] winA00 = new double[4];
+        final double[] winA01 = new double[4];
+        final double[] winA10 = new double[4];
+        final double[] winA11 = new double[4];
+        final float[] winB00 = new float[4];
+        final float[] winB01 = new float[4];
+        final float[] winB10 = new float[4];
+        final float[] winB11 = new float[4];
+
+        final PMVMatrix m = new PMVMatrix();
+        final float[] mat4Mv = new float[16];
+        final float[] mat4P = new float[16];
+        final ProjectDouble glu = new ProjectDouble();
+
+        m.glGetFloatv(GLMatrixFunc.GL_MODELVIEW_MATRIX, mat4Mv, 0);
+        m.glGetFloatv(GLMatrixFunc.GL_PROJECTION_MATRIX, mat4P, 0);
+        System.err.println(FloatUtil.matrixToString(null, "mat4Mv", "%10.5f", mat4Mv, 0, 4, 4, false /* rowMajorOrder */));
+        System.err.println(FloatUtil.matrixToString(null, "mat4P ", "%10.5f", mat4P,  0, 4, 4, false /* rowMajorOrder */));
+        double[] d_mat4Mv = Buffers.getDoubleArray(mat4Mv, 0, null, 0, -1);
+        double[] d_mat4P = Buffers.getDoubleArray(mat4P, 0, null, 0, -1);
+
+        glu.gluProject(1f, 0f, 0f, d_mat4Mv, 0, d_mat4P, 0, viewport, 0, winA00, 0);
+        System.err.println("A.0.0 - Project 1,0 -->" + Arrays.toString(winA00));
+        FloatUtil.mapObjToWinCoords(1f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB00, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.0 - Project 1,0 -->" + Arrays.toString(winB00));
+
+        glu.gluProject(0f, 0f, 0f, d_mat4Mv, 0, d_mat4P, 0, viewport, 0, winA01, 0);
+        System.err.println("A.0.1 - Project 0,0 -->" + Arrays.toString(winA01));
+        FloatUtil.mapObjToWinCoords(0f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB01, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.1 - Project 0,0 -->" + Arrays.toString(winB01));
+
+        m.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
+        m.glOrthof(0, 10, 0, 10, 1, -1);
+        System.err.println("MATRIX - Ortho 0,0,10,10 - Locate the origin in the bottom left and scale");
+        System.err.println(m);
+        m.glGetFloatv(GLMatrixFunc.GL_MODELVIEW_MATRIX, mat4Mv, 0);
+        m.glGetFloatv(GLMatrixFunc.GL_PROJECTION_MATRIX, mat4P, 0);
+        System.err.println(FloatUtil.matrixToString(null, "mat4Mv", "%10.5f", mat4Mv, 0, 4, 4, false /* rowMajorOrder */));
+        System.err.println(FloatUtil.matrixToString(null, "mat4P ", "%10.5f", mat4P,  0, 4, 4, false /* rowMajorOrder */));
+        d_mat4Mv = Buffers.getDoubleArray(mat4Mv, 0, null, 0, -1);
+        d_mat4P = Buffers.getDoubleArray(mat4P, 0, null, 0, -1);
+
+        glu.gluProject(1f, 0f, 0f, d_mat4Mv, 0, d_mat4P, 0, viewport, 0, winA10, 0);
+        System.err.println("A.1.0 - Project 1,0 -->" +Arrays.toString(winA10));
+        FloatUtil.mapObjToWinCoords(1f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB10, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.1.0 - Project 1,0 -->" +Arrays.toString(winB10));
+
+        glu.gluProject(0f, 0f, 0f, d_mat4Mv, 0, d_mat4P, 0, viewport, 0, winA11, 0);
+        System.err.println("A.1.1 - Project 0,0 -->" +Arrays.toString(winA11));
+        FloatUtil.mapObjToWinCoords(0f, 0f, 0f, mat4Mv, 0, mat4P, 0, viewport, 0, winB11, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.1.1 - Project 0,0 -->" +Arrays.toString(winB11));
+
+        double[] d_winBxx = Buffers.getDoubleArray(winB00, 0, null, 0, -1);
+        Assert.assertArrayEquals("A/B 0.0 Project 1,0 failure", d_winBxx, winA00, epsilon);
+        d_winBxx = Buffers.getDoubleArray(winB01, 0, null, 0, -1);
+        Assert.assertArrayEquals("A/B 0.1 Project 0,0 failure", d_winBxx, winA01, epsilon);
+        d_winBxx = Buffers.getDoubleArray(winB10, 0, null, 0, -1);
+        Assert.assertArrayEquals("A/B 1.0 Project 1,0 failure", d_winBxx, winA10, epsilon);
+        d_winBxx = Buffers.getDoubleArray(winB11, 0, null, 0, -1);
+        Assert.assertArrayEquals("A/B 1.1 Project 0,0 failure", d_winBxx, winA11, epsilon);
+    }
+
+    public static void main(final String args[]) {
+        org.junit.runner.JUnitCore.main(TestFloatUtilProject01NOUI.class.getName());
+    }
+}
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtilProject02NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtilProject02NOUI.java
new file mode 100644
index 000000000..ed3f68f5d
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtilProject02NOUI.java
@@ -0,0 +1,125 @@
+/**
+ * Copyright 2014-2023 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+package com.jogamp.opengl.test.junit.jogl.math;
+
+import java.util.Arrays;
+
+import com.jogamp.junit.util.JunitTracer;
+
+import com.jogamp.opengl.math.FloatUtil;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestFloatUtilProject02NOUI extends JunitTracer {
+
+    static final float epsilon = 0.00001f;
+
+    @Test
+    public void test01FloatUtilProject() {
+        final float[] vec4Tmp1 = new float[4];
+        final float[] vec4Tmp2 = new float[4];
+
+        final float[] winHas = new float[3];
+        final int[] winExp = { 297, 360 };
+
+        final int[] viewport = new int[] { 0, 0, 1280, 720 };
+
+
+        final float[] mat4Mv = new float[] {
+                0.40000000596046450000f,    0.00000000000000000000f,    0.00000000000000000000f,    0.00000000000000000000f,
+                0.00000000000000000000f,    0.40000000596046450000f,    0.00000000000000000000f,    0.00000000000000000000f,
+                0.00000000000000000000f,    0.00000000000000000000f,    1.00000000000000000000f,    0.00000000000000000000f,
+               -0.09278385341167450000f,   -0.00471283448860049250f,   -0.20000000298023224000f,    1.00000000000000000000f
+        };
+        final float[] mat4P = new float[] {
+                1.35799503326416020000f,    0.00000000000000000000f,    0.00000000000000000000f,    0.00000000000000000000f,
+                0.00000000000000000000f,    2.41421341896057130000f,    0.00000000000000000000f,    0.00000000000000000000f,
+                0.00000000000000000000f,    0.00000000000000000000f,   -1.00002861022949220000f,   -1.00000000000000000000f,
+                0.00000000000000000000f,    0.00000000000000000000f,   -0.20000286400318146000f,    0.00000000000000000000f,
+        };
+
+        final float[] objPos = { 0.02945519052445888500f,    0.01178207620978355400f,   -0.00499999988824129100f };
+
+        System.err.println("pMv");
+        System.err.println(FloatUtil.matrixToString(null, "", "%25.20ff", mat4Mv, 0, 4, 4, true /* rowMajorOrder */));
+        System.err.println("pP");
+        System.err.println(FloatUtil.matrixToString(null, "", "%25.20ff", mat4P,  0, 4, 4, true/* rowMajorOrder */));
+
+        FloatUtil.mapObjToWinCoords(objPos[0], objPos[1], objPos[2], mat4Mv, 0, mat4P, 0, viewport, 0, winHas, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.0 - Project 1,0 -->" + Arrays.toString(winHas));
+
+        Assert.assertEquals("A/B 0.0 Project 1,0 failure.x", winExp[0], Math.round(winHas[0]));
+        Assert.assertEquals("A/B 0.0 Project 1,0 failure.y", winExp[1], Math.round(winHas[1]));
+    }
+
+    @Test
+    public void test02GLUFloatUtil() {
+        final float[] vec4Tmp1 = new float[4];
+        final float[] vec4Tmp2 = new float[4];
+
+        final float[] winHas = new float[3];
+        final int[] winExp = { 136, 360 };
+
+        final int[] viewport = new int[] { 0, 0, 1280, 720 };
+
+
+        final float[] mat4Mv = new float[] {
+                0.40000000596046450000f,    0.00000000000000000000f,    0.00000000000000000000f,    0.00000000000000000000f,
+                0.00000000000000000000f,    0.40000000596046450000f,    0.00000000000000000000f,    0.00000000000000000000f,
+                0.00000000000000000000f,    0.00000000000000000000f,    1.00000000000000000000f,    0.00000000000000000000f,
+               -0.13065303862094880000f,   -0.00471283448860049250f,   -0.20000000298023224000f,    1.00000000000000000000f,
+        };
+        final float[] mat4P = new float[] {
+                1.35799503326416020000f,    0.00000000000000000000f,    0.00000000000000000000f,    0.00000000000000000000f,
+                0.00000000000000000000f,    2.41421341896057130000f,    0.00000000000000000000f,    0.00000000000000000000f,
+                0.00000000000000000000f,    0.00000000000000000000f,   -1.00002861022949220000f,   -1.00000000000000000000f,
+                0.00000000000000000000f,    0.00000000000000000000f,   -0.20000286400318146000f,    0.00000000000000000000f,
+        };
+
+        final float[] objPos = { 0.02945519052445888500f,    0.01178207620978355400f,   -0.00499999988824129100f };
+
+        System.err.println("pMv");
+        System.err.println(FloatUtil.matrixToString(null, "", "%25.20ff", mat4Mv, 0, 4, 4, true /* rowMajorOrder */));
+        System.err.println("pP");
+        System.err.println(FloatUtil.matrixToString(null, "", "%25.20ff", mat4P,  0, 4, 4, true/* rowMajorOrder */));
+
+        FloatUtil.mapObjToWinCoords(objPos[0], objPos[1], objPos[2], mat4Mv, 0, mat4P, 0, viewport, 0, winHas, 0, vec4Tmp1, vec4Tmp2);
+        System.err.println("B.0.0 - Project 1,0 -->" + Arrays.toString(winHas));
+
+        Assert.assertEquals("A/B 0.0 Project 1,0 failure.x", winExp[0], Math.round(winHas[0]));
+        Assert.assertEquals("A/B 0.0 Project 1,0 failure.y", winExp[1], Math.round(winHas[1]));
+    }
+
+    public static void main(final String args[]) {
+        org.junit.runner.JUnitCore.main(TestFloatUtilProject02NOUI.class.getName());
+    }
+}
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestGluUnprojectDoubleNOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestGluUnprojectDoubleNOUI.java
index 00a474b05..7d7ec47d6 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestGluUnprojectDoubleNOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestGluUnprojectDoubleNOUI.java
@@ -28,6 +28,7 @@
 
 package com.jogamp.opengl.test.junit.jogl.math;
 
+import com.jogamp.junit.util.JunitTracer;
 import com.jogamp.opengl.glu.GLU;
 
 import org.junit.Assert;
@@ -39,7 +40,7 @@ import org.junit.runners.MethodSorters;
  * @author Julien Gouesse
  */
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class TestGluUnprojectDoubleNOUI {
+public class TestGluUnprojectDoubleNOUI extends JunitTracer {
 
     @Test
     public void test(){
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestGluUnprojectFloatNOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestGluUnprojectFloatNOUI.java
index d0557ccc4..55df4bcd4 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestGluUnprojectFloatNOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestGluUnprojectFloatNOUI.java
@@ -28,6 +28,7 @@
 
 package com.jogamp.opengl.test.junit.jogl.math;
 
+import com.jogamp.junit.util.JunitTracer;
 import com.jogamp.opengl.glu.GLU;
 
 import org.junit.Assert;
@@ -36,7 +37,7 @@ import org.junit.FixMethodOrder;
 import org.junit.runners.MethodSorters;
 
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class TestGluUnprojectFloatNOUI {
+public class TestGluUnprojectFloatNOUI extends JunitTracer {
 
     @Test
     public void testNaN(){
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVMatrix02NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVMatrix02NOUI.java
index 78c66d927..d6a0beac6 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVMatrix02NOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVMatrix02NOUI.java
@@ -34,7 +34,7 @@ import org.junit.FixMethodOrder;
 import org.junit.runners.MethodSorters;

 

 import com.jogamp.opengl.util.PMVMatrix;

-

+import com.jogamp.junit.util.JunitTracer;

 import com.jogamp.opengl.fixedfunc.GLMatrixFunc;

 import java.nio.FloatBuffer;

 

@@ -44,7 +44,7 @@ import static org.junit.Assert.assertArrayEquals;
  * @author Thomas De Bodt

  */

 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class TestPMVMatrix02NOUI {

+public class TestPMVMatrix02NOUI extends JunitTracer {

 

   private PMVMatrix fMat;

 

diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVMatrix03NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVMatrix03NOUI.java
index f356a3678..63cb5b539 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVMatrix03NOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVMatrix03NOUI.java
@@ -2,6 +2,7 @@ package com.jogamp.opengl.test.junit.jogl.math;
 
 import java.util.Arrays;
 
+import com.jogamp.junit.util.JunitTracer;
 import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
 
 import jogamp.opengl.ProjectFloat;
@@ -15,7 +16,7 @@ import org.junit.FixMethodOrder;
 import org.junit.runners.MethodSorters;
 
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class TestPMVMatrix03NOUI {
+public class TestPMVMatrix03NOUI extends JunitTracer {
 
     static final float epsilon = 0.00001f;
 
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVTransform01NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVTransform01NOUI.java
new file mode 100644
index 000000000..a9bac4f48
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestPMVTransform01NOUI.java
@@ -0,0 +1,96 @@
+/**
+ * Copyright 2014-2023 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+package com.jogamp.opengl.test.junit.jogl.math;
+
+import com.jogamp.junit.util.JunitTracer;
+
+import com.jogamp.opengl.math.FloatUtil;
+import com.jogamp.opengl.util.PMVMatrix;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestPMVTransform01NOUI extends JunitTracer {
+
+    static final float epsilon = 0.00001f;
+
+    @Test
+    public void test01() {
+        final PMVMatrix pmv = new PMVMatrix();
+        System.err.println(FloatUtil.matrixToString(null, "Ident     ", "%7.5f", pmv.glGetMatrixf(), 0, 4, 4, true /* rowMajorOrder */));
+
+        final float[] t = { 1f, 2f, 3f };
+        final float[] s = { 2f, 2f, 2f };
+
+        pmv.glTranslatef(t[0], t[1], t[2]);
+        System.err.println(FloatUtil.matrixToString(null, "Translate ", "%7.5f", pmv.glGetMatrixf(), 0, 4, 4, true/* rowMajorOrder */));
+        pmv.glScalef(s[0], s[1], s[2]);
+        System.err.println(FloatUtil.matrixToString(null, "Scale     ", "%7.5f", pmv.glGetMatrixf(), 0, 4, 4, true /* rowMajorOrder */));
+
+        final float[] exp = new float[] {
+                2.00000f, 0.00000f, 0.00000f, 0.00000f,
+                0.00000f, 2.00000f, 0.00000f, 0.00000f,
+                0.00000f, 0.00000f, 2.00000f, 0.00000f,
+                1.00000f, 2.00000f, 3.00000f, 1.00000f,
+        };
+        final float[] has = new float[16];
+        pmv.multPMvMatrixf(has, 0);
+        Assert.assertArrayEquals(exp, has, epsilon);
+    }
+
+    @Test
+    public void test02() {
+        final PMVMatrix pmv = new PMVMatrix();
+        System.err.println(FloatUtil.matrixToString(null, "Ident     ", "%7.5f", pmv.glGetMatrixf(), 0, 4, 4, true /* rowMajorOrder */));
+
+        final float[] t = { 1f, 2f, 3f };
+        final float[] s = { 2f, 2f, 2f };
+
+        pmv.glScalef(s[0], s[1], s[2]);
+        System.err.println(FloatUtil.matrixToString(null, "Scale     ", "%7.5f", pmv.glGetMatrixf(), 0, 4, 4, true /* rowMajorOrder */));
+        pmv.glTranslatef(t[0], t[1], t[2]);
+        System.err.println(FloatUtil.matrixToString(null, "Translate ", "%7.5f", pmv.glGetMatrixf(), 0, 4, 4, true/* rowMajorOrder */));
+
+        final float[] exp = new float[] {
+                2.00000f, 0.00000f, 0.00000f, 0.00000f,
+                0.00000f, 2.00000f, 0.00000f, 0.00000f,
+                0.00000f, 0.00000f, 2.00000f, 0.00000f,
+                2.00000f, 4.00000f, 6.00000f, 1.00000f,
+        };
+        final float[] has = new float[16];
+        pmv.multPMvMatrixf(has, 0);
+        Assert.assertArrayEquals(exp, has, epsilon);
+    }
+
+    public static void main(final String args[]) {
+        org.junit.runner.JUnitCore.main(TestPMVTransform01NOUI.class.getName());
+    }
+}
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestQuaternion01NOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestQuaternion01NOUI.java
index d6d7131fa..80d2e088f 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestQuaternion01NOUI.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestQuaternion01NOUI.java
@@ -35,12 +35,13 @@ import org.junit.Test;
 import org.junit.FixMethodOrder;
 import org.junit.runners.MethodSorters;

 

+import com.jogamp.junit.util.JunitTracer;

 import com.jogamp.opengl.math.FloatUtil;

 import com.jogamp.opengl.math.Quaternion;

 import com.jogamp.opengl.math.VectorUtil;

 

 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
-public class TestQuaternion01NOUI {

+public class TestQuaternion01NOUI extends JunitTracer {

     static final boolean DEBUG = false;

 

     static final Quaternion QUAT_IDENT = new Quaternion(0f, 0f, 0f, 1f);