diff --git a/src/d3d11/d3d11_blend.cpp b/src/d3d11/d3d11_blend.cpp
new file mode 100644
index 00000000..a7d6dd65
--- /dev/null
+++ b/src/d3d11/d3d11_blend.cpp
@@ -0,0 +1,126 @@
+#include "d3d11_blend.h"
+#include "d3d11_device.h"
+
+namespace dxvk {
+
+ D3D11BlendState::D3D11BlendState(
+ D3D11Device* device,
+ const D3D11_BLEND_DESC& desc)
+ : m_device(device), m_desc(desc) {
+ // If Independent Blend is disabled, we must ignore the
+ // blend modes for render target 1 to 7. In Vulkan, all
+ // blend modes need to be identical in that case.
+ for (uint32_t i = 0; i < m_blendModes.size(); i++) {
+ m_blendModes.at(i) = DecodeBlendMode(
+ desc.IndependentBlendEnable
+ ? desc.RenderTarget[i]
+ : desc.RenderTarget[0]);
+ }
+
+ // Multisample state is part of the blend state in D3D11
+ m_msState.sampleMask = 0; // Set during bind
+ m_msState.enableAlphaToCoverage = desc.AlphaToCoverageEnable;
+ m_msState.enableAlphaToOne = VK_FALSE;
+ m_msState.enableSampleShading = VK_FALSE;
+ m_msState.minSampleShading = 0.0f;
+ }
+
+
+ D3D11BlendState::~D3D11BlendState() {
+
+ }
+
+
+ HRESULT D3D11BlendState::QueryInterface(REFIID riid, void** ppvObject) {
+ COM_QUERY_IFACE(riid, ppvObject, IUnknown);
+ COM_QUERY_IFACE(riid, ppvObject, ID3D11DeviceChild);
+ COM_QUERY_IFACE(riid, ppvObject, ID3D11BlendState);
+
+ Logger::warn("D3D11BlendState::QueryInterface: Unknown interface query");
+ return E_NOINTERFACE;
+ }
+
+
+ void D3D11BlendState::GetDevice(ID3D11Device** ppDevice) {
+ *ppDevice = ref(m_device);
+ }
+
+
+ void D3D11BlendState::GetDesc(D3D11_BLEND_DESC* pDesc) {
+ *pDesc = m_desc;
+ }
+
+
+ void D3D11BlendState::BindToContext(
+ const Rc<DxvkContext>& ctx,
+ uint32_t sampleMask) const {
+ // We handled Independent Blend during object creation
+ // already, so if it is disabled, all elements in the
+ // blend mode array will be identical
+ for (uint32_t i = 0; i < m_blendModes.size(); i++)
+ ctx->setBlendMode(i, m_blendModes.at(i));
+
+ // The sample mask is dynamic state in D3D11
+ DxvkMultisampleState msState = m_msState;
+ msState.sampleMask = sampleMask;
+ ctx->setMultisampleState(msState);
+ }
+
+
+ DxvkBlendMode D3D11BlendState::DecodeBlendMode(
+ const D3D11_RENDER_TARGET_BLEND_DESC& blendDesc) {
+ DxvkBlendMode mode;
+ mode.enableBlending = blendDesc.BlendEnable;
+ mode.colorSrcFactor = DecodeBlendFactor(blendDesc.SrcBlend, false);
+ mode.colorDstFactor = DecodeBlendFactor(blendDesc.DestBlend, false);
+ mode.colorBlendOp = DecodeBlendOp(blendDesc.BlendOp);
+ mode.alphaSrcFactor = DecodeBlendFactor(blendDesc.SrcBlendAlpha, true);
+ mode.alphaDstFactor = DecodeBlendFactor(blendDesc.DestBlendAlpha, true);
+ mode.alphaBlendOp = DecodeBlendOp(blendDesc.BlendOpAlpha);
+ // TODO find out if D3D11 wants us to apply the write mask if blending
+ // is disabled as well. This is standard behaviour in Vulkan.
+ mode.writeMask = blendDesc.RenderTargetWriteMask;
+ return mode;
+ }
+
+
+ VkBlendFactor D3D11BlendState::DecodeBlendFactor(D3D11_BLEND blendFactor, bool isAlpha) {
+ switch (blendFactor) {
+ case D3D11_BLEND_ZERO: return VK_BLEND_FACTOR_ZERO;
+ case D3D11_BLEND_ONE: return VK_BLEND_FACTOR_ONE;
+ case D3D11_BLEND_SRC_COLOR: return VK_BLEND_FACTOR_SRC_COLOR;
+ case D3D11_BLEND_INV_SRC_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
+ case D3D11_BLEND_SRC_ALPHA: return VK_BLEND_FACTOR_SRC_ALPHA;
+ case D3D11_BLEND_INV_SRC_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+ case D3D11_BLEND_DEST_ALPHA: return VK_BLEND_FACTOR_DST_ALPHA;
+ case D3D11_BLEND_INV_DEST_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
+ case D3D11_BLEND_DEST_COLOR: return VK_BLEND_FACTOR_DST_COLOR;
+ case D3D11_BLEND_INV_DEST_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
+ case D3D11_BLEND_SRC_ALPHA_SAT: return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
+ case D3D11_BLEND_BLEND_FACTOR: return isAlpha ? VK_BLEND_FACTOR_CONSTANT_ALPHA : VK_BLEND_FACTOR_CONSTANT_COLOR;
+ case D3D11_BLEND_INV_BLEND_FACTOR: return isAlpha ? VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA : VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
+ case D3D11_BLEND_SRC1_COLOR: return VK_BLEND_FACTOR_SRC1_COLOR;
+ case D3D11_BLEND_INV_SRC1_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
+ case D3D11_BLEND_SRC1_ALPHA: return VK_BLEND_FACTOR_SRC1_ALPHA;
+ case D3D11_BLEND_INV_SRC1_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
+ }
+
+ Logger::err(str::format("D3D11: Invalid blend factor: ", blendFactor));
+ return VK_BLEND_FACTOR_ZERO;
+ }
+
+
+ VkBlendOp D3D11BlendState::DecodeBlendOp(D3D11_BLEND_OP blendOp) {
+ switch (blendOp) {
+ case D3D11_BLEND_OP_ADD: return VK_BLEND_OP_ADD;
+ case D3D11_BLEND_OP_SUBTRACT: return VK_BLEND_OP_SUBTRACT;
+ case D3D11_BLEND_OP_REV_SUBTRACT: return VK_BLEND_OP_REVERSE_SUBTRACT;
+ case D3D11_BLEND_OP_MIN: return VK_BLEND_OP_MIN;
+ case D3D11_BLEND_OP_MAX: return VK_BLEND_OP_MAX;
+ }
+
+ Logger::err(str::format("D3D11: Invalid blend op: ", blendOp));
+ return VK_BLEND_OP_ADD;
+ }
+
+}
diff --git a/src/d3d11/d3d11_blend.h b/src/d3d11/d3d11_blend.h
new file mode 100644
index 00000000..b8f418c1
--- /dev/null
+++ b/src/d3d11/d3d11_blend.h
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <dxvk_device.h>
+
+#include "d3d11_device_child.h"
+#include "d3d11_util.h"
+
+namespace dxvk {
+
+ class D3D11Device;
+
+ class D3D11BlendState : public D3D11DeviceChild<ID3D11BlendState> {
+
+ public:
+
+ using DescType = D3D11_BLEND_DESC;
+
+ D3D11BlendState(
+ D3D11Device* device,
+ const D3D11_BLEND_DESC& desc);
+ ~D3D11BlendState();
+
+ HRESULT QueryInterface(
+ REFIID riid,
+ void** ppvObject) final;
+
+ void GetDevice(
+ ID3D11Device **ppDevice) final;
+
+ void GetDesc(
+ D3D11_BLEND_DESC* pDesc) final;
+
+ void BindToContext(
+ const Rc<DxvkContext>& ctx,
+ uint32_t sampleMask) const;
+
+ private:
+
+ D3D11Device* const m_device;
+ D3D11_BLEND_DESC m_desc;
+
+ std::array<DxvkBlendMode, 8> m_blendModes;
+ DxvkMultisampleState m_msState;
+
+ static DxvkBlendMode DecodeBlendMode(
+ const D3D11_RENDER_TARGET_BLEND_DESC& blendDesc);
+
+ static VkBlendFactor DecodeBlendFactor(
+ D3D11_BLEND blendFactor,
+ bool isAlpha);
+
+ static VkBlendOp DecodeBlendOp(
+ D3D11_BLEND_OP blendOp);
+
+ };
+
+}
diff --git a/src/d3d11/d3d11_context.cpp b/src/d3d11/d3d11_context.cpp
index afdba50c..5e915e6f 100644
--- a/src/d3d11/d3d11_context.cpp
+++ b/src/d3d11/d3d11_context.cpp
@@ -1559,6 +1559,7 @@ namespace dxvk {
void D3D11DeviceContext::SetDefaultBlendState() {
DxvkMultisampleState msState;
+ msState.sampleMask = 0xffffffff;
msState.enableAlphaToCoverage = VK_FALSE;
msState.enableAlphaToOne = VK_FALSE;
msState.enableSampleShading = VK_FALSE;
@@ -1579,9 +1580,9 @@ namespace dxvk {
blendMode.alphaDstFactor = VK_BLEND_FACTOR_ZERO;
blendMode.alphaBlendOp = VK_BLEND_OP_ADD;
blendMode.writeMask = VK_COLOR_COMPONENT_R_BIT
- | VK_COLOR_COMPONENT_G_BIT
- | VK_COLOR_COMPONENT_B_BIT
- | VK_COLOR_COMPONENT_A_BIT;
+ | VK_COLOR_COMPONENT_G_BIT
+ | VK_COLOR_COMPONENT_B_BIT
+ | VK_COLOR_COMPONENT_A_BIT;
for (uint32_t i = 0; i < DxvkLimits::MaxNumRenderTargets; i++)
m_context->setBlendMode(i, blendMode);
diff --git a/src/d3d11/d3d11_device.cpp b/src/d3d11/d3d11_device.cpp
index c4fe30bf..57fcf69b 100644
--- a/src/d3d11/d3d11_device.cpp
+++ b/src/d3d11/d3d11_device.cpp
@@ -802,8 +802,32 @@ namespace dxvk {
HRESULT D3D11Device::CreateBlendState(
const D3D11_BLEND_DESC* pBlendStateDesc,
ID3D11BlendState** ppBlendState) {
- Logger::err("D3D11Device::CreateBlendState: Not implemented");
- return E_NOTIMPL;
+ D3D11_BLEND_DESC desc;
+
+ if (pBlendStateDesc != nullptr) {
+ desc = *pBlendStateDesc;
+ } else {
+ desc.AlphaToCoverageEnable = FALSE;
+ desc.IndependentBlendEnable = FALSE;
+
+ // 1-7 must be ignored if IndependentBlendEnable is disabled so
+ // technically this is not needed, but since this structure is
+ // going to be copied around we'll initialize it nonetheless
+ for (uint32_t i = 0; i < 8; i++) {
+ desc.RenderTarget[i].BlendEnable = FALSE;
+ desc.RenderTarget[i].SrcBlend = D3D11_BLEND_ONE;
+ desc.RenderTarget[i].DestBlend = D3D11_BLEND_ZERO;
+ desc.RenderTarget[i].BlendOp = D3D11_BLEND_OP_ADD;
+ desc.RenderTarget[i].SrcBlendAlpha = D3D11_BLEND_ONE;
+ desc.RenderTarget[i].DestBlendAlpha = D3D11_BLEND_ZERO;
+ desc.RenderTarget[i].BlendOpAlpha = D3D11_BLEND_OP_ADD;
+ desc.RenderTarget[i].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
+ }
+ }
+
+ if (ppBlendState != nullptr)
+ *ppBlendState = m_bsStateObjects.Create(this, desc);
+ return S_OK;
}
diff --git a/src/d3d11/d3d11_device.h b/src/d3d11/d3d11_device.h
index 39d65baf..c72de8d5 100644
--- a/src/d3d11/d3d11_device.h
+++ b/src/d3d11/d3d11_device.h
@@ -248,6 +248,7 @@ namespace dxvk {
std::mutex m_resourceInitMutex;
Rc<DxvkContext> m_resourceInitContext;
+ D3D11StateObjectSet<D3D11BlendState> m_bsStateObjects;
D3D11StateObjectSet<D3D11DepthStencilState> m_dsStateObjects;
D3D11StateObjectSet<D3D11RasterizerState> m_rsStateObjects;
diff --git a/src/d3d11/d3d11_state.cpp b/src/d3d11/d3d11_state.cpp
index b2d6ea21..4d5f47b2 100644
--- a/src/d3d11/d3d11_state.cpp
+++ b/src/d3d11/d3d11_state.cpp
@@ -2,7 +2,25 @@
namespace dxvk {
- size_t D3D11StateDescHash::operator () (const D3D11_DEPTH_STENCILOP_DESC& desc) const {
+ size_t D3D11StateDescHash::operator () (
+ const D3D11_BLEND_DESC& desc) const {
+ DxvkHashState hash;
+ hash.add(desc.AlphaToCoverageEnable);
+ hash.add(desc.IndependentBlendEnable);
+
+ // Render targets 1 to 7 are ignored and may contain
+ // undefined data if independent blend is disabled
+ const uint32_t usedRenderTargets = desc.IndependentBlendEnable ? 8 : 1;
+
+ for (uint32_t i = 0; i < usedRenderTargets; i++)
+ hash.add(this->operator () (desc.RenderTarget[i]));
+
+ return hash;
+ }
+
+
+ size_t D3D11StateDescHash::operator () (
+ const D3D11_DEPTH_STENCILOP_DESC& desc) const {
DxvkHashState hash;
hash.add(desc.StencilFunc);
hash.add(desc.StencilDepthFailOp);
@@ -12,7 +30,8 @@ namespace dxvk {
}
- size_t D3D11StateDescHash::operator () (const D3D11_DEPTH_STENCIL_DESC& desc) const {
+ size_t D3D11StateDescHash::operator () (
+ const D3D11_DEPTH_STENCIL_DESC& desc) const {
DxvkHashState hash;
hash.add(desc.DepthEnable);
hash.add(desc.DepthWriteMask);
@@ -26,7 +45,8 @@ namespace dxvk {
}
- size_t D3D11StateDescHash::operator () (const D3D11_RASTERIZER_DESC& desc) const {
+ size_t D3D11StateDescHash::operator () (
+ const D3D11_RASTERIZER_DESC& desc) const {
DxvkHashState hash;
hash.add(desc.FillMode);
hash.add(desc.CullMode);
@@ -42,7 +62,41 @@ namespace dxvk {
}
- bool D3D11StateDescEqual::operator () (const D3D11_DEPTH_STENCILOP_DESC& a, const D3D11_DEPTH_STENCILOP_DESC& b) const {
+ size_t D3D11StateDescHash::operator () (
+ const D3D11_RENDER_TARGET_BLEND_DESC& desc) const {
+ DxvkHashState hash;
+ hash.add(desc.BlendEnable);
+ hash.add(desc.SrcBlend);
+ hash.add(desc.DestBlend);
+ hash.add(desc.BlendOp);
+ hash.add(desc.SrcBlendAlpha);
+ hash.add(desc.DestBlendAlpha);
+ hash.add(desc.BlendOpAlpha);
+ hash.add(desc.RenderTargetWriteMask);
+ return hash;
+ }
+
+
+ bool D3D11StateDescEqual::operator () (
+ const D3D11_BLEND_DESC& a,
+ const D3D11_BLEND_DESC& b) const {
+ bool eq = a.AlphaToCoverageEnable == b.AlphaToCoverageEnable
+ && a.IndependentBlendEnable == b.IndependentBlendEnable;
+
+ // Render targets 1 to 7 are ignored and may contain
+ // undefined data if independent blend is disabled
+ const uint32_t usedRenderTargets = a.IndependentBlendEnable ? 8 : 1;
+
+ for (uint32_t i = 0; !eq && (i < usedRenderTargets); i++)
+ eq &= this->operator () (a.RenderTarget[i], b.RenderTarget[i]);
+
+ return eq;
+ }
+
+
+ bool D3D11StateDescEqual::operator () (
+ const D3D11_DEPTH_STENCILOP_DESC& a,
+ const D3D11_DEPTH_STENCILOP_DESC& b) const {
return a.StencilFunc == b.StencilFunc
&& a.StencilDepthFailOp == b.StencilDepthFailOp
&& a.StencilPassOp == b.StencilPassOp
@@ -50,7 +104,9 @@ namespace dxvk {
}
- bool D3D11StateDescEqual::operator () (const D3D11_DEPTH_STENCIL_DESC& a, const D3D11_DEPTH_STENCIL_DESC& b) const {
+ bool D3D11StateDescEqual::operator () (
+ const D3D11_DEPTH_STENCIL_DESC& a,
+ const D3D11_DEPTH_STENCIL_DESC& b) const {
return a.DepthEnable == b.DepthEnable
&& a.DepthWriteMask == b.DepthWriteMask
&& a.DepthFunc == b.DepthFunc
@@ -62,7 +118,9 @@ namespace dxvk {
}
- bool D3D11StateDescEqual::operator () (const D3D11_RASTERIZER_DESC& a, const D3D11_RASTERIZER_DESC& b) const {
+ bool D3D11StateDescEqual::operator () (
+ const D3D11_RASTERIZER_DESC& a,
+ const D3D11_RASTERIZER_DESC& b) const {
return a.FillMode == b.FillMode
&& a.CullMode == b.CullMode
&& a.FrontCounterClockwise == b.FrontCounterClockwise
@@ -75,4 +133,18 @@ namespace dxvk {
&& a.AntialiasedLineEnable == b.AntialiasedLineEnable;
}
+
+ bool D3D11StateDescEqual::operator () (
+ const D3D11_RENDER_TARGET_BLEND_DESC& a,
+ const D3D11_RENDER_TARGET_BLEND_DESC& b) const {
+ return a.BlendEnable == b.BlendEnable
+ && a.SrcBlend == b.SrcBlend
+ && a.DestBlend == b.DestBlend
+ && a.BlendOp == b.BlendOp
+ && a.SrcBlendAlpha == b.SrcBlendAlpha
+ && a.DestBlendAlpha == b.DestBlendAlpha
+ && a.BlendOpAlpha == b.BlendOpAlpha
+ && a.RenderTargetWriteMask == b.RenderTargetWriteMask;
+ }
+
}
\ No newline at end of file
diff --git a/src/d3d11/d3d11_state.h b/src/d3d11/d3d11_state.h
index 3d9b8b34..396302ce 100644
--- a/src/d3d11/d3d11_state.h
+++ b/src/d3d11/d3d11_state.h
@@ -2,6 +2,7 @@
#include <unordered_map>
+#include "d3d11_blend.h"
#include "d3d11_depth_stencil.h"
#include "d3d11_rasterizer.h"
@@ -10,16 +11,20 @@ namespace dxvk {
class D3D11Device;
struct D3D11StateDescHash {
+ size_t operator () (const D3D11_BLEND_DESC& desc) const;
size_t operator () (const D3D11_DEPTH_STENCILOP_DESC& desc) const;
size_t operator () (const D3D11_DEPTH_STENCIL_DESC& desc) const;
size_t operator () (const D3D11_RASTERIZER_DESC& desc) const;
+ size_t operator () (const D3D11_RENDER_TARGET_BLEND_DESC& desc) const;
};
struct D3D11StateDescEqual {
+ bool operator () (const D3D11_BLEND_DESC& a, const D3D11_BLEND_DESC& b) const;
bool operator () (const D3D11_DEPTH_STENCILOP_DESC& a, const D3D11_DEPTH_STENCILOP_DESC& b) const;
bool operator () (const D3D11_DEPTH_STENCIL_DESC& a, const D3D11_DEPTH_STENCIL_DESC& b) const;
bool operator () (const D3D11_RASTERIZER_DESC& a, const D3D11_RASTERIZER_DESC& b) const;
+ bool operator () (const D3D11_RENDER_TARGET_BLEND_DESC& a, const D3D11_RENDER_TARGET_BLEND_DESC& b) const;
};
diff --git a/src/d3d11/meson.build b/src/d3d11/meson.build
index ba991110..1a6d7a78 100644
--- a/src/d3d11/meson.build
+++ b/src/d3d11/meson.build
@@ -1,4 +1,5 @@
d3d11_src = [
+ 'd3d11_blend.cpp',
'd3d11_buffer.cpp',
'd3d11_context.cpp',
'd3d11_depth_stencil.cpp',
diff --git a/src/dxgi/dxgi_presenter.cpp b/src/dxgi/dxgi_presenter.cpp
index ba7295b4..0b569ae5 100644
--- a/src/dxgi/dxgi_presenter.cpp
+++ b/src/dxgi/dxgi_presenter.cpp
@@ -76,6 +76,7 @@ namespace dxvk {
m_context->setRasterizerState(rsState);
DxvkMultisampleState msState;
+ msState.sampleMask = 0xffffffff;
msState.enableAlphaToCoverage = VK_FALSE;
msState.enableAlphaToOne = VK_FALSE;
msState.enableSampleShading = VK_FALSE;
diff --git a/src/dxvk/dxvk_constant_state.h b/src/dxvk/dxvk_constant_state.h
index 7e09949f..5f14c296 100644
--- a/src/dxvk/dxvk_constant_state.h
+++ b/src/dxvk/dxvk_constant_state.h
@@ -47,6 +47,7 @@ namespace dxvk {
* aspects of multisampling.
*/
struct DxvkMultisampleState {
+ uint32_t sampleMask;
VkBool32 enableAlphaToCoverage;
VkBool32 enableAlphaToOne;
VkBool32 enableSampleShading;
diff --git a/src/dxvk/dxvk_context.cpp b/src/dxvk/dxvk_context.cpp
index b61ddec5..915baf04 100644
--- a/src/dxvk/dxvk_context.cpp
+++ b/src/dxvk/dxvk_context.cpp
@@ -702,7 +702,7 @@ namespace dxvk {
// TODO implement multisampling support properly
gpState.msSampleCount = VK_SAMPLE_COUNT_1_BIT;
- gpState.msSampleMask = m_state.om.sampleMask;
+ gpState.msSampleMask = m_state.ms.sampleMask;
gpState.msEnableAlphaToCoverage = m_state.ms.enableAlphaToCoverage;
gpState.msEnableAlphaToOne = m_state.ms.enableAlphaToOne;
gpState.msEnableSampleShading = m_state.ms.enableSampleShading;
diff --git a/src/dxvk/dxvk_context_state.h b/src/dxvk/dxvk_context_state.h
index 7d1d319d..5dc9d48d 100644
--- a/src/dxvk/dxvk_context_state.h
+++ b/src/dxvk/dxvk_context_state.h
@@ -55,7 +55,6 @@ namespace dxvk {
struct DxvkOutputMergerState {
- uint32_t sampleMask = 0xFFFFFFFFu;
Rc<DxvkFramebuffer> framebuffer;
std::array<DxvkBlendMode, DxvkLimits::MaxNumRenderTargets> blendModes;
diff --git a/tests/dxvk/test_dxvk_triangle.cpp b/tests/dxvk/test_dxvk_triangle.cpp
index 44ac11a5..cacbb03d 100644
--- a/tests/dxvk/test_dxvk_triangle.cpp
+++ b/tests/dxvk/test_dxvk_triangle.cpp
@@ -102,6 +102,7 @@ public:
m_dxvkContext->setRasterizerState(rsState);
DxvkMultisampleState msState;
+ msState.sampleMask = 0xffffffff;
msState.enableAlphaToCoverage = VK_FALSE;
msState.enableAlphaToOne = VK_FALSE;
msState.enableSampleShading = VK_FALSE;