up

Author: elect86

src/main/kotlin/vkk/_10/api/Device_vk10.kt

@@ -79,11 +79,16 @@ interface Device_vk10 : Pointer {
     infix fun createCommandPool(createInfo: CommandPoolCreateInfo): VkCommandPool =
             stak { it createCommandPool createInfo }
 
-//    infix fun MemoryStack.createCommandPoolUnique(createInfo: CommandPoolCreateInfo): VkCommandPool =
-//            createCommandPool(createInfo).also { vk.cleaner.register() }
-//
-//    infix fun createCommandPoolUnique(createInfo: CommandPoolCreateInfo): VkCommandPool =
-//            createCommandPool(createInfo)
+    infix fun MemoryStack.createCommandPoolUnique(createInfo: CommandPoolCreateInfo): VkCommandPool {
+        val commandPool = createCommandPool(createInfo)
+        vk.cleaner.register(commandPool) {
+            callPJPV(this@Device_vk10.adr, commandPool.L, NULL, capabilities.vkDestroyCommandPool)
+        }
+        return commandPool
+    }
+
+    infix fun createCommandPoolUnique(createInfo: CommandPoolCreateInfo): VkCommandPool =
+            stak { it createCommandPoolUnique createInfo }
 
     // --- [ vkCreateComputePipelines ] ---
 

src/main/kotlin/vkk/entities/objects.kt

@@ -39,6 +39,10 @@ inline class VkBufferView(val L: Long = VK_NULL_HANDLE) {
     }
 }
 
+//fun VkUniqueCommandPool(long: Long = VK_NULL_HANDLE): VkUniqueCommandPool = VkUniqueCommandPool(L)
+//
+//inline class VkUniqueCommandPool(val L: Long = VK_NULL_HANDLE)
+
 inline class VkCommandPool(val L: Long = VK_NULL_HANDLE) {
     val isValid get() = L != VK_NULL_HANDLE
     val isInvalid get() = L == VK_NULL_HANDLE

src/main/kotlin/vkk/identifiers/CommandBuffer.kt

@@ -1,6 +1,8 @@
 package vkk.identifiers
 
 import kool.Ptr
+import kool.adr
+import org.lwjgl.system.JNI
 import org.lwjgl.system.MemoryStack
 import vkk.VkQueryControlFlags
 import vkk.VkSubpassContents
@@ -10,8 +12,17 @@ import vkk._10.structs.RenderPassBeginInfo
 import vkk._11.api.CommandBuffer_vk11
 import vkk.entities.VkQueryPool
 
+class UniqueCommandBuffer(handle: Ptr, device: Device) : CommandBuffer(handle, device) {
+//    val address = adr
+//    val function = capabilities.vkDestroy
+//    vk.cleaner.register(this) {
+//        JNI.callPJPV(address, commandPool.L, commandBufferCount, pCommandBuffers, capabilities.vkFreeCommandBuffers)
+//        println("device gc'ed")
+//    }
+}
+
 /** Wraps a Vulkan command buffer handle.  */
-class CommandBuffer
+open class CommandBuffer
 /**
  * Creates a `VkCommandBuffer` using the specified native handle and device.
  *
@@ -20,8 +31,7 @@ class CommandBuffer
  */
 constructor(handle: Ptr,
             /** Returns the device on which this `VkCommandBuffer` was created.  */
-            val device: Device
-)
+            val device: Device)
 
     : DispatchableHandleDevice(handle, device.capabilities),
 

src/main/kotlin/vkk/identifiers/Device.kt

@@ -73,6 +73,32 @@ open class Device(handle: Ptr,
     infix fun allocateCommandBuffers(allocateInfo: CommandBufferAllocateInfo): Array<CommandBuffer> =
             stak { it allocateCommandBuffers allocateInfo }
 
+    // Unique
+
+    infix fun MemoryStack.allocateCommandBufferUnique(allocateInfo: CommandBufferAllocateInfo): UniqueCommandBuffer =
+            framed { UniqueCommandBuffer(this.pointerAdr { nAllocateCommandBuffers(allocateInfo write this, it).check() }, this@Device) }
+
+    infix fun allocateCommandBufferUnique(allocateInfo: CommandBufferAllocateInfo): CommandBuffer =
+            stak { it allocateCommandBufferUnique allocateInfo }
+
+
+    infix fun MemoryStack.allocateCommandBuffersUnique(allocateInfo: CommandBufferAllocateInfo): Array<UniqueCommandBuffer> =
+            framed {
+                val pCommandBuffers = this.mPointer(allocateInfo.commandBufferCount)
+                nAllocateCommandBuffers(allocateInfo write this, pCommandBuffers.adr)
+//                val address = [email protected]
+                val array = Array(allocateInfo.commandBufferCount) {
+                    UniqueCommandBuffer(memGetAddress(pCommandBuffers[it]), this@Device)
+                }
+//                vk.cleaner.register(array) {
+//                    callPJPV(address, allocateInfo.commandPool.L, array.size, pCommandBuffers, capabilities.vkFreeCommandBuffers)
+//                }
+                array
+            }
+
+    infix fun allocateCommandBuffersUnique(allocateInfo: CommandBufferAllocateInfo): Array<UniqueCommandBuffer> =
+            stak { it allocateCommandBuffersUnique allocateInfo }
+
     // --- [ vkGetDeviceQueue ] ---
 
     fun MemoryStack.getQueue(queueFamilyIndex: Int, queueIndex: Int = 0): Queue =

src/test/kotlin/tests/01 initInstance.kt

@@ -26,5 +26,14 @@ class `01 initInstance` : StringSpec() {
                 // Note: No need to explicitly destroy the instance, as the corresponding destroy function is
                 // called by the destructor of the UniqueInstance on leaving this scope.
             }
+//        "a" {
+//            for (i in 1..10000) {
+//                val a = IntArray(10000)
+//                try {
+//                    Thread.sleep(1)
+//                } catch (e: InterruptedException) {
+//                }
+//            }
+//        }
     }
 }

src/test/kotlin/tests/04 initCommandBuffer.kt

@@ -2,6 +2,9 @@ package tests
 
 import io.kotlintest.specs.StringSpec
 import main.isNotCI
+import vkk.VkCommandBufferLevel
+import vkk._10.structs.CommandBufferAllocateInfo
+import vkk._10.structs.CommandPoolCreateInfo
 import vkk.vu
 
 class `04 initCommandBuffer` : StringSpec() {
@@ -25,10 +28,18 @@ class `04 initCommandBuffer` : StringSpec() {
                 /* VULKAN_HPP_KEY_START */
 
                 // create a UniqueCommandPool to allocate a CommandBuffer from
-//                val commandPool = device.createCommandPoolUnique(CommandPoolCreateInfo(0, graphicsQueueFamilyIndex))
+                val commandPool = device.createCommandPoolUnique(CommandPoolCreateInfo(0, graphicsQueueFamilyIndex))
 
                 // allocate a CommandBuffer from the CommandPool
-//                vk::UniqueCommandBuffer commandBuffer = std::move(device->allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo(commandPool.get(), vk::CommandBufferLevel::ePrimary, 1)).front())
+                val commandBuffer = device.allocateCommandBuffersUnique(CommandBufferAllocateInfo(commandPool, VkCommandBufferLevel.PRIMARY, 1))[0]
+
+//                for (i in 1..10000) {
+//                    val a = IntArray(10000)
+//                    try {
+//                        Thread.sleep(1)
+//                    } catch (e: InterruptedException) {
+//                    }
+//                }
             }
     }
 }