Merge branch 'main' of https://github.com/TheNumbat/rvk

Author: TheNumbat

README.md

@@ -40,8 +40,6 @@ If you're already using [rpp](https://github.com/TheNumbat/rpp), also set the fo
 set(RVK_HAS_RPP TRUE)
 ```
 
-Alternatively, to start an rvk project from scratch, you can fork [rpp_example_project/rvk](https://github.com/TheNumbat/rpp_example_project/tree/rvk).
-
 ## Examples
 
 ### Main Loop
@@ -103,8 +101,8 @@ i32 main() {
 
     rvk::Shader_Loader loader = rvk::make_shader_loader();
 
-    auto vertex = loader.load("shader.vert.spv"_v);
-    auto fragment = loader.load("shader.frag.spv"_v);
+    auto vertex = loader.compile("shader.vert.spv"_v);
+    auto fragment = loader.compile("shader.frag.spv"_v);
 
     loader.on_reload(Slice{{vertex, fragment}}, [&](Shader_Loader&) {
         // Recreate your pipeline...

deps/rpp

@@ -3,6 +3,7 @@
 
 #include "acceleration.h"
 #include "commands.h"
+#include "rvk.h"
 
 namespace rvk::impl {
 
@@ -31,7 +32,7 @@ TLAS& TLAS::operator=(TLAS&& src) {
     return *this;
 }
 
-Opt<TLAS::Staged> TLAS::make(Arc<Device_Memory, Alloc> memory, Buffer& instances, u32 n_instances) {
+Opt<TLAS::Staged> TLAS::make(Arc<Device_Memory, Alloc> memory, Buffer instances, u32 n_instances) {
 
     assert(instances.length());
 
@@ -73,14 +74,13 @@ Opt<TLAS::Staged> TLAS::make(Arc<Device_Memory, Alloc> memory, Buffer& instances
                                                        VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
     if(!scratch) return {};
 
-    return Opt<Staged>{Staged{move(*structure_buf), move(*scratch), instances, n_instances,
+    return Opt<Staged>{Staged{move(*structure_buf), move(*scratch), move(instances), n_instances,
                               build_sizes.accelerationStructureSize, move(memory)}};
 }
 
 TLAS TLAS::build(Commands& cmds, Staged buffers) {
 
     // Create acceleration structure
-    assert(buffers.instances);
 
     VkAccelerationStructureKHR acceleration_structure = null;
 
@@ -103,7 +103,7 @@ TLAS TLAS::build(Commands& cmds, Staged buffers) {
     geom.geometry.instances.sType =
         VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR;
     geom.geometry.instances.arrayOfPointers = VK_FALSE;
-    geom.geometry.instances.data.deviceAddress = buffers.instances->gpu_address();
+    geom.geometry.instances.data.deviceAddress = buffers.instances.gpu_address();
 
     VkAccelerationStructureBuildGeometryInfoKHR build_info = {};
     build_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
@@ -116,6 +116,7 @@ TLAS TLAS::build(Commands& cmds, Staged buffers) {
     build_info.dstAccelerationStructure = acceleration_structure;
 
     cmds.attach(move(buffers.scratch));
+    cmds.attach(move(buffers.instances));
 
     VkAccelerationStructureBuildRangeInfoKHR offset = {};
     offset.primitiveCount = buffers.n_instances;
@@ -189,6 +190,8 @@ Opt<BLAS::Staged> BLAS::make(Arc<Device_Memory, Alloc> memory, Buffer data,
             geom.geometry.triangles.indexData.deviceAddress = base_data + offset.index;
             if(offset.transform) {
                 geom.geometry.triangles.transformData.deviceAddress = base_data + *offset.transform;
+            } else {
+                geom.geometry.triangles.transformData.deviceAddress = 0;
             }
             geom.geometry.triangles.maxVertex = static_cast<u32>(offset.n_vertices);
 
@@ -231,6 +234,8 @@ Opt<BLAS::Staged> BLAS::make(Arc<Device_Memory, Alloc> memory, Buffer data,
 
 BLAS BLAS::build(Commands& cmds, Staged buffers) {
 
+    if(!buffers.geometry.length()) return {};
+
     // Create acceleration structure
 
     VkAccelerationStructureKHR acceleration_structure = null;

rvk/acceleration.cpp

@@ -27,15 +27,15 @@ struct TLAS {
         Staged& operator=(Staged&& src) = default;
 
     private:
-        explicit Staged(Buffer result, Buffer scratch, Buffer& instances, u32 n_instances,
+        explicit Staged(Buffer result, Buffer scratch, Buffer instances, u32 n_instances,
                         u64 result_size, Arc<Device_Memory, Alloc> memory)
-            : result(move(result)), scratch(move(scratch)), instances(instances),
+            : result(move(result)), scratch(move(scratch)), instances(move(instances)),
               n_instances(n_instances), result_size(result_size), memory(move(memory)) {
         }
 
         Buffer result;
         Buffer scratch;
-        Ref<Buffer> instances;
+        Buffer instances;
         u32 n_instances = 0;
         u64 result_size = 0;
         Arc<Device_Memory, Alloc> memory;
@@ -63,7 +63,7 @@ struct TLAS {
                   VkAccelerationStructureKHR accel);
     friend struct Vk;
 
-    static Opt<Staged> make(Arc<Device_Memory, Alloc> memory, Buffer& instances, u32 n_instances);
+    static Opt<Staged> make(Arc<Device_Memory, Alloc> memory, Buffer instances, u32 n_instances);
 
     Arc<Device_Memory, Alloc> memory;
 

rvk/acceleration.h

@@ -147,6 +147,8 @@ void Commands::reset() {
 
     RVK_CHECK(vkResetCommandBuffer(buffer, 0));
 
+    transient_buffers.clear();
+
     VkCommandBufferBeginInfo begin_info = {};
     begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
@@ -245,7 +247,7 @@ void Command_Pool_Manager<F>::begin_thread() {
         VkCommandPool pool = null;
         RVK_CHECK(vkCreateCommandPool(*device, &create_info, null, &pool));
 
-        this_thread.pool = Box<Command_Pool, Alloc>::make(device.dup(), F, pool);
+        this_thread.pool = Arc<Command_Pool, Alloc>::make(device.dup(), F, pool);
 
         Profile::Time_Point end = Profile::timestamp();
         info("[rvk] Allocated new % command pool for thread % in %ms.", F, id,

rvk/commands.cpp

@@ -114,7 +114,7 @@ struct Command_Pool {
 
 private:
     explicit Command_Pool(Arc<Device, Alloc> device, Queue_Family family, VkCommandPool pool);
-    friend struct Box<Command_Pool, Alloc>;
+    friend struct Arc<Command_Pool, Alloc>;
 
     Commands make();
     void release(VkCommandBuffer commands);
@@ -141,8 +141,8 @@ struct Command_Pool_Manager {
     Command_Pool_Manager& operator=(Command_Pool_Manager&&) = delete;
 
     // When allocating a command buffer, you _MUST_ get it from your current
-    // thread's pool, and it _MUST_ be recorded in that thread _ONLY_. Once recording
-    // is complete, it _MAY_ then be passed to another thread (e.g. the main thread)
+    // thread's pool, and it _MUST_ be recorded in that thread _ONLY_. Once the buffer
+    // is ended, it _MAY_ then be passed to another thread (e.g. the main thread)
     // for submission and deletion. Deletion is OK on another thread because
     // all it does is push it onto the buffer free list, which is protected by the mutex.
     //
@@ -162,15 +162,15 @@ struct Command_Pool_Manager {
         ~This_Thread() {
             if(pool_manager) pool_manager->end_thread();
         }
-        Box<Command_Pool, Alloc> pool;
+        Arc<Command_Pool, Alloc> pool;
         Ref<Command_Pool_Manager> pool_manager;
     };
 
     static inline thread_local This_Thread this_thread;
 
     Arc<Device, Alloc> device;
 
-    Vec<Box<Command_Pool, Alloc>, Alloc> free_list;
+    Vec<Arc<Command_Pool, Alloc>, Alloc> free_list;
     Map<Thread::Id, Empty<>, Alloc> active_threads;
     Thread::Mutex mutex;
 };

rvk/commands.h

@@ -606,8 +606,6 @@ u32 Device::queue_index(Queue_Family family) {
 
 void Device::submit(Commands& cmds, u32 index) {
 
-    cmds.end();
-
     VkCommandBufferSubmitInfo cmd_info = {};
     cmd_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
     cmd_info.commandBuffer = cmds;
@@ -625,8 +623,6 @@ void Device::submit(Commands& cmds, u32 index) {
 
 void Device::submit(Commands& cmds, u32 index, Fence& fence) {
 
-    cmds.end();
-
     VkCommandBufferSubmitInfo cmd_info = {};
     cmd_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
     cmd_info.commandBuffer = cmds;
@@ -645,8 +641,6 @@ void Device::submit(Commands& cmds, u32 index, Fence& fence) {
 
 void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_Ref> wait) {
 
-    cmds.end();
-
     Region(R) {
 
         Vec<VkSemaphoreSubmitInfo, Mregion<R>> vk_signal(signal.length());
@@ -690,8 +684,6 @@ void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_
 void Device::submit(Commands& cmds, u32 index, Slice<Sem_Ref> signal, Slice<Sem_Ref> wait,
                     Fence& fence) {
 
-    cmds.end();
-
     Region(R) {
 
         Vec<VkSemaphoreSubmitInfo, Mregion<R>> vk_signal(signal.length());

rvk/device.cpp

@@ -10,7 +10,8 @@ namespace rvk {
 
 namespace impl {
 Arc<Device, Alloc> get_device();
-}
+bool validation_enabled();
+} // namespace impl
 
 using namespace rpp;
 
@@ -39,10 +40,12 @@ auto sync(F&& f, Queue_Family family, u32 index) -> Invoke_Result<F, Commands&>
     auto cmds = make_commands(family);
     if constexpr(Same<Invoke_Result<F, Commands&>, void>) {
         f(cmds);
+        cmds.end();
         submit(cmds, index, fence);
         fence.wait();
     } else {
         auto result = f(cmds);
+        cmds.end();
         submit(cmds, index, fence);
         fence.wait();
         return result;
@@ -53,17 +56,27 @@ template<typename F>
     requires Invocable<F, Commands&>
 auto async(Async::Pool<>& pool, F&& f, Queue_Family family, u32 index)
     -> Async::Task<Invoke_Result<F, Commands&>> {
-    co_await pool.suspend();
     auto fence = make_fence();
     auto cmds = make_commands(family);
     if constexpr(Same<Invoke_Result<F, Commands&>, void>) {
         forward<F>(f)(cmds);
+        cmds.end();
         submit(cmds, index, fence);
-        co_await pool.event(fence.event());
+        if(impl::validation_enabled()) {
+            fence.wait();
+        } else {
+            co_await pool.event(fence.event());
+        }
+        co_return;
     } else {
         auto ret = forward<F>(f)(cmds);
+        cmds.end();
         submit(cmds, index, fence);
-        co_await pool.event(fence.event());
+        if(impl::validation_enabled()) {
+            fence.wait();
+        } else {
+            co_await pool.event(fence.event());
+        }
         co_return ret;
     }
 }

rvk/execute.h

@@ -48,8 +48,9 @@ struct Command_Pool;
 template<Queue_Family F>
 struct Command_Pool_Manager;
 struct Pipeline;
-template<VkShaderStageFlagBits stages, typename... Ts>
+template<u32 stages, typename... Ts>
 struct Push_Constants;
+struct Binding_Table;
 struct Shader;
 struct Sampler;
 struct Swapchain;
@@ -63,6 +64,7 @@ void check(VkResult result);
 
 } // namespace impl
 
+using impl::Binding_Table;
 using impl::BLAS;
 using impl::Buffer;
 using impl::Commands;

rvk/fwd.h

@@ -340,7 +340,7 @@ Buffer& Buffer::operator=(Buffer&& src) {
     return *this;
 }
 
-u64 Buffer::gpu_address() {
+u64 Buffer::gpu_address() const {
     if(!buffer) return 0;
     VkBufferDeviceAddressInfo info = {};
     info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;