kbz_8/Pulse
1
0
Fork 0
mirror of https://github.com/Kbz-8/Pulse.git synced 2026-01-11 15:33:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

working on vulkan descriptor sets

Browse Source
This commit is contained in:
kbz_8
2025-01-26 00:35:06 +01:00
parent 14b9b28bf9
commit 6a40074c08
23 changed files with 518 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Sources/Backends/Vulkan/VulkanBuffer.c
View File

@@ -37,7 +37,7 @@ PulseBuffer VulkanCreateBuffer(PulseDevice device, const PulseBufferCreateInfo*
vulkan_buffer->usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
allocation_create_info.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
}
if(buffer->usage & PULSE_BUFFER_USAGE_UNIFORM_ACCESS)
if(buffer->usage & PULSE_INTERNAL_BUFFER_USAGE_UNIFORM_ACCESS)
{
vulkan_buffer->usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
allocation_create_info.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;

38
Sources/Backends/Vulkan/VulkanCommandList.c
View File

@@ -26,16 +26,31 @@ static void VulkanInitCommandList(VulkanCommandPool* pool, PulseCommandList cmd)
info.commandBufferCount = 1;
CHECK_VK(pool->device->backend, vulkan_device->vkAllocateCommandBuffers(vulkan_device->device, &info, &vulkan_cmd->cmd), PULSE_ERROR_INITIALIZATION_FAILED);
if(pool->available_command_lists_size == pool->available_command_lists_capacity)
{
pool->available_command_lists_capacity += 5;
pool->available_command_lists = (PulseCommandList*)realloc(pool->available_command_lists, pool->available_command_lists_capacity * sizeof(PulseCommandList));
PULSE_CHECK_ALLOCATION(pool->available_command_lists);
}
PULSE_EXPAND_ARRAY_IF_NEEDED(pool->available_command_lists, PulseCommandList, pool->available_command_lists_size, pool->available_command_lists_capacity, 5);
pool->available_command_lists[pool->available_command_lists_size] = cmd;
pool->available_command_lists_size++;
}
PulseComputePass VulkanCreateComputePass(PulseDevice device, PulseCommandList cmd)
{
PulseComputePass pass = (PulseComputePass)calloc(1, sizeof(PulseComputePassHandler));
PULSE_CHECK_ALLOCATION_RETVAL(pass, PULSE_NULL_HANDLE);
VulkanComputePass* vulkan_pass = (VulkanComputePass*)calloc(1, sizeof(VulkanComputePass));
PULSE_CHECK_ALLOCATION_RETVAL(vulkan_pass, PULSE_NULL_HANDLE);
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
// vulkan_pass->read_only_descriptor_set = VulkanRequestDescriptorSetFromPool(
// VulkanGetAvailableDescriptorSetPool(&vulkan_device->descriptor_set_pool_manager),
// VulkanGetDescriptorSetLayout(&vulkan_device->descriptor_set_layout_manager, ));
pass->cmd = cmd;
pass->driver_data = vulkan_pass;
return pass;
}
PulseCommandList VulkanRequestCommandList(PulseDevice device, PulseCommandListUsage usage)
{
PULSE_CHECK_HANDLE_RETVAL(device, PULSE_NULL_HANDLE);
@@ -77,7 +92,7 @@ PulseCommandList VulkanRequestCommandList(PulseDevice device, PulseCommandListUs
VulkanInitCommandList(pool, cmd);
}
cmd->compute_pipelines_bound_size = 0;
cmd->pass = VulkanCreateComputePass(device, cmd);
cmd->state = PULSE_COMMAND_LIST_STATE_RECORDING;
cmd->is_available = false;
@@ -169,3 +184,12 @@ void VulkanReleaseCommandList(PulseDevice device, PulseCommandList cmd)
}
}
}
PulseComputePass VulkanBeginComputePass(PulseCommandList cmd)
{
return cmd->pass;
}
void VulkanEndComputePass(PulseComputePass pass)
{
}

12
Sources/Backends/Vulkan/VulkanCommandList.h
View File

