Add world space coordinates map to GBuffer and add its image usage as input attachment

src/VK/GLTF/GltfPbrPass.cpp

@@ -551,6 +551,19 @@ namespace CAULDRON_VK
             att_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
             att_states.push_back(att_state);
         }
+        if (defines.Has("HAS_WORLD_COORD_RT"))
+        {
+            VkPipelineColorBlendAttachmentState att_state = {};
+            att_state.colorWriteMask = 0xf;
+            att_state.blendEnable = VK_FALSE;
+            att_state.alphaBlendOp = VK_BLEND_OP_ADD;
+            att_state.colorBlendOp = VK_BLEND_OP_ADD;
+            att_state.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+            att_state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+            att_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+            att_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+            att_states.push_back(att_state);
+        }
         if (defines.Has("HAS_MOTION_VECTORS_RT"))
         {
             VkPipelineColorBlendAttachmentState att_state = {};

src/VK/base/GBuffer.cpp

@@ -78,6 +78,13 @@ namespace CAULDRON_VK
             defines["HAS_NORMALS_RT"] = std::to_string(rtIndex++);
         }
 
+        // World Space Coordinates
+        //
+        if (m_flags & GBUFFER_WORLD_COORD)
+        {
+            defines["HAS_WORLD_COORD_RT"] = std::to_string(rtIndex++);
+        }
+
         // Diffuse
         //
         if (m_flags & GBUFFER_DIFFUSE)
@@ -120,7 +127,7 @@ namespace CAULDRON_VK
     //
     VkRenderPass GBuffer::CreateRenderPass(GBufferFlags flags, bool bClear)
     {
-        VkAttachmentDescription depthAttachment;
+        VkAttachmentDescription *pDepthAttachment = NULL;
         VkAttachmentDescription colorAttachments[10];
         uint32_t colorAttanchmentCount = 0;
 
@@ -146,6 +153,12 @@ namespace CAULDRON_VK
             assert(m_GBufferFlags & GBUFFER_NORMAL_BUFFER); // asserts if there if the RT is not present in the GBuffer
         }
 
+        if (flags & GBUFFER_WORLD_COORD)
+        {
+            addAttachment(m_formats[GBUFFER_WORLD_COORD], m_sampleCount, previousColor, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, &colorAttachments[colorAttanchmentCount++]);
+            assert(m_GBufferFlags & GBUFFER_WORLD_COORD); // asserts if there if the RT is not present in the GBuffer
+        }
+
         if (flags & GBUFFER_DIFFUSE)
         {
             addAttachment(m_formats[GBUFFER_DIFFUSE], m_sampleCount, previousColor, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, &colorAttachments[colorAttanchmentCount++]);
@@ -160,11 +173,17 @@ namespace CAULDRON_VK
 
         if (flags & GBUFFER_DEPTH)
         {
-            addAttachment(m_formats[GBUFFER_DEPTH], m_sampleCount, previousDepth, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, &depthAttachment);
+            pDepthAttachment = new VkAttachmentDescription[1];
+            addAttachment(m_formats[GBUFFER_DEPTH], m_sampleCount, previousDepth, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, pDepthAttachment);
             assert(m_GBufferFlags & GBUFFER_DEPTH); // asserts if there if the RT is not present in the GBuffer
         }
 
-        return CreateRenderPassOptimal(m_pDevice->GetDevice(), colorAttanchmentCount, colorAttachments, &depthAttachment);
+        VkRenderPass renderPass = CreateRenderPassOptimal(m_pDevice->GetDevice(), colorAttanchmentCount, colorAttachments, pDepthAttachment);
+
+        if (pDepthAttachment != NULL)
+            delete[] pDepthAttachment;
+
+        return renderPass;
     }
 
     void GBuffer::GetAttachmentList(GBufferFlags flags, std::vector<VkImageView> *pAttachments, std::vector<VkClearValue> *pClearValues)
@@ -213,6 +232,20 @@ namespace CAULDRON_VK
             }
         }
 
+        // World Space Coordinates
+        //
+        if (flags & GBUFFER_WORLD_COORD)
+        {
+            pAttachments->push_back(m_WorldCoordSRV);
+
+            if (pClearValues)
+            {
+                VkClearValue cv;
+                cv.color = { 0.0f, 0.0f, 0.0f, 0.0f };
+                pClearValues->push_back(cv);
+            }
+        }
+
         // Diffuse
         //
         if (flags & GBUFFER_DIFFUSE)
