rend 1.0.1HEADmain

5 files changed, 921 insertions, 0 deletions

diff --git a/unused code/rend_vk_buffer.c b/unused code/rend_vk_buffer.c
new file mode 100644
index 0000000..37f3e06
--- /dev/null
+++ b/unused code/rend_vk_buffer.c
@@ -0,0 +1,116 @@
+#pragma once
+#include "rend_internal.h"
+#include "rend_vk_internal.h"
+#include <vulkan/vulkan_core.h>
+
+#if 0
+static RendBuffer
+rend_vk_buffer_create(VkDevice logical_device, VkAllocationCallbacks *allocator, VkDeviceSize size, VkBufferUsageFlags usage, uint32_t *family_indices, uint32_t family_indices_count)
+{
+    RendBuffer buffer = {
+        .handle = 0,
+        .logical_device = logical_device,
+        .memory = NULL,
+        .allocator = allocator,
+        .usage = usage | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+    };
+
+    VkBufferCreateInfo buffer_info = {
+        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .size = size,
+        .usage = usage,
+        .sharingMode = (family_indices_count > 1) ? VK_SHARING_MODE_CONCURRENT : VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = family_indices_count,
+        .pQueueFamilyIndices = family_indices
+    };
+
+    vkCreateBuffer(logical_device, &buffer_info, allocator, &buffer.handle);
+    return buffer;
+}
+
+static uint32_t
+rend_vk_buffer_required_memory_type(RendBuffer *buffer) 
+{
+    assert(buffer->memory == NULL && "Buffer already bound to memory");
+    VkMemoryRequirements mem_requirements;
+    vkGetBufferMemoryRequirements(buffer->logical_device, buffer->handle, &mem_requirements);
+    return mem_requirements.memoryTypeBits;
+}
+
+static void
+rend_vk_buffer_bind_memory(RendBuffer *buffer, RendVkMemory *memory) 
+{
+    assert(buffer->memory == NULL && "Buffer already bound to memory");
+    vkBindBufferMemory(buffer->logical_device, buffer->handle, memory->device_memory, 0);
+    buffer->memory = memory;
+}
+
+static void
+rend_vk_buffer_destroy(RendBuffer *buffer)
+{
+    assert(buffer && buffer->handle != 0);
+    vkDestroyBuffer(buffer->logical_device, buffer->handle, buffer->allocator);
+    buffer->handle = 0;
+    buffer->memory = 0;
+}
+
+static void 
+rend_vk_buffer_copy_device(VkQueue queue, VkCommandPool pool, RendBuffer *dest, size_t dest_offset, size_t bytes, RendBuffer *src, size_t src_offset, VkFence fence) 
+{
+    assert(src && dest); // check that im not sending null pointers
+    assert(src->usage & VK_BUFFER_USAGE_TRANSFER_SRC_BIT); // source buffer must be marked as transfer src
+    assert(dest->usage & VK_BUFFER_USAGE_TRANSFER_DST_BIT); // dest buffer must be marked as transfer dest
+
+    VkCommandBuffer transfer_cmd = VK_NULL_HANDLE;
+
+    VkCommandBufferAllocateInfo alloc_info = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+        .commandBufferCount = 1,
+        .commandPool = pool,
+        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+        .pNext = NULL,
+    };
+
+    vkAllocateCommandBuffers(dest->logical_device, &alloc_info, &transfer_cmd);
+
+    VkCommandBufferBeginInfo begin_info = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+    };
+    vkBeginCommandBuffer(transfer_cmd, &begin_info);
+
+    VkBufferCopy buffer_copy = {
+        .srcOffset = (VkDeviceSize)src_offset,
+        .dstOffset = (VkDeviceSize)dest_offset,
+        .size      = (VkDeviceSize)bytes,
+    };
+
+    vkCmdCopyBuffer(transfer_cmd, src->handle, dest->handle, 1, &buffer_copy);
+    vkEndCommandBuffer(transfer_cmd);
+
+    VkCommandBufferSubmitInfo cmd_info = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
+        .commandBuffer = transfer_cmd,
+        .deviceMask = 0,
+    };
+
+    VkSubmitInfo2 submit_info = {
+        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
+        .commandBufferInfoCount = 1,
+        .pCommandBufferInfos = &cmd_info,
+    };
+
+    vkQueueSubmit2(queue, 1, &submit_info, fence);
+    vkQueueWaitIdle(queue);
+    vkFreeCommandBuffers(dest->logical_device, pool, 1, &transfer_cmd);
+}
+
+static uint64_t
+rend_vk_buffer_address(RendBuffer *buffer, VkDevice device)
+{
+    VkBufferDeviceAddressInfoKHR address_info = {VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR};
+    address_info.buffer = buffer->handle;
+    VkDeviceAddress address = vkGetBufferDeviceAddress(device, &address_info);
+    return (uint64_t) address;
+}
+#endif
diff --git a/unused code/rend_vk_command_queue.c b/unused code/rend_vk_command_queue.c
new file mode 100644
index 0000000..1ddd780
--- /dev/null
+++ b/unused code/rend_vk_command_queue.c
@@ -0,0 +1,153 @@
+#pragma once
+#include "rend_internal.h"
+#include "rend_vk_internal.h"
+#include <vulkan/vulkan_core.h>
+#include <stdatomic.h>
+#include <stdlib.h>
+
+/* DEFERRED COMMANDS:
+ * Tracks single-use command buffers submitted for async GPU work,
+ * so callers don't have to block (vkQueueWaitIdle) to know when it's
+ * safe to free/reset them. One shared timeline semaphore; every
+ * submission claims the next monotonic value.
+ */
+
+struct RendVkPendingCmd {
+    VkCommandPool   pool;
+    VkCommandBuffer cmd;
+    uint64_t        wait_value;
+};
+
+struct RendVkDeferredCmds {
+    VkSemaphore        timeline;
+    RendVkPendingCmd  *darray;
+    size_t             count;
+    size_t             capacity;
+};
+
+#define RENDER_VK_DEFERRED_CMDS_INITIAL_CAPACITY 16
+
+static inline RendVkDeferredCmds
+rend_vk_cmdbuf_deferred_create(void)
+{
+    RendVkDeferredCmds tracker = {0};
+
+    VkSemaphoreTypeCreateInfo type_info = {
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
+        .semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE,
+        .initialValue = 0,
+    };
+    VkSemaphoreCreateInfo sem_info = {
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+        .pNext = &type_info,
+    };
+    vkCreateSemaphore(vk_device.logical_device, &sem_info, vk_allocator, &tracker.timeline);
+
+    tracker.capacity = RENDER_VK_DEFERRED_CMDS_INITIAL_CAPACITY;
+    tracker.darray = rmalloc(sizeof(RendVkPendingCmd) * tracker.capacity);
+    tracker.count = 0;
+
+    return tracker;
+}
+
+static inline void
+rend_vk_cmdbuf_deferred_destroy(RendVkDeferredCmds *tracker)
+{
+    vkDestroySemaphore(vk_device.logical_device, tracker->timeline, vk_allocator);
+    rfree(tracker->darray);
+    *tracker = (RendVkDeferredCmds) {0};
+}
+
+static inline void rend_vk_cmdbuf_deferred_lock(RendVkDeferredCmds *t)   { (void)t; }
+static inline void rend_vk_cmdbuf_deferred_unlock(RendVkDeferredCmds *t) { (void)t; }
+
+static inline VkCommandBuffer
+rend_vk_cmdbuf_deferred_begin(VkCommandPool pool)
+{
+    VkCommandBufferAllocateInfo alloc_info = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+        .commandPool = pool,
+        .commandBufferCount = 1,
+    };
+
+    VkCommandBuffer cmd;
+    vkAllocateCommandBuffers(vk_device.logical_device, &alloc_info, &cmd);
+
+    VkCommandBufferBeginInfo begin = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+    };
+
+    vkBeginCommandBuffer(cmd, &begin);
+    return cmd;
+}
+
+static inline void
+rend_vk_cmdbuf_deferred_push(RendVkDeferredCmds *tracker, VkCommandPool pool, VkCommandBuffer cmd, uint64_t wait_value)
+{
+    rend_vk_cmdbuf_deferred_lock(tracker);
+    if (tracker->count == tracker->capacity) {
+        tracker->capacity *= 2;
+        tracker->darray = realloc(tracker->darray, sizeof(RendVkPendingCmd) * tracker->capacity);
+    }
+    tracker->darray[tracker->count++] = (RendVkPendingCmd) {
+        .pool = pool,
+        .cmd = cmd,
+        .wait_value = wait_value,
+    };
+    rend_vk_cmdbuf_deferred_unlock(tracker);
+}
+
+static inline uint64_t
+rend_vk_cmdbuf_deferred_submit(RendVkDeferredCmds *tracker, VkCommandPool pool, VkCommandBuffer cmd, VkQueue queue, uint64_t wait_value, VkPipelineStageFlags2 wait_stage, VkPipelineStageFlags2 signal_stage)
+{
+    uint64_t signal_value = wait_value + 1;
+
+    VkCommandBufferSubmitInfo cmd_info = {
+        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
+        .commandBuffer = cmd,
+    };
+    VkSemaphoreSubmitInfo wait_info = {
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
+        .semaphore = tracker->timeline,
+        .value = wait_value,
+        .stageMask = wait_stage,
+    };
+    VkSemaphoreSubmitInfo signal_info = {
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
+        .semaphore = tracker->timeline,
+        .value = signal_value,
+        .stageMask = signal_stage,
+    };
+    VkSubmitInfo2 submit = {
+        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
+        .waitSemaphoreInfoCount = wait_value ? 1 : 0,
+        .pWaitSemaphoreInfos = &wait_info,
+        .commandBufferInfoCount = 1,
+        .pCommandBufferInfos = &cmd_info,
+        .signalSemaphoreInfoCount = 1,
+        .pSignalSemaphoreInfos = &signal_info,
+    };
+
+    vkQueueSubmit2(queue, 1, &submit, VK_NULL_HANDLE);
+
+    rend_vk_cmdbuf_deferred_push(tracker, pool, cmd, signal_value);
+    return signal_value;
+}
+
+static inline void
+rend_vk_cmdbuf_deferred_flush(RendVkDeferredCmds *tracker)
+{
+    uint64_t completed;
+    vkGetSemaphoreCounterValue(vk_device.logical_device, tracker->timeline, &completed);
+
+    for (size_t i = 0; i < tracker->count; ) {
+        if (completed >= tracker->darray[i].wait_value) {
+            vkFreeCommandBuffers(vk_device.logical_device, tracker->darray[i].pool, 1, &tracker->darray[i].cmd);
+            tracker->darray[i] = tracker->darray[--tracker->count];
+        } else {
+            i++;
+        }
+    }
+}
diff --git a/unused code/rend_vk_memory.c b/unused code/rend_vk_memory.c
new file mode 100644
index 0000000..4782b46
--- /dev/null
+++ b/unused code/rend_vk_memory.c
@@ -0,0 +1,100 @@
+#pragma once
+
+#include "rend_internal.h"
+#include "rend_vk_internal.h"
+#include <vulkan/vulkan_core.h>
+
+
+#if 0
+static RendVkMemory
+rend_vk_memory_malloc(size_t size, VkDevice logical_device, VkPhysicalDevice physical_device, uint32_t heap_index, VkAllocationCallbacks *allocator)
+{
+    RendVkMemory memory = {
+        .host_mapped_memory = NULL,
+        .device_memory = 0,
+        .logical_device = logical_device,
+        .heap_index = heap_index
+    };
+
+    VkMemoryAllocateFlagsInfo flags_info = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
+        .pNext = NULL,
+        .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, /* REQUIRED for BDA buffers */
+        .deviceMask = 0
+    };
+
+    VkMemoryAllocateInfo alloc_info = {
+        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+        .allocationSize = size,
+        .pNext = &flags_info,
+        .memoryTypeIndex = heap_index
+    };
+
+    vkAllocateMemory(logical_device, &alloc_info, allocator, &memory.device_memory);
+    return memory;
+}
+
+static void
+rend_vk_memory_free(RendVkMemory *memory)
+{
+    if (memory->host_mapped_memory) {
+        rend_vk_memory_unmap(memory);
+    }
+    if (memory->offset == 0) {
+        vkFreeMemory(memory->logical_device, memory->device_memory, memory->allocator);
+        memset(memory, 0, sizeof *memory);
+    } else {
+        PWARN("[REND_VK] Attempted to free memory with an offset!");
+    }
+}
+
+static void*
+rend_vk_memory_map(RendVkMemory *memory)
+{
+    // SPEC: memory must have been created with a memory type that reports VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
+    // vkMapMemory will fail if the implementation is unable to allocate an appropriately sized contiguous virtual address range,
+    // e.g. due to virtual address space fragmentation or platform limits.
+    // In such cases, vkMapMemory must return VK_ERROR_MEMORY_MAP_FAILED.
+    // The application can improve the likelihood of success by reducing the size of the mapped range and/or removing unneeded mappings using vkUnmapMemory.
+
+    vkMapMemory(memory->logical_device, memory->device_memory, memory->offset, memory->size, 0, &memory->host_mapped_memory);
+    return memory->host_mapped_memory;
+}
+
+static void
+rend_vk_memory_unmap(RendVkMemory *memory) 
+{
+    if (memory->offset == 0) {
+        vkUnmapMemory(memory->logical_device, memory->device_memory);
+        memory->host_mapped_memory = 0;
+    } else {
+        PWARN("[REND_VK] Attempted to unmap memory with an offset!");
+    }
+}
+
+static void
+rend_vk_memory_copy(RendVkMemory *memory, size_t offset, const void *data, size_t size)
+{
+    /* bounds check */
+    if (offset + size > memory->size) {
+        REND__WARN("Memory write out of bounds!");
+        return;
+    }
+
+    /* important to cast this */
+    uint8_t *dest = memory->host_mapped_memory;
+    memcpy(dest + offset, data, size);
+
+    /* flush host writes if memory is non-coherent */
+    // VkMappedMemoryRange range = {
+    //     .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
+    //     .memory = memory->device_memory,
+    //     .offset = offset,
+    //     .size = size
+    // };
+    //
+    // vkFlushMappedMemoryRanges(memory->logical_device, 1, &range);
+
+}
+
+#endif
diff --git a/unused code/rend_vk_pool.c b/unused code/rend_vk_pool.c
new file mode 100644
index 0000000..e527354
--- /dev/null
+++ b/unused code/rend_vk_pool.c
@@ -0,0 +1,221 @@
+#pragma once
+#include "rend_internal.h"
+#include "rend_vk_internal.h"
+#include <vulkan/vulkan_core.h>
+
+/* NOTE(vasco):
+ * Check out https://kylehalladay.com/blog/tutorial/2017/12/13/Custom-Allocators-Vulkan.html
+ * for a basic grasp on what it entails to actually write a memory allocator for vulkan.
+ *
+ * This allocator isnt anything particularly amazing but it works so I'm keeping this code.
+ * Based on the framework presented here we could implement other more efficient allocators.
+ * Which is what I did for the arena allocator.
+ */
+
+#if 0
+typedef struct RendVkAddress {
+    VkDeviceMemory handle;
+    uint32_t type;
+    uint32_t id;
+    VkDeviceSize size;
+    VkDeviceSize offset;
+} RendVkAddress;
+
+typedef struct RendVkPoolLayout {
+    uint64_t offset, size;
+} RendVkPoolLayout;
+
+typedef struct RendVKPoolBlock {
+    RendVkAddress address;
+    RendVkPoolLayout *layout_darr;
+    uint8_t reserved;
+} RendVKPoolBlock;
+
+typedef struct RendVkPoolMemory {
+    RendVKPoolBlock *block_darr;
+} RendVkPoolMemory;
+
+struct RendVkPoolAllocator {
+    VkAllocationCallbacks *allocator;
+    size_t *mem_type_alloc_sizes; // allocation size per type of memory available on the gpu
+    RendVkPoolMemory *mem_pools; // memory pools per type of memory available on the gpu
+    VkDevice logical_device; // virtual device
+    VkPhysicalDevice physical_device; // physical device we are allocating memory from
+    VkDeviceSize page_size; // allocations must respect the physical limitations of the gpu
+    VkDeviceSize block_min_size; // minimum size per block of memory
+    uint64_t total_allocations;
+    uint32_t memory_type_count;
+};
+
+static RendVkPoolAllocator
+rend_vk_pool_create(VkDevice logical_device, VkPhysicalDevice physical_device, VkPhysicalDeviceLimits device_limits, VkAllocationCallbacks *allocator)
+{
+        RendVkPoolAllocator pool = {
+            .allocator = allocator,
+            .mem_type_alloc_sizes = NULL,
+            .mem_pools = NULL,
+            .logical_device = logical_device,
+            .physical_device = physical_device,
+            .page_size = 0,
+            .block_min_size = 0,
+            .total_allocations = 0,
+            .memory_type_count = 0,
+        };
+
+		VkPhysicalDeviceMemoryProperties mem_properties;
+		vkGetPhysicalDeviceMemoryProperties(physical_device, &mem_properties);
+		
+        pool.mem_type_alloc_sizes = malloc(mem_properties.memoryTypeCount * sizeof *pool.mem_type_alloc_sizes);
+        memset(pool.mem_type_alloc_sizes, 0, mem_properties.memoryTypeCount * sizeof *pool.mem_type_alloc_sizes);
+
+        pool.mem_pools = malloc(mem_properties.memoryTypeCount * sizeof *pool.mem_pools);
+        memset(pool.mem_pools, 0, mem_properties.memoryTypeCount * sizeof *pool.mem_pools);
+
+        pool.memory_type_count = mem_properties.memoryTypeCount;
+		pool.page_size = device_limits.bufferImageGranularity;
+		pool.block_min_size = pool.page_size * 10;
+
+        return pool;
+}
+
+static uint32_t
+rend_vk_pool_add_block(RendVkPoolAllocator *pool, VkDeviceSize size, uint32_t memory_type, VkMemoryPropertyFlags properties, bool fit_to_alloc)
+{
+		VkDeviceSize new_pool_size = size * 2;
+		new_pool_size = (new_pool_size < pool->block_min_size) ? pool->block_min_size : new_pool_size;
+		
+        VkMemoryAllocateInfo alloc_info = {
+            .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+            .allocationSize = new_pool_size,
+            .memoryTypeIndex = rend_vk_memory_find_index(pool->physical_device, memory_type, properties)
+        };
+
+		RendVKPoolBlock block = {0};
+		VkResult res = vkAllocateMemory(pool->logical_device, &alloc_info, pool->allocator, &block.address.handle);
+		block.address.type = memory_type;
+		block.address.size = new_pool_size;
+
+        RendVkPoolMemory *mem_pool = &pool->mem_pools[memory_type];
+        p_darray_push(mem_pool->block_darr, block);
+		
+        RendVkPoolLayout layout = {
+            .offset = 0,
+            .size = new_pool_size
+        };
+        p_darray_push(mem_pool->block_darr[pool_size - 1].layout_darr, layout);
+        
+        pool->total_allocations++;
+
+        size_t pool_size = p_darray_len(mem_pool->block_darr);
+		return pool_size - 1;
+}
+
+static RendVkMemory 
+rend_vk_pool_alloc(RendVkPoolAllocator *pool, VkDeviceSize size, uint32_t usage, uint32_t memory_type, VkMemoryPropertyFlags properties)
+{
+    RendVkPoolMemory *mem_pool = &pool->mem_pools[memory_type];
+
+    VkDeviceSize requested_alloc_size = ((size / pool->page_size) + 1) * pool->page_size;
+    pool->mem_type_alloc_sizes[memory_type] += requested_alloc_size;
+
+    /* find free chunk for allocation 
+     * TODO: free list? 
+     */
+    int whole_page = usage != VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    uint64_t block_idx = UINT64_MAX;
+    uint64_t span_idx  = UINT64_MAX;
+    for (uint32_t i = 0; i < p_darray_len(mem_pool->block_darr); ++i) {
+        for (uint32_t j = 0; j < p_darray_len(mem_pool->block_darr[i].layout_darr); ++j) {
+            int valid = (whole_page) ? mem_pool->block_darr[i].layout_darr[j].offset == 0 : 1;
+            if (mem_pool->block_darr[i].layout_darr[j].size >= size && valid) {
+                block_idx = i;
+                span_idx = j;
+            }
+        }
+    }
+
+    if (block_idx == UINT64_MAX || span_idx == UINT64_MAX) {
+        block_idx = rend_vk_pool_add_block(pool, size, memory_type, properites, whole_page);
+        span_idx = 0;
+    }
+
+    mem_pool->block_darr[block_idx].reserved = whole_page;
+
+    RendVkMemory memory = {
+        .device_memory = mem_pool->block_darr[block_idx].address.handle,
+        .size = size,
+        .offset = mem_pool->block_darr[block_idx].layout_darr[span_idx].offset, 
+        .type = memory_type,
+
+        .logical_device = pool->logical_device,
+        .allocator = pool->allocator,
+        .host_mapped_memory = 0,
+        .physical_device = pool->physical_device,
+        .properties = properties,
+
+        .id = block_idx,
+    };
+        
+    /* mark chunck */
+    mem_pool->block_darr[block_idx].layout_darr[span_idx].offset += size;
+    mem_pool->block_darr[block_idx].layout_darr[span_idx].size -= size;
+    return memory;
+}
+
+
+static void
+rend_vk_pool_free(RendVkPoolAllocator *pool, RendVkMemory *memory)
+{
+    VkDeviceSize requested = ((memory->size / pool->page_size) + 1) * pool->page_size;
+
+    RendVkPoolMemory *mem_pool = &pool->mem_pools[memory->type];
+
+    pool->blocks_[allocation.id].pageReserved = false;
+
+    mem_pool->block_darr[block_idx].layout_darr[span_idx].offset += size;
+    mem_pool->block_darr[block_idx].layout_darr[span_idx].size -= size;
+
+    OffsetSize span = {allocation.offset, requestedAllocSize };
+    bool found = false;
+
+    uint32_t numLayoutMems = pool.blocks[allocation.id].layout.size();
+    for (uint32_t j = 0; j < numLayoutMems; ++j)
+    {
+        if (pool.blocks[allocation.id].layout[j].offset == requestedAllocSize +allocation.offset)
+        {
+            pool.blocks[allocation.id].layout[j].offset = allocation.offset;
+            pool.blocks[allocation.id].layout[j].size += requestedAllocSize;
+            found = true;
+            break;
+        }
+    }
+
+    if (!found)
+    {
+        state.memPools[allocation.type].blocks[allocation.id].layout.push_back(span);
+        state.memTypeAllocSizes[allocation.type] -= requestedAllocSize;
+    }
+}
+
+static void
+rend_vk_pool_destroy(RendVkPoolAllocator *pool)
+{
+    if (pool->mem_pools) { 
+        for (size_t u = 0; u < pool->memory_type_count; ++u) {
+            RendVkPoolMemory mem_pool = pool->mem_pools[u];
+            for (size_t b = 0; b < p_darray_len(mem_pool.block_darr); ++b) {
+                RendVKPoolBlock block = mem_pool.block_darr[b];
+                p_darray_destroy(block.layout_darr);
+            }
+            p_darray_destroy(mem_pool.block_darr);
+        }
+        free(pool->mem_pools);
+        pool->mem_pools = 0;
+    }
+    if (pool->mem_type_alloc_sizes) {
+        free(pool->mem_type_alloc_sizes);
+        pool->mem_type_alloc_sizes = 0;
+    }
+    memset(pool, 0, sizeof *pool);
+}
+#endif
diff --git a/unused code/rend_vk_sbta.c b/unused code/rend_vk_sbta.c
new file mode 100644
index 0000000..7bc51c4
--- /dev/null
+++ b/unused code/rend_vk_sbta.c
@@ -0,0 +1,331 @@
+#pragma once
+#include "rend_internal.h"
+#include "rend_vk_internal.h"
+#include <vulkan/vulkan_core.h>
+
+/*
+ * Sparse Bindless Texture Array (SBTA)
+ *
+ */
+
+struct RendVkSbta {
+    VkDevice logical_device;
+    RendVkImage image;              /* single 2D array image, arrayLayers = max_layers */
+    VkImageView *views;             /* per-layer VkImageView array */
+    VkFormat format;
+    VkExtent2D extent;
+    uint32_t max_layers;
+    uint32_t mip_levels;
+    uint64_t *bitmap;               /* 1 bit per layer slot */
+    uint32_t bitmap_word_count;
+    uint32_t allocated_count;
+    RendMemory memory;
+};
+
+static inline uint32_t
+rend_vk_sbta_mip_count(uint32_t w, uint32_t h)
+{
+    uint32_t v = (w > h) ? w : h;
+    uint32_t levels = 1;
+    while (v >>= 1) { levels++; }
+    return levels;
+}
+
+static void
+rend_vk_sbta_create(RendVkSbta *sbta, VkDevice logical_device, VkExtent2D extent, uint32_t layers)
+{
+    memset(sbta, 0, sizeof *sbta);
+    sbta->logical_device = logical_device;
+    sbta->format = VK_FORMAT_R8G8B8A8_SRGB;
+    sbta->extent = extent;
+    sbta->max_layers = layers;
+    sbta->mip_levels = rend_vk_sbta_mip_count(extent.width, extent.height);
+
+    /* create image */
+    sbta->image = rend_vk_image_create(
+        logical_device,
+        VK_IMAGE_TYPE_2D,
+        extent.width, extent.height,
+        sbta->format,
+        VK_IMAGE_TILING_OPTIMAL,
+        VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+        1,                  /* depth */
+        sbta->mip_levels,
+        layers,
+        VK_SAMPLE_COUNT_1_BIT,
+        VK_SHARING_MODE_EXCLUSIVE
+    );
+
+    /* allocate per-layer views array */
+    sbta->views = rmalloc(layers * sizeof *sbta->views);
+    memset(sbta->views, 0, layers * sizeof *sbta->views);
+
+    /* bitmap: ceil(layers / 64) words */
+    sbta->bitmap_word_count = (layers + 63) / 64;
+    sbta->bitmap = rmalloc(sbta->bitmap_word_count * sizeof *sbta->bitmap);
+    memset(sbta->bitmap, 0, sbta->bitmap_word_count * sizeof *sbta->bitmap);
+    sbta->allocated_count = 0;
+}
+
+static void
+rend_vk_sbta_create_views(RendVkSbta *sbta)
+{
+    for (uint32_t i = 0; i < sbta->max_layers; ++i) {
+        VkImageViewCreateInfo view_info = {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+            .image = sbta->image.handle,
+            .format = sbta->format,
+            .viewType = VK_IMAGE_VIEW_TYPE_2D,
+            .subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .subresourceRange.baseMipLevel = 0,
+            .subresourceRange.levelCount = sbta->mip_levels,
+            .subresourceRange.baseArrayLayer = i,
+            .subresourceRange.layerCount = 1,
+        };
+        vkCreateImageView(sbta->logical_device, &view_info, vk_allocator, &sbta->views[i]);
+    }
+}
+
+static void
+rend_vk_sbta_destroy(RendVkSbta *sbta)
+{
+    for (uint32_t i = 0; i < sbta->max_layers; ++i) {
+        if (sbta->views[i]) {
+            vkDestroyImageView(sbta->logical_device, sbta->views[i], vk_allocator);
+        }
+    }
+
+    rend_vk_image_destroy(&sbta->image);
+
+    rfree(sbta->views);
+    rfree(sbta->bitmap);
+    memset(sbta, 0, sizeof *sbta);
+}
+
+static uint64_t
+rend_vk_sbta_alloc(RendVkSbta *sbta)
+{
+    for (uint32_t w = 0; w < sbta->bitmap_word_count; ++w) {
+        if (sbta->bitmap[w] == ~(uint64_t)0) continue; /* word full */
+
+        /* find first zero bit */
+        uint64_t word = sbta->bitmap[w];
+        uint64_t bit = ~word & (word + 1); /* isolate lowest zero bit */
+        uint32_t bit_index = 0;
+        uint64_t tmp = bit;
+        while (tmp >>= 1) { bit_index++; }
+
+        uint64_t slot = (uint64_t)w * 64 + bit_index;
+        if (slot >= sbta->max_layers) return UINT64_MAX; /* past capacity */
+
+        sbta->bitmap[w] |= bit;
+        sbta->allocated_count++;
+        return slot;
+    }
+    return UINT64_MAX; /* full */
+}
+
+static void
+rend_vk_sbta_free(RendVkSbta *sbta, uint64_t idx)
+{
+    assert(idx < sbta->max_layers && "SBTA free: index out of range");
+
+    uint32_t word = (uint32_t)(idx / 64);
+    uint32_t bit  = (uint32_t)(idx % 64);
+    assert((sbta->bitmap[word] & (1ULL << bit)) && "SBTA free: slot not allocated (double free?)");
+
+    sbta->bitmap[word] &= ~(1ULL << bit);
+    sbta->allocated_count--;
+}
+
+static void
+rend_vk_sbta_upload(RendVkSbta *sbta, VkCommandBuffer cmd, RendVkArenaAllocator *staging_arena, uint64_t slot, void *pixels, uint64_t size)
+{
+    assert(slot < sbta->max_layers);
+    assert(pixels && size > 0);
+
+    /* ---- staging buffer ---- */
+    VkBufferCreateInfo buf_info = {
+        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .size  = size,
+        .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+    };
+
+    VkBuffer staging_buf;
+    vkCreateBuffer(sbta->logical_device, &buf_info, vk_allocator, &staging_buf);
+
+    VkMemoryRequirements staging_reqs;
+    vkGetBufferMemoryRequirements(sbta->logical_device, staging_buf, &staging_reqs);
+
+    uint32_t host_index = vk_device.host_index;
+    RendMemory staging_mem = rend_vk_arena_alloc(staging_arena, staging_reqs.size, host_index);
+    vkBindBufferMemory(sbta->logical_device, staging_buf, (VkDeviceMemory) staging_mem.device_memory, staging_mem.offset);
+
+    /* copy pixels into staging */
+    memcpy(staging_mem.host_mapped_memory, pixels, size);
+
+    /* ---- transition layer mip 0: UNDEFINED -> TRANSFER_DST ---- */
+    VkImageMemoryBarrier2 barrier_to_dst = {
+        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
+        .srcStageMask  = VK_PIPELINE_STAGE_2_NONE,
+        .srcAccessMask = VK_ACCESS_2_NONE,
+        .dstStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
+        .dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
+        .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+        .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+        .image = sbta->image.handle,
+        .subresourceRange = {
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .baseMipLevel = 0,
+            .levelCount = sbta->mip_levels,
+            .baseArrayLayer = (uint32_t)slot,
+            .layerCount = 1,
+        },
+    };
+
+    VkDependencyInfo dep_to_dst = {
+        .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
+        .imageMemoryBarrierCount = 1,
+        .pImageMemoryBarriers = &barrier_to_dst,
+    };
+    vkCmdPipelineBarrier2(cmd, &dep_to_dst);
+
+    /* ---- copy staging -> image mip 0 ---- */
+    VkBufferImageCopy copy_region = {
+        .bufferOffset = 0,
+        .imageSubresource = {
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .mipLevel = 0,
+            .baseArrayLayer = (uint32_t)slot,
+            .layerCount = 1,
+        },
+        .imageExtent = { sbta->extent.width, sbta->extent.height, 1 },
+    };
+
+    vkCmdCopyBufferToImage(cmd, staging_buf, sbta->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy_region);
+
+    /* ---- generate mipmaps via blit chain ---- */
+    int32_t mip_w = (int32_t)sbta->extent.width;
+    int32_t mip_h = (int32_t)sbta->extent.height;
+
+    for (uint32_t mip = 1; mip < sbta->mip_levels; ++mip) {
+        /* transition previous mip: TRANSFER_DST -> TRANSFER_SRC */
+        VkImageMemoryBarrier2 barrier_src = {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
+            .srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
+            .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
+            .dstStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
+            .dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT,
+            .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+            .image = sbta->image.handle,
+            .subresourceRange = {
+                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                .baseMipLevel = mip - 1,
+                .levelCount = 1,
+                .baseArrayLayer = (uint32_t)slot,
+                .layerCount = 1,
+            },
+        };
+
+        VkDependencyInfo dep_src = {
+            .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
+            .imageMemoryBarrierCount = 1,
+            .pImageMemoryBarriers = &barrier_src,
+        };
+        vkCmdPipelineBarrier2(cmd, &dep_src);
+
+        /* blit from mip-1 to mip */
+        int32_t next_w = (mip_w > 1) ? mip_w / 2 : 1;
+        int32_t next_h = (mip_h > 1) ? mip_h / 2 : 1;
+
+        VkImageBlit2 blit = {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2,
+            .srcSubresource = {
+                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                .mipLevel = mip - 1,
+                .baseArrayLayer = (uint32_t)slot,
+                .layerCount = 1,
+            },
+            .srcOffsets = { {0, 0, 0}, {mip_w, mip_h, 1} },
+            .dstSubresource = {
+                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                .mipLevel = mip,
+                .baseArrayLayer = (uint32_t)slot,
+                .layerCount = 1,
+            },
+            .dstOffsets = { {0, 0, 0}, {next_w, next_h, 1} },
+        };
+
+        VkBlitImageInfo2 blit_info = {
+            .sType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2,
+            .srcImage = sbta->image.handle,
+            .srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+            .dstImage = sbta->image.handle,
+            .dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            .regionCount = 1,
+            .pRegions = &blit,
+            .filter = VK_FILTER_LINEAR,
+        };
+        vkCmdBlitImage2(cmd, &blit_info);
+
+        mip_w = next_w;
+        mip_h = next_h;
+    }
+
+    /* ---- final transition: all mips -> SHADER_READ_ONLY ---- */
+    /* last mip is still TRANSFER_DST, all others are TRANSFER_SRC */
+
+    /* transition last mip: TRANSFER_DST -> SHADER_READ_ONLY */
+    VkImageMemoryBarrier2 barriers_final[2] = {
+        /* mips 0..N-2: TRANSFER_SRC -> SHADER_READ_ONLY */
+        {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
+            .srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
+            .srcAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT,
+            .dstStageMask  = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
+            .dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT,
+            .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+            .newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+            .image = sbta->image.handle,
+            .subresourceRange = {
+                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                .baseMipLevel = 0,
+                .levelCount = (sbta->mip_levels > 1) ? sbta->mip_levels - 1 : 1,
+                .baseArrayLayer = (uint32_t)slot,
+                .layerCount = 1,
+            },
+        },
+        /* last mip: TRANSFER_DST -> SHADER_READ_ONLY */
+        {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
+            .srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
+            .srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
+            .dstStageMask  = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
+            .dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT,
+            .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+            .newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+            .image = sbta->image.handle,
+            .subresourceRange = {
+                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                .baseMipLevel = sbta->mip_levels - 1,
+                .levelCount = 1,
+                .baseArrayLayer = (uint32_t)slot,
+                .layerCount = 1,
+            },
+        },
+    };
+
+    uint32_t barrier_count = (sbta->mip_levels > 1) ? 2 : 1;
+
+    /* if only 1 mip, use second barrier (TRANSFER_DST path) */
+    VkImageMemoryBarrier2 *barrier_ptr = (sbta->mip_levels > 1) ? barriers_final : &barriers_final[1];
+
+    VkDependencyInfo dep_final = {
+        .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
+        .imageMemoryBarrierCount = barrier_count,
+        .pImageMemoryBarriers = barrier_ptr,
+    };
+    vkCmdPipelineBarrier2(cmd, &dep_final);
+}