diff --git a/renderdoc/Makefile b/renderdoc/Makefile index f4819492d..75221e1e1 100644 --- a/renderdoc/Makefile +++ b/renderdoc/Makefile @@ -63,6 +63,9 @@ data/glsl/quadoverdraw.frago \ data/glsl/histogram.compo \ data/glsl/arraymscopy.compo \ data/glsl/outline.frago \ +data/spv/blitvs.spv \ +data/spv/checkerboardfs.spv \ +data/spv/texdisplayfs.spv \ data/sourcecodepro.ttfo .PHONY: all @@ -105,6 +108,9 @@ $(OBJDIR)/%.ttfo: %.ttf $(OBJDIR)/%.ho: %.h @echo Object building $@ @$(OBJGEN) +$(OBJDIR)/%.spvo: %.spv + @echo Object building $@ + @$(OBJGEN) OBJDIR_OBJECTS=$(addprefix $(OBJDIR)/, $(OBJECTS)) OBJDIR_DATA=$(addprefix $(OBJDIR)/, $(DATA)) diff --git a/renderdoc/data/embedded_files.h b/renderdoc/data/embedded_files.h index 8a7652dfa..57a62bf15 100644 --- a/renderdoc/data/embedded_files.h +++ b/renderdoc/data/embedded_files.h @@ -47,5 +47,8 @@ DECLARE_EMBED(text_frag); DECLARE_EMBED(text_vert); DECLARE_EMBED(sourcecodepro_ttf); DECLARE_EMBED(outline_frag); +DECLARE_EMBED(blitvs_spv); +DECLARE_EMBED(checkerboardfs_spv); +DECLARE_EMBED(texdisplayfs_spv); #undef DECLARE_EMBED diff --git a/renderdoc/data/renderdoc.rc b/renderdoc/data/renderdoc.rc index b25aaf8e3..c3bf30139 100644 --- a/renderdoc/data/renderdoc.rc +++ b/renderdoc/data/renderdoc.rc @@ -131,6 +131,10 @@ RESOURCE_outline_frag TYPE_EMBED "glsl/outline.frag" RESOURCE_sourcecodepro_ttf TYPE_EMBED "sourcecodepro.ttf" +RESOURCE_blitvs_spv TYPE_EMBED "spv/blitvs.spv" +RESOURCE_checkerboardfs_spv TYPE_EMBED "spv/checkerboardfs.spv" +RESOURCE_texdisplayfs_spv TYPE_EMBED "spv/texdisplayfs.spv" + #ifndef APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // diff --git a/renderdoc/data/resource.h b/renderdoc/data/resource.h index d4bdf59b5..25971279c 100644 --- a/renderdoc/data/resource.h +++ b/renderdoc/data/resource.h @@ -33,6 +33,10 @@ #define RESOURCE_sourcecodepro_ttf 301 +#define RESOURCE_blitvs_spv 401 +#define RESOURCE_checkerboardfs_spv 402 +#define RESOURCE_texdisplayfs_spv 403 + #if !defined(STRINGIZE) #define STRINGIZE2(a) #a #define STRINGIZE(a) STRINGIZE2(a) diff --git a/renderdoc/data/spv/blit.vert b/renderdoc/data/spv/blit.vert new file mode 100644 index 000000000..d218292cf --- /dev/null +++ b/renderdoc/data/spv/blit.vert @@ -0,0 +1,42 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2015 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#version 420 core + +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; + float gl_ClipDistance[]; +}; + +void main(void) +{ + const vec4 verts[4] = vec4[4](vec4(-1.0, -1.0, 0.5, 1.0), + vec4( 1.0, -1.0, 0.5, 1.0), + vec4(-1.0, 1.0, 0.5, 1.0), + vec4( 1.0, 1.0, 0.5, 1.0)); + + gl_Position = verts[gl_VertexID]; +} diff --git a/renderdoc/data/spv/checkerboard.frag b/renderdoc/data/spv/checkerboard.frag new file mode 100644 index 000000000..190680ffe --- /dev/null +++ b/renderdoc/data/spv/checkerboard.frag @@ -0,0 +1,50 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2015 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#version 420 core + +layout (location = 0) out vec4 color_out; + +layout (binding = 0, std140) uniform checkeruniforms +{ + vec4 lightCol; + vec4 darkCol; +} checker; + +void main(void) +{ + vec2 ab = mod(gl_FragCoord.xy, 128.0f.xx); + + if( + (ab.x < 64 && ab.y < 64) || + (ab.x > 64 && ab.y > 64) + ) + { + color_out = vec4(sqrt(checker.lightCol.rgb), 1); + } + else + { + color_out = vec4(sqrt(checker.darkCol.rgb), 1); + } +} diff --git a/renderdoc/data/spv/texdisplay.frag b/renderdoc/data/spv/texdisplay.frag new file mode 100644 index 000000000..190680ffe --- /dev/null +++ b/renderdoc/data/spv/texdisplay.frag @@ -0,0 +1,50 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2015 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#version 420 core + +layout (location = 0) out vec4 color_out; + +layout (binding = 0, std140) uniform checkeruniforms +{ + vec4 lightCol; + vec4 darkCol; +} checker; + +void main(void) +{ + vec2 ab = mod(gl_FragCoord.xy, 128.0f.xx); + + if( + (ab.x < 64 && ab.y < 64) || + (ab.x > 64 && ab.y > 64) + ) + { + color_out = vec4(sqrt(checker.lightCol.rgb), 1); + } + else + { + color_out = vec4(sqrt(checker.darkCol.rgb), 1); + } +} diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index af7bccd54..66f04397e 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -36,6 +36,8 @@ VulkanReplay::OutputWindow::OutputWindow() : wnd(NULL_WND_HANDLE), width(0), hei { colimg[i] = VK_NULL_HANDLE; colview[i] = VK_NULL_HANDLE; + fb[i] = VK_NULL_HANDLE; + fbdepth[i] = VK_NULL_HANDLE; } VkImageMemoryBarrier t = { @@ -71,6 +73,12 @@ void VulkanReplay::OutputWindow::MakeTargets(const VulkanFunctions &vk, VkDevice if(colimg[i] != VK_NULL_HANDLE) { vk.vkDestroyAttachmentView(device, colview[i]); + vk.vkDestroyFramebuffer(device, fb[i]); + if(dsimg != VK_NULL_HANDLE) + vk.vkDestroyFramebuffer(device, fbdepth[i]); + + fb[i] = VK_NULL_HANDLE; + fbdepth[i] = VK_NULL_HANDLE; colimg[i] = VK_NULL_HANDLE; colview[i] = VK_NULL_HANDLE; } @@ -158,6 +166,38 @@ void VulkanReplay::OutputWindow::MakeTargets(const VulkanFunctions &vk, VkDevice */ } + { + VkAttachmentDescription attDesc = { + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION, NULL, + VK_FORMAT_B8G8R8A8_UNORM, 1, + VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL + }; + + VkAttachmentReference attRef = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; + + VkSubpassDescription sub = { + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION, NULL, + VK_PIPELINE_BIND_POINT_GRAPHICS, 0, + 0, NULL, // inputs + 1, &attRef, // color + NULL, // resolve + { VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_UNDEFINED }, // depth-stencil + 0, NULL, // preserve + }; + + VkRenderPassCreateInfo rpinfo = { + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, NULL, + 1, &attDesc, + 1, &sub, + 0, NULL, // dependencies + }; + + res = vk.vkCreateRenderPass(device, &rpinfo, &renderpass); + RDCASSERT(res == VK_SUCCESS); + } + for(uint32_t i=0; i < numImgs; i++) { if(colimg[i] != VK_NULL_HANDLE) @@ -167,7 +207,20 @@ void VulkanReplay::OutputWindow::MakeTargets(const VulkanFunctions &vk, VkDevice colimg[i], VK_FORMAT_B8G8R8A8_UNORM, 0, 0, 1, 0 }; - vk.vkCreateAttachmentView(device, &info, &colview[i]); + res = vk.vkCreateAttachmentView(device, &info, &colview[i]); + RDCASSERT(res == VK_SUCCESS); + + VkAttachmentBindInfo attBind = { colview[i], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }; + + VkFramebufferCreateInfo fbinfo = { + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, NULL, + renderpass, + 1, &attBind, + (uint32_t)width, (uint32_t)height, 1, + }; + + res = vk.vkCreateFramebuffer(device, &fbinfo, &fb[i]); + RDCASSERT(res == VK_SUCCESS); } } @@ -192,6 +245,246 @@ VulkanReplay::VulkanReplay() m_BindDepth = false; } +void VulkanReplay::InitDebugData() +{ + const VulkanFunctions &vk = m_pDriver->m_Real; + VkDevice dev = m_pDriver->GetDev(); + + VkResult vkr = VK_SUCCESS; + + // VKTODOMED all of this is leaking + + VkPipelineCacheCreateInfo cacheInfo = { VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, NULL, 0, NULL, 0 }; + + vkr = vk.vkCreatePipelineCache(dev, &cacheInfo, &m_PipelineCache); + RDCASSERT(vkr == VK_SUCCESS); + + VkDescriptorSetLayoutBinding layoutBinding[] = { + { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_ALL, NULL, } + }; + + VkDescriptorSetLayoutCreateInfo descsetLayoutInfo = { + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, NULL, + ARRAY_COUNT(layoutBinding), &layoutBinding[0], + }; + + vkr = vk.vkCreateDescriptorSetLayout(dev, &descsetLayoutInfo, &m_TexDisplayDescSetLayout); + RDCASSERT(vkr == VK_SUCCESS); + + VkPipelineLayoutCreateInfo pipeLayoutInfo = { + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, NULL, + 1, &m_TexDisplayDescSetLayout, + 0, NULL, // push constant ranges + }; + + vkr = vk.vkCreatePipelineLayout(dev, &pipeLayoutInfo, &m_TexDisplayPipeLayout); + RDCASSERT(vkr == VK_SUCCESS); + + VkDescriptorTypeCount descPoolTypes[] = { + { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, }, + }; + + VkDescriptorPoolCreateInfo descpoolInfo = { + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, NULL, + ARRAY_COUNT(descPoolTypes), &descPoolTypes[0], + }; + + vkr = vk.vkCreateDescriptorPool(dev, VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1, &descpoolInfo, &m_TexDisplayDescPool); + RDCASSERT(vkr == VK_SUCCESS); + + uint32_t count; + vkr = vk.vkAllocDescriptorSets(dev, m_TexDisplayDescPool, VK_DESCRIPTOR_SET_USAGE_STATIC, 1, &m_TexDisplayDescSetLayout, &m_TexDisplayDescSet, &count); + RDCASSERT(vkr == VK_SUCCESS); + + VkMemoryAllocInfo allocInfo = { + VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO, NULL, + 128, 2, // VKTODOHIGH find appropriate memory type index + }; + + vkr = vk.vkAllocMemory(dev, &allocInfo, &m_TexDisplayUBO.mem); + RDCASSERT(vkr == VK_SUCCESS); + + VkBufferCreateInfo bufInfo = { + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, NULL, + 128, VK_BUFFER_USAGE_GENERAL, 0, + VK_SHARING_MODE_EXCLUSIVE, 0, NULL, + }; + + vkr = vk.vkCreateBuffer(dev, &bufInfo, &m_TexDisplayUBO.buf); + RDCASSERT(vkr == VK_SUCCESS); + + vkr = vk.vkBindBufferMemory(dev, m_TexDisplayUBO.buf, m_TexDisplayUBO.mem, 0); + RDCASSERT(vkr == VK_SUCCESS); + + VkBufferViewCreateInfo bufviewInfo = { + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, NULL, + m_TexDisplayUBO.buf, VK_BUFFER_VIEW_TYPE_RAW, + VK_FORMAT_UNDEFINED, 0, 128, + }; + + vkr = vk.vkCreateBufferView(dev, &bufviewInfo, &m_TexDisplayUBO.view); + RDCASSERT(vkr == VK_SUCCESS); + + Vec4f *data = NULL; + vkr = vk.vkMapMemory(dev, m_TexDisplayUBO.mem, 0, 0, 0, (void **)&data); + data[0] = Vec4f(0.6f, 0.0f, 0.0f, 1.0f); + data[1] = Vec4f(0.0f, 0.0f, 0.6f, 1.0f); + vk.vkUnmapMemory(dev, m_TexDisplayUBO.mem); + + VkDescriptorInfo desc = { 0 }; desc.bufferView = m_TexDisplayUBO.view; + + VkWriteDescriptorSet writeSet = { + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, + m_TexDisplayDescSet, 0, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &desc + }; + + vkr = vk.vkUpdateDescriptorSets(dev, 1, &writeSet, 0, NULL); + RDCASSERT(vkr == VK_SUCCESS); + + VkDynamicRasterStateCreateInfo rsInfo = { + VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO, NULL, + 0.0f, 0.0f, 0.0f, 1.0f, + }; + + vkr = vk.vkCreateDynamicRasterState(dev, &rsInfo, &m_DynamicRSState); + RDCASSERT(vkr == VK_SUCCESS); + + VkDynamicColorBlendStateCreateInfo cbInfo = { + VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO, NULL, + { 1.0f, 1.0f, 1.0f, 1.0f }, + }; + + vkr = vk.vkCreateDynamicColorBlendState(dev, &cbInfo, &m_DynamicCBStateWhite); + RDCASSERT(vkr == VK_SUCCESS); + + VkDynamicDepthStencilStateCreateInfo dsInfo = { + VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO, NULL, + 0.0f, 1.0f, 0xff, 0xff, 0, 0, + }; + + vkr = vk.vkCreateDynamicDepthStencilState(dev, &dsInfo, &m_DynamicDSStateDisabled); + RDCASSERT(vkr == VK_SUCCESS); + + string shaderSources[] = { + GetEmbeddedResource(blitvs_spv), + GetEmbeddedResource(checkerboardfs_spv), + GetEmbeddedResource(texdisplayfs_spv), + }; + + enum shaderIdx + { + BLITVS, + CHECKERBOARDFS, + TEXDISPLAYFS, + }; + + VkShaderModule module[ARRAY_COUNT(shaderSources)]; + VkShader shader[ARRAY_COUNT(shaderSources)]; + + for(size_t i=0; i < ARRAY_COUNT(module); i++) + { + VkShaderModuleCreateInfo modinfo = { + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, NULL, + shaderSources[i].size(), (void *)&shaderSources[i][0], 0, + }; + + vkr = vk.vkCreateShaderModule(dev, &modinfo, &module[i]); + RDCASSERT(vkr == VK_SUCCESS); + + VkShaderCreateInfo shadinfo = { + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO, NULL, + module[i], "main", 0, + }; + + vkr = vk.vkCreateShader(dev, &shadinfo, &shader[i]); + RDCASSERT(vkr == VK_SUCCESS); + } + + VkPipelineShaderStageCreateInfo stages[2] = { + { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, VK_SHADER_STAGE_VERTEX, shader[0], NULL }, + { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, VK_SHADER_STAGE_FRAGMENT, shader[1], NULL }, + }; + + VkPipelineInputAssemblyStateCreateInfo ia = { + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, NULL, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, false, + }; + + VkPipelineViewportStateCreateInfo vp = { + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, NULL, + 1, + }; + + VkPipelineRasterStateCreateInfo rs = { + VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO, NULL, + true, false, VK_FILL_MODE_SOLID, VK_CULL_MODE_NONE, VK_FRONT_FACE_CW, + }; + + VkPipelineMultisampleStateCreateInfo msaa = { + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, NULL, + 1, false, 0.0f, 1, + }; + + VkPipelineDepthStencilStateCreateInfo ds = { + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, NULL, + false, false, VK_COMPARE_OP_ALWAYS, false, false, + { VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS }, + { VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS }, + }; + + VkPipelineColorBlendAttachmentState attState = { + false, + VK_BLEND_ONE, VK_BLEND_ZERO, VK_BLEND_OP_ADD, + VK_BLEND_ONE, VK_BLEND_ZERO, VK_BLEND_OP_ADD, + 0xf, + }; + + VkPipelineColorBlendStateCreateInfo cb = { + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, NULL, + false, false, VK_LOGIC_OP_NOOP, + 1, &attState, + }; + + VkGraphicsPipelineCreateInfo pipeInfo = { + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, NULL, + 2, stages, + NULL, // vertex input + &ia, + NULL, // tess + &vp, + &rs, + &msaa, + &ds, + &cb, + 0, // flags + m_TexDisplayPipeLayout, + VK_NULL_HANDLE, // render pass + 0, // sub pass + VK_NULL_HANDLE, // base pipeline handle + 0, // base pipeline index + }; + + stages[0].shader = shader[BLITVS]; + stages[1].shader = shader[CHECKERBOARDFS]; + + vkr = vk.vkCreateGraphicsPipelines(dev, m_PipelineCache, 1, &pipeInfo, &m_CheckerboardPipeline); + RDCASSERT(vkr == VK_SUCCESS); + + stages[1].shader = shader[TEXDISPLAYFS]; + + vkr = vk.vkCreateGraphicsPipelines(dev, m_PipelineCache, 1, &pipeInfo, &m_TexDisplayPipeline); + RDCASSERT(vkr == VK_SUCCESS); + + for(size_t i=0; i < ARRAY_COUNT(module); i++) + { + vkr = vk.vkDestroyShader(dev, shader[i]); + RDCASSERT(vkr == VK_SUCCESS); + + vkr = vk.vkDestroyShaderModule(dev, module[i]); + RDCASSERT(vkr == VK_SUCCESS); + } +} + void VulkanReplay::Shutdown() { delete m_pDriver; @@ -210,6 +503,8 @@ APIProperties VulkanReplay::GetAPIProperties() void VulkanReplay::ReadLogInitialisation() { m_pDriver->ReadLogInitialisation(); + + InitDebugData(); } void VulkanReplay::ReplayLog(uint32_t frameID, uint32_t startEventID, uint32_t endEventID, ReplayLogType replayType) @@ -545,10 +840,47 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, &barrier); fakeTrans.oldLayout = fakeTrans.newLayout; - outw.curcoltrans->newLayout = VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL; + outw.curcoltrans->newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; vk.vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, (void **)&outw.curcoltrans); outw.curcoltrans->oldLayout = outw.curcoltrans->newLayout; + VkViewport vp = { 0.0f, 0.0f, (float)outw.width, (float)outw.height, 0.0f, 1.0f, }; + VkRect2D sc = { { 0, 0 }, { outw.width, outw.height } }; + + VkDynamicViewportStateCreateInfo vpInfo = { + VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, NULL, + 1, &vp, &sc + }; + + VkDynamicViewportState dynVP; + + // VKTODOMED cache this, or create per output window on resize + VkResult vkr = vk.vkCreateDynamicViewportState(dev, &vpInfo, &dynVP); + RDCASSERT(vkr == VK_SUCCESS); + + { + VkClearValue clearval = {0}; + clearval.color.f32[2] = clearval.color.f32[3] = 1.0f; + VkRenderPassBeginInfo rpbegin = { + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, NULL, + outw.renderpass, outw.fb[ outw.curidx ], + { { 0, 0, }, { outw.width, outw.height } }, + 1, &clearval, + }; + vk.vkCmdBeginRenderPass(cmd, &rpbegin, VK_RENDER_PASS_CONTENTS_INLINE); + + vk.vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_CheckerboardPipeline); + vk.vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, m_TexDisplayPipeLayout, 0, 1, &m_TexDisplayDescSet, 0, NULL); + + vk.vkCmdBindDynamicViewportState(cmd, dynVP); + vk.vkCmdBindDynamicRasterState(cmd, m_DynamicRSState); + vk.vkCmdBindDynamicColorBlendState(cmd, m_DynamicCBStateWhite); + vk.vkCmdBindDynamicDepthStencilState(cmd, m_DynamicDSStateDisabled); + + vk.vkCmdDraw(cmd, 0, 4, 0, 1); + vk.vkCmdEndRenderPass(cmd); + } + VkImageCopy region = { { VK_IMAGE_ASPECT_COLOR, 0, 0}, { 0, 0, 0 }, { VK_IMAGE_ASPECT_COLOR, 0, 0}, { 0, 0, 0 }, @@ -576,6 +908,8 @@ void VulkanReplay::FlipOutputWindow(uint64_t id) } vk.vkDeviceWaitIdle(dev); + + vk.vkDestroyDynamicViewportState(dev, dynVP); } void VulkanReplay::DestroyOutputWindow(uint64_t id) diff --git a/renderdoc/driver/vulkan/vk_replay.h b/renderdoc/driver/vulkan/vk_replay.h index 1881b9b4e..295d3a826 100644 --- a/renderdoc/driver/vulkan/vk_replay.h +++ b/renderdoc/driver/vulkan/vk_replay.h @@ -175,8 +175,10 @@ class VulkanReplay : public IReplayDriver uint32_t numImgs; VkImage colimg[8]; VkAttachmentView colview[8]; + VkFramebuffer fb[8], fbdepth[8]; VkImageMemoryBarrier coltrans[8]; VkImageMemoryBarrier *curcoltrans; + VkRenderPass renderpass; uint32_t curidx; VkImage dsimg; @@ -197,4 +199,30 @@ class VulkanReplay : public IReplayDriver bool m_Proxy; WrappedVulkan *m_pDriver; + + // Debug data + + void InitDebugData(); + + struct UBO + { + VkBuffer buf; + VkDeviceMemory mem; + VkBufferView view; + }; + + VkPipelineCache m_PipelineCache; + VkDynamicColorBlendState m_DynamicCBStateWhite; + VkDynamicRasterState m_DynamicRSState; + VkDynamicDepthStencilState m_DynamicDSStateDisabled; + + VkPipeline m_CheckerboardPipeline; + UBO m_CheckerboardUBO; + + VkPipeline m_TexDisplayPipeline; + VkDescriptorSetLayout m_TexDisplayDescSetLayout; + VkPipelineLayout m_TexDisplayPipeLayout; + VkDescriptorPool m_TexDisplayDescPool; + VkDescriptorSet m_TexDisplayDescSet; + UBO m_TexDisplayUBO; }; diff --git a/renderdoc/renderdoc.vcxproj b/renderdoc/renderdoc.vcxproj index 8f8157e1f..821833cf6 100644 --- a/renderdoc/renderdoc.vcxproj +++ b/renderdoc/renderdoc.vcxproj @@ -357,6 +357,10 @@ + + + + diff --git a/renderdoc/renderdoc.vcxproj.filters b/renderdoc/renderdoc.vcxproj.filters index 04e6f594d..0de869144 100644 --- a/renderdoc/renderdoc.vcxproj.filters +++ b/renderdoc/renderdoc.vcxproj.filters @@ -70,6 +70,9 @@ {3e51a921-b167-4794-937d-e77573a928b8} + + {188ad934-e74f-4805-b74b-167f8760fab6} + @@ -427,6 +430,18 @@ Resources\glsl + + Resources\spv + + + Resources\spv + + + Resources\spv + + + Resources\spv +