backup/xn65
1
0
Fork 0
mirror of https://github.com/borgesdan/xn65 synced 2024-12-29 21:54:47 +01:00
Code Issues Projects Releases Activity

Corrige BlendState

Browse Source
This commit is contained in:
Danilo 2024-05-19 21:22:34 -03:00
parent ffeb668adc
commit eff09301d9
7 changed files with 185 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
framework/platform/blendstate-dx.cpp
View File

@ -1,7 +1,23 @@
#include "platform-dx/blendstate-dx.hpp"
#include "graphics/blendstate.hpp"
#include "graphics/gresource.hpp"
#include "platform-dx/device-dx.hpp"
#include "platform-dx/dxheaders.hpp"
#include "graphics/blendstate.hpp"
#include "platform-dx/implementations.hpp"
namespace xna {
BlendState::BlendState() : GraphicsResource(nullptr) {
impl = uNew<PlatformImplementation>();
}
BlendState::BlendState(sptr<GraphicsDevice> const& device) : GraphicsResource(device) {
impl = uNew<PlatformImplementation>();
}
BlendState::~BlendState() {
impl = nullptr;
}
bool BlendState::Initialize(xna_error_ptr_arg)
{
if (!m_device || !m_device->_device) {
@ -9,12 +25,14 @@ namespace xna {
return false;
}
if (dxBlendState) {
dxBlendState->Release();
dxBlendState = nullptr;
if (impl->dxBlendState) {
impl->dxBlendState->Release();
impl->dxBlendState = nullptr;
}
const auto hr = m_device->_device->CreateBlendState(&dxDescription, &dxBlendState);
const auto hr = m_device->_device->CreateBlendState(
&impl->dxDescription,
&impl->dxBlendState);
if (FAILED(hr)) {
xna_error_apply(err, XnaErrorCode::FAILED_OPERATION);
@ -30,52 +48,76 @@ namespace xna {
return false;
}
if (!dxBlendState) {
if (!impl->dxBlendState) {
xna_error_apply(err, XnaErrorCode::UNINTIALIZED_RESOURCE);
return false;
}
m_device->_context->OMSetBlendState(dxBlendState, blendFactor, sampleMask);
m_device->_context->OMSetBlendState(
impl->dxBlendState,
impl->blendFactor,
impl->sampleMask);
return true;
}
void BlendState::AlphaToCoverageEnable(bool value) {
impl->dxDescription.AlphaToCoverageEnable = value;
}
void BlendState::IndependentBlendEnable(bool value) {
impl->dxDescription.IndependentBlendEnable = value;
}
void BlendState::RenderTargets(std::vector<BlendRenderTarget> const& value) {
for (size_t i = 0; i < value.size() && i < 8; ++i) {
impl->dxDescription.RenderTarget[i].BlendEnable = value[i].Enabled;
impl->dxDescription.RenderTarget[i].SrcBlend = PlatformImplementation::ConvertBlend(value[i].Source);
impl->dxDescription.RenderTarget[i].DestBlend = PlatformImplementation::ConvertBlend(value[i].Destination);
impl->dxDescription.RenderTarget[i].BlendOp = PlatformImplementation::ConvertOperation(value[i].Operation);
impl->dxDescription.RenderTarget[i].SrcBlendAlpha = PlatformImplementation::ConvertBlend(value[i].SourceAlpha);
impl->dxDescription.RenderTarget[i].DestBlendAlpha = PlatformImplementation::ConvertBlend(value[i].DestinationAlpha);
impl->dxDescription.RenderTarget[i].BlendOpAlpha = PlatformImplementation::ConvertOperation(value[i].OperationAlpha);
impl->dxDescription.RenderTarget[i].RenderTargetWriteMask = PlatformImplementation::ConvertColorWrite(value[i].WriteMask);
}
}
uptr<BlendState> BlendState::Opaque() {
auto blendState = std::unique_ptr<BlendState>(new BlendState());
blendState->dxDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendState->dxDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ZERO;
blendState->dxDescription.RenderTarget[0].DestBlend = D3D11_BLEND_DEST_ALPHA;
blendState->dxDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
auto blendState = uNew<BlendState>();
blendState->impl->dxDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendState->impl->dxDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ZERO;
blendState->impl->dxDescription.RenderTarget[0].DestBlend = D3D11_BLEND_DEST_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
return blendState;
}
uptr<BlendState> BlendState::AlphaBlend() {
auto blendState = std::unique_ptr<BlendState>(new BlendState());
blendState->dxDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendState->dxDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendState->dxDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendState->dxDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blendState->impl->dxDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendState->impl->dxDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
return blendState;
}
uptr<BlendState> BlendState::Additive() {
auto blendState = std::unique_ptr<BlendState>(new BlendState());
blendState->dxDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendState->dxDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blendState->dxDescription.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;
blendState->dxDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ONE;
blendState->impl->dxDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;
blendState->impl->dxDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ONE;
return blendState;
}
uptr<BlendState> BlendState::NonPremultiplied() {
auto blendState = std::unique_ptr<BlendState>(new BlendState());
blendState->dxDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendState->dxDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blendState->dxDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendState->dxDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendState->impl->dxDescription.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
return blendState;
}

14
framework/platform/device-dx.cpp
View File

@ -1,13 +1,13 @@
#include "platform-dx/device-dx.hpp"
#include "platform-dx/window-dx.hpp"
#include "platform-dx/swapchain-dx.hpp"
#include "platform-dx/rendertarget-dx.hpp"
#include "platform-dx/blendstate-dx.hpp"
#include "platform-dx/gdeviceinfo-dx.hpp"
#include "common/color.hpp"
#include "platform-dx/gdevicemanager-dx.hpp"
#include "graphics/adapter.hpp"
#include "graphics/blendstate.hpp"
#include "platform-dx/device-dx.hpp"
#include "platform-dx/gdeviceinfo-dx.hpp"
#include "platform-dx/gdevicemanager-dx.hpp"
#include "platform-dx/implementations.hpp"
#include "platform-dx/rendertarget-dx.hpp"
#include "platform-dx/swapchain-dx.hpp"
#include "platform-dx/window-dx.hpp"
namespace xna {
GraphicsDevice::GraphicsDevice() {

4
framework/platform/sprite-dx.cpp
View File

@ -1,4 +1,3 @@
#include "platform-dx/blendstate-dx.hpp"
#include "platform-dx/device-dx.hpp"
#include "platform-dx/rasterizerstate-dx.hpp"
#include "platform-dx/depthstencilstate-dx.hpp"
@ -8,6 +7,7 @@
#include "common/numerics.hpp"
#include "graphics/sprite.hpp"
#include "graphics/viewport.hpp"
#include "graphics/blendstate.hpp"
#include "platform-dx/implementations.hpp"
using DxSpriteBatch = DirectX::SpriteBatch;
@ -78,7 +78,7 @@ namespace xna {
implementation->_dxspriteBatch->Begin(
sort,
blendState ? blendState->dxBlendState : nullptr,
blendState ? blendState->impl->dxBlendState : nullptr,
samplerState ? samplerState->_samplerState : nullptr,
depthStencil ? depthStencil->dxDepthStencil : nullptr,
rasterizerState ? rasterizerState->dxRasterizerState : nullptr,

25
inc/graphics/blendstate.hpp
View File

@ -2,19 +2,30 @@
#define XNA_GRAPHICS_BLENDSTATE_HPP
#include "../default.hpp"
#include "gresource.hpp"
namespace xna {
struct BlendRenderTarget;
class IBlendState {
class BlendState : public GraphicsResource {
public:
virtual ~IBlendState() {}
virtual bool Initialize(xna_error_nullarg) = 0;
virtual void AlphaToCoverageEnable(bool value) = 0;
virtual void IndependentBlendEnable(bool value) = 0;
virtual void RenderTargets(std::vector<BlendRenderTarget> const& value) = 0;
BlendState();
BlendState(sptr<GraphicsDevice> const& device);
~BlendState();
bool Initialize(xna_error_nullarg) ;
void AlphaToCoverageEnable(bool value) ;
void IndependentBlendEnable(bool value) ;
void RenderTargets(std::vector<BlendRenderTarget> const& value);
bool Apply(xna_error_nullarg);
virtual bool Apply(xna_error_nullarg) = 0;
static uptr<BlendState> Opaque();
static uptr<BlendState> AlphaBlend();
static uptr<BlendState> Additive();
static uptr<BlendState> NonPremultiplied();
public:
struct PlatformImplementation;
uptr<PlatformImplementation> impl = nullptr;
};
}

138
inc/platform-dx/blendstate-dx.hpp
View File

@ -1,138 +0,0 @@
#ifndef XNA_PLATFORM_BLENDSTATE_HPP
#define XNA_PLATFORM_BLENDSTATE_HPP
#include "../graphics/blendstate.hpp"
#include "../graphics/gresource.hpp"
#include "dxheaders.hpp"
namespace xna {
struct BlendRenderTarget {
bool Enabled{ true };
Blend Source{ Blend::SourceAlpha };
Blend Destination{ Blend::InverseSourceAlpha };
BlendOperation Operation{ BlendOperation::Add };
Blend SourceAlpha{ Blend::One };
Blend DestinationAlpha{ Blend::Zero };
BlendOperation OperationAlpha{ BlendOperation::Add };
ColorWriteChannels WriteMask{ ColorWriteChannels::All };
constexpr BlendRenderTarget() = default;
};
class BlendState : public IBlendState, public GraphicsResource {
public:
BlendState(sptr<GraphicsDevice> const& device) : GraphicsResource(device) {};
virtual ~BlendState() override {
if (dxBlendState) {
dxBlendState->Release();
dxBlendState = nullptr;
}
}
virtual bool Initialize(xna_error_nullarg) override;
virtual constexpr void AlphaToCoverageEnable(bool value) override {
dxDescription.AlphaToCoverageEnable = value;
}
virtual constexpr void IndependentBlendEnable(bool value) override {
dxDescription.IndependentBlendEnable = value;
}
virtual void RenderTargets(std::vector<BlendRenderTarget> const& value) override {
for (size_t i = 0; i < value.size() && i < 8; ++i) {
dxDescription.RenderTarget[i].BlendEnable = value[i].Enabled;
dxDescription.RenderTarget[i].SrcBlend = ConvertBlend(value[i].Source);
dxDescription.RenderTarget[i].DestBlend = ConvertBlend(value[i].Destination);
dxDescription.RenderTarget[i].BlendOp = ConvertOperation(value[i].Operation);
dxDescription.RenderTarget[i].SrcBlendAlpha = ConvertBlend(value[i].SourceAlpha);
dxDescription.RenderTarget[i].DestBlendAlpha = ConvertBlend(value[i].DestinationAlpha);
dxDescription.RenderTarget[i].BlendOpAlpha = ConvertOperation(value[i].OperationAlpha);
dxDescription.RenderTarget[i].RenderTargetWriteMask = ConvertColorWrite(value[i].WriteMask);
}
}
virtual bool Apply(xna_error_nullarg) override;
static uptr<BlendState> Opaque();
static uptr<BlendState> AlphaBlend();
static uptr<BlendState> Additive();
static uptr<BlendState> NonPremultiplied();
public:
ID3D11BlendState* dxBlendState{ nullptr };
D3D11_BLEND_DESC dxDescription{};
float blendFactor[4] { 1.0F, 1.0F, 1.0F, 1.0F };
UINT sampleMask{ 0xffffffff };
private:
BlendState() : GraphicsResource(nullptr){}
public:
static constexpr D3D11_BLEND ConvertBlend(Blend blend) {
switch (blend)
{
case xna::Blend::Zero:
return D3D11_BLEND_ZERO;
case xna::Blend::One:
return D3D11_BLEND_ONE;
case xna::Blend::SourceColor:
return D3D11_BLEND_SRC_COLOR;
case xna::Blend::InverseSourceColor:
return D3D11_BLEND_INV_SRC_COLOR;
case xna::Blend::SourceAlpha:
return D3D11_BLEND_SRC_ALPHA;
case xna::Blend::InverseSourceAlpha:
return D3D11_BLEND_INV_SRC_ALPHA;
case xna::Blend::DestinationAlpha:
return D3D11_BLEND_DEST_ALPHA;
case xna::Blend::InverseDestinationAlpha:
return D3D11_BLEND_INV_DEST_ALPHA;
case xna::Blend::DestinationColor:
return D3D11_BLEND_DEST_COLOR;
case xna::Blend::InverseDestinationColor:
return D3D11_BLEND_INV_DEST_COLOR;
case xna::Blend::SourceAlphaSaturation:
return D3D11_BLEND_SRC_ALPHA_SAT;
case xna::Blend::BlendFactor:
return D3D11_BLEND_BLEND_FACTOR;
case xna::Blend::InverseBlendFactor:
return D3D11_BLEND_INV_BLEND_FACTOR;
case xna::Blend::Source1Color:
return D3D11_BLEND_SRC1_COLOR;
case xna::Blend::InverseSource1Color:
return D3D11_BLEND_INV_SRC1_COLOR;
case xna::Blend::Source1Alpha:
return D3D11_BLEND_SRC1_ALPHA;
case xna::Blend::InverseSource1Alpha:
return D3D11_BLEND_INV_SRC1_ALPHA;
default:
return D3D11_BLEND_ZERO;
}
}
static constexpr D3D11_BLEND_OP ConvertOperation(BlendOperation op) {
return static_cast<D3D11_BLEND_OP>(static_cast<int>(op) + 1);
}
static constexpr D3D11_COLOR_WRITE_ENABLE ConvertColorWrite(ColorWriteChannels colorWrite) {
switch (colorWrite)
{
case xna::ColorWriteChannels::Red:
return D3D11_COLOR_WRITE_ENABLE_RED;
case xna::ColorWriteChannels::Green:
return D3D11_COLOR_WRITE_ENABLE_GREEN;
case xna::ColorWriteChannels::Blue:
return D3D11_COLOR_WRITE_ENABLE_BLUE;
case xna::ColorWriteChannels::Alpha:
return D3D11_COLOR_WRITE_ENABLE_ALPHA;
case xna::ColorWriteChannels::All:
return D3D11_COLOR_WRITE_ENABLE_ALL;
default:
return D3D11_COLOR_WRITE_ENABLE_ALL;
}
}
};
}
#endif

93
inc/platform-dx/implementations.hpp
View File

@ -5,7 +5,7 @@
#include "dxheaders.hpp"
#include "platform-dx/swapchain-dx.hpp"
#include "platform-dx/rendertarget-dx.hpp"
#include "platform-dx/blendstate-dx.hpp"
#include "graphics/blendstate.hpp"
namespace xna {
struct SpriteFont::PlatformImplementation {
@ -127,4 +127,95 @@ namespace xna {
}
}
};
struct BlendRenderTarget {
bool Enabled{ true };
Blend Source{ Blend::SourceAlpha };
Blend Destination{ Blend::InverseSourceAlpha };
BlendOperation Operation{ BlendOperation::Add };
Blend SourceAlpha{ Blend::One };
Blend DestinationAlpha{ Blend::Zero };
BlendOperation OperationAlpha{ BlendOperation::Add };
ColorWriteChannels WriteMask{ ColorWriteChannels::All };
constexpr BlendRenderTarget() = default;
};
struct BlendState::PlatformImplementation {
~PlatformImplementation() {
if (dxBlendState) {
dxBlendState->Release();
dxBlendState = nullptr;
}
}
ID3D11BlendState* dxBlendState = nullptr;
D3D11_BLEND_DESC dxDescription{};
float blendFactor[4]{ 1.0F, 1.0F, 1.0F, 1.0F };
UINT sampleMask{ 0xffffffff };
static constexpr D3D11_BLEND ConvertBlend(Blend blend) {
switch (blend)
{
case xna::Blend::Zero:
return D3D11_BLEND_ZERO;
case xna::Blend::One:
return D3D11_BLEND_ONE;
case xna::Blend::SourceColor:
return D3D11_BLEND_SRC_COLOR;
case xna::Blend::InverseSourceColor:
return D3D11_BLEND_INV_SRC_COLOR;
case xna::Blend::SourceAlpha:
return D3D11_BLEND_SRC_ALPHA;
case xna::Blend::InverseSourceAlpha:
return D3D11_BLEND_INV_SRC_ALPHA;
case xna::Blend::DestinationAlpha:
return D3D11_BLEND_DEST_ALPHA;
case xna::Blend::InverseDestinationAlpha:
return D3D11_BLEND_INV_DEST_ALPHA;
case xna::Blend::DestinationColor:
return D3D11_BLEND_DEST_COLOR;
case xna::Blend::InverseDestinationColor:
return D3D11_BLEND_INV_DEST_COLOR;
case xna::Blend::SourceAlphaSaturation:
return D3D11_BLEND_SRC_ALPHA_SAT;
case xna::Blend::BlendFactor:
return D3D11_BLEND_BLEND_FACTOR;
case xna::Blend::InverseBlendFactor:
return D3D11_BLEND_INV_BLEND_FACTOR;
case xna::Blend::Source1Color:
return D3D11_BLEND_SRC1_COLOR;
case xna::Blend::InverseSource1Color:
return D3D11_BLEND_INV_SRC1_COLOR;
case xna::Blend::Source1Alpha:
return D3D11_BLEND_SRC1_ALPHA;
case xna::Blend::InverseSource1Alpha:
return D3D11_BLEND_INV_SRC1_ALPHA;
default:
return D3D11_BLEND_ZERO;
}
}
static constexpr D3D11_BLEND_OP ConvertOperation(BlendOperation op) {
return static_cast<D3D11_BLEND_OP>(static_cast<int>(op) + 1);
}
static constexpr D3D11_COLOR_WRITE_ENABLE ConvertColorWrite(ColorWriteChannels colorWrite) {
switch (colorWrite)
{
case xna::ColorWriteChannels::Red:
return D3D11_COLOR_WRITE_ENABLE_RED;
case xna::ColorWriteChannels::Green:
return D3D11_COLOR_WRITE_ENABLE_GREEN;
case xna::ColorWriteChannels::Blue:
return D3D11_COLOR_WRITE_ENABLE_BLUE;
case xna::ColorWriteChannels::Alpha:
return D3D11_COLOR_WRITE_ENABLE_ALPHA;
case xna::ColorWriteChannels::All:
return D3D11_COLOR_WRITE_ENABLE_ALL;
default:
return D3D11_COLOR_WRITE_ENABLE_ALL;
}
}
};
}

1
inc/platform-dx/xna-dx.hpp
View File

@ -1,5 +1,4 @@
#include "audioengine-dx.hpp"
#include "blendstate-dx.hpp"
#include "clock-dx.hpp"
#include "constbuffer-dx.hpp"
#include "databuffer-dx.hpp"