Bug 1452 - Decouple math functionality to 'com.jogamp.math' to be toolkit agnostic (PMVMatrix, Matrix4f, Vec4f, ..)

Math functionality (PMVMatrix, Matrix4f, Vec4f, ..) - shall be used toolkit agnostic, e.g. independent from OpenGL - shall be reused within our upcoming Vulkan implementation - may also move outside of JOGL, i.e. GlueGen or within its own package to be reused for other purposed. The 'com.jogamp.opengl.util.PMVMatrix' currently also used to feed in GLUniformData via the toolkit agnostic SyncAction and SyncBuffer shall also be split to a toolkit agnostic variant. An OpenGL PMVMatrix specialization implementing GLMatrixFunc can still exist, being derived from the toolkit agnostic base implementation. +++ Initial commit .. compile clean, passing most unit tests.
author: Sven Gothel <sgothel@jausoft.com> 2023-09-20 19:51:55 +0200
committer: Sven Gothel <sgothel@jausoft.com> 2023-09-20 19:51:55 +0200
commit: 5d6e8a367c03644740187e500c6de5d3ac039d5e (patch)
tree: a649f559413c51272ee3f4afff1f68ebfea45477 /src/jogl
parent: bbe845846ffc00807395a5070a7352c6bbe7e4ef (diff)
80 files changed, 2571 insertions, 1440 deletions
diff --git a/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java b/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java
index 644f428cd..2da0f6850 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java
@@ -36,14 +36,14 @@ import com.jogamp.graph.curve.tess.Triangulator;
 import com.jogamp.graph.geom.Outline;
 import com.jogamp.graph.geom.Triangle;
 import com.jogamp.graph.geom.Vertex;