@@ -262,39 +295,47 @@ namespace CAULDRON_VK
         //
         if (m_GBufferFlags & GBUFFER_FORWARD)
         {
-            m_HDR.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_FORWARD], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), false, "m_HDR");
+            m_HDR.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_FORWARD], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT), false, "m_HDR");
             m_HDR.CreateSRV(&m_HDRSRV);
         }
 
         // Motion Vectors
         //
         if (m_GBufferFlags & GBUFFER_MOTION_VECTORS)
         {
-            m_MotionVectors.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_MOTION_VECTORS], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), false, "m_MotionVector");
+            m_MotionVectors.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_MOTION_VECTORS], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT), false, "m_MotionVector");
             m_MotionVectors.CreateSRV(&m_MotionVectorsSRV);
         }
 
         // Normal Buffer
         //
         if (m_GBufferFlags & GBUFFER_NORMAL_BUFFER)
         {
-            m_NormalBuffer.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_NORMAL_BUFFER], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), false, "m_NormalBuffer");
+            m_NormalBuffer.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_NORMAL_BUFFER], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT), false, "m_NormalBuffer");
             m_NormalBuffer.CreateSRV(&m_NormalBufferSRV);
         }
 
+        // World Space Coordinates
+        //
+        if (m_GBufferFlags & GBUFFER_WORLD_COORD)
+        {
+            m_WorldCoord.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_WORLD_COORD], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT), false, "m_WorldCoord");
+            m_WorldCoord.CreateSRV(&m_WorldCoordSRV);
+        }
+
         // Diffuse
         //
         if (m_GBufferFlags & GBUFFER_DIFFUSE)
         {
-            m_Diffuse.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_DIFFUSE], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), false, "m_Diffuse");
+            m_Diffuse.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_DIFFUSE], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT), false, "m_Diffuse");
             m_Diffuse.CreateSRV(&m_DiffuseSRV);
         }
 
         // Specular Roughness
         //
         if (m_GBufferFlags & GBUFFER_SPECULAR_ROUGHNESS)
         {
-            m_SpecularRoughness.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_SPECULAR_ROUGHNESS], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT), false, "m_SpecularRoughness");
+            m_SpecularRoughness.InitRenderTarget(m_pDevice, Width, Height, m_formats[GBUFFER_SPECULAR_ROUGHNESS], m_sampleCount, (VkImageUsageFlags)(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT), false, "m_SpecularRoughness");
             m_SpecularRoughness.CreateSRV(&m_SpecularRoughnessSRV);
         }
 
@@ -322,6 +363,12 @@ namespace CAULDRON_VK
             m_Diffuse.OnDestroy();
         }
 
+        if (m_GBufferFlags & GBUFFER_WORLD_COORD)
+        {
+            vkDestroyImageView(m_pDevice->GetDevice(), m_WorldCoordSRV, nullptr);
+            m_WorldCoord.OnDestroy();
+        }
+
         if (m_GBufferFlags & GBUFFER_NORMAL_BUFFER)
         {
             vkDestroyImageView(m_pDevice->GetDevice(), m_NormalBufferSRV, nullptr);

src/VK/base/GBuffer.h

@@ -16,7 +16,8 @@ namespace CAULDRON_VK
         GBUFFER_MOTION_VECTORS = 4,
         GBUFFER_NORMAL_BUFFER = 8,
         GBUFFER_DIFFUSE = 16,
-        GBUFFER_SPECULAR_ROUGHNESS = 32
+        GBUFFER_SPECULAR_ROUGHNESS = 32,
+        GBUFFER_WORLD_COORD = 64
     } GBufferFlagBits;
 
     typedef uint32_t GBufferFlags;
@@ -82,6 +83,10 @@ namespace CAULDRON_VK
         Texture                         m_NormalBuffer;
         VkImageView                     m_NormalBufferSRV;
 
+        // world space coordinates
+        Texture                         m_WorldCoord;
+        VkImageView                     m_WorldCoordSRV;
+
         // HDR
         Texture                         m_HDR;
         VkImageView                     m_HDRSRV;

src/VK/base/Texture.cpp

@@ -272,7 +272,7 @@ namespace CAULDRON_VK
         image_info.queueFamilyIndexCount = 0;
         image_info.pQueueFamilyIndices = NULL;
         image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-        image_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; //TODO    
+        image_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; //TODO    
         image_info.flags = 0;
         image_info.tiling = VK_IMAGE_TILING_OPTIMAL;   // VK_IMAGE_TILING_LINEAR should never be used and will never be faster
 

src/VK/shaders/GLTFPbrPass-frag.glsl

@@ -74,6 +74,10 @@ layout(location = HAS_MOTION_VECTORS_RT) out vec2 Output_motionVect;
     layout (location = HAS_NORMALS_RT) out vec4 Output_normal;
 #endif
 
+#ifdef HAS_WORLD_COORD_RT
+    layout (location = HAS_WORLD_COORD_RT) out vec4 Output_worldCoord;
+#endif
+
 //--------------------------------------------------------------------------------------
 //
 // Constant Buffers 
@@ -141,6 +145,10 @@ void main()
     Output_diffuseColor = vec4(diffuseColor, 0);
 #endif
 
+#ifdef HAS_WORLD_COORD_RT
+    Output_worldCoord = vec4(Input.WorldPos, 1);
+#endif
+
 #ifdef HAS_NORMALS_RT
     Output_normal = vec4((getPixelNormal(Input) + 1) / 2, 0);
 #endif