bulmanator/ld58
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Added image loading

Browse Source 
Added some string functions and macros
Added path listing on windows
Added assets
This commit is contained in:
James Bulman
2025-10-04 17:24:30 +01:00
parent 7d55b16c8e
commit b1a805cea8
17 changed files with 617 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
code/vulkan/core.c
View File

@@ -330,6 +330,7 @@ bool Vk_Setup(SDL_Window *window) {
VkResult err = vk.CreateCommandPool(vk.device, &pool, 0, &frame->pool);
// Base command buffer
VkCommandBufferAllocateInfo alloc = { 0 };
alloc.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
alloc.commandBufferCount = 1;
@@ -338,16 +339,26 @@ bool Vk_Setup(SDL_Window *window) {
vk.AllocateCommandBuffers(vk.device, &alloc, &frame->cmd);
VkSemaphoreCreateInfo semaphore = { 0 };
semaphore.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
// Scratch command buffers
VkCommandBuffer scratch[VK_NUM_SCRATCH];
alloc.commandBufferCount = VK_NUM_SCRATCH;
err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->acquire), err);
err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->complete), err);
vk.AllocateCommandBuffers(vk.device, &alloc, scratch);
VkFenceCreateInfo fence = { 0 };
fence.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fence.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (U32 s = 0; s < VK_NUM_SCRATCH; ++s) {
frame->scratch[s].handle = scratch[s];
err = Min(vk.CreateFence(vk.device, &fence, 0, &frame->scratch[s].fence), err);
}
VkSemaphoreCreateInfo semaphore = { 0 };
semaphore.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->acquire), err);
err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->complete), err);
err = Min(vk.CreateFence(vk.device, &fence, 0, &frame->fence), err);
vk.err = err;
@@ -450,3 +461,137 @@ void Vk_FrameEnd() {
vk.n_frames += 1;
}
Vk_CommandBuffer *Vk_CommandBufferPush() {
Vk_Frame *frame = &vk.frames[vk.n_frames % vk.in_flight];
// If this scratch buffer is still in use wait for it to finish, this is _bad_ but we
// shouldn't hit this
U32 idx = frame->next_scratch & (VK_NUM_SCRATCH - 1);
Vk_CommandBuffer *result = &frame->scratch[idx];
vk.WaitForFences(vk.device, 1, &result->fence, VK_TRUE, U64_MAX);
vk.ResetFences(vk.device, 1, &result->fence);
VkCommandBufferBeginInfo begin_info = { 0 };
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
vk.BeginCommandBuffer(result->handle, &begin_info);
return result;
}
void Vk_CommandBufferSubmit(Vk_CommandBuffer *cmds, B32 wait) {
vk.EndCommandBuffer(cmds->handle);
VkSubmitInfo submit_info = { 0 };
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &cmds->handle;
vk.QueueSubmit(vk.queue.handle, 1, &submit_info, cmds->fence);
if (wait) {
vk.DeviceWaitIdle(vk.device);
}
}
#define VK_HOST_VISIBLE_FLAGS (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
internal VkDeviceMemory Vk_Allocate(VkMemoryRequirements *mreq, VkMemoryPropertyFlags usage) {
VkDeviceMemory result = VK_NULL_HANDLE;
VkPhysicalDeviceMemoryProperties2 _props = { 0 };
_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
vk.GetPhysicalDeviceMemoryProperties2(vk.gpu, &_props);
// ?????
VkPhysicalDeviceMemoryProperties *props = &_props.memoryProperties;
U32 type_index = U32_MAX;
for (U32 it = 0; it < props->memoryTypeCount; ++it) {
VkMemoryType *type = &props->memoryTypes[it];
if ((type->propertyFlags & usage) == usage) {
type_index = it;
break;
}
}
if (type_index != -1) {
VkMemoryAllocateInfo alloc_info = { 0 };
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
alloc_info.allocationSize = mreq->size;
alloc_info.memoryTypeIndex = type_index;
vk.AllocateMemory(vk.device, &alloc_info, 0, &result);
}
return result;
}
Vk_Buffer Vk_BufferCreate(U64 size, B32 host_visible) {
Vk_Buffer result = { 0 };
VkBufferCreateInfo create_info = { 0 };
create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
create_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
create_info.size = size;
vk.CreateBuffer(vk.device, &create_info, 0, &result.handle);
VkMemoryRequirements req;
vk.GetBufferMemoryRequirements(vk.device, result.handle, &req);
VkMemoryPropertyFlags usage = host_visible ? VK_HOST_VISIBLE_FLAGS : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
result.size = req.size;
result.memory = Vk_Allocate(&req, usage);
vk.BindBufferMemory(vk.device, result.handle, result.memory, 0);
if (host_visible) {
vk.MapMemory(vk.device, result.memory, 0, result.size, 0, &result.data);
}
return result;
}
void Vk_ImageCreate(Vk_Image *image) {
VkImageCreateInfo create_info = { 0 };
create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
create_info.imageType = VK_IMAGE_TYPE_2D;
create_info.format = image->format;
create_info.extent.width = image->width;
create_info.extent.height = image->height;
create_info.extent.depth = 1;
create_info.mipLevels = 1;
create_info.arrayLayers = 1;
create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | image->usage;
create_info.samples = VK_SAMPLE_COUNT_1_BIT;
create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
vk.CreateImage(vk.device, &create_info, 0, &image->handle);
VkMemoryRequirements req;
vk.GetImageMemoryRequirements(vk.device, image->handle, &req);
image->size = req.size;
image->memory = Vk_Allocate(&req, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vk.BindImageMemory(vk.device, image->handle, image->memory, 0);
VkImageViewCreateInfo view_info = { 0 };
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
view_info.format = image->format;
view_info.image = image->handle;
view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
view_info.subresourceRange.levelCount = 1;
view_info.subresourceRange.layerCount = 1;
vk.CreateImageView(vk.device, &view_info, 0, &image->view);
}