941 lines
34 KiB
C++
941 lines
34 KiB
C++
|
/*
|
||
|
|
* Vulkan Example - Using subpasses for G-Buffer compositing
|
||
|
|
*
|
||
|
|
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de
|
||
|
|
*
|
||
|
|
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <assert.h>
|
||
|
|
#include <vector>
|
||
|
|
#include <random>
|
||
|
|
|
||
|
|
#define GLM_FORCE_RADIANS
|
||
|
|
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
|
||
|
|
#include <glm/glm.hpp>
|
||
|
|
#include <glm/gtc/matrix_transform.hpp>
|
||
|
|
|
||
|
|
#include <vulkan/vulkan.h>
|
||
|
|
#include "vulkanexamplebase.h"
|
||
|
|
|
||
|
|
#define VERTEX_BUFFER_BIND_ID 0
|
||
|
|
#define ENABLE_VALIDATION false
|
||
|
|
|
||
|
|
#define NUM_LIGHTS 32
|
||
|
|
|
||
|
|
// Vertex layout for this example
|
||
|
|
std::vector<vkMeshLoader::VertexLayout> vertexLayout =
|
||
|
|
{
|
||
|
|
vkMeshLoader::VERTEX_LAYOUT_POSITION,
|
||
|
|
vkMeshLoader::VERTEX_LAYOUT_COLOR,
|
||
|
|
vkMeshLoader::VERTEX_LAYOUT_NORMAL,
|
||
|
|
};
|
||
|
|
|
||
|
|
class VulkanExample : public VulkanExampleBase
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
struct {
|
||
|
|
vkMeshLoader::MeshBuffer scene;
|
||
|
|
} meshes;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
VkPipelineVertexInputStateCreateInfo inputState;
|
||
|
|
std::vector<VkVertexInputBindingDescription> bindingDescriptions;
|
||
|
|
std::vector<VkVertexInputAttributeDescription> attributeDescriptions;
|
||
|
|
} vertices;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
glm::mat4 projection;
|
||
|
|
glm::mat4 model;
|
||
|
|
glm::mat4 view;
|
||
|
|
} uboVS, uboOffscreenVS;
|
||
|
|
|
||
|
|
struct Light {
|
||
|
|
glm::vec4 position;
|
||
|
|
glm::vec3 color;
|
||
|
|
float radius;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct {
|
||
|
|
glm::vec4 viewPos;
|
||
|
|
Light lights[NUM_LIGHTS];
|
||
|
|
} uboFragmentLights;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
vkTools::UniformData vsOffscreen;
|
||
|
|
vkTools::UniformData fsLights;
|
||
|
|
} uniformData;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
VkPipeline offscreen;
|
||
|
|
} pipelines;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
VkPipelineLayout offscreen;
|
||
|
|
} pipelineLayouts;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
VkDescriptorSet scene;
|
||
|
|
} descriptorSets;
|
||
|
|
|
||
|
|
VkDescriptorSetLayout descriptorSetLayout;
|
||
|
|
|
||
|
|
// todo
|
||
|
|
struct {
|
||
|
|
VkPipelineLayout pipelineLayout;
|
||
|
|
VkPipeline pipeline;
|
||
|
|
VkDescriptorSetLayout descriptorSetLayout;
|
||
|
|
VkDescriptorSet descriptorSet;
|
||
|
|
} composition;
|
||
|
|
|
||
|
|
// Framebuffer for offscreen rendering
|
||
|
|
struct FrameBufferAttachment {
|
||
|
|
VkImage image;
|
||
|
|
VkDeviceMemory mem;
|
||
|
|
VkImageView view;
|
||
|
|
VkFormat format;
|
||
|
|
};
|
||
|
|
struct Attachments {
|
||
|
|
FrameBufferAttachment position, normal, albedo;
|
||
|
|
} attachments;
|
||
|
|
|
||
|
|
VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION)
|
||
|
|
{
|
||
|
|
enableTextOverlay = false;
|
||
|
|
title = "Vulkan Example - Subpasses";
|
||
|
|
camera.type = Camera::CameraType::firstperson;
|
||
|
|
camera.movementSpeed = 5.0f;
|
||
|
|
#ifndef __ANDROID__
|
||
|
|
camera.rotationSpeed = 0.25f;
|
||
|
|
#endif
|
||
|
|
camera.position = { 9.5f, 4.5f, -5.8f };
|
||
|
|
camera.setRotation(glm::vec3(-9.5f, 53.25f, 0.0f));
|
||
|
|
camera.setPerspective(60.0f, (float)width / (float)height, 0.1f, 256.0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
~VulkanExample()
|
||
|
|
{
|
||
|
|
// Clean up used Vulkan resources
|
||
|
|
// Note : Inherited destructor cleans up resources stored in base class
|
||
|
|
|
||
|
|
// Frame buffer
|
||
|
|
|
||
|
|
// Color attachments
|
||
|
|
vkDestroyImageView(device, attachments.position.view, nullptr);
|
||
|
|
vkDestroyImage(device, attachments.position.image, nullptr);
|
||
|
|
vkFreeMemory(device, attachments.position.mem, nullptr);
|
||
|
|
|
||
|
|
vkDestroyImageView(device, attachments.normal.view, nullptr);
|
||
|
|
vkDestroyImage(device, attachments.normal.image, nullptr);
|
||
|
|
vkFreeMemory(device, attachments.normal.mem, nullptr);
|
||
|
|
|
||
|
|
vkDestroyImageView(device, attachments.albedo.view, nullptr);
|
||
|
|
vkDestroyImage(device, attachments.albedo.image, nullptr);
|
||
|
|
vkFreeMemory(device, attachments.albedo.mem, nullptr);
|
||
|
|
|
||
|
|
vkDestroyPipeline(device, pipelines.offscreen, nullptr);
|
||
|
|
|
||
|
|
vkDestroyPipelineLayout(device, pipelineLayouts.offscreen, nullptr);
|
||
|
|
|
||
|
|
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
|
||
|
|
|
||
|
|
// Meshes
|
||
|
|
vkMeshLoader::freeMeshBufferResources(device, &meshes.scene);
|
||
|
|
|
||
|
|
// Uniform buffers
|
||
|
|
vkTools::destroyUniformData(device, &uniformData.vsOffscreen);
|
||
|
|
vkTools::destroyUniformData(device, &uniformData.fsLights);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Create a frame buffer attachment
|
||
|
|
void createAttachment(VkFormat format, VkImageUsageFlags usage, FrameBufferAttachment *attachment)
|
||
|
|
{
|
||
|
|
VkImageAspectFlags aspectMask = 0;
|
||
|
|
VkImageLayout imageLayout;
|
||
|
|
|
||
|
|
attachment->format = format;
|
||
|
|
|
||
|
|
if (usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
|
||
|
|
{
|
||
|
|
aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||
|
|
imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||
|
|
}
|
||
|
|
if (usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
|
||
|
|
{
|
||
|
|
aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
|
||
|
|
imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||
|
|
}
|
||
|
|
|
||
|
|
assert(aspectMask > 0);
|
||
|
|
|
||
|
|
VkImageCreateInfo image = vkTools::initializers::imageCreateInfo();
|
||
|
|
image.imageType = VK_IMAGE_TYPE_2D;
|
||
|
|
image.format = format;
|
||
|
|
image.extent.width = width;
|
||
|
|
image.extent.height = height;
|
||
|
|
image.extent.depth = 1;
|
||
|
|
image.mipLevels = 1;
|
||
|
|
image.arrayLayers = 1;
|
||
|
|
image.samples = VK_SAMPLE_COUNT_1_BIT;
|
||
|
|
image.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||
|
|
image.usage = usage | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT flag is required for input attachments;
|
||
|
|
image.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
|
|
|
||
|
|
VkMemoryAllocateInfo memAlloc = vkTools::initializers::memoryAllocateInfo();
|
||
|
|
VkMemoryRequirements memReqs;
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkCreateImage(device, &image, nullptr, &attachment->image));
|
||
|
|
vkGetImageMemoryRequirements(device, attachment->image, &memReqs);
|
||
|
|
memAlloc.allocationSize = memReqs.size;
|
||
|
|
memAlloc.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||
|
|
VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &attachment->mem));
|
||
|
|
VK_CHECK_RESULT(vkBindImageMemory(device, attachment->image, attachment->mem, 0));
|
||
|
|
|
||
|
|
VkImageViewCreateInfo imageView = vkTools::initializers::imageViewCreateInfo();
|
||
|
|
imageView.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||
|
|
imageView.format = format;
|
||
|
|
imageView.subresourceRange = {};
|
||
|
|
imageView.subresourceRange.aspectMask = aspectMask;
|
||
|
|
imageView.subresourceRange.baseMipLevel = 0;
|
||
|
|
imageView.subresourceRange.levelCount = 1;
|
||
|
|
imageView.subresourceRange.baseArrayLayer = 0;
|
||
|
|
imageView.subresourceRange.layerCount = 1;
|
||
|
|
imageView.image = attachment->image;
|
||
|
|
VK_CHECK_RESULT(vkCreateImageView(device, &imageView, nullptr, &attachment->view));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Create color attachments for the G-Buffer components
|
||
|
|
void createGBufferAttachments()
|
||
|
|
{
|
||
|
|
createAttachment(VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, &attachments.position); // (World space) Positions
|
||
|
|
createAttachment(VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, &attachments.normal); // (World space) Normals
|
||
|
|
createAttachment(VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, &attachments.albedo); // Albedo (color)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Override framebuffer setup from base class
|
||
|
|
// Deferred components will be used as frame buffer attachments
|
||
|
|
void setupFrameBuffer()
|
||
|
|
{
|
||
|
|
VkImageView attachments[5];
|
||
|
|
|
||
|
|
VkFramebufferCreateInfo frameBufferCreateInfo = {};
|
||
|
|
frameBufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
||
|
|
frameBufferCreateInfo.pNext = NULL;
|
||
|
|
frameBufferCreateInfo.renderPass = renderPass;
|
||
|
|
frameBufferCreateInfo.attachmentCount = 5;
|
||
|
|
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;
|
||
|
|
attachments[1] = this->attachments.position.view;
|
||
|
|
attachments[2] = this->attachments.normal.view;
|
||
|
|
attachments[3] = this->attachments.albedo.view;
|
||
|
|
attachments[4] = depthStencil.view;
|
||
|
|
VK_CHECK_RESULT(vkCreateFramebuffer(device, &frameBufferCreateInfo, nullptr, &frameBuffers[i]));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Override render pass setup from base class
|
||
|
|
void setupRenderPass()
|
||
|
|
{
|
||
|
|
createGBufferAttachments();
|
||
|
|
|
||
|
|
std::array<VkAttachmentDescription, 5> attachments{};
|
||
|
|
// Color attachment
|
||
|
|
attachments[0].format = 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;
|
||
|
|
|
||
|
|
// Deferred attachments
|
||
|
|
// Position
|
||
|
|
attachments[1].format = this->attachments.position.format;
|
||
|
|
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_DONT_CARE;
|
||
|
|
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||
|
|
attachments[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
|
|
attachments[1].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||
|
|
// Normals
|
||
|
|
attachments[2].format = this->attachments.normal.format;
|
||
|
|
attachments[2].samples = VK_SAMPLE_COUNT_1_BIT;
|
||
|
|
attachments[2].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||
|
|
attachments[2].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||
|
|
attachments[2].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||
|
|
attachments[2].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||
|
|
attachments[2].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
|
|
attachments[2].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||
|
|
// Albedo
|
||
|
|
attachments[3].format = this->attachments.albedo.format;
|
||
|
|
attachments[3].samples = VK_SAMPLE_COUNT_1_BIT;
|
||
|
|
attachments[3].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||
|
|
attachments[3].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||
|
|
attachments[3].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||
|
|
attachments[3].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||
|
|
attachments[3].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
|
|
attachments[3].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||
|
|
// Depth attachment
|
||
|
|
attachments[4].format = depthFormat;
|
||
|
|
attachments[4].samples = VK_SAMPLE_COUNT_1_BIT;
|
||
|
|
attachments[4].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||
|
|
attachments[4].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
||
|
|
attachments[4].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||
|
|
attachments[4].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||
|
|
attachments[4].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||
|
|
attachments[4].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||
|
|
|
||
|
|
std::array<VkSubpassDescription,2> subpassDescriptions{};
|
||
|
|
|
||
|
|
// First subpass: Fill G-Buffer components
|
||
|
|
|
||
|
|
VkAttachmentReference colorReferences[4];
|
||
|
|
colorReferences[0] = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
|
||
|
|
colorReferences[1] = { 1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
|
||
|
|
colorReferences[2] = { 2, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
|
||
|
|
colorReferences[3] = { 3, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
|
||
|
|
VkAttachmentReference depthReference = { 4, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
|
||
|
|
|
||
|
|
subpassDescriptions[0].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||
|
|
subpassDescriptions[0].colorAttachmentCount = 4;
|
||
|
|
subpassDescriptions[0].pColorAttachments = colorReferences;
|
||
|
|
subpassDescriptions[0].pDepthStencilAttachment = &depthReference;
|
||
|
|
|
||
|
|
// Second subpass: Final composition (using G-Buffer components)
|
||
|
|
|
||
|
|
VkAttachmentReference colorReference = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
|
||
|
|
|
||
|
|
VkAttachmentReference inputReferences[3];
|
||
|
|
inputReferences[0] = { 1, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
|
||
|
|
inputReferences[1] = { 2, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
|
||
|
|
inputReferences[2] = { 3, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL };
|
||
|
|
|
||
|
|
subpassDescriptions[1].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||
|
|
subpassDescriptions[1].colorAttachmentCount = 1;
|
||
|
|
subpassDescriptions[1].pColorAttachments = &colorReference;
|
||
|
|
subpassDescriptions[1].pDepthStencilAttachment = &depthReference;
|
||
|
|
subpassDescriptions[1].inputAttachmentCount = 3;
|
||
|
|
subpassDescriptions[1].pInputAttachments = inputReferences;
|
||
|
|
|
||
|
|
// Subpass dependencies for layout transitions
|
||
|
|
std::array<VkSubpassDependency, 3> dependencies;
|
||
|
|
|
||
|
|
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;
|
||
|
|
dependencies[0].srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
|
||
|
|
dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||
|
|
dependencies[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
||
|
|
|
||
|
|
// This dependency transitions the input attachment from color attachment to shader read
|
||
|
|
dependencies[1].srcSubpass = 0;
|
||
|
|
dependencies[1].dstSubpass = 1;
|
||
|
|
dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||
|
|
dependencies[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
||
|
|
dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||
|
|
dependencies[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
||
|
|
dependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
||
|
|
|
||
|
|
dependencies[2].srcSubpass = 0;
|
||
|
|
dependencies[2].dstSubpass = VK_SUBPASS_EXTERNAL;
|
||
|
|
dependencies[2].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||
|
|
dependencies[2].dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
|
||
|
|
dependencies[2].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||
|
|
dependencies[2].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
|
||
|
|
dependencies[2].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
|
||
|
|
|
||
|
|
VkRenderPassCreateInfo renderPassInfo = {};
|
||
|
|
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
||
|
|
renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
|
||
|
|
renderPassInfo.pAttachments = attachments.data();
|
||
|
|
renderPassInfo.subpassCount = static_cast<uint32_t>(subpassDescriptions.size());
|
||
|
|
renderPassInfo.pSubpasses = subpassDescriptions.data();
|
||
|
|
renderPassInfo.dependencyCount = static_cast<uint32_t>(dependencies.size());
|
||
|
|
renderPassInfo.pDependencies = dependencies.data();
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass));
|
||
|
|
}
|
||
|
|
|
||
|
|
void buildCommandBuffers()
|
||
|
|
{
|
||
|
|
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
|
||
|
|
|
||
|
|
VkClearValue clearValues[5];
|
||
|
|
clearValues[0].color = { { 0.0f, 0.0f, 0.0f, 0.0f } };
|
||
|
|
clearValues[1].color = { { 0.0f, 0.0f, 0.0f, 0.0f } };
|
||
|
|
clearValues[2].color = { { 0.0f, 0.0f, 0.0f, 0.0f } };
|
||
|
|
clearValues[3].color = { { 0.0f, 0.0f, 0.0f, 0.0f } };
|
||
|
|
clearValues[4].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 = 5;
|
||
|
|
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));
|
||
|
|
|
||
|
|
// First sub pass
|
||
|
|
// Renders the components of the scene to the G-Buffer atttachments
|
||
|
|
|
||
|
|
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);
|
||
|
|
|
||
|
|
VkDeviceSize offsets[1] = { 0 };
|
||
|
|
|
||
|
|
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.offscreen);
|
||
|
|
|
||
|
|
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.offscreen, 0, 1, &descriptorSets.scene, 0, NULL);
|
||
|
|
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.scene.vertices.buf, offsets);
|
||
|
|
vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.scene.indices.buf, 0, VK_INDEX_TYPE_UINT32);
|
||
|
|
vkCmdDrawIndexed(drawCmdBuffers[i], meshes.scene.indexCount, 1, 0, 0, 0);
|
||
|
|
|
||
|
|
// Second sub pass
|
||
|
|
// This subpass will use the G-Buffer components that have been filled in the first subpass as input attachment for the final compositing
|
||
|
|
|
||
|
|
vkCmdNextSubpass(drawCmdBuffers[i], VK_SUBPASS_CONTENTS_INLINE);
|
||
|
|
|
||
|
|
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, composition.pipeline);
|
||
|
|
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, composition.pipelineLayout, 0, 1, &composition.descriptorSet, 0, NULL);
|
||
|
|
vkCmdDraw(drawCmdBuffers[i], 3, 1, 0, 0);
|
||
|
|
|
||
|
|
vkCmdEndRenderPass(drawCmdBuffers[i]);
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void loadAssets()
|
||
|
|
{
|
||
|
|
loadMesh(getAssetPath() + "models/samplescene.dae", &meshes.scene, vertexLayout, 0.25f);
|
||
|
|
}
|
||
|
|
|
||
|
|
void setupVertexDescriptions()
|
||
|
|
{
|
||
|
|
// Binding description
|
||
|
|
vertices.bindingDescriptions.resize(1);
|
||
|
|
vertices.bindingDescriptions[0] =
|
||
|
|
vkTools::initializers::vertexInputBindingDescription(
|
||
|
|
VERTEX_BUFFER_BIND_ID,
|
||
|
|
vkMeshLoader::vertexSize(vertexLayout),
|
||
|
|
VK_VERTEX_INPUT_RATE_VERTEX);
|
||
|
|
|
||
|
|
// Attribute descriptions
|
||
|
|
vertices.attributeDescriptions.resize(3);
|
||
|
|
// Location 0: Position
|
||
|
|
vertices.attributeDescriptions[0] =
|
||
|
|
vkTools::initializers::vertexInputAttributeDescription(
|
||
|
|
VERTEX_BUFFER_BIND_ID,
|
||
|
|
0,
|
||
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
||
|
|
0);
|
||
|
|
// Location 1: Color
|
||
|
|
vertices.attributeDescriptions[1] =
|
||
|
|
vkTools::initializers::vertexInputAttributeDescription(
|
||
|
|
VERTEX_BUFFER_BIND_ID,
|
||
|
|
1,
|
||
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
||
|
|
sizeof(float) * 3);
|
||
|
|
// Location 2: Normal
|
||
|
|
vertices.attributeDescriptions[2] =
|
||
|
|
vkTools::initializers::vertexInputAttributeDescription(
|
||
|
|
VERTEX_BUFFER_BIND_ID,
|
||
|
|
2,
|
||
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
||
|
|
sizeof(float) * 6);
|
||
|
|
|
||
|
|
vertices.inputState = vkTools::initializers::pipelineVertexInputStateCreateInfo();
|
||
|
|
vertices.inputState.vertexBindingDescriptionCount = static_cast<uint32_t>(vertices.bindingDescriptions.size());
|
||
|
|
vertices.inputState.pVertexBindingDescriptions = vertices.bindingDescriptions.data();
|
||
|
|
vertices.inputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertices.attributeDescriptions.size());
|
||
|
|
vertices.inputState.pVertexAttributeDescriptions = vertices.attributeDescriptions.data();
|
||
|
|
}
|
||
|
|
|
||
|
|
void setupDescriptorPool()
|
||
|
|
{
|
||
|
|
std::vector<VkDescriptorPoolSize> poolSizes =
|
||
|
|
{
|
||
|
|
vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 8),
|
||
|
|
vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 9),
|
||
|
|
vkTools::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 3),
|
||
|
|
};
|
||
|
|
|
||
|
|
VkDescriptorPoolCreateInfo descriptorPoolInfo =
|
||
|
|
vkTools::initializers::descriptorPoolCreateInfo(
|
||
|
|
static_cast<uint32_t>(poolSizes.size()),
|
||
|
|
poolSizes.data(),
|
||
|
|
4);
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
|
||
|
|
}
|
||
|
|
|
||
|
|
void setupDescriptorSetLayout()
|
||
|
|
{
|
||
|
|
// Deferred shading layout
|
||
|
|
std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =
|
||
|
|
{
|
||
|
|
// Binding 0 : Vertex shader uniform buffer
|
||
|
|
vkTools::initializers::descriptorSetLayoutBinding(
|
||
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
||
|
|
VK_SHADER_STAGE_VERTEX_BIT,
|
||
|
|
0)
|
||
|
|
};
|
||
|
|
|
||
|
|
VkDescriptorSetLayoutCreateInfo descriptorLayout =
|
||
|
|
vkTools::initializers::descriptorSetLayoutCreateInfo(
|
||
|
|
setLayoutBindings.data(),
|
||
|
|
static_cast<uint32_t>(setLayoutBindings.size()));
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
|
||
|
|
|
||
|
|
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
|
||
|
|
vkTools::initializers::pipelineLayoutCreateInfo(
|
||
|
|
&descriptorSetLayout,
|
||
|
|
1);
|
||
|
|
|
||
|
|
// Offscreen (scene) rendering pipeline layout
|
||
|
|
VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayouts.offscreen));
|
||
|
|
}
|
||
|
|
|
||
|
|
void setupDescriptorSet()
|
||
|
|
{
|
||
|
|
std::vector<VkWriteDescriptorSet> writeDescriptorSets;
|
||
|
|
|
||
|
|
VkDescriptorSetAllocateInfo allocInfo =
|
||
|
|
vkTools::initializers::descriptorSetAllocateInfo(
|
||
|
|
descriptorPool,
|
||
|
|
&descriptorSetLayout,
|
||
|
|
1);
|
||
|
|
|
||
|
|
// Background
|
||
|
|
VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.scene));
|
||
|
|
writeDescriptorSets =
|
||
|
|
{
|
||
|
|
// Binding 0: Vertex shader uniform buffer
|
||
|
|
vkTools::initializers::writeDescriptorSet(
|
||
|
|
descriptorSets.scene,
|
||
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
||
|
|
0,
|
||
|
|
&uniformData.vsOffscreen.descriptor)
|
||
|
|
};
|
||
|
|
vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
void preparePipelines()
|
||
|
|
{
|
||
|
|
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
|
||
|
|
vkTools::initializers::pipelineInputAssemblyStateCreateInfo(
|
||
|
|
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
|
||
|
|
0,
|
||
|
|
VK_FALSE);
|
||
|
|
|
||
|
|
VkPipelineRasterizationStateCreateInfo rasterizationState =
|
||
|
|
vkTools::initializers::pipelineRasterizationStateCreateInfo(
|
||
|
|
VK_POLYGON_MODE_FILL,
|
||
|
|
VK_CULL_MODE_BACK_BIT,
|
||
|
|
VK_FRONT_FACE_CLOCKWISE,
|
||
|
|
0);
|
||
|
|
|
||
|
|
VkPipelineColorBlendAttachmentState blendAttachmentState =
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(
|
||
|
|
0xf,
|
||
|
|
VK_FALSE);
|
||
|
|
|
||
|
|
VkPipelineColorBlendStateCreateInfo colorBlendState =
|
||
|
|
vkTools::initializers::pipelineColorBlendStateCreateInfo(
|
||
|
|
1,
|
||
|
|
&blendAttachmentState);
|
||
|
|
|
||
|
|
VkPipelineDepthStencilStateCreateInfo depthStencilState =
|
||
|
|
vkTools::initializers::pipelineDepthStencilStateCreateInfo(
|
||
|
|
VK_TRUE,
|
||
|
|
VK_TRUE,
|
||
|
|
VK_COMPARE_OP_LESS_OR_EQUAL);
|
||
|
|
|
||
|
|
VkPipelineViewportStateCreateInfo viewportState =
|
||
|
|
vkTools::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
|
||
|
|
|
||
|
|
VkPipelineMultisampleStateCreateInfo multisampleState =
|
||
|
|
vkTools::initializers::pipelineMultisampleStateCreateInfo(
|
||
|
|
VK_SAMPLE_COUNT_1_BIT,
|
||
|
|
0);
|
||
|
|
|
||
|
|
std::vector<VkDynamicState> dynamicStateEnables = {
|
||
|
|
VK_DYNAMIC_STATE_VIEWPORT,
|
||
|
|
VK_DYNAMIC_STATE_SCISSOR
|
||
|
|
};
|
||
|
|
VkPipelineDynamicStateCreateInfo dynamicState =
|
||
|
|
vkTools::initializers::pipelineDynamicStateCreateInfo(
|
||
|
|
dynamicStateEnables.data(),
|
||
|
|
static_cast<uint32_t>(dynamicStateEnables.size()),
|
||
|
|
0);
|
||
|
|
|
||
|
|
// Final fullscreen pass pipeline
|
||
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
|
||
|
|
|
||
|
|
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
|
||
|
|
vkTools::initializers::pipelineCreateInfo(
|
||
|
|
pipelineLayouts.offscreen,
|
||
|
|
renderPass,
|
||
|
|
0);
|
||
|
|
|
||
|
|
pipelineCreateInfo.pVertexInputState = &vertices.inputState;
|
||
|
|
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
|
||
|
|
pipelineCreateInfo.pRasterizationState = &rasterizationState;
|
||
|
|
pipelineCreateInfo.pColorBlendState = &colorBlendState;
|
||
|
|
pipelineCreateInfo.pMultisampleState = &multisampleState;
|
||
|
|
pipelineCreateInfo.pViewportState = &viewportState;
|
||
|
|
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
|
||
|
|
pipelineCreateInfo.pDynamicState = &dynamicState;
|
||
|
|
pipelineCreateInfo.stageCount = static_cast<uint32_t>(shaderStages.size());
|
||
|
|
pipelineCreateInfo.pStages = shaderStages.data();
|
||
|
|
|
||
|
|
std::array<VkPipelineColorBlendAttachmentState, 4> blendAttachmentStates = {
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE)
|
||
|
|
};
|
||
|
|
|
||
|
|
colorBlendState.attachmentCount = static_cast<uint32_t>(blendAttachmentStates.size());
|
||
|
|
colorBlendState.pAttachments = blendAttachmentStates.data();
|
||
|
|
|
||
|
|
// Offscreen pipeline
|
||
|
|
shaderStages[0] = loadShader(getAssetPath() + "shaders/subpasses/gbuffer.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
||
|
|
shaderStages[1] = loadShader(getAssetPath() + "shaders/subpasses/gbuffer.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.offscreen));
|
||
|
|
}
|
||
|
|
|
||
|
|
// todo: comment
|
||
|
|
void prepareCompositionPass()
|
||
|
|
{
|
||
|
|
// Descriptor set layout
|
||
|
|
std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =
|
||
|
|
{
|
||
|
|
// Binding 0: Position input attachment
|
||
|
|
vkTools::initializers::descriptorSetLayoutBinding(
|
||
|
|
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
|
||
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
||
|
|
0),
|
||
|
|
// Binding 1: Normal input attachment
|
||
|
|
vkTools::initializers::descriptorSetLayoutBinding(
|
||
|
|
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
|
||
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
||
|
|
1),
|
||
|
|
// Binding 2: Albedo input attachment
|
||
|
|
vkTools::initializers::descriptorSetLayoutBinding(
|
||
|
|
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
|
||
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
||
|
|
2),
|
||
|
|
// Binding 3: Light positions
|
||
|
|
vkTools::initializers::descriptorSetLayoutBinding(
|
||
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
||
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
||
|
|
3),
|
||
|
|
};
|
||
|
|
|
||
|
|
VkDescriptorSetLayoutCreateInfo descriptorLayout =
|
||
|
|
vkTools::initializers::descriptorSetLayoutCreateInfo(
|
||
|
|
setLayoutBindings.data(),
|
||
|
|
static_cast<uint32_t>(setLayoutBindings.size()));
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &composition.descriptorSetLayout));
|
||
|
|
|
||
|
|
// Pipeline layout
|
||
|
|
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
|
||
|
|
vkTools::initializers::pipelineLayoutCreateInfo(&composition.descriptorSetLayout, 1);
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &composition.pipelineLayout));
|
||
|
|
|
||
|
|
// Descriptor sets
|
||
|
|
VkDescriptorSetAllocateInfo allocInfo =
|
||
|
|
vkTools::initializers::descriptorSetAllocateInfo(descriptorPool, &composition.descriptorSetLayout, 1);
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &composition.descriptorSet));
|
||
|
|
|
||
|
|
// Image descriptors for the offscreen color attachments
|
||
|
|
VkDescriptorImageInfo texDescriptorPosition =
|
||
|
|
vkTools::initializers::descriptorImageInfo(
|
||
|
|
nullptr,
|
||
|
|
attachments.position.view,
|
||
|
|
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
|
||
|
|
|
||
|
|
VkDescriptorImageInfo texDescriptorNormal =
|
||
|
|
vkTools::initializers::descriptorImageInfo(
|
||
|
|
nullptr,
|
||
|
|
attachments.normal.view,
|
||
|
|
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
|
||
|
|
|
||
|
|
VkDescriptorImageInfo texDescriptorAlbedo =
|
||
|
|
vkTools::initializers::descriptorImageInfo(
|
||
|
|
nullptr,
|
||
|
|
attachments.albedo.view,
|
||
|
|
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
|
||
|
|
|
||
|
|
std::vector<VkWriteDescriptorSet> writeDescriptorSets = {
|
||
|
|
// Binding 0: Position texture target
|
||
|
|
vkTools::initializers::writeDescriptorSet(
|
||
|
|
composition.descriptorSet,
|
||
|
|
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
|
||
|
|
0,
|
||
|
|
&texDescriptorPosition),
|
||
|
|
// Binding 1: Normals texture target
|
||
|
|
vkTools::initializers::writeDescriptorSet(
|
||
|
|
composition.descriptorSet,
|
||
|
|
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
|
||
|
|
1,
|
||
|
|
&texDescriptorNormal),
|
||
|
|
// Binding 2: Albedo texture target
|
||
|
|
vkTools::initializers::writeDescriptorSet(
|
||
|
|
composition.descriptorSet,
|
||
|
|
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
|
||
|
|
2,
|
||
|
|
&texDescriptorAlbedo),
|
||
|
|
// Binding 4: Fragment shader lights
|
||
|
|
vkTools::initializers::writeDescriptorSet(
|
||
|
|
composition.descriptorSet,
|
||
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
||
|
|
3,
|
||
|
|
&uniformData.fsLights.descriptor),
|
||
|
|
};
|
||
|
|
|
||
|
|
vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);
|
||
|
|
|
||
|
|
// Pipeline
|
||
|
|
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
|
||
|
|
vkTools::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
|
||
|
|
|
||
|
|
VkPipelineRasterizationStateCreateInfo rasterizationState =
|
||
|
|
vkTools::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE, 0);
|
||
|
|
|
||
|
|
VkPipelineColorBlendAttachmentState blendAttachmentState =
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
|
||
|
|
|
||
|
|
VkPipelineColorBlendStateCreateInfo colorBlendState =
|
||
|
|
vkTools::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState);
|
||
|
|
|
||
|
|
std::array<VkPipelineColorBlendAttachmentState, 4> blendAttachmentStates = {
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),
|
||
|
|
vkTools::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),
|
||
|
|
};
|
||
|
|
|
||
|
|
colorBlendState.attachmentCount = static_cast<uint32_t>(blendAttachmentStates.size());
|
||
|
|
colorBlendState.pAttachments = blendAttachmentStates.data();
|
||
|
|
|
||
|
|
VkPipelineDepthStencilStateCreateInfo depthStencilState =
|
||
|
|
vkTools::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL);
|
||
|
|
|
||
|
|
VkPipelineViewportStateCreateInfo viewportState =
|
||
|
|
vkTools::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
|
||
|
|
|
||
|
|
VkPipelineMultisampleStateCreateInfo multisampleState =
|
||
|
|
vkTools::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0);
|
||
|
|
|
||
|
|
std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
|
||
|
|
VkPipelineDynamicStateCreateInfo dynamicState =
|
||
|
|
vkTools::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables.data(), static_cast<uint32_t>(dynamicStateEnables.size()), 0);
|
||
|
|
|
||
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
|
||
|
|
|
||
|
|
shaderStages[0] = loadShader(getAssetPath() + "shaders/subpasses/composition.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
||
|
|
shaderStages[1] = loadShader(getAssetPath() + "shaders/subpasses/composition.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
||
|
|
|
||
|
|
// Use specialization constants to pass number of lights to the shader
|
||
|
|
VkSpecializationMapEntry specializationEntry{};
|
||
|
|
specializationEntry.constantID = 0;
|
||
|
|
specializationEntry.offset = 0;
|
||
|
|
specializationEntry.size = sizeof(uint32_t);
|
||
|
|
|
||
|
|
uint32_t specializationData = NUM_LIGHTS;
|
||
|
|
|
||
|
|
VkSpecializationInfo specializationInfo;
|
||
|
|
specializationInfo.mapEntryCount = 1;
|
||
|
|
specializationInfo.pMapEntries = &specializationEntry;
|
||
|
|
specializationInfo.dataSize = sizeof(specializationData);
|
||
|
|
specializationInfo.pData = &specializationData;
|
||
|
|
|
||
|
|
shaderStages[1].pSpecializationInfo = &specializationInfo;
|
||
|
|
|
||
|
|
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
|
||
|
|
vkTools::initializers::pipelineCreateInfo(composition.pipelineLayout, renderPass, 0);
|
||
|
|
|
||
|
|
VkPipelineVertexInputStateCreateInfo emptyInputState{};
|
||
|
|
emptyInputState.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
|
||
|
|
|
||
|
|
pipelineCreateInfo.pVertexInputState = &emptyInputState;
|
||
|
|
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
|
||
|
|
pipelineCreateInfo.pRasterizationState = &rasterizationState;
|
||
|
|
pipelineCreateInfo.pColorBlendState = &colorBlendState;
|
||
|
|
pipelineCreateInfo.pMultisampleState = &multisampleState;
|
||
|
|
pipelineCreateInfo.pViewportState = &viewportState;
|
||
|
|
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
|
||
|
|
pipelineCreateInfo.pDynamicState = &dynamicState;
|
||
|
|
pipelineCreateInfo.stageCount = static_cast<uint32_t>(shaderStages.size());
|
||
|
|
pipelineCreateInfo.pStages = shaderStages.data();
|
||
|
|
|
||
|
|
VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &composition.pipeline));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Prepare and initialize uniform buffer containing shader uniforms
|
||
|
|
void prepareUniformBuffers()
|
||
|
|
{
|
||
|
|
// Deferred vertex shader
|
||
|
|
createBuffer(
|
||
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
||
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||
|
|
sizeof(uboOffscreenVS),
|
||
|
|
nullptr,
|
||
|
|
&uniformData.vsOffscreen.buffer,
|
||
|
|
&uniformData.vsOffscreen.memory,
|
||
|
|
&uniformData.vsOffscreen.descriptor);
|
||
|
|
|
||
|
|
// Deferred fragment shader
|
||
|
|
createBuffer(
|
||
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
||
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||
|
|
sizeof(uboFragmentLights),
|
||
|
|
nullptr,
|
||
|
|
&uniformData.fsLights.buffer,
|
||
|
|
&uniformData.fsLights.memory,
|
||
|
|
&uniformData.fsLights.descriptor);
|
||
|
|
|
||
|
|
// Update
|
||
|
|
updateUniformBufferDeferredMatrices();
|
||
|
|
updateUniformBufferDeferredLights();
|
||
|
|
}
|
||
|
|
|
||
|
|
void updateUniformBufferDeferredMatrices()
|
||
|
|
{
|
||
|
|
uboOffscreenVS.projection = camera.matrices.perspective;
|
||
|
|
uboOffscreenVS.view = camera.matrices.view;
|
||
|
|
uboOffscreenVS.model = glm::mat4();
|
||
|
|
|
||
|
|
uint8_t *pData;
|
||
|
|
VK_CHECK_RESULT(vkMapMemory(device, uniformData.vsOffscreen.memory, 0, sizeof(uboOffscreenVS), 0, (void **)&pData));
|
||
|
|
memcpy(pData, &uboOffscreenVS, sizeof(uboOffscreenVS));
|
||
|
|
vkUnmapMemory(device, uniformData.vsOffscreen.memory);
|
||
|
|
}
|
||
|
|
|
||
|
|
void initLights()
|
||
|
|
{
|
||
|
|
std::vector<glm::vec3> colors =
|
||
|
|
{
|
||
|
|
glm::vec3(1.0f, 1.0f, 1.0f),
|
||
|
|
glm::vec3(1.0f, 0.0f, 0.0f),
|
||
|
|
glm::vec3(0.0f, 1.0f, 0.0f),
|
||
|
|
glm::vec3(0.0f, 0.0f, 1.0f),
|
||
|
|
glm::vec3(1.0f, 1.0f, 0.0f),
|
||
|
|
};
|
||
|
|
|
||
|
|
std::mt19937 rndGen((unsigned)time(NULL));
|
||
|
|
std::uniform_real_distribution<float> rndDist(-1.0f, 1.0f);
|
||
|
|
std::uniform_int_distribution<uint32_t> rndCol(0, colors.size()-1);
|
||
|
|
|
||
|
|
for (auto& light : uboFragmentLights.lights)
|
||
|
|
{
|
||
|
|
light.position = glm::vec4(rndDist(rndGen) * 6.0f, 0.25f + std::abs(rndDist(rndGen)) * 4.0f, rndDist(rndGen) * 6.0f, 1.0f);
|
||
|
|
light.color = colors[rndCol(rndGen)];
|
||
|
|
light.radius = 1.0f + std::abs(rndDist(rndGen));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update fragment shader light position uniform block
|
||
|
|
void updateUniformBufferDeferredLights()
|
||
|
|
{
|
||
|
|
// Current view position
|
||
|
|
uboFragmentLights.viewPos = glm::vec4(camera.position, 0.0f) * glm::vec4(-1.0f, 1.0f, -1.0f, 1.0f);
|
||
|
|
|
||
|
|
uint8_t *pData;
|
||
|
|
VK_CHECK_RESULT(vkMapMemory(device, uniformData.fsLights.memory, 0, sizeof(uboFragmentLights), 0, (void **)&pData));
|
||
|
|
memcpy(pData, &uboFragmentLights, sizeof(uboFragmentLights));
|
||
|
|
vkUnmapMemory(device, uniformData.fsLights.memory);
|
||
|
|
}
|
||
|
|
|
||
|
|
void draw()
|
||
|
|
{
|
||
|
|
VulkanExampleBase::prepareFrame();
|
||
|
|
|
||
|
|
// Command buffer to be sumitted to the queue
|
||
|
|
submitInfo.commandBufferCount = 1;
|
||
|
|
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
|
||
|
|
|
||
|
|
// Submit to queue
|
||
|
|
VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
|
||
|
|
|
||
|
|
VulkanExampleBase::submitFrame();
|
||
|
|
}
|
||
|
|
|
||
|
|
void prepare()
|
||
|
|
{
|
||
|
|
VulkanExampleBase::prepare();
|
||
|
|
loadAssets();
|
||
|
|
setupVertexDescriptions();
|
||
|
|
initLights();
|
||
|
|
prepareUniformBuffers();
|
||
|
|
setupDescriptorSetLayout();
|
||
|
|
preparePipelines();
|
||
|
|
setupDescriptorPool();
|
||
|
|
setupDescriptorSet();
|
||
|
|
prepareCompositionPass();
|
||
|
|
buildCommandBuffers();
|
||
|
|
prepared = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void render()
|
||
|
|
{
|
||
|
|
if (!prepared)
|
||
|
|
return;
|
||
|
|
draw();
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void viewChanged()
|
||
|
|
{
|
||
|
|
updateUniformBufferDeferredMatrices();
|
||
|
|
updateUniformBufferDeferredLights();
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void keyPressed(uint32_t keyCode)
|
||
|
|
{
|
||
|
|
switch (keyCode)
|
||
|
|
{
|
||
|
|
case KEY_F1:
|
||
|
|
case GAMEPAD_BUTTON_A:
|
||
|
|
initLights();
|
||
|
|
updateUniformBufferDeferredLights();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
VULKAN_EXAMPLE_MAIN()
|