2016-03-08 21:52:40 +01:00
/*
2016-06-05 15:44:04 +02:00
* Vulkan Example - Shadow mapping for directional light sources
2016-03-08 21:52:40 +01:00
*
* Copyright ( C ) 2016 by Sascha Willems - www . saschawillems . de
*
* This code is licensed under the MIT license ( MIT ) ( http : //opensource.org/licenses/MIT)
*/
# include "vulkanexamplebase.h"
2020-07-28 20:20:38 +02:00
# include "VulkanglTFModel.h"
2016-03-08 21:52:40 +01:00
# define ENABLE_VALIDATION false
// 16 bits of depth is enough for such a small scene
# define DEPTH_FORMAT VK_FORMAT_D16_UNORM
2016-06-05 15:44:04 +02:00
// Shadowmap properties
# if defined(__ANDROID__)
# define SHADOWMAP_DIM 1024
# else
# define SHADOWMAP_DIM 2048
# endif
2020-06-20 00:08:13 +02:00
# define DEFAULT_SHADOWMAP_FILTER VK_FILTER_LINEAR
2016-03-08 21:52:40 +01:00
class VulkanExample : public VulkanExampleBase
{
public :
2016-03-25 15:29:38 +01:00
bool displayShadowMap = false ;
2017-01-07 20:20:40 +01:00
bool filterPCF = true ;
2016-03-08 21:52:40 +01:00
// Keep depth range as small as possible
// for better shadow map precision
float zNear = 1.0f ;
float zFar = 96.0f ;
2020-08-09 13:48:49 +02:00
// Depth bias (and slope) are used to avoid shadowing artifacts
2016-03-08 21:52:40 +01:00
// Constant depth bias factor (always applied)
float depthBiasConstant = 1.25f ;
// Slope depth bias factor, applied depending on polygon's slope
float depthBiasSlope = 1.75f ;
glm : : vec3 lightPos = glm : : vec3 ( ) ;
float lightFOV = 45.0f ;
2020-07-28 20:20:38 +02:00
std : : vector < vkglTF : : Model > scenes ;
2017-11-04 21:23:37 +01:00
std : : vector < std : : string > sceneNames ;
int32_t sceneIndex = 0 ;
2016-03-08 21:52:40 +01:00
struct {
2017-02-12 10:44:51 +01:00
vks : : Buffer scene ;
vks : : Buffer offscreen ;
2016-12-24 12:48:01 +01:00
} uniformBuffers ;
2016-03-08 21:52:40 +01:00
struct {
glm : : mat4 projection ;
glm : : mat4 view ;
glm : : mat4 model ;
glm : : mat4 depthBiasMVP ;
glm : : vec3 lightPos ;
} uboVSscene ;
struct {
glm : : mat4 depthMVP ;
} uboOffscreenVS ;
struct {
VkPipeline offscreen ;
2017-01-07 20:20:40 +01:00
VkPipeline sceneShadow ;
VkPipeline sceneShadowPCF ;
2020-07-28 20:20:38 +02:00
VkPipeline debug ;
2016-03-08 21:52:40 +01:00
} pipelines ;
2020-07-28 20:20:38 +02:00
VkPipelineLayout pipelineLayout ;
2016-03-08 21:52:40 +01:00
struct {
VkDescriptorSet offscreen ;
VkDescriptorSet scene ;
2020-07-28 20:20:38 +02:00
VkDescriptorSet debug ;
2016-03-08 21:52:40 +01:00
} descriptorSets ;
VkDescriptorSetLayout descriptorSetLayout ;
// Framebuffer for offscreen rendering
struct FrameBufferAttachment {
VkImage image ;
VkDeviceMemory mem ;
VkImageView view ;
} ;
2016-08-13 19:31:41 +02:00
struct OffscreenPass {
2016-03-08 21:52:40 +01:00
int32_t width , height ;
VkFramebuffer frameBuffer ;
2016-08-13 19:53:37 +02:00
FrameBufferAttachment depth ;
2016-03-10 21:17:48 +01:00
VkRenderPass renderPass ;
2016-06-05 15:44:04 +02:00
VkSampler depthSampler ;
2016-08-13 19:31:41 +02:00
VkDescriptorImageInfo descriptor ;
} offscreenPass ;
2016-03-08 21:52:40 +01:00
VulkanExample ( ) : VulkanExampleBase ( ENABLE_VALIDATION )
{
2017-11-01 14:22:10 +01:00
title = " Projected shadow mapping " ;
2020-04-22 20:58:24 +02:00
camera . type = Camera : : CameraType : : lookat ;
camera . setPosition ( glm : : vec3 ( 0.0f , - 0.0f , - 20.0f ) ) ;
camera . setRotation ( glm : : vec3 ( - 15.0f , - 390.0f , 0.0f ) ) ;
camera . setPerspective ( 60.0f , ( float ) width / ( float ) height , 1.0f , 256.0f ) ;
2016-03-08 21:52:40 +01:00
timerSpeed * = 0.5f ;
2017-11-01 14:22:10 +01:00
settings . overlay = true ;
2016-03-08 21:52:40 +01:00
}
~ VulkanExample ( )
{
2020-05-29 16:08:53 +01:00
// Clean up used Vulkan resources
2016-03-08 21:52:40 +01:00
// Note : Inherited destructor cleans up resources stored in base class
// Frame buffer
2016-08-13 19:31:41 +02:00
vkDestroySampler ( device , offscreenPass . depthSampler , nullptr ) ;
2016-03-08 21:52:40 +01:00
// Depth attachment
2016-08-13 19:31:41 +02:00
vkDestroyImageView ( device , offscreenPass . depth . view , nullptr ) ;
vkDestroyImage ( device , offscreenPass . depth . image , nullptr ) ;
vkFreeMemory ( device , offscreenPass . depth . mem , nullptr ) ;
2016-03-08 21:52:40 +01:00
2016-08-13 19:31:41 +02:00
vkDestroyFramebuffer ( device , offscreenPass . frameBuffer , nullptr ) ;
2016-03-08 21:52:40 +01:00
2016-08-13 19:31:41 +02:00
vkDestroyRenderPass ( device , offscreenPass . renderPass , nullptr ) ;
2016-03-13 16:04:39 +01:00
2020-07-28 20:20:38 +02:00
vkDestroyPipeline ( device , pipelines . debug , nullptr ) ;
2016-03-08 21:52:40 +01:00
vkDestroyPipeline ( device , pipelines . offscreen , nullptr ) ;
2017-01-07 20:20:40 +01:00
vkDestroyPipeline ( device , pipelines . sceneShadow , nullptr ) ;
vkDestroyPipeline ( device , pipelines . sceneShadowPCF , nullptr ) ;
2016-03-08 21:52:40 +01:00
2020-07-28 20:20:38 +02:00
vkDestroyPipelineLayout ( device , pipelineLayout , nullptr ) ;
2016-03-08 21:52:40 +01:00
vkDestroyDescriptorSetLayout ( device , descriptorSetLayout , nullptr ) ;
// Uniform buffers
2016-12-24 12:48:01 +01:00
uniformBuffers . offscreen . destroy ( ) ;
uniformBuffers . scene . destroy ( ) ;
2016-03-08 21:52:40 +01:00
}
2016-03-10 21:17:48 +01:00
// Set up a separate render pass for the offscreen frame buffer
2016-08-13 19:31:41 +02:00
// This is necessary as the offscreen frame buffer attachments use formats different to those from the example render pass
2016-06-05 15:44:04 +02:00
void prepareOffscreenRenderpass ( )
2016-03-10 21:17:48 +01:00
{
2016-12-29 23:16:29 +01:00
VkAttachmentDescription attachmentDescription { } ;
attachmentDescription . format = DEPTH_FORMAT ;
attachmentDescription . samples = VK_SAMPLE_COUNT_1_BIT ;
attachmentDescription . loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR ; // Clear depth at beginning of the render pass
attachmentDescription . storeOp = VK_ATTACHMENT_STORE_OP_STORE ; // We will read from depth, so it's important to store the depth attachment results
attachmentDescription . stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE ;
attachmentDescription . stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE ;
attachmentDescription . initialLayout = VK_IMAGE_LAYOUT_UNDEFINED ; // We don't care about initial layout of the attachment
attachmentDescription . finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL ; // Attachment will be transitioned to shader read at render pass end
2016-03-10 21:17:48 +01:00
VkAttachmentReference depthReference = { } ;
2016-08-13 19:53:37 +02:00
depthReference . attachment = 0 ;
2016-12-29 23:16:29 +01:00
depthReference . layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL ; // Attachment will be used as depth/stencil during render pass
2016-03-10 21:17:48 +01:00
VkSubpassDescription subpass = { } ;
subpass . pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS ;
2016-12-29 23:16:29 +01:00
subpass . colorAttachmentCount = 0 ; // No color attachments
subpass . pDepthStencilAttachment = & depthReference ; // Reference to our depth attachment
2016-03-10 21:17:48 +01:00
2016-08-13 19:31:41 +02:00
// Use subpass dependencies for layout transitions
std : : array < VkSubpassDependency , 2 > dependencies ;
dependencies [ 0 ] . srcSubpass = VK_SUBPASS_EXTERNAL ;
dependencies [ 0 ] . dstSubpass = 0 ;
2019-04-01 20:22:28 +02:00
dependencies [ 0 ] . srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT ;
dependencies [ 0 ] . dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT ;
dependencies [ 0 ] . srcAccessMask = VK_ACCESS_SHADER_READ_BIT ;
dependencies [ 0 ] . dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT ;
2016-08-13 19:31:41 +02:00
dependencies [ 0 ] . dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT ;
dependencies [ 1 ] . srcSubpass = 0 ;
dependencies [ 1 ] . dstSubpass = VK_SUBPASS_EXTERNAL ;
2016-12-31 11:28:08 +01:00
dependencies [ 1 ] . srcStageMask = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT ;
2017-06-01 22:13:38 +02:00
dependencies [ 1 ] . dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT ;
2019-04-01 20:22:28 +02:00
dependencies [ 1 ] . srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT ;
2017-06-01 22:13:38 +02:00
dependencies [ 1 ] . dstAccessMask = VK_ACCESS_SHADER_READ_BIT ;
2016-08-13 19:31:41 +02:00
dependencies [ 1 ] . dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT ;
2017-02-12 11:12:42 +01:00
VkRenderPassCreateInfo renderPassCreateInfo = vks : : initializers : : renderPassCreateInfo ( ) ;
2016-08-13 19:53:37 +02:00
renderPassCreateInfo . attachmentCount = 1 ;
2016-12-29 23:16:29 +01:00
renderPassCreateInfo . pAttachments = & attachmentDescription ;
2016-03-10 21:17:48 +01:00
renderPassCreateInfo . subpassCount = 1 ;
renderPassCreateInfo . pSubpasses = & subpass ;
2016-08-13 19:31:41 +02:00
renderPassCreateInfo . dependencyCount = static_cast < uint32_t > ( dependencies . size ( ) ) ;
renderPassCreateInfo . pDependencies = dependencies . data ( ) ;
2016-03-10 21:17:48 +01:00
2016-08-13 19:31:41 +02:00
VK_CHECK_RESULT ( vkCreateRenderPass ( device , & renderPassCreateInfo , nullptr , & offscreenPass . renderPass ) ) ;
2016-03-10 21:17:48 +01:00
}
2016-08-13 19:31:41 +02:00
// Setup the offscreen framebuffer for rendering the scene from light's point-of-view to
// The depth attachment of this framebuffer will then be used to sample from in the fragment shader of the shadowing pass
2016-03-08 21:52:40 +01:00
void prepareOffscreenFramebuffer ( )
{
2016-08-13 19:31:41 +02:00
offscreenPass . width = SHADOWMAP_DIM ;
offscreenPass . height = SHADOWMAP_DIM ;
2016-03-08 21:52:40 +01:00
2016-08-13 19:53:37 +02:00
// For shadow mapping we only need a depth attachment
2017-02-12 11:12:42 +01:00
VkImageCreateInfo image = vks : : initializers : : imageCreateInfo ( ) ;
2016-03-08 21:52:40 +01:00
image . imageType = VK_IMAGE_TYPE_2D ;
2016-08-13 19:31:41 +02:00
image . extent . width = offscreenPass . width ;
image . extent . height = offscreenPass . height ;
2016-06-05 15:44:04 +02:00
image . extent . depth = 1 ;
2016-03-08 21:52:40 +01:00
image . mipLevels = 1 ;
image . arrayLayers = 1 ;
image . samples = VK_SAMPLE_COUNT_1_BIT ;
image . tiling = VK_IMAGE_TILING_OPTIMAL ;
2016-08-13 19:53:37 +02:00
image . format = DEPTH_FORMAT ; // Depth stencil attachment
image . usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT ; // We will sample directly from the depth attachment for the shadow mapping
VK_CHECK_RESULT ( vkCreateImage ( device , & image , nullptr , & offscreenPass . depth . image ) ) ;
2016-03-08 21:52:40 +01:00
2017-02-12 11:12:42 +01:00
VkMemoryAllocateInfo memAlloc = vks : : initializers : : memoryAllocateInfo ( ) ;
2016-05-14 19:27:23 +02:00
VkMemoryRequirements memReqs ;
2016-08-13 19:53:37 +02:00
vkGetImageMemoryRequirements ( device , offscreenPass . depth . image , & memReqs ) ;
2016-03-08 21:52:40 +01:00
memAlloc . allocationSize = memReqs . size ;
2016-07-23 20:42:03 +02:00
memAlloc . memoryTypeIndex = vulkanDevice - > getMemoryType ( memReqs . memoryTypeBits , VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT ) ;
2016-08-13 19:53:37 +02:00
VK_CHECK_RESULT ( vkAllocateMemory ( device , & memAlloc , nullptr , & offscreenPass . depth . mem ) ) ;
VK_CHECK_RESULT ( vkBindImageMemory ( device , offscreenPass . depth . image , offscreenPass . depth . mem , 0 ) ) ;
2016-03-08 21:52:40 +01:00
2017-02-12 11:12:42 +01:00
VkImageViewCreateInfo depthStencilView = vks : : initializers : : imageViewCreateInfo ( ) ;
2016-03-08 21:52:40 +01:00
depthStencilView . viewType = VK_IMAGE_VIEW_TYPE_2D ;
depthStencilView . format = DEPTH_FORMAT ;
depthStencilView . subresourceRange = { } ;
depthStencilView . subresourceRange . aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT ;
depthStencilView . subresourceRange . baseMipLevel = 0 ;
depthStencilView . subresourceRange . levelCount = 1 ;
depthStencilView . subresourceRange . baseArrayLayer = 0 ;
depthStencilView . subresourceRange . layerCount = 1 ;
2016-08-13 19:31:41 +02:00
depthStencilView . image = offscreenPass . depth . image ;
VK_CHECK_RESULT ( vkCreateImageView ( device , & depthStencilView , nullptr , & offscreenPass . depth . view ) ) ;
2016-03-08 21:52:40 +01:00
2020-05-29 16:08:53 +01:00
// Create sampler to sample from to depth attachment
2016-06-05 16:42:27 +02:00
// Used to sample in the fragment shader for shadowed rendering
2020-06-20 00:08:13 +02:00
VkFilter shadowmap_filter = vks : : tools : : formatIsFilterable ( physicalDevice , DEPTH_FORMAT , VK_IMAGE_TILING_OPTIMAL ) ?
DEFAULT_SHADOWMAP_FILTER :
VK_FILTER_NEAREST ;
2017-02-12 11:12:42 +01:00
VkSamplerCreateInfo sampler = vks : : initializers : : samplerCreateInfo ( ) ;
2020-06-20 00:08:13 +02:00
sampler . magFilter = shadowmap_filter ;
sampler . minFilter = shadowmap_filter ;
2016-06-05 15:44:04 +02:00
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 ;
2017-06-01 22:32:39 +02:00
sampler . maxAnisotropy = 1.0f ;
2016-06-05 15:44:04 +02:00
sampler . minLod = 0.0f ;
sampler . maxLod = 1.0f ;
sampler . borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE ;
2016-08-13 19:31:41 +02:00
VK_CHECK_RESULT ( vkCreateSampler ( device , & sampler , nullptr , & offscreenPass . depthSampler ) ) ;
2016-06-05 15:44:04 +02:00
prepareOffscreenRenderpass ( ) ;
2016-03-10 21:17:48 +01:00
// Create frame buffer
2017-02-12 11:12:42 +01:00
VkFramebufferCreateInfo fbufCreateInfo = vks : : initializers : : framebufferCreateInfo ( ) ;
2020-05-29 16:08:53 +01:00
fbufCreateInfo . renderPass = offscreenPass . renderPass ;
2016-08-13 19:53:37 +02:00
fbufCreateInfo . attachmentCount = 1 ;
fbufCreateInfo . pAttachments = & offscreenPass . depth . view ;
2016-08-13 19:31:41 +02:00
fbufCreateInfo . width = offscreenPass . width ;
fbufCreateInfo . height = offscreenPass . height ;
2016-03-08 21:52:40 +01:00
fbufCreateInfo . layers = 1 ;
2016-08-13 19:31:41 +02:00
VK_CHECK_RESULT ( vkCreateFramebuffer ( device , & fbufCreateInfo , nullptr , & offscreenPass . frameBuffer ) ) ;
2016-03-08 21:52:40 +01:00
}
void buildCommandBuffers ( )
{
2017-02-12 11:12:42 +01:00
VkCommandBufferBeginInfo cmdBufInfo = vks : : initializers : : commandBufferBeginInfo ( ) ;
2016-03-08 21:52:40 +01:00
VkClearValue clearValues [ 2 ] ;
2019-04-01 20:22:28 +02:00
VkViewport viewport ;
VkRect2D scissor ;
2016-03-08 21:52:40 +01:00
for ( int32_t i = 0 ; i < drawCmdBuffers . size ( ) ; + + i )
{
2016-05-14 19:27:23 +02:00
VK_CHECK_RESULT ( vkBeginCommandBuffer ( drawCmdBuffers [ i ] , & cmdBufInfo ) ) ;
2016-03-08 21:52:40 +01:00
2019-04-01 20:22:28 +02:00
/*
First render pass : Generate shadow map by rendering the scene from light ' s POV
*/
{
clearValues [ 0 ] . depthStencil = { 1.0f , 0 } ;
2020-05-29 16:08:53 +01:00
2019-04-01 20:22:28 +02:00
VkRenderPassBeginInfo renderPassBeginInfo = vks : : initializers : : renderPassBeginInfo ( ) ;
renderPassBeginInfo . renderPass = offscreenPass . renderPass ;
renderPassBeginInfo . framebuffer = offscreenPass . frameBuffer ;
renderPassBeginInfo . renderArea . extent . width = offscreenPass . width ;
renderPassBeginInfo . renderArea . extent . height = offscreenPass . height ;
renderPassBeginInfo . clearValueCount = 1 ;
renderPassBeginInfo . pClearValues = clearValues ;
vkCmdBeginRenderPass ( drawCmdBuffers [ i ] , & renderPassBeginInfo , VK_SUBPASS_CONTENTS_INLINE ) ;
2020-05-29 16:08:53 +01:00
2019-04-01 20:22:28 +02:00
viewport = vks : : initializers : : viewport ( ( float ) offscreenPass . width , ( float ) offscreenPass . height , 0.0f , 1.0f ) ;
vkCmdSetViewport ( drawCmdBuffers [ i ] , 0 , 1 , & viewport ) ;
scissor = vks : : initializers : : rect2D ( offscreenPass . width , offscreenPass . height , 0 , 0 ) ;
vkCmdSetScissor ( drawCmdBuffers [ i ] , 0 , 1 , & scissor ) ;
// Set depth bias (aka "Polygon offset")
2020-08-09 13:48:49 +02:00
// Required to avoid shadow mapping artifacts
2019-04-01 20:22:28 +02:00
vkCmdSetDepthBias (
drawCmdBuffers [ i ] ,
depthBiasConstant ,
0.0f ,
depthBiasSlope ) ;
vkCmdBindPipeline ( drawCmdBuffers [ i ] , VK_PIPELINE_BIND_POINT_GRAPHICS , pipelines . offscreen ) ;
2020-07-28 20:20:38 +02:00
vkCmdBindDescriptorSets ( drawCmdBuffers [ i ] , VK_PIPELINE_BIND_POINT_GRAPHICS , pipelineLayout , 0 , 1 , & descriptorSets . offscreen , 0 , nullptr ) ;
scenes [ sceneIndex ] . draw ( drawCmdBuffers [ i ] ) ;
2019-04-01 20:22:28 +02:00
vkCmdEndRenderPass ( drawCmdBuffers [ i ] ) ;
}
/*
Note : Explicit synchronization is not required between the render pass , as this is done implicit via sub pass dependencies
*/
2016-03-08 21:52:40 +01:00
2019-04-01 20:22:28 +02:00
/*
Second pass : Scene rendering with applied shadow map
*/
2016-03-08 21:52:40 +01:00
2019-04-01 20:22:28 +02:00
{
clearValues [ 0 ] . color = defaultClearColor ;
clearValues [ 1 ] . depthStencil = { 1.0f , 0 } ;
2016-03-08 21:52:40 +01:00
2019-04-01 20:22:28 +02:00
VkRenderPassBeginInfo renderPassBeginInfo = vks : : initializers : : renderPassBeginInfo ( ) ;
renderPassBeginInfo . renderPass = renderPass ;
renderPassBeginInfo . framebuffer = frameBuffers [ i ] ;
renderPassBeginInfo . renderArea . extent . width = width ;
renderPassBeginInfo . renderArea . extent . height = height ;
renderPassBeginInfo . clearValueCount = 2 ;
renderPassBeginInfo . pClearValues = clearValues ;
2016-03-08 21:52:40 +01:00
2019-04-01 20:22:28 +02:00
vkCmdBeginRenderPass ( drawCmdBuffers [ i ] , & renderPassBeginInfo , VK_SUBPASS_CONTENTS_INLINE ) ;
viewport = vks : : initializers : : viewport ( ( float ) width , ( float ) height , 0.0f , 1.0f ) ;
vkCmdSetViewport ( drawCmdBuffers [ i ] , 0 , 1 , & viewport ) ;
2016-03-08 21:52:40 +01:00
2019-04-01 20:22:28 +02:00
scissor = vks : : initializers : : rect2D ( width , height , 0 , 0 ) ;
vkCmdSetScissor ( drawCmdBuffers [ i ] , 0 , 1 , & scissor ) ;
2016-03-08 21:52:40 +01:00
2019-04-01 20:22:28 +02:00
// Visualize shadow map
if ( displayShadowMap ) {
2020-07-28 20:20:38 +02:00
vkCmdBindDescriptorSets ( drawCmdBuffers [ i ] , VK_PIPELINE_BIND_POINT_GRAPHICS , pipelineLayout , 0 , 1 , & descriptorSets . debug , 0 , nullptr ) ;
vkCmdBindPipeline ( drawCmdBuffers [ i ] , VK_PIPELINE_BIND_POINT_GRAPHICS , pipelines . debug ) ;
vkCmdDraw ( drawCmdBuffers [ i ] , 3 , 1 , 0 , 0 ) ;
2019-04-01 20:22:28 +02:00
}
2016-03-08 21:52:40 +01:00
2019-04-01 20:22:28 +02:00
// 3D scene
2020-07-28 20:20:38 +02:00
vkCmdBindDescriptorSets ( drawCmdBuffers [ i ] , VK_PIPELINE_BIND_POINT_GRAPHICS , pipelineLayout , 0 , 1 , & descriptorSets . scene , 0 , nullptr ) ;
2019-04-01 20:22:28 +02:00
vkCmdBindPipeline ( drawCmdBuffers [ i ] , VK_PIPELINE_BIND_POINT_GRAPHICS , ( filterPCF ) ? pipelines . sceneShadowPCF : pipelines . sceneShadow ) ;
2020-07-28 20:20:38 +02:00
scenes [ sceneIndex ] . draw ( drawCmdBuffers [ i ] ) ;
2019-04-01 20:22:28 +02:00
drawUI ( drawCmdBuffers [ i ] ) ;
vkCmdEndRenderPass ( drawCmdBuffers [ i ] ) ;
}
2016-03-08 21:52:40 +01:00
2016-05-14 19:27:23 +02:00
VK_CHECK_RESULT ( vkEndCommandBuffer ( drawCmdBuffers [ i ] ) ) ;
2016-03-08 21:52:40 +01:00
}
}
2016-08-13 20:35:22 +02:00
void loadAssets ( )
2016-03-08 21:52:40 +01:00
{
2020-07-28 20:20:38 +02:00
const uint32_t glTFLoadingFlags = vkglTF : : FileLoadingFlags : : PreTransformVertices | vkglTF : : FileLoadingFlags : : PreMultiplyVertexColors | vkglTF : : FileLoadingFlags : : FlipY ;
2017-11-04 21:23:37 +01:00
scenes . resize ( 2 ) ;
2020-07-28 20:20:38 +02:00
scenes [ 0 ] . loadFromFile ( getAssetPath ( ) + " models/vulkanscene_shadow.gltf " , vulkanDevice , queue , glTFLoadingFlags ) ;
scenes [ 1 ] . loadFromFile ( getAssetPath ( ) + " models/samplescene.gltf " , vulkanDevice , queue , glTFLoadingFlags ) ;
2017-11-04 21:23:37 +01:00
sceneNames = { " Vulkan scene " , " Teapots and pillars " } ;
2016-03-08 21:52:40 +01:00
}
void setupDescriptorPool ( )
{
2019-04-01 20:22:28 +02:00
std : : vector < VkDescriptorPoolSize > poolSizes = {
2020-07-28 20:20:38 +02:00
vks : : initializers : : descriptorPoolSize ( VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 3 ) ,
vks : : initializers : : descriptorPoolSize ( VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER , 3 )
2016-03-08 21:52:40 +01:00
} ;
2020-07-28 20:20:38 +02:00
VkDescriptorPoolCreateInfo descriptorPoolInfo = vks : : initializers : : descriptorPoolCreateInfo ( poolSizes , 3 ) ;
2016-05-14 19:27:23 +02:00
VK_CHECK_RESULT ( vkCreateDescriptorPool ( device , & descriptorPoolInfo , nullptr , & descriptorPool ) ) ;
2016-03-08 21:52:40 +01:00
}
void setupDescriptorSetLayout ( )
{
2020-07-28 20:20:38 +02:00
// Shared pipeline layout for all pipelines used in this sample
2019-04-01 20:22:28 +02:00
std : : vector < VkDescriptorSetLayoutBinding > setLayoutBindings = {
2016-03-08 21:52:40 +01:00
// Binding 0 : Vertex shader uniform buffer
2019-04-01 20:22:28 +02:00
vks : : initializers : : descriptorSetLayoutBinding ( VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , VK_SHADER_STAGE_VERTEX_BIT , 0 ) ,
2020-07-28 20:20:38 +02:00
// Binding 1 : Fragment shader image sampler (shadow map)
2019-04-01 20:22:28 +02:00
vks : : initializers : : descriptorSetLayoutBinding ( VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER , VK_SHADER_STAGE_FRAGMENT_BIT , 1 )
2016-03-08 21:52:40 +01:00
} ;
2020-07-28 20:20:38 +02:00
VkDescriptorSetLayoutCreateInfo descriptorLayout = vks : : initializers : : descriptorSetLayoutCreateInfo ( setLayoutBindings ) ;
2016-05-14 19:27:23 +02:00
VK_CHECK_RESULT ( vkCreateDescriptorSetLayout ( device , & descriptorLayout , nullptr , & descriptorSetLayout ) ) ;
2020-07-28 20:20:38 +02:00
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = vks : : initializers : : pipelineLayoutCreateInfo ( & descriptorSetLayout , 1 ) ;
VK_CHECK_RESULT ( vkCreatePipelineLayout ( device , & pPipelineLayoutCreateInfo , nullptr , & pipelineLayout ) ) ;
2016-03-08 21:52:40 +01:00
}
void setupDescriptorSets ( )
{
2016-12-24 12:48:01 +01:00
std : : vector < VkWriteDescriptorSet > writeDescriptorSets ;
2016-06-05 15:44:04 +02:00
// Image descriptor for the shadow map attachment
2020-07-28 20:20:38 +02:00
VkDescriptorImageInfo shadowMapDescriptor =
vks : : initializers : : descriptorImageInfo (
offscreenPass . depthSampler ,
offscreenPass . depth . view ,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL ) ;
// Debug display
VkDescriptorSetAllocateInfo allocInfo = vks : : initializers : : descriptorSetAllocateInfo ( descriptorPool , & descriptorSetLayout , 1 ) ;
VK_CHECK_RESULT ( vkAllocateDescriptorSets ( device , & allocInfo , & descriptorSets . debug ) ) ;
2016-12-24 12:48:01 +01:00
writeDescriptorSets = {
2016-03-08 21:52:40 +01:00
// Binding 1 : Fragment shader texture sampler
2020-07-28 20:20:38 +02:00
vks : : initializers : : writeDescriptorSet ( descriptorSets . debug , VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER , 1 , & shadowMapDescriptor )
2016-03-08 21:52:40 +01:00
} ;
2020-07-28 20:20:38 +02:00
vkUpdateDescriptorSets ( device , writeDescriptorSets . size ( ) , writeDescriptorSets . data ( ) , 0 , nullptr ) ;
2016-03-08 21:52:40 +01:00
2020-07-28 20:20:38 +02:00
// Offscreen shadow map generation
2016-05-14 19:27:23 +02:00
VK_CHECK_RESULT ( vkAllocateDescriptorSets ( device , & allocInfo , & descriptorSets . offscreen ) ) ;
2016-12-24 12:48:01 +01:00
writeDescriptorSets = {
2016-03-08 21:52:40 +01:00
// Binding 0 : Vertex shader uniform buffer
2019-04-01 20:22:28 +02:00
vks : : initializers : : writeDescriptorSet ( descriptorSets . offscreen , VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 0 , & uniformBuffers . offscreen . descriptor ) ,
2016-03-08 21:52:40 +01:00
} ;
2020-07-28 20:20:38 +02:00
vkUpdateDescriptorSets ( device , writeDescriptorSets . size ( ) , writeDescriptorSets . data ( ) , 0 , nullptr ) ;
2016-03-08 21:52:40 +01:00
2020-08-09 13:48:49 +02:00
// Scene rendering with shadow map applied
2016-05-14 19:27:23 +02:00
VK_CHECK_RESULT ( vkAllocateDescriptorSets ( device , & allocInfo , & descriptorSets . scene ) ) ;
2016-12-24 12:48:01 +01:00
writeDescriptorSets = {
2016-03-08 21:52:40 +01:00
// Binding 0 : Vertex shader uniform buffer
2019-04-01 20:22:28 +02:00
vks : : initializers : : writeDescriptorSet ( descriptorSets . scene , VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER , 0 , & uniformBuffers . scene . descriptor ) ,
2016-03-08 21:52:40 +01:00
// Binding 1 : Fragment shader shadow sampler
2020-07-28 20:20:38 +02:00
vks : : initializers : : writeDescriptorSet ( descriptorSets . scene , VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER , 1 , & shadowMapDescriptor )
2016-03-08 21:52:40 +01:00
} ;
2020-07-28 20:20:38 +02:00
vkUpdateDescriptorSets ( device , writeDescriptorSets . size ( ) , writeDescriptorSets . data ( ) , 0 , nullptr ) ;
2016-03-08 21:52:40 +01:00
}
void preparePipelines ( )
{
2019-04-01 20:22:28 +02:00
VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = vks : : initializers : : pipelineInputAssemblyStateCreateInfo ( VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST , 0 , VK_FALSE ) ;
2020-07-28 20:20:38 +02:00
VkPipelineRasterizationStateCreateInfo rasterizationStateCI = vks : : initializers : : pipelineRasterizationStateCreateInfo ( VK_POLYGON_MODE_FILL , VK_CULL_MODE_BACK_BIT , VK_FRONT_FACE_COUNTER_CLOCKWISE , 0 ) ;
2019-04-01 20:22:28 +02:00
VkPipelineColorBlendAttachmentState blendAttachmentState = vks : : initializers : : pipelineColorBlendAttachmentState ( 0xf , VK_FALSE ) ;
VkPipelineColorBlendStateCreateInfo colorBlendStateCI = vks : : initializers : : pipelineColorBlendStateCreateInfo ( 1 , & blendAttachmentState ) ;
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 ) ;
std : : vector < VkDynamicState > dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT , VK_DYNAMIC_STATE_SCISSOR } ;
VkPipelineDynamicStateCreateInfo dynamicStateCI = vks : : initializers : : pipelineDynamicStateCreateInfo ( dynamicStateEnables . data ( ) , dynamicStateEnables . size ( ) , 0 ) ;
2016-03-08 21:52:40 +01:00
std : : array < VkPipelineShaderStageCreateInfo , 2 > shaderStages ;
2020-07-28 20:20:38 +02:00
VkGraphicsPipelineCreateInfo pipelineCI = vks : : initializers : : pipelineCreateInfo ( pipelineLayout , renderPass , 0 ) ;
2019-04-01 20:22:28 +02:00
pipelineCI . pInputAssemblyState = & inputAssemblyStateCI ;
pipelineCI . pRasterizationState = & rasterizationStateCI ;
pipelineCI . pColorBlendState = & colorBlendStateCI ;
pipelineCI . pMultisampleState = & multisampleStateCI ;
pipelineCI . pViewportState = & viewportStateCI ;
pipelineCI . pDepthStencilState = & depthStencilStateCI ;
pipelineCI . pDynamicState = & dynamicStateCI ;
pipelineCI . stageCount = shaderStages . size ( ) ;
pipelineCI . pStages = shaderStages . data ( ) ;
2016-03-08 21:52:40 +01:00
2017-11-01 14:22:10 +01:00
// Shadow mapping debug quad display
2019-04-01 20:22:28 +02:00
rasterizationStateCI . cullMode = VK_CULL_MODE_NONE ;
2020-05-29 16:08:53 +01:00
shaderStages [ 0 ] = loadShader ( getShadersPath ( ) + " shadowmapping/quad.vert.spv " , VK_SHADER_STAGE_VERTEX_BIT ) ;
shaderStages [ 1 ] = loadShader ( getShadersPath ( ) + " shadowmapping/quad.frag.spv " , VK_SHADER_STAGE_FRAGMENT_BIT ) ;
2017-11-12 19:32:09 +01:00
// Empty vertex input state
VkPipelineVertexInputStateCreateInfo emptyInputState = vks : : initializers : : pipelineVertexInputStateCreateInfo ( ) ;
2019-04-01 20:22:28 +02:00
pipelineCI . pVertexInputState = & emptyInputState ;
2020-07-28 20:20:38 +02:00
VK_CHECK_RESULT ( vkCreateGraphicsPipelines ( device , pipelineCache , 1 , & pipelineCI , nullptr , & pipelines . debug ) ) ;
2017-11-12 19:32:09 +01:00
2017-01-07 20:20:40 +01:00
// Scene rendering with shadows applied
2020-07-28 20:20:38 +02:00
pipelineCI . pVertexInputState = vkglTF : : Vertex : : getPipelineVertexInputState ( { vkglTF : : VertexComponent : : Position , vkglTF : : VertexComponent : : UV , vkglTF : : VertexComponent : : Color , vkglTF : : VertexComponent : : Normal } ) ;
2019-04-01 20:22:28 +02:00
rasterizationStateCI . cullMode = VK_CULL_MODE_BACK_BIT ;
2020-05-29 16:08:53 +01:00
shaderStages [ 0 ] = loadShader ( getShadersPath ( ) + " shadowmapping/scene.vert.spv " , VK_SHADER_STAGE_VERTEX_BIT ) ;
shaderStages [ 1 ] = loadShader ( getShadersPath ( ) + " shadowmapping/scene.frag.spv " , VK_SHADER_STAGE_FRAGMENT_BIT ) ;
2017-01-07 20:20:40 +01:00
// Use specialization constants to select between horizontal and vertical blur
uint32_t enablePCF = 0 ;
2017-02-12 11:12:42 +01:00
VkSpecializationMapEntry specializationMapEntry = vks : : initializers : : specializationMapEntry ( 0 , 0 , sizeof ( uint32_t ) ) ;
VkSpecializationInfo specializationInfo = vks : : initializers : : specializationInfo ( 1 , & specializationMapEntry , sizeof ( uint32_t ) , & enablePCF ) ;
2017-01-07 20:20:40 +01:00
shaderStages [ 1 ] . pSpecializationInfo = & specializationInfo ;
// No filtering
2019-04-01 20:22:28 +02:00
VK_CHECK_RESULT ( vkCreateGraphicsPipelines ( device , pipelineCache , 1 , & pipelineCI , nullptr , & pipelines . sceneShadow ) ) ;
2017-01-07 20:20:40 +01:00
// PCF filtering
enablePCF = 1 ;
2019-04-01 20:22:28 +02:00
VK_CHECK_RESULT ( vkCreateGraphicsPipelines ( device , pipelineCache , 1 , & pipelineCI , nullptr , & pipelines . sceneShadowPCF ) ) ;
2016-03-08 21:52:40 +01:00
2018-05-21 16:45:19 -07:00
// Offscreen pipeline (vertex shader only)
2020-05-29 16:08:53 +01:00
shaderStages [ 0 ] = loadShader ( getShadersPath ( ) + " shadowmapping/offscreen.vert.spv " , VK_SHADER_STAGE_VERTEX_BIT ) ;
2019-04-01 20:22:28 +02:00
pipelineCI . stageCount = 1 ;
2016-08-13 19:53:37 +02:00
// No blend attachment states (no color attachments used)
2019-04-01 20:22:28 +02:00
colorBlendStateCI . attachmentCount = 0 ;
2016-03-08 21:52:40 +01:00
// Cull front faces
2019-04-01 20:22:28 +02:00
depthStencilStateCI . depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL ;
2016-03-08 21:52:40 +01:00
// Enable depth bias
2019-04-01 20:22:28 +02:00
rasterizationStateCI . depthBiasEnable = VK_TRUE ;
2016-03-08 21:52:40 +01:00
// Add depth bias to dynamic state, so we can change it at runtime
dynamicStateEnables . push_back ( VK_DYNAMIC_STATE_DEPTH_BIAS ) ;
2019-04-01 20:22:28 +02:00
dynamicStateCI =
2017-02-12 11:12:42 +01:00
vks : : initializers : : pipelineDynamicStateCreateInfo (
2016-03-08 21:52:40 +01:00
dynamicStateEnables . data ( ) ,
dynamicStateEnables . size ( ) ,
0 ) ;
2019-04-01 20:22:28 +02:00
pipelineCI . renderPass = offscreenPass . renderPass ;
VK_CHECK_RESULT ( vkCreateGraphicsPipelines ( device , pipelineCache , 1 , & pipelineCI , nullptr , & pipelines . offscreen ) ) ;
2016-03-08 21:52:40 +01:00
}
// Prepare and initialize uniform buffer containing shader uniforms
void prepareUniformBuffers ( )
{
2016-08-13 19:31:41 +02:00
// Offscreen vertex shader uniform buffer block
2016-12-24 12:48:01 +01:00
VK_CHECK_RESULT ( vulkanDevice - > createBuffer (
2016-03-08 21:52:40 +01:00
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT ,
2016-06-05 15:44:04 +02:00
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ,
2016-12-24 12:48:01 +01:00
& uniformBuffers . offscreen ,
sizeof ( uboOffscreenVS ) ) ) ;
2016-03-08 21:52:40 +01:00
2020-05-29 16:08:53 +01:00
// Scene vertex shader uniform buffer block
2016-12-24 12:48:01 +01:00
VK_CHECK_RESULT ( vulkanDevice - > createBuffer (
2016-03-08 21:52:40 +01:00
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT ,
2016-06-05 15:44:04 +02:00
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ,
2016-12-24 12:48:01 +01:00
& uniformBuffers . scene ,
sizeof ( uboVSscene ) ) ) ;
// Map persistent
VK_CHECK_RESULT ( uniformBuffers . offscreen . map ( ) ) ;
VK_CHECK_RESULT ( uniformBuffers . scene . map ( ) ) ;
2016-03-08 21:52:40 +01:00
updateLight ( ) ;
updateUniformBufferOffscreen ( ) ;
updateUniformBuffers ( ) ;
}
void updateLight ( )
{
// Animate the light source
lightPos . x = cos ( glm : : radians ( timer * 360.0f ) ) * 40.0f ;
lightPos . y = - 50.0f + sin ( glm : : radians ( timer * 360.0f ) ) * 20.0f ;
lightPos . z = 25.0f + sin ( glm : : radians ( timer * 360.0f ) ) * 5.0f ;
}
void updateUniformBuffers ( )
{
2020-04-22 20:58:24 +02:00
uboVSscene . projection = camera . matrices . perspective ;
uboVSscene . view = camera . matrices . view ;
2017-09-24 18:17:07 +02:00
uboVSscene . model = glm : : mat4 ( 1.0f ) ;
2016-03-08 21:52:40 +01:00
uboVSscene . lightPos = lightPos ;
uboVSscene . depthBiasMVP = uboOffscreenVS . depthMVP ;
2016-12-24 12:48:01 +01:00
memcpy ( uniformBuffers . scene . mapped , & uboVSscene , sizeof ( uboVSscene ) ) ;
2016-03-08 21:52:40 +01:00
}
void updateUniformBufferOffscreen ( )
{
// Matrix from light's point of view
glm : : mat4 depthProjectionMatrix = glm : : perspective ( glm : : radians ( lightFOV ) , 1.0f , zNear , zFar ) ;
2016-06-05 15:44:04 +02:00
glm : : mat4 depthViewMatrix = glm : : lookAt ( lightPos , glm : : vec3 ( 0.0f ) , glm : : vec3 ( 0 , 1 , 0 ) ) ;
2017-09-24 18:17:07 +02:00
glm : : mat4 depthModelMatrix = glm : : mat4 ( 1.0f ) ;
2016-03-08 21:52:40 +01:00
uboOffscreenVS . depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix ;
2016-12-24 12:48:01 +01:00
memcpy ( uniformBuffers . offscreen . mapped , & uboOffscreenVS , sizeof ( uboOffscreenVS ) ) ;
2016-03-08 21:52:40 +01:00
}
2016-06-05 15:44:04 +02:00
void draw ( )
2016-03-08 21:52:40 +01:00
{
2016-06-05 15:44:04 +02:00
VulkanExampleBase : : prepareFrame ( ) ;
2016-03-08 21:52:40 +01:00
2020-08-09 13:16:35 +02:00
// Command buffer to be submitted to the queue
2016-06-05 15:44:04 +02:00
submitInfo . commandBufferCount = 1 ;
submitInfo . pCommandBuffers = & drawCmdBuffers [ currentBuffer ] ;
2019-04-01 20:22:28 +02:00
// Submit to queue
2016-06-05 15:44:04 +02:00
VK_CHECK_RESULT ( vkQueueSubmit ( queue , 1 , & submitInfo , VK_NULL_HANDLE ) ) ;
2016-03-08 21:52:40 +01:00
2016-06-05 15:44:04 +02:00
VulkanExampleBase : : submitFrame ( ) ;
2016-03-08 21:52:40 +01:00
}
void prepare ( )
{
VulkanExampleBase : : prepare ( ) ;
2016-08-13 20:35:22 +02:00
loadAssets ( ) ;
2016-06-05 15:44:04 +02:00
prepareOffscreenFramebuffer ( ) ;
2016-03-08 21:52:40 +01:00
prepareUniformBuffers ( ) ;
setupDescriptorSetLayout ( ) ;
preparePipelines ( ) ;
setupDescriptorPool ( ) ;
setupDescriptorSets ( ) ;
buildCommandBuffers ( ) ;
prepared = true ;
}
virtual void render ( )
{
if ( ! prepared )
return ;
draw ( ) ;
2019-04-01 20:22:28 +02:00
if ( ! paused | | camera . updated )
2016-03-08 21:52:40 +01:00
{
updateLight ( ) ;
updateUniformBufferOffscreen ( ) ;
updateUniformBuffers ( ) ;
}
}
2017-11-01 14:22:10 +01:00
virtual void OnUpdateUIOverlay ( vks : : UIOverlay * overlay )
2016-06-05 15:44:04 +02:00
{
2017-11-01 14:22:10 +01:00
if ( overlay - > header ( " Settings " ) ) {
2017-11-04 21:23:37 +01:00
if ( overlay - > comboBox ( " Scenes " , & sceneIndex , sceneNames ) ) {
buildCommandBuffers ( ) ;
}
2017-11-04 21:29:11 +01:00
if ( overlay - > checkBox ( " Display shadow render target " , & displayShadowMap ) ) {
2017-11-01 14:22:10 +01:00
buildCommandBuffers ( ) ;
}
if ( overlay - > checkBox ( " PCF filtering " , & filterPCF ) ) {
buildCommandBuffers ( ) ;
}
2016-06-05 15:44:04 +02:00
}
}
2016-03-08 21:52:40 +01:00
} ;
2016-08-13 19:31:41 +02:00
VULKAN_EXAMPLE_MAIN ( )