-import com.jogamp.graph.geom.plane.AffineTransform;
-import com.jogamp.graph.geom.plane.Path2F;
-import com.jogamp.graph.geom.plane.Winding;
-import com.jogamp.opengl.math.FloatUtil;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.math.VectorUtil;
-import com.jogamp.opengl.math.Vert2fImmutable;
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.FloatUtil;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.VectorUtil;
+import com.jogamp.math.Vert2fImmutable;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.plane.AffineTransform;
+import com.jogamp.math.geom.plane.Path2F;
+import com.jogamp.math.geom.plane.Winding;
 
 /**
  * A Generic shape objects which is defined by a list of Outlines.
@@ -671,7 +671,7 @@ public final class OutlineShape implements Comparable<OutlineShape> {
      * @param y point (P1)
      * @param z point (P1)
      * @see Path2F#moveTo(float, float)
-     * @see #addPath(com.jogamp.graph.geom.plane.Path2F.Iterator, boolean)
+     * @see #addPath(com.jogamp.math.geom.plane.Path2F.Iterator, boolean)
      * @see <a href="#windingrules">see winding rules</a>
      */
     public final void moveTo(final float x, final float y, final float z) {
@@ -691,7 +691,7 @@ public final class OutlineShape implements Comparable<OutlineShape> {
      * @param y final point (P1)
      * @param z final point (P1)
      * @see Path2F#lineTo(float, float)
-     * @see #addPath(com.jogamp.graph.geom.plane.Path2F.Iterator, boolean)
+     * @see #addPath(com.jogamp.math.geom.plane.Path2F.Iterator, boolean)
      * @see <a href="#windingrules">see winding rules</a>
      */
     public final void lineTo(final float x, final float y, final float z) {
@@ -708,7 +708,7 @@ public final class OutlineShape implements Comparable<OutlineShape> {
      * @param y2 final interpolated control point (P2)
      * @param z2 quadratic parametric control point (P2)
      * @see Path2F#quadTo(float, float, float, float)
-     * @see #addPath(com.jogamp.graph.geom.plane.Path2F.Iterator, boolean)
+     * @see #addPath(com.jogamp.math.geom.plane.Path2F.Iterator, boolean)
      * @see <a href="#windingrules">see winding rules</a>
      */
     public final void quadTo(final float x1, final float y1, final float z1, final float x2, final float y2, final float z2) {
@@ -729,7 +729,7 @@ public final class OutlineShape implements Comparable<OutlineShape> {
      * @param y3 final interpolated control point (P3)
      * @param z3 final interpolated control point (P3)
      * @see Path2F#cubicTo(float, float, float, float, float, float)
-     * @see #addPath(com.jogamp.graph.geom.plane.Path2F.Iterator, boolean)
+     * @see #addPath(com.jogamp.math.geom.plane.Path2F.Iterator, boolean)
      * @see <a href="#windingrules">see winding rules</a>
      */
     public final void cubicTo(final float x1, final float y1, final float z1, final float x2, final float y2, final float z2, final float x3, final float y3, final float z3) {
@@ -741,7 +741,7 @@ public final class OutlineShape implements Comparable<OutlineShape> {
     /**
      * Closes the current sub-path segment by drawing a straight line back to the coordinates of the last moveTo. If the path is already closed then this method has no effect.
      * @see Path2F#closePath()
-     * @see #addPath(com.jogamp.graph.geom.plane.Path2F.Iterator, boolean)
+     * @see #addPath(com.jogamp.math.geom.plane.Path2F.Iterator, boolean)
      */
     public final void closePath() {
         if ( 0 < getLastOutline().getVertexCount() ) {
diff --git a/src/jogl/classes/com/jogamp/graph/curve/OutlineShapeXForm.java b/src/jogl/classes/com/jogamp/graph/curve/OutlineShapeXForm.java
index 1a21ea74f..c8d9223af 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/OutlineShapeXForm.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/OutlineShapeXForm.java
@@ -1,6 +1,6 @@
 package com.jogamp.graph.curve;
 
-import com.jogamp.graph.geom.plane.AffineTransform;
+import com.jogamp.math.geom.plane.AffineTransform;
 
 public class OutlineShapeXForm {
     public final OutlineShape shape;
diff --git a/src/jogl/classes/com/jogamp/graph/curve/Region.java b/src/jogl/classes/com/jogamp/graph/curve/Region.java
index 66ef3da6e..93b05aefa 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/Region.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/Region.java
@@ -40,17 +40,17 @@ import jogamp.opengl.Debug;
 
 import com.jogamp.graph.geom.Triangle;
 import com.jogamp.graph.geom.Vertex;
-import com.jogamp.graph.geom.plane.AffineTransform;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.Vec4f;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.Frustum;
+import com.jogamp.math.geom.plane.AffineTransform;
 import com.jogamp.common.nio.Buffers;
 import com.jogamp.common.os.Clock;
 import com.jogamp.common.util.PerfCounterCtrl;
 import com.jogamp.graph.curve.opengl.GLRegion;
 import com.jogamp.opengl.GLCapabilitiesImmutable;
 import com.jogamp.opengl.GLProfile;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.math.Vec4f;
-import com.jogamp.opengl.math.geom.AABBox;
-import com.jogamp.opengl.math.geom.Frustum;
 import com.jogamp.opengl.util.texture.TextureSequence;
 
 /**
diff --git a/src/jogl/classes/com/jogamp/graph/curve/opengl/GLRegion.java b/src/jogl/classes/com/jogamp/graph/curve/opengl/GLRegion.java
index d25ab4311..47f8e1b2a 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/opengl/GLRegion.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/opengl/GLRegion.java
@@ -35,8 +35,6 @@ import com.jogamp.opengl.util.GLArrayDataEditable;
 import com.jogamp.opengl.util.GLArrayDataServer;
 import com.jogamp.opengl.util.GLArrayDataWrapper;
 import com.jogamp.opengl.GLProfile;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.math.Vec4f;
 
 import jogamp.graph.curve.opengl.VBORegion2PMSAAES2;
 import jogamp.graph.curve.opengl.VBORegion2PVBAAES2;
@@ -44,11 +42,12 @@ import jogamp.graph.curve.opengl.VBORegionSPES2;
 import jogamp.graph.curve.opengl.shader.AttributeNames;
 import jogamp.opengl.Debug;
 
-import com.jogamp.opengl.util.PMVMatrix;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
 import com.jogamp.opengl.util.texture.TextureSequence;
 import com.jogamp.graph.curve.Region;
 import com.jogamp.graph.font.Font;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.Vec4f;
 
 import java.io.PrintStream;
 import java.nio.FloatBuffer;
@@ -508,7 +507,7 @@ public abstract class GLRegion extends Region {
      * {@link RegionRenderer#create(Vertex.Factory<? extends Vertex>, RenderState, com.jogamp.graph.curve.opengl.RegionRenderer.GLCallback, com.jogamp.graph.curve.opengl.RegionRenderer.GLCallback) created}
      * with the appropriate {@link RegionRenderer.GLCallback callbacks}.
      * </p>
-     * @param matrix current {@link PMVMatrix}.
+     * @param gl current {@link GL2ES2}.
      * @param renderer the {@link RegionRenderer} to be used
      * @param sampleCount desired multisampling sample count for vbaa- or msaa-rendering.
      *        Use -1 for glSelect mode, pass1 w/o any color texture nor channel, use static select color only.
diff --git a/src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java b/src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java
index 6fbedf809..7e3a7ff30 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java
@@ -34,9 +34,6 @@ import com.jogamp.opengl.GL;
 import com.jogamp.opengl.GL2ES2;
 import com.jogamp.opengl.GLES2;
 import com.jogamp.opengl.GLException;
-import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
-import com.jogamp.opengl.math.Recti;
-import com.jogamp.opengl.math.Vec4f;
 
 import jogamp.graph.curve.opengl.shader.AttributeNames;
 import jogamp.graph.curve.opengl.shader.UniformNames;
@@ -46,10 +43,12 @@ import com.jogamp.opengl.GLRendererQuirks;
 import com.jogamp.opengl.util.glsl.ShaderCode;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
 import com.jogamp.opengl.util.texture.TextureSequence;
-import com.jogamp.opengl.util.PMVMatrix;
 import com.jogamp.common.os.Platform;
 import com.jogamp.common.util.IntObjectHashMap;
 import com.jogamp.graph.curve.Region;
+import com.jogamp.math.Recti;
+import com.jogamp.math.Vec4f;
+import com.jogamp.math.util.PMVMatrix4f;
 
 /**
  * OpenGL {@link Region} renderer
@@ -177,7 +176,7 @@ public final class RegionRenderer {
      * For example, instances {@link #defaultBlendEnable} and {@link #defaultBlendDisable}
      * can be utilized to enable and disable {@link GL#GL_BLEND}.
      * </p>
-     * @param sharedPMVMatrix optional shared {@link PMVMatrix} to be used for the {@link RenderState} composition.
+     * @param sharedPMVMatrix optional shared {@link PMVMatrix4f} to be used for the {@link RenderState} composition.
      * @param enableCallback optional {@link GLCallback}, if not <code>null</code> will be issued at
      *                       {@link #init(GL2ES2) init(gl)} and {@link #enable(GL2ES2, boolean) enable(gl, true)}.
      * @param disableCallback optional {@link GLCallback}, if not <code>null</code> will be issued at
@@ -185,7 +184,7 @@ public final class RegionRenderer {
      * @return an instance of Region Renderer
      * @see #enable(GL2ES2, boolean)
      */
-    public static RegionRenderer create(final PMVMatrix sharedPMVMatrix,
+    public static RegionRenderer create(final PMVMatrix4f sharedPMVMatrix,
                                         final GLCallback enableCallback, final GLCallback disableCallback) {
         return new RegionRenderer(sharedPMVMatrix, enableCallback, disableCallback);
     }
@@ -221,7 +220,7 @@ public final class RegionRenderer {
         this(null, enableCallback, disableCallback);
     }
 
-    protected RegionRenderer(final PMVMatrix sharedPMVMatrix,
+    protected RegionRenderer(final PMVMatrix4f sharedPMVMatrix,
                              final GLCallback enableCallback, final GLCallback disableCallback)
     {
         this.rs = new RenderState(sharedPMVMatrix);
@@ -290,8 +289,8 @@ public final class RegionRenderer {
     // RenderState forwards
     //
 
-    /** Borrow the current {@link PMVMatrix}. */
-    public final PMVMatrix getMatrix() { return rs.getMatrix(); }
+    /** Borrow the current {@link PMVMatrix4f}. */
+    public final PMVMatrix4f getMatrix() { return rs.getMatrix(); }
 
     public final float getWeight() { return rs.getWeight(); }
 
@@ -357,7 +356,7 @@ public final class RegionRenderer {
     }
 
     /**
-     * No PMVMatrix operation is performed here.
+     * No PMVMatrix4f operation is performed here.
      */
     public final void reshapeNotify(final int x, final int y, final int width, final int height) {
         viewport.set(x, y, width, height);
@@ -374,10 +373,9 @@ public final class RegionRenderer {
     public final void reshapePerspective(final float angle_rad, final int width, final int height, final float near, final float far) {
         reshapeNotify(0, 0, width, height);
         final float ratio = (float)width/(float)height;
-        final PMVMatrix p = getMatrix();
-        p.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
-        p.glLoadIdentity();
-        p.gluPerspective(angle_rad, ratio, near, far);
+        final PMVMatrix4f p = getMatrix();
+        p.loadPIdentity();
+        p.perspectiveP(angle_rad, ratio, near, far);
     }
 
     /**
@@ -389,10 +387,9 @@ public final class RegionRenderer {
      */
     public final void reshapeOrtho(final int width, final int height, final float near, final float far) {
         reshapeNotify(0, 0, width, height);
-        final PMVMatrix p = getMatrix();
-        p.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
-        p.glLoadIdentity();
-        p.glOrthof(0, width, 0, height, near, far);
+        final PMVMatrix4f p = getMatrix();
+        p.loadPIdentity();
+        p.orthoP(0, width, 0, height, near, far);
     }
 
     //
diff --git a/src/jogl/classes/com/jogamp/graph/curve/opengl/RenderState.java b/src/jogl/classes/com/jogamp/graph/curve/opengl/RenderState.java
index f2e1c8066..b1bbdde91 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/opengl/RenderState.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/opengl/RenderState.java
@@ -33,20 +33,20 @@ import com.jogamp.opengl.GL;
 import com.jogamp.opengl.GL2ES2;
 import com.jogamp.opengl.GLException;
 import com.jogamp.opengl.GLUniformData;
-import com.jogamp.opengl.math.Vec4f;
 
 import jogamp.common.os.PlatformPropsImpl;
 import jogamp.graph.curve.opengl.shader.UniformNames;
 
 import com.jogamp.graph.curve.Region;
+import com.jogamp.math.Vec4f;
+import com.jogamp.math.util.PMVMatrix4f;
 import com.jogamp.opengl.util.GLArrayDataWrapper;
-import com.jogamp.opengl.util.PMVMatrix;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
 
 /**
  * The RenderState is owned by {@link RegionRenderer}.
  *
- * It holds rendering state data like {@link PMVMatrix}, viewport,
+ * It holds rendering state data like {@link PMVMatrix4f}, viewport,
  * but also the current {@link #getColorStatic(float[]) static color}.
  */
 public class RenderState {
@@ -91,7 +91,7 @@ public class RenderState {
         return (RenderState) gl.getContext().getAttachedObject(thisKey);
     }
 
-    private final PMVMatrix pmvMatrix;
+    private final PMVMatrix4f pmvMatrix;
     private final float[] weight;
     private final FloatBuffer weightBuffer;
     private final float[] colorStatic;
@@ -140,7 +140,7 @@ public class RenderState {
         public final boolean update(final GL2ES2 gl, final RenderState rs, final boolean updateLocation, final int renderModes, final boolean pass1, final boolean throwOnError) {
             if( rs.id() != rsId ) {
                 // Assignment of Renderstate buffers to uniforms (no copy, direct reference)
-                gcu_PMVMatrix01.setData(rs.pmvMatrix.getSyncPMvMat());
+                gcu_PMVMatrix01.setData(rs.pmvMatrix.getSyncPMv());
                 gcu_Weight.setData(rs.weightBuffer);
                 gcu_ColorStatic.setData(rs.colorStaticBuffer);
                 rsId = rs.id();
@@ -185,12 +185,12 @@ public class RenderState {
 
     /**
      * Create a RenderState, a composition of RegionRenderer
-     * @param sharedPMVMatrix optional shared PMVMatrix, if null using a local instance
+     * @param sharedPMVMatrix optional shared PMVMatrix4f, if null using a local instance
      */
-    /* pp */ RenderState(final PMVMatrix sharedPMVMatrix) {
+    /* pp */ RenderState(final PMVMatrix4f sharedPMVMatrix) {
         this.id = getNextID();
         this.sp = null;
-        this.pmvMatrix = null != sharedPMVMatrix ? sharedPMVMatrix : new PMVMatrix();
+        this.pmvMatrix = null != sharedPMVMatrix ? sharedPMVMatrix : new PMVMatrix4f();
         this.weight = new float[1];
         this.weightBuffer = FloatBuffer.wrap(weight);
         this.colorStatic = new float[] { 1, 1, 1, 1 };
@@ -229,7 +229,8 @@ public class RenderState {
         return true;
     }
 
-    public final PMVMatrix getMatrix() { return pmvMatrix; }
+    /** Borrow the current {@link PMVMatrix4f}. */
+    public final PMVMatrix4f getMatrix() { return pmvMatrix; }
 
     public static boolean isWeightValid(final float v) {
         return 0.0f <= v && v <= 1.9f ;
diff --git a/src/jogl/classes/com/jogamp/graph/curve/opengl/TextRegionUtil.java b/src/jogl/classes/com/jogamp/graph/curve/opengl/TextRegionUtil.java
index 0090480bb..782615c3e 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/opengl/TextRegionUtil.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/opengl/TextRegionUtil.java
@@ -33,13 +33,13 @@ import java.util.Iterator;
 
 import com.jogamp.opengl.GL2ES2;
 import com.jogamp.opengl.GLException;
-import com.jogamp.opengl.math.Vec4f;
-import com.jogamp.opengl.math.geom.AABBox;
 import com.jogamp.graph.curve.OutlineShape;
 import com.jogamp.graph.curve.Region;
 import com.jogamp.graph.font.Font;
 import com.jogamp.graph.font.Font.Glyph;
-import com.jogamp.graph.geom.plane.AffineTransform;
+import com.jogamp.math.Vec4f;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.plane.AffineTransform;
 
 /**
  * Text Type Rendering Utility Class adding the {@link Font.Glyph}s {@link OutlineShape} to a {@link GLRegion}.
diff --git a/src/jogl/classes/com/jogamp/graph/font/Font.java b/src/jogl/classes/com/jogamp/graph/font/Font.java
index c3c997135..997eacbb8 100644
--- a/src/jogl/classes/com/jogamp/graph/font/Font.java
+++ b/src/jogl/classes/com/jogamp/graph/font/Font.java
@@ -28,8 +28,8 @@
 package com.jogamp.graph.font;
 
 import com.jogamp.graph.curve.OutlineShape;
-import com.jogamp.graph.geom.plane.AffineTransform;
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.plane.AffineTransform;
 
 /**
  * Interface wrapper for font implementation.
diff --git a/src/jogl/classes/com/jogamp/graph/geom/Outline.java b/src/jogl/classes/com/jogamp/graph/geom/Outline.java
index 654bd2636..272f92f37 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/Outline.java
+++ b/src/jogl/classes/com/jogamp/graph/geom/Outline.java
@@ -29,13 +29,13 @@ package com.jogamp.graph.geom;
 
 import java.util.ArrayList;
 
-import com.jogamp.graph.geom.plane.AffineTransform;
-import com.jogamp.graph.geom.plane.Winding;
+import com.jogamp.math.FloatUtil;
+import com.jogamp.math.VectorUtil;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.plane.AffineTransform;
+import com.jogamp.math.geom.plane.Winding;
 import com.jogamp.graph.curve.OutlineShape;
 import com.jogamp.graph.curve.Region;
-import com.jogamp.opengl.math.FloatUtil;
-import com.jogamp.opengl.math.VectorUtil;
-import com.jogamp.opengl.math.geom.AABBox;
 
 
 
diff --git a/src/jogl/classes/com/jogamp/graph/geom/Triangle.java b/src/jogl/classes/com/jogamp/graph/geom/Triangle.java
index 6b07501a6..e26d2aaf1 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/Triangle.java
+++ b/src/jogl/classes/com/jogamp/graph/geom/Triangle.java
@@ -27,8 +27,8 @@
  */
 package com.jogamp.graph.geom;
 
-import com.jogamp.graph.geom.plane.AffineTransform;
-import com.jogamp.opengl.math.VectorUtil;
+import com.jogamp.math.VectorUtil;
+import com.jogamp.math.geom.plane.AffineTransform;
 
 public class Triangle {
     private final Vertex[] vertices = new Vertex[3];
diff --git a/src/jogl/classes/com/jogamp/graph/geom/Vertex.java b/src/jogl/classes/com/jogamp/graph/geom/Vertex.java
index e5fe76c28..8744474d9 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/Vertex.java
+++ b/src/jogl/classes/com/jogamp/graph/geom/Vertex.java
@@ -27,9 +27,9 @@
  */
 package com.jogamp.graph.geom;
 
-import com.jogamp.opengl.math.Vec2f;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.math.Vert3fImmutable;
+import com.jogamp.math.Vec2f;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.Vert3fImmutable;
 
 /**
  * A Vertex exposing Vec3f vertex- and texture-coordinates.
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Binary16.java b/src/jogl/classes/com/jogamp/math/Binary16.java
index 8e4aa9176..725c608c6 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Binary16.java
+++ b/src/jogl/classes/com/jogamp/math/Binary16.java
@@ -26,7 +26,7 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * <p>
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Binary32.java b/src/jogl/classes/com/jogamp/math/Binary32.java
index 599b1ff68..398f97c3a 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Binary32.java
+++ b/src/jogl/classes/com/jogamp/math/Binary32.java
@@ -26,7 +26,7 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * Functions for interrogating <code>binary32</code> (float) values.
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Binary64.java b/src/jogl/classes/com/jogamp/math/Binary64.java
index d4ec636a5..8561cfa8d 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Binary64.java
+++ b/src/jogl/classes/com/jogamp/math/Binary64.java
@@ -26,7 +26,7 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * Functions for interrogating <code>binary64</code> (double) values.
diff --git a/src/jogl/classes/com/jogamp/math/DoubleUtil.java b/src/jogl/classes/com/jogamp/math/DoubleUtil.java
new file mode 100644
index 000000000..e9ccceb10
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/math/DoubleUtil.java
@@ -0,0 +1,274 @@
+/**
+ * Copyright 2010-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.math;
+
+/**
+ * Basic Double math utility functions.
+ */
+public final class DoubleUtil {
+  //
+  // Scalar Ops
+  //
+
+  @SuppressWarnings("unused")
+  private static void calculateMachineEpsilonDouble() {
+      final long t0;
+      double machEps = 1.0;
+      int i=0;
+      do {
+          machEps /= 2.0;
+          i++;
+      } while (1.0 + (machEps / 2.0) != 1.0);
+      machEpsilon = machEps;
+  }
+  private static volatile boolean machEpsilonAvail = false;
+  private static double machEpsilon = 0f;
+
+  /**
+   * Return computed machine Epsilon value.
+   * <p>
+   * The machine Epsilon value is computed once.
+   * </p>
+   * @see #EPSILON
+   */
+  public static double getMachineEpsilon() {
+      if( !machEpsilonAvail ) {
+          synchronized(DoubleUtil.class) {
+              if( !machEpsilonAvail ) {
+                  machEpsilonAvail = true;
+                  calculateMachineEpsilonDouble();
+              }
+          }
+      }
+      return machEpsilon;
+  }
+
+  public static final double E = 2.7182818284590452354;
+
+  /** The value PI, i.e. 180 degrees in radians. */
+  public static final double PI = 3.14159265358979323846;
+
+  /** The value 2PI, i.e. 360 degrees in radians. */
+  public static final double TWO_PI = 2.0 * PI;
+
+  /** The value PI/2, i.e. 90 degrees in radians. */
+  public static final double HALF_PI = PI / 2.0;
+
+  /** The value PI/4, i.e. 45 degrees in radians. */
+  public static final double QUARTER_PI = PI / 4.0;
+
+  /** The value PI^2. */
+  public final static double SQUARED_PI = PI * PI;
+
+  /** Converts arc-degree to radians */
+  public static double adegToRad(final double arc_degree) {
+      return arc_degree * PI / 180.0;
+  }
+
+  /** Converts radians to arc-degree */
+  public static double radToADeg(final double rad) {
+      return rad * 180.0 / PI;
+  }
+
+  /**
+   * Epsilon for floating point {@value}, as once computed via {@link #getMachineEpsilon()} on an AMD-64 CPU.
+   * <p>
+   * Definition of machine epsilon guarantees that:
+   * <pre>
+   *        1.0 + EPSILON != 1.0
+   * </pre>
+   * In other words: <i>machEps</i> is the maximum relative error of the chosen rounding procedure.
+   * </p>
+   * <p>
+   * A number can be considered zero if it is in the range (or in the set):
+   * <pre>
+   *    <b>MaybeZeroSet</b> e ]-<i>machEps</i> .. <i>machEps</i>[  <i>(exclusive)</i>
+   * </pre>
+   * While comparing floating point values, <i>machEps</i> allows to clip the relative error:
+   * <pre>
+   *    boolean isZero    = afloat < EPSILON;
+   *    boolean isNotZero = afloat >= EPSILON;
+   *
+   *    boolean isEqual    = abs(bfloat - afloat) < EPSILON;
+   *    boolean isNotEqual = abs(bfloat - afloat) >= EPSILON;
+   * </pre>
+   * </p>
+   * @see #isEqual(float, float, float)
+   * @see #isZero(float, float)
+   */
+  public static final double EPSILON = 2.220446049250313E-16;
+
+  /**
+   * Inversion Epsilon, used with equals method to determine if two inverted matrices are close enough to be considered equal.
+   * <p>
+   * Using {@value}, which is ~100 times {@link DoubleUtil#EPSILON}.
+   * </p>
+   */
+  public static final double INV_DEVIANCE = 1.0E-8f; // EPSILON == 1.1920929E-7f; double ALLOWED_DEVIANCE: 1.0E-8f
+
+  /**
+   * Return true if both values are equal w/o regarding an epsilon.
+   * <p>
+   * Implementation considers following corner cases:
+   * <ul>
+   *    <li>NaN == NaN</li>
+   *    <li>+Inf == +Inf</li>
+   *    <li>-Inf == -Inf</li>
+   * </ul>
+   * </p>
+   * @see #isEqual(float, float, float)
+   */
+  public static boolean isEqualRaw(final double a, final double b) {
+      // Values are equal (Inf, Nan .. )
+      return Double.doubleToLongBits(a) == Double.doubleToLongBits(b);
+  }
+
+  /**
+   * Return true if both values are equal, i.e. their absolute delta < <code>epsilon</code>.
+   * <p>
+   * Implementation considers following corner cases:
+   * <ul>
+   *    <li>NaN == NaN</li>
+   *    <li>+Inf == +Inf</li>
+   *    <li>-Inf == -Inf</li>
+   * </ul>
+   * </p>
+   * @see #EPSILON
+   */
+  public static boolean isEqual(final double a, final double b, final double epsilon) {
+      if ( Math.abs(a - b) < epsilon ) {
+          return true;
+      } else {
+          // Values are equal (Inf, Nan .. )
+          return Double.doubleToLongBits(a) == Double.doubleToLongBits(b);
+      }
+  }
+
+  /**
+   * Return true if both values are equal, i.e. their absolute delta < {@link #EPSILON}.
+   * <p>
+   * Implementation considers following corner cases:
+   * <ul>
+   *    <li>NaN == NaN</li>
+   *    <li>+Inf == +Inf</li>
+   *    <li>-Inf == -Inf</li>
+   * </ul>
+   * </p>
+   * @see #EPSILON
+   */
+  public static boolean isEqual(final double a, final double b) {
+      if ( Math.abs(a - b) < EPSILON ) {
+          return true;
+      } else {
+          // Values are equal (Inf, Nan .. )
+          return Double.doubleToLongBits(a) == Double.doubleToLongBits(b);
+      }
+  }
+
+  /**
+   * Return true if both values are equal, i.e. their absolute delta < {@link #EPSILON}.
+   * <p>
+   * Implementation does not consider corner cases like {@link #isEqual(float, float, float)}.
+   * </p>
+   * @see #EPSILON
+   */
+  public static boolean isEqual2(final double a, final double b) {
+      return Math.abs(a - b) < EPSILON;
+  }
+
+  /**
+   * Return true if both values are equal w/o regarding an epsilon.
+   * <p>
+   * Implementation considers following corner cases:
+   * <ul>
+   *    <li>NaN == NaN</li>
+   *    <li>+Inf == +Inf</li>
+   *    <li>-Inf == -Inf</li>
+   *    <li>NaN > 0</li>
+   *    <li>+Inf > -Inf</li>
+   * </ul>
+   * </p>
+   * @see #compare(float, float, float)
+   */
+  public static int compare(final double a, final double b) {
+      if (a < b) {
+          return -1; // Neither is NaN, a is smaller
+      }
+      if (a > b) {
+          return 1;  // Neither is NaN, a is larger
+      }
+      final long aBits = Double.doubleToLongBits(a);
+      final long bBits = Double.doubleToLongBits(b);
+      if( aBits == bBits ) {
+          return 0;  // Values are equal (Inf, Nan .. )
+      } else if( aBits < bBits ) {
+          return -1; // (-0.0,  0.0) or (!NaN,  NaN)
+      } else {
+          return 1;  // ( 0.0, -0.0) or ( NaN, !NaN)
+      }
+  }
+
+  /**
+   * Return true if both values are equal, i.e. their absolute delta < <code>epsilon</code>.
+   * <p>
+   * Implementation considers following corner cases:
+   * <ul>
+   *    <li>NaN == NaN</li>
+   *    <li>+Inf == +Inf</li>
+   *    <li>-Inf == -Inf</li>
+   *    <li>NaN > 0</li>
+   *    <li>+Inf > -Inf</li>
+   * </ul>
+   * </p>
+   * @see #EPSILON
+   */
+  public static int compare(final double a, final double b, final double epsilon) {
+      if ( Math.abs(a - b) < epsilon ) {
+          return 0;
+      } else {
+          return compare(a, b);
+      }
+  }
+
+  /**
+   * Return true if value is zero, i.e. it's absolute value < <code>epsilon</code>.
+   * @see #EPSILON
+   */
+  public static boolean isZero(final double a, final double epsilon) {
+      return Math.abs(a) < epsilon;
+  }
+
+  /**
+   * Return true if value is zero, i.e. it's absolute value < {@link #EPSILON}.
+   * @see #EPSILON
+   */
+  public static boolean isZero(final double a) {
+      return Math.abs(a) < EPSILON;
+  }
+
+}
+\ No newline at end of file
diff --git a/src/jogl/classes/com/jogamp/opengl/math/FixedPoint.java b/src/jogl/classes/com/jogamp/math/FixedPoint.java
index 31408b079..d40bd6dac 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/FixedPoint.java
+++ b/src/jogl/classes/com/jogamp/math/FixedPoint.java
@@ -31,7 +31,7 @@
  *
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 public class FixedPoint {
   public static final int toFixed(int value) {
diff --git a/src/jogl/classes/com/jogamp/opengl/math/FloatUtil.java b/src/jogl/classes/com/jogamp/math/FloatUtil.java
index 25b5a8ad7..e75e86b7f 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/FloatUtil.java
+++ b/src/jogl/classes/com/jogamp/math/FloatUtil.java
@@ -25,7 +25,7 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 import java.nio.FloatBuffer;
 import java.util.Locale;
diff --git a/src/jogl/classes/com/jogamp/opengl/math/FovHVHalves.java b/src/jogl/classes/com/jogamp/math/FovHVHalves.java
index 5d7907f2f..cc7bcee3d 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/FovHVHalves.java
+++ b/src/jogl/classes/com/jogamp/math/FovHVHalves.java
@@ -25,7 +25,7 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * Horizontal and vertical field of view (FOV) halves,
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Matrix4f.java b/src/jogl/classes/com/jogamp/math/Matrix4f.java
index 5d1d8e968..ee505a95d 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Matrix4f.java
+++ b/src/jogl/classes/com/jogamp/math/Matrix4f.java
@@ -26,13 +26,13 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 import java.nio.FloatBuffer;
 
-import com.jogamp.opengl.math.geom.AABBox;
-import com.jogamp.opengl.math.geom.Frustum;
-import com.jogamp.opengl.math.geom.Frustum.Plane;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.Frustum;
+import com.jogamp.math.geom.Frustum.Plane;
 
 /**
  * Basic 4x4 float matrix implementation using fields for intensive use-cases (host operations).
@@ -40,8 +40,7 @@ import com.jogamp.opengl.math.geom.Frustum.Plane;
  * Implementation covers {@link FloatUtil} matrix functionality, exposed in an object oriented manner.
  * </p>
  * <p>
- * Unlike {@link com.jogamp.opengl.util.PMVMatrix PMVMatrix}, this class only represents one single matrix
- * without a complete {@link com.jogamp.opengl.fixedfunc.GLMatrixFunc GLMatrixFunc} implementation.
+ * Unlike {@link com.jogamp.math.util.PMVMatrix4f PMVMatrix4f}, this class only represents one single matrix.
  * </p>
  * <p>
  * For array operations the layout is expected in column-major order
@@ -84,7 +83,7 @@ import com.jogamp.opengl.math.geom.Frustum.Plane;
  *   <li><a href="https://github.com/lessthanoptimal/ejml">EJML Efficient Java Matrix Library</a></li>
  * </ul>
  * </p>
- * @see com.jogamp.opengl.util.PMVMatrix
+ * @see com.jogamp.math.util.PMVMatrix4f
  * @see FloatUtil
  */
 public class Matrix4f {
@@ -1319,7 +1318,7 @@ public class Matrix4f {
      * @return this matrix for chaining
      * @throws IllegalArgumentException if {@code zNear <= 0} or {@code zFar <= zNear}
      * @see #setToFrustum(float, float, float, float, float, float)
-     * @see Frustum#updateByFovDesc(Matrix4f, com.jogamp.opengl.math.geom.Frustum.FovDesc)
+     * @see Frustum#updateByFovDesc(Matrix4f, com.jogamp.math.geom.Frustum.FovDesc)
      */
     public Matrix4f setToPerspective(final FovHVHalves fovhv, final float zNear, final float zFar) throws IllegalArgumentException {
         final FovHVHalves fovhvTan = fovhv.toTangents();  // use tangent of half-fov !
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Quaternion.java b/src/jogl/classes/com/jogamp/math/Quaternion.java
index 0d04c69cc..690c1b8dc 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Quaternion.java
+++ b/src/jogl/classes/com/jogamp/math/Quaternion.java
@@ -25,7 +25,7 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * Quaternion implementation supporting
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Ray.java b/src/jogl/classes/com/jogamp/math/Ray.java
index 25a7d9a70..0189b9ce2 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Ray.java
+++ b/src/jogl/classes/com/jogamp/math/Ray.java
@@ -25,9 +25,9 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
 
 /**
  * Simple compound denoting a ray.
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Recti.java b/src/jogl/classes/com/jogamp/math/Recti.java
index 58f5e5e77..68e0cfd0b 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Recti.java
+++ b/src/jogl/classes/com/jogamp/math/Recti.java
@@ -26,7 +26,7 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * Rectangle with x, y, width and height integer components.
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Vec2f.java b/src/jogl/classes/com/jogamp/math/Vec2f.java
index f504b960b..27371401a 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Vec2f.java
+++ b/src/jogl/classes/com/jogamp/math/Vec2f.java
@@ -26,7 +26,7 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * 2D Vector based upon two float components.
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Vec2i.java b/src/jogl/classes/com/jogamp/math/Vec2i.java
index 9e70a502f..73906120d 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Vec2i.java
+++ b/src/jogl/classes/com/jogamp/math/Vec2i.java
@@ -26,7 +26,7 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * 2D Vector based upon two integer components.
diff --git a/src/jogl/classes/com/jogamp/math/Vec3d.java b/src/jogl/classes/com/jogamp/math/Vec3d.java
new file mode 100644
index 000000000..14408f714
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/math/Vec3d.java
@@ -0,0 +1,397 @@
+/**
+ * Copyright 2022-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.math;
+
+
+/**
+ * 3D Vector based upon three double components.
+ *
+ * Implementation borrowed from [gfxbox2](https://jausoft.com/cgit/cs_class/gfxbox2.git/tree/include/pixel/pixel3f.hpp#n29)
+ * and its data layout from JOAL's Vec3f.
+ */
+public final class Vec3d {
+    private double x;
+    private double y;
+    private double z;
+
+    public Vec3d() {}
+
+    public Vec3d(final Vec3d o) {
+        set(o);
+    }
+
+    /** Creating new Vec3f using Vec4f, dropping w. */
+    public Vec3d(final Vec4f o) {
+        set(o);
+    }
+
+    /** Creating new Vec3f using { Vec2f, z}. */
+    public Vec3d(final Vec2f o, final double z) {
+        set(o, z);
+    }
+
+    public Vec3d copy() {
+        return new Vec3d(this);
+    }
+
+    public Vec3d(final double[/*3*/] xyz) {
+        set(xyz);
+    }
+
+    public Vec3d(final double x, final double y, final double z) {
+        set(x, y, z);
+    }
+
+    /** this = o, returns this. */
+    public Vec3d set(final Vec3d o) {
+        this.x = o.x;
+        this.y = o.y;
+        this.z = o.z;
+        return this;
+    }
+
+    /** this = { o, z }, returns this. */
+    public Vec3d set(final Vec2f o, final double z) {
+        this.x = o.x();
+        this.y = o.y();
+        this.z = z;
+        return this;
+    }
+
+    /** this = o while dropping w, returns this. */
+    public Vec3d set(final Vec4f o) {
+        this.x = o.x();
+        this.y = o.y();
+        this.z = o.z();
+        return this;
+    }
+
+    /** this = { x, y, z }, returns this. */
+    public Vec3d set(final double x, final double y, final double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+
+    /** this = xyz, returns this. */
+    public Vec3d set(final double[/*3*/] xyz) {
+        this.x = xyz[0];
+        this.y = xyz[1];
+        this.z = xyz[2];
+        return this;
+    }
+
+    /** Sets the ith component, 0 <= i < 3 */
+    public void set(final int i, final double val) {
+        switch (i) {
+            case 0: x = val; break;
+            case 1: y = val; break;
+            case 2: z = val; break;
+            default: throw new IndexOutOfBoundsException();
+        }
+    }
+
+    /** xyz = this, returns xyz. */
+    public double[] get(final double[/*3*/] xyz) {
+        xyz[0] = this.x;
+        xyz[1] = this.y;
+        xyz[2] = this.z;
+        return xyz;
+    }
+
+    /** Gets the ith component, 0 <= i < 3 */
+    public double get(final int i) {
+        switch (i) {
+            case 0: return x;
+            case 1: return y;
+            case 2: return z;
+            default: throw new IndexOutOfBoundsException();
+        }
+    }
+
+    public double x() { return x; }
+    public double y() { return y; }
+    public double z() { return z; }
+
+    public void setX(final double x) { this.x = x; }
+    public void setY(final double y) { this.y = y; }
+    public void setZ(final double z) { this.z = z; }
+
+    /** this = max(this, m), returns this. */
+    public Vec3d max(final Vec3d m) {
+        this.x = Math.max(this.x, m.x);
+        this.y = Math.max(this.y, m.y);
+        this.z = Math.max(this.z, m.z);
+        return this;
+    }
+    /** this = min(this, m), returns this. */
+    public Vec3d min(final Vec3d m) {
+        this.x = Math.min(this.x, m.x);
+        this.y = Math.min(this.y, m.y);
+        this.z = Math.min(this.z, m.z);
+        return this;
+    }
+
+    /** Returns this * val; creates new vector */
+    public Vec3d mul(final double val) {
+        return new Vec3d(this).scale(val);
+    }
+
+    /** this = a * b, returns this. */
+    public Vec3d mul(final Vec3d a, final Vec3d b) {
+        x = a.x * b.x;
+        y = a.y * b.y;
+        z = a.z * b.z;
+        return this;
+    }
+
+    /** this = this * s, returns this. */
+    public Vec3d scale(final double s) {
+        x *= s;
+        y *= s;
+        z *= s;
+        return this;
+    }
+
+    /** this = this * { sx, sy, sz }, returns this. */
+    public Vec3d scale(final double sx, final double sy, final double sz) {
+        x *= sx;
+        y *= sy;
+        z *= sz;
+        return this;
+    }
+
+    /** this = this * { s.x, s.y, s.z }, returns this. */
+    public Vec3d scale(final Vec3d s) { return scale(s.x, s.y, s.z); }
+
+    /** Returns this + arg; creates new vector */
+    public Vec3d plus(final Vec3d arg) {
+        return new Vec3d(this).add(arg);
+    }
+
+    /** this = a + b, returns this. */
+    public Vec3d plus(final Vec3d a, final Vec3d b) {
+        x = a.x + b.x;
+        y = a.y + b.y;
+        z = a.z + b.z;
+        return this;
+    }
+
+    /** this = this + { dx, dy, dz }, returns this. */
+    public Vec3d add(final double dx, final double dy, final double dz) {
+        x += dx;
+        y += dy;
+        z += dz;
+        return this;
+    }
+
+    /** this = this + b, returns this. */
+    public Vec3d add(final Vec3d b) {
+        x += b.x;
+        y += b.y;
+        z += b.z;
+        return this;
+    }
+
+    /** Returns this - arg; creates new vector */
+    public Vec3d minus(final Vec3d arg) {
+        return new Vec3d(this).sub(arg);
+    }
+
+    /** this = a - b, returns this. */
+    public Vec3d minus(final Vec3d a, final Vec3d b) {
+        x = a.x - b.x;
+        y = a.y - b.y;
+        z = a.z - b.z;
+        return this;
+    }
+
+    /** this = this - b, returns this. */
+    public Vec3d sub(final Vec3d b) {
+        x -= b.x;
+        y -= b.y;
+        z -= b.z;
+        return this;
+    }
+
+    /** Return true if all components are zero, i.e. it's absolute value < {@link #EPSILON}. */
+    public boolean isZero() {
+        return DoubleUtil.isZero(x) && DoubleUtil.isZero(y) && DoubleUtil.isZero(z);
+    }
+
+    /**
+     * Return the length of this vector, a.k.a the <i>norm</i> or <i>magnitude</i>
+     */
+    public double length() {
+        return Math.sqrt(lengthSq());
+    }
+
+    /**
+     * Return the squared length of this vector, a.k.a the squared <i>norm</i> or squared <i>magnitude</i>
+     */
+    public double lengthSq() {
+        return x*x + y*y + z*z;
+    }
+
+    /**
+     * Normalize this vector in place
+     */
+    public Vec3d normalize() {
+        final double lengthSq = lengthSq();
+        if ( DoubleUtil.isZero( lengthSq ) ) {
+            x = 0.0f;
+            y = 0.0f;
+            z = 0.0f;
+        } else {
+            final double invSqr = 1.0f / Math.sqrt(lengthSq);
+            x *= invSqr;
+            y *= invSqr;
+            z *= invSqr;
+        }
+        return this;
+    }
+
+    /**
+     * Return the squared distance between this vector and the given one.
+     * <p>
+     * When comparing the relative distance between two points it is usually sufficient to compare the squared
+     * distances, thus avoiding an expensive square root operation.
+     * </p>
+     */
+    public double distSq(final Vec3d o) {
+        final double dx = x - o.x;
+        final double dy = y - o.y;
+        final double dz = z - o.z;
+        return dx*dx + dy*dy + dz*dz;
+    }
+
+    /**
+     * Return the distance between this vector and the given one.
+     */
+    public double dist(final Vec3d o) {
+        return Math.sqrt(distSq(o));
+    }
+
+
+    /**
+     * Return the dot product of this vector and the given one
+     * @return the dot product as double
+     */
+    public double dot(final Vec3d o) {
+        return x*o.x + y*o.y + z*o.z;
+    }
+
+    /** Returns this cross arg; creates new vector */
+    public Vec3d cross(final Vec3d arg) {
+        return new Vec3d().cross(this, arg);
+    }
+
+    /** this = a cross b. NOTE: "this" must be a different vector than
+      both a and b. */
+    public Vec3d cross(final Vec3d a, final Vec3d b) {
+        x = a.y * b.z - a.z * b.y;
+        y = a.z * b.x - a.x * b.z;
+        z = a.x * b.y - a.y * b.x;
+        return this;
+    }
+
+    /**
+     * Return the cosine of the angle between two vectors using {@link #dot(Vec3d)}
+     */
+    public double cosAngle(final Vec3d o) {
+        return dot(o) / ( length() * o.length() ) ;
+    }
+
+    /**
+     * Return the angle between two vectors in radians using {@link Math#acos(double)} on {@link #cosAngle(Vec3d)}.
+     */
+    public double angle(final Vec3d o) {
+        return Math.acos( cosAngle(o) );
+    }
+
+    /**
+     * Equals check using a given {@link DoubleUtil#EPSILON} value and {@link DoubleUtil#isEqual(double, double, double)}.
+     * <p>
+     * Implementation considers following corner cases:
+     * <ul>
+     *    <li>NaN == NaN</li>
+     *    <li>+Inf == +Inf</li>
+     *    <li>-Inf == -Inf</li>
+     * </ul>
+     * @param o comparison value
+     * @param epsilon consider using {@link DoubleUtil#EPSILON}
+     * @return true if all components differ less than {@code epsilon}, otherwise false.
+     */
+    public boolean isEqual(final Vec3d o, final double epsilon) {
+        if( this == o ) {
+            return true;
+        } else {
+            return DoubleUtil.isEqual(x, o.x, epsilon) &&
+                   DoubleUtil.isEqual(y, o.y, epsilon) &&
+                   DoubleUtil.isEqual(z, o.z, epsilon);
+        }
+    }
+
+    /**
+     * Equals check using {@link DoubleUtil#EPSILON} in {@link DoubleUtil#isEqual(double, double)}.
+     * <p>
+     * Implementation considers following corner cases:
+     * <ul>
+     *    <li>NaN == NaN</li>
+     *    <li>+Inf == +Inf</li>
+     *    <li>-Inf == -Inf</li>
+     * </ul>
+     * @param o comparison value
+     * @return true if all components differ less than {@link DoubleUtil#EPSILON}, otherwise false.
+     */
+    public boolean isEqual(final Vec3d o) {
+        if( this == o ) {
+            return true;
+        } else {
+            return DoubleUtil.isEqual(x, o.x) &&
+                   DoubleUtil.isEqual(y, o.y) &&
+                   DoubleUtil.isEqual(z, o.z);
+        }
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if( o instanceof Vec3d ) {
+            return isEqual((Vec3d)o);
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return x + " / " + y + " / " + z;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Vec3f.java b/src/jogl/classes/com/jogamp/math/Vec3f.java
index 7012edd74..1ad27463e 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Vec3f.java
+++ b/src/jogl/classes/com/jogamp/math/Vec3f.java
@@ -26,7 +26,7 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * 3D Vector based upon three float components.
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Vec4f.java b/src/jogl/classes/com/jogamp/math/Vec4f.java
index 914450bf1..45afea7f8 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Vec4f.java
+++ b/src/jogl/classes/com/jogamp/math/Vec4f.java
@@ -26,7 +26,7 @@
  * or implied, of JogAmp Community.
  */
 
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 /**
  * 4D Vector based upon four float components.
diff --git a/src/jogl/classes/com/jogamp/opengl/math/VectorUtil.java b/src/jogl/classes/com/jogamp/math/VectorUtil.java
index e38501c73..6cea0be0b 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/VectorUtil.java
+++ b/src/jogl/classes/com/jogamp/math/VectorUtil.java
@@ -25,11 +25,11 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 import java.util.ArrayList;
 
-import com.jogamp.graph.geom.plane.Winding;
+import com.jogamp.math.geom.plane.Winding;
 
 public final class VectorUtil {
     /**
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Vert2fImmutable.java b/src/jogl/classes/com/jogamp/math/Vert2fImmutable.java
index 66bf078f3..5fc5de7ef 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Vert2fImmutable.java
+++ b/src/jogl/classes/com/jogamp/math/Vert2fImmutable.java
@@ -25,7 +25,7 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 public interface Vert2fImmutable {
     float x();
diff --git a/src/jogl/classes/com/jogamp/opengl/math/Vert3fImmutable.java b/src/jogl/classes/com/jogamp/math/Vert3fImmutable.java
index 6f63a746c..03e26e840 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/Vert3fImmutable.java
+++ b/src/jogl/classes/com/jogamp/math/Vert3fImmutable.java
@@ -25,7 +25,7 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math;
+package com.jogamp.math;
 
 public interface Vert3fImmutable extends Vert2fImmutable {
     float z();
diff --git a/src/jogl/classes/com/jogamp/opengl/math/geom/AABBox.java b/src/jogl/classes/com/jogamp/math/geom/AABBox.java
index 1720caf0e..926f55aec 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/geom/AABBox.java
+++ b/src/jogl/classes/com/jogamp/math/geom/AABBox.java
@@ -25,16 +25,15 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math.geom;
+package com.jogamp.math.geom;
 
-import com.jogamp.graph.geom.plane.AffineTransform;
-import com.jogamp.opengl.math.FloatUtil;
-import com.jogamp.opengl.math.Matrix4f;
-import com.jogamp.opengl.math.Quaternion;
-import com.jogamp.opengl.math.Ray;
-import com.jogamp.opengl.math.Recti;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.util.PMVMatrix;
+import com.jogamp.math.FloatUtil;
+import com.jogamp.math.Matrix4f;
+import com.jogamp.math.Quaternion;
+import com.jogamp.math.Ray;
+import com.jogamp.math.Recti;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.geom.plane.AffineTransform;
 
 
 /**
@@ -836,21 +835,6 @@ public class AABBox {
     }
 
     /**
-     * Transform this box using the {@link PMVMatrix#getMvMat() modelview} of the given {@link PMVMatrix} into {@code out}
-     * @param pmv transformation {@link PMVMatrix}
-     * @param out the resulting {@link AABBox}
-     * @return the resulting {@link AABBox} for chaining
-     */
-    public AABBox transformMv(final PMVMatrix pmv, final AABBox out) {
-        final Vec3f tmp = new Vec3f();
-        out.reset();
-        out.resize( pmv.mulMvMatVec3f(low, tmp) );
-        out.resize( pmv.mulMvMatVec3f(high, tmp) );
-        out.computeCenter();
-        return out;
-    }
-
-    /**
      * Assume this bounding box as being in object space and
      * compute the window bounding box.
      * <p>
diff --git a/src/jogl/classes/com/jogamp/opengl/math/geom/Frustum.java b/src/jogl/classes/com/jogamp/math/geom/Frustum.java
index 73079959b..9e9f65c31 100644
--- a/src/jogl/classes/com/jogamp/opengl/math/geom/Frustum.java
+++ b/src/jogl/classes/com/jogamp/math/geom/Frustum.java
@@ -25,11 +25,11 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.math.geom;
+package com.jogamp.math.geom;
 
-import com.jogamp.opengl.math.FovHVHalves;
-import com.jogamp.opengl.math.Matrix4f;
-import com.jogamp.opengl.math.Vec3f;
+import com.jogamp.math.FovHVHalves;
+import com.jogamp.math.Matrix4f;
+import com.jogamp.math.Vec3f;
 
 /**
  * Providing frustum {@link #getPlanes() planes} derived by different inputs
diff --git a/src/jogl/classes/com/jogamp/graph/geom/plane/AffineTransform.java b/src/jogl/classes/com/jogamp/math/geom/plane/AffineTransform.java
index 66d661990..05d7e201e 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/plane/AffineTransform.java
+++ b/src/jogl/classes/com/jogamp/math/geom/plane/AffineTransform.java
@@ -18,15 +18,15 @@
  * @author Denis M. Kishenko
  * @author Sven Gothel, (c) 2010-2023
  */
-package com.jogamp.graph.geom.plane;
+package com.jogamp.math.geom.plane;
 
 // import jogamp.opengl.util.HashCode;
 
 import com.jogamp.graph.geom.Vertex;
-import com.jogamp.opengl.math.FloatUtil;
-import com.jogamp.opengl.math.Vec2f;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.FloatUtil;
+import com.jogamp.math.Vec2f;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.geom.AABBox;
 
 public class AffineTransform implements Cloneable {
 
diff --git a/src/jogl/classes/com/jogamp/graph/geom/plane/Crossing2F.java b/src/jogl/classes/com/jogamp/math/geom/plane/Crossing2F.java
index 7eb1d0bf0..09476238f 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/plane/Crossing2F.java
+++ b/src/jogl/classes/com/jogamp/math/geom/plane/Crossing2F.java
@@ -17,9 +17,9 @@
 /**
  * @author Denis M. Kishenko
  */
-package com.jogamp.graph.geom.plane;
+package com.jogamp.math.geom.plane;
 
-import com.jogamp.opengl.math.FloatUtil;
+import com.jogamp.math.FloatUtil;
 
 /* pp */ class Crossing2F {
 
diff --git a/src/jogl/classes/com/jogamp/graph/geom/plane/IllegalPathStateException.java b/src/jogl/classes/com/jogamp/math/geom/plane/IllegalPathStateException.java
index be0a14a76..95e47fe5b 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/plane/IllegalPathStateException.java
+++ b/src/jogl/classes/com/jogamp/math/geom/plane/IllegalPathStateException.java
@@ -17,7 +17,7 @@
 /**
  * @author Denis M. Kishenko
  */
-package com.jogamp.graph.geom.plane;
+package com.jogamp.math.geom.plane;
 
 public class IllegalPathStateException extends RuntimeException {
 
diff --git a/src/jogl/classes/com/jogamp/graph/geom/plane/NoninvertibleTransformException.java b/src/jogl/classes/com/jogamp/math/geom/plane/NoninvertibleTransformException.java
index fb90cedfc..f82195944 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/plane/NoninvertibleTransformException.java
+++ b/src/jogl/classes/com/jogamp/math/geom/plane/NoninvertibleTransformException.java
@@ -17,7 +17,7 @@
 /**
  * @author Denis M. Kishenko
  */
-package com.jogamp.graph.geom.plane;
+package com.jogamp.math.geom.plane;
 
 public class NoninvertibleTransformException extends java.lang.Exception {
 
diff --git a/src/jogl/classes/com/jogamp/graph/geom/plane/Path2F.java b/src/jogl/classes/com/jogamp/math/geom/plane/Path2F.java
index 588232d9a..9e0dda286 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/plane/Path2F.java
+++ b/src/jogl/classes/com/jogamp/math/geom/plane/Path2F.java
@@ -18,12 +18,12 @@
  * @author Denis M. Kishenko
  * @author Sven Gothel
  */
-package com.jogamp.graph.geom.plane;
+package com.jogamp.math.geom.plane;
 
 import java.io.PrintStream;
 import java.util.NoSuchElementException;
 
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
 
 /**
  * Path2F represents and provides construction method for a 2D shape using float[2] points.
diff --git a/src/jogl/classes/com/jogamp/graph/geom/plane/Winding.java b/src/jogl/classes/com/jogamp/math/geom/plane/Winding.java
index bfa214c22..0b3c8dc21 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/plane/Winding.java
+++ b/src/jogl/classes/com/jogamp/math/geom/plane/Winding.java
@@ -1,4 +1,4 @@
-package com.jogamp.graph.geom.plane;
+package com.jogamp.math.geom.plane;
 
 /**
  * Winding direction, either clockwise (CW) or counter-clockwise (CCW).
diff --git a/src/jogl/classes/com/jogamp/graph/geom/plane/WindingRule.java b/src/jogl/classes/com/jogamp/math/geom/plane/WindingRule.java
index 46ef167a3..d7881b6db 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/plane/WindingRule.java
+++ b/src/jogl/classes/com/jogamp/math/geom/plane/WindingRule.java
@@ -1,4 +1,4 @@
-package com.jogamp.graph.geom.plane;
+package com.jogamp.math.geom.plane;
 
 /**
  * Winding rule, either EVEN_ODD or NON_ZERO (like for TrueType fonts).
diff --git a/src/jogl/classes/com/jogamp/math/util/PMVMatrix4f.java b/src/jogl/classes/com/jogamp/math/util/PMVMatrix4f.java
new file mode 100644
index 000000000..826ca82f6
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/math/util/PMVMatrix4f.java
@@ -0,0 +1,1610 @@
+/**
+ * Copyright 2009-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.math.util;
+
+import java.nio.Buffer;
+import java.nio.FloatBuffer;
+
+import com.jogamp.common.nio.Buffers;
+import com.jogamp.math.FloatUtil;
+import com.jogamp.math.Matrix4f;
+import com.jogamp.math.Quaternion;
+import com.jogamp.math.Ray;
+import com.jogamp.math.Recti;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.Vec4f;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.Frustum;
+
+/**
+ * PMVMatrix4f implements the basic computer graphics {@link Matrix4f} pack using
+ * projection (P), modelview (Mv) and texture (T) {@link Matrix4f} operations.
+ * <p>
+ * Unlike {@link com.jogamp.opengl.util.PMVMatrix PMVMatrix}, this class doesn't implement
+ * {@link com.jogamp.opengl.fixedfunc.GLMatrixFunc GLMatrixFunc} and is OpenGL agnostic.
+ * </p>
+ * <p>
+ * This is the second implementation of `PMVMatrix4f` using
+ * direct {@link Matrix4f}, {@link Vec4f} and {@link Vec3f} math operations instead of `float[]`
+ * via {@link com.jogamp.math.FloatUtil FloatUtil}.
+ * </p>
+ * <p>
+ * PMVMatrix4f provides the {@link #getMvi() inverse modelview matrix (Mvi)} and
+ * {@link #getMvit() inverse transposed modelview matrix (Mvit)}.
+ * {@link Frustum} is also provided by {@link #getFrustum()}.
+ *
+ * To keep these derived values synchronized after mutable Mv operations like {@link #rotateMv(Quaternion)}
+ * users have to call {@link #update()} before using Mvi and Mvit.
+ * </p>
+ * <p>
+ * All matrices are provided in column-major order,
+ * as specified in the OpenGL fixed function pipeline, i.e. compatibility profile.
+ * See {@link Matrix4f}.
+ * </p>
+ * <p>
+ * PMVMatrix4f can supplement {@link com.jogamp.opengl.GL2ES2 GL2ES2} applications w/ the
+ * lack of the described matrix functionality.
+ * </p>
+ * <a name="storageDetails"><h5>Matrix storage details</h5></a>
+ * <p>
+ * The {@link SyncBuffer} abstraction is provided, e.g. {@link #getSyncPMvMvi()},
+ * to synchronize the respective {@link Matrix4f matrices} with the `float[]` backing store.
+ * The latter is represents the data to {@link com.jogamp.opengl.GLUniformData} via its {@link FloatBuffer}s, see {@link SyncBuffer#getBuffer()},
+ * and is pushed to the GPU eventually.
+ * </p>
+ * <p>
+ * {@link SyncBuffer}'s {@link SyncAction} is called by {@link com.jogamp.opengl.GLUniformData#getBuffer()},
+ * i.e. before the data is pushed to the GPU.
+ * </p>
+ * <p>
+ * The provided {@link SyncAction} ensures that the {@link Matrix4f matrices data}
+ * gets copied into the `float[]` backing store.
+ * </p>
+ * <p>
+ * PMVMatrix4f provides two specializations of {@link SyncBuffer}, {@link SyncMatrix4f} for single {@link Matrix4f} mappings
+ * and {@link SyncMatrices4f} for multiple {@link Matrix4f} mappings.
+ * </p>
+ * <p>
+ * They can be feed directly to instantiate a {@link com.jogamp.opengl.GLUniformData} object via e.g. {@link com.jogamp.opengl.GLUniformData#GLUniformData(String, int, int, SyncBuffer)}.
+ * </p>
+ * <p>
+ * All {@link Matrix4f matrix} {@link SyncBuffer}'s backing store are backed up by a common primitive float-array for performance considerations
+ * and are a {@link Buffers#slice2Float(float[], int, int) sliced} representation of it.
+ * </p>
+ * <p>
+ * <b>{@link Matrix4f} {@link SyncBuffer}'s Backing-Store Notes:</b>
+ * <ul>
+ *   <li>The {@link Matrix4f matrix} {@link SyncBuffer}'s backing store is a {@link Buffers#slice2Float(float[], int, int) sliced part } of a host matrix and it's start position has been {@link FloatBuffer#mark() marked}.</li>
+ *   <li>Use {@link FloatBuffer#reset() reset()} to rewind it to it's start position after relative operations, like {@link FloatBuffer#get() get()}.</li>
+ *   <li>If using absolute operations like {@link FloatBuffer#get(int) get(int)}, use it's {@link FloatBuffer#reset() reset} {@link FloatBuffer#position() position} as it's offset.</li>
+ * </ul>
+ * </p>
+ */
+public class PMVMatrix4f {
+
+    /** Bit value stating a modified {@link #getP() projection matrix (P)}, since last {@link #update()} call. */
+    public static final int MODIFIED_PROJECTION = 1 << 0;
+    /** Bit value stating a modified {@link #getMv() modelview matrix (Mv)}, since last {@link #update()} call. */
+    public static final int MODIFIED_MODELVIEW = 1 << 1;
+    /** Bit value stating a modified {@link #getT() texture matrix (T)}, since last {@link #update()} call. */
+    public static final int MODIFIED_TEXTURE = 1 << 2;
+    /** Bit value stating all is modified */
+    public static final int MODIFIED_ALL = MODIFIED_PROJECTION | MODIFIED_MODELVIEW | MODIFIED_TEXTURE;
+    /** Bit value for {@link #getMvi() inverse modelview matrix (Mvi)}, updated via {@link #update()}. */
+    public static final int INVERSE_MODELVIEW = 1 << 1;
+    /** Bit value for {@link #getMvit() inverse transposed modelview matrix (Mvit)}, updated via {@link #update()}. */
+    public static final int INVERSE_TRANSPOSED_MODELVIEW = 1 << 2;
+    /** Bit value for {@link #getFrustum() frustum} and updated by {@link #getFrustum()}. */
+    public static final int FRUSTUM = 1 << 3;
+    /** Bit value for {@link #getPMv() pre-multiplied P * Mv}, updated by {@link #getPMv()}. */
+    public static final int PREMUL_PMV = 1 << 4;
+    /** Bit value for {@link #getPMvi() pre-multiplied invert(P * Mv)}, updated by {@link #getPMvi()}. */
+    public static final int PREMUL_PMVI = 1 << 5;
+    /** Manual bits not covered by {@link #update()} but {@link #getFrustum()}, {@link #FRUSTUM}, {@link #getPMv()}, {@link #PREMUL_PMV}, {@link #getPMvi()}, {@link #PREMUL_PMVI}, etc. */
+    public static final int MANUAL_BITS = FRUSTUM | PREMUL_PMV | PREMUL_PMVI;
+
+    /**
+     * Creates an instance of PMVMatrix4f.
+     * <p>
+     * This constructor only sets up an instance w/o additional {@link #INVERSE_MODELVIEW} or {@link #INVERSE_TRANSPOSED_MODELVIEW}.
+     * </p>
+     * <p>
+     * Implementation uses non-direct non-NIO Buffers with guaranteed backing array,
+     * which are synchronized to the actual Matrix4f instances.
+     * This allows faster access in Java computation.
+     * </p>
+     * @see #PMVMatrix4f(int)
+     */
+    public PMVMatrix4f() {
+        this(0);
+    }
+
+    /**
+     * Creates an instance of PMVMatrix4f.
+     * <p>
+     * Additional derived matrices can be requested via `derivedMatrices`, i.e.
+     * - {@link #INVERSE_MODELVIEW}
+     * - {@link #INVERSE_TRANSPOSED_MODELVIEW}
+     * </p>
+     * <p>
+     * Implementation uses non-direct non-NIO Buffers with guaranteed backing array,
+     * which are synchronized to the actual Matrix4f instances.
+     * This allows faster access in Java computation.
+     * </p>
+     * @param derivedMatrices additional matrices can be requested by passing bits {@link #INVERSE_MODELVIEW} and {@link #INVERSE_TRANSPOSED_MODELVIEW}.
+     * @see #getReqBits()
+     * @see #isReqDirty()
+     * @see #getDirtyBits()
+     * @see #update()
+     */
+    public PMVMatrix4f(final int derivedMatrices) {
+        // I    Identity
+        // T    Texture
+        // P    Projection
+        // Mv   ModelView
+        // Mvi  Modelview-Inverse
+        // Mvit Modelview-Inverse-Transpose
+        {
+            int mask = 0;
+            if( 0 != ( derivedMatrices & ( INVERSE_MODELVIEW | INVERSE_TRANSPOSED_MODELVIEW ) ) ) {
+                mask |= INVERSE_MODELVIEW;
+            }
+            if( 0 != ( derivedMatrices & INVERSE_TRANSPOSED_MODELVIEW ) ) {
+                mask |= INVERSE_TRANSPOSED_MODELVIEW;
+            }
+            requestBits = mask;
+        }
+
+        // actual underlying Matrix4f count
+        int mcount     = 3;
+
+        // actual underlying Matrix4f data
+        matP           = new Matrix4f();
+        matMv          = new Matrix4f();
+        matTex         = new Matrix4f();
+
+        if( 0 != ( requestBits & INVERSE_MODELVIEW ) ) {
+            matMvi         = new Matrix4f();
+            mMvi_offset    = 2*16;
+            ++mcount;
+        } else {
+            matMvi         = null;
+            mMvi_offset    = -1;
+        }
+        if( 0 != ( requestBits & INVERSE_TRANSPOSED_MODELVIEW ) ) {
+            matMvit        = new Matrix4f();
+            mMvit_offset   = 3*16;
+            ++mcount;
+        } else {
+            matMvit        = null;
+            mMvit_offset   = -1;
+        }
+        mTex_offset        = (mcount-1)*16; // last one
+
+        // float back buffer for GPU, Matrix4f -> matrixStore via SyncedBuffer
+        matrixStore    = new float[mcount*16];
+
+        // FloatBuffer for single Matrix4f back-buffer
+        final FloatBuffer bufP                 = Buffers.slice2Float(matrixStore,  mP_offset,    1*16);  // P
+        syncP       = new SyncBuffer0(matP,    bufP);   // mP_offset
+
+        final FloatBuffer bufMv                = Buffers.slice2Float(matrixStore,  mMv_offset,   1*16);  // Mv
+        syncMv      = new SyncBuffer1(matMv,   bufMv,   mMv_offset);
+
+        final FloatBuffer bufP_Mv              = Buffers.slice2Float(matrixStore,  mP_offset,    2*16);  // P + Mv
+        syncP_Mv    = new SyncBufferN(new Matrix4f[]  { matP, matMv }, bufP_Mv, mP_offset);
+
+        final FloatBuffer bufTex               = Buffers.slice2Float(matrixStore,  mTex_offset,  1*16);  // T
+        syncT       = new SyncBuffer1(matTex,  bufTex,  mTex_offset);
+
+        if( null != matMvi ) {
+            final FloatBuffer bufMvi           = Buffers.slice2Float(matrixStore,  mMvi_offset,  1*16);  // Mvi
+            final FloatBuffer bufP_Mv_Mvi      = Buffers.slice2Float(matrixStore,  mP_offset,    3*16);  // P + Mv + Mvi
+            syncMvi      = new SyncBuffer1U(matMvi,  bufMvi,  mMvi_offset);
+            syncP_Mv_Mvi = new SyncBufferNU(new Matrix4f[] { matP, matMv, matMvi }, bufP_Mv_Mvi, mP_offset);
+        } else {
+            syncMvi     = null;
+            syncP_Mv_Mvi = null;
+        }
+        if( null != matMvit ) {
+            final FloatBuffer bufMvit          = Buffers.slice2Float(matrixStore,  mMvit_offset, 1*16);  //          Mvit
+            final FloatBuffer bufP_Mv_Mvi_Mvit = Buffers.slice2Float(matrixStore,  mP_offset,    4*16);  // P + Mv + Mvi + Mvit
+            syncMvit          = new SyncBuffer1U(matMvit, bufMvit, mMvit_offset);
+            syncP_Mv_Mvi_Mvit = new SyncBufferNU(new Matrix4f[] { matP, matMv, matMvi, matMvit }, bufP_Mv_Mvi_Mvit, mP_offset);
+        } else {
+            syncMvit = null;
+            syncP_Mv_Mvi_Mvit = null;
+        }
+
+        mat4Tmp1 = new Matrix4f();
+
+        mat4Tmp2 = null; // on demand
+        matPMv = null; // on demand
+        matPMvi = null; // on demand
+        matPMviOK = false;
+        frustum = null; // on demand
+
+        reset();
+    }
+
+    /**
+     * Issues {@link Matrix4f#loadIdentity()} on all matrices and resets all internal states.
+     */
+    public void reset() {
+        matP.loadIdentity();
+        matMv.loadIdentity();
+        matTex.loadIdentity();
+
+        modifiedBits = MODIFIED_ALL;
+        dirtyBits = requestBits | MANUAL_BITS;
+    }
+
+    //
+    // Temporary storage access for efficiency
+    //
+
+
+    /**
+     * Return the second temporary Matrix4f exposed to be reused for efficiency.
+     * <p>
+     * Temporary storage is only used by this class within single method calls,
+     * hence has no side-effects.
+     * </p>
+     */
+    protected final Matrix4f getTmp2Mat() {
+        if( null == mat4Tmp2 ) {
+            mat4Tmp2 = new Matrix4f();
+        }
+        return mat4Tmp2;
+    }
+
+    //
+    // Regular Matrix4f access as well as their SyncedBuffer counterpart SyncedMatrix and SyncedMatrices
+    //
+
+    /**
+     * Returns the {@link GLMatrixFunc#GL_TEXTURE_MATRIX texture matrix} (T).
+     * <p>
+     * Consider using {@link #setTextureDirty()} if modifying the returned {@link Matrix4f}.
+     * </p>
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     */
+    public final Matrix4f getT() {
+        return matTex;
+    }
+
+    /**
+     * Returns the {@link SyncMatrix} of {@link GLMatrixFunc#GL_TEXTURE_MATRIX texture matrix} (T).
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     */
+    public final SyncMatrix4f getSyncT() {
+        return syncT;
+    }
+
+    /**
+     * Returns the {@link GLMatrixFunc#GL_PROJECTION_MATRIX projection matrix} (P).
+     * <p>
+     * Consider using {@link #setProjectionDirty()} if modifying the returned {@link Matrix4f}.
+     * </p>
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     */
+    public final Matrix4f getP() {
+        return matP;
+    }
+
+    /**
+     * Returns the {@link SyncMatrix} of {@link GLMatrixFunc#GL_PROJECTION_MATRIX projection matrix} (P).
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     */
+    public final SyncMatrix4f getSyncP() {
+        return syncP;
+    }
+
+    /**
+     * Returns the {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mv).
+     * <p>
+     * Consider using {@link #setModelviewDirty()} if modifying the returned {@link Matrix4f}.
+     * </p>
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     */
+    public final Matrix4f getMv() {
+        return matMv;
+    }
+
+    /**
+     * Returns the {@link SyncMatrix} of {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mv).
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     */
+    public final SyncMatrix4f getSyncMv() {
+        return syncMv;
+    }
+
+    /**
+     * Returns {@link SyncMatrices4f} of 2 matrices within one FloatBuffer: {@link #getP() P} and {@link #getMv() Mv}.
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     */
+    public final SyncMatrices4f getSyncPMv() {
+        return syncP_Mv;
+    }
+
+    /**
+     * Returns the inverse {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mvi) if requested.
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     * @throws IllegalArgumentException if {@link #INVERSE_MODELVIEW} has not been requested in ctor {@link #PMVMatrix4f(int)}.
+     */
+    public final Matrix4f getMvi() {
+        if( 0 == ( INVERSE_MODELVIEW & requestBits ) ) {
+            throw new IllegalArgumentException("Not requested in ctor");
+        }
+        updateImpl(false);
+        return matMvi;
+    }
+
+    /**
+     * Returns the {@link SyncMatrix} of inverse {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mvi) if requested.
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     * @throws IllegalArgumentException if {@link #INVERSE_MODELVIEW} has not been requested in ctor {@link #PMVMatrix4f(int)}.
+     */
+    public final SyncMatrix4f getSyncMvi() {
+        if( 0 == ( INVERSE_MODELVIEW & requestBits ) ) {
+            throw new IllegalArgumentException("Not requested in ctor");
+        }
+        return syncMvi;
+    }
+
+    /**
+     * Returns the inverse transposed {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mvit) if requested.
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     * @throws IllegalArgumentException if {@link #INVERSE_TRANSPOSED_MODELVIEW} has not been requested in ctor {@link #PMVMatrix4f(int)}.
+     */
+    public final Matrix4f getMvit() {
+        if( 0 == ( INVERSE_TRANSPOSED_MODELVIEW & requestBits ) ) {
+            throw new IllegalArgumentException("Not requested in ctor");
+        }
+        updateImpl(false);
+        return matMvit;
+    }
+
+    /**
+     * Returns the {@link SyncMatrix} of inverse transposed {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mvit) if requested.
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     * @throws IllegalArgumentException if {@link #INVERSE_TRANSPOSED_MODELVIEW} has not been requested in ctor {@link #PMVMatrix4f(int)}.
+     */
+    public final SyncMatrix4f getSyncMvit() {
+        if( 0 == ( INVERSE_TRANSPOSED_MODELVIEW & requestBits ) ) {
+            throw new IllegalArgumentException("Not requested in ctor");
+        }
+        return syncMvit;
+    }
+
+    /**
+     * Returns {@link SyncMatrices4f} of 3 matrices within one FloatBuffer: {@link #getP() P}, {@link #getMv() Mv} and {@link #getMvi() Mvi} if requested.
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     * @throws IllegalArgumentException if {@link #INVERSE_MODELVIEW} has not been requested in ctor {@link #PMVMatrix4f(int)}.
+     */
+    public final SyncMatrices4f getSyncPMvMvi() {
+        if( 0 == ( INVERSE_MODELVIEW & requestBits ) ) {
+            throw new IllegalArgumentException("Not requested in ctor");
+        }
+        return syncP_Mv_Mvi;
+    }
+
+    /**
+     * Returns {@link SyncMatrices4f} of 4 matrices within one FloatBuffer: {@link #getP() P}, {@link #getMv() Mv}, {@link #getMvi() Mvi} and {@link #getMvit() Mvit} if requested.
+     * <p>
+     * See <a href="#storageDetails"> matrix storage details</a>.
+     * </p>
+     * @throws IllegalArgumentException if {@link #INVERSE_TRANSPOSED_MODELVIEW} has not been requested in ctor {@link #PMVMatrix4f(int)}.
+     */
+    public final SyncMatrices4f getSyncPMvMviMvit() {
+        if( 0 == ( INVERSE_TRANSPOSED_MODELVIEW & requestBits ) ) {
+            throw new IllegalArgumentException("Not requested in ctor");
+        }
+        return syncP_Mv_Mvi_Mvit;
+    }
+
+    //
+    // Basic Matrix4f, Vec3f and Vec4f operations similar to GLMatrixFunc
+    //
+
+    /**
+     * Returns multiplication result of {@link #getP() P} and {@link #getMv() Mv} matrix, i.e.
+     * <pre>
+     *    result = P x Mv
+     * </pre>
+     * @param result 4x4 matrix storage for result
+     * @return given result matrix for chaining
+     */
+    public final Matrix4f getMulPMv(final Matrix4f result) {
+        return result.mul(matP, matMv);
+    }
+
+    /**
+     * Returns multiplication result of {@link #getMv() Mv} and {@link #getP() P} matrix, i.e.
+     * <pre>
+     *    result = Mv x P
+     * </pre>
+     * @param result 4x4 matrix storage for result
+     * @return given result matrix for chaining
+     */
+    public final Matrix4f getMulMvP(final Matrix4f result) {
+        return result.mul(matMv, matP);
+    }
+
+    /**
+     * v_out = Mv * v_in
+     * @param v_in input vector, can be v_out for in-place transformation
+     * @param v_out output vector
+     * @returns v_out for chaining
+     */
+    public final Vec4f mulWithMv(final Vec4f v_in, final Vec4f v_out) {
+        return matMv.mulVec4f(v_in, v_out);
+    }
+
+    /**
+     * v_inout = Mv * v_inout
+     * @param v_inout input and output vector, i.e. in-place transformation
+     * @returns v_inout for chaining
+     */
+    public final Vec4f mulWithMv(final Vec4f v_inout) {
+        return matMv.mulVec4f(v_inout);
+    }
+
+    /**
+     * v_out = Mv * v_in
+     *
+     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
+     *
+     * @param v_in input vector, can be v_out for in-place transformation
+     * @param v_out output vector
+     * @returns v_out for chaining
+     */
+    public final Vec3f mulWithMv(final Vec3f v_in, final Vec3f v_out) {
+        return matMv.mulVec3f(v_in, v_out);
+    }
+
+    /**
+     * v_inout = Mv * v_inout
+     *
+     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
+     *
+     * @param v_inout input and output vector, i.e. in-place transformation
+     * @returns v_inout for chaining
+     */
+    public final Vec3f mulWithMv(final Vec3f v_inout) {
+        return matMv.mulVec3f(v_inout);
+    }
+
+    /**
+     * v_out = P * v_in
+     * @param v_in input vector, can be v_out for in-place transformation
+     * @param v_out output vector
+     * @return given result vector for chaining
+     * @returns v_out for chaining
+     */
+    public final Vec4f mulWithP(final Vec4f v_in, final Vec4f v_out) {
+        return matP.mulVec4f(v_in, v_out);
+    }
+
+    /**
+     * v_inout = P * v_inout
+     * @param v_inout input and output vector, i.e. in-place transformation
+     * @return given result vector for chaining
+     * @returns v_inout for chaining
+     */
+    public final Vec4f mulWithP(final Vec4f v_inout) {
+        return matP.mulVec4f(v_inout);
+    }
+
+    /**
+     * v_out = P * v_in
+     *
+     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
+     *
+     * @param v_in float[3] input vector, can be v_out for in-place transformation
+     * @param v_out float[3] output vector
+     * @returns v_out for chaining
+     */
+    public final Vec3f mulWithP(final Vec3f v_in, final Vec3f v_out) {
+        return matP.mulVec3f(v_in, v_out);
+    }
+
+    /**
+     * v_inout = P * v_inout
+     *
+     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
+     *
+     * @param v_inout input and output vector, i.e. in-place transformation
+     * @returns v_inout for chaining
+     */
+    public final Vec3f mulWithP(final Vec3f v_inout) {
+        return matP.mulVec3f(v_inout);
+    }
+
+    /**
+     * v_out = P * Mv * v_in
+     * @param v_in float[4] input vector, can be v_out for in-place transformation
+     * @param v_out float[4] output vector
+     * @returns v_out for chaining
+     */
+    public final Vec4f mulWithPMv(final Vec4f v_in, final Vec4f v_out) {
+        return matP.mulVec4f( matMv.mulVec4f( v_in, v_out ) );
+    }
+
+    /**
+     * v_inout = P * Mv * v_inout
+     * @param v_inout input and output vector, i.e. in-place transformation
+     * @returns v_inout for chaining
+     */
+    public final Vec4f mulWithPMv(final Vec4f v_inout) {
+        return matP.mulVec4f( matMv.mulVec4f( v_inout ) );
+    }
+
+    /**
+     * v_out = P * Mv * v_in
+     *
+     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
+     *
+     * @param v_in float[3] input vector, can be v_out for in-place transformation
+     * @param v_out float[3] output vector
+     * @returns v_out for chaining
+     */
+    public final Vec3f mulWithPMv(final Vec3f v_in, final Vec3f v_out) {
+        return matP.mulVec3f( matMv.mulVec3f( v_in, v_out ) );
+    }
+
+    /**
+     * v_inout = P * Mv * v_inout
+     *
+     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
+     *
+     * @param v_inout float[3] input and output vector, i.e. in-place transformation
+     * @returns v_inout for chaining
+     */
+    public final Vec3f mulWithPMv(final Vec3f v_inout) {
+        return matP.mulVec3f( matMv.mulVec3f( v_inout ) );
+    }
+
+    //
+    // GLMatrixFunc alike functionality
+    //
+
+    /**
+     * Load the {@link #getMv() modelview matrix} with the provided values.
+     */
+    public final PMVMatrix4f loadMv(final float[] values, final int offset) {
+        matMv.load(values, offset);
+        setModelviewDirty();
+        return this;
+    }
+    /**
+     * Load the {@link #getMv() modelview matrix} with the provided values.
+     */
+    public final PMVMatrix4f loadMv(final java.nio.FloatBuffer m) {
+        final int spos = m.position();
+        matMv.load(m);
+        setModelviewDirty();
+        m.position(spos);
+        return this;
+    }
+    /**
+     * Load the {@link #getMv() modelview matrix} with the values of the given {@link Matrix4f}.
+     */
+    public final PMVMatrix4f loadMv(final Matrix4f m) {
+        matMv.load(m);
+        setModelviewDirty();
+        return this;
+    }
+    /**
+     * Load the {@link #getMv() modelview matrix} with the values of the given {@link Quaternion}'s rotation {@link Matrix4f#setToRotation(Quaternion) matrix representation}.
+     */
+    public final PMVMatrix4f loadMv(final Quaternion quat) {
+        matMv.setToRotation(quat);
+        setModelviewDirty();
+        return this;
+    }
+
+    /**
+     * Load the {@link #getP() projection matrix} with the provided values.
+     */
+    public final PMVMatrix4f loadP(final float[] values, final int offset) {
+        matP.load(values, offset);
+        setProjectionDirty();
+        return this;
+    }
+    /**
+     * Load the {@link #getP() projection matrix} with the provided values.
+     */
+    public final PMVMatrix4f loadP(final java.nio.FloatBuffer m) {
+        final int spos = m.position();
+        matP.load(m);
+        setProjectionDirty();
+        m.position(spos);
+        return this;
+    }
+    /**
+     * Load the {@link #getP() projection matrix} with the values of the given {@link Matrix4f}.
+     */
+    public final PMVMatrix4f loadP(final Matrix4f m) {
+        matP.load(m);
+        setProjectionDirty();
+        return this;
+    }
+    /**
+     * Load the {@link #getP() projection matrix} with the values of the given {@link Quaternion}'s rotation {@link Matrix4f#setToRotation(Quaternion) matrix representation}.
+     */
+    public final PMVMatrix4f loadP(final Quaternion quat) {
+        matP.setToRotation(quat);
+        setProjectionDirty();
+        return this;
+    }
+
+    /**
+     * Load the {@link #getT() texture matrix} with the provided values.
+     */
+    public final PMVMatrix4f loadT(final float[] values, final int offset) {
+        matTex.load(values, offset);
+        setTextureDirty();
+        return this;
+    }
+    /**
+     * Load the {@link #getT() texture matrix} with the provided values.
+     */
+    public final PMVMatrix4f loadT(final java.nio.FloatBuffer m) {
+        final int spos = m.position();
+        matTex.load(m);
+        setTextureDirty();
+        m.position(spos);
+        return this;
+    }
+    /**
+     * Load the {@link #getT() texture matrix} with the values of the given {@link Matrix4f}.
+     */
+    public final PMVMatrix4f loadT(final Matrix4f m) {
+        matTex.load(m);
+        setTextureDirty();
+        return this;
+    }
+    /**
+     * Load the {@link #getT() texture matrix} with the values of the given {@link Quaternion}'s rotation {@link Matrix4f#setToRotation(Quaternion) matrix representation}.
+     */
+    public final PMVMatrix4f loadT(final Quaternion quat) {
+        matTex.setToRotation(quat);
+        setTextureDirty();
+        return this;
+    }
+
+    /**
+     * Load the {@link #getMv() modelview matrix} with the values of the given {@link Matrix4f}.
+     */
+    public final PMVMatrix4f loadMvIdentity() {
+        matMv.loadIdentity();
+        setModelviewDirty();
+        return this;
+    }
+
+    /**
+     * Load the {@link #getP() projection matrix} with the values of the given {@link Matrix4f}.
+     */
+    public final PMVMatrix4f loadPIdentity() {
+        matP.loadIdentity();
+        setProjectionDirty();
+        return this;
+    }
+
+    /**
+     * Load the {@link #getT() texture matrix} with the values of the given {@link Matrix4f}.
+     */
+    public final PMVMatrix4f loadTIdentity() {
+        matTex.loadIdentity();
+        setTextureDirty();
+        return this;
+    }
+
+    /**
+     * Multiply the {@link #getMv() modelview matrix}: [c] = [c] x [m]
+     * @param m the right hand Matrix4f
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f mulMv(final Matrix4f m) {
+        matMv.mul( m );
+        setModelviewDirty();
+        return this;
+    }
+
+    /**
+     * Multiply the {@link #getP() projection matrix}: [c] = [c] x [m]
+     * @param m the right hand Matrix4f
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f mulP(final Matrix4f m) {
+        matP.mul( m );
+        setProjectionDirty();
+        return this;
+    }
+
+    /**
+     * Multiply the {@link #getT() texture matrix}: [c] = [c] x [m]
+     * @param m the right hand Matrix4f
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f mulT(final Matrix4f m) {
+        matTex.mul( m );
+        setTextureDirty();
+        return this;
+    }
+
+    /**
+     * Translate the {@link #getMv() modelview matrix}.
+     * @param x
+     * @param y
+     * @param z
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f translateMv(final float x, final float y, final float z) {
+        return mulMv( mat4Tmp1.setToTranslation(x, y, z) );
+    }
+    /**
+     * Translate the {@link #getMv() modelview matrix}.
+     * @param t translation vec3
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f translateMv(final Vec3f t) {
+        return mulMv( mat4Tmp1.setToTranslation(t) );
+    }
+
+    /**
+     * Translate the {@link #getP() projection matrix}.
+     * @param x
+     * @param y
+     * @param z
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f translateP(final float x, final float y, final float z) {
+        return mulP( mat4Tmp1.setToTranslation(x, y, z) );
+    }
+    /**
+     * Translate the {@link #getP() projection matrix}.
+     * @param t translation vec3
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f translateP(final Vec3f t) {
+        return mulP( mat4Tmp1.setToTranslation(t) );
+    }
+
+    /**
+     * Scale the {@link #getMv() modelview matrix}.
+     * @param x
+     * @param y
+     * @param z
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f scaleMv(final float x, final float y, final float z) {
+        return mulMv( mat4Tmp1.setToScale(x, y, z) );
+    }
+    /**
+     * Scale the {@link #getMv() modelview matrix}.
+     * @param s scale vec4f
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f scaleMv(final Vec3f s) {
+        return mulMv( mat4Tmp1.setToScale(s) );
+    }
+
+    /**
+     * Scale the {@link #getP() projection matrix}.
+     * @param x
+     * @param y
+     * @param z
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f scaleP(final float x, final float y, final float z) {
+        return mulP( mat4Tmp1.setToScale(x, y, z) );
+    }
+    /**
+     * Scale the {@link #getP() projection matrix}.
+     * @param s scale vec4f
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f scaleP(final Vec3f s) {
+        return mulP( mat4Tmp1.setToScale(s) );
+    }
+
+    /**
+     * Rotate the {@link #getMv() modelview matrix} by the given axis and angle in radians.
+     * <p>
+     * Consider using {@link #rotateMv(Quaternion)}
+     * </p>
+     * @param ang_rad angle in radians
+     * @param axis rotation axis
+     * @return this instance of chaining
+     * @see #rotateMv(Quaternion)
+     */
+    public final PMVMatrix4f rotateMv(final float ang_rad, final float x, final float y, final float z) {
+        return mulMv( mat4Tmp1.setToRotationAxis(ang_rad, x, y, z) );
+    }
+    /**
+     * Rotate the {@link #getMv() modelview matrix} by the given axis and angle in radians.
+     * <p>
+     * Consider using {@link #rotateMv(Quaternion)}
+     * </p>
+     * @param ang_rad angle in radians
+     * @param axis rotation axis
+     * @return this instance of chaining
+     * @see #rotateMv(Quaternion)
+     */
+    public final PMVMatrix4f rotateMv(final float ang_rad, final Vec3f axis) {
+        return mulMv( mat4Tmp1.setToRotationAxis(ang_rad, axis) );
+    }
+    /**
+     * Rotate the {@link #getMv() modelview matrix} with the given {@link Quaternion}'s rotation {@link Matrix4f#setToRotation(Quaternion) matrix representation}.
+     * @param quat the {@link Quaternion}
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f rotateMv(final Quaternion quat) {
+        return mulMv( mat4Tmp1.setToRotation(quat) );
+    }
+
+    /**
+     * Rotate the {@link #getP() projection matrix} by the given axis and angle in radians.
+     * <p>
+     * Consider using {@link #rotateP(Quaternion)}
+     * </p>
+     * @param ang_rad angle in radians
+     * @param axis rotation axis
+     * @return this instance of chaining
+     * @see #rotateP(Quaternion)
+     */
+    public final PMVMatrix4f rotateP(final float ang_rad, final float x, final float y, final float z) {
+        return mulP( mat4Tmp1.setToRotationAxis(ang_rad, x, y, z) );
+    }
+    /**
+     * Rotate the {@link #getP() projection matrix} by the given axis and angle in radians.
+     * <p>
+     * Consider using {@link #rotateP(Quaternion)}
+     * </p>
+     * @param ang_rad angle in radians
+     * @param axis rotation axis
+     * @return this instance of chaining
+     * @see #rotateP(Quaternion)
+     */
+    public final PMVMatrix4f rotateP(final float ang_rad, final Vec3f axis) {
+        return mulP( mat4Tmp1.setToRotationAxis(ang_rad, axis) );
+    }
+    /**
+     * Rotate the {@link #getP() projection matrix} with the given {@link Quaternion}'s rotation {@link Matrix4f#setToRotation(Quaternion) matrix representation}.
+     * @param quat the {@link Quaternion}
+     * @return this instance of chaining
+     */
+    public final PMVMatrix4f rotateP(final Quaternion quat) {
+        return mulP( mat4Tmp1.setToRotation(quat) );
+    }
+
+    /** Pop the {@link #getMv() modelview matrix} from its stack. */
+    public final PMVMatrix4f popMv() {
+        matMv.pop();
+        setModelviewDirty();
+        return this;
+    }
+    /** Pop the {@link #getP() projection matrix} from its stack. */
+    public final PMVMatrix4f popP() {
+        matP.pop();
+        setProjectionDirty();
+        return this;
+    }
+    /** Pop the {@link #getT() texture matrix} from its stack. */
+    public final PMVMatrix4f popT() {
+        matTex.pop();
+        setTextureDirty();
+        return this;
+    }
+    /** Push the {@link #getMv() modelview matrix} to its stack, while preserving its values. */
+    public final PMVMatrix4f pushMv() {
+        matMv.push();
+        return this;
+    }
+    /** Push the {@link #getP() projection matrix} to its stack, while preserving its values. */
+    public final PMVMatrix4f pushP() {
+        matP.push();
+        return this;
+    }
+    /** Push the {@link #getT() texture matrix} to its stack, while preserving its values. */
+    public final PMVMatrix4f pushT() {
+        matTex.push();
+        return this;
+    }
+
+    /**
+     * {@link #mulP(Matrix4f) Multiply} the {@link #getP() projection matrix} with the orthogonal matrix.
+     * @param left
+     * @param right
+     * @param bottom
+     * @param top
+     * @param zNear
+     * @param zFar
+     * @see Matrix4f#setToOrtho(float, float, float, float, float, float)
+     */
+    public final void orthoP(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) {
+        mulP( mat4Tmp1.setToOrtho(left, right, bottom, top, zNear, zFar) );
+    }
+
+    /**
+     * {@link #mulP(Matrix4f) Multiply} the {@link #getP() projection matrix} with the frustum matrix.
+     *
+     * @throws IllegalArgumentException if {@code zNear <= 0} or {@code zFar <= zNear}
+     *                          or {@code left == right}, or {@code bottom == top}.
+     * @see Matrix4f#setToFrustum(float, float, float, float, float, float)
+     */
+    public final void frustumP(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) throws IllegalArgumentException {
+        mulP( mat4Tmp1.setToFrustum(left, right, bottom, top, zNear, zFar) );
+    }
+
+    //
+    // Extra functionality
+    //
+
+    /**
+     * {@link #mulP(Matrix4f) Multiply} the {@link #getP() projection matrix} with the perspective/frustum matrix.
+     *
+     * @param fovy_rad fov angle in radians
+     * @param aspect aspect ratio width / height
+     * @param zNear
+     * @param zFar
+     * @throws IllegalArgumentException if {@code zNear <= 0} or {@code zFar <= zNear}
+     * @see Matrix4f#setToPerspective(float, float, float, float)
+     */
+    public final PMVMatrix4f perspectiveP(final float fovy_rad, final float aspect, final float zNear, final float zFar) throws IllegalArgumentException {
+        mulP( mat4Tmp1.setToPerspective(fovy_rad, aspect, zNear, zFar) );
+        return this;
+    }
+
+    /**
+     * {@link #mulP(Matrix4f) Multiply} the {@link #getP() projection matrix}
+     * with the eye, object and orientation, i.e. {@link Matrix4f#setToLookAt(Vec3f, Vec3f, Vec3f, Matrix4f)}.
+     */
+    public final PMVMatrix4f lookAtP(final Vec3f eye, final Vec3f center, final Vec3f up) {
+        mulP( mat4Tmp1.setToLookAt(eye, center, up, getTmp2Mat()) );
+        return this;
+    }
+
+    /**
+     * Map object coordinates to window coordinates.
+     * <p>
+     * Traditional <code>gluProject</code> implementation.
+     * </p>
+     *
+     * @param objPos 3 component object coordinate
+     * @param viewport Rect4i viewport
+     * @param winPos 3 component window coordinate, the result
+     * @return true if successful, otherwise false (z is 1)
+     */
+    public final boolean mapObjToWin(final Vec3f objPos, final Recti viewport, final Vec3f winPos) {
+        return Matrix4f.mapObjToWin(objPos, matMv, matP, viewport, winPos);
+    }
+
+    /**
+     * Map window coordinates to object coordinates.
+     * <p>
+     * Traditional <code>gluUnProject</code> implementation.
+     * </p>
+     *
+     * @param winx
+     * @param winy
+     * @param winz
+     * @param viewport Rect4i viewport
+     * @param objPos 3 component object coordinate, the result
+     * @return true if successful, otherwise false (failed to invert matrix, or becomes infinity due to zero z)
+     */
+    public final boolean mapWinToObj(final float winx, final float winy, final float winz,
+                                     final Recti viewport, final Vec3f objPos) {
+        if( Matrix4f.mapWinToObj(winx, winy, winz, getPMvi(), viewport, objPos) ) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Map window coordinates to object coordinates.
+     * <p>
+     * Traditional <code>gluUnProject4</code> implementation.
+     * </p>
+     *
+     * @param winx
+     * @param winy
+     * @param winz
+     * @param clipw
+     * @param viewport Rect4i viewport
+     * @param near
+     * @param far
+     * @param objPos 4 component object coordinate, the result
+     * @return true if successful, otherwise false (failed to invert matrix, or becomes infinity due to zero z)
+     */
+    public boolean mapWinToObj4(final float winx, final float winy, final float winz, final float clipw,
+                                final Recti viewport, final float near, final float far, final Vec4f objPos) {
+        if( Matrix4f.mapWinToObj4(winx, winy, winz, clipw, getPMvi(), viewport, near, far, objPos) ) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Map two window coordinates w/ shared X/Y and distinctive Z
+     * to a {@link Ray}. The resulting {@link Ray} maybe used for <i>picking</i>
+     * using a {@link AABBox#getRayIntersection(Vec3f, Ray, float, boolean) bounding box}.
+     * <p>
+     * Notes for picking <i>winz0</i> and <i>winz1</i>:
+     * <ul>
+     *   <li>see {@link FloatUtil#getZBufferEpsilon(int, float, float)}</li>
+     *   <li>see {@link FloatUtil#getZBufferValue(int, float, float, float)}</li>
+     *   <li>see {@link FloatUtil#getOrthoWinZ(float, float, float)}</li>
+     * </ul>
+     * </p>
+     * @param winx
+     * @param winy
+     * @param winz0
+     * @param winz1
+     * @param viewport
+     * @param ray storage for the resulting {@link Ray}
+     * @return true if successful, otherwise false (failed to invert matrix, or becomes z is infinity)
+     */
+    public final boolean mapWinToRay(final float winx, final float winy, final float winz0, final float winz1,
+                                     final Recti viewport, final Ray ray) {
+        return Matrix4f.mapWinToRay(winx, winy, winz0, winz1, getPMvi(), viewport, ray);
+    }
+
+    public StringBuilder toString(StringBuilder sb, final String f) {
+        if(null == sb) {
+            sb = new StringBuilder();
+        }
+        final boolean pmvDirty  = 0 != (PREMUL_PMV & dirtyBits);
+        final boolean pmvUsed = null != matPMv;
+
+        final boolean pmviDirty  = 0 != (PREMUL_PMVI & dirtyBits);
+        final boolean pmviUsed = null != matPMvi;
+
+        final boolean frustumDirty = 0 != (FRUSTUM & dirtyBits);
+        final boolean frustumUsed = null != frustum;
+
+        final boolean mviDirty  = 0 != (INVERSE_MODELVIEW & dirtyBits);
+        final boolean mviReq = 0 != (INVERSE_MODELVIEW & requestBits);
+
+        final boolean mvitDirty = 0 != (INVERSE_TRANSPOSED_MODELVIEW & dirtyBits);
+        final boolean mvitReq = 0 != (INVERSE_TRANSPOSED_MODELVIEW & requestBits);
+
+        final boolean modP = 0 != ( MODIFIED_PROJECTION & modifiedBits );
+        final boolean modMv = 0 != ( MODIFIED_MODELVIEW & modifiedBits );
+        final boolean modT = 0 != ( MODIFIED_TEXTURE & modifiedBits );
+        int count = 3; // P, Mv, T
+
+        sb.append("PMVMatrix4f[modified[P ").append(modP).append(", Mv ").append(modMv).append(", T ").append(modT);
+        sb.append("], dirty/used[PMv ").append(pmvDirty).append("/").append(pmvUsed).append(", Pmvi ").append(pmviDirty).append("/").append(pmviUsed).append(", Frustum ").append(frustumDirty).append("/").append(frustumUsed);
+        sb.append("], dirty/req[Mvi ").append(mviDirty).append("/").append(mviReq).append(", Mvit ").append(mvitDirty).append("/").append(mvitReq).append("]").append(System.lineSeparator());
+        sb.append(", Projection").append(System.lineSeparator());
+        matP.toString(sb, null, f);
+        sb.append(", Modelview").append(System.lineSeparator());
+        matMv.toString(sb, null, f);
+        sb.append(", Texture").append(System.lineSeparator());
+        matTex.toString(sb, null, f);
+        if( null != matPMv ) {
+            sb.append(", P * Mv").append(System.lineSeparator());
+            matPMv.toString(sb, null, f);
+            ++count;
+        }
+        if( null != matPMvi ) {
+            sb.append(", P * Mv").append(System.lineSeparator());
+            matPMvi.toString(sb, null, f);
+            ++count;
+        }
+        if( mviReq ) {
+            sb.append(", Inverse Modelview").append(System.lineSeparator());
+            matMvi.toString(sb, null, f);
+            ++count;
+        }
+        if( mvitReq ) {
+            sb.append(", Inverse Transposed Modelview").append(System.lineSeparator());
+            matMvit.toString(sb, null, f);
+            ++count;
+        }
+        int tmpCount = 1;
+        if( null != mat4Tmp2 ) {
+            ++tmpCount;
+        }
+        sb.append(", matrices "+count+" + "+tmpCount+" temp = "+(count+tmpCount)+"]");
+        return sb;
+    }
+
+    @Override
+    public String toString() {
+        return toString(null, "%10.5f").toString();
+    }
+
+    /**
+     * Returns the modified bits due to mutable operations..
+     * <p>
+     * A modified bit is set, if the corresponding matrix had been modified by a mutable operation
+     * since last {@link #update()} or {@link #getModifiedBits(boolean) getModifiedBits(true)} call.
+     * </p>
+     * @param clear if true, clears the modified bits, otherwise leaves them untouched.
+     *
+     * @see #MODIFIED_PROJECTION
+     * @see #MODIFIED_MODELVIEW
+     * @see #MODIFIED_TEXTURE
+     * @see #getDirtyBits()
+     * @see #isReqDirty()
+     */
+    public final int getModifiedBits(final boolean clear) {
+        final int r = modifiedBits;
+        if(clear) {
+            modifiedBits = 0;
+        }
+        return r;
+    }
+
+    /**
+     * Returns the dirty bits due to mutable operations,
+     * i.e.
+     * - {@link #INVERSE_MODELVIEW} (if requested)
+     * - {@link #INVERSE_TRANSPOSED_MODELVIEW} (if requested)
+     * - {@link #FRUSTUM} (always, cleared via {@link #getFrustum()}
+     * <p>
+     * A dirty bit is set, if the corresponding matrix had been modified by a mutable operation
+     * since last {@link #update()} call and requested in the constructor {@link #PMVMatrix4f(int)}.
+     * </p>
+     * <p>
+     * {@link #update()} clears the dirty state for the matrices and {@link #getFrustum()} for {@link #FRUSTUM}.
+     * </p>
+     *
+     * @see #isReqDirty()
+     * @see #INVERSE_MODELVIEW
+     * @see #INVERSE_TRANSPOSED_MODELVIEW
+     * @see #FRUSTUM
+     * @see #PMVMatrix4f(int)
+     * @see #getMvi()
+     * @see #getMvit()
+     * @see #getSyncPMvMvi()
+     * @see #getSyncPMvMviMvit()
+     * @see #getFrustum()
+     */
+    public final int getDirtyBits() {
+        return dirtyBits;
+    }
+
+    /**
+     * Returns true if the one of the {@link #getReqBits() requested bits} are are set dirty due to mutable operations,
+     * i.e. at least one of
+     * - {@link #INVERSE_MODELVIEW}
+     * - {@link #INVERSE_TRANSPOSED_MODELVIEW}
+     * <p>
+     * A dirty bit is set, if the corresponding matrix had been modified by a mutable operation
+     * since last {@link #update()} call and requested in the constructor {@link #PMVMatrix4f(int)}.
+     * </p>
+     * <p>
+     * {@link #update()} clears the dirty state for the matrices and {@link #getFrustum()} for {@link #FRUSTUM}.
+     * </p>
+     *
+     * @see #INVERSE_MODELVIEW
+     * @see #INVERSE_TRANSPOSED_MODELVIEW
+     * @see #PMVMatrix4f(int)
+     * @see #getMvi()
+     * @see #getMvit()
+     * @see #getSyncPMvMvi()
+     * @see #getSyncPMvMviMvit()
+     */
+    public final boolean isReqDirty() {
+        return 0 != ( requestBits & dirtyBits );
+    }
+
+    /**
+     * Sets the {@link #getMv() Modelview (Mv)} matrix dirty and modified,
+     * i.e. adds {@link #getReqBits() requested bits} and {@link #MANUAL_BITS} to {@link #getDirtyBits() dirty bits}.
+     * @see #isReqDirty()
+     */
+    public final void setModelviewDirty() {
+        dirtyBits |= requestBits | MANUAL_BITS ;
+        modifiedBits |= MODIFIED_MODELVIEW;
+    }
+
+    /**
+     * Sets the {@link #getP() Projection (P)} matrix dirty and modified,
+     * i.e. adds {@link #MANUAL_BITS} to {@link #getDirtyBits() dirty bits}.
+     */
+    public final void setProjectionDirty() {
+        dirtyBits |= MANUAL_BITS ;
+        modifiedBits |= MODIFIED_PROJECTION;
+    }
+
+    /**
+     * Sets the {@link #getT() Texture (T)} matrix modified.
+     */
+    public final void setTextureDirty() {
+        modifiedBits |= MODIFIED_TEXTURE;
+    }
+
+    /**
+     * Returns the request bit mask, which uses bit values equal to the dirty mask
+     * and may contain
+     * - {@link #INVERSE_MODELVIEW}
+     * - {@link #INVERSE_TRANSPOSED_MODELVIEW}
+     * <p>
+     * The request bit mask is set by in the constructor {@link #PMVMatrix4f(int)}.
+     * </p>
+     *
+     * @see #INVERSE_MODELVIEW
+     * @see #INVERSE_TRANSPOSED_MODELVIEW
+     * @see #PMVMatrix4f(int)
+     * @see #getMvi()
+     * @see #getMvit()
+     * @see #getSyncPMvMvi()
+     * @see #getSyncPMvMviMvit()
+     * @see #getFrustum()
+     */
+    public final int getReqBits() {
+        return requestBits;
+    }
+
+    /**
+     * Returns the pre-multiplied projection x modelview, P x Mv.
+     * <p>
+     * This {@link Matrix4f} instance should be re-fetched via this method and not locally stored
+     * to have it updated from a potential modification of underlying projection and/or modelview matrix.
+     * {@link #update()} has no effect on this {@link Matrix4f}.
+     * </p>
+     * <p>
+     * This pre-multipled P x Mv is considered dirty, if its corresponding
+     * {@link #getP() P matrix} or {@link #getMv() Mv matrix} has been modified since its last update.
+     * </p>
+     * @see #update()
+     */
+    public final Matrix4f getPMv() {
+        if( 0 != ( dirtyBits & PREMUL_PMV ) ) {
+            if( null == matPMv ) {
+                matPMv = new Matrix4f();
+            }
+            matPMv.mul(matP, matMv);
+            dirtyBits &= ~PREMUL_PMV;
+        }
+        return matPMv;
+    }
+
+    /**
+     * Returns the pre-multiplied inverse projection x modelview,
+     * if {@link Matrix4f#invert(Matrix4f)} succeeded, otherwise `null`.
+     * <p>
+     * This {@link Matrix4f} instance should be re-fetched via this method and not locally stored
+     * to have it updated from a potential modification of underlying projection and/or modelview matrix.
+     * {@link #update()} has no effect on this {@link Matrix4f}.
+     * </p>
+     * <p>
+     * This pre-multipled invert(P x Mv) is considered dirty, if its corresponding
+     * {@link #getP() P matrix} or {@link #getMv() Mv matrix} has been modified since its last update.
+     * </p>
+     * @see #update()
+     */
+    public final Matrix4f getPMvi() {
+        if( 0 != ( dirtyBits & PREMUL_PMVI ) ) {
+            if( null == matPMvi ) {
+                matPMvi = new Matrix4f();
+            }
+            final Matrix4f mPMv = getPMv();
+            matPMviOK = matPMvi.invert(mPMv);
+            dirtyBits &= ~PREMUL_PMVI;
+        }
+        return matPMviOK ? matPMvi : null;
+    }
+
+    /**
+     * Returns the frustum, derived from projection x modelview.
+     * <p>
+     * This {@link Frustum} instance should be re-fetched via this method and not locally stored
+     * to have it updated from a potential modification of underlying projection and/or modelview matrix.
+     * {@link #update()} has no effect on this {@link Frustum}.
+     * </p>
+     * <p>
+     * The {@link Frustum} is considered dirty, if its corresponding
+     * {@link #getP() P matrix} or {@link #getMv() Mv matrix} has been modified since its last update.
+     * </p>
+     * @see #update()
+     */
+    public final Frustum getFrustum() {
+        if( 0 != ( dirtyBits & FRUSTUM ) ) {
+            if( null == frustum ) {
+                frustum = new Frustum();
+            }
+            final Matrix4f mPMv = getPMv();
+            frustum.updateFrustumPlanes(mPMv);
+            dirtyBits &= ~FRUSTUM;
+        }
+        return frustum;
+    }
+
+    /**
+     * Update the derived {@link #getMvi() inverse modelview (Mvi)},
+     * {@link #getMvit() inverse transposed modelview (Mvit)} matrices
+     * <b>if</b> they {@link #isReqDirty() are dirty} <b>and</b>
+     * requested via the constructor {@link #PMVMatrix4f(int)}.<br/>
+     * Hence updates the following dirty bits.
+     * - {@link #INVERSE_MODELVIEW}
+     * - {@link #INVERSE_TRANSPOSED_MODELVIEW}
+     * <p>
+     * The {@link Frustum} is updated only via {@link #getFrustum()} separately.
+     * </p>
+     * <p>
+     * The Mvi and Mvit matrices are considered dirty, if their corresponding
+     * {@link #getMv() Mv matrix} has been modified since their last update.
+     * </p>
+     * <p>
+     * Method is automatically called by {@link SyncMatrix4f} and {@link SyncMatrices4f}
+     * instances {@link SyncAction} as retrieved by e.g. {@link #getSyncMvit()}.
+     * This ensures an automatic update cycle if used with {@link com.jogamp.opengl.GLUniformData}.
+     * </p>
+     * <p>
+     * Method may be called manually in case mutable operations has been called
+     * and caller operates on already fetched references, i.e. not calling
+     * {@link #getMvi()}, {@link #getMvit()} anymore.
+     * </p>
+     * <p>
+     * Method clears the modified bits like {@link #getModifiedBits(boolean) getModifiedBits(true)},
+     * which are set by any mutable operation. The modified bits have no impact
+     * on this method, but the return value.
+     * </p>
+     *
+     * @return true if any matrix has been modified since last update call or
+     *         if the derived matrices Mvi and Mvit were updated, otherwise false.
+     *         In other words, method returns true if any matrix used by the caller must be updated,
+     *         e.g. uniforms in a shader program.
+     *
+     * @see #getModifiedBits(boolean)
+     * @see #isReqDirty()
+     * @see #INVERSE_MODELVIEW
+     * @see #INVERSE_TRANSPOSED_MODELVIEW
+     * @see #PMVMatrix4f(int)
+     * @see #getMvi()
+     * @see #getMvit()
+     * @see #getSyncPMvMvi()
+     * @see #getSyncPMvMviMvit()
+     */
+    public final boolean update() {
+        return updateImpl(true);
+    }
+
+    //
+    // private
+    //
+
+    private final boolean updateImpl(final boolean clearModBits) {
+        boolean mod = 0 != modifiedBits;
+        if( clearModBits ) {
+            modifiedBits = 0;
+        }
+        if( 0 != ( requestBits & ( ( dirtyBits & ( INVERSE_MODELVIEW | INVERSE_TRANSPOSED_MODELVIEW ) ) ) ) ) { // only if dirt requested & dirty
+            if( !matMvi.invert(matMv) ) {
+                throw new RuntimeException("Invalid source Mv matrix, can't compute inverse");
+            }
+            dirtyBits &= ~INVERSE_MODELVIEW;
+            mod = true;
+        }
+        if( 0 != ( requestBits & ( dirtyBits & INVERSE_TRANSPOSED_MODELVIEW ) ) ) { // only if requested & dirty
+            matMvit.transpose(matMvi);
+            dirtyBits &= ~INVERSE_TRANSPOSED_MODELVIEW;
+            mod = true;
+        }
+        return mod;
+    }
+
+    protected final Matrix4f matP;
+    protected final Matrix4f matMv;
+    protected final Matrix4f matTex;
+
+    private final Matrix4f matMvi;
+    private final Matrix4f matMvit;
+
+    private static final int mP_offset      = 0*16;
+    private static final int mMv_offset     = 1*16;
+    private final int mMvi_offset;
+    private final int mMvit_offset;
+    private final int mTex_offset;
+
+    private final float[] matrixStore;
+
+    private final SyncMatrix4f syncP, syncMv, syncT;
+    private final SyncMatrix4f syncMvi, syncMvit;
+    private final SyncMatrices4f syncP_Mv, syncP_Mv_Mvi, syncP_Mv_Mvi_Mvit;
+
+    protected final Matrix4f mat4Tmp1;
+    private Matrix4f mat4Tmp2;
+
+    private int modifiedBits = MODIFIED_ALL;
+    private int dirtyBits = 0; // contains the dirty bits, i.e. hinting for update operation
+    private final int requestBits; // may contain the requested bits: INVERSE_MODELVIEW | INVERSE_TRANSPOSED_MODELVIEW
+    private Matrix4f matPMv;
+    private Matrix4f matPMvi;
+    private boolean matPMviOK;
+    private Frustum frustum;
+
+    private abstract class PMVSyncBuffer implements SyncMatrix4f {
+        protected final Matrix4f mat;
+        private final FloatBuffer fbuf;
+
+        public PMVSyncBuffer(final Matrix4f m, final FloatBuffer fbuf) {
+            this.mat = m;
+            this.fbuf = fbuf;
+        }
+
+        @Override
+        public final Buffer getBuffer() { return fbuf; }
+
+        @Override
+        public final SyncBuffer sync() { getAction().sync(); return this; }
+
+        @Override
+        public final Buffer getSyncBuffer() { getAction().sync(); return fbuf; }
+
+        @Override
+        public final Matrix4f getMatrix() { return mat; }
+
+        @Override
+        public final FloatBuffer getSyncFloats() { getAction().sync(); return fbuf; }
+    }
+    private final class SyncBuffer0 extends PMVSyncBuffer {
+        private final SyncAction action = new SyncAction() {
+            @Override
+            public void sync() { mat.get(matrixStore); }
+        };
+
+        public SyncBuffer0(final Matrix4f m, final FloatBuffer fbuf) { super(m, fbuf); }
+
+        @Override
+        public SyncAction getAction() { return action; }
+
+    }
+    private final class SyncBuffer1 extends PMVSyncBuffer {
+        private final int offset;
+        private final SyncAction action = new SyncAction() {
+            @Override
+            public void sync() { mat.get(matrixStore, offset); }
+        };
+
+        public SyncBuffer1(final Matrix4f m, final FloatBuffer fbuf, final int offset) {
+            super(m, fbuf);
+            this.offset = offset;
+        }
+
+        @Override
+        public SyncAction getAction() { return action; }
+    }
+    private final class SyncBuffer1U extends PMVSyncBuffer {
+        private final int offset;
+        private final SyncAction action = new SyncAction() {
+            @Override
+            public void sync() {
+                updateImpl(true);
+                mat.get(matrixStore, offset);
+            }
+        };
+
+        public SyncBuffer1U(final Matrix4f m, final FloatBuffer fbuf, final int offset) {
+            super(m, fbuf);
+            this.offset = offset;
+        }
+
+        @Override
+        public SyncAction getAction() { return action; }
+    }
+
+    private abstract class PMVSyncBufferN implements SyncMatrices4f {
+        protected final Matrix4f[] mats;
+        private final FloatBuffer fbuf;
+
+        public PMVSyncBufferN(final Matrix4f[] ms, final FloatBuffer fbuf) {
+            this.mats = ms;
+            this.fbuf = fbuf;
+        }
+
+        @Override
+        public final Buffer getBuffer() { return fbuf; }
+
+        @Override
+        public final SyncBuffer sync() { getAction().sync(); return this; }
+
+        @Override
+        public final Buffer getSyncBuffer() { getAction().sync(); return fbuf; }
+
+        @Override
+        public Matrix4f[] getMatrices() { return mats; }
+
+        @Override
+        public final FloatBuffer getSyncFloats() { getAction().sync(); return fbuf; }
+    }
+    private final class SyncBufferN extends PMVSyncBufferN {
+        private final int offset;
+        private final SyncAction action = new SyncAction() {
+            @Override
+            public void sync() {
+                int ioff = offset;
+                for(int i=0; i<mats.length; ++i, ioff+=16) {
+                    mats[i].get(matrixStore, ioff);
+                }
+            }
+        };
+
+        public SyncBufferN(final Matrix4f[] ms, final FloatBuffer fbuf, final int offset) {
+            super(ms, fbuf);
+            this.offset = offset;
+        }
+
+        @Override
+        public SyncAction getAction() { return action; }
+    }
+    private final class SyncBufferNU extends PMVSyncBufferN {
+        private final int offset;
+        private final SyncAction action = new SyncAction() {
+            @Override
+            public void sync() {
+                updateImpl(true);
+                int ioff = offset;
+                for(int i=0; i<mats.length; ++i, ioff+=16) {
+                    mats[i].get(matrixStore, ioff);
+                }
+            }
+        };
+
+        public SyncBufferNU(final Matrix4f[] ms, final FloatBuffer fbuf, final int offset) {
+            super(ms, fbuf);
+            this.offset = offset;
+        }
+
+        @Override
+        public SyncAction getAction() { return action; }
+    }
+}
+\ No newline at end of file
diff --git a/src/jogl/classes/com/jogamp/opengl/util/SyncAction.java b/src/jogl/classes/com/jogamp/math/util/SyncAction.java
index fbf55e683..08be2d2ac 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/SyncAction.java
+++ b/src/jogl/classes/com/jogamp/math/util/SyncAction.java
@@ -25,7 +25,7 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.util;
+package com.jogamp.math.util;
 
 /**
  * Specific data synchronization action implemented by the data provider
diff --git a/src/jogl/classes/com/jogamp/opengl/util/SyncBuffer.java b/src/jogl/classes/com/jogamp/math/util/SyncBuffer.java
index 27bdb5dfb..368a69b14 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/SyncBuffer.java
+++ b/src/jogl/classes/com/jogamp/math/util/SyncBuffer.java
@@ -25,7 +25,7 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.util;
+package com.jogamp.math.util;
 
 import java.nio.Buffer;
 
diff --git a/src/jogl/classes/com/jogamp/opengl/util/SyncMatrices4f.java b/src/jogl/classes/com/jogamp/math/util/SyncMatrices4f.java
index 055345d65..cc2ae36b6 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/SyncMatrices4f.java
+++ b/src/jogl/classes/com/jogamp/math/util/SyncMatrices4f.java
@@ -25,13 +25,13 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.util;
+package com.jogamp.math.util;
 
 import java.nio.FloatBuffer;
 
-import com.jogamp.opengl.math.Matrix4f;
+import com.jogamp.math.Matrix4f;
 
-/** {@link SyncBuffer} with a multiple underlying {@link Matrix4f}, used in {@link SyncMatrices4f16} and {@link PMVMatrix} */
+/** {@link SyncBuffer} with a multiple underlying {@link Matrix4f}, used in {@link SyncMatrices4f16} and {@link com.jogamp.math.util.PMVMatrix4f PMVMatrix4f} */
 public interface SyncMatrices4f extends SyncBuffer {
     /** Return the underlying multiple {@link Matrix4f}, used to {@link SyncAction#sync() synchronize} to the {@link #getBuffer()}. */
     Matrix4f[] getMatrices();
diff --git a/src/jogl/classes/com/jogamp/opengl/util/SyncMatrices4f16.java b/src/jogl/classes/com/jogamp/math/util/SyncMatrices4f16.java
index bca827b9f..6faba38ee 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/SyncMatrices4f16.java
+++ b/src/jogl/classes/com/jogamp/math/util/SyncMatrices4f16.java
@@ -25,12 +25,12 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.util;
+package com.jogamp.math.util;
 
 import java.nio.Buffer;
 import java.nio.FloatBuffer;
 
-import com.jogamp.opengl.math.Matrix4f;
+import com.jogamp.math.Matrix4f;
 
 /** {@link SyncBuffer} {@link SyncMatrices4f16} implementation for multiple underlying {@link Matrix4f} instances using one {@code float[16*n]} backing array. */
 public final class SyncMatrices4f16 implements SyncMatrices4f {
diff --git a/src/jogl/classes/com/jogamp/opengl/util/SyncMatrix4f.java b/src/jogl/classes/com/jogamp/math/util/SyncMatrix4f.java
index 6ab473771..9ca6857c5 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/SyncMatrix4f.java
+++ b/src/jogl/classes/com/jogamp/math/util/SyncMatrix4f.java
@@ -25,13 +25,13 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.util;
+package com.jogamp.math.util;
 
 import java.nio.FloatBuffer;
 
-import com.jogamp.opengl.math.Matrix4f;
+import com.jogamp.math.Matrix4f;
 
-/** {@link SyncBuffer} interface with a single underlying {@link Matrix4f}, used in {@link SyncMatrix4f16} and {@link PMVMatrix}. */
+/** {@link SyncBuffer} interface with a single underlying {@link Matrix4f}, used in {@link SyncMatrix4f16} and {@link com.jogamp.math.util.PMVMatrix4f PMVMatrix4f}. */
 public interface SyncMatrix4f extends SyncBuffer {
     /** Return the underlying {@link Matrix4f}, used to {@link SyncAction#sync() synchronize} to the {@link #getBuffer()}. */
     Matrix4f getMatrix();
diff --git a/src/jogl/classes/com/jogamp/opengl/util/SyncMatrix4f16.java b/src/jogl/classes/com/jogamp/math/util/SyncMatrix4f16.java
index 03a4b64fa..e6b7e8742 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/SyncMatrix4f16.java
+++ b/src/jogl/classes/com/jogamp/math/util/SyncMatrix4f16.java
@@ -25,12 +25,12 @@
  * authors and should not be interpreted as representing official policies, either expressed
  * or implied, of JogAmp Community.
  */
-package com.jogamp.opengl.util;
+package com.jogamp.math.util;
 
 import java.nio.Buffer;
 import java.nio.FloatBuffer;
 
-import com.jogamp.opengl.math.Matrix4f;
+import com.jogamp.math.Matrix4f;
 
 /** {@link SyncBuffer} {@link SyncMatrix4f} implementation for a single underlying {@link Matrix4f} using one {@code float[16]} backing array. */
 public final class SyncMatrix4f16 implements SyncMatrix4f {
diff --git a/src/jogl/classes/com/jogamp/opengl/GLUniformData.java b/src/jogl/classes/com/jogamp/opengl/GLUniformData.java
index c4cc3fe8f..63eb2658d 100644
--- a/src/jogl/classes/com/jogamp/opengl/GLUniformData.java
+++ b/src/jogl/classes/com/jogamp/opengl/GLUniformData.java
@@ -32,9 +32,9 @@ import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 
 import com.jogamp.common.nio.Buffers;
-import com.jogamp.opengl.math.FloatUtil;
-import com.jogamp.opengl.util.SyncAction;
-import com.jogamp.opengl.util.SyncBuffer;
+import com.jogamp.math.FloatUtil;
+import com.jogamp.math.util.SyncAction;
+import com.jogamp.math.util.SyncBuffer;
 
 /**
  * GLSL uniform data wrapper encapsulating data to be uploaded to the GPU as a uniform.
diff --git a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
index ebb164912..3350b30a7 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
@@ -27,38 +27,27 @@
  */
 package com.jogamp.opengl.util;
 
-import java.nio.Buffer;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 
 import com.jogamp.opengl.GL;
 import com.jogamp.opengl.GLException;
 import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
-import com.jogamp.opengl.GLUniformData;
 
-import com.jogamp.common.nio.Buffers;
-import com.jogamp.opengl.math.FloatUtil;
-import com.jogamp.opengl.math.Matrix4f;
-import com.jogamp.opengl.math.Quaternion;
-import com.jogamp.opengl.math.Ray;
-import com.jogamp.opengl.math.Recti;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.math.Vec4f;
-import com.jogamp.opengl.math.geom.AABBox;
-import com.jogamp.opengl.math.geom.Frustum;
+import com.jogamp.math.FloatUtil;
+import com.jogamp.math.Matrix4f;
+import com.jogamp.math.Quaternion;
+import com.jogamp.math.Recti;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.geom.Frustum;
+import com.jogamp.math.util.PMVMatrix4f;
 
 /**
- * PMVMatrix implements a subset of the fixed function pipeline
- * regarding the projection (P), modelview (Mv) and texture (T) matrix operations,
- * which is specified in {@link GLMatrixFunc}.
+ * PMVMatrix implements a subset of the fixed function pipeline {@link GLMatrixFunc}
+ * using {@link PMVMatrix4f}.
  * <p>
- * This is the second implementation of `PMVMatrix` using
- * direct {@link Matrix4f}, {@link Vec4f} and {@link Vec3f} math operations instead of `float[]`
- * via {@link com.jogamp.opengl.math.FloatUtil FloatUtil}.
- * </p>
- * <p>
- * PMVMatrix provides the {@link #getMviMat() inverse modelview matrix (Mvi)} and
- * {@link #getMvitMat() inverse transposed modelview matrix (Mvit)}.
+ * PMVMatrix provides the {@link #getMvi() inverse modelview matrix (Mvi)} and
+ * {@link #getMvit() inverse transposed modelview matrix (Mvit)}.
  * {@link Frustum} is also provided by {@link #getFrustum()}.
  *
  * To keep these derived values synchronized after mutable Mv operations like {@link #glRotatef(float, float, float, float) glRotatef(..)}
@@ -66,68 +55,11 @@ import com.jogamp.opengl.math.geom.Frustum;
  * users have to call {@link #update()} before using Mvi and Mvit.
  * </p>
  * <p>
- * All matrices are provided in column-major order,
- * as specified in the OpenGL fixed function pipeline, i.e. compatibility profile.
- * See {@link Matrix4f}.
- * </p>
- * <p>
- * PMVMatrix can supplement {@link GL2ES2} applications w/ the
+ * PMVMatrix can supplement {@link com.jogamp.opengl.GL2ES2 GL2ES2} applications w/ the
  * lack of the described matrix functionality.
  * </p>
- * <a name="storageDetails"><h5>Matrix storage details</h5></a>
- * <p>
- * The {@link SyncBuffer} abstraction is provided, e.g. {@link #getSyncPMvMviMat()},
- * to synchronize the respective {@link Matrix4f matrices} with the `float[]` backing store.
- * The latter is represents the data to {@link GLUniformData} via its {@link FloatBuffer}s, see {@link SyncBuffer#getBuffer()},
- * and is pushed to the GPU eventually.
- *
- * {@link SyncBuffer}'s {@link SyncAction} is called by {@link GLUniformData#getBuffer()},
- * i.e. before the data is pushed to the GPU.
- *
- * The provided {@link SyncAction} ensures that the {@link Matrix4f matrices data}
- * gets copied into the `float[]` backing store.
- *
- * PMVMatrix provides two specializations of {@link SyncBuffer}, {@link SyncMatrix4f} for single {@link Matrix4f} mappings
- * and {@link SyncMatrices4f} for multiple {@link Matrix4f} mappings.
- *
- * They can be feed directly to instantiate a {@link GLUniformData} object via e.g. {@link GLUniformData#GLUniformData(String, int, int, SyncBuffer)}.
- * </p>
- * <p>
- * All matrices are backed up by a common primitive float-array for performance considerations
- * and are a {@link Buffers#slice2Float(float[], int, int) sliced} representation of it.
- * </p>
- * <p>
- * <b>Note:</b>
- * <ul>
- *   <li>The matrix is a {@link Buffers#slice2Float(float[], int, int) sliced part } of a host matrix and it's start position has been {@link FloatBuffer#mark() marked}.</li>
- *   <li>Use {@link FloatBuffer#reset() reset()} to rewind it to it's start position after relative operations, like {@link FloatBuffer#get() get()}.</li>
- *   <li>If using absolute operations like {@link FloatBuffer#get(int) get(int)}, use it's {@link FloatBuffer#reset() reset} {@link FloatBuffer#position() position} as it's offset.</li>
- * </ul>
- * </p>
  */
-public final class PMVMatrix implements GLMatrixFunc {
-
-    /** Bit value stating a modified {@link #getPMat() projection matrix (P)}, since last {@link #update()} call. */
-    public static final int MODIFIED_PROJECTION                 = 1 << 0;
-    /** Bit value stating a modified {@link #getMvMat() modelview matrix (Mv)}, since last {@link #update()} call. */
-    public static final int MODIFIED_MODELVIEW                  = 1 << 1;
-    /** Bit value stating a modified {@link #getTMat() texture matrix (T)}, since last {@link #update()} call. */
-    public static final int MODIFIED_TEXTURE                    = 1 << 2;
-    /** Bit value stating all is modified */
-    public static final int MODIFIED_ALL                        = MODIFIED_PROJECTION | MODIFIED_MODELVIEW | MODIFIED_TEXTURE ;
-
-    /** Bit value for {@link #getMviMat() inverse modelview matrix (Mvi)}, updated via {@link #update()}. */
-    public static final int INVERSE_MODELVIEW             = 1 << 1;
-    /** Bit value for {@link #getMvitMat() inverse transposed modelview matrix (Mvit)}, updated via {@link #update()}. */
-    public static final int INVERSE_TRANSPOSED_MODELVIEW  = 1 << 2;
-    /** Bit value for {@link #getFrustum() frustum} and updated by {@link #getFrustum()}. */
-    public static final int FRUSTUM                       = 1 << 3;
-    /** Bit value for {@link #getPMvMat() pre-multiplied P * Mv}, updated by {@link #getPMvMat()}. */
-    public static final int PREMUL_PMV                   = 1 << 4;
-    /** Bit value for {@link #getPMviMat() pre-multiplied invert(P * Mv)}, updated by {@link #getPMviMat()}. */
-    public static final int PREMUL_PMVI                  = 1 << 5;
-    /** Manual bits not covered by {@link #update()} but {@link #getFrustum()}, {@link #FRUSTUM}, {@link #getPMvMat()}, {@link #PREMUL_PMV}, {@link #getPMviMat()}, {@link #PREMUL_PMVI}, etc. */
-    public static final int MANUAL_BITS                   = FRUSTUM | PREMUL_PMV | PREMUL_PMVI;
+public final class PMVMatrix extends PMVMatrix4f implements GLMatrixFunc {
 
     /**
      * @param matrixModeName One of {@link GLMatrixFunc#GL_MODELVIEW GL_MODELVIEW}, {@link GLMatrixFunc#GL_PROJECTION GL_PROJECTION} or {@link GL#GL_TEXTURE GL_TEXTURE}
@@ -227,297 +159,29 @@ public final class PMVMatrix implements GLMatrixFunc {
      * @see #update()
      */
     public PMVMatrix(final int derivedMatrices) {
-        // I    Identity
-        // T    Texture
-        // P    Projection
-        // Mv   ModelView
-        // Mvi  Modelview-Inverse
-        // Mvit Modelview-Inverse-Transpose
-        {
-            int mask = 0;
-            if( 0 != ( derivedMatrices & ( INVERSE_MODELVIEW | INVERSE_TRANSPOSED_MODELVIEW ) ) ) {
-                mask |= INVERSE_MODELVIEW;
-            }
-            if( 0 != ( derivedMatrices & INVERSE_TRANSPOSED_MODELVIEW ) ) {
-                mask |= INVERSE_TRANSPOSED_MODELVIEW;
-            }
-            requestBits = mask;
-        }
-
-        // actual underlying Matrix4f count
-        int mcount     = 3;
-
-        // actual underlying Matrix4f data
-        matP           = new Matrix4f();
-        matMv          = new Matrix4f();
-        matTex         = new Matrix4f();
-
-        if( 0 != ( requestBits & INVERSE_MODELVIEW ) ) {
-            matMvi         = new Matrix4f();
-            mMvi_offset    = 2*16;
-            ++mcount;
-        } else {
-            matMvi         = null;
-            mMvi_offset    = -1;
-        }
-        if( 0 != ( requestBits & INVERSE_TRANSPOSED_MODELVIEW ) ) {
-            matMvit        = new Matrix4f();
-            mMvit_offset   = 3*16;
-            ++mcount;
-        } else {
-            matMvit        = null;
-            mMvit_offset   = -1;
-        }
-        mTex_offset        = (mcount-1)*16; // last one
-
-        // float back buffer for GPU, Matrix4f -> matrixStore via SyncedBuffer
-        matrixStore    = new float[mcount*16];
-
-        // FloatBuffer for single Matrix4f back-buffer
-        bufP        = Buffers.slice2Float(matrixStore,  mP_offset,    1*16);  // P
-        syncP       = new SyncBuffer0(matP,    bufP);   // mP_offset
-
-        bufMv       = Buffers.slice2Float(matrixStore,  mMv_offset,   1*16);  // Mv
-        syncMv      = new SyncBuffer1(matMv,   bufMv,   mMv_offset);
-
-        bufP_Mv     = Buffers.slice2Float(matrixStore,  mP_offset,    2*16);  // P + Mv
-        syncP_Mv    = new SyncBufferN(new Matrix4f[]  { matP, matMv }, bufP_Mv, mP_offset);
-
-        bufTex      = Buffers.slice2Float(matrixStore,  mTex_offset,  1*16);  // T
-        syncT       = new SyncBuffer1(matTex,  bufTex,  mTex_offset);
-
-        if( null != matMvi ) {
-            bufMvi       = Buffers.slice2Float(matrixStore,  mMvi_offset,  1*16);  // Mvi
-            bufP_Mv_Mvi  = Buffers.slice2Float(matrixStore,  mP_offset,    3*16);  // P + Mv + Mvi
-            syncMvi      = new SyncBuffer1U(matMvi,  bufMvi,  mMvi_offset);
-            syncP_Mv_Mvi = new SyncBufferNU(new Matrix4f[] { matP, matMv, matMvi }, bufP_Mv_Mvi, mP_offset);
-        } else {
-            bufMvi  = null;
-            bufP_Mv_Mvi = null;
-            syncMvi     = null;
-            syncP_Mv_Mvi = null;
-        }
-        if( null != matMvit ) {
-            bufMvit           = Buffers.slice2Float(matrixStore,  mMvit_offset, 1*16);  //          Mvit
-            bufP_Mv_Mvi_Mvit  = Buffers.slice2Float(matrixStore,  mP_offset,    4*16);  // P + Mv + Mvi + Mvit
-            syncMvit          = new SyncBuffer1U(matMvit, bufMvit, mMvit_offset);
-            syncP_Mv_Mvi_Mvit = new SyncBufferNU(new Matrix4f[] { matP, matMv, matMvi, matMvit }, bufP_Mv_Mvi_Mvit, mP_offset);
-        } else {
-            bufMvit = null;
-            bufP_Mv_Mvi_Mvit = null;
-            syncMvit = null;
-            syncP_Mv_Mvi_Mvit = null;
-        }
-
-        mat4Tmp1       = new Matrix4f();
-
-        mat4Tmp2 = null; // on demand
-        matPMv = null; // on demand
-        matPMvi = null; // on demand
-        matPMviOK = false;
-        frustum = null; // on demand
-
-        reset();
-    }
-
-    /**
-     * Issues {@link #glLoadIdentity()} on all matrices,
-     * i.e. {@link GLMatrixFunc#GL_MODELVIEW GL_MODELVIEW}, {@link GLMatrixFunc#GL_PROJECTION GL_PROJECTION} or {@link GL#GL_TEXTURE GL_TEXTURE}
-     * and resets all internal states.
-     *
-     * Leaves {@link GLMatrixFunc#GL_MODELVIEW GL_MODELVIEW} the active matrix mode.
-     */
-    public final void reset() {
-        matP.loadIdentity();
-        matMv.loadIdentity();
-        matTex.loadIdentity();
-
-        modifiedBits = MODIFIED_ALL;
-        dirtyBits = requestBits | MANUAL_BITS;
-        matrixMode = GL_MODELVIEW;
-    }
-
-    /** Returns the current matrix-mode, one of {@link GLMatrixFunc#GL_MODELVIEW GL_MODELVIEW}, {@link GLMatrixFunc#GL_PROJECTION GL_PROJECTION} or {@link GL#GL_TEXTURE GL_TEXTURE}. */
-    public final int  glGetMatrixMode() {
-        return matrixMode;
+        super(derivedMatrices);
     }
 
-    //
-    // Temporary storage access for efficiency
-    //
 
     /**
-     * Return the second temporary Matrix4f exposed to be reused for efficiency.
+     * {@inheritDoc}
      * <p>
-     * Temporary storage is only used by this class within single method calls,
-     * hence has no side-effects.
+     * Leaves {@link GLMatrixFunc#GL_MODELVIEW GL_MODELVIEW} the active matrix mode.
      * </p>
      */
-    private final Matrix4f getTmp2Mat() {
-        if( null == mat4Tmp2 ) {
-            mat4Tmp2 = new Matrix4f();
-        }
-        return mat4Tmp2;
+    @Override
+    public void reset() {
+        super.reset();
+        matrixMode = GL_MODELVIEW;
     }
 
     //
-    // Regular Matrix4f access as well as their SyncedBuffer counterpart SyncedMatrix and SyncedMatrices
+    // GLMatrixFunc implementation
     //
 
-    /**
-     * Returns the {@link GLMatrixFunc#GL_TEXTURE_MATRIX texture matrix} (T).
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     */
-    public final Matrix4f getTMat() {
-        return matTex;
-    }
-
-    /**
-     * Returns the {@link SyncMatrix} of {@link GLMatrixFunc#GL_TEXTURE_MATRIX texture matrix} (T).
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     */
-    public final SyncMatrix4f getSyncTMat() {
-        return syncT;
-    }
-
-    /**
-     * Returns the {@link GLMatrixFunc#GL_PROJECTION_MATRIX projection matrix} (P).
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     */
-    public final Matrix4f getPMat() {
-        return matP;
-    }
-
-    /**
-     * Returns the {@link SyncMatrix} of {@link GLMatrixFunc#GL_PROJECTION_MATRIX projection matrix} (P).
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     */
-    public final SyncMatrix4f getSyncPMat() {
-        return syncP;
-    }
-
-    /**
-     * Returns the {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mv).
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     */
-    public final Matrix4f getMvMat() {
-        return matMv;
-    }
-
-    /**
-     * Returns the {@link SyncMatrix} of {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mv).
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     */
-    public final SyncMatrix4f getSyncMvMat() {
-        return syncMv;
-    }
-
-    /**
-     * Returns {@link SyncMatrices4f} of 2 matrices within one FloatBuffer: {@link #getPMat() P} and {@link #getMvMat() Mv}.
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     */
-    public final SyncMatrices4f getSyncPMvMat() {
-        return syncP_Mv;
-    }
-
-    /**
-     * Returns the inverse {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mvi) if requested.
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     * @throws IllegalArgumentException if {@link #INVERSE_MODELVIEW} has not been requested in ctor {@link #PMVMatrix(int)}.
-     */
-    public final Matrix4f getMviMat() {
-        if( 0 == ( INVERSE_MODELVIEW & requestBits ) ) {
-            throw new IllegalArgumentException("Not requested in ctor");
-        }
-        updateImpl(false);
-        return matMvi;
-    }
-
-    /**
-     * Returns the {@link SyncMatrix} of inverse {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mvi) if requested.
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     * @throws IllegalArgumentException if {@link #INVERSE_MODELVIEW} has not been requested in ctor {@link #PMVMatrix(int)}.
-     */
-    public final SyncMatrix4f getSyncMviMat() {
-        if( 0 == ( INVERSE_MODELVIEW & requestBits ) ) {
-            throw new IllegalArgumentException("Not requested in ctor");
-        }
-        return syncMvi;
-    }
-
-    /**
-     * Returns the inverse transposed {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mvit) if requested.
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     * @throws IllegalArgumentException if {@link #INVERSE_TRANSPOSED_MODELVIEW} has not been requested in ctor {@link #PMVMatrix(int)}.
-     */
-    public final Matrix4f getMvitMat() {
-        if( 0 == ( INVERSE_TRANSPOSED_MODELVIEW & requestBits ) ) {
-            throw new IllegalArgumentException("Not requested in ctor");
-        }
-        updateImpl(false);
-        return matMvit;
-    }
-
-    /**
-     * Returns the {@link SyncMatrix} of inverse transposed {@link GLMatrixFunc#GL_MODELVIEW_MATRIX modelview matrix} (Mvit) if requested.
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     * @throws IllegalArgumentException if {@link #INVERSE_TRANSPOSED_MODELVIEW} has not been requested in ctor {@link #PMVMatrix(int)}.
-     */
-    public final SyncMatrix4f getSyncMvitMat() {
-        if( 0 == ( INVERSE_TRANSPOSED_MODELVIEW & requestBits ) ) {
-            throw new IllegalArgumentException("Not requested in ctor");
-        }
-        return syncMvit;
-    }
-
-    /**
-     * Returns {@link SyncMatrices4f} of 3 matrices within one FloatBuffer: {@link #getPMat() P}, {@link #getMvMat() Mv} and {@link #getMviMat() Mvi} if requested.
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     * @throws IllegalArgumentException if {@link #INVERSE_MODELVIEW} has not been requested in ctor {@link #PMVMatrix(int)}.
-     */
-    public final SyncMatrices4f getSyncPMvMviMat() {
-        if( 0 == ( INVERSE_MODELVIEW & requestBits ) ) {
-            throw new IllegalArgumentException("Not requested in ctor");
-        }
-        return syncP_Mv_Mvi;
-    }
-
-    /**
-     * Returns {@link SyncMatrices4f} of 4 matrices within one FloatBuffer: {@link #getPMat() P}, {@link #getMvMat() Mv}, {@link #getMviMat() Mvi} and {@link #getMvitMat() Mvit} if requested.
-     * <p>
-     * See <a href="#storageDetails"> matrix storage details</a>.
-     * </p>
-     * @throws IllegalArgumentException if {@link #INVERSE_TRANSPOSED_MODELVIEW} has not been requested in ctor {@link #PMVMatrix(int)}.
-     */
-    public final SyncMatrices4f getSyncPMvMviMvitMat() {
-        if( 0 == ( INVERSE_TRANSPOSED_MODELVIEW & requestBits ) ) {
-            throw new IllegalArgumentException("Not requested in ctor");
-        }
-        return syncP_Mv_Mvi_Mvit;
+    /** Returns the current matrix-mode, one of {@link GLMatrixFunc#GL_MODELVIEW GL_MODELVIEW}, {@link GLMatrixFunc#GL_PROJECTION GL_PROJECTION} or {@link GL#GL_TEXTURE GL_TEXTURE}. */
+    public final int glGetMatrixMode() {
+        return matrixMode;
     }
 
     /**
@@ -550,172 +214,6 @@ public final class PMVMatrix implements GLMatrixFunc {
         }
     }
 
-    //
-    // Basic Matrix4f, Vec3f and Vec4f operations similar to GLMatrixFunc
-    //
-
-    /**
-     * Multiplies the {@link #getPMat() P} and {@link #getMvMat() Mv} matrix, i.e.
-     * <pre>
-     *    result = P x Mv
-     * </pre>
-     * @param result 4x4 matrix storage for result
-     * @return given result matrix for chaining
-     */
-    public final Matrix4f mulPMvMat(final Matrix4f result) {
-        return result.mul(matP, matMv);
-    }
-
-    /**
-     * Multiplies the {@link #getMvMat() Mv} and {@link #getPMat() P} matrix, i.e.
-     * <pre>
-     *    result = Mv x P
-     * </pre>
-     * @param result 4x4 matrix storage for result
-     * @return given result matrix for chaining
-     */
-    public final Matrix4f mulMvPMat(final Matrix4f result) {
-        return result.mul(matMv, matP);
-    }
-
-    /**
-     * v_out = Mv * v_in
-     * @param v_in input vector, can be v_out for in-place transformation
-     * @param v_out output vector
-     * @returns v_out for chaining
-     */
-    public final Vec4f mulMvMatVec4f(final Vec4f v_in, final Vec4f v_out) {
-        return matMv.mulVec4f(v_in, v_out);
-    }
-
-    /**
-     * v_inout = Mv * v_inout
-     * @param v_inout input and output vector, i.e. in-place transformation
-     * @returns v_inout for chaining
-     */
-    public final Vec4f mulMvMatVec4f(final Vec4f v_inout) {
-        return matMv.mulVec4f(v_inout);
-    }
-
-    /**
-     * v_out = Mv * v_in
-     *
-     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
-     *
-     * @param v_in input vector, can be v_out for in-place transformation
-     * @param v_out output vector
-     * @returns v_out for chaining
-     */
-    public final Vec3f mulMvMatVec3f(final Vec3f v_in, final Vec3f v_out) {
-        return matMv.mulVec3f(v_in, v_out);
-    }
-
-    /**
-     * v_inout = Mv * v_inout
-     *
-     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
-     *
-     * @param v_inout input and output vector, i.e. in-place transformation
-     * @returns v_inout for chaining
-     */
-    public final Vec3f mulMvMatVec3f(final Vec3f v_inout) {
-        return matMv.mulVec3f(v_inout);
-    }
-
-    /**
-     * v_out = P * v_in
-     * @param v_in input vector, can be v_out for in-place transformation
-     * @param v_out output vector
-     * @return given result vector for chaining
-     * @returns v_out for chaining
-     */
-    public final Vec4f mulPMatVec4f(final Vec4f v_in, final Vec4f v_out) {
-        return matP.mulVec4f(v_in, v_out);
-    }
-
-    /**
-     * v_inout = P * v_inout
-     * @param v_inout input and output vector, i.e. in-place transformation
-     * @return given result vector for chaining
-     * @returns v_inout for chaining
-     */
-    public final Vec4f mulPMatVec4f(final Vec4f v_inout) {
-        return matP.mulVec4f(v_inout);
-    }
-
-    /**
-     * v_out = P * v_in
-     *
-     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
-     *
-     * @param v_in float[3] input vector, can be v_out for in-place transformation
-     * @param v_out float[3] output vector
-     * @returns v_out for chaining
-     */
-    public final Vec3f mulPMatVec3f(final Vec3f v_in, final Vec3f v_out) {
-        return matP.mulVec3f(v_in, v_out);
-    }
-
-    /**
-     * v_inout = P * v_inout
-     *
-     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
-     *
-     * @param v_inout input and output vector, i.e. in-place transformation
-     * @returns v_inout for chaining
-     */
-    public final Vec3f mulPMatVec3f(final Vec3f v_inout) {
-        return matP.mulVec3f(v_inout);
-    }
-
-    /**
-     * v_out = P * Mv * v_in
-     * @param v_in float[4] input vector, can be v_out for in-place transformation
-     * @param v_out float[4] output vector
-     * @returns v_out for chaining
-     */
-    public final Vec4f mulPMvMatVec4f(final Vec4f v_in, final Vec4f v_out) {
-        return matP.mulVec4f( matMv.mulVec4f( v_in, v_out ) );
-    }
-
-    /**
-     * v_inout = P * Mv * v_inout
-     * @param v_inout input and output vector, i.e. in-place transformation
-     * @returns v_inout for chaining
-     */
-    public final Vec4f mulPMvMatVec4f(final Vec4f v_inout) {
-        return matP.mulVec4f( matMv.mulVec4f( v_inout ) );
-    }
-
-    /**
-     * v_out = P * Mv * v_in
-     *
-     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
-     *
-     * @param v_in float[3] input vector, can be v_out for in-place transformation
-     * @param v_out float[3] output vector
-     * @returns v_out for chaining
-     */
-    public final Vec3f mulPMvMatVec3f(final Vec3f v_in, final Vec3f v_out) {
-        return matP.mulVec3f( matMv.mulVec3f( v_in, v_out ) );
-    }
-
-    /**
-     * v_inout = P * Mv * v_inout
-     *
-     * Affine 3f-vector transformation by 4x4 matrix, see {@link Matrix4f#mulVec3f(Vec3f, Vec3f)}.
-     *
-     * @param v_inout float[3] input and output vector, i.e. in-place transformation
-     * @returns v_inout for chaining
-     */
-    public final Vec3f mulPMvMatVec3f(final Vec3f v_inout) {
-        return matP.mulVec3f( matMv.mulVec3f( v_inout ) );
-    }
-
-    //
-    // GLMatrixFunc implementation
-    //
-
     @Override
     public final void glMatrixMode(final int matrixName) {
         switch(matrixName) {
@@ -772,35 +270,23 @@ public final class PMVMatrix implements GLMatrixFunc {
     @Override
     public final void glLoadMatrixf(final float[] values, final int offset) {
         if(matrixMode==GL_MODELVIEW) {
-            matMv.load(values, offset);
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
+            loadMv(values, offset);
         } else if(matrixMode==GL_PROJECTION) {
-            matP.load(values, offset);
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
+            loadP(values, offset);
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.load(values, offset);
-            modifiedBits |= MODIFIED_TEXTURE;
+            loadT(values, offset);
         }
     }
 
     @Override
     public final void glLoadMatrixf(final java.nio.FloatBuffer m) {
-        final int spos = m.position();
         if(matrixMode==GL_MODELVIEW) {
-            matMv.load(m);
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
+            loadMv(m);
         } else if(matrixMode==GL_PROJECTION) {
-            matP.load(m);
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
+            loadP(m);
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.load(m);
-            modifiedBits |= MODIFIED_TEXTURE;
+            loadT(m);
         }
-        m.position(spos);
     }
 
     /**
@@ -811,16 +297,11 @@ public final class PMVMatrix implements GLMatrixFunc {
      */
     public final void glLoadMatrixf(final Matrix4f m) {
         if(matrixMode==GL_MODELVIEW) {
-            matMv.load(m);
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
+            loadMv(m);
         } else if(matrixMode==GL_PROJECTION) {
-            matP.load(m);
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
+            loadP(m);
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.load(m);
-            modifiedBits |= MODIFIED_TEXTURE;
+            loadT(m);
         }
     }
 
@@ -832,59 +313,22 @@ public final class PMVMatrix implements GLMatrixFunc {
      */
     public final void glLoadMatrix(final Quaternion quat) {
         if(matrixMode==GL_MODELVIEW) {
-            matMv.setToRotation(quat);
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
+            loadMv(quat);
         } else if(matrixMode==GL_PROJECTION) {
-            matP.setToRotation(quat);
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
+            loadP(quat);
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.setToRotation(quat);
-            modifiedBits |= MODIFIED_TEXTURE;
-        }
-    }
-
-    @Override
-    public final void glPopMatrix() {
-        if(matrixMode==GL_MODELVIEW) {
-            matMv.pop();
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
-        } else if(matrixMode==GL_PROJECTION) {
-            matP.pop();
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
-        } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.pop();
-            modifiedBits |= MODIFIED_TEXTURE;
-        }
-    }
-
-    @Override
-    public final void glPushMatrix() {
-        if(matrixMode==GL_MODELVIEW) {
-            matMv.push();
-        } else if(matrixMode==GL_PROJECTION) {
-            matP.push();
-        } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.push();
+            loadT(quat);
         }
     }
 
     @Override
     public final void glLoadIdentity() {
         if(matrixMode==GL_MODELVIEW) {
-            matMv.loadIdentity();
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
+            loadMvIdentity();
         } else if(matrixMode==GL_PROJECTION) {
-            matP.loadIdentity();
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
+            loadPIdentity();
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.loadIdentity();
-            modifiedBits |= MODIFIED_TEXTURE;
+            loadTIdentity();
         }
     }
 
@@ -892,16 +336,11 @@ public final class PMVMatrix implements GLMatrixFunc {
     public final void glMultMatrixf(final FloatBuffer m) {
         final int spos = m.position();
         if(matrixMode==GL_MODELVIEW) {
-            matMv.mul( mat4Tmp1.load( m ) );
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
+            mulMv( mat4Tmp1.load( m ) );
         } else if(matrixMode==GL_PROJECTION) {
-            matP.mul( mat4Tmp1.load( m ) );
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
+            mulP( mat4Tmp1.load( m ) );
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.mul( mat4Tmp1.load( m ) );
-            modifiedBits |= MODIFIED_TEXTURE;
+            mulT( mat4Tmp1.load( m ) );
         }
         m.position(spos);
     }
@@ -909,16 +348,11 @@ public final class PMVMatrix implements GLMatrixFunc {
     @Override
     public final void glMultMatrixf(final float[] m, final int m_offset) {
         if(matrixMode==GL_MODELVIEW) {
-            matMv.mul( mat4Tmp1.load( m, m_offset ) );
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
+            mulMv( mat4Tmp1.load( m, m_offset ) );
         } else if(matrixMode==GL_PROJECTION) {
-            matP.mul( mat4Tmp1.load( m, m_offset ) );
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
+            mulP( mat4Tmp1.load( m, m_offset ) );
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.mul( mat4Tmp1.load( m, m_offset ) );
-            modifiedBits |= MODIFIED_TEXTURE;
+            mulT( mat4Tmp1.load( m, m_offset ) );
         }
     }
 
@@ -932,16 +366,11 @@ public final class PMVMatrix implements GLMatrixFunc {
      */
     public final PMVMatrix glMultMatrixf(final Matrix4f m) {
         if(matrixMode==GL_MODELVIEW) {
-            matMv.mul( m );
-            dirtyBits |= requestBits | MANUAL_BITS ;
-            modifiedBits |= MODIFIED_MODELVIEW;
+            mulMv(m);
         } else if(matrixMode==GL_PROJECTION) {
-            matP.mul( m );
-            dirtyBits |= MANUAL_BITS ;
-            modifiedBits |= MODIFIED_PROJECTION;
+            mulP(m);
         } else if(matrixMode==GL.GL_TEXTURE) {
-            matTex.mul( m );
-            modifiedBits |= MODIFIED_TEXTURE;
+            mulT(m);
         }
         return this;
     }
@@ -1015,6 +444,28 @@ public final class PMVMatrix implements GLMatrixFunc {
     }
 
     @Override
+    public final void glPopMatrix() {
+        if(matrixMode==GL_MODELVIEW) {
+            popMv();
+        } else if(matrixMode==GL_PROJECTION) {
+            popP();
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            popT();
+        }
+    }
+
+    @Override
+    public final void glPushMatrix() {
+        if(matrixMode==GL_MODELVIEW) {
+            pushMv();
+        } else if(matrixMode==GL_PROJECTION) {
+            pushP();
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            pushT();
+        }
+    }
+
+    @Override
     public final void glOrthof(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) {
         glMultMatrixf( mat4Tmp1.setToOrtho(left, right, bottom, top, zNear, zFar) );
     }
@@ -1022,12 +473,12 @@ public final class PMVMatrix implements GLMatrixFunc {
     /**
      * {@inheritDoc}
      *
-     * @throws GLException if {@code zNear <= 0} or {@code zFar <= zNear}
-     *                     or {@code left == right}, or {@code bottom == top}.
+     * @throws IllegalArgumentException if {@code zNear <= 0} or {@code zFar <= zNear}
+     *                                  or {@code left == right}, or {@code bottom == top}.
      * @see Matrix4f#setToFrustum(float, float, float, float, float, float)
      */
     @Override
-    public final void glFrustumf(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) throws GLException {
+    public final void glFrustumf(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) throws IllegalArgumentException {
         glMultMatrixf( mat4Tmp1.setToFrustum(left, right, bottom, top, zNear, zFar) );
     }
 
@@ -1042,111 +493,22 @@ public final class PMVMatrix implements GLMatrixFunc {
      * @param aspect aspect ratio width / height
      * @param zNear
      * @param zFar
-     * @throws GLException if {@code zNear <= 0} or {@code zFar <= zNear}
+     * @throws IllegalArgumentException if {@code zNear <= 0} or {@code zFar <= zNear}
      * @see Matrix4f#setToPerspective(float, float, float, float)
      */
-    public final void gluPerspective(final float fovy_rad, final float aspect, final float zNear, final float zFar) throws GLException {
+    public final void gluPerspective(final float fovy_rad, final float aspect, final float zNear, final float zFar) throws IllegalArgumentException {
          glMultMatrixf( mat4Tmp1.setToPerspective(fovy_rad, aspect, zNear, zFar) );
     }
 
     /**
-     * {@link #glMultMatrixf(FloatBuffer) Multiply} and {@link #glTranslatef(float, float, float) translate} the {@link #glGetMatrixMode() current matrix}
-     * with the eye, object and orientation.
+     * {@link #glMultMatrixf(FloatBuffer) Multiply} the {@link #glGetMatrixMode() current matrix}
+     * with the eye, object and orientation, i.e. {@link Matrix4f#setToLookAt(Vec3f, Vec3f, Vec3f, Matrix4f)}.
      */
     public final void gluLookAt(final Vec3f eye, final Vec3f center, final Vec3f up) {
         glMultMatrixf( mat4Tmp1.setToLookAt(eye, center, up, getTmp2Mat()) );
     }
 
     /**
-     * Map object coordinates to window coordinates.
-     * <p>
-     * Traditional <code>gluProject</code> implementation.
-     * </p>
-     *
-     * @param objPos 3 component object coordinate
-     * @param viewport Rect4i viewport
-     * @param winPos 3 component window coordinate, the result
-     * @return true if successful, otherwise false (z is 1)
-     */
-    public final boolean gluProject(final Vec3f objPos, final Recti viewport, final Vec3f winPos ) {
-        return Matrix4f.mapObjToWin(objPos, matMv, matP, viewport, winPos);
-    }
-
-    /**
-     * Map window coordinates to object coordinates.
-     * <p>
-     * Traditional <code>gluUnProject</code> implementation.
-     * </p>
-     *
-     * @param winx
-     * @param winy
-     * @param winz
-     * @param viewport Rect4i viewport
-     * @param objPos 3 component object coordinate, the result
-     * @return true if successful, otherwise false (failed to invert matrix, or becomes infinity due to zero z)
-     */
-    public final boolean gluUnProject(final float winx, final float winy, final float winz,
-                                      final Recti viewport, final Vec3f objPos) {
-        if( Matrix4f.mapWinToObj(winx, winy, winz, getPMviMat(), viewport, objPos) ) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Map window coordinates to object coordinates.
-     * <p>
-     * Traditional <code>gluUnProject4</code> implementation.
-     * </p>
-     *
-     * @param winx
-     * @param winy
-     * @param winz
-     * @param clipw
-     * @param viewport Rect4i viewport
-     * @param near
-     * @param far
-     * @param objPos 4 component object coordinate, the result
-     * @return true if successful, otherwise false (failed to invert matrix, or becomes infinity due to zero z)
-     */
-    public boolean gluUnProject4(final float winx, final float winy, final float winz, final float clipw,
-                                 final Recti viewport,
-                                 final float near, final float far,
-                                 final Vec4f objPos) {
-        if( Matrix4f.mapWinToObj4(winx, winy, winz, clipw, getPMviMat(), viewport, near, far, objPos) ) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Map two window coordinates w/ shared X/Y and distinctive Z
-     * to a {@link Ray}. The resulting {@link Ray} maybe used for <i>picking</i>
-     * using a {@link AABBox#getRayIntersection(Vec3f, Ray, float, boolean) bounding box}.
-     * <p>
-     * Notes for picking <i>winz0</i> and <i>winz1</i>:
-     * <ul>
-     *   <li>see {@link FloatUtil#getZBufferEpsilon(int, float, float)}</li>
-     *   <li>see {@link FloatUtil#getZBufferValue(int, float, float, float)}</li>
-     *   <li>see {@link FloatUtil#getOrthoWinZ(float, float, float)}</li>
-     * </ul>
-     * </p>
-     * @param winx
-     * @param winy
-     * @param winz0
-     * @param winz1
-     * @param viewport
-     * @param ray storage for the resulting {@link Ray}
-     * @return true if successful, otherwise false (failed to invert matrix, or becomes z is infinity)
-     */
-    public final boolean gluUnProjectRay(final float winx, final float winy, final float winz0, final float winz1,
-                                         final Recti viewport, final Ray ray) {
-        return Matrix4f.mapWinToRay(winx, winy, winz0, winz1, getPMviMat(), viewport, ray);
-    }
-
-    /**
      * Make given matrix the <i>pick</i> matrix based on given parameters.
      * <p>
      * Traditional <code>gluPickMatrix</code> implementation.
@@ -1160,495 +522,15 @@ public final class PMVMatrix implements GLMatrixFunc {
      * @param deltaY the height of the picking region in window coordinates.
      * @param viewport Rect4i viewport vector
      */
-    public final void gluPickMatrix(final float x, final float y,
-                                    final float deltaX, final float deltaY, final Recti viewport) {
+    public final void gluPickMatrix(final float x, final float y, final float deltaX, final float deltaY, final Recti viewport) {
         if( null != mat4Tmp1.setToPick(x, y, deltaX, deltaY, viewport, getTmp2Mat()) ) {
             glMultMatrixf( mat4Tmp1 );
         }
     }
 
-    public StringBuilder toString(StringBuilder sb, final String f) {
-        if(null == sb) {
-            sb = new StringBuilder();
-        }
-        final boolean pmvDirty  = 0 != (PREMUL_PMV & dirtyBits);
-        final boolean pmvUsed = null != matPMv;
-
-        final boolean pmviDirty  = 0 != (PREMUL_PMVI & dirtyBits);
-        final boolean pmviUsed = null != matPMvi;
-
-        final boolean frustumDirty = 0 != (FRUSTUM & dirtyBits);
-        final boolean frustumUsed = null != frustum;
-
-        final boolean mviDirty  = 0 != (INVERSE_MODELVIEW & dirtyBits);
-        final boolean mviReq = 0 != (INVERSE_MODELVIEW & requestBits);
-
-        final boolean mvitDirty = 0 != (INVERSE_TRANSPOSED_MODELVIEW & dirtyBits);
-        final boolean mvitReq = 0 != (INVERSE_TRANSPOSED_MODELVIEW & requestBits);
-
-        final boolean modP = 0 != ( MODIFIED_PROJECTION & modifiedBits );
-        final boolean modMv = 0 != ( MODIFIED_MODELVIEW & modifiedBits );
-        final boolean modT = 0 != ( MODIFIED_TEXTURE & modifiedBits );
-        int count = 3; // P, Mv, T
-
-        sb.append("PMVMatrix[modified[P ").append(modP).append(", Mv ").append(modMv).append(", T ").append(modT);
-        sb.append("], dirty/used[PMv ").append(pmvDirty).append("/").append(pmvUsed).append(", Pmvi ").append(pmviDirty).append("/").append(pmviUsed).append(", Frustum ").append(frustumDirty).append("/").append(frustumUsed);
-        sb.append("], dirty/req[Mvi ").append(mviDirty).append("/").append(mviReq).append(", Mvit ").append(mvitDirty).append("/").append(mvitReq).append("]").append(System.lineSeparator());
-        sb.append(", Projection").append(System.lineSeparator());
-        matP.toString(sb, null, f);
-        sb.append(", Modelview").append(System.lineSeparator());
-        matMv.toString(sb, null, f);
-        sb.append(", Texture").append(System.lineSeparator());
-        matTex.toString(sb, null, f);
-        if( null != matPMv ) {
-            sb.append(", P * Mv").append(System.lineSeparator());
-            matPMv.toString(sb, null, f);
-            ++count;
-        }
-        if( null != matPMvi ) {
-            sb.append(", P * Mv").append(System.lineSeparator());
-            matPMvi.toString(sb, null, f);
-            ++count;
-        }
-        if( mviReq ) {
-            sb.append(", Inverse Modelview").append(System.lineSeparator());
-            matMvi.toString(sb, null, f);
-            ++count;
-        }
-        if( mvitReq ) {
-            sb.append(", Inverse Transposed Modelview").append(System.lineSeparator());
-            matMvit.toString(sb, null, f);
-            ++count;
-        }
-        int tmpCount = 1;
-        if( null != mat4Tmp2 ) {
-            ++tmpCount;
-        }
-        sb.append(", matrices "+count+" + "+tmpCount+" temp = "+(count+tmpCount)+"]");
-        return sb;
-    }
-
-    @Override
-    public String toString() {
-        return toString(null, "%10.5f").toString();
-    }
-
-    /**
-     * Returns the modified bits due to mutable operations..
-     * <p>
-     * A modified bit is set, if the corresponding matrix had been modified by a mutable operation
-     * since last {@link #update()} or {@link #getModifiedBits(boolean) getModifiedBits(true)} call.
-     * </p>
-     * @param clear if true, clears the modified bits, otherwise leaves them untouched.
-     *
-     * @see #MODIFIED_PROJECTION
-     * @see #MODIFIED_MODELVIEW
-     * @see #MODIFIED_TEXTURE
-     * @see #getDirtyBits()
-     * @see #isReqDirty()
-     */
-    public final int getModifiedBits(final boolean clear) {
-        final int r = modifiedBits;
-        if(clear) {
-            modifiedBits = 0;
-        }
-        return r;
-    }
-
-    /**
-     * Returns the dirty bits due to mutable operations,
-     * i.e.
-     * - {@link #INVERSE_MODELVIEW} (if requested)
-     * - {@link #INVERSE_TRANSPOSED_MODELVIEW} (if requested)
-     * - {@link #FRUSTUM} (always, cleared via {@link #getFrustum()}
-     * <p>
-     * A dirty bit is set, if the corresponding matrix had been modified by a mutable operation
-     * since last {@link #update()} call and requested in the constructor {@link #PMVMatrix(int)}.
-     * </p>
-     * <p>
-     * {@link #update()} clears the dirty state for the matrices and {@link #getFrustum()} for {@link #FRUSTUM}.
-     * </p>
-     *
-     * @see #isReqDirty()
-     * @see #INVERSE_MODELVIEW
-     * @see #INVERSE_TRANSPOSED_MODELVIEW
-     * @see #FRUSTUM
-     * @see #PMVMatrix(int)
-     * @see #getMviMat()
-     * @see #getMvitMat()
-     * @see #getSyncPMvMviMat()
-     * @see #getSyncPMvMviMvitMat()
-     * @see #getFrustum()
-     */
-    public final int getDirtyBits() {
-        return dirtyBits;
-    }
-
-    /**
-     * Returns true if the one of the {@link #getReqBits() requested bits} are are set dirty due to mutable operations,
-     * i.e. at least one of
-     * - {@link #INVERSE_MODELVIEW}
-     * - {@link #INVERSE_TRANSPOSED_MODELVIEW}
-     * <p>
-     * A dirty bit is set, if the corresponding matrix had been modified by a mutable operation
-     * since last {@link #update()} call and requested in the constructor {@link #PMVMatrix(int)}.
-     * </p>
-     * <p>
-     * {@link #update()} clears the dirty state for the matrices and {@link #getFrustum()} for {@link #FRUSTUM}.
-     * </p>
-     *
-     * @see #INVERSE_MODELVIEW
-     * @see #INVERSE_TRANSPOSED_MODELVIEW
-     * @see #PMVMatrix(int)
-     * @see #getMviMat()
-     * @see #getMvitMat()
-     * @see #getSyncPMvMviMat()
-     * @see #getSyncPMvMviMvitMat()
-     */
-    public final boolean isReqDirty() {
-        return 0 != ( requestBits & dirtyBits );
-    }
-
-    /**
-     * Returns the request bit mask, which uses bit values equal to the dirty mask
-     * and may contain
-     * - {@link #INVERSE_MODELVIEW}
-     * - {@link #INVERSE_TRANSPOSED_MODELVIEW}
-     * <p>
-     * The request bit mask is set by in the constructor {@link #PMVMatrix(int)}.
-     * </p>
-     *
-     * @see #INVERSE_MODELVIEW
-     * @see #INVERSE_TRANSPOSED_MODELVIEW
-     * @see #PMVMatrix(int)
-     * @see #getMviMat()
-     * @see #getMvitMat()
-     * @see #getSyncPMvMviMat()
-     * @see #getSyncPMvMviMvitMat()
-     * @see #getFrustum()
-     */
-    public final int getReqBits() {
-        return requestBits;
-    }
-
-    /**
-     * Returns the pre-multiplied projection x modelview, P x Mv.
-     * <p>
-     * This {@link Matrix4f} instance should be re-fetched via this method and not locally stored
-     * to have it updated from a potential modification of underlying projection and/or modelview matrix.
-     * {@link #update()} has no effect on this {@link Matrix4f}.
-     * </p>
-     * <p>
-     * This pre-multipled P x Mv is considered dirty, if its corresponding
-     * {@link #getPMat() P matrix} or {@link #getMvMat() Mv matrix} has been modified since its last update.
-     * </p>
-     * @see #update()
-     */
-    public final Matrix4f getPMvMat() {
-        if( 0 != ( dirtyBits & PREMUL_PMV ) ) {
-            if( null == matPMv ) {
-                matPMv = new Matrix4f();
-            }
-            matPMv.mul(matP, matMv);
-            dirtyBits &= ~PREMUL_PMV;
-        }
-        return matPMv;
-    }
-
-    /**
-     * Returns the pre-multiplied inverse projection x modelview,
-     * if {@link Matrix4f#invert(Matrix4f)} succeeded, otherwise `null`.
-     * <p>
-     * This {@link Matrix4f} instance should be re-fetched via this method and not locally stored
-     * to have it updated from a potential modification of underlying projection and/or modelview matrix.
-     * {@link #update()} has no effect on this {@link Matrix4f}.
-     * </p>
-     * <p>
-     * This pre-multipled invert(P x Mv) is considered dirty, if its corresponding
-     * {@link #getPMat() P matrix} or {@link #getMvMat() Mv matrix} has been modified since its last update.
-     * </p>
-     * @see #update()
-     */
-    public final Matrix4f getPMviMat() {
-        if( 0 != ( dirtyBits & PREMUL_PMVI ) ) {
-            if( null == matPMvi ) {
-                matPMvi = new Matrix4f();
-            }
-            final Matrix4f mPMv = getPMvMat();
-            matPMviOK = matPMvi.invert(mPMv);
-            dirtyBits &= ~PREMUL_PMVI;
-        }
-        return matPMviOK ? matPMvi : null;
-    }
-
-    /**
-     * Returns the frustum, derived from projection x modelview.
-     * <p>
-     * This {@link Frustum} instance should be re-fetched via this method and not locally stored
-     * to have it updated from a potential modification of underlying projection and/or modelview matrix.
-     * {@link #update()} has no effect on this {@link Frustum}.
-     * </p>
-     * <p>
-     * The {@link Frustum} is considered dirty, if its corresponding
-     * {@link #getPMat() P matrix} or {@link #getMvMat() Mv matrix} has been modified since its last update.
-     * </p>
-     * @see #update()
-     */
-    public final Frustum getFrustum() {
-        if( 0 != ( dirtyBits & FRUSTUM ) ) {
-            if( null == frustum ) {
-                frustum = new Frustum();
-            }
-            final Matrix4f mPMv = getPMvMat();
-            frustum.updateFrustumPlanes(mPMv);
-            dirtyBits &= ~FRUSTUM;
-        }
-        return frustum;
-    }
-
-    /**
-     * Update the derived {@link #getMviMat() inverse modelview (Mvi)},
-     * {@link #getMvitMat() inverse transposed modelview (Mvit)} matrices
-     * <b>if</b> they {@link #isReqDirty() are dirty} <b>and</b>
-     * requested via the constructor {@link #PMVMatrix(int)}.<br/>
-     * Hence updates the following dirty bits.
-     * - {@link #INVERSE_MODELVIEW}
-     * - {@link #INVERSE_TRANSPOSED_MODELVIEW}
-     * <p>
-     * The {@link Frustum} is updated only via {@link #getFrustum()} separately.
-     * </p>
-     * <p>
-     * The Mvi and Mvit matrices are considered dirty, if their corresponding
-     * {@link #getMvMat() Mv matrix} has been modified since their last update.
-     * </p>
-     * <p>
-     * Method is automatically called by {@link SyncMatrix4f} and {@link SyncMatrices4f}
-     * instances {@link SyncAction} as retrieved by e.g. {@link #getSyncMvitMat()}.
-     * This ensures an automatic update cycle if used with {@link GLUniformData}.
-     * </p>
-     * <p>
-     * Method may be called manually in case mutable operations has been called
-     * and caller operates on already fetched references, i.e. not calling
-     * {@link #getMviMat()}, {@link #getMvitMat()} anymore.
-     * </p>
-     * <p>
-     * Method clears the modified bits like {@link #getModifiedBits(boolean) getModifiedBits(true)},
-     * which are set by any mutable operation. The modified bits have no impact
-     * on this method, but the return value.
-     * </p>
-     *
-     * @return true if any matrix has been modified since last update call or
-     *         if the derived matrices Mvi and Mvit were updated, otherwise false.
-     *         In other words, method returns true if any matrix used by the caller must be updated,
-     *         e.g. uniforms in a shader program.
-     *
-     * @see #getModifiedBits(boolean)
-     * @see #isReqDirty()
-     * @see #INVERSE_MODELVIEW
-     * @see #INVERSE_TRANSPOSED_MODELVIEW
-     * @see #PMVMatrix(int)
-     * @see #getMviMat()
-     * @see #getMvitMat()
-     * @see #getSyncPMvMviMat()
-     * @see #getSyncPMvMviMvitMat()
-     */
-    public final boolean update() {
-        return updateImpl(true);
-    }
-
     //
     // private
     //
 
-    private final boolean updateImpl(final boolean clearModBits) {
-        boolean mod = 0 != modifiedBits;
-        if( clearModBits ) {
-            modifiedBits = 0;
-        }
-        if( 0 != ( requestBits & ( ( dirtyBits & ( INVERSE_MODELVIEW | INVERSE_TRANSPOSED_MODELVIEW ) ) ) ) ) { // only if dirt requested & dirty
-            if( !matMvi.invert(matMv) ) {
-                throw new GLException(msgCantComputeInverse);
-            }
-            dirtyBits &= ~INVERSE_MODELVIEW;
-            mod = true;
-        }
-        if( 0 != ( requestBits & ( dirtyBits & INVERSE_TRANSPOSED_MODELVIEW ) ) ) { // only if requested & dirty
-            matMvit.transpose(matMvi);
-            dirtyBits &= ~INVERSE_TRANSPOSED_MODELVIEW;
-            mod = true;
-        }
-        return mod;
-    }
-    private static final String msgCantComputeInverse = "Invalid source Mv matrix, can't compute inverse";
-
-    private final Matrix4f matP;
-    private final Matrix4f matMv;
-    private final Matrix4f matTex;
-
-    private final Matrix4f matMvi;
-    private final Matrix4f matMvit;
-
-    private static final int mP_offset      = 0*16;
-    private static final int mMv_offset     = 1*16;
-    private final int mMvi_offset;
-    private final int mMvit_offset;
-    private final int mTex_offset;
-
-    private final float[] matrixStore;
-
-    private final FloatBuffer bufP, bufMv, bufTex;
-    private final FloatBuffer bufMvi, bufMvit;
-    private final FloatBuffer bufP_Mv, bufP_Mv_Mvi, bufP_Mv_Mvi_Mvit;
-
-    private final SyncMatrix4f syncP, syncMv, syncT;
-    private final SyncMatrix4f syncMvi, syncMvit;
-    private final SyncMatrices4f syncP_Mv, syncP_Mv_Mvi, syncP_Mv_Mvi_Mvit;
-
-    private final Matrix4f mat4Tmp1;
-
     private int matrixMode = GL_MODELVIEW;
-    private int modifiedBits = MODIFIED_ALL;
-    private int dirtyBits = 0; // contains the dirty bits, i.e. hinting for update operation
-    private final int requestBits; // may contain the requested bits: INVERSE_MODELVIEW | INVERSE_TRANSPOSED_MODELVIEW
-    private Matrix4f mat4Tmp2;
-    private Matrix4f matPMv;
-    private Matrix4f matPMvi;
-    private boolean matPMviOK;
-    private Frustum frustum;
-
-    private abstract class PMVSyncBuffer implements SyncMatrix4f {
-        protected final Matrix4f mat;
-        private final FloatBuffer fbuf;
-
-        public PMVSyncBuffer(final Matrix4f m, final FloatBuffer fbuf) {
-            this.mat = m;
-            this.fbuf = fbuf;
-        }
-
-        @Override
-        public final Buffer getBuffer() { return fbuf; }
-
-        @Override
-        public final SyncBuffer sync() { getAction().sync(); return this; }
-
-        @Override
-        public final Buffer getSyncBuffer() { getAction().sync(); return fbuf; }
-
-        @Override
-        public final Matrix4f getMatrix() { return mat; }
-
-        @Override
-        public final FloatBuffer getSyncFloats() { getAction().sync(); return fbuf; }
-    }
-    private final class SyncBuffer0 extends PMVSyncBuffer {
-        private final SyncAction action = new SyncAction() {
-            @Override
-            public void sync() { mat.get(matrixStore); }
-        };
-
-        public SyncBuffer0(final Matrix4f m, final FloatBuffer fbuf) { super(m, fbuf); }
-
-        @Override
-        public SyncAction getAction() { return action; }
-
-    }
-    private final class SyncBuffer1 extends PMVSyncBuffer {
-        private final int offset;
-        private final SyncAction action = new SyncAction() {
-            @Override
-            public void sync() { mat.get(matrixStore, offset); }
-        };
-
-        public SyncBuffer1(final Matrix4f m, final FloatBuffer fbuf, final int offset) {
-            super(m, fbuf);
-            this.offset = offset;
-        }
-
-        @Override
-        public SyncAction getAction() { return action; }
-    }
-    private final class SyncBuffer1U extends PMVSyncBuffer {
-        private final int offset;
-        private final SyncAction action = new SyncAction() {
-            @Override
-            public void sync() {
-                updateImpl(true);
-                mat.get(matrixStore, offset);
-            }
-        };
-
-        public SyncBuffer1U(final Matrix4f m, final FloatBuffer fbuf, final int offset) {
-            super(m, fbuf);
-            this.offset = offset;
-        }
-
-        @Override
-        public SyncAction getAction() { return action; }
-    }
-
-    private abstract class PMVSyncBufferN implements SyncMatrices4f {
-        protected final Matrix4f[] mats;
-        private final FloatBuffer fbuf;
-
-        public PMVSyncBufferN(final Matrix4f[] ms, final FloatBuffer fbuf) {
-            this.mats = ms;
-            this.fbuf = fbuf;
-        }
-
-        @Override
-        public final Buffer getBuffer() { return fbuf; }
-
-        @Override
-        public final SyncBuffer sync() { getAction().sync(); return this; }
-
-        @Override
-        public final Buffer getSyncBuffer() { getAction().sync(); return fbuf; }
-
-        @Override
-        public Matrix4f[] getMatrices() { return mats; }
-
-        @Override
-        public final FloatBuffer getSyncFloats() { getAction().sync(); return fbuf; }
-    }
-    private final class SyncBufferN extends PMVSyncBufferN {
-        private final int offset;
-        private final SyncAction action = new SyncAction() {
-            @Override
-            public void sync() {
-                int ioff = offset;
-                for(int i=0; i<mats.length; ++i, ioff+=16) {
-                    mats[i].get(matrixStore, ioff);
-                }
-            }
-        };
-
-        public SyncBufferN(final Matrix4f[] ms, final FloatBuffer fbuf, final int offset) {
-            super(ms, fbuf);
-            this.offset = offset;
-        }
-
-        @Override
-        public SyncAction getAction() { return action; }
-    }
-    private final class SyncBufferNU extends PMVSyncBufferN {
-        private final int offset;
-        private final SyncAction action = new SyncAction() {
-            @Override
-            public void sync() {
-                updateImpl(true);
-                int ioff = offset;
-                for(int i=0; i<mats.length; ++i, ioff+=16) {
-                    mats[i].get(matrixStore, ioff);
-                }
-            }
-        };
-
-        public SyncBufferNU(final Matrix4f[] ms, final FloatBuffer fbuf, final int offset) {
-            super(ms, fbuf);
-            this.offset = offset;
-        }
-
-        @Override
-        public SyncAction getAction() { return action; }
-    }
 }
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java
index 37bca895a..e6549baba 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java
@@ -4,6 +4,7 @@
 
 package com.jogamp.opengl.util.glsl.fixedfunc;
 
+import com.jogamp.math.util.PMVMatrix4f;
 import com.jogamp.opengl.GL;
 import com.jogamp.opengl.GL2ES1;
 import com.jogamp.opengl.GL2ES2;
@@ -66,7 +67,7 @@ public class FixedFuncUtil {
      * @see ShaderSelectionMode#COLOR_TEXTURE
      * @see ShaderSelectionMode#COLOR_TEXTURE_LIGHT_PER_VERTEX
      */
-    public static final GL2ES1 wrapFixedFuncEmul(final GL gl, final ShaderSelectionMode mode, final PMVMatrix pmvMatrix) {
+    public static final GL2ES1 wrapFixedFuncEmul(final GL gl, final ShaderSelectionMode mode, final PMVMatrix4f pmvMatrix) {
         return wrapFixedFuncEmul(gl, mode, null, false, false);
     }
 
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/EyeParameter.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/EyeParameter.java
index e0f465da7..c6c968415 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/stereo/EyeParameter.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/EyeParameter.java
@@ -27,8 +27,8 @@
  */
 package com.jogamp.opengl.util.stereo;
 
-import com.jogamp.opengl.math.FovHVHalves;
-import com.jogamp.opengl.math.Vec3f;
+import com.jogamp.math.FovHVHalves;
+import com.jogamp.math.Vec3f;
 
 /**
  * Constant single eye parameter of the viewer, relative to its {@link ViewerPose}.
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/LocationSensorParameter.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/LocationSensorParameter.java
index 6294adee1..2634535aa 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/stereo/LocationSensorParameter.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/LocationSensorParameter.java
@@ -27,8 +27,8 @@
  */
 package com.jogamp.opengl.util.stereo;
 
-import com.jogamp.opengl.math.Matrix4f;
-import com.jogamp.opengl.math.geom.Frustum;
+import com.jogamp.math.Matrix4f;
+import com.jogamp.math.geom.Frustum;
 
 /**
  * Constant parameter of the positioning sensor to locate the {@link ViewerPose}.
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoDevice.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoDevice.java
index 85e752302..538152f7a 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoDevice.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoDevice.java
@@ -27,14 +27,13 @@
  */
 package com.jogamp.opengl.util.stereo;
 
+import com.jogamp.math.FovHVHalves;
+import com.jogamp.math.Vec3f;
 import com.jogamp.nativewindow.util.DimensionImmutable;
 import com.jogamp.nativewindow.util.PointImmutable;
 
 import jogamp.opengl.Debug;
 
-import com.jogamp.opengl.math.FovHVHalves;
-import com.jogamp.opengl.math.Vec3f;
-
 /**
  * Interface describing a native stereoscopic device
  */
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoDeviceRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoDeviceRenderer.java
index 0d6539634..624a1984c 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoDeviceRenderer.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoDeviceRenderer.java
@@ -27,12 +27,11 @@
  */
 package com.jogamp.opengl.util.stereo;
 
+import com.jogamp.math.FovHVHalves;
 import com.jogamp.nativewindow.util.DimensionImmutable;
 import com.jogamp.nativewindow.util.RectangleImmutable;
 import com.jogamp.opengl.GL;
 
-import com.jogamp.opengl.math.FovHVHalves;
-
 /**
  * Stereoscopic device rendering interface.
  * <p>
@@ -175,7 +174,7 @@ public interface StereoDeviceRenderer {
      * <p>
      * In case the renderer does not support multiple textures for post-processing,
      * or no post-processing at all, method returns zero despite the request
-     * from {@link StereoDevice#createRenderer(int, int, float[], com.jogamp.opengl.math.FovHVHalves[], float)}.
+     * from {@link StereoDevice#createRenderer(int, int, float[], com.jogamp.math.FovHVHalves[], float)}.
      * </p>
      */
     public int getTextureCount();
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoGLEventListener.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoGLEventListener.java
index 59f38f2af..9108a0723 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoGLEventListener.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoGLEventListener.java
@@ -27,10 +27,9 @@
  */
 package com.jogamp.opengl.util.stereo;
 
+import com.jogamp.math.FloatUtil;
 import com.jogamp.opengl.GLAutoDrawable;
 import com.jogamp.opengl.GLEventListener;
-
-import com.jogamp.opengl.math.FloatUtil;
 import com.jogamp.opengl.util.CustomGLEventListener;
 
 /**
@@ -65,7 +64,7 @@ public interface StereoGLEventListener extends CustomGLEventListener {
      * @param height viewport height in pixel units
      * @param eyeParam constant eye parameter, i.e. FOV and IPD
      * @param viewerPose current viewer position and orientation
-     * @see FloatUtil#makePerspective(float[], int, boolean, com.jogamp.opengl.math.FloatUtil.FovHVHalves, float, float)
+     * @see FloatUtil#makePerspective(float[], int, boolean, com.jogamp.math.FloatUtil.FovHVHalves, float, float)
      */
     public void reshapeForEye(final GLAutoDrawable drawable, final int x, final int y, final int width, final int height,
                               final EyeParameter eyeParam, final ViewerPose viewerPose);
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoUtil.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoUtil.java
index 63cb3e1e7..404c80d23 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoUtil.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/StereoUtil.java
@@ -27,9 +27,9 @@
  */
 package com.jogamp.opengl.util.stereo;
 
-import com.jogamp.opengl.math.Matrix4f;
-import com.jogamp.opengl.math.Quaternion;
-import com.jogamp.opengl.math.Vec3f;
+import com.jogamp.math.Matrix4f;
+import com.jogamp.math.Quaternion;
+import com.jogamp.math.Vec3f;
 import com.jogamp.opengl.util.CustomGLEventListener;
 import com.jogamp.opengl.util.stereo.StereoDeviceRenderer.Eye;
 
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/ViewerPose.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/ViewerPose.java
index 5d2cf925c..7c116a019 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/stereo/ViewerPose.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/ViewerPose.java
@@ -27,8 +27,8 @@
  */
 package com.jogamp.opengl.util.stereo;
 
-import com.jogamp.opengl.math.Quaternion;
-import com.jogamp.opengl.math.Vec3f;
+import com.jogamp.math.Quaternion;
+import com.jogamp.math.Vec3f;
 
 /**
  * {@link #position} and {@link #orientation} of viewer.
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceFactory.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceFactory.java
index 0cdef8770..a25e923dc 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceFactory.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceFactory.java
@@ -31,11 +31,11 @@ import jogamp.opengl.util.stereo.DistortionMesh;
 import jogamp.opengl.util.stereo.GenericStereoDevice;
 
 import com.jogamp.common.util.ReflectionUtil;
+import com.jogamp.math.FloatUtil;
+import com.jogamp.math.FovHVHalves;
+import com.jogamp.math.Vec3f;
 import com.jogamp.nativewindow.util.Dimension;
 import com.jogamp.nativewindow.util.DimensionImmutable;
-import com.jogamp.opengl.math.FloatUtil;
-import com.jogamp.opengl.math.FovHVHalves;
-import com.jogamp.opengl.math.Vec3f;
 import com.jogamp.opengl.util.stereo.EyeParameter;
 import com.jogamp.opengl.util.stereo.StereoDevice;
 import com.jogamp.opengl.util.stereo.StereoDeviceConfig;
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PMSAAES2.java b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PMSAAES2.java
index 52c674342..73af4603d 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PMSAAES2.java
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PMSAAES2.java
@@ -41,13 +41,13 @@ import com.jogamp.graph.curve.Region;
 import com.jogamp.graph.curve.opengl.GLRegion;
 import com.jogamp.graph.curve.opengl.RegionRenderer;
 import com.jogamp.graph.curve.opengl.RenderState;
+import com.jogamp.math.Matrix4f;
+import com.jogamp.math.Recti;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.util.SyncMatrices4f16;
 import com.jogamp.opengl.FBObject;
 import com.jogamp.opengl.FBObject.Attachment;
-import com.jogamp.opengl.math.Matrix4f;
-import com.jogamp.opengl.math.Recti;
-import com.jogamp.opengl.math.geom.AABBox;
 import com.jogamp.opengl.util.GLArrayDataServer;
-import com.jogamp.opengl.util.SyncMatrices4f16;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
 import com.jogamp.opengl.util.texture.Texture;
 import com.jogamp.opengl.util.texture.TextureCoords;
@@ -288,7 +288,7 @@ public final class VBORegion2PMSAAES2  extends GLRegion {
                 drawView.setWidth(vpWidth);
                 drawView.setHeight(vpHeight);
 
-                box.mapToWindow(drawWinBox, renderer.getMatrix().getPMvMat(), drawView, true /* useCenterZ */);
+                box.mapToWindow(drawWinBox, renderer.getMatrix().getPMv(), drawView, true /* useCenterZ */);
 
                 winWidth = drawWinBox.getWidth();
                 winHeight = drawWinBox.getHeight();
diff --git a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PVBAAES2.java b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PVBAAES2.java
index d8e8166b3..9fad72881 100644
--- a/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PVBAAES2.java
+++ b/src/jogl/classes/jogamp/graph/curve/opengl/VBORegion2PVBAAES2.java
@@ -43,14 +43,14 @@ import com.jogamp.graph.curve.Region;
 import com.jogamp.graph.curve.opengl.GLRegion;
 import com.jogamp.graph.curve.opengl.RegionRenderer;
 import com.jogamp.graph.curve.opengl.RenderState;
+import com.jogamp.math.Matrix4f;
+import com.jogamp.math.Recti;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.util.SyncMatrices4f16;
 import com.jogamp.opengl.FBObject;
 import com.jogamp.opengl.FBObject.Attachment;
 import com.jogamp.opengl.FBObject.TextureAttachment;
-import com.jogamp.opengl.math.Matrix4f;
-import com.jogamp.opengl.math.Recti;
-import com.jogamp.opengl.math.geom.AABBox;
 import com.jogamp.opengl.util.GLArrayDataServer;
-import com.jogamp.opengl.util.SyncMatrices4f16;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
 import com.jogamp.opengl.util.texture.Texture;
 import com.jogamp.opengl.util.texture.TextureCoords;
@@ -322,7 +322,7 @@ public final class VBORegion2PVBAAES2  extends GLRegion {
                 drawView.setWidth(vpWidth);
                 drawView.setHeight(vpHeight);
 
-                box.mapToWindow(drawWinBox, renderer.getMatrix().getPMvMat(), drawView, true /* useCenterZ */);
+                box.mapToWindow(drawWinBox, renderer.getMatrix().getPMv(), drawView, true /* useCenterZ */);
 
                 winWidth = drawWinBox.getWidth();
                 winHeight = drawWinBox.getHeight();
diff --git a/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2D.java b/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2D.java
index e187b1590..b7fee25e5 100644
--- a/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2D.java
+++ b/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2D.java
@@ -35,9 +35,9 @@ import com.jogamp.graph.curve.tess.Triangulator;
 import com.jogamp.graph.geom.Outline;
 import com.jogamp.graph.geom.Triangle;
 import com.jogamp.graph.geom.Vertex;
-import com.jogamp.graph.geom.plane.Winding;
-import com.jogamp.opengl.math.Vec2f;
-import com.jogamp.opengl.math.VectorUtil;
+import com.jogamp.math.Vec2f;
+import com.jogamp.math.VectorUtil;
+import com.jogamp.math.geom.plane.Winding;
 
 import jogamp.opengl.Debug;
 
diff --git a/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2DExpAddOn.java b/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2DExpAddOn.java
index 86edf7d61..32f526f3b 100644
--- a/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2DExpAddOn.java
+++ b/src/jogl/classes/jogamp/graph/curve/tess/CDTriangulator2DExpAddOn.java
@@ -30,9 +30,9 @@ package jogamp.graph.curve.tess;
 
 import com.jogamp.graph.geom.Triangle;
 import com.jogamp.graph.geom.Vertex;
-import com.jogamp.opengl.math.Vec2f;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.math.VectorUtil;
+import com.jogamp.math.Vec2f;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.VectorUtil;
 
 /**
  * Experimental Add-On ..
diff --git a/src/jogl/classes/jogamp/graph/curve/tess/GraphVertex.java b/src/jogl/classes/jogamp/graph/curve/tess/GraphVertex.java
index 275abda23..396c541ab 100644
--- a/src/jogl/classes/jogamp/graph/curve/tess/GraphVertex.java
+++ b/src/jogl/classes/jogamp/graph/curve/tess/GraphVertex.java
@@ -30,7 +30,7 @@ package jogamp.graph.curve.tess;
 import java.util.ArrayList;
 
 import com.jogamp.graph.geom.Vertex;
-import com.jogamp.opengl.math.Vec3f;
+import com.jogamp.math.Vec3f;
 
 public class GraphVertex {
     private Vertex point;
diff --git a/src/jogl/classes/jogamp/graph/curve/tess/Loop.java b/src/jogl/classes/jogamp/graph/curve/tess/Loop.java
index 6020e7c66..a27540878 100644
--- a/src/jogl/classes/jogamp/graph/curve/tess/Loop.java
+++ b/src/jogl/classes/jogamp/graph/curve/tess/Loop.java
@@ -31,11 +31,11 @@ import java.util.ArrayList;
 
 
 import com.jogamp.graph.geom.Vertex;
-import com.jogamp.graph.geom.plane.Winding;
+import com.jogamp.math.Vec3f;
+import com.jogamp.math.VectorUtil;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.plane.Winding;
 import com.jogamp.graph.geom.Triangle;
-import com.jogamp.opengl.math.Vec3f;
-import com.jogamp.opengl.math.VectorUtil;
-import com.jogamp.opengl.math.geom.AABBox;
 
 public class Loop {
     private HEdge root = null;
diff --git a/src/jogl/classes/jogamp/graph/font/typecast/TypecastFont.java b/src/jogl/classes/jogamp/graph/font/typecast/TypecastFont.java
index b153b813e..a8651389c 100644
--- a/src/jogl/classes/jogamp/graph/font/typecast/TypecastFont.java
+++ b/src/jogl/classes/jogamp/graph/font/typecast/TypecastFont.java
@@ -31,8 +31,8 @@ import com.jogamp.common.util.IntObjectHashMap;
 import com.jogamp.graph.curve.OutlineShape;
 import com.jogamp.graph.font.Font;
 import com.jogamp.graph.font.FontFactory;
-import com.jogamp.graph.geom.plane.AffineTransform;
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
+import com.jogamp.math.geom.plane.AffineTransform;
 
 import jogamp.graph.font.typecast.ot.OTFontCollection;
 import jogamp.graph.font.typecast.ot.TTFont;
diff --git a/src/jogl/classes/jogamp/graph/font/typecast/TypecastGlyph.java b/src/jogl/classes/jogamp/graph/font/typecast/TypecastGlyph.java
index 3ace5c480..fa8271088 100644
--- a/src/jogl/classes/jogamp/graph/font/typecast/TypecastGlyph.java
+++ b/src/jogl/classes/jogamp/graph/font/typecast/TypecastGlyph.java
@@ -29,7 +29,7 @@ package jogamp.graph.font.typecast;
 
 import com.jogamp.graph.curve.OutlineShape;
 import com.jogamp.graph.font.Font;
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
 
 import jogamp.graph.font.typecast.ot.table.KernSubtable;
 import jogamp.graph.font.typecast.ot.table.KerningPair;
diff --git a/src/jogl/classes/jogamp/graph/font/typecast/TypecastHMetrics.java b/src/jogl/classes/jogamp/graph/font/typecast/TypecastHMetrics.java
index 11f1ce7c7..900747f01 100644
--- a/src/jogl/classes/jogamp/graph/font/typecast/TypecastHMetrics.java
+++ b/src/jogl/classes/jogamp/graph/font/typecast/TypecastHMetrics.java
@@ -31,7 +31,7 @@ import jogamp.graph.font.typecast.ot.table.HeadTable;
 import jogamp.graph.font.typecast.ot.table.HheaTable;
 
 import com.jogamp.graph.font.Font.Metrics;
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
 
 final class TypecastHMetrics implements Metrics {
     private final TypecastFont fontImpl;
diff --git a/src/jogl/classes/jogamp/graph/font/typecast/TypecastRenderer.java b/src/jogl/classes/jogamp/graph/font/typecast/TypecastRenderer.java
index 816be92b2..248e023ed 100644
--- a/src/jogl/classes/jogamp/graph/font/typecast/TypecastRenderer.java
+++ b/src/jogl/classes/jogamp/graph/font/typecast/TypecastRenderer.java
@@ -34,7 +34,7 @@ import jogamp.opengl.Debug;
 
 import com.jogamp.graph.curve.OutlineShape;
 import com.jogamp.graph.geom.Vertex;
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
 
 /**
  * Factory to build an {@link OutlineShape} from
diff --git a/src/jogl/classes/jogamp/graph/font/typecast/ot/Glyph.java b/src/jogl/classes/jogamp/graph/font/typecast/ot/Glyph.java
index 5bb610a1c..2c4394317 100644
--- a/src/jogl/classes/jogamp/graph/font/typecast/ot/Glyph.java
+++ b/src/jogl/classes/jogamp/graph/font/typecast/ot/Glyph.java
@@ -18,7 +18,7 @@
 
 package jogamp.graph.font.typecast.ot;
 
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
 
 /**
  * An individual glyph within a font.
diff --git a/src/jogl/classes/jogamp/graph/font/typecast/ot/T2Glyph.java b/src/jogl/classes/jogamp/graph/font/typecast/ot/T2Glyph.java
index 9df937121..b8c0c4900 100644
--- a/src/jogl/classes/jogamp/graph/font/typecast/ot/T2Glyph.java
+++ b/src/jogl/classes/jogamp/graph/font/typecast/ot/T2Glyph.java
@@ -17,7 +17,7 @@
  */
 package jogamp.graph.font.typecast.ot;
 
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
 
 import jogamp.graph.font.typecast.cff.CharstringType2;
 import jogamp.graph.font.typecast.cff.T2Interpreter;
diff --git a/src/jogl/classes/jogamp/graph/font/typecast/ot/TTGlyph.java b/src/jogl/classes/jogamp/graph/font/typecast/ot/TTGlyph.java
index 5e0f83a33..d5f9eedc5 100644
--- a/src/jogl/classes/jogamp/graph/font/typecast/ot/TTGlyph.java
+++ b/src/jogl/classes/jogamp/graph/font/typecast/ot/TTGlyph.java
@@ -17,7 +17,7 @@
  */
 package jogamp.graph.font.typecast.ot;
 
-import com.jogamp.opengl.math.geom.AABBox;
+import com.jogamp.math.geom.AABBox;
 
 import jogamp.graph.font.typecast.ot.table.GlyfDescript;
 import jogamp.graph.font.typecast.ot.table.GlyphDescription;
diff --git a/src/jogl/classes/jogamp/opengl/ProjectFloat.java b/src/jogl/classes/jogamp/opengl/ProjectFloat.java
index cc4640534..991a57a4d 100644
--- a/src/jogl/classes/jogamp/opengl/ProjectFloat.java
+++ b/src/jogl/classes/jogamp/opengl/ProjectFloat.java
@@ -118,11 +118,10 @@ package jogamp.opengl;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 
+import com.jogamp.math.FloatUtil;
 import com.jogamp.opengl.GLException;
 import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
 
-import com.jogamp.opengl.math.FloatUtil;
-
 /**
  * ProjectFloat.java
  * <p>
diff --git a/src/jogl/classes/jogamp/opengl/glu/GLUquadricImpl.java b/src/jogl/classes/jogamp/opengl/glu/GLUquadricImpl.java
index afd6ba204..4415f2c9e 100644
--- a/src/jogl/classes/jogamp/opengl/glu/GLUquadricImpl.java
+++ b/src/jogl/classes/jogamp/opengl/glu/GLUquadricImpl.java
@@ -115,11 +115,10 @@
 
 package jogamp.opengl.glu;
 
+import com.jogamp.math.FloatUtil;
 import com.jogamp.opengl.GL;
 import com.jogamp.opengl.glu.GLU;
 import com.jogamp.opengl.glu.GLUquadric;
-
-import com.jogamp.opengl.math.FloatUtil;
 import com.jogamp.opengl.util.ImmModeSink;
 import com.jogamp.opengl.util.glsl.ShaderState;
 
diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
index 2fb690747..a308c0597 100644
--- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
+++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
@@ -58,7 +58,6 @@ import com.jogamp.opengl.GLContext;
 import com.jogamp.opengl.GLException;
 import com.jogamp.opengl.GLProfile;
 import com.jogamp.opengl.GLUniformData;
-import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
 
 import jogamp.nativewindow.macosx.OSXUtil;
 import jogamp.opengl.Debug;
@@ -76,8 +75,8 @@ import com.jogamp.common.util.VersionNumber;
 import com.jogamp.common.util.locks.RecursiveLock;
 import com.jogamp.gluegen.runtime.ProcAddressTable;
 import com.jogamp.gluegen.runtime.opengl.GLProcAddressResolver;
+import com.jogamp.math.util.PMVMatrix4f;
 import com.jogamp.opengl.GLRendererQuirks;
-import com.jogamp.opengl.util.PMVMatrix;
 import com.jogamp.opengl.util.glsl.ShaderCode;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
 
@@ -199,12 +198,10 @@ public class MacOSXCGLContext extends GLContextImpl
       sp.useProgram(gl, true);
 
       // setup mgl_PMVMatrix
-      final PMVMatrix pmvMatrix = new PMVMatrix();
-      pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
-      pmvMatrix.glLoadIdentity();
-      pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
-      pmvMatrix.glLoadIdentity();
-      final GLUniformData pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.getSyncPMvMat()); // P, Mv
+      final PMVMatrix4f pmvMatrix = new PMVMatrix4f();
+      pmvMatrix.loadPIdentity();
+      pmvMatrix.loadMvIdentity();
+      final GLUniformData pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.getSyncPMv()); // P, Mv
       pmvMatrixUniform.setLocation(gl, sp.program());
       gl.glUniform(pmvMatrixUniform);
 
diff --git a/src/jogl/classes/jogamp/opengl/util/av/GLMediaPlayerImpl.java b/src/jogl/classes/jogamp/opengl/util/av/GLMediaPlayerImpl.java
index 94b666b7b..7d517c2d6 100644
--- a/src/jogl/classes/jogamp/opengl/util/av/GLMediaPlayerImpl.java
+++ b/src/jogl/classes/jogamp/opengl/util/av/GLMediaPlayerImpl.java
@@ -1459,6 +1459,7 @@ public abstract class GLMediaPlayerImpl implements GLMediaPlayer {
                     isBlocked = false;
                 } catch (final Throwable t) {
                     streamErr = new StreamException(t.getClass().getSimpleName()+" while decoding: "+GLMediaPlayerImpl.this.toString(), t);
+                    isBlocked = false;
                 } finally {
                     if( null != nextFrame ) { // put back
                         videoFramesFree.put(nextFrame);
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLTextureRaster.java b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLTextureRaster.java
index 72c7c257f..e39def369 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/GLSLTextureRaster.java
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/GLSLTextureRaster.java
@@ -31,23 +31,21 @@ package jogamp.opengl.util.glsl;
 import java.nio.FloatBuffer;
 
 import com.jogamp.opengl.util.GLArrayDataServer;
-import com.jogamp.opengl.util.PMVMatrix;
 import com.jogamp.opengl.util.glsl.ShaderCode;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
-
+import com.jogamp.math.util.PMVMatrix4f;
 import com.jogamp.opengl.GL;
 import com.jogamp.opengl.GL2ES2;
 import com.jogamp.opengl.GLArrayData;
 import com.jogamp.opengl.GLException;
 import com.jogamp.opengl.GLUniformData;
-import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
 
 public class GLSLTextureRaster  {
     private final boolean textureVertFlipped;
     private final int textureUnit;
 
     private ShaderProgram sp;
-    private PMVMatrix pmvMatrix;
+    private PMVMatrix4f pmvMatrix;
     private GLUniformData pmvMatrixUniform;
     private GLUniformData activeTexUniform;
     private GLArrayDataServer interleavedVBO;
@@ -82,12 +80,10 @@ public class GLSLTextureRaster  {
         sp.useProgram(gl, true);
 
         // setup mgl_PMVMatrix
-        pmvMatrix = new PMVMatrix();
-        pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
-        pmvMatrix.glLoadIdentity();
-        pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
-        pmvMatrix.glLoadIdentity();
-        pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.getSyncPMvMat()); // P, Mv
+        pmvMatrix = new PMVMatrix4f();
+        pmvMatrix.loadPIdentity();
+        pmvMatrix.loadMvIdentity();
+        pmvMatrixUniform = new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.getSyncPMv()); // P, Mv
         if( pmvMatrixUniform.setLocation(gl, sp.program()) < 0 ) {
             throw new GLException("Couldn't locate "+pmvMatrixUniform+" in shader: "+sp);
         }
@@ -130,12 +126,10 @@ public class GLSLTextureRaster  {
 
     public void reshape(final GL2ES2 gl, final int x, final int y, final int width, final int height) {
         if(null != sp) {
-            pmvMatrix.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
-            pmvMatrix.glLoadIdentity();
-            pmvMatrix.glOrthof(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 10.0f);
+            pmvMatrix.loadPIdentity();
+            pmvMatrix.orthoP(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 10.0f);
 
-            pmvMatrix.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
-            pmvMatrix.glLoadIdentity();
+            pmvMatrix.loadMvIdentity();
 
             sp.useProgram(gl, true);
             gl.glUniform(pmvMatrixUniform);
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncHook.java b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncHook.java
index 998406856..fb2bf1bdc 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncHook.java
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncHook.java
@@ -43,6 +43,7 @@ import com.jogamp.opengl.fixedfunc.GLPointerFunc;
 
 import com.jogamp.common.nio.Buffers;
 import com.jogamp.common.util.ValueConv;
+import com.jogamp.math.util.PMVMatrix4f;
 import com.jogamp.opengl.util.GLArrayDataWrapper;
 import com.jogamp.opengl.util.GLBuffers;
 import com.jogamp.opengl.util.PMVMatrix;
@@ -70,7 +71,7 @@ public class FixedFuncHook implements GLLightingFunc, GLMatrixFunc, GLPointerFun
             this.pmvMatrix = pmvMatrix;
         } else {
             this.ownsPMVMatrix = true;
-            this.pmvMatrix = new PMVMatrix(PMVMatrix.INVERSE_MODELVIEW | PMVMatrix.INVERSE_TRANSPOSED_MODELVIEW);
+            this.pmvMatrix = new PMVMatrix(PMVMatrix4f.INVERSE_MODELVIEW | PMVMatrix4f.INVERSE_TRANSPOSED_MODELVIEW);
         }
         fixedFunction = new FixedFuncPipeline(this.gl, mode, this.pmvMatrix);
     }
@@ -91,7 +92,7 @@ public class FixedFuncHook implements GLLightingFunc, GLMatrixFunc, GLPointerFun
             this.pmvMatrix = pmvMatrix;
         } else {
             this.ownsPMVMatrix = true;
-            this.pmvMatrix = new PMVMatrix(PMVMatrix.INVERSE_MODELVIEW | PMVMatrix.INVERSE_TRANSPOSED_MODELVIEW);
+            this.pmvMatrix = new PMVMatrix(PMVMatrix4f.INVERSE_MODELVIEW | PMVMatrix4f.INVERSE_TRANSPOSED_MODELVIEW);
         }
 
         fixedFunction = new FixedFuncPipeline(this.gl, mode, this.pmvMatrix, shaderRootClass, shaderSrcRoot,
@@ -109,7 +110,7 @@ public class FixedFuncHook implements GLLightingFunc, GLMatrixFunc, GLPointerFun
         gl=null;
     }
 
-    public PMVMatrix getMatrix() { return pmvMatrix; }
+    public PMVMatrix4f getMatrix() { return pmvMatrix; }
 
     //
     // FixedFuncHookIf - hooks
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
index c9e2664ba..a4b5e9afd 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
@@ -54,9 +54,9 @@ import jogamp.opengl.Debug;
 import com.jogamp.common.nio.Buffers;
 import com.jogamp.common.util.IntIntHashMap;
 import com.jogamp.common.util.PropertyAccess;
-import com.jogamp.opengl.util.PMVMatrix;
-import com.jogamp.opengl.util.SyncBuffer;
-import com.jogamp.opengl.util.SyncMatrices4f;
+import com.jogamp.math.util.PMVMatrix4f;
+import com.jogamp.math.util.SyncBuffer;
+import com.jogamp.math.util.SyncMatrices4f;
 import com.jogamp.opengl.util.glsl.ShaderCode;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
 import com.jogamp.opengl.util.glsl.ShaderState;
@@ -82,7 +82,7 @@ public class FixedFuncPipeline {
     public static final int MAX_TEXTURE_UNITS = 8;
     public static final int MAX_LIGHTS        = 8;
 
-    public FixedFuncPipeline(final GL2ES2 gl, final ShaderSelectionMode mode, final PMVMatrix pmvMatrix) {
+    public FixedFuncPipeline(final GL2ES2 gl, final ShaderSelectionMode mode, final PMVMatrix4f pmvMatrix) {
         shaderRootClass = FixedFuncPipeline.class;
         shaderSrcRoot = shaderSrcRootDef;
         shaderBinRoot = shaderBinRootDef;
@@ -92,7 +92,7 @@ public class FixedFuncPipeline {
         fragmentColorTextureFile = fragmentColorTextureFileDef;
         init(gl, mode, pmvMatrix);
     }
-    public FixedFuncPipeline(final GL2ES2 gl, final ShaderSelectionMode mode, final PMVMatrix pmvMatrix,
+    public FixedFuncPipeline(final GL2ES2 gl, final ShaderSelectionMode mode, final PMVMatrix4f pmvMatrix,
                              final Class<?> shaderRootClass, final String shaderSrcRoot,
                              final String shaderBinRoot,
                              final String vertexColorFile, final String vertexColorLightFile,
@@ -820,9 +820,9 @@ public class FixedFuncPipeline {
                 final SyncMatrices4f m;
                 if(ShaderSelectionMode.COLOR_TEXTURE8_LIGHT_PER_VERTEX == currentShaderSelectionMode ||
                    ShaderSelectionMode.COLOR_LIGHT_PER_VERTEX== currentShaderSelectionMode ) {
-                    m = pmvMatrix.getSyncPMvMviMvitMat();
+                    m = pmvMatrix.getSyncPMvMviMvit();
                 } else {
-                    m = pmvMatrix.getSyncPMvMat();
+                    m = pmvMatrix.getSyncPMv();
                 }
                 if(m != ud.getBuffer()) {
                     ud.setData(m);
@@ -1102,7 +1102,7 @@ public class FixedFuncPipeline {
         return sp;
     }
 
-    private void init(final GL2ES2 gl, final ShaderSelectionMode mode, final PMVMatrix pmvMatrix) {
+    private void init(final GL2ES2 gl, final ShaderSelectionMode mode, final PMVMatrix4f pmvMatrix) {
         if(null==pmvMatrix) {
             throw new GLException("PMVMatrix is null");
         }
@@ -1114,7 +1114,7 @@ public class FixedFuncPipeline {
         shaderState.attachShaderProgram(gl, selectShaderProgram(gl, requestedShaderSelectionMode), true);
 
         // mandatory ..
-        if(!shaderState.uniform(gl, new GLUniformData(mgl_PMVMatrix, 4, 4, pmvMatrix.getSyncPMvMviMvitMat()))) {
+        if(!shaderState.uniform(gl, new GLUniformData(mgl_PMVMatrix, 4, 4, pmvMatrix.getSyncPMvMviMvit()))) {
             throw new GLException("Error setting PMVMatrix in shader: "+this);
         }
 
@@ -1202,7 +1202,7 @@ public class FixedFuncPipeline {
     /** ( pointSize, pointSmooth, attn. pointMinSize, attn. pointMaxSize ) , ( attenuation coefficients 1f 0f 0f, attenuation fade theshold 1f )   */
     private final FloatBuffer pointParams = Buffers.newDirectFloatBuffer(new float[] {  1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f });
 
-    private PMVMatrix pmvMatrix;
+    private PMVMatrix4f pmvMatrix;
     private ShaderState shaderState;
     private ShaderProgram shaderProgramColor;
     private ShaderProgram shaderProgramColorTexture2, shaderProgramColorTexture4, shaderProgramColorTexture8;
diff --git a/src/jogl/classes/jogamp/opengl/util/stereo/GenericStereoDevice.java b/src/jogl/classes/jogamp/opengl/util/stereo/GenericStereoDevice.java
index 60adc7d74..89765e4f6 100644
--- a/src/jogl/classes/jogamp/opengl/util/stereo/GenericStereoDevice.java
+++ b/src/jogl/classes/jogamp/opengl/util/stereo/GenericStereoDevice.java
@@ -27,14 +27,14 @@
  */
 package jogamp.opengl.util.stereo;
 
+import com.jogamp.math.FovHVHalves;
+import com.jogamp.math.Vec3f;
 import com.jogamp.nativewindow.util.Dimension;
 import com.jogamp.nativewindow.util.DimensionImmutable;
 import com.jogamp.nativewindow.util.Point;
 import com.jogamp.nativewindow.util.PointImmutable;
 import com.jogamp.nativewindow.util.Rectangle;
 import com.jogamp.nativewindow.util.RectangleImmutable;
-import com.jogamp.opengl.math.FovHVHalves;
-import com.jogamp.opengl.math.Vec3f;
 import com.jogamp.opengl.util.stereo.StereoDeviceConfig;
 import com.jogamp.opengl.util.stereo.EyeParameter;
 import com.jogamp.opengl.util.stereo.LocationSensorParameter;
diff --git a/src/jogl/classes/jogamp/opengl/util/stereo/GenericStereoDeviceRenderer.java b/src/jogl/classes/jogamp/opengl/util/stereo/GenericStereoDeviceRenderer.java
index 3c6f5e37e..3a3ead790 100644
--- a/src/jogl/classes/jogamp/opengl/util/stereo/GenericStereoDeviceRenderer.java
+++ b/src/jogl/classes/jogamp/opengl/util/stereo/GenericStereoDeviceRenderer.java
@@ -44,8 +44,8 @@ import jogamp.common.os.PlatformPropsImpl;
 
 import com.jogamp.common.nio.Buffers;
 import com.jogamp.common.os.Platform;
+import com.jogamp.math.Vec3f;
 import com.jogamp.opengl.JoglVersion;
-import com.jogamp.opengl.math.Vec3f;
 import com.jogamp.opengl.util.GLArrayDataServer;
 import com.jogamp.opengl.util.glsl.ShaderCode;
 import com.jogamp.opengl.util.glsl.ShaderProgram;
diff --git a/src/jogl/classes/jogamp/opengl/util/stereo/ScaleAndOffset2D.java b/src/jogl/classes/jogamp/opengl/util/stereo/ScaleAndOffset2D.java
index 1fed69363..f7a5a5e9b 100644
--- a/src/jogl/classes/jogamp/opengl/util/stereo/ScaleAndOffset2D.java
+++ b/src/jogl/classes/jogamp/opengl/util/stereo/ScaleAndOffset2D.java
@@ -27,12 +27,11 @@
  */
 package jogamp.opengl.util.stereo;
 
+import com.jogamp.math.FovHVHalves;
+import com.jogamp.math.VectorUtil;
 import com.jogamp.nativewindow.util.DimensionImmutable;
 import com.jogamp.nativewindow.util.RectangleImmutable;
 
-import com.jogamp.opengl.math.FovHVHalves;
-import com.jogamp.opengl.math.VectorUtil;
-
 /**
  * 2D scale and offset NDC class,
  * providing conversion from {@link FovHVHalves} in tangent to NDC space.
author	Sven Gothel <sgothel@jausoft.com>	2023-09-20 19:51:55 +0200
committer	Sven Gothel <sgothel@jausoft.com>	2023-09-20 19:51:55 +0200
commit	5d6e8a367c03644740187e500c6de5d3ac039d5e (patch)
tree	a649f559413c51272ee3f4afff1f68ebfea45477 /src/jogl
parent	bbe845846ffc00807395a5070a7352c6bbe7e4ef (diff)