Vulkan

VulkanDesign.txt

@@ -0,0 +1,7 @@
+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-android/src/main/java/com/jme3/app/state/VideoRecorderAppState.java

@@ -43,7 +43,7 @@
 import com.jme3.system.JmeSystem;
 import com.jme3.system.Timer;
 import com.jme3.texture.FrameBuffer;
-import com.jme3.texture.Image;
+import com.jme3.texture.GlImage;
 import com.jme3.util.AndroidScreenshots;
 import com.jme3.util.BufferUtils;
 import java.io.File;
@@ -241,7 +241,7 @@ public void addImage(Renderer renderer, FrameBuffer out) {
                 final WorkItem item = freeItems.take();
                 usedItems.add(item);
                 item.buffer.clear();
-                renderer.readFrameBufferWithFormat(out, item.buffer, Image.Format.BGRA8);
+                renderer.readFrameBufferWithFormat(out, item.buffer, GlImage.Format.BGRA8);
                 executor.submit(new Callable<Void>() {
 
                     @Override

jme3-android/src/main/java/com/jme3/texture/plugins/AndroidBufferImageLoader.java

@@ -37,7 +37,7 @@
 import com.jme3.asset.AssetInfo;
 import com.jme3.asset.AssetLoader;
 import com.jme3.asset.TextureKey;
-import com.jme3.texture.Image;
+import com.jme3.texture.GlImage;
 import com.jme3.texture.image.ColorSpace;
 import com.jme3.util.BufferUtils;
 import java.io.IOException;
@@ -72,7 +72,7 @@ private static void convertARGBtoABGR(int[] src, int srcOff, int[] dst, int dstO
     @Override
     public Object load(AssetInfo assetInfo) throws IOException {
         Bitmap bitmap;
-        Image.Format format;
+        GlImage.Format format;
         int bpp;
 
         BitmapFactory.Options options = new BitmapFactory.Options();
@@ -102,15 +102,15 @@ public Object load(AssetInfo assetInfo) throws IOException {
 
         switch (bitmap.getConfig()) {
             case ALPHA_8:
-                format = Image.Format.Alpha8;
+                format = GlImage.Format.Alpha8;
                 bpp = 1;
                 break;
             case ARGB_8888:
-                format = Image.Format.RGBA8;
+                format = GlImage.Format.RGBA8;
                 bpp = 4;
                 break;
             case RGB_565:
-                format = Image.Format.RGB565;
+                format = GlImage.Format.RGB565;
                 bpp = 2;
                 break;
             default:
@@ -124,7 +124,7 @@ public Object load(AssetInfo assetInfo) throws IOException {
 
         ByteBuffer data = BufferUtils.createByteBuffer(bitmap.getWidth() * bitmap.getHeight() * bpp);
 
-        if (format == Image.Format.RGBA8) {
+        if (format == GlImage.Format.RGBA8) {
             int[] pixelData = new int[width * height];
             bitmap.getPixels(pixelData, 0,  width, 0, 0,          width,  height);
 
@@ -163,7 +163,7 @@ public Object load(AssetInfo assetInfo) throws IOException {
 
         bitmap.recycle();
 
-        Image image = new Image(format, width, height, data, ColorSpace.sRGB);
+        GlImage image = new GlImage(format, width, height, data, ColorSpace.sRGB);
 
         return image;
     }

jme3-android/src/main/java/com/jme3/texture/plugins/AndroidNativeImageLoader.java

@@ -34,7 +34,7 @@
 import com.jme3.asset.AssetInfo;
 import com.jme3.asset.AssetLoader;
 import com.jme3.asset.TextureKey;
-import com.jme3.texture.Image;
+import com.jme3.texture.GlImage;
 import java.io.IOException;
 import java.io.InputStream;
 
@@ -52,10 +52,10 @@ public class AndroidNativeImageLoader  implements AssetLoader {
          System.loadLibrary("decodejme");
     }
 
-    private static native Image load(InputStream in, boolean flipY, byte[] tmpArray) throws IOException;
+    private static native GlImage load(InputStream in, boolean flipY, byte[] tmpArray) throws IOException;
 
     @Override
-    public Image load(AssetInfo info) throws IOException {
+    public GlImage load(AssetInfo info) throws IOException {
         boolean flip = ((TextureKey) info.getKey()).isFlipY();
         try (final InputStream in = info.openStream()) {
             return load(in, flip, tmpArray);

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/asset/AssetManager.java

@@ -42,7 +42,7 @@
 import com.jme3.scene.Spatial;
 import com.jme3.scene.plugins.OBJLoader;
 import com.jme3.shader.ShaderGenerator;
-import com.jme3.texture.Texture;
+import com.jme3.texture.GlTexture;
 import com.jme3.texture.plugins.TGALoader;
 import java.io.IOException;
 import java.io.InputStream;
@@ -270,7 +270,7 @@ public default List<ClassLoader> getClassLoaders() {
      *
      * @see AssetManager#loadAsset(com.jme3.asset.AssetKey)
      */
-    public Texture loadTexture(TextureKey key);
+    public GlTexture loadTexture(TextureKey key);
 
     /**
      * Loads texture file, supported types are BMP, JPG, PNG, GIF,
@@ -283,7 +283,7 @@ public default List<ClassLoader> getClassLoaders() {
      *
      * @see AssetManager#loadAsset(com.jme3.asset.AssetKey)
      */
-    public Texture loadTexture(String name);
+    public GlTexture loadTexture(String name);
 
     /**
      * Load audio file, supported types are WAV or OGG.

jme3-core/src/main/java/com/jme3/asset/DesktopAssetManager.java

@@ -44,7 +44,7 @@
 import com.jme3.shader.Glsl300ShaderGenerator;
 import com.jme3.shader.ShaderGenerator;
 import com.jme3.system.JmeSystem;
-import com.jme3.texture.Texture;
+import com.jme3.texture.GlTexture;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
@@ -405,7 +405,7 @@ public Object loadAsset(String name) {
     }
 
     @Override
-    public Texture loadTexture(TextureKey key) {
+    public GlTexture loadTexture(TextureKey key) {
         return loadAsset(key);
     }
 
@@ -415,7 +415,7 @@ public Material loadMaterial(String name) {
     }
 
     @Override
-    public Texture loadTexture(String name) {
+    public GlTexture loadTexture(String name) {
         TextureKey key = new TextureKey(name, true);
         key.setGenerateMips(true);
         return loadTexture(key);

jme3-core/src/main/java/com/jme3/asset/TextureKey.java

@@ -31,35 +31,35 @@
  */
 package com.jme3.asset;
 
-import com.jme3.texture.Texture.Type;
+import com.jme3.texture.GlTexture.Type;
 import com.jme3.asset.cache.AssetCache;
 import com.jme3.asset.cache.WeakRefCloneAssetCache;
 import com.jme3.export.InputCapsule;
 import com.jme3.export.JmeExporter;
 import com.jme3.export.JmeImporter;
 import com.jme3.export.OutputCapsule;
-import com.jme3.texture.Image;
-import com.jme3.texture.Texture;
+import com.jme3.texture.GlImage;
+import com.jme3.texture.GlTexture;
 import com.jme3.texture.TextureProcessor;
 import java.io.IOException;
 
 /**
  * Used to load textures from image files such as JPG or PNG.
- * Note that texture loaders actually load the asset as an {@link Image}
- * object, which is then converted to a {@link Texture} in the
+ * Note that texture loaders actually load the asset as an {@link GlImage}
+ * object, which is then converted to a {@link GlTexture} in the
  * {@link TextureProcessor#postProcess(com.jme3.asset.AssetKey, java.lang.Object)}
  * method. Since textures are cloneable smart assets, the texture stored
  * in the cache will be collected when all clones of the texture become
  * unreachable.
  *
  * @author Kirill Vainer
  */
-public class TextureKey extends AssetKey<Texture> {
+public class TextureKey extends AssetKey<GlTexture> {
 
     private boolean generateMips;
     private boolean flipY;
     private int anisotropy;
-    private Texture.Type textureTypeHint = Texture.Type.TwoDimensional;
+    private GlTexture.Type textureTypeHint = GlTexture.Type.TwoDimensional;
 
     public TextureKey(String name, boolean flipY) {
         super(name);
@@ -213,7 +213,7 @@ public void read(JmeImporter im) throws IOException {
             // Backwards compat
             textureTypeHint = Type.CubeMap;
         } else {
-            textureTypeHint = ic.readEnum("tex_type", Texture.Type.class, Type.TwoDimensional);
+            textureTypeHint = ic.readEnum("tex_type", GlTexture.Type.class, Type.TwoDimensional);
         }
     }
 }

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();