add uniforms; fix native crash and memory leaks

Author: codex128

hs_err_pid78128.log

@@ -2560,4 +2560,16 @@ public Matrix4f clone() {
             throw new AssertionError(); // can not happen
         }
     }
+
+    /**
+     * Flips the sign of the Y scalar component (m11) to make Vulkan renderings
+     * appear upright in clip space.
+     *
+     * @return this instance
+     */
+    public Matrix4f flipYScalarForVulkan() {
+        m11 = -m11;
+        return this;
+    }
+
 }

jme3-core/src/main/java/com/jme3/math/Matrix4f.java

@@ -1248,7 +1248,6 @@ public void updateViewProjection() {
         if (overrideProjection) {
             viewProjectionMatrix.set(projectionMatrixOverride).multLocal(viewMatrix);
         } else {
-            //viewProjectionMatrix.set(viewMatrix).multLocal(projectionMatrix);
             viewProjectionMatrix.set(projectionMatrix).multLocal(viewMatrix);
         }
     }
@@ -1358,7 +1357,9 @@ public void onFrustumChange() {
 
         projectionMatrix.fromFrustum(frustumNear, frustumFar, frustumLeft, frustumRight,
                 frustumTop, frustumBottom, parallelProjection);
-//        projectionMatrix.transposeLocal();
+
+        // for Vulkan rendering
+        projectionMatrix.flipYScalarForVulkan();
 
         // The frame is affected by the frustum values
         // update it as well

jme3-core/src/main/java/com/jme3/renderer/Camera.java

@@ -1,5 +1,6 @@
 package com.jme3.renderer.vulkan;
 
+import com.jme3.util.natives.Native;
 import org.lwjgl.PointerBuffer;
 import org.lwjgl.system.MemoryStack;
 import org.lwjgl.system.MemoryUtil;
@@ -127,6 +128,10 @@ public static boolean isBitSet(int n, int bit) {
         return (n & bit) > 0;
     }
 
+    public static int sharingMode(boolean concurrent) {
+        return concurrent ? VK_SHARING_MODE_CONCURRENT : VK_SHARING_MODE_EXCLUSIVE;
+    }
+
     public static <T extends StructBuffer<E, T>, E extends Struct<E>> T accumulate(Collection<E> collection, IntFunction<T> allocate) {
         T buffer = allocate.apply(collection.size());
         for (E e : collection) {
@@ -135,6 +140,26 @@ public static <T extends StructBuffer<E, T>, E extends Struct<E>> T accumulate(C
         return buffer.rewind();
     }
 
+    public static LongBuffer accumulate(MemoryStack stack, Native<Long>... natives) {
+        LongBuffer buf = stack.mallocLong(natives.length);
+        for (int i = 0; i < buf.limit(); i++) {
+            buf.put(i, natives[i].getNativeObject());
+        }
+        return buf;
+    }
+
+    public static int[] getTransferArguments(int srcLayout, int dstLayout) {
+        // output array format: {srcAccessMask, dstAccessMask, srcStage, dstStage}
+        if (srcLayout == VK_IMAGE_LAYOUT_UNDEFINED && dstLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
+            return new int[] {0, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT};
+        } else if (srcLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && dstLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
+            return new int[] {VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
+                    VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT};
+        } else {
+            throw new UnsupportedOperationException("Unsupported layer transitions.");
+        }
+    }
+
     public static class NativeIterator <T> implements Iterable<T>, Iterator<T> {
 
         private final PointerBuffer pointers;

jme3-core/src/main/java/com/jme3/renderer/vulkan/VulkanUtils.java

@@ -3,10 +3,7 @@
 import java.lang.ref.PhantomReference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
@@ -39,16 +36,20 @@ public int flush() {
         int flushed = 0;
         for (NativeRef ref; (ref = (NativeRef)unreachable.poll()) != null;) {
             ref.destroy();
+            refMap.remove(ref.id);
             flushed++;
         }
+        if (flushed > 0) {
+            refMap.values().removeIf(NativeRef::isDestroyed);
+        }
         return flushed;
     }
 
     @Override
     public int clear() {
         int size = refMap.size();
         for (NativeRef ref : refMap.values()) {
-            ref.destroyNoRemove();
+            ref.destroy();
         }
         refMap.clear();
         return size;
@@ -57,10 +58,10 @@ public int clear() {
     public class NativeRef extends WeakReference<Native> implements NativeReference {
 
         private final long id;
-        private final Runnable destroyer;
         private final WeakReference<Native> weakRef;
         private final AtomicBoolean active = new AtomicBoolean(true);
         private final Collection<NativeReference> dependents = new ArrayList<>();
+        private Runnable destroyer;
 
         private NativeRef(long id, Native referent, ReferenceQueue<Native> q) {
             super(referent, q);
@@ -72,33 +73,43 @@ private NativeRef(long id, Native referent, ReferenceQueue<Native> q) {
         @Override
         public void destroy() {
             if (active.getAndSet(false)) {
+                for (NativeReference ref : dependents) {
+                    ref.destroy();
+                }
                 dependents.clear();
-                destroyNoRemove();
-                refMap.remove(id, this);
+                destroyer.run();
+                Native referent = weakRef.get();
+                if (referent != null) {
+                    referent.prematureNativeDestruction();
+                }
             }
         }
 
         @Override
         public void addDependent(NativeReference reference) {
+            if (isDestroyed()) {
+                throw new IllegalStateException("Cannot add dependent to destroyed resource.");
+            }
             dependents.add(reference);
         }
 
-        private long getId() {
-            return id;
+        @Override
+        public boolean isDestroyed() {
+            return !active.get();
         }
 
-        private void destroyNoRemove() {
-            for (NativeReference ref : dependents) {
-                ref.destroy();
-            }
-            dependents.clear();
-            destroyer.run();
-            Native referent = weakRef.get();
-            if (referent != null) {
-                referent.prematureNativeDestruction();
+        @Override
+        public void refresh() {
+            Native obj = weakRef.get();
+            if (obj != null) {
+                destroyer = obj.createNativeDestroyer();
             }
         }
 
+        private long getId() {
+            return id;
+        }
+
     }
 
 }

jme3-core/src/main/java/com/jme3/util/natives/BasicNativeManager.java

@@ -6,4 +6,8 @@ public interface NativeReference {
 
     void addDependent(NativeReference reference);
 
+    boolean isDestroyed();
+
+    void refresh();
+
 }