mirror of
https://github.com/baldurk/renderdoc.git
synced 2026-10-03 02:47:47 +00:00
Remove dynamic state objects
This commit is contained in:
baldurk
@@ -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<Attachment> 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
|
||||
|
||||
@@ -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 \
|
||||
|
||||
@@ -35,6 +35,7 @@
|
||||
</ClCompile>
|
||||
<ClCompile Include="vk_resources.cpp" />
|
||||
<ClCompile Include="wrappers\vk_cmd_funcs.cpp" />
|
||||
<ClCompile Include="wrappers\vk_dynamic_funcs.cpp" />
|
||||
<ClCompile Include="wrappers\vk_descriptor_funcs.cpp" />
|
||||
<ClCompile Include="wrappers\vk_device_funcs.cpp" />
|
||||
<ClCompile Include="wrappers\vk_draw_funcs.cpp" />
|
||||
|
||||
@@ -46,6 +46,9 @@
|
||||
<ClCompile Include="wrappers\vk_cmd_funcs.cpp">
|
||||
<Filter>Wrappers</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="wrappers\vk_dynamic_funcs.cpp">
|
||||
<Filter>Wrappers</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="wrappers\vk_descriptor_funcs.cpp">
|
||||
<Filter>Wrappers</Filter>
|
||||
</ClCompile>
|
||||
|
||||
@@ -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)
|
||||
{
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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<VkViewport> views;
|
||||
vector<VkRect2D> 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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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); \
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -111,47 +111,6 @@ struct VulkanCreationInfo
|
||||
};
|
||||
map<ResourceId, Pipeline> m_Pipeline;
|
||||
|
||||
struct ViewportScissor
|
||||
{
|
||||
void Init(const VkDynamicViewportStateCreateInfo* pCreateInfo);
|
||||
|
||||
vector<VkViewport> viewports;
|
||||
vector<VkRect2D> scissors;
|
||||
};
|
||||
map<ResourceId, ViewportScissor> m_VPScissor;
|
||||
|
||||
struct Raster
|
||||
{
|
||||
void Init(const VkDynamicRasterStateCreateInfo* pCreateInfo);
|
||||
|
||||
float depthBias;
|
||||
float depthBiasClamp;
|
||||
float slopeScaledDepthBias;
|
||||
float lineWidth;
|
||||
};
|
||||
map<ResourceId, Raster> m_Raster;
|
||||
|
||||
struct Blend
|
||||
{
|
||||
void Init(const VkDynamicColorBlendStateCreateInfo* pCreateInfo);
|
||||
|
||||
float blendConst[4];
|
||||
};
|
||||
map<ResourceId, Blend> 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<ResourceId, DepthStencil> m_DepthStencil;
|
||||
|
||||
struct RenderPass
|
||||
{
|
||||
void Init(const VkRenderPassCreateInfo* pCreateInfo);
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -193,7 +193,6 @@ class VulkanReplay : public IReplayDriver
|
||||
VkImageMemoryBarrier bbtrans;
|
||||
VkFramebuffer fb, fbdepth;
|
||||
VkRenderPass renderpass;
|
||||
VkDynamicViewportState fullVP;
|
||||
uint32_t curidx;
|
||||
|
||||
VkImage dsimg;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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<VkDynamicViewportState>(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<VkCmdBuffer>(cmdid);
|
||||
dynamicViewportState = GetResourceManager()->GetLiveHandle<VkDynamicViewportState>(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<VkDynamicRasterState>(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<VkCmdBuffer>(cmdid);
|
||||
dynamicRasterState = GetResourceManager()->GetLiveHandle<VkDynamicRasterState>(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<VkDynamicColorBlendState>(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<VkCmdBuffer>(cmdid);
|
||||
dynamicColorBlendState = GetResourceManager()->GetLiveHandle<VkDynamicColorBlendState>(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<VkDynamicDepthStencilState>(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<VkCmdBuffer>(cmdid);
|
||||
dynamicDepthStencilState = GetResourceManager()->GetLiveHandle<VkDynamicDepthStencilState>(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,
|
||||
|
||||
@@ -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<VkCmdBuffer>(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<VkCmdBuffer>(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<VkCmdBuffer>(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<VkCmdBuffer>(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<VkCmdBuffer>(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<VkCmdBuffer>(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<VkCmdBuffer>(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<VkCmdBuffer>(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<VkCmdBuffer>(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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<VkDescriptorSetLayout>());
|
||||
break;
|
||||
case eResViewportState:
|
||||
vt->DestroyDynamicViewportState(Unwrap(dev), nondisp->real.As<VkDynamicViewportState>());
|
||||
break;
|
||||
case eResRasterState:
|
||||
vt->DestroyDynamicViewportState(Unwrap(dev), nondisp->real.As<VkDynamicViewportState>());
|
||||
break;
|
||||
case eResColorBlendState:
|
||||
vt->DestroyDynamicColorBlendState(Unwrap(dev), nondisp->real.As<VkDynamicColorBlendState>());
|
||||
break;
|
||||
case eResDepthStencilState:
|
||||
vt->DestroyDynamicDepthStencilState(Unwrap(dev), nondisp->real.As<VkDynamicDepthStencilState>());
|
||||
break;
|
||||
case eResCmdPool:
|
||||
vt->DestroyCommandPool(Unwrap(dev), nondisp->real.As<VkCmdPool>());
|
||||
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<VkDevice>(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<VkDevice>(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<VkDevice>(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<VkDevice>(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,
|
||||
|
||||
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user