Vulkan

VulkanDesign.txt

@@ -0,0 +1,5 @@
+Spatial: Current problems:
+
+    * The transform refresh only works when transform setter methods are used. I propose that the world transform should be recalculated on every frame. It will make the system a lot simpler, I think.
+    * An explicit world light list is unnecessary. All that needs to be done to capture all lights affecting a spatial is to iterate up the hierarchy and collect lights from the local light lists. Iterating up the hierarchy is extremely cheap and I want to take more advantage of it.
+    * There should be at most one method in Spatial for iterating over an entire tree. It should use depth-first traversal. Breadth-first traversal isn't used within the engine and is obviously more expensive. collideWith() is also counted as a traversal method. If possible, I'd like to take more advantage of SceneGraphIterator, since I think it is the most powerful traversal available.

gradle/libs.versions.toml

@@ -34,6 +34,8 @@ lwjgl3-opencl   = { module = "org.lwjgl:lwjgl-opencl",   version.ref = "lwjgl3"
 lwjgl3-opengl   = { module = "org.lwjgl:lwjgl-opengl",   version.ref = "lwjgl3" }
 lwjgl3-openvr   = { module = "org.lwjgl:lwjgl-openvr",   version.ref = "lwjgl3" }
 lwjgl3-ovr      = { module = "org.lwjgl:lwjgl-ovr",      version.ref = "lwjgl3" }
+lwjgl3-vulkan   = { module = "org.lwjgl:lwjgl-vulkan",   version.ref = "lwjgl3" }
+lwjgl3-shaderc  = { module = "org.lwjgl:lwjgl-shaderc",  version.ref = "lwjgl3" }
 
 mokito-core = "org.mockito:mockito-core:3.12.4"
 

jme3-core/build.gradle

@@ -19,6 +19,56 @@ dependencies {
     testRuntimeOnly project(':jme3-testdata')
     testImplementation project(':jme3-desktop')
     testRuntimeOnly project(':jme3-plugins')
+
+    // Use LWJGL3 directly in core. This destroys LWJGL2 and JOGL compatibility.
+    api (libs.lwjgl3.awt) {
+        exclude group: 'org.lwjgl', module: 'lwjgl'
+    }
+    api libs.lwjgl3.base
+    api libs.lwjgl3.glfw
+    api libs.lwjgl3.jawt
+    api libs.lwjgl3.jemalloc
+    api libs.lwjgl3.openal
+    api libs.lwjgl3.opencl
+    api libs.lwjgl3.opengl
+    api libs.lwjgl3.vulkan
+    runtimeOnly(variantOf(libs.lwjgl3.base){ classifier('natives-windows') })
+    runtimeOnly(variantOf(libs.lwjgl3.base){ classifier('natives-windows-x86') })
+    runtimeOnly(variantOf(libs.lwjgl3.base){ classifier('natives-linux') })
+    runtimeOnly(variantOf(libs.lwjgl3.base){ classifier('natives-linux-arm32') })
+    runtimeOnly(variantOf(libs.lwjgl3.base){ classifier('natives-linux-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.base){ classifier('natives-macos') })
+    runtimeOnly(variantOf(libs.lwjgl3.base){ classifier('natives-macos-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.glfw){ classifier('natives-windows') })
+    runtimeOnly(variantOf(libs.lwjgl3.glfw){ classifier('natives-windows-x86') })
+    runtimeOnly(variantOf(libs.lwjgl3.glfw){ classifier('natives-linux') })
+    runtimeOnly(variantOf(libs.lwjgl3.glfw){ classifier('natives-linux-arm32') })
+    runtimeOnly(variantOf(libs.lwjgl3.glfw){ classifier('natives-linux-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.glfw){ classifier('natives-macos') })
+    runtimeOnly(variantOf(libs.lwjgl3.glfw){ classifier('natives-macos-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.jemalloc){ classifier('natives-windows') })
+    runtimeOnly(variantOf(libs.lwjgl3.jemalloc){ classifier('natives-windows-x86') })
+    runtimeOnly(variantOf(libs.lwjgl3.jemalloc){ classifier('natives-linux') })
+    runtimeOnly(variantOf(libs.lwjgl3.jemalloc){ classifier('natives-linux-arm32') })
+    runtimeOnly(variantOf(libs.lwjgl3.jemalloc){ classifier('natives-linux-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.jemalloc){ classifier('natives-macos') })
+    runtimeOnly(variantOf(libs.lwjgl3.jemalloc){ classifier('natives-macos-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.opengl){ classifier('natives-windows') })
+    runtimeOnly(variantOf(libs.lwjgl3.opengl){ classifier('natives-windows-x86') })
+    runtimeOnly(variantOf(libs.lwjgl3.opengl){ classifier('natives-linux') })
+    runtimeOnly(variantOf(libs.lwjgl3.opengl){ classifier('natives-linux-arm32') })
+    runtimeOnly(variantOf(libs.lwjgl3.opengl){ classifier('natives-linux-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.opengl){ classifier('natives-macos') })
+    runtimeOnly(variantOf(libs.lwjgl3.opengl){ classifier('natives-macos-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.openal){ classifier('natives-windows') })
+    runtimeOnly(variantOf(libs.lwjgl3.openal){ classifier('natives-windows-x86') })
+    runtimeOnly(variantOf(libs.lwjgl3.openal){ classifier('natives-linux') })
+    runtimeOnly(variantOf(libs.lwjgl3.openal){ classifier('natives-linux-arm32') })
+    runtimeOnly(variantOf(libs.lwjgl3.openal){ classifier('natives-linux-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.openal){ classifier('natives-macos') })
+    runtimeOnly(variantOf(libs.lwjgl3.openal){ classifier('natives-macos-arm64') })
+    runtimeOnly(variantOf(libs.lwjgl3.shaderc) { classifier('natives-linux') })
+
 }
 
 task updateVersionPropertiesFile {

jme3-core/src/main/java/com/jme3/bounding/BoundingBox.java

@@ -43,6 +43,9 @@
 import com.jme3.scene.Mesh;
 import com.jme3.scene.Spatial;
 import com.jme3.util.TempVars;
+import com.jme3.vulkan.mesh.VertexReader;
+import com.jme3.vulkan.util.FloatBufferModifier;
+
 import java.io.IOException;
 import java.nio.FloatBuffer;
 //import com.jme.scene.TriMesh;
@@ -129,6 +132,11 @@ public Type getType() {
      */
     @Override
     public void computeFromPoints(FloatBuffer points) {
+        containAABB(new FloatBufferModifier(points, 3));
+    }
+
+    @Override
+    public void computeFromPoints(VertexReader points) {
         containAABB(points);
     }
 
@@ -236,59 +244,37 @@ public static void checkMinMax(Vector3f min, Vector3f max, Vector3f point) {
      * @param points
      *            the list of points.
      */
-    public void containAABB(FloatBuffer points) {
+    public void containAABB(VertexReader points) {
         if (points == null) {
             return;
         }
 
-        points.rewind();
-        if (points.remaining() <= 2) // we need at least a 3 float vector
+        //points.rewind();
+        if (points.limit() == 0) // we need at least a 3 float vector
         {
             return;
         }
 
         TempVars vars = TempVars.get();
 
-        float[] tmpArray = vars.skinPositions;
-
         float minX = Float.POSITIVE_INFINITY,
                 minY = Float.POSITIVE_INFINITY,
                 minZ = Float.POSITIVE_INFINITY;
         float maxX = Float.NEGATIVE_INFINITY,
                 maxY = Float.NEGATIVE_INFINITY,
                 maxZ = Float.NEGATIVE_INFINITY;
 
-        int iterations = (int) FastMath.ceil(points.limit() / ((float) tmpArray.length));
-        for (int i = iterations - 1; i >= 0; i--) {
-            int bufLength = Math.min(tmpArray.length, points.remaining());
-            points.get(tmpArray, 0, bufLength);
-
-            for (int j = 0; j < bufLength; j += 3) {
-                vars.vect1.x = tmpArray[j];
-                vars.vect1.y = tmpArray[j + 1];
-                vars.vect1.z = tmpArray[j + 2];
-
-                if (vars.vect1.x < minX) {
-                    minX = vars.vect1.x;
-                }
-                if (vars.vect1.x > maxX) {
-                    maxX = vars.vect1.x;
-                }
-
-                if (vars.vect1.y < minY) {
-                    minY = vars.vect1.y;
-                }
-                if (vars.vect1.y > maxY) {
-                    maxY = vars.vect1.y;
-                }
-
-                if (vars.vect1.z < minZ) {
-                    minZ = vars.vect1.z;
-                }
-                if (vars.vect1.z > maxZ) {
-                    maxZ = vars.vect1.z;
-                }
-            }
+        for (int i = 0, l = points.limit(); i < l; i++) {
+//                vars.vect1.x = tmpArray[j];
+//                vars.vect1.y = tmpArray[j + 1];
+//                vars.vect1.z = tmpArray[j + 2];
+            points.getVector3(i, 0, vars.vect1);
+            minX = Math.min(minX, vars.vect1.x);
+            minY = Math.min(minY, vars.vect1.y);
+            minZ = Math.min(minZ, vars.vect1.z);
+            maxX = Math.max(maxX, vars.vect1.x);
+            maxY = Math.max(maxY, vars.vect1.y);
+            maxZ = Math.max(maxZ, vars.vect1.z);
         }
 
         vars.release();

jme3-core/src/main/java/com/jme3/bounding/BoundingSphere.java

@@ -39,8 +39,12 @@
 import com.jme3.export.JmeImporter;
 import com.jme3.math.*;
 import com.jme3.scene.Spatial;
-import com.jme3.util.BufferUtils;
 import com.jme3.util.TempVars;
+import com.jme3.vulkan.mesh.VertexReader;
+import com.jme3.vulkan.mesh.VertexWriter;
+import com.jme3.vulkan.util.FloatBufferModifier;
+import org.lwjgl.system.MemoryStack;
+
 import java.io.IOException;
 import java.nio.FloatBuffer;
 import java.util.Objects;
@@ -120,6 +124,11 @@ public void setRadius(float radius) {
      */
     @Override
     public void computeFromPoints(FloatBuffer points) {
+        calcWelzl(new FloatBufferModifier(points, 3));
+    }
+
+    @Override
+    public void computeFromPoints(VertexReader points) {
         calcWelzl(points);
     }
 
@@ -184,15 +193,17 @@ public void computeFromTris(Triangle[] tris, int start, int end) {
      * @param points
      *            The points to calculate the minimum bounds from.
      */
-    public void calcWelzl(FloatBuffer points) {
+    public void calcWelzl(VertexReader points) {
         if (center == null) {
             center = new Vector3f();
         }
-        FloatBuffer buf = BufferUtils.createFloatBuffer(points.limit());
-        points.rewind();
-        buf.put(points);
-        buf.flip();
-        recurseMini(buf, buf.limit() / 3, 0, 0);
+        assert points.components() == 3;
+        try (MemoryStack stack = MemoryStack.stackPush()) {
+            FloatBuffer buf = stack.mallocFloat(points.limit() * 3);
+            points.getFloats(0, 0, buf);
+            FloatBufferModifier bufMod = new FloatBufferModifier(buf, 3);
+            recurseMini(bufMod, bufMod.limit(), 0, 0);
+        }
     }
 
     /**
@@ -210,7 +221,7 @@ public void calcWelzl(FloatBuffer points) {
      *            A variable simulating pointer arithmetic from C++, and offset
      *            in <code>points</code>.
      */
-    private void recurseMini(FloatBuffer points, int p, int b, int ap) {
+    private void recurseMini(VertexWriter points, int p, int b, int ap) {
         //TempVars vars = TempVars.get();
 
         Vector3f tempA = new Vector3f(); //vars.vect1;
@@ -225,36 +236,51 @@ private void recurseMini(FloatBuffer points, int p, int b, int ap) {
                 break;
             case 1:
                 this.radius = 1f - RADIUS_EPSILON;
-                BufferUtils.populateFromBuffer(center, points, ap - 1);
+                //BufferUtils.populateFromBuffer(center, points, ap - 1);
+                points.getVector3(ap - 1, 0, center);
                 break;
             case 2:
-                BufferUtils.populateFromBuffer(tempA, points, ap - 1);
-                BufferUtils.populateFromBuffer(tempB, points, ap - 2);
+                //BufferUtils.populateFromBuffer(tempA, points, ap - 1);
+                //BufferUtils.populateFromBuffer(tempB, points, ap - 2);
+                points.getVector3(ap - 1, 0, tempA);
+                points.getVector3(ap - 2, 0, tempB);
                 setSphere(tempA, tempB);
                 break;
             case 3:
-                BufferUtils.populateFromBuffer(tempA, points, ap - 1);
-                BufferUtils.populateFromBuffer(tempB, points, ap - 2);
-                BufferUtils.populateFromBuffer(tempC, points, ap - 3);
+//                BufferUtils.populateFromBuffer(tempA, points, ap - 1);
+//                BufferUtils.populateFromBuffer(tempB, points, ap - 2);
+//                BufferUtils.populateFromBuffer(tempC, points, ap - 3);
+                points.getVector3(ap - 1, 0, tempA);
+                points.getVector3(ap - 2, 0, tempB);
+                points.getVector3(ap - 3, 0, tempC);
                 setSphere(tempA, tempB, tempC);
                 break;
             case 4:
-                BufferUtils.populateFromBuffer(tempA, points, ap - 1);
-                BufferUtils.populateFromBuffer(tempB, points, ap - 2);
-                BufferUtils.populateFromBuffer(tempC, points, ap - 3);
-                BufferUtils.populateFromBuffer(tempD, points, ap - 4);
+//                BufferUtils.populateFromBuffer(tempA, points, ap - 1);
+//                BufferUtils.populateFromBuffer(tempB, points, ap - 2);
+//                BufferUtils.populateFromBuffer(tempC, points, ap - 3);
+//                BufferUtils.populateFromBuffer(tempD, points, ap - 4);
+                points.getVector3(ap - 1, 0, tempA);
+                points.getVector3(ap - 2, 0, tempB);
+                points.getVector3(ap - 3, 0, tempC);
+                points.getVector3(ap - 4, 0, tempD);
                 setSphere(tempA, tempB, tempC, tempD);
                 //vars.release();
                 return;
         }
         for (int i = 0; i < p; i++) {
-            BufferUtils.populateFromBuffer(tempA, points, i + ap);
+            //BufferUtils.populateFromBuffer(tempA, points, i + ap);
+            points.getVector3(i + ap, 0, tempA);
             if (tempA.distanceSquared(center) - (radius * radius) > RADIUS_EPSILON - 1f) {
                 for (int j = i; j > 0; j--) {
-                    BufferUtils.populateFromBuffer(tempB, points, j + ap);
-                    BufferUtils.populateFromBuffer(tempC, points, j - 1 + ap);
-                    BufferUtils.setInBuffer(tempC, points, j + ap);
-                    BufferUtils.setInBuffer(tempB, points, j - 1 + ap);
+//                    BufferUtils.populateFromBuffer(tempB, points, j + ap);
+//                    BufferUtils.populateFromBuffer(tempC, points, j - 1 + ap);
+                    points.getVector3(j + ap, 0, tempB);
+                    points.getVector3(j - 1 + ap, 0, tempC);
+//                    BufferUtils.setInBuffer(tempC, points, j + ap);
+//                    BufferUtils.setInBuffer(tempB, points, j - 1 + ap);
+                    points.putVector3(j + ap, 0, tempC);
+                    points.putVector3(j - 1 + ap, 0, tempB);
                 }
                 recurseMini(points, i, b + 1, ap + 1);
             }
@@ -274,7 +300,7 @@ private void recurseMini(FloatBuffer points, int p, int b, int ap) {
      *            The 3rd point inside the sphere.
      * @param C
      *            The 4th point inside the sphere.
-     * @see #calcWelzl(java.nio.FloatBuffer)
+     * @see #calcWelzl(VertexReader) 
      */
     private void setSphere(Vector3f O, Vector3f A, Vector3f B, Vector3f C) {
         Vector3f a = A.subtract(O);
@@ -307,7 +333,7 @@ private void setSphere(Vector3f O, Vector3f A, Vector3f B, Vector3f C) {
      *            The 2nd point inside the sphere.
      * @param B
      *            The 3rd point inside the sphere.
-     * @see #calcWelzl(java.nio.FloatBuffer)
+     * @see #calcWelzl(VertexReader) 
      */
     private void setSphere(Vector3f O, Vector3f A, Vector3f B) {
         Vector3f a = A.subtract(O);
@@ -335,7 +361,7 @@ private void setSphere(Vector3f O, Vector3f A, Vector3f B) {
      *            The 1st point inside the sphere.
      * @param A
      *            The 2nd point inside the sphere.
-     * @see #calcWelzl(java.nio.FloatBuffer)
+     * @see #calcWelzl(VertexReader) 
      */
     private void setSphere(Vector3f O, Vector3f A) {
         radius = FastMath.sqrt(((A.x - O.x) * (A.x - O.x) + (A.y - O.y)

jme3-core/src/main/java/com/jme3/bounding/BoundingVolume.java

@@ -38,6 +38,8 @@
 import com.jme3.export.Savable;
 import com.jme3.math.*;
 import com.jme3.util.TempVars;
+import com.jme3.vulkan.mesh.VertexReader;
+
 import java.io.IOException;
 import java.nio.FloatBuffer;
 import java.util.Objects;
@@ -149,6 +151,8 @@ public final BoundingVolume transform(Transform trans) {
      */
     public abstract void computeFromPoints(FloatBuffer points);
 
+    public abstract void computeFromPoints(VertexReader points);
+
     /**
      * <code>merge</code> combines two bounding volumes into a single bounding
      * volume that contains both this bounding volume and the parameter volume.