@@ -10,7 +10,9 @@
#include <vulkan/vulkan_core.h>
#include <Pulse.h>
#include "VulkanBuffer.h"
#include "VulkanCommandPool.h"
#include "VulkanDescriptor.h"
typedef struct VulkanCommandList
{
@@ -18,9 +20,19 @@ typedef struct VulkanCommandList
VkCommandBuffer cmd;
} VulkanCommandList;
typedef struct VulkanComputePass
{
VulkanDescriptorSet* read_only_descriptor_set;
VulkanDescriptorSet* read_write_descriptor_set;
VulkanDescriptorSet* uniform_descriptor_set;
PulseBuffer uniform_buffer;
} VulkanComputePass;
PulseCommandList VulkanRequestCommandList(PulseDevice device, PulseCommandListUsage usage);
bool VulkanSubmitCommandList(PulseDevice device, PulseCommandList cmd, PulseFence fence);
void VulkanReleaseCommandList(PulseDevice device, PulseCommandList cmd);
PulseComputePass VulkanBeginComputePass(PulseCommandList cmd);
void VulkanEndComputePass(PulseComputePass pass);
#endif // PULSE_VULKAN_COMMAND_LIST_H_

39
Sources/Backends/Vulkan/VulkanComputePipeline.c
View File

@@ -60,16 +60,6 @@ PulseComputePipeline VulkanCreateComputePipeline(PulseDevice device, const Pulse
return pipeline;
}
void VulkanDispatchComputePipeline(PulseComputePipeline pipeline, PulseCommandList cmd, uint32_t groupcount_x, uint32_t groupcount_y, uint32_t groupcount_z)
{
VulkanComputePipeline* vulkan_pipeline = VULKAN_RETRIEVE_DRIVER_DATA_AS(pipeline, VulkanComputePipeline*);
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(cmd->device, VulkanDevice*);
VulkanCommandList* vulkan_cmd = VULKAN_RETRIEVE_DRIVER_DATA_AS(cmd, VulkanCommandList*);
vulkan_device->vkCmdBindPipeline(vulkan_cmd->cmd, VK_PIPELINE_BIND_POINT_COMPUTE, vulkan_pipeline->pipeline);
vulkan_device->vkCmdDispatch(vulkan_cmd->cmd, groupcount_x, groupcount_y, groupcount_z);
}
void VulkanDestroyComputePipeline(PulseDevice device, PulseComputePipeline pipeline)
{
if(pipeline == PULSE_NULL_HANDLE)
@@ -91,3 +81,32 @@ void VulkanDestroyComputePipeline(PulseDevice device, PulseComputePipeline pipel
if(PULSE_IS_BACKEND_HIGH_LEVEL_DEBUG(device->backend))
PulseLogInfoFmt(device->backend, "(Vulkan) destroyed compute pipeline %p", pipeline);
}
void VulkanBindStorageBuffers(PulseComputePass pass, uint32_t starting_slot, PulseBuffer* const* buffers, uint32_t num_buffers)
{
}
void VulkanBindUniformData(PulseComputePass pass, uint32_t slot, const void* data, uint32_t data_size)
{
}
void VulkanBindStorageImages(PulseComputePass pass, uint32_t starting_slot, PulseImage* const* images, uint32_t num_images)
{
}
void VulkanBindComputePipeline(PulseComputePass pass, PulseComputePipeline pipeline)
{
VulkanComputePipeline* vulkan_pipeline = VULKAN_RETRIEVE_DRIVER_DATA_AS(pipeline, VulkanComputePipeline*);
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(pass->cmd->device, VulkanDevice*);
VulkanCommandList* vulkan_cmd = VULKAN_RETRIEVE_DRIVER_DATA_AS(pass->cmd, VulkanCommandList*);
vulkan_device->vkCmdBindPipeline(vulkan_cmd->cmd, VK_PIPELINE_BIND_POINT_COMPUTE, vulkan_pipeline->pipeline);
}
void VulkanDispatchComputations(PulseComputePass pass, uint32_t groupcount_x, uint32_t groupcount_y, uint32_t groupcount_z)
{
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(pass->cmd->device, VulkanDevice*);
VulkanCommandList* vulkan_cmd = VULKAN_RETRIEVE_DRIVER_DATA_AS(pass->cmd, VulkanCommandList*);
vulkan_device->vkCmdDispatch(vulkan_cmd->cmd, groupcount_x, groupcount_y, groupcount_z);
}

6
Sources/Backends/Vulkan/VulkanComputePipeline.h
View File

@@ -19,8 +19,12 @@ typedef struct VulkanComputePipeline
} VulkanComputePipeline;
PulseComputePipeline VulkanCreateComputePipeline(PulseDevice device, const PulseComputePipelineCreateInfo* info);
void VulkanDispatchComputePipeline(PulseComputePipeline pipeline, PulseCommandList cmd, uint32_t groupcount_x, uint32_t groupcount_y, uint32_t groupcount_z);
void VulkanDestroyComputePipeline(PulseDevice device, PulseComputePipeline pipeline);
void VulkanBindStorageBuffers(PulseComputePass pass, uint32_t starting_slot, PulseBuffer* const* buffers, uint32_t num_buffers);
void VulkanBindUniformData(PulseComputePass pass, uint32_t slot, const void* data, uint32_t data_size);
void VulkanBindStorageImages(PulseComputePass pass, uint32_t starting_slot, PulseImage* const* images, uint32_t num_images);
void VulkanBindComputePipeline(PulseComputePass pass, PulseComputePipeline pipeline);
void VulkanDispatchComputations(PulseComputePass pass, uint32_t groupcount_x, uint32_t groupcount_y, uint32_t groupcount_z);
#endif // PULSE_VULKAN_COMPUTE_PIPELINE_H_

