d0211d1f14
Toggling validation via command line arguments is the preferred way anyway Define was also added as a CMake option
605 lines
30 KiB
C++
605 lines
30 KiB
C++
/*
|
|
* Vulkan Example - Variable rate shading
|
|
*
|
|
* Copyright (C) 2020-2023 by Sascha Willems - www.saschawillems.de
|
|
*
|
|
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
|
|
*/
|
|
|
|
#include "variablerateshading.h"
|
|
|
|
VulkanExample::VulkanExample() : VulkanExampleBase()
|
|
{
|
|
title = "Variable rate shading";
|
|
apiVersion = VK_API_VERSION_1_1;
|
|
camera.type = Camera::CameraType::firstperson;
|
|
camera.flipY = true;
|
|
camera.setPosition(glm::vec3(0.0f, 1.0f, 0.0f));
|
|
camera.setRotation(glm::vec3(0.0f, -90.0f, 0.0f));
|
|
camera.setPerspective(60.0f, (float)width / (float)height, 0.1f, 256.0f);
|
|
camera.setRotationSpeed(0.25f);
|
|
enabledInstanceExtensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
enabledDeviceExtensions.push_back(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
|
|
enabledDeviceExtensions.push_back(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
|
|
}
|
|
|
|
VulkanExample::~VulkanExample()
|
|
{
|
|
vkDestroyPipeline(device, pipelines.masked, nullptr);
|
|
vkDestroyPipeline(device, pipelines.opaque, nullptr);
|
|
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
|
|
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
|
|
vkDestroyImageView(device, shadingRateImage.view, nullptr);
|
|
vkDestroyImage(device, shadingRateImage.image, nullptr);
|
|
vkFreeMemory(device, shadingRateImage.memory, nullptr);
|
|
shaderData.buffer.destroy();
|
|
}
|
|
|
|
void VulkanExample::getEnabledFeatures()
|
|
{
|
|
enabledFeatures.samplerAnisotropy = deviceFeatures.samplerAnisotropy;
|
|
// POI
|
|
enabledPhysicalDeviceShadingRateImageFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
|
|
enabledPhysicalDeviceShadingRateImageFeaturesKHR.attachmentFragmentShadingRate = VK_TRUE;
|
|
enabledPhysicalDeviceShadingRateImageFeaturesKHR.pipelineFragmentShadingRate = VK_FALSE;
|
|
enabledPhysicalDeviceShadingRateImageFeaturesKHR.primitiveFragmentShadingRate = VK_FALSE;
|
|
deviceCreatepNextChain = &enabledPhysicalDeviceShadingRateImageFeaturesKHR;
|
|
}
|
|
|
|
/*
|
|
If the window has been resized, we need to recreate the shading rate image and the render pass. That's because the render pass holds information on the fragment shading rate image resolution
|
|
|
|
*/
|
|
void VulkanExample::handleResize()
|
|
{
|
|
vkDeviceWaitIdle(device);
|
|
// Invalidate the shading rate image, will be recreated in the renderpass setup
|
|
vkDestroyImageView(device, shadingRateImage.view, nullptr);
|
|
vkDestroyImage(device, shadingRateImage.image, nullptr);
|
|
vkFreeMemory(device, shadingRateImage.memory, nullptr);
|
|
prepareShadingRateImage();
|
|
// Recreate the render pass and update it with the new fragment shading rate image resolution
|
|
vkDestroyRenderPass(device, renderPass, nullptr);
|
|
setupRenderPass();
|
|
resized = false;
|
|
}
|
|
|
|
void VulkanExample::setupFrameBuffer()
|
|
{
|
|
if (resized) {
|
|
handleResize();
|
|
}
|
|
|
|
if (shadingRateImage.image == VK_NULL_HANDLE) {
|
|
prepareShadingRateImage();
|
|
}
|
|
|
|
VkImageView attachments[3];
|
|
|
|
// Depth/Stencil attachment is the same for all frame buffers
|
|
attachments[1] = depthStencil.view;
|
|
// Fragment shading rate attachment
|
|
attachments[2] = shadingRateImage.view;
|
|
|
|
VkFramebufferCreateInfo frameBufferCreateInfo{};
|
|
frameBufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
|
frameBufferCreateInfo.renderPass = renderPass;
|
|
frameBufferCreateInfo.attachmentCount = 3;
|
|
frameBufferCreateInfo.pAttachments = attachments;
|
|
frameBufferCreateInfo.width = width;
|
|
frameBufferCreateInfo.height = height;
|
|
frameBufferCreateInfo.layers = 1;
|
|
|
|
// Create frame buffers for every swap chain image
|
|
frameBuffers.resize(swapChain.imageCount);
|
|
for (uint32_t i = 0; i < frameBuffers.size(); i++)
|
|
{
|
|
attachments[0] = swapChain.buffers[i].view;
|
|
VK_CHECK_RESULT(vkCreateFramebuffer(device, &frameBufferCreateInfo, nullptr, &frameBuffers[i]));
|
|
}
|
|
}
|
|
|
|
void VulkanExample::setupRenderPass()
|
|
{
|
|
// Note that we need to use ...2KHR types in here, as fragment shading rate requires additional properties and structs to be passed at renderpass creation
|
|
if (!vkCreateRenderPass2KHR) {
|
|
vkCreateRenderPass2KHR = reinterpret_cast<PFN_vkCreateRenderPass2KHR>(vkGetInstanceProcAddr(instance, "vkCreateRenderPass2KHR"));
|
|
}
|
|
|
|
if (shadingRateImage.image == VK_NULL_HANDLE) {
|
|
prepareShadingRateImage();
|
|
}
|
|
|
|
std::array<VkAttachmentDescription2KHR, 3> attachments = {};
|
|
// Color attachment
|
|
attachments[0].sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
|
|
attachments[0].format = swapChain.colorFormat;
|
|
attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
|
|
attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
|
attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
attachments[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
attachments[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
|
// Depth attachment
|
|
attachments[1].sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
|
|
attachments[1].format = depthFormat;
|
|
attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
|
|
attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
|
attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
attachments[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
attachments[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
|
// Fragment shading rate attachment
|
|
attachments[2].sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
|
|
attachments[2].format = VK_FORMAT_R8_UINT;
|
|
attachments[2].samples = VK_SAMPLE_COUNT_1_BIT;
|
|
attachments[2].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
|
|
attachments[2].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
attachments[2].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
attachments[2].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
attachments[2].initialLayout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
|
|
attachments[2].finalLayout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
|
|
|
|
VkAttachmentReference2KHR colorReference = {};
|
|
colorReference.sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
|
|
colorReference.attachment = 0;
|
|
colorReference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
colorReference.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
|
|
VkAttachmentReference2KHR depthReference = {};
|
|
depthReference.sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
|
|
depthReference.attachment = 1;
|
|
depthReference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
|
depthReference.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
|
|
|
// Setup the attachment reference for the shading rate image attachment in slot 2
|
|
VkAttachmentReference2 fragmentShadingRateReference{};
|
|
fragmentShadingRateReference.sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
|
|
fragmentShadingRateReference.attachment = 2;
|
|
fragmentShadingRateReference.layout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
|
|
|
|
// Setup the attachment info for the shading rate image, which will be added to the sub pass via structure chaining (in pNext)
|
|
VkFragmentShadingRateAttachmentInfoKHR fragmentShadingRateAttachmentInfo{};
|
|
fragmentShadingRateAttachmentInfo.sType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
|
|
fragmentShadingRateAttachmentInfo.pFragmentShadingRateAttachment = &fragmentShadingRateReference;
|
|
fragmentShadingRateAttachmentInfo.shadingRateAttachmentTexelSize.width = physicalDeviceShadingRateImageProperties.maxFragmentShadingRateAttachmentTexelSize.width;
|
|
fragmentShadingRateAttachmentInfo.shadingRateAttachmentTexelSize.height = physicalDeviceShadingRateImageProperties.maxFragmentShadingRateAttachmentTexelSize.height;
|
|
|
|
VkSubpassDescription2KHR subpassDescription = {};
|
|
subpassDescription.sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2;
|
|
subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
|
subpassDescription.colorAttachmentCount = 1;
|
|
subpassDescription.pColorAttachments = &colorReference;
|
|
subpassDescription.pDepthStencilAttachment = &depthReference;
|
|
subpassDescription.inputAttachmentCount = 0;
|
|
subpassDescription.pInputAttachments = nullptr;
|
|
subpassDescription.preserveAttachmentCount = 0;
|
|
subpassDescription.pPreserveAttachments = nullptr;
|
|
subpassDescription.pResolveAttachments = nullptr;
|
|
subpassDescription.pNext = &fragmentShadingRateAttachmentInfo;
|
|
|
|
// Subpass dependencies for layout transitions
|
|
std::array<VkSubpassDependency2KHR, 2> dependencies = {};
|
|
|
|
dependencies[0].sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
|
|
dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
|
|
dependencies[0].dstSubpass = 0;
|
|
dependencies[0].srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
|
|
dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
|
dependencies[0].srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
|
|
dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
dependencies[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
|
|
|
dependencies[1].sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
|
|
dependencies[1].srcSubpass = 0;
|
|
dependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;
|
|
dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
|
dependencies[1].dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
|
|
dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
dependencies[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
|
|
dependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
|
|
|
VkRenderPassCreateInfo2KHR renderPassCI = {};
|
|
renderPassCI.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2;
|
|
renderPassCI.attachmentCount = static_cast<uint32_t>(attachments.size());
|
|
renderPassCI.pAttachments = attachments.data();
|
|
renderPassCI.subpassCount = 1;
|
|
renderPassCI.pSubpasses = &subpassDescription;
|
|
renderPassCI.dependencyCount = static_cast<uint32_t>(dependencies.size());
|
|
renderPassCI.pDependencies = dependencies.data();
|
|
|
|
VK_CHECK_RESULT(vkCreateRenderPass2KHR(device, &renderPassCI, nullptr, &renderPass));
|
|
}
|
|
|
|
void VulkanExample::buildCommandBuffers()
|
|
{
|
|
// As this is an extension, we need to manually load the extension pointers
|
|
if (!vkCmdSetFragmentShadingRateKHR) {
|
|
vkCmdSetFragmentShadingRateKHR = reinterpret_cast<PFN_vkCmdSetFragmentShadingRateKHR>(vkGetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateKHR"));
|
|
}
|
|
|
|
VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
|
|
|
|
VkClearValue clearValues[3];
|
|
clearValues[0].color = { { 0.25f, 0.25f, 0.25f, 1.0f } };;
|
|
clearValues[1].depthStencil = { 1.0f, 0 };
|
|
clearValues[2].color = { {0.0f, 0.0f, 0.0f, 0.0f} };
|
|
|
|
VkRenderPassBeginInfo renderPassBeginInfo = vks::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 = 3;
|
|
renderPassBeginInfo.pClearValues = clearValues;
|
|
|
|
const VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
|
|
const VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
|
|
|
|
for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
|
|
{
|
|
renderPassBeginInfo.framebuffer = frameBuffers[i];
|
|
VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
|
|
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
|
|
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
|
|
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
|
|
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);
|
|
|
|
// Set the fragment shading rate state for the current pipeline
|
|
VkExtent2D fragmentSize = { 1, 1 };
|
|
VkFragmentShadingRateCombinerOpKHR combinerOps[2];
|
|
// The combiners determine how the different shading rate values for the pipeline, primitives and attachment are combined
|
|
if (enableShadingRate)
|
|
{
|
|
// If shading rate from attachment is enabled, we set the combiner, so that the values from the attachment are used
|
|
// Combiner for pipeline (A) and primitive (B) - Not used in this sample
|
|
combinerOps[0] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR;
|
|
// Combiner for pipeline (A) and attachment (B), replace the pipeline default value (fragment_size) with the fragment sizes stored in the attachment
|
|
combinerOps[1] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR;
|
|
}
|
|
else
|
|
{
|
|
// If shading rate from attachment is disabled, we keep the value set via the dynamic state
|
|
combinerOps[0] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR;
|
|
combinerOps[1] = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR;
|
|
}
|
|
vkCmdSetFragmentShadingRateKHR(drawCmdBuffers[i], &fragmentSize, combinerOps);
|
|
|
|
// Render the scene
|
|
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.opaque);
|
|
scene.draw(drawCmdBuffers[i], vkglTF::RenderFlags::BindImages | vkglTF::RenderFlags::RenderOpaqueNodes, pipelineLayout);
|
|
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.masked);
|
|
scene.draw(drawCmdBuffers[i], vkglTF::RenderFlags::BindImages | vkglTF::RenderFlags::RenderAlphaMaskedNodes, pipelineLayout);
|
|
|
|
drawUI(drawCmdBuffers[i]);
|
|
vkCmdEndRenderPass(drawCmdBuffers[i]);
|
|
VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
|
|
}
|
|
}
|
|
|
|
void VulkanExample::loadAssets()
|
|
{
|
|
vkglTF::descriptorBindingFlags = vkglTF::DescriptorBindingFlags::ImageBaseColor | vkglTF::DescriptorBindingFlags::ImageNormalMap;
|
|
scene.loadFromFile(getAssetPath() + "models/sponza/sponza.gltf", vulkanDevice, queue, vkglTF::FileLoadingFlags::PreTransformVertices);
|
|
}
|
|
|
|
void VulkanExample::setupDescriptors()
|
|
{
|
|
// Pool
|
|
const std::vector<VkDescriptorPoolSize> poolSizes = {
|
|
vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),
|
|
};
|
|
VkDescriptorPoolCreateInfo descriptorPoolInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, 1);
|
|
VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
|
|
|
|
// Descriptor set layout
|
|
const std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {
|
|
vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0),
|
|
};
|
|
VkDescriptorSetLayoutCreateInfo descriptorLayout = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);
|
|
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
|
|
|
|
// Pipeline layout
|
|
const std::vector<VkDescriptorSetLayout> setLayouts = {
|
|
descriptorSetLayout,
|
|
vkglTF::descriptorSetLayoutImage,
|
|
};
|
|
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = vks::initializers::pipelineLayoutCreateInfo(setLayouts.data(), 2);
|
|
VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));
|
|
|
|
// Descriptor set
|
|
VkDescriptorSetAllocateInfo allocInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);
|
|
VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
|
|
std::vector<VkWriteDescriptorSet> writeDescriptorSets = {
|
|
vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &shaderData.buffer.descriptor),
|
|
};
|
|
vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, nullptr);
|
|
}
|
|
|
|
// [POI]
|
|
void VulkanExample::prepareShadingRateImage()
|
|
{
|
|
// As this is an extension, we need to manually load the extension pointers
|
|
if (!vkGetPhysicalDeviceFragmentShadingRatesKHR) {
|
|
vkGetPhysicalDeviceFragmentShadingRatesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR>(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR"));
|
|
}
|
|
|
|
// Get properties of this extensions, which also contains texel sizes required to setup the image
|
|
physicalDeviceShadingRateImageProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
|
|
VkPhysicalDeviceProperties2 deviceProperties2{};
|
|
deviceProperties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
|
|
deviceProperties2.pNext = &physicalDeviceShadingRateImageProperties;
|
|
vkGetPhysicalDeviceProperties2(physicalDevice, &deviceProperties2);
|
|
|
|
// We need to check if the requested format for the shading rate attachment supports the required flag
|
|
const VkFormat imageFormat = VK_FORMAT_R8_UINT;
|
|
VkFormatProperties formatProperties;
|
|
vkGetPhysicalDeviceFormatProperties(physicalDevice, imageFormat, &formatProperties);
|
|
if (!(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR))
|
|
{
|
|
throw std::runtime_error("Selected shading rate attachment image format does not fragment shading rate");
|
|
}
|
|
|
|
// Shading rate image size depends on shading rate texel size
|
|
// For each texel in the target image, there is a corresponding shading texel size width x height block in the shading rate image
|
|
VkExtent3D imageExtent{};
|
|
imageExtent.width = static_cast<uint32_t>(ceil(width / (float)physicalDeviceShadingRateImageProperties.maxFragmentShadingRateAttachmentTexelSize.width));
|
|
imageExtent.height = static_cast<uint32_t>(ceil(height / (float)physicalDeviceShadingRateImageProperties.maxFragmentShadingRateAttachmentTexelSize.height));
|
|
imageExtent.depth = 1;
|
|
|
|
VkImageCreateInfo imageCI{};
|
|
imageCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
imageCI.imageType = VK_IMAGE_TYPE_2D;
|
|
imageCI.format = imageFormat;
|
|
imageCI.extent = imageExtent;
|
|
imageCI.mipLevels = 1;
|
|
imageCI.arrayLayers = 1;
|
|
imageCI.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
imageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
imageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
imageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
imageCI.usage = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
VK_CHECK_RESULT(vkCreateImage(device, &imageCI, nullptr, &shadingRateImage.image));
|
|
VkMemoryRequirements memReqs{};
|
|
vkGetImageMemoryRequirements(device, shadingRateImage.image, &memReqs);
|
|
|
|
VkMemoryAllocateInfo memAllloc{};
|
|
memAllloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
memAllloc.allocationSize = memReqs.size;
|
|
memAllloc.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
|
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllloc, nullptr, &shadingRateImage.memory));
|
|
VK_CHECK_RESULT(vkBindImageMemory(device, shadingRateImage.image, shadingRateImage.memory, 0));
|
|
|
|
VkImageViewCreateInfo imageViewCI{};
|
|
imageViewCI.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
imageViewCI.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
imageViewCI.image = shadingRateImage.image;
|
|
imageViewCI.format = VK_FORMAT_R8_UINT;
|
|
imageViewCI.subresourceRange.baseMipLevel = 0;
|
|
imageViewCI.subresourceRange.levelCount = 1;
|
|
imageViewCI.subresourceRange.baseArrayLayer = 0;
|
|
imageViewCI.subresourceRange.layerCount = 1;
|
|
imageViewCI.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
VK_CHECK_RESULT(vkCreateImageView(device, &imageViewCI, nullptr, &shadingRateImage.view));
|
|
|
|
// The shading rates are stored in a buffer that'll be copied to the shading rate image
|
|
VkDeviceSize bufferSize = imageExtent.width * imageExtent.height * sizeof(uint8_t);
|
|
|
|
// Fragment sizes are encoded in a single texel as follows:
|
|
// size(w) = 2^((texel/4) & 3)
|
|
// size(h)h = 2^(texel & 3)
|
|
|
|
// Populate it with the lowest possible shading rate
|
|
uint8_t val = (4 >> 1) | (4 << 1);
|
|
uint8_t* shadingRatePatternData = new uint8_t[bufferSize];
|
|
memset(shadingRatePatternData, val, bufferSize);
|
|
|
|
// Get a list of available shading rate patterns
|
|
std::vector<VkPhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates{};
|
|
uint32_t fragmentShadingRatesCount = 0;
|
|
vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, &fragmentShadingRatesCount, nullptr);
|
|
if (fragmentShadingRatesCount > 0) {
|
|
fragmentShadingRates.resize(fragmentShadingRatesCount);
|
|
for (VkPhysicalDeviceFragmentShadingRateKHR& fragmentShadingRate : fragmentShadingRates) {
|
|
// In addition to the value, we also need to set the sType for each rate to comply with the spec or else the call to vkGetPhysicalDeviceFragmentShadingRatesKHR will result in undefined behaviour
|
|
fragmentShadingRate.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
|
|
}
|
|
vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, &fragmentShadingRatesCount, fragmentShadingRates.data());
|
|
}
|
|
// Create a circular pattern from the available list of fragment shading rates with decreasing sampling rates outwards (max. range, pattern)
|
|
// Shading rates returned by vkGetPhysicalDeviceFragmentShadingRatesKHR are ordered from largest to smallest
|
|
std::map<float, uint8_t> patternLookup{};
|
|
float range = 25.0f / static_cast<uint32_t>(fragmentShadingRates.size());
|
|
float currentRange = 8.0f;
|
|
for (size_t i = fragmentShadingRates.size() - 1; i > 0; i--) {
|
|
uint32_t rate_v = fragmentShadingRates[i].fragmentSize.width == 1 ? 0 : (fragmentShadingRates[i].fragmentSize.width >> 1);
|
|
uint32_t rate_h = fragmentShadingRates[i].fragmentSize.height == 1 ? 0 : (fragmentShadingRates[i].fragmentSize.height << 1);
|
|
patternLookup[currentRange] = rate_v | rate_h;
|
|
currentRange += range;
|
|
}
|
|
|
|
uint8_t* ptrData = shadingRatePatternData;
|
|
for (uint32_t y = 0; y < imageExtent.height; y++) {
|
|
for (uint32_t x = 0; x < imageExtent.width; x++) {
|
|
const float deltaX = (static_cast<float>(imageExtent.width) / 2.0f - static_cast<float>(x)) / imageExtent.width * 100.0f;
|
|
const float deltaY = (static_cast<float>(imageExtent.height) / 2.0f - static_cast<float>(y)) / imageExtent.height * 100.0f;
|
|
const float dist = std::sqrt(deltaX * deltaX + deltaY * deltaY);
|
|
for (auto pattern : patternLookup) {
|
|
if (dist < pattern.first) {
|
|
*ptrData = pattern.second;
|
|
break;
|
|
}
|
|
}
|
|
ptrData++;
|
|
}
|
|
}
|
|
|
|
// Copy the shading rate pattern to the shading rate image
|
|
|
|
VkBuffer stagingBuffer;
|
|
VkDeviceMemory stagingMemory;
|
|
|
|
VkBufferCreateInfo bufferCreateInfo{};
|
|
bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
|
bufferCreateInfo.size = bufferSize;
|
|
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
|
bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
VK_CHECK_RESULT(vkCreateBuffer(device, &bufferCreateInfo, nullptr, &stagingBuffer));
|
|
VkMemoryAllocateInfo memAllocInfo{};
|
|
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
memReqs = {};
|
|
vkGetBufferMemoryRequirements(device, stagingBuffer, &memReqs);
|
|
memAllocInfo.allocationSize = memReqs.size;
|
|
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
|
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &stagingMemory));
|
|
VK_CHECK_RESULT(vkBindBufferMemory(device, stagingBuffer, stagingMemory, 0));
|
|
|
|
uint8_t* mapped;
|
|
VK_CHECK_RESULT(vkMapMemory(device, stagingMemory, 0, memReqs.size, 0, (void**)&mapped));
|
|
memcpy(mapped, shadingRatePatternData, bufferSize);
|
|
vkUnmapMemory(device, stagingMemory);
|
|
|
|
delete[] shadingRatePatternData;
|
|
|
|
// Upload
|
|
VkCommandBuffer copyCmd = vulkanDevice->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
|
|
VkImageSubresourceRange subresourceRange = {};
|
|
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
subresourceRange.levelCount = 1;
|
|
subresourceRange.layerCount = 1;
|
|
{
|
|
VkImageMemoryBarrier imageMemoryBarrier{};
|
|
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
|
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
|
imageMemoryBarrier.srcAccessMask = 0;
|
|
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
imageMemoryBarrier.image = shadingRateImage.image;
|
|
imageMemoryBarrier.subresourceRange = subresourceRange;
|
|
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
|
|
}
|
|
VkBufferImageCopy bufferCopyRegion{};
|
|
bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
bufferCopyRegion.imageSubresource.layerCount = 1;
|
|
bufferCopyRegion.imageExtent.width = imageExtent.width;
|
|
bufferCopyRegion.imageExtent.height = imageExtent.height;
|
|
bufferCopyRegion.imageExtent.depth = 1;
|
|
vkCmdCopyBufferToImage(copyCmd, stagingBuffer, shadingRateImage.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &bufferCopyRegion);
|
|
{
|
|
VkImageMemoryBarrier imageMemoryBarrier{};
|
|
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
|
imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
|
imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
|
|
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
imageMemoryBarrier.dstAccessMask = 0;
|
|
imageMemoryBarrier.image = shadingRateImage.image;
|
|
imageMemoryBarrier.subresourceRange = subresourceRange;
|
|
vkCmdPipelineBarrier(copyCmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);
|
|
}
|
|
vulkanDevice->flushCommandBuffer(copyCmd, queue, true);
|
|
|
|
vkFreeMemory(device, stagingMemory, nullptr);
|
|
vkDestroyBuffer(device, stagingBuffer, nullptr);
|
|
}
|
|
|
|
void VulkanExample::preparePipelines()
|
|
{
|
|
VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
|
|
VkPipelineRasterizationStateCreateInfo rasterizationStateCI = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);
|
|
VkPipelineColorBlendAttachmentState blendAttachmentStateCI = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
|
|
VkPipelineColorBlendStateCreateInfo colorBlendStateCI = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentStateCI);
|
|
VkPipelineDepthStencilStateCreateInfo depthStencilStateCI = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL);
|
|
VkPipelineViewportStateCreateInfo viewportStateCI = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
|
|
VkPipelineMultisampleStateCreateInfo multisampleStateCI = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0);
|
|
const std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR };
|
|
VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables.data(), static_cast<uint32_t>(dynamicStateEnables.size()), 0);
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
|
|
|
|
VkGraphicsPipelineCreateInfo pipelineCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0);
|
|
pipelineCI.pInputAssemblyState = &inputAssemblyStateCI;
|
|
pipelineCI.pRasterizationState = &rasterizationStateCI;
|
|
pipelineCI.pColorBlendState = &colorBlendStateCI;
|
|
pipelineCI.pMultisampleState = &multisampleStateCI;
|
|
pipelineCI.pViewportState = &viewportStateCI;
|
|
pipelineCI.pDepthStencilState = &depthStencilStateCI;
|
|
pipelineCI.pDynamicState = &dynamicStateCI;
|
|
pipelineCI.stageCount = static_cast<uint32_t>(shaderStages.size());
|
|
pipelineCI.pStages = shaderStages.data();
|
|
pipelineCI.pVertexInputState = vkglTF::Vertex::getPipelineVertexInputState({ vkglTF::VertexComponent::Position, vkglTF::VertexComponent::Normal, vkglTF::VertexComponent::UV, vkglTF::VertexComponent::Color, vkglTF::VertexComponent::Tangent });
|
|
|
|
shaderStages[0] = loadShader(getShadersPath() + "variablerateshading/scene.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shaderStages[1] = loadShader(getShadersPath() + "variablerateshading/scene.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
|
|
// Properties for alpha masked materials will be passed via specialization constants
|
|
struct SpecializationData {
|
|
VkBool32 alphaMask;
|
|
float alphaMaskCutoff;
|
|
} specializationData;
|
|
specializationData.alphaMask = false;
|
|
specializationData.alphaMaskCutoff = 0.5f;
|
|
const std::vector<VkSpecializationMapEntry> specializationMapEntries = {
|
|
vks::initializers::specializationMapEntry(0, offsetof(SpecializationData, alphaMask), sizeof(SpecializationData::alphaMask)),
|
|
vks::initializers::specializationMapEntry(1, offsetof(SpecializationData, alphaMaskCutoff), sizeof(SpecializationData::alphaMaskCutoff)),
|
|
};
|
|
VkSpecializationInfo specializationInfo = vks::initializers::specializationInfo(specializationMapEntries, sizeof(specializationData), &specializationData);
|
|
shaderStages[1].pSpecializationInfo = &specializationInfo;
|
|
VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipelines.opaque));
|
|
|
|
specializationData.alphaMask = true;
|
|
rasterizationStateCI.cullMode = VK_CULL_MODE_NONE;
|
|
VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCI, nullptr, &pipelines.masked));
|
|
}
|
|
|
|
void VulkanExample::prepareUniformBuffers()
|
|
{
|
|
VK_CHECK_RESULT(vulkanDevice->createBuffer(
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&shaderData.buffer,
|
|
sizeof(shaderData.values)));
|
|
VK_CHECK_RESULT(shaderData.buffer.map());
|
|
updateUniformBuffers();
|
|
}
|
|
|
|
void VulkanExample::updateUniformBuffers()
|
|
{
|
|
shaderData.values.projection = camera.matrices.perspective;
|
|
shaderData.values.view = camera.matrices.view;
|
|
shaderData.values.viewPos = camera.viewPos;
|
|
shaderData.values.colorShadingRate = colorShadingRate;
|
|
memcpy(shaderData.buffer.mapped, &shaderData.values, sizeof(shaderData.values));
|
|
}
|
|
|
|
void VulkanExample::prepare()
|
|
{
|
|
VulkanExampleBase::prepare();
|
|
loadAssets();
|
|
prepareUniformBuffers();
|
|
setupDescriptors();
|
|
preparePipelines();
|
|
buildCommandBuffers();
|
|
prepared = true;
|
|
}
|
|
|
|
void VulkanExample::render()
|
|
{
|
|
renderFrame();
|
|
if (camera.updated) {
|
|
updateUniformBuffers();
|
|
}
|
|
}
|
|
|
|
void VulkanExample::OnUpdateUIOverlay(vks::UIOverlay* overlay)
|
|
{
|
|
if (overlay->checkBox("Enable shading rate", &enableShadingRate)) {
|
|
buildCommandBuffers();
|
|
}
|
|
if (overlay->checkBox("Color shading rates", &colorShadingRate)) {
|
|
updateUniformBuffers();
|
|
}
|
|
}
|
|
|
|
VULKAN_EXAMPLE_MAIN()
|