diff --git a/renderdoc/api/replay/vk_pipestate.h b/renderdoc/api/replay/vk_pipestate.h index 9fd5da5da..89214fb23 100644 --- a/renderdoc/api/replay/vk_pipestate.h +++ b/renderdoc/api/replay/vk_pipestate.h @@ -134,8 +134,6 @@ struct VulkanPipelineState struct ViewState { - ResourceId state; - struct ViewportScissor { struct Viewport @@ -164,8 +162,7 @@ struct VulkanPipelineState TriangleFillMode FillMode; TriangleCullMode CullMode; - // from dynamic state - ResourceId state; + // dynamic float depthBias, depthBiasClamp, slopeScaledDepthBias, lineWidth; } RS; @@ -206,7 +203,7 @@ struct VulkanPipelineState }; rdctype::array attachments; - ResourceId state; + // dynamic float blendConst[4]; } CB; @@ -214,7 +211,7 @@ struct VulkanPipelineState { DepthStencil() : depthTestEnable(false), depthWriteEnable(false), depthBoundsEnable(false), stencilTestEnable(false) - , minDepthBounds(0), maxDepthBounds(0), stencilReadMask(0), stencilWriteMask(0) {} + , minDepthBounds(0), maxDepthBounds(0) {} bool32 depthTestEnable, depthWriteEnable, depthBoundsEnable; rdctype::str depthCompareOp; @@ -222,17 +219,18 @@ struct VulkanPipelineState bool32 stencilTestEnable; struct StencilOp { - StencilOp() : stencilref(0) {} + StencilOp() : ref(0), compareMask(0xff), writeMask(0xff) {} rdctype::str failOp; rdctype::str depthFailOp; rdctype::str passOp; rdctype::str func; - uint32_t stencilref; + + // dynamic + uint32_t ref, compareMask, writeMask; } front, back; - ResourceId state; + // dynamic float minDepthBounds, maxDepthBounds; - uint32_t stencilReadMask, stencilWriteMask; } DS; struct CurrentPass diff --git a/renderdoc/driver/vulkan/Makefile b/renderdoc/driver/vulkan/Makefile index 1e2c5d5af..45e70c0aa 100644 --- a/renderdoc/driver/vulkan/Makefile +++ b/renderdoc/driver/vulkan/Makefile @@ -21,6 +21,7 @@ vk_replay.o \ vk_info.o \ vk_replay_linux.o \ wrappers/vk_cmd_funcs.o \ +wrappers/vk_dynamic_funcs.o \ wrappers/vk_descriptor_funcs.o \ wrappers/vk_device_funcs.o \ wrappers/vk_draw_funcs.o \ diff --git a/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj b/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj index 88b83152a..1bfd31135 100644 --- a/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj +++ b/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj @@ -35,6 +35,7 @@ + diff --git a/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj.filters b/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj.filters index 1431572dd..1dfabcd8e 100644 --- a/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj.filters +++ b/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj.filters @@ -46,6 +46,9 @@ Wrappers + + Wrappers + Wrappers diff --git a/renderdoc/driver/vulkan/vk_common.cpp b/renderdoc/driver/vulkan/vk_common.cpp index 73bfd6c83..276de29d1 100644 --- a/renderdoc/driver/vulkan/vk_common.cpp +++ b/renderdoc/driver/vulkan/vk_common.cpp @@ -2335,69 +2335,6 @@ void Serialiser::Serialise(const char *name, VkRenderPassBeginInfo &el) SerialisePODArray("pAttachmentClearValues", (VkClearValue *&)el.pAttachmentClearValues, el.attachmentCount); } -template<> -void Serialiser::Serialise(const char *name, VkDynamicViewportStateCreateInfo &el) -{ - ScopedContext scope(this, name, "VkDynamicVpStateCreateInfo", 0, true); - - RDCASSERT(m_Mode < WRITING || el.sType == VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO); - Serialise("sType", el.sType); - SerialiseNext(this, el.pNext); - - if(m_Mode == READING) - { - el.pViewports = NULL; - el.pScissors = NULL; - } - - SerialisePODArray("viewports", (VkViewport *&)el.pViewports, el.viewportAndScissorCount); - SerialisePODArray("scissors", (VkRect2D *&)el.pScissors, el.viewportAndScissorCount); -} - -template<> -void Serialiser::Serialise(const char *name, VkDynamicRasterStateCreateInfo &el) -{ - ScopedContext scope(this, name, "VkDynamicRsStateCreateInfo", 0, true); - - RDCASSERT(m_Mode < WRITING || el.sType == VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO); - Serialise("sType", el.sType); - SerialiseNext(this, el.pNext); - - Serialise("depthBias", el.depthBias); - Serialise("depthBiasClamp", el.depthBiasClamp); - Serialise("slopeScaledDepthBias", el.slopeScaledDepthBias); - Serialise("lineWidth", el.lineWidth); -} - -template<> -void Serialiser::Serialise(const char *name, VkDynamicColorBlendStateCreateInfo &el) -{ - ScopedContext scope(this, name, "VkDynamicCbStateCreateInfo", 0, true); - - RDCASSERT(m_Mode < WRITING || el.sType == VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO); - Serialise("sType", el.sType); - SerialiseNext(this, el.pNext); - - SerialisePODArray<4>("blendConst", el.blendConst); -} - -template<> -void Serialiser::Serialise(const char *name, VkDynamicDepthStencilStateCreateInfo &el) -{ - ScopedContext scope(this, name, "VkDynamicDsStateCreateInfo", 0, true); - - RDCASSERT(m_Mode < WRITING || el.sType == VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO); - Serialise("sType", el.sType); - SerialiseNext(this, el.pNext); - - Serialise("minDepthBounds", el.minDepthBounds); - Serialise("maxDepthBounds", el.maxDepthBounds); - Serialise("stencilReadMask", el.stencilReadMask); - Serialise("stencilWriteMask", el.stencilWriteMask); - Serialise("stencilFrontRef", el.stencilFrontRef); - Serialise("stencilBackRef", el.stencilBackRef); -} - template<> void Serialiser::Serialise(const char *name, VkVertexInputBindingDescription &el) { diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index b5d284a64..f75c6cea5 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -87,10 +87,6 @@ template<> void Serialiser::Serialise(const char *name, VkImageViewCreateInfo &e template<> void Serialiser::Serialise(const char *name, VkFramebufferCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkRenderPassCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkRenderPassBeginInfo &el); -template<> void Serialiser::Serialise(const char *name, VkDynamicViewportStateCreateInfo &el); -template<> void Serialiser::Serialise(const char *name, VkDynamicRasterStateCreateInfo &el); -template<> void Serialiser::Serialise(const char *name, VkDynamicColorBlendStateCreateInfo &el); -template<> void Serialiser::Serialise(const char *name, VkDynamicDepthStencilStateCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkPipelineInputAssemblyStateCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkPipelineTessellationStateCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkPipelineViewportStateCreateInfo &el); @@ -204,10 +200,15 @@ enum VulkanChunkType END_RENDERPASS, BIND_PIPELINE, - BIND_VP_STATE, - BIND_RS_STATE, - BIND_CB_STATE, - BIND_DS_STATE, + SET_VP, + SET_SCISSOR, + SET_LINE_WIDTH, + SET_DEPTH_BIAS, + SET_BLEND_CONST, + SET_DEPTH_BOUNDS, + SET_STENCIL_COMP_MASK, + SET_STENCIL_WRITE_MASK, + SET_STENCIL_REF, BIND_DESCRIPTOR_SET, BIND_VERTEX_BUFFERS, BIND_INDEX_BUFFER, diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index a9622a907..01266ee57 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -66,10 +66,6 @@ const char *VkChunkNames[] = "vkCreateImage", "vkCreateImageView", "vkCreateDepthTargetView", - "vkCreateDynamicViewportState", - "vkCreateDynamicRasterState", - "vkCreateDynamicBlendState", - "vkCreateDynamicDepthStencilState", "vkCreateSampler", "vkCreateShader", "vkCreateShaderModule", @@ -106,10 +102,17 @@ const char *VkChunkNames[] = "vkCmdEndRenderPass", "vkCmdBindPipeline", - "vkCmdBindDynamicViewportState", - "vkCmdBindDynamicRasterState", - "vkCmdBindDynamicColorBlendState", - "vkCmdBindDynamicDepthStencilState", + + "vkCmdSetViewport", + "vkCmdSetScissor", + "vkCmdSetLineWidth", + "vkCmdSetDepthBias", + "vkCmdSetBlendConstants", + "vkCmdSetDepthBounds", + "vkCmdSetStencilCompareMask", + "vkCmdSetStencilWriteMask", + "vkCmdSetStencilReference", + "vkCmdBindDescriptorSet", "vkCmdBindVertexBuffers", "vkCmdBindIndexBuffer", @@ -382,8 +385,6 @@ WrappedVulkan::~WrappedVulkan() //if(it->second.rp != VK_NULL_HANDLE) //ObjDisp(GetDev())->DestroyRenderPass(Unwrap(GetDev()), it->second.rp); - //if(it->second.vp != VK_NULL_HANDLE) - //ObjDisp(GetDev())->DestroyDynamicViewportState(Unwrap(GetDev()), it->second.vp); } m_SwapChainInfo.clear(); @@ -962,18 +963,6 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context) case CREATE_IMAGE_VIEW: Serialise_vkCreateImageView(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; - case CREATE_VIEWPORT_STATE: - Serialise_vkCreateDynamicViewportState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); - break; - case CREATE_RASTER_STATE: - Serialise_vkCreateDynamicRasterState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); - break; - case CREATE_BLEND_STATE: - Serialise_vkCreateDynamicColorBlendState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); - break; - case CREATE_DEPTH_STATE: - Serialise_vkCreateDynamicDepthStencilState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); - break; case CREATE_SAMPLER: Serialise_vkCreateSampler(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; @@ -1068,17 +1057,32 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context) case BIND_PIPELINE: Serialise_vkCmdBindPipeline(GetMainSerialiser(), VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE); break; - case BIND_VP_STATE: - Serialise_vkCmdBindDynamicViewportState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); + case SET_VP: + Serialise_vkCmdSetViewport(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL); break; - case BIND_RS_STATE: - Serialise_vkCmdBindDynamicRasterState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); + case SET_SCISSOR: + Serialise_vkCmdSetScissor(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL); break; - case BIND_CB_STATE: - Serialise_vkCmdBindDynamicColorBlendState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); + case SET_LINE_WIDTH: + Serialise_vkCmdSetLineWidth(GetMainSerialiser(), 0); break; - case BIND_DS_STATE: - Serialise_vkCmdBindDynamicDepthStencilState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); + case SET_DEPTH_BIAS: + Serialise_vkCmdSetDepthBias(GetMainSerialiser(), 0.0f, 0.0f, 0.0f); + break; + case SET_BLEND_CONST: + Serialise_vkCmdSetLineWidth(GetMainSerialiser(), NULL); + break; + case SET_DEPTH_BOUNDS: + Serialise_vkCmdSetDepthBounds(GetMainSerialiser(), 0.0f, 0.0f); + break; + case SET_STENCIL_COMP_MASK: + Serialise_vkCmdSetStencilCompareMask(GetMainSerialiser(), VK_STENCIL_FACE_NONE, 0); + break; + case SET_STENCIL_WRITE_MASK: + Serialise_vkCmdSetStencilWriteMask(GetMainSerialiser(), VK_STENCIL_FACE_NONE, 0); + break; + case SET_STENCIL_REF: + Serialise_vkCmdSetStencilReference(GetMainSerialiser(), VK_STENCIL_FACE_NONE, 0); break; case BIND_DESCRIPTOR_SET: Serialise_vkCmdBindDescriptorSets(GetMainSerialiser(), VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE, 0, 0, NULL, 0, NULL); diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 2b8ebf9ad..e04f067f2 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -291,8 +291,7 @@ private: { StateVector() { - compute.pipeline = graphics.pipeline = renderPass = framebuffer = - dynamicVP = dynamicRS = dynamicCB = dynamicDS = ResourceId(); + compute.pipeline = graphics.pipeline = renderPass = framebuffer = ResourceId(); compute.descSets.clear(); graphics.descSets.clear(); @@ -302,10 +301,14 @@ private: vbuffers.clear(); } - ResourceId dynamicVP; - ResourceId dynamicRS; - ResourceId dynamicCB; - ResourceId dynamicDS; + // dynamic state + vector views; + vector scissors; + float lineWidth; + struct { float depth, biasclamp, slope; } bias; + float blendConst[4]; + float mindepth, maxdepth; + struct { uint32_t compare, write, ref; } front, back; ResourceId renderPass; ResourceId framebuffer; @@ -344,7 +347,6 @@ private: int arraySize; VkRenderPass rp; - VkDynamicViewportState vp; struct SwapImage { @@ -840,44 +842,6 @@ public: uint32_t count, const VkDescriptorSet* pDescriptorSets); - // State object functions - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicViewportState, - VkDevice device, - const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicViewportState, - VkDevice device, - VkDynamicViewportState state); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicRasterState, - VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicRasterState, - VkDevice device, - VkDynamicRasterState state); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicColorBlendState, - VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicColorBlendState, - VkDevice device, - VkDynamicColorBlendState state); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicDepthStencilState, - VkDevice device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState); - - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicDepthStencilState, - VkDevice device, - VkDynamicDepthStencilState state); - // Command pool functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateCommandPool, @@ -923,21 +887,49 @@ public: VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicViewportState, + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetViewport, VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState); + uint32_t viewportCount, + const VkViewport* pViewports); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicRasterState, + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetScissor, VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState); + uint32_t scissorCount, + const VkRect2D* pScissors); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicColorBlendState, + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetLineWidth, VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState); + float lineWidth); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicDepthStencilState, + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetDepthBias, VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState); + float depthBias, + float depthBiasClamp, + float slopeScaledDepthBias); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetBlendConstants, + VkCmdBuffer cmdBuffer, + const float blendConst[4]); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetDepthBounds, + VkCmdBuffer cmdBuffer, + float minDepthBounds, + float maxDepthBounds); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetStencilCompareMask, + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilCompareMask); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetStencilWriteMask, + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilWriteMask); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetStencilReference, + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilReference); IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets, VkCmdBuffer cmdBuffer, diff --git a/renderdoc/driver/vulkan/vk_debug.cpp b/renderdoc/driver/vulkan/vk_debug.cpp index aa0caaab5..4ec0cd7fa 100644 --- a/renderdoc/driver/vulkan/vk_debug.cpp +++ b/renderdoc/driver/vulkan/vk_debug.cpp @@ -177,9 +177,6 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) // VKTODOLOW needs tidy up - isn't scalable. Needs more classes like UBO above. m_DescriptorPool = VK_NULL_HANDLE; - m_DynamicCBStateWhite = VK_NULL_HANDLE; - m_DynamicRSState = VK_NULL_HANDLE; - m_DynamicDSStateDisabled = VK_NULL_HANDLE; m_LinearSampler = VK_NULL_HANDLE; m_PointSampler = VK_NULL_HANDLE; @@ -413,36 +410,6 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) m_TextStringUBO.Create(driver, dev, 4096); RDCCOMPILE_ASSERT(sizeof(stringdata) <= 4096, "font uniforms size"); - - VkDynamicRasterStateCreateInfo rsInfo = { - VK_STRUCTURE_TYPE_DYNAMIC_RASTER_STATE_CREATE_INFO, NULL, - 0.0f, 0.0f, 0.0f, 1.0f, - }; - - vkr = vt->CreateDynamicRasterState(Unwrap(dev), &rsInfo, &m_DynamicRSState); - RDCASSERT(vkr == VK_SUCCESS); - - VKMGR()->WrapResource(Unwrap(dev), m_DynamicRSState); - - VkDynamicColorBlendStateCreateInfo cbInfo = { - VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO, NULL, - { 1.0f, 1.0f, 1.0f, 1.0f }, - }; - - vkr = vt->CreateDynamicColorBlendState(Unwrap(dev), &cbInfo, &m_DynamicCBStateWhite); - RDCASSERT(vkr == VK_SUCCESS); - - VKMGR()->WrapResource(Unwrap(dev), m_DynamicCBStateWhite); - - VkDynamicDepthStencilStateCreateInfo dsInfo = { - VK_STRUCTURE_TYPE_DYNAMIC_DEPTH_STENCIL_STATE_CREATE_INFO, NULL, - 0.0f, 1.0f, 0xff, 0xff, 0, 0, - }; - - vkr = vt->CreateDynamicDepthStencilState(Unwrap(dev), &dsInfo, &m_DynamicDSStateDisabled); - RDCASSERT(vkr == VK_SUCCESS); - - VKMGR()->WrapResource(Unwrap(dev), m_DynamicDSStateDisabled); string shaderSources[] = { GetEmbeddedResource(blitvs_spv), @@ -501,14 +468,18 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, false, }; + VkRect2D scissor = { { 0, 0 }, { 4096, 4096 } }; + VkPipelineViewportStateCreateInfo vp = { VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, NULL, - 1, + 1, NULL, + 1, &scissor }; 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, + false, 0.0f, 0.0f, 0.0f, 1.0f, }; VkPipelineMultisampleStateCreateInfo msaa = { @@ -519,8 +490,9 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) 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 }, + { VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS, 0, 0, 0 }, + { VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS, 0, 0, 0 }, + 0.0f, 1.0f, }; VkPipelineColorBlendAttachmentState attState = { @@ -534,6 +506,14 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, NULL, false, false, VK_LOGIC_OP_NOOP, 1, &attState, + { 1.0f, 1.0f, 1.0f, 1.0f } + }; + + VkDynamicState dynstates[] = { VK_DYNAMIC_STATE_VIEWPORT }; + + VkPipelineDynamicStateCreateInfo dyn = { + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, NULL, + ARRAY_COUNT(dynstates), dynstates, }; VkGraphicsPipelineCreateInfo pipeInfo = { @@ -547,6 +527,7 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) &msaa, &ds, &cb, + &dyn, 0, // flags Unwrap(m_CheckerboardPipeLayout), VK_NULL_HANDLE, // render pass @@ -856,27 +837,6 @@ VulkanDebugManager::~VulkanDebugManager() VKMGR()->ReleaseWrappedResource(m_DescriptorPool); } - if(m_DynamicCBStateWhite != VK_NULL_HANDLE) - { - vkr = vt->DestroyDynamicColorBlendState(Unwrap(dev), Unwrap(m_DynamicCBStateWhite)); - RDCASSERT(vkr == VK_SUCCESS); - VKMGR()->ReleaseWrappedResource(m_DynamicCBStateWhite); - } - - if(m_DynamicRSState != VK_NULL_HANDLE) - { - vkr = vt->DestroyDynamicRasterState(Unwrap(dev), Unwrap(m_DynamicRSState)); - RDCASSERT(vkr == VK_SUCCESS); - VKMGR()->ReleaseWrappedResource(m_DynamicRSState); - } - - if(m_DynamicDSStateDisabled != VK_NULL_HANDLE) - { - vkr = vt->DestroyDynamicDepthStencilState(Unwrap(dev), Unwrap(m_DynamicDSStateDisabled)); - RDCASSERT(vkr == VK_SUCCESS); - VKMGR()->ReleaseWrappedResource(m_DynamicDSStateDisabled); - } - if(m_LinearSampler != VK_NULL_HANDLE) { vkr = vt->DestroySampler(Unwrap(dev), Unwrap(m_LinearSampler)); @@ -1080,10 +1040,8 @@ void VulkanDebugManager::RenderTextInternal(const TextPrintState &textstate, flo vt->CmdBindPipeline(Unwrap(textstate.cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(m_TextPipeline)); vt->CmdBindDescriptorSets(Unwrap(textstate.cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(m_TextPipeLayout), 0, 1, UnwrapPtr(m_TextDescSet), 0, NULL); - vt->CmdBindDynamicViewportState(Unwrap(textstate.cmd), Unwrap(textstate.vp)); - vt->CmdBindDynamicRasterState(Unwrap(textstate.cmd), Unwrap(m_DynamicRSState)); - vt->CmdBindDynamicColorBlendState(Unwrap(textstate.cmd), Unwrap(m_DynamicCBStateWhite)); - vt->CmdBindDynamicDepthStencilState(Unwrap(textstate.cmd), Unwrap(m_DynamicDSStateDisabled)); + VkViewport viewport = { 0.0f, 0.0f, (float)textstate.w, (float)textstate.h, 0.0f, 1.0f }; + vt->CmdSetViewport(Unwrap(cmd), 1, &viewport); // VKTODOMED strip + instance ID doesn't seem to work atm? instance ID comes through 0 // for now, do lists, but want to change back diff --git a/renderdoc/driver/vulkan/vk_debug.h b/renderdoc/driver/vulkan/vk_debug.h index 8121b8b91..4ab2ae1b6 100644 --- a/renderdoc/driver/vulkan/vk_debug.h +++ b/renderdoc/driver/vulkan/vk_debug.h @@ -36,7 +36,6 @@ struct TextPrintState VkCmdBuffer cmd; VkRenderPass rp; VkFramebuffer fb; - VkDynamicViewportState vp; int32_t w, h; }; @@ -64,9 +63,6 @@ class VulkanDebugManager // VKTODOLOW make this all private/wrapped up VkDescriptorPool m_DescriptorPool; - VkDynamicColorBlendState m_DynamicCBStateWhite; - VkDynamicRasterState m_DynamicRSState; - VkDynamicDepthStencilState m_DynamicDSStateDisabled; VkSampler m_LinearSampler, m_PointSampler; VkDescriptorSetLayout m_CheckerboardDescSetLayout; diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index 5130041ff..efcaf4bf2 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -94,14 +94,6 @@ HookInit(AllocDescriptorSets); \ HookInit(UpdateDescriptorSets); \ HookInit(FreeDescriptorSets); \ - HookInit(CreateDynamicViewportState); \ - HookInit(DestroyDynamicViewportState); \ - HookInit(CreateDynamicRasterState); \ - HookInit(DestroyDynamicRasterState); \ - HookInit(CreateDynamicColorBlendState); \ - HookInit(DestroyDynamicColorBlendState); \ - HookInit(CreateDynamicDepthStencilState); \ - HookInit(DestroyDynamicDepthStencilState); \ HookInit(CreateCommandPool); \ HookInit(DestroyCommandPool); \ HookInit(ResetCommandPool); \ @@ -111,10 +103,15 @@ HookInit(EndCommandBuffer); \ HookInit(ResetCommandBuffer); \ HookInit(CmdBindPipeline); \ - HookInit(CmdBindDynamicViewportState); \ - HookInit(CmdBindDynamicRasterState); \ - HookInit(CmdBindDynamicColorBlendState); \ - HookInit(CmdBindDynamicDepthStencilState); \ + HookInit(CmdSetViewport); \ + HookInit(CmdSetScissor); \ + HookInit(CmdSetLineWidth); \ + HookInit(CmdSetDepthBias); \ + HookInit(CmdSetBlendConstants); \ + HookInit(CmdSetDepthBounds); \ + HookInit(CmdSetStencilCompareMask); \ + HookInit(CmdSetStencilWriteMask); \ + HookInit(CmdSetStencilReference); \ HookInit(CmdBindDescriptorSets); \ HookInit(CmdBindVertexBuffers); \ HookInit(CmdBindIndexBuffer); \ @@ -219,14 +216,6 @@ HookDefine7(VkResult, vkAllocDescriptorSets, VkDevice, device, VkDescriptorPool, descriptorPool, VkDescriptorSetUsage, setUsage, uint32_t, count, const VkDescriptorSetLayout*, pSetLayouts, VkDescriptorSet*, pDescriptorSets, uint32_t*, pCount); \ HookDefine5(VkResult, vkUpdateDescriptorSets, VkDevice, device, uint32_t, writeCount, const VkWriteDescriptorSet*, pDescriptorWrites, uint32_t, copyCount, const VkCopyDescriptorSet*, pDescriptorCopies); \ HookDefine4(VkResult, vkFreeDescriptorSets, VkDevice, device, VkDescriptorPool, descriptorPool, uint32_t, count, const VkDescriptorSet*, pDescriptorSets); \ - HookDefine3(VkResult, vkCreateDynamicViewportState, VkDevice, device, const VkDynamicViewportStateCreateInfo*, pCreateInfo, VkDynamicViewportState*, pState); \ - HookDefine2(VkResult, vkDestroyDynamicViewportState, VkDevice, device, VkDynamicViewportState, state); \ - HookDefine3(VkResult, vkCreateDynamicRasterState, VkDevice, device, const VkDynamicRasterStateCreateInfo*, pCreateInfo, VkDynamicRasterState*, pState); \ - HookDefine2(VkResult, vkDestroyDynamicRasterState, VkDevice, device, VkDynamicRasterState, state); \ - HookDefine3(VkResult, vkCreateDynamicColorBlendState, VkDevice, device, const VkDynamicColorBlendStateCreateInfo*, pCreateInfo, VkDynamicColorBlendState*, pState); \ - HookDefine2(VkResult, vkDestroyDynamicColorBlendState, VkDevice, device, VkDynamicColorBlendState, state); \ - HookDefine3(VkResult, vkCreateDynamicDepthStencilState, VkDevice, device, const VkDynamicDepthStencilStateCreateInfo*, pCreateInfo, VkDynamicDepthStencilState*, pState); \ - HookDefine2(VkResult, vkDestroyDynamicDepthStencilState, VkDevice, device, VkDynamicDepthStencilState, state); \ HookDefine3(VkResult, vkCreateCommandPool, VkDevice, device, const VkCmdPoolCreateInfo*, pCreateInfo, VkCmdPool*, pCmdPool); \ HookDefine2(VkResult, vkDestroyCommandPool, VkDevice, device, VkCmdPool, cmdPool); \ HookDefine3(VkResult, vkResetCommandPool, VkDevice, device, VkCmdPool, cmdPool, VkCmdPoolResetFlags, flags); \ @@ -236,10 +225,15 @@ HookDefine1(VkResult, vkEndCommandBuffer, VkCmdBuffer, cmdBuffer); \ HookDefine2(VkResult, vkResetCommandBuffer, VkCmdBuffer, cmdBuffer, VkCmdBufferResetFlags, flags); \ HookDefine3(void, vkCmdBindPipeline, VkCmdBuffer, cmdBuffer, VkPipelineBindPoint, pipelineBindPoint, VkPipeline, pipeline); \ - HookDefine2(void, vkCmdBindDynamicViewportState, VkCmdBuffer, cmdBuffer, VkDynamicViewportState, dynamicViewportState); \ - HookDefine2(void, vkCmdBindDynamicRasterState, VkCmdBuffer, cmdBuffer, VkDynamicRasterState, dynamicRasterState); \ - HookDefine2(void, vkCmdBindDynamicColorBlendState, VkCmdBuffer, cmdBuffer, VkDynamicColorBlendState, dynamicColorBlendState); \ - HookDefine2(void, vkCmdBindDynamicDepthStencilState, VkCmdBuffer, cmdBuffer, VkDynamicDepthStencilState, dynamicDepthStencilState); \ + HookDefine3(void, vkCmdSetViewport, VkCmdBuffer, cmdBuffer, uint32_t, viewportCount, const VkViewport* pViewports); \ + HookDefine3(void, vkCmdSetScissor, VkCmdBuffer, cmdBuffer, uint32_t, scissorCount, const VkRect2D*, pScissors); \ + HookDefine2(void, vkCmdSetLineWidth, VkCmdBuffer, cmdBuffer, float, lineWidth); \ + HookDefine4(void, vkCmdSetDepthBias, VkCmdBuffer, cmdBuffer, float, depthBias, float, depthBiasClamp, float, slopeScaledDepthBias); \ + HookDefine2(void, vkCmdSetBlendConstants, VkCmdBuffer, cmdBuffer, const float*, blendConst); \ + HookDefine3(void, vkCmdSetDepthBounds, VkCmdBuffer, cmdBuffer, float, minDepthBounds, float, maxDepthBounds); \ + HookDefine3(void, vkCmdSetStencilCompareMask, VkCmdBuffer, cmdBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilCompareMask); \ + HookDefine3(void, vkCmdSetStencilWriteMask, VkCmdBuffer, cmdBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilWriteMask); \ + HookDefine3(void, vkCmdSetStencilReference, VkCmdBuffer, cmdBuffer, VkStencilFaceFlags, faceMask, uint32_t, stencilReference); \ HookDefine8(void, vkCmdBindDescriptorSets, VkCmdBuffer, cmdBuffer, VkPipelineBindPoint, pipelineBindPoint, VkPipelineLayout, layout, uint32_t, firstSet, uint32_t, setCount, const VkDescriptorSet*, pDescriptorSets, uint32_t, dynamicOffsetCount, const uint32_t*, pDynamicOffsets); \ HookDefine4(void, vkCmdBindIndexBuffer, VkCmdBuffer, cmdBuffer, VkBuffer, buffer, VkDeviceSize, offset, VkIndexType, indexType); \ HookDefine5(void, vkCmdBindVertexBuffers, VkCmdBuffer, cmdBuffer, uint32_t, startBinding, uint32_t, bindingCount, const VkBuffer*, pBuffers, const VkDeviceSize*, pOffsets); \ diff --git a/renderdoc/driver/vulkan/vk_info.cpp b/renderdoc/driver/vulkan/vk_info.cpp index 4ae1bc959..80441756d 100644 --- a/renderdoc/driver/vulkan/vk_info.cpp +++ b/renderdoc/driver/vulkan/vk_info.cpp @@ -110,42 +110,6 @@ void VulkanCreationInfo::Pipeline::Init(const VkGraphicsPipelineCreateInfo* pCre } } -void VulkanCreationInfo::ViewportScissor::Init(const VkDynamicViewportStateCreateInfo* pCreateInfo) -{ - viewports.resize(pCreateInfo->viewportAndScissorCount); - scissors.resize(pCreateInfo->viewportAndScissorCount); - - for(uint32_t i=0; i < pCreateInfo->viewportAndScissorCount; i++) - { - viewports[i] = pCreateInfo->pViewports[i]; - scissors[i] = pCreateInfo->pScissors[i]; - } -} - -void VulkanCreationInfo::Raster::Init(const VkDynamicRasterStateCreateInfo* pCreateInfo) -{ - depthBias = pCreateInfo->depthBias; - depthBiasClamp = pCreateInfo->depthBiasClamp; - slopeScaledDepthBias = pCreateInfo->slopeScaledDepthBias; - lineWidth = pCreateInfo->lineWidth; -} - -void VulkanCreationInfo::Blend::Init(const VkDynamicColorBlendStateCreateInfo* pCreateInfo) -{ - RDCCOMPILE_ASSERT(sizeof(blendConst) == sizeof(pCreateInfo->blendConst), "blend constant size mismatch!"); - memcpy(blendConst, pCreateInfo->blendConst, sizeof(blendConst)); -} - -void VulkanCreationInfo::DepthStencil::Init(const VkDynamicDepthStencilStateCreateInfo* pCreateInfo) -{ - minDepthBounds = pCreateInfo->minDepthBounds; - maxDepthBounds = pCreateInfo->maxDepthBounds; - stencilReadMask = pCreateInfo->stencilReadMask; - stencilWriteMask = pCreateInfo->stencilWriteMask; - stencilFrontRef = pCreateInfo->stencilFrontRef; - stencilBackRef = pCreateInfo->stencilBackRef; -} - void VulkanCreationInfo::RenderPass::Init(const VkRenderPassCreateInfo* pCreateInfo) { // VKTODOMED figure out how subpasses work diff --git a/renderdoc/driver/vulkan/vk_info.h b/renderdoc/driver/vulkan/vk_info.h index 9826fa767..181c41686 100644 --- a/renderdoc/driver/vulkan/vk_info.h +++ b/renderdoc/driver/vulkan/vk_info.h @@ -111,47 +111,6 @@ struct VulkanCreationInfo }; map m_Pipeline; - struct ViewportScissor - { - void Init(const VkDynamicViewportStateCreateInfo* pCreateInfo); - - vector viewports; - vector scissors; - }; - map m_VPScissor; - - struct Raster - { - void Init(const VkDynamicRasterStateCreateInfo* pCreateInfo); - - float depthBias; - float depthBiasClamp; - float slopeScaledDepthBias; - float lineWidth; - }; - map m_Raster; - - struct Blend - { - void Init(const VkDynamicColorBlendStateCreateInfo* pCreateInfo); - - float blendConst[4]; - }; - map m_Blend; - - struct DepthStencil - { - void Init(const VkDynamicDepthStencilStateCreateInfo* pCreateInfo); - - float minDepthBounds; - float maxDepthBounds; - uint32_t stencilReadMask; - uint32_t stencilWriteMask; - uint32_t stencilFrontRef; - uint32_t stencilBackRef; - }; - map m_DepthStencil; - struct RenderPass { void Init(const VkRenderPassCreateInfo* pCreateInfo); diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index d185b9b99..46ebab0b5 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -112,9 +112,6 @@ void VulkanReplay::OutputWindow::Destroy(WrappedVulkan *driver, VkDevice device) { vt->DestroyRenderPass(Unwrap(device), Unwrap(renderpass)); renderpass = VK_NULL_HANDLE; - - vt->DestroyDynamicViewportState(Unwrap(device), Unwrap(fullVP)); - fullVP = VK_NULL_HANDLE; vt->DestroyImage(Unwrap(device), Unwrap(bb)); vt->DestroyImageView(Unwrap(device), Unwrap(bbview)); @@ -318,21 +315,6 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device, VKMGR()->WrapResource(Unwrap(device), renderpass); } - { - VkViewport vp = { 0.0f, 0.0f, (float)width, (float)height, 0.0f, 1.0f, }; - VkRect2D sc = { { 0, 0 }, { width, height } }; - - VkDynamicViewportStateCreateInfo vpInfo = { - VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, NULL, - 1, &vp, &sc - }; - - VkResult vkr = vt->CreateDynamicViewportState(Unwrap(device), &vpInfo, &fullVP); - RDCASSERT(vkr == VK_SUCCESS); - - VKMGR()->WrapResource(Unwrap(device), fullVP); - } - { VkImageCreateInfo imInfo = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, NULL, @@ -812,10 +794,8 @@ bool VulkanReplay::RenderTexture(TextureDisplay cfg) vt->CmdBindPipeline(Unwrap(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, cfg.rawoutput ? Unwrap(GetDebugManager()->m_TexDisplayPipeline) : Unwrap(GetDebugManager()->m_TexDisplayBlendPipeline)); vt->CmdBindDescriptorSets(Unwrap(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(GetDebugManager()->m_TexDisplayPipeLayout), 0, 1, UnwrapPtr(GetDebugManager()->m_TexDisplayDescSet), 0, NULL); - vt->CmdBindDynamicViewportState(Unwrap(cmd), Unwrap(outw.fullVP)); - vt->CmdBindDynamicRasterState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicRSState)); - vt->CmdBindDynamicColorBlendState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicCBStateWhite)); - vt->CmdBindDynamicDepthStencilState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicDSStateDisabled)); + VkViewport viewport = { 0.0f, 0.0f, (float)outw.width, (float)outw.height, 0.0f, 1.0f }; + vt->CmdSetViewport(Unwrap(cmd), 1, &viewport); vt->CmdDraw(Unwrap(cmd), 0, 4, 0, 1); vt->CmdEndRenderPass(Unwrap(cmd)); @@ -884,10 +864,8 @@ void VulkanReplay::RenderCheckerboard(Vec3f light, Vec3f dark) vt->CmdBindPipeline(Unwrap(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(GetDebugManager()->m_CheckerboardPipeline)); vt->CmdBindDescriptorSets(Unwrap(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(GetDebugManager()->m_CheckerboardPipeLayout), 0, 1, UnwrapPtr(GetDebugManager()->m_CheckerboardDescSet), 0, NULL); - vt->CmdBindDynamicViewportState(Unwrap(cmd), Unwrap(outw.fullVP)); - vt->CmdBindDynamicRasterState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicRSState)); - vt->CmdBindDynamicColorBlendState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicCBStateWhite)); - vt->CmdBindDynamicDepthStencilState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicDSStateDisabled)); + VkViewport viewport = { 0.0f, 0.0f, (float)outw.width, (float)outw.height, 0.0f, 1.0f }; + vt->CmdSetViewport(Unwrap(cmd), 1, &viewport); vt->CmdDraw(Unwrap(cmd), 0, 4, 0, 1); vt->CmdEndRenderPass(Unwrap(cmd)); @@ -952,10 +930,8 @@ void VulkanReplay::RenderHighlightBox(float w, float h, float scale) vt->CmdBindPipeline(Unwrap(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(GetDebugManager()->m_GenericPipeline)); vt->CmdBindDescriptorSets(Unwrap(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, Unwrap(GetDebugManager()->m_GenericPipeLayout), 0, 1, UnwrapPtr(GetDebugManager()->m_GenericDescSet), 0, NULL); - vt->CmdBindDynamicViewportState(Unwrap(cmd), Unwrap(outw.fullVP)); - vt->CmdBindDynamicRasterState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicRSState)); - vt->CmdBindDynamicColorBlendState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicCBStateWhite)); - vt->CmdBindDynamicDepthStencilState(Unwrap(cmd), Unwrap(GetDebugManager()->m_DynamicDSStateDisabled)); + VkViewport viewport = { 0.0f, 0.0f, (float)outw.width, (float)outw.height, 0.0f, 1.0f }; + vt->CmdSetViewport(Unwrap(cmd), 1, &viewport); VkDeviceSize zero = 0; vt->CmdBindVertexBuffers(Unwrap(cmd), 0, 1, UnwrapPtr(GetDebugManager()->m_OutlineStripVBO.buf), &zero); @@ -1579,21 +1555,20 @@ void VulkanReplay::SavePipelineState() m_VulkanPipelineState.Tess.numControlPoints = p.patchControlPoints; // Viewport/Scissors - m_VulkanPipelineState.VP.state = state.dynamicVP; - create_array_uninit(m_VulkanPipelineState.VP.viewportScissors, c.m_VPScissor[state.dynamicVP].viewports.size()); - for(size_t i=0; i < c.m_VPScissor[state.dynamicVP].viewports.size(); i++) + create_array_uninit(m_VulkanPipelineState.VP.viewportScissors, RDCMIN(state.views.size(), state.scissors.size())); + for(size_t i=0; i < state.views.size(); i++) { - m_VulkanPipelineState.VP.viewportScissors[i].vp.x = c.m_VPScissor[state.dynamicVP].viewports[i].originX; - m_VulkanPipelineState.VP.viewportScissors[i].vp.y = c.m_VPScissor[state.dynamicVP].viewports[i].originY; - m_VulkanPipelineState.VP.viewportScissors[i].vp.width = c.m_VPScissor[state.dynamicVP].viewports[i].width; - m_VulkanPipelineState.VP.viewportScissors[i].vp.height = c.m_VPScissor[state.dynamicVP].viewports[i].height; - m_VulkanPipelineState.VP.viewportScissors[i].vp.minDepth = c.m_VPScissor[state.dynamicVP].viewports[i].minDepth; - m_VulkanPipelineState.VP.viewportScissors[i].vp.maxDepth = c.m_VPScissor[state.dynamicVP].viewports[i].maxDepth; + m_VulkanPipelineState.VP.viewportScissors[i].vp.x = state.views[i].originX; + m_VulkanPipelineState.VP.viewportScissors[i].vp.y = state.views[i].originY; + m_VulkanPipelineState.VP.viewportScissors[i].vp.width = state.views[i].width; + m_VulkanPipelineState.VP.viewportScissors[i].vp.height = state.views[i].height; + m_VulkanPipelineState.VP.viewportScissors[i].vp.minDepth = state.views[i].minDepth; + m_VulkanPipelineState.VP.viewportScissors[i].vp.maxDepth = state.views[i].maxDepth; - m_VulkanPipelineState.VP.viewportScissors[i].scissor.x = c.m_VPScissor[state.dynamicVP].scissors[i].offset.x; - m_VulkanPipelineState.VP.viewportScissors[i].scissor.y = c.m_VPScissor[state.dynamicVP].scissors[i].offset.y; - m_VulkanPipelineState.VP.viewportScissors[i].scissor.width = c.m_VPScissor[state.dynamicVP].scissors[i].extent.width; - m_VulkanPipelineState.VP.viewportScissors[i].scissor.height = c.m_VPScissor[state.dynamicVP].scissors[i].extent.height; + m_VulkanPipelineState.VP.viewportScissors[i].scissor.x = state.scissors[i].offset.x; + m_VulkanPipelineState.VP.viewportScissors[i].scissor.y = state.scissors[i].offset.y; + m_VulkanPipelineState.VP.viewportScissors[i].scissor.width = state.scissors[i].extent.width; + m_VulkanPipelineState.VP.viewportScissors[i].scissor.height = state.scissors[i].extent.height; } // Rasterizer @@ -1624,11 +1599,10 @@ void VulkanReplay::SavePipelineState() break; } - m_VulkanPipelineState.RS.state = state.dynamicRS; - m_VulkanPipelineState.RS.depthBias = c.m_Raster[state.dynamicRS].depthBias; - m_VulkanPipelineState.RS.depthBiasClamp = c.m_Raster[state.dynamicRS].depthBiasClamp; - m_VulkanPipelineState.RS.slopeScaledDepthBias = c.m_Raster[state.dynamicRS].slopeScaledDepthBias; - m_VulkanPipelineState.RS.lineWidth = c.m_Raster[state.dynamicRS].lineWidth; + m_VulkanPipelineState.RS.depthBias = state.bias.depth; + m_VulkanPipelineState.RS.depthBiasClamp = state.bias.biasclamp; + m_VulkanPipelineState.RS.slopeScaledDepthBias = state.bias.slope; + m_VulkanPipelineState.RS.lineWidth = state.lineWidth; // MSAA m_VulkanPipelineState.MSAA.rasterSamples = p.rasterSamples; @@ -1657,8 +1631,7 @@ void VulkanReplay::SavePipelineState() m_VulkanPipelineState.CB.attachments[i].writeMask = p.attachments[i].channelWriteMask; } - m_VulkanPipelineState.CB.state = state.dynamicCB; - memcpy(m_VulkanPipelineState.CB.blendConst, c.m_Blend[state.dynamicCB].blendConst, sizeof(float)*4); + memcpy(m_VulkanPipelineState.CB.blendConst, state.blendConst, sizeof(float)*4); // Depth Stencil m_VulkanPipelineState.DS.depthTestEnable = p.depthTestEnable; @@ -1677,15 +1650,16 @@ void VulkanReplay::SavePipelineState() m_VulkanPipelineState.DS.back.depthFailOp = ToStr::Get(p.back.stencilDepthFailOp); m_VulkanPipelineState.DS.back.func = ToStr::Get(p.back.stencilCompareOp); - m_VulkanPipelineState.DS.state = state.dynamicDS; - m_VulkanPipelineState.DS.minDepthBounds = c.m_DepthStencil[state.dynamicDS].minDepthBounds; - m_VulkanPipelineState.DS.maxDepthBounds = c.m_DepthStencil[state.dynamicDS].maxDepthBounds; + m_VulkanPipelineState.DS.minDepthBounds = state.mindepth; + m_VulkanPipelineState.DS.maxDepthBounds = state.maxdepth; - m_VulkanPipelineState.DS.front.stencilref = c.m_DepthStencil[state.dynamicDS].stencilFrontRef; - m_VulkanPipelineState.DS.back.stencilref = c.m_DepthStencil[state.dynamicDS].stencilBackRef; + m_VulkanPipelineState.DS.front.ref = state.front.ref; + m_VulkanPipelineState.DS.front.compareMask = state.compareMask; + m_VulkanPipelineState.DS.front.writeMask = state.writeMask; - m_VulkanPipelineState.DS.stencilReadMask = c.m_DepthStencil[state.dynamicDS].stencilReadMask; - m_VulkanPipelineState.DS.stencilWriteMask = c.m_DepthStencil[state.dynamicDS].stencilWriteMask; + m_VulkanPipelineState.DS.back.ref = state.back.ref; + m_VulkanPipelineState.DS.back.compareMask = state.compareMask; + m_VulkanPipelineState.DS.back.writeMask = state.writeMask; // Renderpass m_VulkanPipelineState.Pass.renderpass.obj = state.renderPass; diff --git a/renderdoc/driver/vulkan/vk_replay.h b/renderdoc/driver/vulkan/vk_replay.h index 4d2d5efa6..3b9561880 100644 --- a/renderdoc/driver/vulkan/vk_replay.h +++ b/renderdoc/driver/vulkan/vk_replay.h @@ -193,7 +193,6 @@ class VulkanReplay : public IReplayDriver VkImageMemoryBarrier bbtrans; VkFramebuffer fb, fbdepth; VkRenderPass renderpass; - VkDynamicViewportState fullVP; uint32_t curidx; VkImage dsimg; diff --git a/renderdoc/driver/vulkan/vk_resources.cpp b/renderdoc/driver/vulkan/vk_resources.cpp index d39260fe5..c3c0def8e 100644 --- a/renderdoc/driver/vulkan/vk_resources.cpp +++ b/renderdoc/driver/vulkan/vk_resources.cpp @@ -48,10 +48,6 @@ WRAPPED_POOL_INST(WrappedVkDescriptorSetLayout) WRAPPED_POOL_INST(WrappedVkSampler) WRAPPED_POOL_INST(WrappedVkDescriptorPool) WRAPPED_POOL_INST(WrappedVkDescriptorSet) -WRAPPED_POOL_INST(WrappedVkDynamicViewportState) -WRAPPED_POOL_INST(WrappedVkDynamicRasterState) -WRAPPED_POOL_INST(WrappedVkDynamicColorBlendState) -WRAPPED_POOL_INST(WrappedVkDynamicDepthStencilState) WRAPPED_POOL_INST(WrappedVkFramebuffer) WRAPPED_POOL_INST(WrappedVkCmdPool) @@ -85,10 +81,6 @@ VkResourceType IdentifyTypeByPtr(WrappedVkRes *ptr) if(WrappedVkDescriptorPool::IsAlloc(ptr)) return eResDescriptorPool; if(WrappedVkDescriptorSetLayout::IsAlloc(ptr)) return eResDescriptorSetLayout; if(WrappedVkDescriptorSet::IsAlloc(ptr)) return eResDescriptorSet; - if(WrappedVkDynamicViewportState::IsAlloc(ptr)) return eResViewportState; - if(WrappedVkDynamicRasterState::IsAlloc(ptr)) return eResRasterState; - if(WrappedVkDynamicColorBlendState::IsAlloc(ptr)) return eResColorBlendState; - if(WrappedVkDynamicDepthStencilState::IsAlloc(ptr)) return eResDepthStencilState; if(WrappedVkCmdPool::IsAlloc(ptr)) return eResCmdPool; if(WrappedVkCmdBuffer::IsAlloc(ptr)) return eResCmdBuffer; if(WrappedVkFence::IsAlloc(ptr)) return eResFence; diff --git a/renderdoc/driver/vulkan/vk_resources.h b/renderdoc/driver/vulkan/vk_resources.h index 77515da96..d6cdc6ffb 100644 --- a/renderdoc/driver/vulkan/vk_resources.h +++ b/renderdoc/driver/vulkan/vk_resources.h @@ -362,32 +362,6 @@ struct WrappedVkDescriptorSet : WrappedVkNonDispRes ALLOCATE_WITH_WRAPPED_POOL(WrappedVkDescriptorSet, AllocPoolCount, AllocPoolMaxByteSize); enum { TypeEnum = eResDescriptorSet, }; }; -struct WrappedVkDynamicViewportState : WrappedVkNonDispRes -{ - WrappedVkDynamicViewportState(VkDynamicViewportState obj, ResourceId objId) : WrappedVkNonDispRes(obj, objId) {} - typedef VkDynamicViewportState InnerType; - static const int AllocPoolCount = 32*1024; - ALLOCATE_WITH_WRAPPED_POOL(WrappedVkDynamicViewportState, AllocPoolCount); - enum { TypeEnum = eResViewportState, }; -}; -struct WrappedVkDynamicRasterState : WrappedVkNonDispRes -{ - WrappedVkDynamicRasterState(VkDynamicRasterState obj, ResourceId objId) : WrappedVkNonDispRes(obj, objId) {} - typedef VkDynamicRasterState InnerType; ALLOCATE_WITH_WRAPPED_POOL(WrappedVkDynamicRasterState); - enum { TypeEnum = eResRasterState, }; -}; -struct WrappedVkDynamicColorBlendState : WrappedVkNonDispRes -{ - WrappedVkDynamicColorBlendState(VkDynamicColorBlendState obj, ResourceId objId) : WrappedVkNonDispRes(obj, objId) {} - typedef VkDynamicColorBlendState InnerType; ALLOCATE_WITH_WRAPPED_POOL(WrappedVkDynamicColorBlendState); - enum { TypeEnum = eResColorBlendState, }; -}; -struct WrappedVkDynamicDepthStencilState : WrappedVkNonDispRes -{ - WrappedVkDynamicDepthStencilState(VkDynamicDepthStencilState obj, ResourceId objId) : WrappedVkNonDispRes(obj, objId) {} - typedef VkDynamicDepthStencilState InnerType; ALLOCATE_WITH_WRAPPED_POOL(WrappedVkDynamicDepthStencilState); - enum { TypeEnum = eResDepthStencilState, }; -}; struct WrappedVkFramebuffer : WrappedVkNonDispRes { WrappedVkFramebuffer(VkFramebuffer obj, ResourceId objId) : WrappedVkNonDispRes(obj, objId) {} @@ -459,10 +433,6 @@ UNWRAP_NONDISP_HELPER(VkDescriptorSetLayout) UNWRAP_NONDISP_HELPER(VkSampler) UNWRAP_NONDISP_HELPER(VkDescriptorPool) UNWRAP_NONDISP_HELPER(VkDescriptorSet) -UNWRAP_NONDISP_HELPER(VkDynamicViewportState) -UNWRAP_NONDISP_HELPER(VkDynamicRasterState) -UNWRAP_NONDISP_HELPER(VkDynamicColorBlendState) -UNWRAP_NONDISP_HELPER(VkDynamicDepthStencilState) UNWRAP_NONDISP_HELPER(VkFramebuffer) UNWRAP_NONDISP_HELPER(VkCmdPool) UNWRAP_NONDISP_HELPER(VkSwapChainWSI) diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index c18150dae..a00386684 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -839,220 +839,6 @@ void WrappedVulkan::vkCmdBindDescriptorSets( } } -bool WrappedVulkan::Serialise_vkCmdBindDynamicViewportState( - Serialiser* localSerialiser, - VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState) -{ - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); - SERIALISE_ELEMENT(ResourceId, stateid, GetResID(dynamicViewportState)); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) - { - dynamicViewportState = GetResourceManager()->GetLiveHandle(stateid); - - if(IsPartialCmd(cmdid) && InPartialRange()) - { - cmdBuffer = PartialCmdBuf(); - - ObjDisp(cmdBuffer)->CmdBindDynamicViewportState(Unwrap(cmdBuffer), Unwrap(dynamicViewportState)); - m_PartialReplayData.state.dynamicVP = stateid; - } - } - else if(m_State == READING) - { - cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); - dynamicViewportState = GetResourceManager()->GetLiveHandle(stateid); - - ObjDisp(cmdBuffer)->CmdBindDynamicViewportState(Unwrap(cmdBuffer), Unwrap(dynamicViewportState)); - } - - return true; -} - -void WrappedVulkan::vkCmdBindDynamicViewportState( - VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState) -{ - ObjDisp(cmdBuffer)->CmdBindDynamicViewportState(Unwrap(cmdBuffer), Unwrap(dynamicViewportState)); - - if(m_State >= WRITING) - { - VkResourceRecord *record = GetRecord(cmdBuffer); - - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CONTEXT(BIND_VP_STATE); - Serialise_vkCmdBindDynamicViewportState(localSerialiser, cmdBuffer, dynamicViewportState); - - record->AddChunk(scope.Get()); - record->MarkResourceFrameReferenced(GetResID(dynamicViewportState), eFrameRef_Read); - } -} - -bool WrappedVulkan::Serialise_vkCmdBindDynamicRasterState( - Serialiser* localSerialiser, - VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState) -{ - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); - SERIALISE_ELEMENT(ResourceId, stateid, GetResID(dynamicRasterState)); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) - { - dynamicRasterState = GetResourceManager()->GetLiveHandle(stateid); - - if(IsPartialCmd(cmdid) && InPartialRange()) - { - cmdBuffer = PartialCmdBuf(); - - ObjDisp(cmdBuffer)->CmdBindDynamicRasterState(Unwrap(cmdBuffer), Unwrap(dynamicRasterState)); - m_PartialReplayData.state.dynamicRS = stateid; - } - } - else if(m_State == READING) - { - cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); - dynamicRasterState = GetResourceManager()->GetLiveHandle(stateid); - - ObjDisp(cmdBuffer)->CmdBindDynamicRasterState(Unwrap(cmdBuffer), Unwrap(dynamicRasterState)); - } - - return true; -} - -void WrappedVulkan::vkCmdBindDynamicRasterState( - VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState) -{ - ObjDisp(cmdBuffer)->CmdBindDynamicRasterState(Unwrap(cmdBuffer), Unwrap(dynamicRasterState)); - - if(m_State >= WRITING) - { - VkResourceRecord *record = GetRecord(cmdBuffer); - - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CONTEXT(BIND_RS_STATE); - Serialise_vkCmdBindDynamicRasterState(localSerialiser, cmdBuffer, dynamicRasterState); - - record->AddChunk(scope.Get()); - record->MarkResourceFrameReferenced(GetResID(dynamicRasterState), eFrameRef_Read); - } -} - -bool WrappedVulkan::Serialise_vkCmdBindDynamicColorBlendState( - Serialiser* localSerialiser, - VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState) -{ - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); - SERIALISE_ELEMENT(ResourceId, stateid, GetResID(dynamicColorBlendState)); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) - { - dynamicColorBlendState = GetResourceManager()->GetLiveHandle(stateid); - - if(IsPartialCmd(cmdid) && InPartialRange()) - { - cmdBuffer = PartialCmdBuf(); - ObjDisp(cmdBuffer)->CmdBindDynamicColorBlendState(Unwrap(cmdBuffer), Unwrap(dynamicColorBlendState)); - m_PartialReplayData.state.dynamicCB = stateid; - } - } - else if(m_State == READING) - { - cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); - dynamicColorBlendState = GetResourceManager()->GetLiveHandle(stateid); - - ObjDisp(cmdBuffer)->CmdBindDynamicColorBlendState(Unwrap(cmdBuffer), Unwrap(dynamicColorBlendState)); - } - - return true; -} - -void WrappedVulkan::vkCmdBindDynamicColorBlendState( - VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState) -{ - ObjDisp(cmdBuffer)->CmdBindDynamicColorBlendState(Unwrap(cmdBuffer), Unwrap(dynamicColorBlendState)); - - if(m_State >= WRITING) - { - VkResourceRecord *record = GetRecord(cmdBuffer); - - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CONTEXT(BIND_CB_STATE); - Serialise_vkCmdBindDynamicColorBlendState(localSerialiser, cmdBuffer, dynamicColorBlendState); - - record->AddChunk(scope.Get()); - record->MarkResourceFrameReferenced(GetResID(dynamicColorBlendState), eFrameRef_Read); - } -} - -bool WrappedVulkan::Serialise_vkCmdBindDynamicDepthStencilState( - Serialiser* localSerialiser, - VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState) -{ - SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); - SERIALISE_ELEMENT(ResourceId, stateid, GetResID(dynamicDepthStencilState)); - - if(m_State < WRITING) - m_LastCmdBufferID = cmdid; - - if(m_State == EXECUTING) - { - dynamicDepthStencilState = GetResourceManager()->GetLiveHandle(stateid); - - if(IsPartialCmd(cmdid) && InPartialRange()) - { - cmdBuffer = PartialCmdBuf(); - ObjDisp(cmdBuffer)->CmdBindDynamicDepthStencilState(Unwrap(cmdBuffer), Unwrap(dynamicDepthStencilState)); - m_PartialReplayData.state.dynamicDS = stateid; - } - } - else if(m_State == READING) - { - cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); - dynamicDepthStencilState = GetResourceManager()->GetLiveHandle(stateid); - - ObjDisp(cmdBuffer)->CmdBindDynamicDepthStencilState(Unwrap(cmdBuffer), Unwrap(dynamicDepthStencilState)); - } - - return true; -} - -void WrappedVulkan::vkCmdBindDynamicDepthStencilState( - VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState) -{ - ObjDisp(cmdBuffer)->CmdBindDynamicDepthStencilState(Unwrap(cmdBuffer), Unwrap(dynamicDepthStencilState)); - - if(m_State >= WRITING) - { - VkResourceRecord *record = GetRecord(cmdBuffer); - - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CONTEXT(BIND_DS_STATE); - Serialise_vkCmdBindDynamicDepthStencilState(localSerialiser, cmdBuffer, dynamicDepthStencilState); - - record->AddChunk(scope.Get()); - record->MarkResourceFrameReferenced(GetResID(dynamicDepthStencilState), eFrameRef_Read); - } -} - bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, diff --git a/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp new file mode 100644 index 000000000..9ccbcfacc --- /dev/null +++ b/renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp @@ -0,0 +1,518 @@ +/****************************************************************************** + * 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. + ******************************************************************************/ + +#include "../vk_core.h" + +bool WrappedVulkan::Serialise_vkCmdSetViewport( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + uint32_t viewportCount, + const VkViewport* pViewports) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(uint32_t, count, viewportCount); + SERIALISE_ELEMENT_ARR(VkViewport, views, pViewports, count); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetViewport(Unwrap(cmdBuffer), count, views); + m_PartialReplayData.state.views.assign(views, views + count); + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetViewport(Unwrap(cmdBuffer), count, views); + } + + SAFE_DELETE_ARRAY(views); + + return true; +} + +void WrappedVulkan::vkCmdSetViewport( + VkCmdBuffer cmdBuffer, + uint32_t viewportCount, + const VkViewport* pViewports) +{ + ObjDisp(cmdBuffer)->CmdSetViewport(Unwrap(cmdBuffer), viewportCount, pViewports); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(SET_VP); + Serialise_vkCmdSetViewport(localSerialiser, cmdBuffer, viewportCount, pViewports); + + record->AddChunk(scope.Get()); + } +} + +bool WrappedVulkan::Serialise_vkCmdSetScissor( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(uint32_t, count, scissorCount); + SERIALISE_ELEMENT_ARR(VkRect2D, scissors, pScissors, count); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetScissor(Unwrap(cmdBuffer), count, scissors); + m_PartialReplayData.state.scissors.assign(scissors, scissors + count); + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetScissor(Unwrap(cmdBuffer), count, scissors); + } + + SAFE_DELETE_ARRAY(scissors); + + return true; +} + +void WrappedVulkan::vkCmdSetScissor( + VkCmdBuffer cmdBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ + ObjDisp(cmdBuffer)->CmdSetScissor(Unwrap(cmdBuffer), scissorCount, pScissors); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(SET_SCISSOR); + Serialise_vkCmdSetScissor(localSerialiser, cmdBuffer, scissorCount, pScissors); + + record->AddChunk(scope.Get()); + } +} + +bool WrappedVulkan::Serialise_vkCmdSetLineWidth( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + float lineWidth) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(float, width, lineWidth); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetLineWidth(Unwrap(cmdBuffer), width); + m_PartialReplayData.state.lineWidth = width; + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetLineWidth(Unwrap(cmdBuffer), width); + } + + return true; +} + +void WrappedVulkan::vkCmdSetLineWidth( + VkCmdBuffer cmdBuffer, + float lineWidth) +{ + ObjDisp(cmdBuffer)->CmdSetLineWidth(Unwrap(cmdBuffer), lineWidth); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(SET_LINE_WIDTH); + Serialise_vkCmdSetLineWidth(localSerialiser, cmdBuffer, lineWidth); + + record->AddChunk(scope.Get()); + } +} + +bool WrappedVulkan::Serialise_vkCmdSetDepthBias( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + float depthBias, + float depthBiasClamp, + float slopeScaledDepthBias) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(float, bias, depthBias); + SERIALISE_ELEMENT(float, biasclamp, depthBiasClamp); + SERIALISE_ELEMENT(float, slope, slopeScaledDepthBias); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetDepthBias(Unwrap(cmdBuffer), bias, biasclamp, slope); + m_PartialReplayData.state.bias.depth = bias; + m_PartialReplayData.state.bias.biasclamp = biasclamp; + m_PartialReplayData.state.bias.slope = slope; + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetDepthBias(Unwrap(cmdBuffer), bias, biasclamp, slope); + } + + return true; +} + +void WrappedVulkan::vkCmdSetDepthBias( + VkCmdBuffer cmdBuffer, + float depthBias, + float depthBiasClamp, + float slopeScaledDepthBias) +{ + ObjDisp(cmdBuffer)->CmdSetDepthBias(Unwrap(cmdBuffer), depthBias, depthBiasClamp, slopeScaledDepthBias); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(SET_DEPTH_BIAS); + Serialise_vkCmdSetDepthBias(localSerialiser, cmdBuffer, depthBias, depthBiasClamp, slopeScaledDepthBias); + + record->AddChunk(scope.Get()); + } +} + +bool WrappedVulkan::Serialise_vkCmdSetBlendConstants( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + const float* blendConst) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + float blendFactor[4]; + if(m_State >= WRITING) + { + blendFactor[0] = blendConst[0]; + blendFactor[1] = blendConst[1]; + blendFactor[2] = blendConst[2]; + blendFactor[3] = blendConst[3]; + } + localSerialiser->SerialisePODArray<4>("blendConst", blendFactor); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetBlendConstants(Unwrap(cmdBuffer), blendFactor); + memcpy(m_PartialReplayData.state.blendConst, blendFactor, sizeof(blendFactor); + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetBlendConstants(Unwrap(cmdBuffer), blendFactor); + } + + return true; +} + +void WrappedVulkan::vkCmdSetBlendConstants( + VkCmdBuffer cmdBuffer, + const float* blendConst) +{ + ObjDisp(cmdBuffer)->CmdSetBlendConstants(Unwrap(cmdBuffer), blendConst); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(CmdSetBlendConstants); + Serialise_vkCmdSetBlendConstants(localSerialiser, cmdBuffer, blendConst); + + record->AddChunk(scope.Get()); + } +} + +bool WrappedVulkan::Serialise_vkCmdSetDepthBounds( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + float minDepthBounds, + float maxDepthBounds) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(float, mind, minDepthBounds); + SERIALISE_ELEMENT(float, maxd, maxDepthBounds); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetDepthBounds(Unwrap(cmdBuffer), mind, maxd); + m_PartialReplayData.state.mindepth = mind; + m_PartialReplayData.state.maxdepth = maxd; + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetDepthBounds(Unwrap(cmdBuffer), mind, maxd); + } + + return true; +} + +void WrappedVulkan::vkCmdSetDepthBounds( + VkCmdBuffer cmdBuffer, + float minDepthBounds, + float maxDepthBounds) +{ + ObjDisp(cmdBuffer)->CmdSetDepthBounds(Unwrap(cmdBuffer), minDepthBounds, maxDepthBounds); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(SET_DEPTH_BOUNDS); + Serialise_vkCmdSetDepthBounds(localSerialiser, cmdBuffer, minDepthBounds, maxDepthBounds); + + record->AddChunk(scope.Get()); + } +} + +bool WrappedVulkan::Serialise_vkCmdSetStencilCompareMask( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilCompareMask) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(VkStencilFaceFlagsBits, face, faceMask); + SERIALISE_ELEMENT(uint32_t, mask, stencilCompareMask); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetStencilCompareMask(Unwrap(cmdBuffer), face, mask); + + if(face & VK_STENCIL_FACE_FRONT_BIT) + m_PartialReplayData.state.front.compare = mask; + if(face & VK_STENCIL_FACE_BACK_BIT) + m_PartialReplayData.state.back.compare = mask; + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetStencilCompareMask(Unwrap(cmdBuffer), face, mask); + } + + return true; +} + +void WrappedVulkan::vkCmdSetStencilCompareMask( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilCompareMask) +{ + ObjDisp(cmdBuffer)->CmdSetStencilCompareMask(Unwrap(cmdBuffer), faceMask, stencilCompareMask); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(SET_STENCIL_COMP_MASK); + Serialise_vkCmdSetStencilCompareMask(localSerialiser, cmdBuffer, faceMask, stencilCompareMask); + + record->AddChunk(scope.Get()); + } +} + +bool WrappedVulkan::Serialise_vkCmdSetStencilWriteMask( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilWriteMask) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(VkStencilFaceFlagsBits, face, faceMask); + SERIALISE_ELEMENT(uint32_t, mask, stencilWriteMask); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetStencilWriteMask(Unwrap(cmdBuffer), face, mask); + + if(face & VK_STENCIL_FACE_FRONT_BIT) + m_PartialReplayData.state.front.write = mask; + if(face & VK_STENCIL_FACE_BACK_BIT) + m_PartialReplayData.state.back.write = mask; + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetStencilWriteMask(Unwrap(cmdBuffer), face, mask); + } + + return true; +} + +void WrappedVulkan::vkCmdSetStencilWriteMask( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilWriteMask) +{ + ObjDisp(cmdBuffer)->CmdSetStencilWriteMask(Unwrap(cmdBuffer), faceMask, stencilWriteMask); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(SET_STENCIL_WRITE_MASK); + Serialise_vkCmdSetStencilWriteMask(localSerialiser, cmdBuffer, faceMask, stencilWriteMask); + + record->AddChunk(scope.Get()); + } +} + +bool WrappedVulkan::Serialise_vkCmdSetStencilReference( + Serialiser* localSerialiser, + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilReference) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(VkStencilFaceFlagsBits, face, faceMask); + SERIALISE_ELEMENT(uint32_t, mask, stencilReference); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdSetStencilReference(Unwrap(cmdBuffer), face, mask); + + if(face & VK_STENCIL_FACE_FRONT_BIT) + m_PartialReplayData.state.front.ref = mask; + if(face & VK_STENCIL_FACE_BACK_BIT) + m_PartialReplayData.state.back.ref = mask; + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + + ObjDisp(cmdBuffer)->CmdSetStencilReference(Unwrap(cmdBuffer), face, mask); + } + + return true; +} + +void WrappedVulkan::vkCmdSetStencilReference( + VkCmdBuffer cmdBuffer, + VkStencilFaceFlags faceMask, + uint32_t stencilReference) +{ + ObjDisp(cmdBuffer)->CmdSetStencilReference(Unwrap(cmdBuffer), faceMask, stencilReference); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CONTEXT(SET_STENCIL_REF); + Serialise_vkCmdSetStencilReference(localSerialiser, cmdBuffer, faceMask, stencilReference); + + record->AddChunk(scope.Get()); + } +} + diff --git a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp index f304787e6..a1761e92d 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp @@ -49,10 +49,6 @@ DESTROY_IMPL(VkPipelineLayout, DestroyPipelineLayout) DESTROY_IMPL(VkSampler, DestroySampler) DESTROY_IMPL(VkDescriptorSetLayout, DestroyDescriptorSetLayout) DESTROY_IMPL(VkDescriptorPool, DestroyDescriptorPool) -DESTROY_IMPL(VkDynamicViewportState, DestroyDynamicViewportState) -DESTROY_IMPL(VkDynamicRasterState, DestroyDynamicRasterState) -DESTROY_IMPL(VkDynamicColorBlendState, DestroyDynamicColorBlendState) -DESTROY_IMPL(VkDynamicDepthStencilState, DestroyDynamicDepthStencilState) DESTROY_IMPL(VkSemaphore, DestroySemaphore) DESTROY_IMPL(VkFence, DestroyFence) DESTROY_IMPL(VkCmdPool, DestroyCommandPool) @@ -182,18 +178,6 @@ bool WrappedVulkan::ReleaseResource(WrappedVkRes *res) case eResDescriptorSetLayout: vt->DestroyDescriptorSetLayout(Unwrap(dev), nondisp->real.As()); break; - case eResViewportState: - vt->DestroyDynamicViewportState(Unwrap(dev), nondisp->real.As()); - break; - case eResRasterState: - vt->DestroyDynamicViewportState(Unwrap(dev), nondisp->real.As()); - break; - case eResColorBlendState: - vt->DestroyDynamicColorBlendState(Unwrap(dev), nondisp->real.As()); - break; - case eResDepthStencilState: - vt->DestroyDynamicDepthStencilState(Unwrap(dev), nondisp->real.As()); - break; case eResCmdPool: vt->DestroyCommandPool(Unwrap(dev), nondisp->real.As()); break; @@ -628,288 +612,6 @@ VkResult WrappedVulkan::vkCreateRenderPass( return ret; } -// State object functions - -bool WrappedVulkan::Serialise_vkCreateDynamicViewportState( - Serialiser* localSerialiser, - VkDevice device, - const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState) -{ - SERIALISE_ELEMENT(ResourceId, devId, GetResID(device)); - SERIALISE_ELEMENT(VkDynamicViewportStateCreateInfo, info, *pCreateInfo); - SERIALISE_ELEMENT(ResourceId, id, GetResID(*pState)); - - if(m_State == READING) - { - device = GetResourceManager()->GetLiveHandle(devId); - VkDynamicViewportState state = VK_NULL_HANDLE; - - // use original ID - m_CreationInfo.m_VPScissor[id].Init(&info); - - VkResult ret = ObjDisp(device)->CreateDynamicViewportState(Unwrap(device), &info, &state); - - if(ret != VK_SUCCESS) - { - RDCERR("Failed on resource serialise-creation, VkResult: 0x%08x", ret); - } - else - { - ResourceId live = GetResourceManager()->WrapResource(Unwrap(device), state); - GetResourceManager()->AddLiveResource(id, state); - } - } - - return true; -} - -VkResult WrappedVulkan::vkCreateDynamicViewportState( - VkDevice device, - const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState) -{ - VkResult ret = ObjDisp(device)->CreateDynamicViewportState(Unwrap(device), pCreateInfo, pState); - - if(ret == VK_SUCCESS) - { - ResourceId id = GetResourceManager()->WrapResource(Unwrap(device), *pState); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CONTEXT(CREATE_VIEWPORT_STATE); - Serialise_vkCreateDynamicViewportState(localSerialiser, device, pCreateInfo, pState); - - chunk = scope.Get(); - } - - VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pState); - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, *pState); - } - } - - return ret; -} - -bool WrappedVulkan::Serialise_vkCreateDynamicRasterState( - Serialiser* localSerialiser, - VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState) -{ - SERIALISE_ELEMENT(ResourceId, devId, GetResID(device)); - SERIALISE_ELEMENT(VkDynamicRasterStateCreateInfo, info, *pCreateInfo); - SERIALISE_ELEMENT(ResourceId, id, GetResID(*pState)); - - if(m_State == READING) - { - device = GetResourceManager()->GetLiveHandle(devId); - VkDynamicRasterState state = VK_NULL_HANDLE; - - // use original ID - m_CreationInfo.m_Raster[id].Init(&info); - - VkResult ret = ObjDisp(device)->CreateDynamicRasterState(Unwrap(device), &info, &state); - - if(ret != VK_SUCCESS) - { - RDCERR("Failed on resource serialise-creation, VkResult: 0x%08x", ret); - } - else - { - ResourceId live = GetResourceManager()->WrapResource(Unwrap(device), state); - GetResourceManager()->AddLiveResource(id, state); - } - } - - return true; -} - -VkResult WrappedVulkan::vkCreateDynamicRasterState( - VkDevice device, - const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState) -{ - VkResult ret = ObjDisp(device)->CreateDynamicRasterState(Unwrap(device), pCreateInfo, pState); - - if(ret == VK_SUCCESS) - { - ResourceId id = GetResourceManager()->WrapResource(Unwrap(device), *pState); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CONTEXT(CREATE_RASTER_STATE); - Serialise_vkCreateDynamicRasterState(localSerialiser, device, pCreateInfo, pState); - - chunk = scope.Get(); - } - - VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pState); - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, *pState); - } - } - - return ret; -} - -bool WrappedVulkan::Serialise_vkCreateDynamicColorBlendState( - Serialiser* localSerialiser, - VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState) -{ - SERIALISE_ELEMENT(ResourceId, devId, GetResID(device)); - SERIALISE_ELEMENT(VkDynamicColorBlendStateCreateInfo, info, *pCreateInfo); - SERIALISE_ELEMENT(ResourceId, id, GetResID(*pState)); - - if(m_State == READING) - { - device = GetResourceManager()->GetLiveHandle(devId); - VkDynamicColorBlendState state = VK_NULL_HANDLE; - - // use original ID - m_CreationInfo.m_Blend[id].Init(&info); - - VkResult ret = ObjDisp(device)->CreateDynamicColorBlendState(Unwrap(device), &info, &state); - - if(ret != VK_SUCCESS) - { - RDCERR("Failed on resource serialise-creation, VkResult: 0x%08x", ret); - } - else - { - ResourceId live = GetResourceManager()->WrapResource(Unwrap(device), state); - GetResourceManager()->AddLiveResource(id, state); - } - } - - return true; -} - -VkResult WrappedVulkan::vkCreateDynamicColorBlendState( - VkDevice device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState) -{ - VkResult ret = ObjDisp(device)->CreateDynamicColorBlendState(Unwrap(device), pCreateInfo, pState); - - if(ret == VK_SUCCESS) - { - ResourceId id = GetResourceManager()->WrapResource(Unwrap(device), *pState); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CONTEXT(CREATE_BLEND_STATE); - Serialise_vkCreateDynamicColorBlendState(localSerialiser, device, pCreateInfo, pState); - - chunk = scope.Get(); - } - - VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pState); - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, *pState); - } - } - - return ret; -} - -bool WrappedVulkan::Serialise_vkCreateDynamicDepthStencilState( - Serialiser* localSerialiser, - VkDevice device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState) -{ - SERIALISE_ELEMENT(ResourceId, devId, GetResID(device)); - SERIALISE_ELEMENT(VkDynamicDepthStencilStateCreateInfo, info, *pCreateInfo); - SERIALISE_ELEMENT(ResourceId, id, GetResID(*pState)); - - if(m_State == READING) - { - device = GetResourceManager()->GetLiveHandle(devId); - VkDynamicDepthStencilState state = VK_NULL_HANDLE; - - // use original ID - m_CreationInfo.m_DepthStencil[id].Init(&info); - - VkResult ret = ObjDisp(device)->CreateDynamicDepthStencilState(Unwrap(device), &info, &state); - - if(ret != VK_SUCCESS) - { - RDCERR("Failed on resource serialise-creation, VkResult: 0x%08x", ret); - } - else - { - ResourceId live = GetResourceManager()->WrapResource(Unwrap(device), state); - GetResourceManager()->AddLiveResource(id, state); - } - } - - return true; -} - -VkResult WrappedVulkan::vkCreateDynamicDepthStencilState( - VkDevice device, - const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState) -{ - VkResult ret = ObjDisp(device)->CreateDynamicDepthStencilState(Unwrap(device), pCreateInfo, pState); - - if(ret == VK_SUCCESS) - { - ResourceId id = GetResourceManager()->WrapResource(Unwrap(device), *pState); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - CACHE_THREAD_SERIALISER(); - - SCOPED_SERIALISE_CONTEXT(CREATE_DEPTH_STATE); - Serialise_vkCreateDynamicDepthStencilState(localSerialiser, device, pCreateInfo, pState); - - chunk = scope.Get(); - } - - VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pState); - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, *pState); - } - } - - return ret; -} - bool WrappedVulkan::Serialise_vkCreateQueryPool( Serialiser* localSerialiser, VkDevice device, diff --git a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp index 47bad5d0c..d54a5fa6c 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp @@ -371,21 +371,6 @@ VkResult WrappedVulkan::vkCreateSwapChainWSI( GetResourceManager()->WrapResource(Unwrap(device), swapInfo.rp); } - { - VkViewport vp = { 0.0f, 0.0f, (float)pCreateInfo->imageExtent.width, (float)pCreateInfo->imageExtent.height, 0.0f, 1.0f, }; - VkRect2D sc = { { 0, 0 }, { pCreateInfo->imageExtent.width, pCreateInfo->imageExtent.height } }; - - VkDynamicViewportStateCreateInfo vpInfo = { - VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, NULL, - 1, &vp, &sc - }; - - vkr = vt->CreateDynamicViewportState(Unwrap(device), &vpInfo, &swapInfo.vp); - RDCASSERT(vkr == VK_SUCCESS); - - GetResourceManager()->WrapResource(Unwrap(device), swapInfo.vp); - } - // serialise out the swap chain images { size_t swapChainImagesSize; @@ -534,7 +519,6 @@ VkResult WrappedVulkan::vkQueuePresentWSI( if(overlay & eRENDERDOC_Overlay_Enabled) { VkRenderPass rp = swapInfo.rp; - VkDynamicViewportState vp = swapInfo.vp; VkFramebuffer fb = swapInfo.images[pPresentInfo->imageIndices[0]].fb; // VKTODOLOW only handling queue == GetQ()