129
Sources/Backends/Vulkan/VulkanDescriptor.c
View File

@@ -10,28 +10,145 @@
#include "VulkanDevice.h"
#include "VulkanDescriptor.h"
#undef NDEBUG
#include <assert.h>
void VulkanInitDescriptorSetLayoutManager(VulkanDescriptorSetLayoutManager* manager, PulseDevice device)
{
memset(manager, 0, sizeof(VulkanDescriptorSetLayoutManager));
manager->device = device;
}
VulkanDescriptorSetLayout* VulkanGetDescriptorSetLayout(VulkanDescriptorSetLayoutManager* manager,
uint32_t read_storage_buffers_count,
uint32_t read_storage_images_count,
uint32_t write_storage_buffers_count,
uint32_t write_storage_images_count,
uint32_t uniform_buffers_count)
{
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(manager->device, VulkanDevice*);
for(uint32_t i = 0; i < manager->layouts_size; i++)
{
VulkanDescriptorSetLayout* layout = &manager->layouts[i];
if( layout->ReadOnly.storage_buffer_count == read_storage_buffers_count &&
layout->ReadOnly.storage_texture_count == read_storage_images_count &&
layout->ReadWrite.storage_buffer_count == write_storage_buffers_count &&
layout->ReadWrite.storage_texture_count == write_storage_images_count &&
layout->Uniform.buffer_count == uniform_buffers_count)
{
return layout;
}
}
PULSE_EXPAND_ARRAY_IF_NEEDED(manager->layouts, VulkanDescriptorSetLayout, manager->layouts_size, manager->layouts_capacity, 1);
PULSE_CHECK_ALLOCATION_RETVAL(manager->layouts, PULSE_NULLPTR);
VulkanDescriptorSetLayout* layout = &manager->layouts[manager->layouts_size];
VkDescriptorSetLayoutBinding* bindings = (VkDescriptorSetLayoutBinding*)PulseStaticAllocStack(PULSE_MAX_READ_BUFFERS_BOUND + PULSE_MAX_READ_TEXTURES_BOUND + PULSE_MAX_WRITE_BUFFERS_BOUND + PULSE_MAX_WRITE_TEXTURES_BOUND + PULSE_MAX_UNIFORM_BUFFERS_BOUND);
// Category 1
for(uint32_t i = 0; i < read_storage_images_count; i++)
{
bindings[i].binding = i;
bindings[i].descriptorCount = 1;
bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
bindings[i].pImmutableSamplers = PULSE_NULLPTR;
}
for(uint32_t i = read_storage_images_count; i < read_storage_images_count + read_storage_buffers_count; i++)
{
bindings[i].binding = i;
bindings[i].descriptorCount = 1;
bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
bindings[i].pImmutableSamplers = PULSE_NULLPTR;
}
// Category 2
for(uint32_t i = 0; i < write_storage_images_count; i++) {
bindings[i].binding = i;
bindings[i].descriptorCount = 1;
bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
bindings[i].pImmutableSamplers = PULSE_NULLPTR;
}
for(uint32_t i = write_storage_images_count; i < write_storage_images_count + write_storage_buffers_count; i++)
{
bindings[i].binding = i;
bindings[i].descriptorCount = 1;
bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
bindings[i].pImmutableSamplers = PULSE_NULLPTR;
}
// Category 3
for(uint32_t i = 0; i < uniform_buffers_count; i++)
{
bindings[i].binding = i;
bindings[i].descriptorCount = 1;
bindings[i].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
bindings[i].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
bindings[i].pImmutableSamplers = PULSE_NULLPTR;
}
VkDescriptorSetLayoutCreateInfo layout_info = { 0 };
layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layout_info.bindingCount = read_storage_buffers_count + read_storage_images_count + write_storage_buffers_count + write_storage_images_count + uniform_buffers_count;
layout_info.pBindings = bindings;
CHECK_VK_RETVAL(manager->device->backend, vulkan_device->vkCreateDescriptorSetLayout(vulkan_device->device, &layout_info, PULSE_NULLPTR, &layout->layout), PULSE_ERROR_INITIALIZATION_FAILED, PULSE_NULLPTR);
layout->ReadOnly.storage_buffer_count = read_storage_buffers_count;
layout->ReadOnly.storage_texture_count = read_storage_images_count;
layout->ReadWrite.storage_buffer_count = write_storage_buffers_count;
layout->ReadWrite.storage_texture_count = write_storage_images_count;
layout->Uniform.buffer_count = uniform_buffers_count;
return layout;
}
void VulkanDestroyDescriptorSetLayout(VulkanDescriptorSetLayout* layout, PulseDevice device)
{
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
vulkan_device->vkDestroyDescriptorSetLayout(vulkan_device->device, layout->layout, PULSE_NULLPTR);
}
void VulkanDestroyDescriptorSetLayoutManager(VulkanDescriptorSetLayoutManager* manager)
{
for(uint32_t i = 0; i < manager->layouts_size; i++)
{
VulkanDestroyDescriptorSetLayout(&manager->layouts[i], manager->device);
}
free(manager->layouts);
memset(manager, 0, sizeof(VulkanDescriptorSetPoolManager));
}
void VulkanInitDescriptorSetPool(VulkanDescriptorSetPool* pool, PulseDevice device)
{
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
memset(pool, 0, sizeof(VulkanDescriptorSetPool));
pool->device = device;
pool->thread_id = PulseGetThreadID();
VkDescriptorPoolSize pool_sizes[
PULSE_MAX_STORAGE_TEXTURES_BOUND +
PULSE_MAX_STORAGE_BUFFERS_BOUND +
PULSE_MAX_READ_TEXTURES_BOUND +
PULSE_MAX_READ_BUFFERS_BOUND +
PULSE_MAX_WRITE_TEXTURES_BOUND +
PULSE_MAX_WRITE_BUFFERS_BOUND +
PULSE_MAX_UNIFORM_BUFFERS_BOUND];
uint32_t i = 0;
for(uint32_t start = i; i < start + PULSE_MAX_STORAGE_TEXTURES_BOUND; i++)
for(uint32_t start = i; i < start + PULSE_MAX_READ_TEXTURES_BOUND; i++)
{
pool_sizes[i].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
pool_sizes[i].descriptorCount = VULKAN_POOL_SIZE;
}
for(uint32_t start = i; i < start + PULSE_MAX_STORAGE_BUFFERS_BOUND; i++)
for(uint32_t start = i; i < start + PULSE_MAX_READ_BUFFERS_BOUND; i++)
{
pool_sizes[i].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
pool_sizes[i].descriptorCount = VULKAN_POOL_SIZE;
@@ -146,7 +263,6 @@ void VulkanDestroyDescriptorSetPool(VulkanDescriptorSetPool* pool)
memset(pool, 0, sizeof(VulkanDescriptorSetPool));
}
void VulkanInitDescriptorSetPoolManager(VulkanDescriptorSetPoolManager* manager, PulseDevice device)
{
memset(manager, 0, sizeof(VulkanDescriptorSetPoolManager));
@@ -155,9 +271,10 @@ void VulkanInitDescriptorSetPoolManager(VulkanDescriptorSetPoolManager* manager,
VulkanDescriptorSetPool* VulkanGetAvailableDescriptorSetPool(VulkanDescriptorSetPoolManager* manager)
{
PulseThreadID thread_id = PulseGetThreadID();
for(uint32_t i = 0; i < manager->pools_size; i++)
{
if(manager->pools[i]->allocations_count < VULKAN_POOL_SIZE || manager->pools[i]->free_sets[0] != PULSE_NULLPTR)
if(thread_id == manager->pools[i]->thread_id && (manager->pools[i]->allocations_count < VULKAN_POOL_SIZE || manager->pools[i]->free_sets[0] != PULSE_NULLPTR))
return manager->pools[i];
}
PULSE_EXPAND_ARRAY_IF_NEEDED(manager->pools, VulkanDescriptorSetPool*, manager->pools_size, manager->pools_capacity, 1);

22
Sources/Backends/Vulkan/VulkanDescriptor.h
View File

@@ -10,6 +10,7 @@
#include <vulkan/vulkan_core.h>
#include <Pulse.h>
#include "../../PulseInternal.h"
#include "VulkanEnums.h"
@@ -18,7 +19,6 @@
typedef struct VulkanDescriptorSetLayout
{
VkDescriptorSetLayout layout;
VulkanDescriptorSetType type;
union
{
@@ -55,6 +55,7 @@ typedef struct VulkanDescriptorSetPool
uint32_t free_index;
PulseDevice device;
VkDescriptorPool pool;
PulseThreadID thread_id;
uint32_t allocations_count;
} VulkanDescriptorSetPool;
@@ -66,10 +67,25 @@ typedef struct VulkanDescriptorSetPoolManager
uint32_t pools_size;
} VulkanDescriptorSetPoolManager;
void VulkanInitDescriptorSetPool(VulkanDescriptorSetPool* pool, PulseDevice device);
typedef struct VulkanDescriptorSetLayoutManager
{
PulseDevice device;
VulkanDescriptorSetLayout* layouts;
uint32_t layouts_capacity;
uint32_t layouts_size;
} VulkanDescriptorSetLayoutManager;
void VulkanInitDescriptorSetLayoutManager(VulkanDescriptorSetLayoutManager* manager, PulseDevice device);
VulkanDescriptorSetLayout* VulkanGetDescriptorSetLayout(VulkanDescriptorSetLayoutManager* manager,
uint32_t read_storage_buffers_count,
uint32_t read_storage_images_count,
uint32_t write_storage_buffers_count,
uint32_t write_storage_images_count,
uint32_t uniform_buffers_count);
void VulkanDestroyDescriptorSetLayoutManager(VulkanDescriptorSetLayoutManager* manager);
VulkanDescriptorSet* VulkanRequestDescriptorSetFromPool(VulkanDescriptorSetPool* pool, const VulkanDescriptorSetLayout* layout);
void VulkanReturnDescriptorSetToPool(VulkanDescriptorSetPool* pool, const VulkanDescriptorSet* set);
void VulkanDestroyDescriptorSetPool(VulkanDescriptorSetPool* pool);
void VulkanInitDescriptorSetPoolManager(VulkanDescriptorSetPoolManager* manager, PulseDevice device);
VulkanDescriptorSetPool* VulkanGetAvailableDescriptorSetPool(VulkanDescriptorSetPoolManager* manager);

5
Sources/Backends/Vulkan/VulkanDevice.c
View File

@@ -228,6 +228,9 @@ PulseDevice VulkanCreateDevice(PulseBackend backend, PulseDevice* forbiden_devic
pulse_device->backend = backend;
PULSE_LOAD_DRIVER_DEVICE(Vulkan);
VulkanInitDescriptorSetPoolManager(&device->descriptor_set_pool_manager, pulse_device);
VulkanInitDescriptorSetLayoutManager(&device->descriptor_set_layout_manager, pulse_device);
if(PULSE_IS_BACKEND_HIGH_LEVEL_DEBUG(backend))
PulseLogInfoFmt(backend, "(Vulkan) created device from %s", device->properties.deviceName);
return pulse_device;
@@ -238,6 +241,8 @@ void VulkanDestroyDevice(PulseDevice device)
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(device, VulkanDevice*);
if(vulkan_device == PULSE_NULLPTR || vulkan_device->device == VK_NULL_HANDLE)
return;
VulkanDestroyDescriptorSetPoolManager(&vulkan_device->descriptor_set_pool_manager);
VulkanDestroyDescriptorSetLayoutManager(&vulkan_device->descriptor_set_layout_manager);
for(uint32_t i = 0; i < vulkan_device->cmd_pools_size; i++)
vulkan_device->vkDestroyCommandPool(vulkan_device->device, vulkan_device->cmd_pools[i].pool, PULSE_NULLPTR);
vmaDestroyAllocator(vulkan_device->allocator);

4
Sources/Backends/Vulkan/VulkanDevice.h
View File

@@ -17,12 +17,16 @@
#include <Pulse.h>
#include "VulkanEnums.h"
#include "VulkanDescriptor.h"
#include "VulkanCommandPool.h"
struct VulkanQueue;
typedef struct VulkanDevice
{
VulkanDescriptorSetPoolManager descriptor_set_pool_manager;
VulkanDescriptorSetLayoutManager descriptor_set_layout_manager;
VulkanCommandPool* cmd_pools;
uint32_t cmd_pools_size;

1
Sources/Backends/Vulkan/VulkanDevicePrototypes.h
View File

@@ -19,6 +19,7 @@
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdBindPipeline)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdCopyBuffer)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdCopyBufferToImage)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdCopyImageToBuffer)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdDispatch)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdDispatchIndirect)
PULSE_VULKAN_DEVICE_FUNCTION(vkCmdExecuteCommands)

