void ComputeShaderDispatcher::Dispatch(u32 groups_x, u32 groups_y, u32 groups_z)
{
BindDescriptors();
if (!BindPipeline())
return;
vkCmdDispatch(m_command_buffer, groups_x, groups_y, groups_z);
}
void QeParticle::updateComputeCommandBuffer(VkCommandBuffer &commandBuffer) {
if (!currentParticlesSize) return;
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, VK->pipelineLayout, eDescriptorSetLayout_Compute, 1,
&descriptorSetCompute.set, 0, nullptr);
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, VK->createComputePipeline(&computePipeline));
vkCmdDispatch(commandBuffer, currentParticlesSize, 1, 1);
}
void buildComputeCommandBuffer()
{
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();;
vkBeginCommandBuffer(computeCmdBuffer, &cmdBufInfo);
vkCmdBindPipeline(computeCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelines.compute);
vkCmdBindDescriptorSets(computeCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 0, 1, &computeDescriptorSet, 0, 0);
vkCmdDispatch(computeCmdBuffer, PARTICLE_COUNT / 16, 1, 1);
vkEndCommandBuffer(computeCmdBuffer);
}
VkBool32 Example::buildCmdBuffer()
{
VkResult result;
//
cmdBuffer = vkts::commandBuffersCreate(device->getDevice(), commandPool->getCmdPool(), VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1);
if (!cmdBuffer.get())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create command buffer.");
return VK_FALSE;
}
result = cmdBuffer->beginCommandBuffer(0, VK_NULL_HANDLE, 0, VK_NULL_HANDLE, VK_FALSE, 0, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not begin command buffer.");
return VK_FALSE;
}
//
vkCmdBindPipeline(cmdBuffer->getCommandBuffer(), VK_PIPELINE_BIND_POINT_COMPUTE, pipeline->getPipeline());
vkCmdBindDescriptorSets(cmdBuffer->getCommandBuffer(), VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout->getPipelineLayout(), 0, 1, descriptorSet->getDescriptorSets(), 0, nullptr);
VkImageSubresourceRange imageSubresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
image->cmdPipelineBarrier(cmdBuffer->getCommandBuffer(), VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL, imageSubresourceRange);
vkCmdDispatch(cmdBuffer->getCommandBuffer(), VKTS_IMAGE_LENGTH / VKTS_LOCAL_SIZE, VKTS_IMAGE_LENGTH / VKTS_LOCAL_SIZE, 1);
//
result = cmdBuffer->endCommandBuffer();
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not end command buffer.");
return VK_FALSE;
}
return VK_TRUE;
}
void buildCommandBuffers()
{
// Destroy command buffers if already present
if (!checkCommandBuffers())
{
destroyCommandBuffers();
createCommandBuffers();
}
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
VkClearValue clearValues[2];
clearValues[0].color = defaultClearColor;
clearValues[1].depthStencil = { 1.0f, 0 };
VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();
renderPassBeginInfo.renderPass = renderPass;
renderPassBeginInfo.renderArea.offset.x = 0;
renderPassBeginInfo.renderArea.offset.y = 0;
renderPassBeginInfo.renderArea.extent.width = width;
renderPassBeginInfo.renderArea.extent.height = height;
renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = clearValues;
for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
{
// Set target frame buffer
renderPassBeginInfo.framebuffer = frameBuffers[i];
VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
// Compute particle movement
// Add memory barrier to ensure that the (rendering) vertex shader operations have finished
// Required as the compute shader will overwrite the vertex buffer data
VkBufferMemoryBarrier bufferBarrier = vkTools::initializers::bufferMemoryBarrier();
// Vertex shader invocations have finished reading from the buffer
bufferBarrier.srcAccessMask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
// Compute shader buffer read and write
bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
bufferBarrier.buffer = computeStorageBuffer.buffer;
bufferBarrier.size = computeStorageBuffer.descriptor.range;
bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
VK_FLAGS_NONE,
0, nullptr,
1, &bufferBarrier,
0, nullptr);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_COMPUTE, pipelines.compute);
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 0, 1, &computeDescriptorSet, 0, 0);
// Dispatch the compute job
vkCmdDispatch(drawCmdBuffers[i], PARTICLE_COUNT / 16, 1, 1);
// Add memory barrier to ensure that compute shader has finished writing to the buffer
// Without this the (rendering) vertex shader may display incomplete results (partial data from last frame)
// Compute shader has finished writes to the buffer
bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
// Vertex shader access (attribute binding)
bufferBarrier.dstAccessMask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
bufferBarrier.buffer = computeStorageBuffer.buffer;
bufferBarrier.size = computeStorageBuffer.descriptor.range;
bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
VK_FLAGS_NONE,
0, nullptr,
1, &bufferBarrier,
0, nullptr);
// Draw the particle system using the update vertex buffer
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
VkViewport viewport = vkTools::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
VkRect2D scissor = vkTools::initializers::rect2D(width, height, 0, 0);
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.postCompute);
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSetPostCompute, 0, NULL);
VkDeviceSize offsets[1] = { 0 };
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &computeStorageBuffer.buffer, offsets);
vkCmdDraw(drawCmdBuffers[i], PARTICLE_COUNT, 1, 0, 0);
vkCmdEndRenderPass(drawCmdBuffers[i]);
VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
}
}
void CommandBuffer::dispatch(int x, int y, int z)
{
vkCmdDispatch(commandBuffer, x, y, z);
}
void BaseImage::ValidateContent(RandomNumberGenerator& rand)
{
/*
dstBuf has following layout:
For each of texels to be sampled, [0..valueCount):
struct {
in uint32_t pixelX;
in uint32_t pixelY;
out uint32_t pixelColor;
}
*/
const uint32_t valueCount = 128;
VkBufferCreateInfo dstBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
dstBufCreateInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
dstBufCreateInfo.size = valueCount * sizeof(uint32_t) * 3;
VmaAllocationCreateInfo dstBufAllocCreateInfo = {};
dstBufAllocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
dstBufAllocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
VkBuffer dstBuf = nullptr;
VmaAllocation dstBufAlloc = nullptr;
VmaAllocationInfo dstBufAllocInfo = {};
TEST( vmaCreateBuffer(g_hAllocator, &dstBufCreateInfo, &dstBufAllocCreateInfo, &dstBuf, &dstBufAlloc, &dstBufAllocInfo) == VK_SUCCESS );
// Fill dstBuf input data.
{
uint32_t* dstBufContent = (uint32_t*)dstBufAllocInfo.pMappedData;
for(uint32_t i = 0; i < valueCount; ++i)
{
const uint32_t x = rand.Generate() % m_CreateInfo.extent.width;
const uint32_t y = rand.Generate() % m_CreateInfo.extent.height;
dstBufContent[i * 3 ] = x;
dstBufContent[i * 3 + 1] = y;
dstBufContent[i * 3 + 2] = 0;
}
}
VkSamplerCreateInfo samplerCreateInfo = { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
samplerCreateInfo.magFilter = VK_FILTER_NEAREST;
samplerCreateInfo.minFilter = VK_FILTER_NEAREST;
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.unnormalizedCoordinates = VK_TRUE;
VkSampler sampler = nullptr;
TEST( vkCreateSampler( g_hDevice, &samplerCreateInfo, nullptr, &sampler) == VK_SUCCESS );
VkDescriptorSetLayoutBinding bindings[2] = {};
bindings[0].binding = 0;
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
bindings[0].descriptorCount = 1;
bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
bindings[0].pImmutableSamplers = &sampler;
bindings[1].binding = 1;
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
bindings[1].descriptorCount = 1;
bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutCreateInfo descSetLayoutCreateInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
descSetLayoutCreateInfo.bindingCount = 2;
descSetLayoutCreateInfo.pBindings = bindings;
VkDescriptorSetLayout descSetLayout = nullptr;
TEST( vkCreateDescriptorSetLayout(g_hDevice, &descSetLayoutCreateInfo, nullptr, &descSetLayout) == VK_SUCCESS );
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
pipelineLayoutCreateInfo.setLayoutCount = 1;
pipelineLayoutCreateInfo.pSetLayouts = &descSetLayout;
VkPipelineLayout pipelineLayout = nullptr;
TEST( vkCreatePipelineLayout(g_hDevice, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout) == VK_SUCCESS );
std::vector<char> shaderCode;
LoadShader(shaderCode, "SparseBindingTest.comp.spv");
VkShaderModuleCreateInfo shaderModuleCreateInfo = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
shaderModuleCreateInfo.codeSize = shaderCode.size();
shaderModuleCreateInfo.pCode = (const uint32_t*)shaderCode.data();
VkShaderModule shaderModule = nullptr;
TEST( vkCreateShaderModule(g_hDevice, &shaderModuleCreateInfo, nullptr, &shaderModule) == VK_SUCCESS );
VkComputePipelineCreateInfo pipelineCreateInfo = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
pipelineCreateInfo.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
pipelineCreateInfo.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
pipelineCreateInfo.stage.module = shaderModule;
pipelineCreateInfo.stage.pName = "main";
pipelineCreateInfo.layout = pipelineLayout;
VkPipeline pipeline = nullptr;
TEST( vkCreateComputePipelines(g_hDevice, nullptr, 1, &pipelineCreateInfo, nullptr, &pipeline) == VK_SUCCESS );
VkDescriptorPoolSize poolSizes[2] = {};
poolSizes[0].type = bindings[0].descriptorType;
poolSizes[0].descriptorCount = bindings[0].descriptorCount;
poolSizes[1].type = bindings[1].descriptorType;
poolSizes[1].descriptorCount = bindings[1].descriptorCount;
VkDescriptorPoolCreateInfo descPoolCreateInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
descPoolCreateInfo.maxSets = 1;
descPoolCreateInfo.poolSizeCount = 2;
descPoolCreateInfo.pPoolSizes = poolSizes;
VkDescriptorPool descPool = nullptr;
TEST( vkCreateDescriptorPool(g_hDevice, &descPoolCreateInfo, nullptr, &descPool) == VK_SUCCESS );
VkDescriptorSetAllocateInfo descSetAllocInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
descSetAllocInfo.descriptorPool = descPool;
descSetAllocInfo.descriptorSetCount = 1;
descSetAllocInfo.pSetLayouts = &descSetLayout;
VkDescriptorSet descSet = nullptr;
TEST( vkAllocateDescriptorSets(g_hDevice, &descSetAllocInfo, &descSet) == VK_SUCCESS );
VkImageViewCreateInfo imageViewCreateInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
imageViewCreateInfo.image = m_Image;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.format = m_CreateInfo.format;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCreateInfo.subresourceRange.layerCount = 1;
imageViewCreateInfo.subresourceRange.levelCount = 1;
VkImageView imageView = nullptr;
TEST( vkCreateImageView(g_hDevice, &imageViewCreateInfo, nullptr, &imageView) == VK_SUCCESS );
VkDescriptorImageInfo descImageInfo = {};
descImageInfo.imageView = imageView;
descImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
VkDescriptorBufferInfo descBufferInfo = {};
descBufferInfo.buffer = dstBuf;
descBufferInfo.offset = 0;
descBufferInfo.range = VK_WHOLE_SIZE;
VkWriteDescriptorSet descWrites[2] = {};
descWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descWrites[0].dstSet = descSet;
descWrites[0].dstBinding = bindings[0].binding;
descWrites[0].dstArrayElement = 0;
descWrites[0].descriptorCount = 1;
descWrites[0].descriptorType = bindings[0].descriptorType;
descWrites[0].pImageInfo = &descImageInfo;
descWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descWrites[1].dstSet = descSet;
descWrites[1].dstBinding = bindings[1].binding;
descWrites[1].dstArrayElement = 0;
descWrites[1].descriptorCount = 1;
descWrites[1].descriptorType = bindings[1].descriptorType;
descWrites[1].pBufferInfo = &descBufferInfo;
vkUpdateDescriptorSets(g_hDevice, 2, descWrites, 0, nullptr);
BeginSingleTimeCommands();
vkCmdBindPipeline(g_hTemporaryCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
vkCmdBindDescriptorSets(g_hTemporaryCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &descSet, 0, nullptr);
vkCmdDispatch(g_hTemporaryCommandBuffer, valueCount, 1, 1);
EndSingleTimeCommands();
// Validate dstBuf output data.
{
const uint32_t* dstBufContent = (const uint32_t*)dstBufAllocInfo.pMappedData;
for(uint32_t i = 0; i < valueCount; ++i)
{
const uint32_t x = dstBufContent[i * 3 ];
const uint32_t y = dstBufContent[i * 3 + 1];
const uint32_t color = dstBufContent[i * 3 + 2];
const uint8_t a = (uint8_t)(color >> 24);
const uint8_t b = (uint8_t)(color >> 16);
const uint8_t g = (uint8_t)(color >> 8);
const uint8_t r = (uint8_t)color;
TEST(r == (uint8_t)x && g == (uint8_t)y && b == 13 && a == 25);
}
}
vkDestroyImageView(g_hDevice, imageView, nullptr);
vkDestroyDescriptorPool(g_hDevice, descPool, nullptr);
vmaDestroyBuffer(g_hAllocator, dstBuf, dstBufAlloc);
vkDestroyPipeline(g_hDevice, pipeline, nullptr);
vkDestroyShaderModule(g_hDevice, shaderModule, nullptr);
vkDestroyPipelineLayout(g_hDevice, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(g_hDevice, descSetLayout, nullptr);
vkDestroySampler(g_hDevice, sampler, nullptr);
}
