/*

* Vulkan Example - Multi sampling with explicit resolve for deferred shading example

*

* 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>

#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"

#include "VulkanBuffer.hpp"

#include "VulkanTexture.hpp"

#include "VulkanModel.hpp"

#define VERTEX_BUFFER_BIND_ID 0

#define ENABLE_VALIDATION false

// todo: check if hardware supports sample number (or select max. supported)

#define SAMPLE_COUNT VK_SAMPLE_COUNT_8_BIT

class VulkanExample : public VulkanExampleBase

{

public:

bool debugDisplay = false;

bool useMSAA = true;

bool useSampleShading = true;

struct {

struct {

vks::Texture2D colorMap;

vks::Texture2D normalMap;

} model;

struct {

vks::Texture2D colorMap;

vks::Texture2D normalMap;

} floor;

} textures;

// Vertex layout for the models

vks::VertexLayout vertexLayout = vks::VertexLayout({

vks::VERTEX_COMPONENT_POSITION,

vks::VERTEX_COMPONENT_UV,

vks::VERTEX_COMPONENT_COLOR,

vks::VERTEX_COMPONENT_NORMAL,

vks::VERTEX_COMPONENT_TANGENT,

});

struct {

vks::Model model;

vks::Model floor;

vks::Model quad;

} models;

struct {

VkPipelineVertexInputStateCreateInfo inputState;

std::vector<VkVertexInputBindingDescription> bindingDescriptions;

std::vector<VkVertexInputAttributeDescription> attributeDescriptions;

} vertices;

struct {

glm::mat4 projection;

glm::mat4 model;

glm::mat4 view;

glm::vec4 instancePos[3];

} uboVS, uboOffscreenVS;

struct Light {

glm::vec4 position;

glm::vec3 color;

float radius;

};

struct {

Light lights[6];

glm::vec4 viewPos;

glm::ivec2 windowSize;

} uboFragmentLights;

struct {

vks::Buffer vsFullScreen;

vks::Buffer vsOffscreen;

vks::Buffer fsLights;

} uniformBuffers;

struct {

VkPipeline deferred; // Deferred lighting calculation

VkPipeline deferredNoMSAA; // Deferred lighting calculation with explicit MSAA resolve

VkPipeline offscreen; // (Offscreen) scene rendering (fill G-Buffers)

VkPipeline offscreenSampleShading; // (Offscreen) scene rendering (fill G-Buffers) with sample shading rate enabled

VkPipeline debug; // G-Buffers debug display

} pipelines;

struct {

VkPipelineLayout deferred;

VkPipelineLayout offscreen;

} pipelineLayouts;

struct {

VkDescriptorSet model;

VkDescriptorSet floor;

} descriptorSets;

VkDescriptorSet descriptorSet;

VkDescriptorSetLayout descriptorSetLayout;

// Framebuffer for offscreen rendering

struct FrameBufferAttachment {

VkImage image;

VkDeviceMemory mem;

VkImageView view;

VkFormat format;

};

struct FrameBuffer {

int32_t width, height;

VkFramebuffer frameBuffer;

FrameBufferAttachment position, normal, albedo;

FrameBufferAttachment depth;

VkRenderPass renderPass;

} offScreenFrameBuf;

// One sampler for the frame buffer color attachments

VkSampler colorSampler;

VkCommandBuffer offScreenCmdBuffer = VK_NULL_HANDLE;

// Semaphore used to synchronize between offscreen and final scene rendering

VkSemaphore offscreenSemaphore = VK_NULL_HANDLE;

VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION)

{

zoom = -8.0f;

rotation = { 0.0f, 0.0f, 0.0f };

enableTextOverlay = true;

title = "Vulkan Example - Deferred shading (2016 by Sascha Willems)";

camera.type = Camera::CameraType::firstperson;

camera.movementSpeed = 5.0f;

#ifndef __ANDROID__

camera.rotationSpeed = 0.25f;

#endif

camera.position = { 2.15f, 0.3f, -8.75f };

camera.setRotation(glm::vec3(-0.75f, 12.5f, 0.0f));

camera.setPerspective(60.0f, (float)width / (float)height, 0.1f, 256.0f);

paused = true;

}

~VulkanExample()

{

// Clean up used Vulkan resources

// Note : Inherited destructor cleans up resources stored in base class

vkDestroySampler(device, colorSampler, nullptr);

// Frame buffer

// Color attachments

vkDestroyImageView(device, offScreenFrameBuf.position.view, nullptr);

vkDestroyImage(device, offScreenFrameBuf.position.image, nullptr);

vkFreeMemory(device, offScreenFrameBuf.position.mem, nullptr);

vkDestroyImageView(device, offScreenFrameBuf.normal.view, nullptr);

vkDestroyImage(device, offScreenFrameBuf.normal.image, nullptr);

vkFreeMemory(device, offScreenFrameBuf.normal.mem, nullptr);

vkDestroyImageView(device, offScreenFrameBuf.albedo.view, nullptr);

vkDestroyImage(device, offScreenFrameBuf.albedo.image, nullptr);

vkFreeMemory(device, offScreenFrameBuf.albedo.mem, nullptr);

// Depth attachment

vkDestroyImageView(device, offScreenFrameBuf.depth.view, nullptr);

vkDestroyImage(device, offScreenFrameBuf.depth.image, nullptr);

vkFreeMemory(device, offScreenFrameBuf.depth.mem, nullptr);

vkDestroyFramebuffer(device, offScreenFrameBuf.frameBuffer, nullptr);

vkDestroyPipeline(device, pipelines.deferred, nullptr);

vkDestroyPipeline(device, pipelines.deferredNoMSAA, nullptr);

vkDestroyPipeline(device, pipelines.offscreen, nullptr);

vkDestroyPipeline(device, pipelines.offscreenSampleShading, nullptr);

vkDestroyPipeline(device, pipelines.debug, nullptr);

vkDestroyPipelineLayout(device, pipelineLayouts.deferred, nullptr);

vkDestroyPipelineLayout(device, pipelineLayouts.offscreen, nullptr);

vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);

// Meshes

models.model.destroy();

models.floor.destroy();

// Uniform buffers

uniformBuffers.vsOffscreen.destroy();

uniformBuffers.vsFullScreen.destroy();

uniformBuffers.fsLights.destroy();

vkFreeCommandBuffers(device, cmdPool, 1, &offScreenCmdBuffer);

vkDestroyRenderPass(device, offScreenFrameBuf.renderPass, nullptr);

textures.model.colorMap.destroy();

textures.model.normalMap.destroy();

textures.floor.colorMap.destroy();

textures.floor.normalMap.destroy();

vkDestroySemaphore(device, offscreenSemaphore, nullptr);

}

// Enable physical device features required for this example

virtual void getEnabledFeatures()

{

// Enable anisotropic filtering if supported

if (deviceFeatures.samplerAnisotropy) {

enabledFeatures.samplerAnisotropy = VK_TRUE;

}

// Enable texture compression

if (deviceFeatures.textureCompressionBC) {

enabledFeatures.textureCompressionBC = VK_TRUE;

}

else if (deviceFeatures.textureCompressionASTC_LDR) {

enabledFeatures.textureCompressionASTC_LDR = VK_TRUE;

}

else if (deviceFeatures.textureCompressionETC2) {

enabledFeatures.textureCompressionETC2 = VK_TRUE;

}

};

// Create a frame buffer attachment

void createAttachment(

VkFormat format,

VkImageUsageFlagBits usage,

FrameBufferAttachment *attachment,

VkCommandBuffer layoutCmd)

{

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 = vks::initializers::imageCreateInfo();

image.imageType = VK_IMAGE_TYPE_2D;

image.format = format;

image.extent.width = offScreenFrameBuf.width;

image.extent.height = offScreenFrameBuf.height;

image.extent.depth = 1;

image.mipLevels = 1;

image.arrayLayers = 1;

image.samples = SAMPLE_COUNT;

image.tiling = VK_IMAGE_TILING_OPTIMAL;

image.usage = usage | VK_IMAGE_USAGE_SAMPLED_BIT;

VkMemoryAllocateInfo memAlloc = vks::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 = vks::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));

}

// Prepare a new framebuffer for offscreen rendering

// The contents of this framebuffer are then

// blitted to our render target

void prepareOffscreenFramebuffer()

{

VkCommandBuffer layoutCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);

offScreenFrameBuf.width = this->width;

offScreenFrameBuf.height = this->height;

//offScreenFrameBuf.width = FB_DIM;

//offScreenFrameBuf.height = FB_DIM;

// Color attachments

// (World space) Positions

createAttachment(

VK_FORMAT_R16G16B16A16_SFLOAT,

VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,

&offScreenFrameBuf.position,

layoutCmd);

// (World space) Normals

createAttachment(

VK_FORMAT_R16G16B16A16_SFLOAT,

VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,

&offScreenFrameBuf.normal,

layoutCmd);

// Albedo (color)

createAttachment(

VK_FORMAT_R8G8B8A8_UNORM,

VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,

&offScreenFrameBuf.albedo,

layoutCmd);

// Depth attachment

// Find a suitable depth format

VkFormat attDepthFormat;

VkBool32 validDepthFormat = vks::tools::getSupportedDepthFormat(physicalDevice, &attDepthFormat);

assert(validDepthFormat);

createAttachment(

attDepthFormat,

VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,

&offScreenFrameBuf.depth,

layoutCmd);

VulkanExampleBase::flushCommandBuffer(layoutCmd, queue, true);

// Set up separate renderpass with references

// to the color and depth attachments

std::array<VkAttachmentDescription, 4> attachmentDescs = {};

// Init attachment properties

for (uint32_t i = 0; i < 4; ++i)

{

attachmentDescs[i].samples = SAMPLE_COUNT;

attachmentDescs[i].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;

attachmentDescs[i].storeOp = VK_ATTACHMENT_STORE_OP_STORE;

attachmentDescs[i].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;

attachmentDescs[i].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;

if (i == 3)

{

attachmentDescs[i].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;

attachmentDescs[i].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

}

else

{

attachmentDescs[i].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;

attachmentDescs[i].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

}

}

// Formats

attachmentDescs[0].format = offScreenFrameBuf.position.format;

attachmentDescs[1].format = offScreenFrameBuf.normal.format;

attachmentDescs[2].format = offScreenFrameBuf.albedo.format;

attachmentDescs[3].format = offScreenFrameBuf.depth.format;

std::vector<VkAttachmentReference> colorReferences;

colorReferences.push_back({ 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL });

colorReferences.push_back({ 1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL });

colorReferences.push_back({ 2, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL });

VkAttachmentReference depthReference = {};

depthReference.attachment = 3;

depthReference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

VkSubpassDescription subpass = {};

subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;

subpass.pColorAttachments = colorReferences.data();

subpass.colorAttachmentCount = static_cast<uint32_t>(colorReferences.size());

subpass.pDepthStencilAttachment = &depthReference;

// Use subpass dependencies for attachment layput transitions

std::array<VkSubpassDependency, 2> 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;

dependencies[1].srcSubpass = 0;

dependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;

dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_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;

dependencies[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;

dependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;

VkRenderPassCreateInfo renderPassInfo = {};

renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;

renderPassInfo.pAttachments = attachmentDescs.data();

renderPassInfo.attachmentCount = static_cast<uint32_t>(attachmentDescs.size());

renderPassInfo.subpassCount = 1;

renderPassInfo.pSubpasses = &subpass;

renderPassInfo.dependencyCount = 2;

renderPassInfo.pDependencies = dependencies.data();

VK_CHECK_RESULT(vkCreateRenderPass(device, &renderPassInfo, nullptr, &offScreenFrameBuf.renderPass));

std::array<VkImageView,4> attachments;

attachments[0] = offScreenFrameBuf.position.view;

attachments[1] = offScreenFrameBuf.normal.view;

attachments[2] = offScreenFrameBuf.albedo.view;

attachments[3] = offScreenFrameBuf.depth.view;

VkFramebufferCreateInfo fbufCreateInfo = {};

fbufCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;

fbufCreateInfo.pNext = NULL;

fbufCreateInfo.renderPass = offScreenFrameBuf.renderPass;

fbufCreateInfo.pAttachments = attachments.data();

fbufCreateInfo.attachmentCount = static_cast<uint32_t>(attachments.size());

fbufCreateInfo.width = offScreenFrameBuf.width;

fbufCreateInfo.height = offScreenFrameBuf.height;

fbufCreateInfo.layers = 1;

VK_CHECK_RESULT(vkCreateFramebuffer(device, &fbufCreateInfo, nullptr, &offScreenFrameBuf.frameBuffer));

// Create sampler to sample from the color attachments

VkSamplerCreateInfo sampler = vks::initializers::samplerCreateInfo();

sampler.magFilter = VK_FILTER_NEAREST;

sampler.minFilter = VK_FILTER_NEAREST;

sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;

sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;

sampler.addressModeV = sampler.addressModeU;

sampler.addressModeW = sampler.addressModeU;

sampler.mipLodBias = 0.0f;

sampler.maxAnisotropy = 1.0f;

sampler.minLod = 0.0f;

sampler.maxLod = 1.0f;

sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;

VK_CHECK_RESULT(vkCreateSampler(device, &sampler, nullptr, &colorSampler));

}

// Build command buffer for rendering the scene to the offscreen frame buffer attachments

void buildDeferredCommandBuffer()

{

if (offScreenCmdBuffer == VK_NULL_HANDLE)

{

offScreenCmdBuffer = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, false);

}

// Create a semaphore used to synchronize offscreen rendering and usage

VkSemaphoreCreateInfo semaphoreCreateInfo = vks::initializers::semaphoreCreateInfo();

VK_CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &offscreenSemaphore));

VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();

// Clear values for all attachments written in the fragment sahder

std::array<VkClearValue,4> clearValues;

clearValues[0].color = clearValues[1].color = { { 0.0f, 0.0f, 0.0f, 0.0f } };

clearValues[2].color = { { 0.0f, 0.0f, 0.0f, 0.0f } };

clearValues[3].depthStencil = { 1.0f, 0 };

VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();

renderPassBeginInfo.renderPass = offScreenFrameBuf.renderPass;

renderPassBeginInfo.framebuffer = offScreenFrameBuf.frameBuffer;

renderPassBeginInfo.renderArea.extent.width = offScreenFrameBuf.width;

renderPassBeginInfo.renderArea.extent.height = offScreenFrameBuf.height;

renderPassBeginInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());

renderPassBeginInfo.pClearValues = clearValues.data();

VK_CHECK_RESULT(vkBeginCommandBuffer(offScreenCmdBuffer, &cmdBufInfo));

vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);

VkViewport viewport = vks::initializers::viewport((float)offScreenFrameBuf.width, (float)offScreenFrameBuf.height, 0.0f, 1.0f);

vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport);

VkRect2D scissor = vks::initializers::rect2D(offScreenFrameBuf.width, offScreenFrameBuf.height, 0, 0);

vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor);

vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, useSampleShading ? pipelines.offscreenSampleShading : pipelines.offscreen);

VkDeviceSize offsets[1] = { 0 };

// Background

vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.offscreen, 0, 1, &descriptorSets.floor, 0, NULL);

vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &models.floor.vertices.buffer, offsets);

vkCmdBindIndexBuffer(offScreenCmdBuffer, models.floor.indices.buffer, 0, VK_INDEX_TYPE_UINT32);

vkCmdDrawIndexed(offScreenCmdBuffer, models.floor.indexCount, 1, 0, 0, 0);

// Object

vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.offscreen, 0, 1, &descriptorSets.model, 0, NULL);

vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &models.model.vertices.buffer, offsets);

vkCmdBindIndexBuffer(offScreenCmdBuffer, models.model.indices.buffer, 0, VK_INDEX_TYPE_UINT32);

vkCmdDrawIndexed(offScreenCmdBuffer, models.model.indexCount, 3, 0, 0, 0);

vkCmdEndRenderPass(offScreenCmdBuffer);

VK_CHECK_RESULT(vkEndCommandBuffer(offScreenCmdBuffer));

}

void reBuildCommandBuffers()

{

if (!checkCommandBuffers())

{

destroyCommandBuffers();

createCommandBuffers();

}

buildCommandBuffers();

buildDeferredCommandBuffer();

}

void buildCommandBuffers()

{

VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();

VkClearValue clearValues[2];

clearValues[0].color = { { 1.0f, 1.0f, 1.0f, 0.0f } };

clearValues[1].depthStencil = { 1.0f, 0 };

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 = 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));

vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);

VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);

vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);

VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);

vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);

VkDeviceSize offsets[1] = { 0 };

vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.deferred, 0, 1, &descriptorSet, 0, NULL);

if (debugDisplay)

{

vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.debug);

vkCmdDraw(drawCmdBuffers[i], 3, 1, 0, 0);

// Move viewport to display final composition in lower right corner

viewport.x = viewport.width * 0.5f;

viewport.y = viewport.height * 0.5f;

viewport.width = (float)width * 0.5f;

viewport.height = (float)height * 0.5f;

vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);

}

camera.updateAspectRatio((float)viewport.width / (float)viewport.height);

// Final composition as full screen quad

vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, useMSAA ? pipelines.deferred : pipelines.deferredNoMSAA);

vkCmdDraw(drawCmdBuffers[i], 3, 1, 0, 0);

vkCmdEndRenderPass(drawCmdBuffers[i]);

VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));

}

}

void loadAssets()

{

models.model.loadFromFile(getAssetPath() + "models/armor/armor.dae", vertexLayout, 1.0f, vulkanDevice, queue);

vks::ModelCreateInfo modelCreateInfo;

modelCreateInfo.scale = glm::vec3(15.0f);

modelCreateInfo.uvscale = glm::vec2(8.0f, 8.0f);

modelCreateInfo.center = glm::vec3(0.0f, 2.3f, 0.0f);

models.floor.loadFromFile(getAssetPath() + "models/openbox.dae", vertexLayout, &modelCreateInfo, vulkanDevice, queue);

// Textures

std::string texFormatSuffix;

VkFormat texFormat;

// Get supported compressed texture format

if (vulkanDevice->features.textureCompressionBC) {

texFormatSuffix = "_bc3_unorm";

texFormat = VK_FORMAT_BC3_UNORM_BLOCK;

}

else if (vulkanDevice->features.textureCompressionASTC_LDR) {

texFormatSuffix = "_astc_8x8_unorm";

texFormat = VK_FORMAT_ASTC_8x8_UNORM_BLOCK;

}

else if (vulkanDevice->features.textureCompressionETC2) {

texFormatSuffix = "_etc2_unorm";

texFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;

}

else {

vks::tools::exitFatal("Device does not support any compressed texture format!", "Error");

}

textures.model.colorMap.loadFromFile(getAssetPath() + "models/armor/color" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

textures.model.normalMap.loadFromFile(getAssetPath() + "models/armor/normal" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

textures.floor.colorMap.loadFromFile(getAssetPath() + "textures/stonefloor02_color" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

textures.floor.normalMap.loadFromFile(getAssetPath() + "textures/stonefloor02_normal" + texFormatSuffix + ".ktx", texFormat, vulkanDevice, queue);

}

void setupVertexDescriptions()

{

// Binding description

vertices.bindingDescriptions.resize(1);

vertices.bindingDescriptions[0] =

vks::initializers::vertexInputBindingDescription(

VERTEX_BUFFER_BIND_ID,

vertexLayout.stride(),

VK_VERTEX_INPUT_RATE_VERTEX);

// Attribute descriptions

vertices.attributeDescriptions.resize(5);

// Location 0: Position

vertices.attributeDescriptions[0] =

vks::initializers::vertexInputAttributeDescription(

VERTEX_BUFFER_BIND_ID,

0,

VK_FORMAT_R32G32B32_SFLOAT,

0);

// Location 1: Texture coordinates

vertices.attributeDescriptions[1] =

vks::initializers::vertexInputAttributeDescription(

VERTEX_BUFFER_BIND_ID,

1,

VK_FORMAT_R32G32_SFLOAT,

sizeof(float) * 3);

// Location 2: Color

vertices.attributeDescriptions[2] =

vks::initializers::vertexInputAttributeDescription(

VERTEX_BUFFER_BIND_ID,

2,

VK_FORMAT_R32G32B32_SFLOAT,

sizeof(float) * 5);

// Location 3: Normal

vertices.attributeDescriptions[3] =

vks::initializers::vertexInputAttributeDescription(

VERTEX_BUFFER_BIND_ID,

3,

VK_FORMAT_R32G32B32_SFLOAT,

sizeof(float) * 8);

// Location 4: Tangent

vertices.attributeDescriptions[4] =

vks::initializers::vertexInputAttributeDescription(

VERTEX_BUFFER_BIND_ID,

4,

VK_FORMAT_R32G32B32_SFLOAT,

sizeof(float) * 11);

vertices.inputState = vks::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 =

{

vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 8),

vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 9)

};

VkDescriptorPoolCreateInfo descriptorPoolInfo =

vks::initializers::descriptorPoolCreateInfo(

static_cast<uint32_t>(poolSizes.size()),

poolSizes.data(),

3);

VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));

}

void setupDescriptorSetLayout()

{

// Deferred shading layout

std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =

{

// Binding 0 : Vertex shader uniform buffer

vks::initializers::descriptorSetLayoutBinding(

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,

VK_SHADER_STAGE_VERTEX_BIT,

0),

// Binding 1 : Position texture target / Scene colormap

vks::initializers::descriptorSetLayoutBinding(

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

VK_SHADER_STAGE_FRAGMENT_BIT,

1),

// Binding 2 : Normals texture target

vks::initializers::descriptorSetLayoutBinding(

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

VK_SHADER_STAGE_FRAGMENT_BIT,

2),

// Binding 3 : Albedo texture target

vks::initializers::descriptorSetLayoutBinding(

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

VK_SHADER_STAGE_FRAGMENT_BIT,

3),

// Binding 4 : Fragment shader uniform buffer

vks::initializers::descriptorSetLayoutBinding(

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,

VK_SHADER_STAGE_FRAGMENT_BIT,

4),

};

VkDescriptorSetLayoutCreateInfo descriptorLayout =

vks::initializers::descriptorSetLayoutCreateInfo(

setLayoutBindings.data(),

static_cast<uint32_t>(setLayoutBindings.size()));

VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));

VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =

vks::initializers::pipelineLayoutCreateInfo(

&descriptorSetLayout,

1);

VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayouts.deferred));

// Offscreen (scene) rendering pipeline layout

VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayouts.offscreen));

}

void setupDescriptorSet()

{

std::vector<VkWriteDescriptorSet> writeDescriptorSets;

// Textured quad descriptor set

VkDescriptorSetAllocateInfo allocInfo =

vks::initializers::descriptorSetAllocateInfo(

descriptorPool,

&descriptorSetLayout,

1);

VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));

// Image descriptors for the offscreen color attachments

VkDescriptorImageInfo texDescriptorPosition =

vks::initializers::descriptorImageInfo(

colorSampler,

offScreenFrameBuf.position.view,

VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

VkDescriptorImageInfo texDescriptorNormal =

vks::initializers::descriptorImageInfo(

colorSampler,

offScreenFrameBuf.normal.view,

VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

VkDescriptorImageInfo texDescriptorAlbedo =

vks::initializers::descriptorImageInfo(

colorSampler,

offScreenFrameBuf.albedo.view,

VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

writeDescriptorSets = {

// Binding 0 : Vertex shader uniform buffer

vks::initializers::writeDescriptorSet(

descriptorSet,

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,

0,

&uniformBuffers.vsFullScreen.descriptor),

// Binding 1 : Position texture target

vks::initializers::writeDescriptorSet(

descriptorSet,

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

1,

&texDescriptorPosition),

// Binding 2 : Normals texture target

vks::initializers::writeDescriptorSet(

descriptorSet,

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

2,

&texDescriptorNormal),

// Binding 3 : Albedo texture target

vks::initializers::writeDescriptorSet(

descriptorSet,

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

3,

&texDescriptorAlbedo),

// Binding 4 : Fragment shader uniform buffer

vks::initializers::writeDescriptorSet(

descriptorSet,

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,

4,

&uniformBuffers.fsLights.descriptor),

};

vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);

// Offscreen (scene)

// Model

VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.model));

writeDescriptorSets =

{

// Binding 0: Vertex shader uniform buffer

vks::initializers::writeDescriptorSet(

descriptorSets.model,

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,

0,

&uniformBuffers.vsOffscreen.descriptor),

// Binding 1: Color map

vks::initializers::writeDescriptorSet(

descriptorSets.model,

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

1,

&textures.model.colorMap.descriptor),

// Binding 2: Normal map

vks::initializers::writeDescriptorSet(

descriptorSets.model,

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

2,

&textures.model.normalMap.descriptor)

};

vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);

// Backbround

VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.floor));

writeDescriptorSets =

{

// Binding 0: Vertex shader uniform buffer

vks::initializers::writeDescriptorSet(

descriptorSets.floor,

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,

0,

&uniformBuffers.vsOffscreen.descriptor),

// Binding 1: Color map

vks::initializers::writeDescriptorSet(

descriptorSets.floor,

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

1,

&textures.floor.colorMap.descriptor),

// Binding 2: Normal map

vks::initializers::writeDescriptorSet(

descriptorSets.floor,

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,

2,

&textures.floor.normalMap.descriptor)

};

vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);

}

void preparePipelines()

{

VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =

vks::initializers::pipelineInputAssemblyStateCreateInfo(

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,

0,

VK_FALSE);

VkPipelineRasterizationStateCreateInfo rasterizationState =

vks::initializers::pipelineRasterizationStateCreateInfo(

VK_POLYGON_MODE_FILL,

VK_CULL_MODE_BACK_BIT,

VK_FRONT_FACE_CLOCKWISE,

0);

VkPipelineColorBlendAttachmentState blendAttachmentState =

vks::initializers::pipelineColorBlendAttachmentState(

0xf,

VK_FALSE);

VkPipelineColorBlendStateCreateInfo colorBlendState =

vks::initializers::pipelineColorBlendStateCreateInfo(

1,

&blendAttachmentState);

VkPipelineDepthStencilStateCreateInfo depthStencilState =

vks::initializers::pipelineDepthStencilStateCreateInfo(

VK_TRUE,

VK_TRUE,

VK_COMPARE_OP_LESS_OR_EQUAL);

VkPipelineViewportStateCreateInfo viewportState =

vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);

VkPipelineMultisampleStateCreateInfo multisampleState =

vks::initializers::pipelineMultisampleStateCreateInfo(

VK_SAMPLE_COUNT_1_BIT,

0);

std::vector<VkDynamicState> dynamicStateEnables = {

VK_DYNAMIC_STATE_VIEWPORT,

VK_DYNAMIC_STATE_SCISSOR

};

VkPipelineDynamicStateCreateInfo dynamicState =

vks::initializers::pipelineDynamicStateCreateInfo(

dynamicStateEnables.data(),

static_cast<uint32_t>(dynamicStateEnables.size()),

0);

// Final fullscreen pass pipeline

std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;

VkGraphicsPipelineCreateInfo pipelineCreateInfo =

vks::initializers::pipelineCreateInfo(

pipelineLayouts.deferred,

renderPass,

0);

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();

// Deferred

// Empty vertex input state, quads are generated by the vertex shader

VkPipelineVertexInputStateCreateInfo emptyInputState = vks::initializers::pipelineVertexInputStateCreateInfo();

pipelineCreateInfo.pVertexInputState = &emptyInputState;

pipelineCreateInfo.layout = pipelineLayouts.deferred;

// Use specialization constants to pass number of samples to the shader (used for MSAA resolve)

VkSpecializationMapEntry specializationEntry{};

specializationEntry.constantID = 0;

specializationEntry.offset = 0;

specializationEntry.size = sizeof(uint32_t);

uint32_t specializationData = SAMPLE_COUNT;

VkSpecializationInfo specializationInfo;

specializationInfo.mapEntryCount = 1;

specializationInfo.pMapEntries = &specializationEntry;

specializationInfo.dataSize = sizeof(specializationData);

specializationInfo.pData = &specializationData;

// With MSAA

shaderStages[0] = loadShader(getAssetPath() + "shaders/deferredmultisampling/deferred.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);

shaderStages[1] = loadShader(getAssetPath() + "shaders/deferredmultisampling/deferred.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);

shaderStages[1].pSpecializationInfo = &specializationInfo;

VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.deferred));

// No MSAA (1 sample)

specializationData = 1;

VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.deferredNoMSAA));

// Debug display pipeline

shaderStages[0] = loadShader(getAssetPath() + "shaders/deferredmultisampling/debug.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);

shaderStages[1] = loadShader(getAssetPath() + "shaders/deferredmultisampling/debug.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);

VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.debug));

// Offscreen scene rendering pipeline

pipelineCreateInfo.pVertexInputState = &vertices.inputState;

shaderStages[0] = loadShader(getAssetPath() + "shaders/deferredmultisampling/mrt.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);

shaderStages[1] = loadShader(getAssetPath() + "shaders/deferredmultisampling/mrt.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);

//rasterizationState.polygonMode = VK_POLYGON_MODE_LINE;

//rasterizationState.lineWidth = 2.0f;

multisampleState.rasterizationSamples = SAMPLE_COUNT;

multisampleState.alphaToCoverageEnable = VK_TRUE;

// Separate render pass

pipelineCreateInfo.renderPass = offScreenFrameBuf.renderPass;

// Separate layout

pipelineCreateInfo.layout = pipelineLayouts.offscreen;

// Blend attachment states required for all color attachments

// This is important, as color write mask will otherwise be 0x0 and you

// won't see anything rendered to the attachment

std::array<VkPipelineColorBlendAttachmentState, 3> blendAttachmentStates = {

vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),

vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE),

vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE)

};

colorBlendState.attachmentCount = static_cast<uint32_t>(blendAttachmentStates.size());

colorBlendState.pAttachments = blendAttachmentStates.data();

VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.offscreen));

multisampleState.sampleShadingEnable = VK_TRUE;

multisampleState.minSampleShading = 0.25f;

VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.offscreenSampleShading));