diff --git a/src/d3d11/d3d11_context.cpp b/src/d3d11/d3d11_context.cpp index df6f6a02..5be7d014 100644 --- a/src/d3d11/d3d11_context.cpp +++ b/src/d3d11/d3d11_context.cpp @@ -14,12 +14,16 @@ namespace dxvk { m_context->beginRecording( m_device->createCommandList()); - m_defaultRsState = new DxvkRasterizerState( - VK_FALSE, VK_FALSE, - VK_POLYGON_MODE_FILL, - VK_CULL_MODE_BACK_BIT, - VK_FRONT_FACE_CLOCKWISE, - VK_FALSE, 0.0f, 0.0f, 0.0f, 1.0f); + m_defaultRsState.enableDepthClamp = VK_FALSE; + m_defaultRsState.enableDiscard = VK_FALSE; + m_defaultRsState.polygonMode = VK_POLYGON_MODE_FILL; + m_defaultRsState.cullMode = VK_CULL_MODE_BACK_BIT; + m_defaultRsState.frontFace = VK_FRONT_FACE_CLOCKWISE; + m_defaultRsState.depthBiasEnable = VK_FALSE; + m_defaultRsState.depthBiasConstant = 0.0f; + m_defaultRsState.depthBiasClamp = 0.0f; + m_defaultRsState.depthBiasSlope = 0.0f; + m_context->setRasterizerState(m_defaultRsState); VkStencilOpState stencilOp; stencilOp.failOp = VK_STENCIL_OP_KEEP; @@ -30,20 +34,26 @@ namespace dxvk { stencilOp.writeMask = D3D11_DEFAULT_STENCIL_WRITE_MASK; stencilOp.reference = 0; - m_defaultDsState = new DxvkDepthStencilState( - VK_TRUE, VK_TRUE, VK_FALSE, VK_FALSE, - VK_COMPARE_OP_LESS, stencilOp, stencilOp, - 0.0f, 1.0f); + m_defaultDsState.enableDepthTest = VK_TRUE; + m_defaultDsState.enableDepthWrite = VK_TRUE; + m_defaultDsState.enableDepthBounds = VK_FALSE; + m_defaultDsState.enableStencilTest = VK_FALSE; + m_defaultDsState.depthCompareOp = VK_COMPARE_OP_LESS; + m_defaultDsState.stencilOpFront = stencilOp; + m_defaultDsState.stencilOpBack = stencilOp; + m_defaultDsState.depthBoundsMin = 0.0f; + m_defaultDsState.depthBoundsMax = 1.0f; + m_context->setDepthStencilState(m_defaultDsState); - m_defaultMsState = new DxvkMultisampleState( - VK_SAMPLE_COUNT_1_BIT, 0xFFFFFFFFu, - VK_FALSE, VK_FALSE, VK_FALSE, 0.0f); + m_defaultMsState.enableAlphaToCoverage = VK_FALSE; + m_defaultMsState.enableAlphaToOne = VK_FALSE; + m_defaultMsState.enableSampleShading = VK_FALSE; + m_defaultMsState.minSampleShading = 0.0f; + m_context->setMultisampleState(m_defaultMsState); m_defaultCbState = new DxvkBlendState( VK_FALSE, VK_LOGIC_OP_CLEAR, 0, nullptr); - m_context->setRasterizerState(m_defaultRsState); - m_context->setMultisampleState(m_defaultMsState); m_context->setDepthStencilState(m_defaultDsState); m_context->setBlendState(m_defaultCbState); } @@ -464,64 +474,55 @@ namespace dxvk { if (m_state.ia.primitiveTopology != Topology) { m_state.ia.primitiveTopology = Topology; - Rc iaState; + DxvkInputAssemblyState iaState; switch (Topology) { case D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED: - break; + return; case D3D11_PRIMITIVE_TOPOLOGY_POINTLIST: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - VK_FALSE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; + iaState.primitiveRestart = VK_FALSE; break; case D3D11_PRIMITIVE_TOPOLOGY_LINELIST: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_LINE_LIST, - VK_FALSE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST; + iaState.primitiveRestart = VK_FALSE; break; case D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, - VK_TRUE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP; + iaState.primitiveRestart = VK_TRUE; break; case D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - VK_FALSE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + iaState.primitiveRestart = VK_FALSE; break; case D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - VK_TRUE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + iaState.primitiveRestart = VK_TRUE; break; case D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, - VK_FALSE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY; + iaState.primitiveRestart = VK_FALSE; break; case D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, - VK_TRUE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY; + iaState.primitiveRestart = VK_TRUE; break; case D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, - VK_FALSE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY; + iaState.primitiveRestart = VK_FALSE; break; case D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ: - iaState = new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, - VK_TRUE); + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY; + iaState.primitiveRestart = VK_TRUE; break; default: diff --git a/src/d3d11/d3d11_context.h b/src/d3d11/d3d11_context.h index f2bf96e2..53d65ff8 100644 --- a/src/d3d11/d3d11_context.h +++ b/src/d3d11/d3d11_context.h @@ -544,12 +544,12 @@ namespace dxvk { const D3D11_DEVICE_CONTEXT_TYPE m_type = D3D11_DEVICE_CONTEXT_IMMEDIATE; const UINT m_flags = 0; - Rc m_device; - Rc m_context; + Rc m_device; + Rc m_context; - Rc m_defaultRsState; - Rc m_defaultDsState; - Rc m_defaultMsState; + DxvkRasterizerState m_defaultRsState; + DxvkDepthStencilState m_defaultDsState; + DxvkMultisampleState m_defaultMsState; Rc m_defaultCbState; D3D11ContextState m_state; diff --git a/src/d3d11/d3d11_state_rs.cpp b/src/d3d11/d3d11_state_rs.cpp index e94c8b87..ebed7e64 100644 --- a/src/d3d11/d3d11_state_rs.cpp +++ b/src/d3d11/d3d11_state_rs.cpp @@ -8,13 +8,17 @@ namespace dxvk { const D3D11_RASTERIZER_DESC& desc) : m_device(device), m_desc(desc) { + // State that is not supported in D3D11 + m_state.enableDepthClamp = VK_FALSE; + m_state.enableDiscard = VK_FALSE; + // Polygon mode. Determines whether the rasterizer fills // a polygon or renders lines connecting the vertices. - VkPolygonMode polygonMode = VK_POLYGON_MODE_FILL; + m_state.polygonMode = VK_POLYGON_MODE_FILL; switch (desc.FillMode) { - case D3D11_FILL_WIREFRAME: polygonMode = VK_POLYGON_MODE_LINE; break; - case D3D11_FILL_SOLID: polygonMode = VK_POLYGON_MODE_FILL; break; + case D3D11_FILL_WIREFRAME: m_state.polygonMode = VK_POLYGON_MODE_LINE; break; + case D3D11_FILL_SOLID: m_state.polygonMode = VK_POLYGON_MODE_FILL; break; default: Logger::err(str::format( @@ -25,12 +29,12 @@ namespace dxvk { // Face culling properties. The rasterizer may discard // polygons that are facing towards or away from the // viewer, depending on the options below. - VkCullModeFlags cullMode = 0; + m_state.cullMode = VK_CULL_MODE_NONE; switch (desc.CullMode) { - case D3D11_CULL_NONE: cullMode = 0; break; - case D3D11_CULL_FRONT: cullMode = VK_CULL_MODE_FRONT_BIT; break; - case D3D11_CULL_BACK: cullMode = VK_CULL_MODE_BACK_BIT; break; + case D3D11_CULL_NONE: m_state.cullMode = VK_CULL_MODE_NONE; break; + case D3D11_CULL_FRONT: m_state.cullMode = VK_CULL_MODE_FRONT_BIT; break; + case D3D11_CULL_BACK: m_state.cullMode = VK_CULL_MODE_BACK_BIT; break; default: Logger::err(str::format( @@ -38,25 +42,23 @@ namespace dxvk { desc.CullMode)); } - VkFrontFace frontFace = desc.FrontCounterClockwise + m_state.frontFace = desc.FrontCounterClockwise ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE; - // TODO implement depth bias - if (desc.DepthBias != 0) - Logger::err("D3D11RasterizerState: Depth bias not supported"); + // Let's treat the depth bias as enabled by default + m_state.depthBiasEnable = VK_TRUE; + m_state.depthBiasConstant = static_cast(desc.DepthBias); + m_state.depthBiasClamp = desc.DepthBiasClamp; + m_state.depthBiasSlope = desc.SlopeScaledDepthBias; - // TODO implement depth clamp + // TODO implement depth clamp. Note that there are differences + // between D3D11 depth clip (disabled) and Vulkan depth clamp. if (!desc.DepthClipEnable) - Logger::err("D3D11RasterizerState: Depth clip not supported"); + Logger::err("D3D11RasterizerState: Depth clamp not supported"); if (desc.AntialiasedLineEnable) Logger::err("D3D11RasterizerState: Antialiased lines not supported"); - - m_state = new DxvkRasterizerState( - VK_FALSE, VK_FALSE, - polygonMode, cullMode, frontFace, - VK_FALSE, 0.0f, 0.0f, 0.0f, 1.0f); } diff --git a/src/d3d11/d3d11_state_rs.h b/src/d3d11/d3d11_state_rs.h index 4ad7c25a..20912a3b 100644 --- a/src/d3d11/d3d11_state_rs.h +++ b/src/d3d11/d3d11_state_rs.h @@ -29,7 +29,7 @@ namespace dxvk { void GetDesc( D3D11_RASTERIZER_DESC* pDesc) final; - Rc GetDXVKRasterizerState() { + const DxvkRasterizerState& GetDXVKRasterizerState() const { return m_state; } @@ -37,7 +37,7 @@ namespace dxvk { D3D11Device* const m_device; D3D11_RASTERIZER_DESC m_desc; - Rc m_state; + DxvkRasterizerState m_state; }; diff --git a/src/dxgi/dxgi_presenter.cpp b/src/dxgi/dxgi_presenter.cpp index dee4b212..1d5d65da 100644 --- a/src/dxgi/dxgi_presenter.cpp +++ b/src/dxgi/dxgi_presenter.cpp @@ -55,27 +55,33 @@ namespace dxvk { // Set up context state. The shader bindings and the // constant state objects will never be modified. - m_context->setInputAssemblyState( - new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, - VK_FALSE)); + DxvkInputAssemblyState iaState; + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; + iaState.primitiveRestart = VK_FALSE; + m_context->setInputAssemblyState(iaState); m_context->setInputLayout( new DxvkInputLayout( 0, nullptr, 0, nullptr)); - m_context->setRasterizerState( - new DxvkRasterizerState( - VK_FALSE, VK_FALSE, - VK_POLYGON_MODE_FILL, - VK_CULL_MODE_NONE, - VK_FRONT_FACE_COUNTER_CLOCKWISE, - VK_FALSE, 0.0f, 0.0f, 0.0f, 1.0f)); + DxvkRasterizerState rsState; + rsState.enableDepthClamp = VK_FALSE; + rsState.enableDiscard = VK_FALSE; + rsState.polygonMode = VK_POLYGON_MODE_FILL; + rsState.cullMode = VK_CULL_MODE_BACK_BIT; + rsState.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; + rsState.depthBiasEnable = VK_FALSE; + rsState.depthBiasConstant = 0.0f; + rsState.depthBiasClamp = 0.0f; + rsState.depthBiasSlope = 0.0f; + m_context->setRasterizerState(rsState); - m_context->setMultisampleState( - new DxvkMultisampleState( - VK_SAMPLE_COUNT_1_BIT, 0xFFFFFFFF, - VK_FALSE, VK_FALSE, VK_FALSE, 0.0f)); + DxvkMultisampleState msState; + msState.enableAlphaToCoverage = VK_FALSE; + msState.enableAlphaToOne = VK_FALSE; + msState.enableSampleShading = VK_FALSE; + msState.minSampleShading = 0.0f; + m_context->setMultisampleState(msState); VkStencilOpState stencilOp; stencilOp.failOp = VK_STENCIL_OP_KEEP; @@ -86,11 +92,16 @@ namespace dxvk { stencilOp.writeMask = 0xFFFFFFFF; stencilOp.reference = 0; - m_context->setDepthStencilState( - new DxvkDepthStencilState( - VK_FALSE, VK_FALSE, VK_FALSE, VK_FALSE, - VK_COMPARE_OP_ALWAYS, stencilOp, stencilOp, - 0.0f, 1.0f)); + DxvkDepthStencilState dsState; + dsState.enableDepthTest = VK_FALSE; + dsState.enableDepthWrite = VK_FALSE; + dsState.enableDepthBounds = VK_FALSE; + dsState.enableStencilTest = VK_FALSE; + dsState.depthCompareOp = VK_COMPARE_OP_ALWAYS; + dsState.stencilOpFront = stencilOp; + dsState.stencilOpBack = stencilOp; + dsState.depthBoundsMin = 0.0f; + dsState.depthBoundsMax = 1.0f; VkPipelineColorBlendAttachmentState blendAttachment; blendAttachment.blendEnable = VK_FALSE; diff --git a/src/dxvk/dxvk_constant_state.cpp b/src/dxvk/dxvk_constant_state.cpp index 8d166b63..6294152c 100644 --- a/src/dxvk/dxvk_constant_state.cpp +++ b/src/dxvk/dxvk_constant_state.cpp @@ -4,90 +4,6 @@ namespace dxvk { - DxvkInputAssemblyState::DxvkInputAssemblyState( - VkPrimitiveTopology primitiveTopology, - VkBool32 primitiveRestart) { - m_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; - m_info.pNext = nullptr; - m_info.flags = 0; - m_info.topology = primitiveTopology; - m_info.primitiveRestartEnable = primitiveRestart; - } - - - DxvkRasterizerState::DxvkRasterizerState( - VkBool32 enableDepthClamp, - VkBool32 enableDiscard, - VkPolygonMode polygonMode, - VkCullModeFlags cullMode, - VkFrontFace frontFace, - VkBool32 depthBiasEnable, - float depthBiasConstant, - float depthBiasClamp, - float depthBiasSlope, - float lineWidth) { - m_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; - m_info.pNext = nullptr; - m_info.flags = 0; - m_info.depthClampEnable = enableDepthClamp; - m_info.rasterizerDiscardEnable= enableDiscard; - m_info.polygonMode = polygonMode; - m_info.cullMode = cullMode; - m_info.frontFace = frontFace; - m_info.depthBiasEnable = depthBiasEnable; - m_info.depthBiasConstantFactor= depthBiasConstant; - m_info.depthBiasClamp = depthBiasClamp; - m_info.depthBiasSlopeFactor = depthBiasSlope; - m_info.lineWidth = lineWidth; - } - - - DxvkMultisampleState::DxvkMultisampleState( - VkSampleCountFlagBits sampleCount, - uint32_t sampleMask, - VkBool32 enableAlphaToCoverage, - VkBool32 enableAlphaToOne, - VkBool32 enableSampleShading, - float minSampleShading) { - m_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; - m_info.pNext = nullptr; - m_info.flags = 0; - m_info.rasterizationSamples = sampleCount; - m_info.sampleShadingEnable = enableSampleShading; - m_info.minSampleShading = minSampleShading; - m_info.pSampleMask = &m_mask; - m_info.alphaToCoverageEnable = enableAlphaToCoverage; - m_info.alphaToOneEnable = enableAlphaToOne; - - m_mask = sampleMask; - } - - - DxvkDepthStencilState::DxvkDepthStencilState( - VkBool32 enableDepthTest, - VkBool32 enableDepthWrite, - VkBool32 enableDepthBounds, - VkBool32 enableStencilTest, - VkCompareOp depthCompareOp, - VkStencilOpState stencilOpFront, - VkStencilOpState stencilOpBack, - float depthBoundsMin, - float depthBoundsMax) { - m_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; - m_info.pNext = nullptr; - m_info.flags = 0; - m_info.depthTestEnable = enableDepthTest; - m_info.depthWriteEnable = enableDepthWrite; - m_info.depthCompareOp = depthCompareOp; - m_info.depthBoundsTestEnable = enableDepthBounds; - m_info.stencilTestEnable = enableStencilTest; - m_info.front = stencilOpFront; - m_info.back = stencilOpBack; - m_info.minDepthBounds = depthBoundsMin; - m_info.maxDepthBounds = depthBoundsMax; - } - - DxvkBlendState::DxvkBlendState( VkBool32 enableLogicOp, VkLogicOp logicOp, diff --git a/src/dxvk/dxvk_constant_state.h b/src/dxvk/dxvk_constant_state.h index ad03bae6..f12d45eb 100644 --- a/src/dxvk/dxvk_constant_state.h +++ b/src/dxvk/dxvk_constant_state.h @@ -15,22 +15,9 @@ namespace dxvk { * whether or not primitive restart * is enabled. */ - class DxvkInputAssemblyState : public RcObject { - - public: - - DxvkInputAssemblyState( - VkPrimitiveTopology primitiveTopology, - VkBool32 primitiveRestart); - - const VkPipelineInputAssemblyStateCreateInfo& info() const { - return m_info; - } - - private: - - VkPipelineInputAssemblyStateCreateInfo m_info; - + struct DxvkInputAssemblyState { + VkPrimitiveTopology primitiveTopology; + VkBool32 primitiveRestart; }; @@ -40,61 +27,30 @@ namespace dxvk { * Stores the operating mode of the * rasterizer, including the depth bias. */ - class DxvkRasterizerState : public RcObject { - - public: - - DxvkRasterizerState( - VkBool32 enableDepthClamp, - VkBool32 enableDiscard, - VkPolygonMode polygonMode, - VkCullModeFlags cullMode, - VkFrontFace frontFace, - VkBool32 depthBiasEnable, - float depthBiasConstant, - float depthBiasClamp, - float depthBiasSlope, - float lineWidth); - - const VkPipelineRasterizationStateCreateInfo& info() const { - return m_info; - } - - private: - - VkPipelineRasterizationStateCreateInfo m_info; - + struct DxvkRasterizerState { + VkBool32 enableDepthClamp; + VkBool32 enableDiscard; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstant; + float depthBiasClamp; + float depthBiasSlope; }; /** * \brief Multisample state * - * Defines details on how to handle - * multisampling, including the alpha - * coverage mode. + * Defines how to handle certain + * aspects of multisampling. */ - class DxvkMultisampleState : public RcObject { - - public: - - DxvkMultisampleState( - VkSampleCountFlagBits sampleCount, - uint32_t sampleMask, - VkBool32 enableAlphaToCoverage, - VkBool32 enableAlphaToOne, - VkBool32 enableSampleShading, - float minSampleShading); - - const VkPipelineMultisampleStateCreateInfo& info() const { - return m_info; - } - - private: - - VkPipelineMultisampleStateCreateInfo m_info; - uint32_t m_mask; - + struct DxvkMultisampleState { + VkBool32 enableAlphaToCoverage; + VkBool32 enableAlphaToOne; + VkBool32 enableSampleShading; + float minSampleShading; }; @@ -104,29 +60,16 @@ namespace dxvk { * Defines the depth test and stencil * operations for the graphics pipeline. */ - class DxvkDepthStencilState : public RcObject { - - public: - - DxvkDepthStencilState( - VkBool32 enableDepthTest, - VkBool32 enableDepthWrite, - VkBool32 enableDepthBounds, - VkBool32 enableStencilTest, - VkCompareOp depthCompareOp, - VkStencilOpState stencilOpFront, - VkStencilOpState stencilOpBack, - float depthBoundsMin, - float depthBoundsMax); - - const VkPipelineDepthStencilStateCreateInfo& info() const { - return m_info; - } - - private: - - VkPipelineDepthStencilStateCreateInfo m_info; - + struct DxvkDepthStencilState { + VkBool32 enableDepthTest; + VkBool32 enableDepthWrite; + VkBool32 enableDepthBounds; + VkBool32 enableStencilTest; + VkCompareOp depthCompareOp; + VkStencilOpState stencilOpFront; + VkStencilOpState stencilOpBack; + float depthBoundsMin; + float depthBoundsMax; }; @@ -200,11 +143,7 @@ namespace dxvk { struct DxvkConstantStateObjects { - Rc inputAssemblyState; Rc inputLayout; - Rc rasterizerState; - Rc multisampleState; - Rc depthStencilState; Rc blendState; }; diff --git a/src/dxvk/dxvk_context.cpp b/src/dxvk/dxvk_context.cpp index 60ca9082..372d5b31 100644 --- a/src/dxvk/dxvk_context.cpp +++ b/src/dxvk/dxvk_context.cpp @@ -6,7 +6,7 @@ namespace dxvk { DxvkContext::DxvkContext(const Rc& device) : m_device(device) { - Logger::info(str::format(sizeof(DxvkGraphicsPipelineStateInfo))); + } @@ -382,11 +382,9 @@ namespace dxvk { void DxvkContext::setInputAssemblyState( - const Rc& state) { - if (m_state.co.inputAssemblyState != state) { - m_state.co.inputAssemblyState = state; - m_flags.set(DxvkContextFlag::GpDirtyPipelineState); - } + const DxvkInputAssemblyState& state) { + m_state.ia = state; + m_flags.set(DxvkContextFlag::GpDirtyPipelineState); } @@ -400,29 +398,23 @@ namespace dxvk { void DxvkContext::setRasterizerState( - const Rc& state) { - if (m_state.co.rasterizerState != state) { - m_state.co.rasterizerState = state; - m_flags.set(DxvkContextFlag::GpDirtyPipelineState); - } + const DxvkRasterizerState& state) { + m_state.rs = state; + m_flags.set(DxvkContextFlag::GpDirtyPipelineState); } void DxvkContext::setMultisampleState( - const Rc& state) { - if (m_state.co.multisampleState != state) { - m_state.co.multisampleState = state; - m_flags.set(DxvkContextFlag::GpDirtyPipelineState); - } + const DxvkMultisampleState& state) { + m_state.ms = state; + m_flags.set(DxvkContextFlag::GpDirtyPipelineState); } void DxvkContext::setDepthStencilState( - const Rc& state) { - if (m_state.co.depthStencilState != state) { - m_state.co.depthStencilState = state; - m_flags.set(DxvkContextFlag::GpDirtyPipelineState); - } + const DxvkDepthStencilState& state) { + m_state.ds = state; + m_flags.set(DxvkContextFlag::GpDirtyPipelineState); } @@ -506,9 +498,8 @@ namespace dxvk { DxvkGraphicsPipelineStateInfo gpState; - const auto& ia = m_state.co.inputAssemblyState->info(); - gpState.iaPrimitiveTopology = ia.topology; - gpState.iaPrimitiveRestart = ia.primitiveRestartEnable; + gpState.iaPrimitiveTopology = m_state.ia.primitiveTopology; + gpState.iaPrimitiveRestart = m_state.ia.primitiveRestart; const auto& il = m_state.co.inputLayout->info(); gpState.ilAttributeCount = il.vertexAttributeDescriptionCount; @@ -522,37 +513,34 @@ namespace dxvk { gpState.ilBindings[i].stride = m_state.vi.vertexStrides.at(i); } - const auto& rs = m_state.co.rasterizerState->info(); - gpState.rsEnableDepthClamp = rs.depthClampEnable; - gpState.rsEnableDiscard = rs.rasterizerDiscardEnable; - gpState.rsPolygonMode = rs.polygonMode; - gpState.rsCullMode = rs.cullMode; - gpState.rsFrontFace = rs.frontFace; - gpState.rsDepthBiasEnable = rs.depthBiasEnable; - gpState.rsDepthBiasConstant = rs.depthBiasConstantFactor; - gpState.rsDepthBiasClamp = rs.depthBiasClamp; - gpState.rsDepthBiasSlope = rs.depthBiasSlopeFactor; + gpState.rsEnableDepthClamp = m_state.rs.enableDepthClamp; + gpState.rsEnableDiscard = m_state.rs.enableDiscard; + gpState.rsPolygonMode = m_state.rs.polygonMode; + gpState.rsCullMode = m_state.rs.cullMode; + gpState.rsFrontFace = m_state.rs.frontFace; + gpState.rsDepthBiasEnable = m_state.rs.depthBiasEnable; + gpState.rsDepthBiasConstant = m_state.rs.depthBiasConstant; + gpState.rsDepthBiasClamp = m_state.rs.depthBiasClamp; + gpState.rsDepthBiasSlope = m_state.rs.depthBiasSlope; gpState.rsViewportCount = m_state.vp.viewportCount; // TODO implement multisampling support properly - const auto& ms = m_state.co.multisampleState->info(); gpState.msSampleCount = VK_SAMPLE_COUNT_1_BIT; - gpState.msSampleMask = *ms.pSampleMask; - gpState.msEnableAlphaToCoverage = ms.alphaToCoverageEnable; - gpState.msEnableAlphaToOne = ms.alphaToOneEnable; - gpState.msEnableSampleShading = ms.sampleShadingEnable; - gpState.msMinSampleShading = ms.minSampleShading; + gpState.msSampleMask = m_state.om.sampleMask; + gpState.msEnableAlphaToCoverage = m_state.ms.enableAlphaToCoverage; + gpState.msEnableAlphaToOne = m_state.ms.enableAlphaToOne; + gpState.msEnableSampleShading = m_state.ms.enableSampleShading; + gpState.msMinSampleShading = m_state.ms.minSampleShading; - const auto& ds = m_state.co.depthStencilState->info(); - gpState.dsEnableDepthTest = ds.depthTestEnable; - gpState.dsEnableDepthWrite = ds.depthWriteEnable; - gpState.dsEnableDepthBounds = ds.depthBoundsTestEnable; - gpState.dsEnableStencilTest = ds.stencilTestEnable; - gpState.dsDepthCompareOp = ds.depthCompareOp; - gpState.dsStencilOpFront = ds.front; - gpState.dsStencilOpBack = ds.back; - gpState.dsDepthBoundsMin = ds.minDepthBounds; - gpState.dsDepthBoundsMax = ds.maxDepthBounds; + gpState.dsEnableDepthTest = m_state.ds.enableDepthTest; + gpState.dsEnableDepthWrite = m_state.ds.enableDepthWrite; + gpState.dsEnableDepthBounds = m_state.ds.enableDepthBounds; + gpState.dsEnableStencilTest = m_state.ds.enableStencilTest; + gpState.dsDepthCompareOp = m_state.ds.depthCompareOp; + gpState.dsStencilOpFront = m_state.ds.stencilOpFront; + gpState.dsStencilOpBack = m_state.ds.stencilOpBack; + gpState.dsDepthBoundsMin = m_state.ds.depthBoundsMin; + gpState.dsDepthBoundsMax = m_state.ds.depthBoundsMax; const auto& om = m_state.co.blendState->info(); gpState.omEnableLogicOp = om.logicOpEnable; diff --git a/src/dxvk/dxvk_context.h b/src/dxvk/dxvk_context.h index 7dac9faf..0d04befa 100644 --- a/src/dxvk/dxvk_context.h +++ b/src/dxvk/dxvk_context.h @@ -267,7 +267,7 @@ namespace dxvk { * \param [in] state New state object */ void setInputAssemblyState( - const Rc& state); + const DxvkInputAssemblyState& state); /** * \brief Sets input layout state @@ -281,21 +281,21 @@ namespace dxvk { * \param [in] state New state object */ void setRasterizerState( - const Rc& state); + const DxvkRasterizerState& state); /** * \brief Sets multisample state * \param [in] state New state object */ void setMultisampleState( - const Rc& state); + const DxvkMultisampleState& state); /** * \brief Sets depth stencil state * \param [in] state New state object */ void setDepthStencilState( - const Rc& state); + const DxvkDepthStencilState& state); /** * \brief Sets color blend state diff --git a/src/dxvk/dxvk_context_state.h b/src/dxvk/dxvk_context_state.h index e493c535..17a93e9c 100644 --- a/src/dxvk/dxvk_context_state.h +++ b/src/dxvk/dxvk_context_state.h @@ -55,6 +55,7 @@ namespace dxvk { struct DxvkOutputMergerState { + uint32_t sampleMask = 0xFFFFFFFFu; Rc framebuffer; }; @@ -88,6 +89,11 @@ namespace dxvk { * and constant pipeline state objects. */ struct DxvkContextState { + DxvkInputAssemblyState ia; + DxvkRasterizerState rs; + DxvkMultisampleState ms; + DxvkDepthStencilState ds; + DxvkVertexInputState vi; DxvkViewportState vp; DxvkOutputMergerState om; diff --git a/tests/dxvk/test_dxvk_triangle.cpp b/tests/dxvk/test_dxvk_triangle.cpp index f7c18071..977f4315 100644 --- a/tests/dxvk/test_dxvk_triangle.cpp +++ b/tests/dxvk/test_dxvk_triangle.cpp @@ -82,31 +82,45 @@ public: })), m_dxvkContext (m_dxvkDevice->createContext()) { - m_dxvkContext->setInputAssemblyState( - new DxvkInputAssemblyState( - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - VK_FALSE)); + DxvkInputAssemblyState iaState; + iaState.primitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + iaState.primitiveRestart = VK_FALSE; + m_dxvkContext->setInputAssemblyState(iaState); + m_dxvkContext->setInputLayout( new DxvkInputLayout(0, nullptr, 0, nullptr)); - m_dxvkContext->setRasterizerState( - new DxvkRasterizerState( - VK_FALSE, VK_FALSE, - VK_POLYGON_MODE_FILL, - VK_CULL_MODE_NONE, - VK_FRONT_FACE_COUNTER_CLOCKWISE, - VK_FALSE, 0.0f, 0.0f, 0.0f, - 1.0f)); - m_dxvkContext->setMultisampleState( - new DxvkMultisampleState( - VK_SAMPLE_COUNT_1_BIT, 0xFFFFFFFF, - VK_FALSE, VK_FALSE, VK_FALSE, 1.0f)); - m_dxvkContext->setDepthStencilState( - new DxvkDepthStencilState( - VK_FALSE, VK_FALSE, VK_FALSE, VK_FALSE, - VK_COMPARE_OP_ALWAYS, - VkStencilOpState(), - VkStencilOpState(), - 0.0f, 1.0f)); + + DxvkRasterizerState rsState; + rsState.enableDepthClamp = VK_FALSE; + rsState.enableDiscard = VK_FALSE; + rsState.polygonMode = VK_POLYGON_MODE_FILL; + rsState.cullMode = VK_CULL_MODE_BACK_BIT; + rsState.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; + rsState.depthBiasEnable = VK_FALSE; + rsState.depthBiasConstant = 0.0f; + rsState.depthBiasClamp = 0.0f; + rsState.depthBiasSlope = 0.0f; + m_dxvkContext->setRasterizerState(rsState); + + DxvkMultisampleState msState; + msState.enableAlphaToCoverage = VK_FALSE; + msState.enableAlphaToOne = VK_FALSE; + msState.enableSampleShading = VK_FALSE; + msState.minSampleShading = 0.0f; + m_dxvkContext->setMultisampleState(msState); + + DxvkDepthStencilState dsState; + dsState.enableDepthTest = VK_FALSE; + dsState.enableDepthWrite = VK_FALSE; + dsState.enableDepthBounds = VK_FALSE; + dsState.enableStencilTest = VK_FALSE; + dsState.depthCompareOp = VK_COMPARE_OP_ALWAYS; + dsState.stencilOpFront = VkStencilOpState(); + dsState.stencilOpBack = VkStencilOpState(); + dsState.depthBoundsMin = 0.0f; + dsState.depthBoundsMax = 1.0f; + m_dxvkContext->setDepthStencilState(dsState); + m_dxvkContext->setBlendState( new DxvkBlendState( VK_FALSE, VK_LOGIC_OP_COPY,