9
Sources/Backends/Vulkan/VulkanEnums.h
View File

@@ -15,15 +15,6 @@ typedef enum VulkanQueueType
VULKAN_QUEUE_END_ENUM // For internal use only
} VulkanQueueType;
typedef enum VulkanDescriptorSetType
{
VULKAN_DESCRIPTOR_SET_READ_ONLY = 0,
VULKAN_DESCRIPTOR_SET_READ_WRITE,
VULKAN_DESCRIPTOR_SET_UNIFORM,
VULKAN_DESCRIPTOR_SET_END_ENUM // For internal use only
} VulkanDescriptorSetType;
#endif // PULSE_VULKAN_ENUMS_H_
#endif // PULSE_ENABLE_VULKAN_BACKEND

28
Sources/Backends/Vulkan/VulkanImage.c
View File

@@ -5,8 +5,9 @@
#include "Pulse.h"
#include "Vulkan.h"
#include "VulkanImage.h"
#include "VulkanBuffer.h"
#include "VulkanDevice.h"
#include <vulkan/vulkan_core.h>
#include "VulkanCommandList.h"
static VkFormat PulseImageFormatToVkFormat[] = {
VK_FORMAT_UNDEFINED, // INVALID
@@ -61,12 +62,6 @@ static VkFormat PulseImageFormatToVkFormat[] = {
VK_FORMAT_R32_SINT, // R32_INT
VK_FORMAT_R32G32_SINT, // R32G32_INT
VK_FORMAT_R32G32B32A32_SINT, // R32G32B32A32_INT
VK_FORMAT_R8G8B8A8_SRGB, // R8G8B8A8_UNORM_SRGB
VK_FORMAT_B8G8R8A8_SRGB, // B8G8R8A8_UNORM_SRGB
VK_FORMAT_BC1_RGBA_SRGB_BLOCK, // BC1_UNORM_SRGB
VK_FORMAT_BC2_SRGB_BLOCK, // BC3_UNORM_SRGB
VK_FORMAT_BC3_SRGB_BLOCK, // BC3_UNORM_SRGB
VK_FORMAT_BC7_SRGB_BLOCK, // BC7_UNORM_SRGB
};
PULSE_STATIC_ASSERT(PulseImageFormatToVkFormat, (sizeof(PulseImageFormatToVkFormat) / sizeof(VkFormat)) == PULSE_IMAGE_FORMAT_MAX_ENUM);
@@ -189,6 +184,25 @@ bool VulkanIsImageFormatValid(PulseDevice device, PulseImageFormat format, Pulse
bool VulkanCopyImageToBuffer(PulseCommandList cmd, const PulseImageRegion* src, const PulseBufferRegion* dst)
{
VulkanDevice* vulkan_device = VULKAN_RETRIEVE_DRIVER_DATA_AS(src->image->device, VulkanDevice*);
VulkanImage* vulkan_image = VULKAN_RETRIEVE_DRIVER_DATA_AS(src->image, VulkanImage*);
VulkanBuffer* vulkan_buffer = VULKAN_RETRIEVE_DRIVER_DATA_AS(dst->buffer, VulkanBuffer*);
VulkanCommandList* vulkan_cmd = VULKAN_RETRIEVE_DRIVER_DATA_AS(cmd, VulkanCommandList*);
VkOffset3D offset = { src->x, src->y, src->z };
VkExtent3D extent = { src->width, src->height, src->depth };
VkBufferImageCopy region = {};
region.bufferOffset = dst->offset;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageOffset = offset;
region.imageExtent = extent;
vulkan_device->vkCmdCopyImageToBuffer(vulkan_cmd->cmd, vulkan_image->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, vulkan_buffer->buffer, 1, &region);
return true;
}
bool VulkanBlitImage(PulseCommandList cmd, const PulseImageRegion* src, const PulseImageRegion* dst)