rooty/dxvk
1
0
Fork 0
mirror of https://github.com/doitsujin/dxvk.git synced 2025-03-14 04:29:15 +01:00
Code Issues Projects Releases Wiki Activity

[dxvk] Refactoring of most constant state objects

Browse Source
This commit is contained in:
Philip Rebohle 2017-12-08 00:02:43 +01:00
parent 796c200e32
commit 385c92db5a
11 changed files with 218 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
src/d3d11/d3d11_context.cpp
View File

@ -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<DxvkInputAssemblyState> 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:

10
src/d3d11/d3d11_context.h
View File

@ -544,12 +544,12 @@ namespace dxvk {
const D3D11_DEVICE_CONTEXT_TYPE m_type = D3D11_DEVICE_CONTEXT_IMMEDIATE;
const UINT m_flags = 0;
Rc<DxvkDevice> m_device;
Rc<DxvkContext> m_context;
Rc<DxvkDevice> m_device;
Rc<DxvkContext> m_context;
Rc<DxvkRasterizerState> m_defaultRsState;
Rc<DxvkDepthStencilState> m_defaultDsState;
Rc<DxvkMultisampleState> m_defaultMsState;
DxvkRasterizerState m_defaultRsState;
DxvkDepthStencilState m_defaultDsState;
DxvkMultisampleState m_defaultMsState;
Rc<DxvkBlendState> m_defaultCbState;
D3D11ContextState m_state;

38
src/d3d11/d3d11_state_rs.cpp
View File

@ -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<float>(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);
}

4
src/d3d11/d3d11_state_rs.h
View File

@ -29,7 +29,7 @@ namespace dxvk {
void GetDesc(
D3D11_RASTERIZER_DESC* pDesc) final;
Rc<DxvkRasterizerState> GetDXVKRasterizerState() {
const DxvkRasterizerState& GetDXVKRasterizerState() const {
return m_state;
}
@ -37,7 +37,7 @@ namespace dxvk {
D3D11Device* const m_device;
D3D11_RASTERIZER_DESC m_desc;
Rc<DxvkRasterizerState> m_state;
DxvkRasterizerState m_state;
};

51
src/dxgi/dxgi_presenter.cpp
View File

@ -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;

84
src/dxvk/dxvk_constant_state.cpp
View File

@ -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,

121
src/dxvk/dxvk_constant_state.h
View File

@ -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<DxvkInputAssemblyState> inputAssemblyState;
Rc<DxvkInputLayout> inputLayout;
Rc<DxvkRasterizerState> rasterizerState;
Rc<DxvkMultisampleState> multisampleState;
Rc<DxvkDepthStencilState> depthStencilState;
Rc<DxvkBlendState> blendState;
};

88
src/dxvk/dxvk_context.cpp
View File

@ -6,7 +6,7 @@ namespace dxvk {
DxvkContext::DxvkContext(const Rc<DxvkDevice>& device)
: m_device(device) {
Logger::info(str::format(sizeof(DxvkGraphicsPipelineStateInfo)));
}
@ -382,11 +382,9 @@ namespace dxvk {
void DxvkContext::setInputAssemblyState(
const Rc<DxvkInputAssemblyState>& 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<DxvkRasterizerState>& 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<DxvkMultisampleState>& 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<DxvkDepthStencilState>& 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;

8
src/dxvk/dxvk_context.h
View File

@ -267,7 +267,7 @@ namespace dxvk {
* \param [in] state New state object
*/
void setInputAssemblyState(
const Rc<DxvkInputAssemblyState>& 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<DxvkRasterizerState>& state);
const DxvkRasterizerState& state);
/**
* \brief Sets multisample state
* \param [in] state New state object
*/
void setMultisampleState(
const Rc<DxvkMultisampleState>& state);
const DxvkMultisampleState& state);
/**
* \brief Sets depth stencil state
* \param [in] state New state object
*/
void setDepthStencilState(
const Rc<DxvkDepthStencilState>& state);
const DxvkDepthStencilState& state);
/**
* \brief Sets color blend state

6
src/dxvk/dxvk_context_state.h
View File

@ -55,6 +55,7 @@ namespace dxvk {
struct DxvkOutputMergerState {
uint32_t sampleMask = 0xFFFFFFFFu;
Rc<DxvkFramebuffer> 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;

60
tests/dxvk/test_dxvk_triangle.cpp
View File

@ -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,