478 lines
20 KiB
C
478 lines
20 KiB
C
|
#include "initVulkan.h"
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
void shutdownGLFW(GLFWwindow *window)
|
||
|
|
{
|
||
|
|
glfwDestroyWindow(window);
|
||
|
|
glfwTerminate();
|
||
|
|
}
|
||
|
|
|
||
|
|
void createInstance(Compute *compute)
|
||
|
|
{
|
||
|
|
GLuint glfwExtensionsSize;
|
||
|
|
const char **glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionsSize);
|
||
|
|
|
||
|
|
VkApplicationInfo applicationInfo = {};
|
||
|
|
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
||
|
|
applicationInfo.pApplicationName = APP_NAME;
|
||
|
|
applicationInfo.applicationVersion = APP_VERSION;
|
||
|
|
applicationInfo.pEngineName = ENGINE_NAME;
|
||
|
|
applicationInfo.engineVersion = ENGINE_VERSION;
|
||
|
|
applicationInfo.apiVersion = VK_API_VERSION_1_2;
|
||
|
|
|
||
|
|
VkInstanceCreateInfo instanceCreateInfo = {};
|
||
|
|
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
||
|
|
instanceCreateInfo.flags = 0;
|
||
|
|
instanceCreateInfo.pApplicationInfo = &applicationInfo;
|
||
|
|
instanceCreateInfo.enabledLayerCount = 0;
|
||
|
|
instanceCreateInfo.ppEnabledLayerNames = NULL;
|
||
|
|
instanceCreateInfo.enabledExtensionCount = glfwExtensionsSize;
|
||
|
|
instanceCreateInfo.ppEnabledExtensionNames = glfwExtensions;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateInstance(&instanceCreateInfo, NULL, &(compute->instance)))
|
||
|
|
}
|
||
|
|
|
||
|
|
void findPhysicalDevice(Compute *compute)
|
||
|
|
{
|
||
|
|
uint32_t devicesSize;
|
||
|
|
vkEnumeratePhysicalDevices(compute->instance, &devicesSize, NULL);
|
||
|
|
|
||
|
|
if (devicesSize <= 0)
|
||
|
|
{
|
||
|
|
printf("Fatal : No device found with Vulkan support!");
|
||
|
|
assert(devicesSize > 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
VkPhysicalDevice physicalDevices[devicesSize];
|
||
|
|
vkEnumeratePhysicalDevices(compute->instance, &devicesSize, physicalDevices);
|
||
|
|
|
||
|
|
for (int i = 0; i < devicesSize; ++i)
|
||
|
|
{
|
||
|
|
VkPhysicalDeviceProperties deviceProperties = {};
|
||
|
|
vkGetPhysicalDeviceProperties(physicalDevices[i], &deviceProperties);
|
||
|
|
|
||
|
|
if (WORKGROUP_SIZE_X <= deviceProperties.limits.maxComputeWorkGroupSize[0]
|
||
|
|
&& PARTICLE_AMOUNT / WORKGROUP_SIZE_X <= deviceProperties.limits.maxComputeWorkGroupCount[0]
|
||
|
|
&& PARTICLE_SIZE * PARTICLE_AMOUNT <= deviceProperties.limits.maxStorageBufferRange)
|
||
|
|
{
|
||
|
|
compute->physicalDevice = physicalDevices[i];
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!compute->physicalDevice)
|
||
|
|
{
|
||
|
|
printf("Fatal : No device found with capable limits!");
|
||
|
|
assert(compute->physicalDevice);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32_t getQueueFamilyIndex(Compute *compute, VkQueueFlagBits queueFlagBits)
|
||
|
|
{
|
||
|
|
uint32_t queueFamiliesSize;
|
||
|
|
vkGetPhysicalDeviceQueueFamilyProperties(compute->physicalDevice, &queueFamiliesSize, NULL);
|
||
|
|
VkQueueFamilyProperties queueFamilies[queueFamiliesSize];
|
||
|
|
vkGetPhysicalDeviceQueueFamilyProperties(compute->physicalDevice, &queueFamiliesSize, queueFamilies);
|
||
|
|
|
||
|
|
for (uint32_t i = 0; i < queueFamiliesSize; ++i)
|
||
|
|
{
|
||
|
|
if (queueFamilies[i].queueCount > 0
|
||
|
|
&& queueFamilies[i].queueFlags & queueFlagBits)
|
||
|
|
{
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
void createDevice(Compute *compute)
|
||
|
|
{
|
||
|
|
compute->queueFamilyIndex = getQueueFamilyIndex(compute, VK_QUEUE_COMPUTE_BIT);
|
||
|
|
|
||
|
|
if (compute->queueFamilyIndex < 0)
|
||
|
|
{
|
||
|
|
printf("Fatal: Could not find a queue family with capability of computing!");
|
||
|
|
assert(compute->queueFamilyIndex >= 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
VkDeviceQueueCreateInfo deviceQueueCreateInfo = {};
|
||
|
|
deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
||
|
|
deviceQueueCreateInfo.queueFamilyIndex = compute->queueFamilyIndex;
|
||
|
|
deviceQueueCreateInfo.queueCount = 1;
|
||
|
|
deviceQueueCreateInfo.pQueuePriorities = NULL;
|
||
|
|
|
||
|
|
VkPhysicalDeviceFeatures physicalDeviceFeatures = {};
|
||
|
|
|
||
|
|
VkDeviceCreateInfo deviceCreateInfo = {};
|
||
|
|
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
||
|
|
deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
|
||
|
|
deviceCreateInfo.queueCreateInfoCount = 1;
|
||
|
|
deviceCreateInfo.pEnabledFeatures = &physicalDeviceFeatures;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateDevice(compute->physicalDevice, &deviceCreateInfo, NULL, &(compute->device)))
|
||
|
|
|
||
|
|
vkGetDeviceQueue(compute->device, compute->queueFamilyIndex, 0, &(compute->queue));
|
||
|
|
}
|
||
|
|
|
||
|
|
uint32_t findMemoryType(Compute *compute, uint32_t memoryTypeBits, VkMemoryPropertyFlags properties)
|
||
|
|
{
|
||
|
|
VkPhysicalDeviceMemoryProperties memoryProperties;
|
||
|
|
vkGetPhysicalDeviceMemoryProperties(compute->physicalDevice, &memoryProperties);
|
||
|
|
|
||
|
|
for (uint32_t i = 0; i < memoryProperties.memoryTypeCount; i++)
|
||
|
|
{
|
||
|
|
if ((memoryTypeBits & (1u << i))
|
||
|
|
&& ((memoryProperties.memoryTypes[i].propertyFlags & properties) == properties))
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
void createComputeBuffer(Compute *compute, uint32_t bufferSize, VkBufferUsageFlags usageFlags, VkBuffer *buffer,
|
||
|
|
VkDeviceMemory *bufferMemory, VkMemoryPropertyFlags memoryPropertyFlags)
|
||
|
|
{
|
||
|
|
|
||
|
|
VkBufferCreateInfo particleBufferCreateInfo = {};
|
||
|
|
particleBufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
||
|
|
particleBufferCreateInfo.size = bufferSize;
|
||
|
|
particleBufferCreateInfo.usage = usageFlags;
|
||
|
|
particleBufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateBuffer(compute->device, &particleBufferCreateInfo, NULL, buffer))
|
||
|
|
|
||
|
|
VkMemoryRequirements particleBufferMemoryRequirements;
|
||
|
|
vkGetBufferMemoryRequirements(compute->device, *buffer, &particleBufferMemoryRequirements);
|
||
|
|
|
||
|
|
VkMemoryAllocateInfo particleMemoryAllocateInfo = {};
|
||
|
|
particleMemoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||
|
|
particleMemoryAllocateInfo.allocationSize = particleBufferMemoryRequirements.size;
|
||
|
|
particleMemoryAllocateInfo.memoryTypeIndex = findMemoryType(compute,
|
||
|
|
particleBufferMemoryRequirements.memoryTypeBits,
|
||
|
|
memoryPropertyFlags);
|
||
|
|
|
||
|
|
ASSERT_VK(vkAllocateMemory(compute->device, &particleMemoryAllocateInfo, NULL, bufferMemory))
|
||
|
|
|
||
|
|
ASSERT_VK(vkBindBufferMemory(compute->device, *buffer, *bufferMemory, 0))
|
||
|
|
}
|
||
|
|
|
||
|
|
void createComputeBuffers(Compute *compute)
|
||
|
|
{
|
||
|
|
// Particle Buffer
|
||
|
|
createComputeBuffer(compute, compute->particleBufferSize,
|
||
|
|
VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
|
||
|
|
&(compute->particleBuffer),
|
||
|
|
&(compute->particleBufferMemory), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||
|
|
|
||
|
|
// dt Uniform Buffer
|
||
|
|
createComputeBuffer(compute, compute->dtUniformBufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
||
|
|
&(compute->dtUniformBuffer),
|
||
|
|
&(compute->dtUniformBufferMemory),
|
||
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||
|
|
|
||
|
|
// staticIn Uniform Buffer
|
||
|
|
createComputeBuffer(compute, compute->staticInUniformBufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
||
|
|
&(compute->staticInUniformBuffer),
|
||
|
|
&(compute->staticInUniformBufferMemory), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void createComputeDescriptorSetLayout(Compute *compute, uint32_t binding, VkDescriptorType descriptorType, VkDescriptorSetLayout *descriptorSetLayout)
|
||
|
|
{
|
||
|
|
VkDescriptorSetLayoutBinding descriptorSetLayoutBinding = {};
|
||
|
|
descriptorSetLayoutBinding.binding = binding;
|
||
|
|
descriptorSetLayoutBinding.descriptorType = descriptorType;
|
||
|
|
descriptorSetLayoutBinding.descriptorCount = 1;
|
||
|
|
descriptorSetLayoutBinding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
|
||
|
|
|
||
|
|
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {};
|
||
|
|
descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
||
|
|
descriptorSetLayoutCreateInfo.bindingCount = 1;
|
||
|
|
descriptorSetLayoutCreateInfo.pBindings = &descriptorSetLayoutBinding;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateDescriptorSetLayout(compute->device, &descriptorSetLayoutCreateInfo, NULL, descriptorSetLayout))
|
||
|
|
}
|
||
|
|
|
||
|
|
void createComputeDescriptorSetLayouts(Compute *compute)
|
||
|
|
{
|
||
|
|
// Particle Buffer
|
||
|
|
createComputeDescriptorSetLayout(compute, 0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
|
||
|
|
&(compute->particleBufferDescriptorSetLayout));
|
||
|
|
|
||
|
|
// dt Uniform Buffer
|
||
|
|
createComputeDescriptorSetLayout(compute, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
||
|
|
&(compute->dtUniformBufferDescriptorSetLayout));
|
||
|
|
|
||
|
|
// staticIn Uniform Buffer
|
||
|
|
createComputeDescriptorSetLayout(compute, 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
||
|
|
&(compute->staticInUniformBufferDescriptorSetLayout));
|
||
|
|
}
|
||
|
|
|
||
|
|
void createComputeDescriptorSet(Compute *compute, VkDescriptorType descriptorType, VkDescriptorPool *descriptorPool,
|
||
|
|
VkDescriptorSetLayout *descriptorSetLayout, VkDescriptorSet *descriptorSet,
|
||
|
|
VkBuffer buffer, uint32_t bufferSize)
|
||
|
|
{
|
||
|
|
VkDescriptorPoolSize descriptorPoolSize = {};
|
||
|
|
descriptorPoolSize.type = descriptorType;
|
||
|
|
descriptorPoolSize.descriptorCount = 1;
|
||
|
|
|
||
|
|
VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {};
|
||
|
|
descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
|
||
|
|
descriptorPoolCreateInfo.maxSets = 1;
|
||
|
|
descriptorPoolCreateInfo.poolSizeCount = 1;
|
||
|
|
descriptorPoolCreateInfo.pPoolSizes = &descriptorPoolSize;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateDescriptorPool(compute->device, &descriptorPoolCreateInfo, NULL, descriptorPool))
|
||
|
|
|
||
|
|
VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = {};
|
||
|
|
descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
|
||
|
|
descriptorSetAllocateInfo.descriptorPool = *descriptorPool;
|
||
|
|
descriptorSetAllocateInfo.descriptorSetCount = 1;
|
||
|
|
descriptorSetAllocateInfo.pSetLayouts = descriptorSetLayout;
|
||
|
|
|
||
|
|
ASSERT_VK(vkAllocateDescriptorSets(compute->device, &descriptorSetAllocateInfo, descriptorSet))
|
||
|
|
|
||
|
|
VkDescriptorBufferInfo descriptorBufferInfo = {};
|
||
|
|
descriptorBufferInfo.buffer = buffer;
|
||
|
|
descriptorBufferInfo.offset = 0;
|
||
|
|
descriptorBufferInfo.range = bufferSize;
|
||
|
|
|
||
|
|
VkWriteDescriptorSet writeDescriptorSet = {};
|
||
|
|
writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
||
|
|
writeDescriptorSet.dstSet = *descriptorSet;
|
||
|
|
writeDescriptorSet.dstBinding = 0;
|
||
|
|
writeDescriptorSet.descriptorCount = 1;
|
||
|
|
writeDescriptorSet.descriptorType = descriptorType;
|
||
|
|
writeDescriptorSet.pBufferInfo = &descriptorBufferInfo;
|
||
|
|
|
||
|
|
vkUpdateDescriptorSets(compute->device, 1, &writeDescriptorSet, 0, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
void createComputeDescriptorSets(Compute *compute)
|
||
|
|
{
|
||
|
|
// Particle Buffer
|
||
|
|
createComputeDescriptorSet(compute, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &(compute->particleBufferDescriptorPool),
|
||
|
|
&(compute->particleBufferDescriptorSetLayout), &(compute->particleBufferDescriptorSet),
|
||
|
|
compute->particleBuffer, compute->particleBufferSize);
|
||
|
|
|
||
|
|
// dt Uniform Buffer
|
||
|
|
createComputeDescriptorSet(compute, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &(compute->dtUniformBufferDescriptorPool),
|
||
|
|
&(compute->dtUniformBufferDescriptorSetLayout), &(compute->dtUniformBufferDescriptorSet),
|
||
|
|
compute->dtUniformBuffer, compute->dtUniformBufferSize);
|
||
|
|
|
||
|
|
// staticIn Uniform Buffer
|
||
|
|
createComputeDescriptorSet(compute, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
||
|
|
&(compute->staticInUniformBufferDescriptorPool),
|
||
|
|
&(compute->staticInUniformBufferDescriptorSetLayout),
|
||
|
|
&(compute->staticInUniformBufferDescriptorSet),
|
||
|
|
compute->staticInUniformBuffer, compute->staticInUniformBufferSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void createComputePipeline(Compute *compute)
|
||
|
|
{
|
||
|
|
long computeShaderSourceSize;
|
||
|
|
char *computeShaderSource = readFile("./vulkan/comp.spv", "rb", &computeShaderSourceSize);
|
||
|
|
|
||
|
|
VkShaderModuleCreateInfo shaderModuleCreateInfo = {};
|
||
|
|
shaderModuleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
||
|
|
shaderModuleCreateInfo.pCode = (uint32_t *) computeShaderSource;
|
||
|
|
shaderModuleCreateInfo.codeSize = computeShaderSourceSize;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateShaderModule(compute->device, &shaderModuleCreateInfo, NULL, &(compute->shaderModule)))
|
||
|
|
|
||
|
|
free(computeShaderSource);
|
||
|
|
|
||
|
|
VkPipelineShaderStageCreateInfo pipelineShaderStageCreateInfo = {};
|
||
|
|
pipelineShaderStageCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
||
|
|
pipelineShaderStageCreateInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
|
||
|
|
pipelineShaderStageCreateInfo.module = compute->shaderModule;
|
||
|
|
pipelineShaderStageCreateInfo.pName = "main";
|
||
|
|
|
||
|
|
VkDescriptorSetLayout descriptorSetLayouts[] = {
|
||
|
|
compute->particleBufferDescriptorSetLayout,
|
||
|
|
compute->dtUniformBufferDescriptorSetLayout,
|
||
|
|
compute->staticInUniformBufferDescriptorSetLayout
|
||
|
|
};
|
||
|
|
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {};
|
||
|
|
pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
||
|
|
pipelineLayoutCreateInfo.setLayoutCount = 3;
|
||
|
|
pipelineLayoutCreateInfo.pSetLayouts = descriptorSetLayouts;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreatePipelineLayout(compute->device, &pipelineLayoutCreateInfo, NULL, &(compute->pipelineLayout)));
|
||
|
|
|
||
|
|
VkComputePipelineCreateInfo pipelineCreateInfo = {};
|
||
|
|
pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
|
||
|
|
pipelineCreateInfo.stage = pipelineShaderStageCreateInfo;
|
||
|
|
pipelineCreateInfo.layout = compute->pipelineLayout;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateComputePipelines(compute->device, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &(compute->pipeline)))
|
||
|
|
}
|
||
|
|
|
||
|
|
void mapBufferMemory(Compute *compute, VkDeviceMemory memory, void *inputData, uint32_t dataSize)
|
||
|
|
{
|
||
|
|
void *vkData;
|
||
|
|
vkMapMemory(compute->device, memory, 0, dataSize, 0, &vkData);
|
||
|
|
memcpy(vkData, inputData, dataSize);
|
||
|
|
vkUnmapMemory(compute->device, memory);
|
||
|
|
}
|
||
|
|
|
||
|
|
void copyBuffer(Compute *compute, VkBuffer src, VkBuffer dst, VkDeviceSize size)
|
||
|
|
{
|
||
|
|
uint32_t queueFamilyIndex = getQueueFamilyIndex(compute, VK_QUEUE_TRANSFER_BIT);
|
||
|
|
|
||
|
|
VkCommandPoolCreateInfo commandPoolCreateInfo = {};
|
||
|
|
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
||
|
|
commandPoolCreateInfo.flags = 0;
|
||
|
|
commandPoolCreateInfo.queueFamilyIndex = queueFamilyIndex;
|
||
|
|
|
||
|
|
VkCommandPool stagingCommandPool;
|
||
|
|
ASSERT_VK(vkCreateCommandPool(compute->device, &commandPoolCreateInfo, NULL, &stagingCommandPool))
|
||
|
|
|
||
|
|
VkCommandBufferAllocateInfo allocInfo = {};
|
||
|
|
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
||
|
|
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
||
|
|
allocInfo.commandPool = stagingCommandPool;
|
||
|
|
allocInfo.commandBufferCount = 1;
|
||
|
|
|
||
|
|
VkCommandBuffer stagingCommandBuffer;
|
||
|
|
ASSERT_VK(vkAllocateCommandBuffers(compute->device, &allocInfo, &stagingCommandBuffer))
|
||
|
|
|
||
|
|
VkCommandBufferBeginInfo beginInfo = {};
|
||
|
|
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
||
|
|
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
||
|
|
|
||
|
|
ASSERT_VK(vkBeginCommandBuffer(stagingCommandBuffer, &beginInfo))
|
||
|
|
|
||
|
|
VkBufferCopy copyRegion = { .size = size };
|
||
|
|
vkCmdCopyBuffer(stagingCommandBuffer, src, dst, 1, ©Region);
|
||
|
|
|
||
|
|
ASSERT_VK(vkEndCommandBuffer(stagingCommandBuffer))
|
||
|
|
|
||
|
|
VkSubmitInfo submitInfo = {};
|
||
|
|
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
||
|
|
submitInfo.commandBufferCount = 1;
|
||
|
|
submitInfo.pCommandBuffers = &stagingCommandBuffer;
|
||
|
|
|
||
|
|
VkQueue stagingQueue;
|
||
|
|
vkGetDeviceQueue(compute->device, queueFamilyIndex, 0, &stagingQueue);
|
||
|
|
|
||
|
|
vkQueueSubmit(stagingQueue, 1, &submitInfo, VK_NULL_HANDLE);
|
||
|
|
vkQueueWaitIdle(stagingQueue);
|
||
|
|
|
||
|
|
vkFreeCommandBuffers(compute->device, stagingCommandPool, 1, &stagingCommandBuffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
void fillComputeBuffer(Compute *compute, VkBuffer dst, void *data, uint32_t dataSize)
|
||
|
|
{
|
||
|
|
VkBuffer stagingBuffer;
|
||
|
|
VkDeviceMemory stagingBuggerMemory;
|
||
|
|
createComputeBuffer(compute, compute->particleBufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, &stagingBuffer, &stagingBuggerMemory,
|
||
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||
|
|
|
||
|
|
mapBufferMemory(compute, stagingBuggerMemory, data, dataSize);
|
||
|
|
|
||
|
|
copyBuffer(compute, stagingBuffer, dst, dataSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void fillComputeBuffers(Compute *compute, float *particles, Dt *dtData, StaticIn *staticInData)
|
||
|
|
{
|
||
|
|
// Particle Buffer
|
||
|
|
fillComputeBuffer(compute, compute->particleBuffer, particles, compute->particleBufferSize);
|
||
|
|
|
||
|
|
// dt Buffer
|
||
|
|
mapBufferMemory(compute, compute->dtUniformBufferMemory, dtData, compute->dtUniformBufferSize);
|
||
|
|
|
||
|
|
// staticIn Buffer
|
||
|
|
fillComputeBuffer(compute, compute->staticInUniformBuffer, staticInData, compute->staticInUniformBufferSize);
|
||
|
|
}
|
||
|
|
|
||
|
|
void createComputeCommandBuffer(Compute *compute)
|
||
|
|
{
|
||
|
|
VkCommandPoolCreateInfo commandPoolCreateInfo = {};
|
||
|
|
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
||
|
|
commandPoolCreateInfo.flags = 0;
|
||
|
|
commandPoolCreateInfo.queueFamilyIndex = compute->queueFamilyIndex;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateCommandPool(compute->device, &commandPoolCreateInfo, NULL, &(compute->commandPool)))
|
||
|
|
|
||
|
|
VkCommandBufferAllocateInfo commandBufferAllocateInfo = {};
|
||
|
|
commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
||
|
|
commandBufferAllocateInfo.commandPool = compute->commandPool;
|
||
|
|
commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
||
|
|
commandBufferAllocateInfo.commandBufferCount = 1;
|
||
|
|
|
||
|
|
ASSERT_VK(vkAllocateCommandBuffers(compute->device, &commandBufferAllocateInfo, &(compute->commandBuffer)))
|
||
|
|
|
||
|
|
VkCommandBufferBeginInfo beginInfo = {};
|
||
|
|
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
||
|
|
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
|
||
|
|
|
||
|
|
ASSERT_VK(vkBeginCommandBuffer(compute->commandBuffer, &beginInfo))
|
||
|
|
|
||
|
|
vkCmdBindPipeline(compute->commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, compute->pipeline);
|
||
|
|
VkDescriptorSet descriptorSets[] = {
|
||
|
|
compute->particleBufferDescriptorSet,
|
||
|
|
compute->dtUniformBufferDescriptorSet,
|
||
|
|
compute->staticInUniformBufferDescriptorSet,
|
||
|
|
};
|
||
|
|
vkCmdBindDescriptorSets(compute->commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, compute->pipelineLayout, 0, 3,
|
||
|
|
descriptorSets, 0, NULL);
|
||
|
|
|
||
|
|
vkCmdDispatch(compute->commandBuffer, WORKGROUP_SIZE_X, WORKGROUP_SIZE_Y, WORKGROUP_SIZE_Z);
|
||
|
|
|
||
|
|
ASSERT_VK(vkEndCommandBuffer(compute->commandBuffer))
|
||
|
|
}
|
||
|
|
|
||
|
|
void runComputeCommandBuffer(Compute *compute)
|
||
|
|
{
|
||
|
|
VkSubmitInfo submitInfo = {};
|
||
|
|
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
||
|
|
submitInfo.commandBufferCount = 1;
|
||
|
|
submitInfo.pCommandBuffers = &(compute->commandBuffer);
|
||
|
|
|
||
|
|
VkFence fence;
|
||
|
|
VkFenceCreateInfo fenceCreateInfo = {};
|
||
|
|
fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
|
||
|
|
fenceCreateInfo.flags = 0;
|
||
|
|
|
||
|
|
ASSERT_VK(vkCreateFence(compute->device, &fenceCreateInfo, NULL, &fence))
|
||
|
|
|
||
|
|
ASSERT_VK(vkQueueSubmit(compute->queue, 1, &submitInfo, fence))
|
||
|
|
|
||
|
|
ASSERT_VK(vkWaitForFences(compute->device, 1, &fence, VK_TRUE, UINT64_MAX));
|
||
|
|
|
||
|
|
vkDestroyFence(compute->device, fence, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
void shutdownComputeVulkan(Compute *compute)
|
||
|
|
{
|
||
|
|
vkFreeMemory(compute->device, compute->particleBufferMemory, NULL);
|
||
|
|
vkFreeMemory(compute->device, compute->dtUniformBufferMemory, NULL);
|
||
|
|
vkFreeMemory(compute->device, compute->staticInUniformBufferMemory, NULL);
|
||
|
|
|
||
|
|
vkDestroyBuffer(compute->device, compute->particleBuffer, NULL);
|
||
|
|
vkDestroyBuffer(compute->device, compute->dtUniformBuffer, NULL);
|
||
|
|
vkDestroyBuffer(compute->device, compute->staticInUniformBuffer, NULL);
|
||
|
|
|
||
|
|
vkDestroyShaderModule(compute->device, compute->shaderModule, NULL);
|
||
|
|
|
||
|
|
vkDestroyDescriptorPool(compute->device, compute->particleBufferDescriptorPool, NULL);
|
||
|
|
vkDestroyDescriptorPool(compute->device, compute->dtUniformBufferDescriptorPool, NULL);
|
||
|
|
vkDestroyDescriptorPool(compute->device, compute->staticInUniformBufferDescriptorPool, NULL);
|
||
|
|
|
||
|
|
vkDestroyDescriptorSetLayout(compute->device, compute->particleBufferDescriptorSetLayout, NULL);
|
||
|
|
vkDestroyDescriptorSetLayout(compute->device, compute->dtUniformBufferDescriptorSetLayout, NULL);
|
||
|
|
vkDestroyDescriptorSetLayout(compute->device, compute->staticInUniformBufferDescriptorSetLayout, NULL);
|
||
|
|
|
||
|
|
vkDestroyPipelineLayout(compute->device, compute->pipelineLayout, NULL);
|
||
|
|
|
||
|
|
vkDestroyPipeline(compute->device, compute->pipeline, NULL);
|
||
|
|
|
||
|
|
vkDestroyCommandPool(compute->device, compute->commandPool, NULL);
|
||
|
|
|
||
|
|
vkDestroyDevice(compute->device, NULL);
|
||
|
|
|
||
|
|
vkDestroyInstance(compute->instance, NULL);
|
||
|
|
}
|