migrated instance, device, surface, and swapchain to new builder architecture

Author: codex128

jme3-lwjgl3/src/main/java/com/jme3/vulkan/SimplePhysicalDevice.java

@@ -0,0 +1,82 @@
+package com.jme3.vulkan;
+
+import com.jme3.vulkan.devices.LogicalDevice;
+import com.jme3.vulkan.devices.PhysicalDevice;
+import org.lwjgl.system.MemoryStack;
+import org.lwjgl.vulkan.KHRSurface;
+import org.lwjgl.vulkan.VK13;
+import org.lwjgl.vulkan.VkDeviceQueueCreateInfo;
+import org.lwjgl.vulkan.VkQueueFamilyProperties;
+
+import java.nio.IntBuffer;
+
+public class SimplePhysicalDevice extends PhysicalDevice {
+
+    private final Surface surface;
+    private Integer graphicsIndex, presentIndex;
+    private Queue graphics, present;
+
+    public SimplePhysicalDevice(VulkanInstance instance, Surface surface, long id) {
+        super(instance, id);
+        this.surface = surface;
+    }
+
+    @Override
+    protected boolean populateQueueFamilyIndices() {
+        try (MemoryStack stack = MemoryStack.stackPush()) {
+            VkQueueFamilyProperties.Buffer properties = getQueueFamilyProperties(stack);
+            IntBuffer ibuf = stack.callocInt(1);
+            for (int i = 0; i < properties.limit(); i++) {
+                VkQueueFamilyProperties props = properties.get(i);
+                if (graphicsIndex == null && (props.queueFlags() & VK13.VK_QUEUE_GRAPHICS_BIT) > 0) {
+                    graphicsIndex = i;
+                } else if (presentIndex == null) {
+                    KHRSurface.vkGetPhysicalDeviceSurfaceSupportKHR(
+                            getPhysicalDevice(), i, surface.getNativeObject(), ibuf);
+                    if (ibuf.get(0) == VK13.VK_TRUE) {
+                        presentIndex = i;
+                    }
+                }
+                if (graphicsIndex != null && presentIndex != null) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    protected VkDeviceQueueCreateInfo.Buffer createQueueFamilyInfo(MemoryStack stack) {
+        VkDeviceQueueCreateInfo.Buffer create = VkDeviceQueueCreateInfo.calloc(2, stack); // one element for each queue
+        create.get(0).sType(VK13.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO)
+                .queueFamilyIndex(graphicsIndex)
+                .pQueuePriorities(stack.floats(1f));
+        create.get(1).sType(VK13.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO)
+                .queueFamilyIndex(presentIndex)
+                .pQueuePriorities(stack.floats(1f));
+        return create;
+    }
+
+    @Override
+    protected void createQueues(LogicalDevice device) {
+        graphics = new Queue(device, graphicsIndex, 0);
+        present = new Queue(device, presentIndex, 0);
+    }
+
+    public Integer getGraphicsIndex() {
+        return graphicsIndex;
+    }
+
+    public Integer getPresentIndex() {
+        return presentIndex;
+    }
+
+    public Queue getGraphics() {
+        return graphics;
+    }
+
+    public Queue getPresent() {
+        return present;
+    }
+
+}

jme3-lwjgl3/src/main/java/com/jme3/vulkan/VulkanObject.java

@@ -0,0 +1,39 @@
+package com.jme3.vulkan;
+
+import com.jme3.util.natives.Native;
+import com.jme3.util.natives.NativeReference;
+import org.lwjgl.system.MemoryStack;
+
+public abstract class VulkanObject <T> implements Native<T> {
+
+    protected T object;
+    protected NativeReference ref;
+
+    @Override
+    public T getNativeObject() {
+        return object;
+    }
+
+    @Override
+    public void prematureNativeDestruction() {}
+
+    @Override
+    public NativeReference getNativeReference() {
+        return ref;
+    }
+
+    public static abstract class Builder <T extends VulkanObject> implements AutoCloseable {
+
+        protected final MemoryStack stack = MemoryStack.stackPush();
+
+        @Override
+        public void close() {
+            build();
+            stack.pop();
+        }
+
+        protected abstract void build();
+
+    }
+
+}

jme3-lwjgl3/src/main/java/com/jme3/vulkan/app/VulkanApplication.java

@@ -0,0 +1,18 @@
+package com.jme3.vulkan.app;
+
+import com.jme3.app.SimpleApplication;
+import com.jme3.vulkan.VulkanInstance;
+import org.lwjgl.system.MemoryStack;
+
+public class VulkanApplication extends SimpleApplication {
+
+    protected VulkanInstance instance;
+
+    @Override
+    public void simpleInitApp() {
+        try (MemoryStack stack = MemoryStack.stackPush()) {
+
+        }
+    }
+
+}

jme3-lwjgl3/src/main/java/com/jme3/vulkan/devices/DeviceExtension.java

@@ -0,0 +1,65 @@
+package com.jme3.vulkan.devices;
+
+import java.util.Objects;
+import java.util.Set;
+
+public class DeviceExtension {
+
+    private final String name;
+    private final Float success, fail;
+
+    public DeviceExtension(String name) {
+        this(name, 1f, null);
+    }
+
+    public DeviceExtension(String name, Float success) {
+        this(name, success, null);
+    }
+
+    public DeviceExtension(String name, Float success, Float fail) {
+        this.name = name;
+        this.success = success;
+        this.fail = fail;
+    }
+
+    public Float evaluate(Set<String> extensions) {
+        return extensions.contains(name) ? success : fail;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Float getSuccessWeight() {
+        return success;
+    }
+
+    public Float getFailWeight() {
+        return fail;
+    }
+
+    public boolean isRejectOnFailure() {
+        return fail == null;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) return false;
+        DeviceExtension that = (DeviceExtension) o;
+        return Objects.equals(name, that.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(name);
+    }
+
+    public static DeviceExtension critical(String name) {
+        return new DeviceExtension(name, 1f, null);
+    }
+
+    public static DeviceExtension optional(String name, float successWeight) {
+        return new DeviceExtension(name, successWeight);
+    }
+
+}

jme3-lwjgl3/src/main/java/com/jme3/vulkan/devices/DeviceFeature.java

@@ -0,0 +1,24 @@
+package com.jme3.vulkan.devices;
+
+import org.lwjgl.vulkan.VkPhysicalDeviceFeatures;
+
+public interface DeviceFeature {
+
+    void enableFeature(VkPhysicalDeviceFeatures features);
+
+    Float evaluateFeatureSupport(VkPhysicalDeviceFeatures features);
+
+    static DeviceFeature anisotropy(Float pass, boolean rejectOnFail) {
+        return new DeviceFeature() {
+            @Override
+            public void enableFeature(VkPhysicalDeviceFeatures features) {
+                features.samplerAnisotropy(true);
+            }
+            @Override
+            public Float evaluateFeatureSupport(VkPhysicalDeviceFeatures features) {
+                return features.samplerAnisotropy() ? pass : (rejectOnFail ? null : 0f);
+            }
+        };
+    }
+
+}

jme3-lwjgl3/src/main/java/com/jme3/vulkan/devices/DeviceProperty.java

@@ -0,0 +1,13 @@
+package com.jme3.vulkan.devices;
+
+import org.lwjgl.vulkan.VkPhysicalDeviceProperties;
+
+public interface DeviceProperty {
+
+    Float evaluateDeviceProperties(VkPhysicalDeviceProperties properties);
+
+    static DeviceProperty maxAnisotropy(float threshold) {
+        return p -> p.limits().maxSamplerAnisotropy() >= threshold ? 0f : null;
+    }
+
+}

jme3-lwjgl3/src/main/java/com/jme3/vulkan/devices/DeviceWeights.java

@@ -0,0 +1,49 @@
+package com.jme3.vulkan.devices;
+
+public class DeviceWeights {
+
+    public static final Float SUCCESS = 1f;
+    public static final Float FAILURE = -1f;
+    public static final Float REJECTION = null;
+
+    public static Float success(float weight) {
+        return weight;
+    }
+
+    public static Float failure(float weight) {
+        return -weight;
+    }
+
+    public static Float successOrReject(boolean success) {
+        return successOrReject(success, SUCCESS);
+    }
+
+    public static Float successOrReject(boolean success, float weight) {
+        return success ? Float.valueOf(weight) : REJECTION;
+    }
+
+    public static Float successOrFail(boolean success) {
+        return successOrFail(success, SUCCESS, FAILURE);
+    }
+
+    public static Float successOrFail(boolean success, float weight) {
+        return success ? weight : -weight;
+    }
+
+    public static Float successOrFail(boolean success, float successWeight, float failWeight) {
+        return success ? successWeight : -failWeight;
+    }
+
+    public static boolean isSuccess(Float weight) {
+        return weight != null && weight >= 0f;
+    }
+
+    public static boolean isFailure(Float weight) {
+        return weight == null || weight < 0f;
+    }
+
+    public static boolean isRejection(Float weight) {
+        return weight == null;
+    }
+
+}