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

Adiciona PlatformImplementation em SpriteBatch e SpriteFont

Browse Source
This commit is contained in:
Danilo 2024-11-15 14:15:35 -03:00
parent 5ea175273c
commit 1ba86817ec
5 changed files with 118 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
includes/xna-dx/implementations.hpp
View File

@ -54,15 +54,15 @@ namespace xna {
UINT vSyncValue = 1; UINT vSyncValue = 1;
}; };
struct SpriteFont::PlatformImplementation { struct SpriteBatchImplementation {
uptr<DirectX::SpriteFont> dxSpriteFont{ nullptr }; std::shared_ptr<DirectX::SpriteBatch> SpriteBatch;
comptr<ID3D11InputLayout> InputLayout;
std::shared_ptr<DirectX::DX11::IEffect> EffectBuffer;
}; };
struct SpriteBatch::PlatformImplementation { struct SpriteFontImplementation {
sptr<DirectX::SpriteBatch> dxSpriteBatch = nullptr; std::unique_ptr<DirectX::SpriteFont> SpriteFont;
comptr<ID3D11InputLayout> dxInputLayout = nullptr; };
sptr<DirectX::DX11::IEffect> dxEffectBuffer = nullptr;
};
struct GamePad::PlatformImplementation { struct GamePad::PlatformImplementation {
uptr<DirectX::GamePad> _dxGamePad = unew<DirectX::GamePad>(); uptr<DirectX::GamePad> _dxGamePad = unew<DirectX::GamePad>();

1
includes/xna/content/readers/graphics.hpp
View File

@ -42,6 +42,7 @@ namespace xna {
} }
}; };
using PSpriteFont = std::shared_ptr<SpriteFont>;
class SpriteFontReader : public ContentTypeReaderT<PSpriteFont> { class SpriteFontReader : public ContentTypeReaderT<PSpriteFont> {
public: public:
SpriteFontReader() : ContentTypeReaderT(typeof<PSpriteFont>()) { SpriteFontReader() : ContentTypeReaderT(typeof<PSpriteFont>()) {

10
includes/xna/enumerations.hpp
View File

@ -143,15 +143,7 @@ namespace xna {
FlipVertically = 2, FlipVertically = 2,
Both = FlipHorizontally | FlipVertically Both = FlipHorizontally | FlipVertically
}; };
enum class SpriteSortMode
{
Deferred,
Immediate,
Texture,
BackToFront,
FrontToBack,
};
enum class TextureAddressMode { enum class TextureAddressMode {
Wrap, Wrap,

140
includes/xna/graphics/sprite.hpp
View File

@ -3,56 +3,82 @@
#include "../common/color.hpp" #include "../common/color.hpp"
#include "../common/numerics.hpp" #include "../common/numerics.hpp"
#include "../default.hpp"
#include "../graphics/gresource.hpp" #include "../graphics/gresource.hpp"
#include "../platform.hpp"
#include <memory>
#include <optional>
#include <string>
namespace xna { namespace xna {
//Defines sprite sort-rendering options.
enum class SpriteSortMode
{
//Sprites are not drawn until End is called.
//End will apply graphics device settings and draw all the sprites in one batch, in the same order calls to Draw were received.
//This mode allows Draw calls to two or more instances of SpriteBatch without introducing conflicting graphics device settings.
//SpriteBatch defaults to Deferred mode.
Deferred,
//Begin will apply new graphics device settings, and sprites will be drawn within each Draw call.
//In Immediate mode there can only be one active SpriteBatch instance without introducing conflicting device settings.
Immediate,
//Same as Deferred mode, except sprites are sorted by texture prior to drawing.
//This can improve performance when drawing non-overlapping sprites of uniform depth.
Texture,
//Same as Deferred mode, except sprites are sorted by depth in back-to-front order prior to drawing.
//This procedure is recommended when drawing transparent sprites of varying depths.
BackToFront,
//Same as Deferred mode, except sprites are sorted by depth in front-to-back order prior to drawing.
//This procedure is recommended when drawing opaque sprites of varying depths.
FrontToBack,
};
struct SpriteBatchImplementation;
//Enables a group of sprites to be drawn using the same settings. //Enables a group of sprites to be drawn using the same settings.
class SpriteBatch : public GraphicsResource { class SpriteBatch : public GraphicsResource, public PlatformImplementation<SpriteBatchImplementation> {
public: public:
SpriteBatch(sptr<GraphicsDevice> const& device); SpriteBatch(std::shared_ptr<GraphicsDevice> const& device);
//Begins a sprite batch operation. //Begins a sprite batch operation.
void Begin( void Begin(
std::optional<SpriteSortMode> sortMode, std::optional<SpriteSortMode> sortMode,
uptr<BlendState> blendState, std::unique_ptr<BlendState> blendState,
uptr<SamplerState> samplerState, std::unique_ptr<SamplerState> samplerState,
uptr<DepthStencilState> depthStencil, std::unique_ptr<DepthStencilState> depthStencil,
uptr<RasterizerState> rasterizerState, std::unique_ptr<RasterizerState> rasterizerState,
uptr<Effect> effect, std::unique_ptr<Effect> effect,
Matrix const& transformMatrix = Matrix::Identity() Matrix const& transformMatrix = Matrix::Identity())
) { {
Begin( Begin(
!sortMode.has_value() ? SpriteSortMode::Deferred : sortMode.value(), sortMode.has_value() ? sortMode.value() : SpriteSortMode::Deferred,
blendState.get(), blendState.get(),
samplerState.get(), samplerState.get(),
depthStencil.get(), depthStencil.get(),
rasterizerState.get(), rasterizerState.get(),
effect.get(), effect.get(),
transformMatrix transformMatrix);
);
} }
//Begins a sprite batch operation.
void Begin( void Begin(
std::optional<SpriteSortMode> sortMode, std::optional<SpriteSortMode> sortMode,
sptr<BlendState> blendState, std::shared_ptr<BlendState> blendState,
sptr<SamplerState> samplerState, std::shared_ptr<SamplerState> samplerState,
sptr<DepthStencilState> depthStencil, std::shared_ptr<DepthStencilState> depthStencil,
sptr<RasterizerState> rasterizerState, std::shared_ptr<RasterizerState> rasterizerState,
sptr<Effect> effect, std::shared_ptr<Effect> effect,
Matrix const& transformMatrix = Matrix::Identity() Matrix const& transformMatrix = Matrix::Identity()) {
) {
Begin( Begin(
!sortMode.has_value() ? SpriteSortMode::Deferred : sortMode.value(), sortMode.has_value() ? sortMode.value() : SpriteSortMode::Deferred,
blendState.get(), blendState.get(),
samplerState.get(), samplerState.get(),
depthStencil.get(), depthStencil.get(),
rasterizerState.get(), rasterizerState.get(),
effect.get(), effect.get(),
transformMatrix transformMatrix);
);
} }
//Begins a sprite batch operation.
void Begin( void Begin(
SpriteSortMode sortMode = SpriteSortMode::Deferred, SpriteSortMode sortMode = SpriteSortMode::Deferred,
BlendState* blendState = nullptr, BlendState* blendState = nullptr,
@ -70,39 +96,39 @@ namespace xna {
// Draw - Adds a sprite to a batch of sprites to be rendered. // Draw - Adds a sprite to a batch of sprites to be rendered.
// //
void Draw(uptr<Texture2D> const& texture, Vector2 const& position, Color const& color) { Draw(*texture, position, color); } void Draw(std::unique_ptr<Texture2D> const& texture, Vector2 const& position, Color const& color) { Draw(*texture, position, color); }
void Draw(sptr<Texture2D> const& texture, Vector2 const& position, Color const& color) { Draw(*texture, position, color); } void Draw(std::shared_ptr<Texture2D> const& texture, Vector2 const& position, Color const& color) { Draw(*texture, position, color); }
void Draw(Texture2D& texture, Vector2 const& position, Color const& color); void Draw(Texture2D& texture, Vector2 const& position, Color const& color);
void Draw(uptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color) { Draw(*texture, position, sourceRectangle, color); } void Draw(std::unique_ptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color) { Draw(*texture, position, sourceRectangle, color); }
void Draw(sptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color) { Draw(*texture, position, sourceRectangle, color); } void Draw(std::shared_ptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color) { Draw(*texture, position, sourceRectangle, color); }
void Draw(Texture2D& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color); void Draw(Texture2D& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color);
void Draw(uptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(std::unique_ptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth) { Draw(*texture, position, sourceRectangle, color, rotation, origin, scale, effects, layerDepth); } float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth) { Draw(*texture, position, sourceRectangle, color, rotation, origin, scale, effects, layerDepth); }
void Draw(sptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(std::shared_ptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth) { Draw(*texture, position, sourceRectangle, color, rotation, origin, scale, effects, layerDepth); } float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth) { Draw(*texture, position, sourceRectangle, color, rotation, origin, scale, effects, layerDepth); }
void Draw(Texture2D& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(Texture2D& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth); float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth);
void Draw(uptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(std::unique_ptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, Vector2 const& scale, SpriteEffects effects, float layerDepth) { Draw(*texture, position, sourceRectangle, color, rotation, origin, scale, effects, layerDepth); } float rotation, Vector2 const& origin, Vector2 const& scale, SpriteEffects effects, float layerDepth) { Draw(*texture, position, sourceRectangle, color, rotation, origin, scale, effects, layerDepth); }
void Draw(sptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(std::shared_ptr<Texture2D> const& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, Vector2 const& scale, SpriteEffects effects, float layerDepth) { Draw(*texture, position, sourceRectangle, color, rotation, origin, scale, effects, layerDepth); } float rotation, Vector2 const& origin, Vector2 const& scale, SpriteEffects effects, float layerDepth) { Draw(*texture, position, sourceRectangle, color, rotation, origin, scale, effects, layerDepth); }
void Draw(Texture2D& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(Texture2D& texture, Vector2 const& position, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, Vector2 const& scale, SpriteEffects effects, float layerDepth); float rotation, Vector2 const& origin, Vector2 const& scale, SpriteEffects effects, float layerDepth);
void Draw(uptr<Texture2D> const& texture, Rectangle const& destinationRectangle, Color const& color) { Draw(*texture, destinationRectangle, color); } void Draw(std::unique_ptr<Texture2D> const& texture, Rectangle const& destinationRectangle, Color const& color) { Draw(*texture, destinationRectangle, color); }
void Draw(sptr<Texture2D> const& texture, Rectangle const& destinationRectangle, Color const& color) { Draw(*texture, destinationRectangle, color); } void Draw(std::shared_ptr<Texture2D> const& texture, Rectangle const& destinationRectangle, Color const& color) { Draw(*texture, destinationRectangle, color); }
void Draw(Texture2D& texture, Rectangle const& destinationRectangle, Color const& color); void Draw(Texture2D& texture, Rectangle const& destinationRectangle, Color const& color);
void Draw(uptr<Texture2D> const& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color) { Draw(*texture, destinationRectangle, sourceRectangle, color); } void Draw(std::unique_ptr<Texture2D> const& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color) { Draw(*texture, destinationRectangle, sourceRectangle, color); }
void Draw(sptr<Texture2D> const& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color) { Draw(*texture, destinationRectangle, sourceRectangle, color); } void Draw(std::shared_ptr<Texture2D> const& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color) { Draw(*texture, destinationRectangle, sourceRectangle, color); }
void Draw(Texture2D& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color); void Draw(Texture2D& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color);
void Draw(uptr<Texture2D> const& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(std::unique_ptr<Texture2D> const& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, SpriteEffects effects, float layerDepth) { Draw(*texture, destinationRectangle, sourceRectangle, color, rotation, origin, effects, layerDepth); } float rotation, Vector2 const& origin, SpriteEffects effects, float layerDepth) { Draw(*texture, destinationRectangle, sourceRectangle, color, rotation, origin, effects, layerDepth); }
void Draw(sptr<Texture2D> const& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(std::shared_ptr<Texture2D> const& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, SpriteEffects effects, float layerDepth) { Draw(*texture, destinationRectangle, sourceRectangle, color, rotation, origin, effects, layerDepth); } float rotation, Vector2 const& origin, SpriteEffects effects, float layerDepth) { Draw(*texture, destinationRectangle, sourceRectangle, color, rotation, origin, effects, layerDepth); }
void Draw(Texture2D& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color, void Draw(Texture2D& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color,
float rotation, Vector2 const& origin, SpriteEffects effects, float layerDepth); float rotation, Vector2 const& origin, SpriteEffects effects, float layerDepth);
@ -111,57 +137,47 @@ namespace xna {
// DrawString - Adds a string to a batch of sprites to be rendered. // DrawString - Adds a string to a batch of sprites to be rendered.
// //
void DrawString(uptr<SpriteFont> const& spriteFont, String const& text, Vector2 const& position, Color const& color) { DrawString(*spriteFont, text, position, color); } void DrawString(std::unique_ptr<SpriteFont> const& spriteFont, std::string const& text, Vector2 const& position, Color const& color) { DrawString(*spriteFont, text, position, color); }
void DrawString(sptr<SpriteFont> const& spriteFont, String const& text, Vector2 const& position, Color const& color) { DrawString(*spriteFont, text, position, color); } void DrawString(std::shared_ptr<SpriteFont> const& spriteFont, std::string const& text, Vector2 const& position, Color const& color) { DrawString(*spriteFont, text, position, color); }
void DrawString(SpriteFont& spriteFont, String const& text, Vector2 const& position, Color const& color); void DrawString(SpriteFont& spriteFont, std::string const& text, Vector2 const& position, Color const& color);
void DrawString(uptr<SpriteFont> const& spriteFont, String const& text, Vector2 const& position, Color const& color, void DrawString(std::unique_ptr<SpriteFont> const& spriteFont, std::string const& text, Vector2 const& position, Color const& color,
float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth) { DrawString(*spriteFont, text, position, color, rotation, origin, scale, effects, layerDepth); } float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth) { DrawString(*spriteFont, text, position, color, rotation, origin, scale, effects, layerDepth); }
void DrawString(sptr<SpriteFont> const& spriteFont, String const& text, Vector2 const& position, Color const& color, void DrawString(std::shared_ptr<SpriteFont> const& spriteFont, std::string const& text, Vector2 const& position, Color const& color,
float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth) { DrawString(*spriteFont, text, position, color, rotation, origin, scale, effects, layerDepth); } float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth) { DrawString(*spriteFont, text, position, color, rotation, origin, scale, effects, layerDepth); }
void DrawString(SpriteFont& spriteFont, String const& text, Vector2 const& position, Color const& color, void DrawString(SpriteFont& spriteFont, std::string const& text, Vector2 const& position, Color const& color,
float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth); float rotation, Vector2 const& origin, float scale, SpriteEffects effects, float layerDepth);
void Viewport(xna::Viewport const& value);
public:
struct PlatformImplementation;
uptr<PlatformImplementation> impl = nullptr;
}; };
struct SpriteFontImplementation;
//Represents a font texture. //Represents a font texture.
class SpriteFont { class SpriteFont : public PlatformImplementation<SpriteFontImplementation> {
public: public:
SpriteFont( SpriteFont(
sptr<Texture2D> const& texture, std::shared_ptr<Texture2D> const& texture,
std::vector<Rectangle> const& glyphs, std::vector<Rectangle> const& glyphs,
std::vector<Rectangle> const& cropping, std::vector<Rectangle> const& cropping,
std::vector<Char> const& charMap, std::vector<Char> const& charMap,
Int lineSpacing, int32_t lineSpacing,
float spacing, float spacing,
std::vector<Vector3> const& kerning, std::vector<Vector3> const& kerning,
std::optional<Char> const& defaultCharacter); std::optional<Char> const& defaultCharacter);
// Returns the width and height of a string. // Returns the width and height of a string.
Vector2 MeasureString(String const& text, bool ignoreWhiteSpace = true); Vector2 MeasureString(std::string const& text, bool ignoreWhiteSpace = true);
// Returns the width and height of a string. // Returns the width and height of a string.
Vector2 MeasureString(WString const& text, bool ignoreWhiteSpace = true); Vector2 MeasureString(std::wstring const& text, bool ignoreWhiteSpace = true);
//Gets or sets the default character for the font. //Gets or sets the default character for the font.
Char DefaultCharacter() const; Char DefaultCharacter() const;
//Gets or sets the default character for the font. //Gets or sets the default character for the font.
void DefaultCharacter(Char value); void DefaultCharacter(Char value);
//Gets or sets the vertical distance (in pixels) between the base lines of two consecutive lines of text //Gets or sets the vertical distance (in pixels) between the base lines of two consecutive lines of text
Int LineSpacing() const; int32_t LineSpacing() const;
//Gets or sets the vertical distance (in pixels) between the base lines of two consecutive lines of text //Gets or sets the vertical distance (in pixels) between the base lines of two consecutive lines of text
void LineSpacing(float value); void LineSpacing(float value);
public:
struct PlatformImplementation;
uptr<PlatformImplementation> impl = nullptr;
}; };
using PSpriteFont = sptr<SpriteFont>;
} }
#endif #endif

68
sources/framework-dx/sprite.cpp
View File

@ -1,5 +1,4 @@
#include "xna-dx/framework.hpp" #include "xna-dx/framework.hpp"
#include <functional>
using DxSpriteBatch = DirectX::SpriteBatch; using DxSpriteBatch = DirectX::SpriteBatch;
using DxSpriteSortMode = DirectX::SpriteSortMode; using DxSpriteSortMode = DirectX::SpriteSortMode;
@ -53,8 +52,8 @@ namespace xna {
dxGlyps[i] = g; dxGlyps[i] = g;
} }
impl = unew<PlatformImplementation>(); Implementation = unew<SpriteFontImplementation>();
impl->dxSpriteFont = unew<DxSpriteFont>( Implementation->SpriteFont = unew<DxSpriteFont>(
//ID3D11ShaderResourceView* texture //ID3D11ShaderResourceView* texture
texture->impl->dxShaderResource.Get(), texture->impl->dxShaderResource.Get(),
//Glyph const* glyphs //Glyph const* glyphs
@ -67,12 +66,12 @@ namespace xna {
if (defaultCharacter.has_value()) { if (defaultCharacter.has_value()) {
const auto defChar = static_cast<wchar_t>(defaultCharacter.value()); const auto defChar = static_cast<wchar_t>(defaultCharacter.value());
impl->dxSpriteFont->SetDefaultCharacter(defChar); Implementation->SpriteFont->SetDefaultCharacter(defChar);
} }
} }
Vector2 SpriteFont::MeasureString(String const& text, bool ignoreWhiteSpace) { Vector2 SpriteFont::MeasureString(String const& text, bool ignoreWhiteSpace) {
const auto size = impl->dxSpriteFont->MeasureString(text.c_str(), ignoreWhiteSpace); const auto size = Implementation->SpriteFont->MeasureString(text.c_str(), ignoreWhiteSpace);
Vector2 vec2{}; Vector2 vec2{};
vec2.X = size.m128_f32[0]; vec2.X = size.m128_f32[0];
vec2.Y = size.m128_f32[1]; vec2.Y = size.m128_f32[1];
@ -81,7 +80,7 @@ namespace xna {
} }
Vector2 SpriteFont::MeasureString(WString const& text, bool ignoreWhiteSpace){ Vector2 SpriteFont::MeasureString(WString const& text, bool ignoreWhiteSpace){
const auto size = impl->dxSpriteFont->MeasureString(text.c_str(), ignoreWhiteSpace); const auto size = Implementation->SpriteFont->MeasureString(text.c_str(), ignoreWhiteSpace);
Vector2 vec2{}; Vector2 vec2{};
vec2.X = size.m128_f32[0]; vec2.X = size.m128_f32[0];
vec2.Y = size.m128_f32[1]; vec2.Y = size.m128_f32[1];
@ -90,30 +89,30 @@ namespace xna {
} }
Char SpriteFont::DefaultCharacter() const { Char SpriteFont::DefaultCharacter() const {
const auto defChar = impl->dxSpriteFont->GetDefaultCharacter(); const auto defChar = Implementation->SpriteFont->GetDefaultCharacter();
return static_cast<Char>(defChar); return static_cast<Char>(defChar);
} }
void SpriteFont::DefaultCharacter(Char value) { void SpriteFont::DefaultCharacter(Char value) {
const auto defChar = static_cast<wchar_t>(value); const auto defChar = static_cast<wchar_t>(value);
impl->dxSpriteFont->SetDefaultCharacter(defChar); Implementation->SpriteFont->SetDefaultCharacter(defChar);
} }
Int SpriteFont::LineSpacing() const { Int SpriteFont::LineSpacing() const {
const auto space = impl->dxSpriteFont->GetLineSpacing(); const auto space = Implementation->SpriteFont->GetLineSpacing();
return static_cast<Int>(space); return static_cast<Int>(space);
} }
void SpriteFont::LineSpacing(float value) { void SpriteFont::LineSpacing(float value) {
impl->dxSpriteFont->SetLineSpacing(value); Implementation->SpriteFont->SetLineSpacing(value);
} }
SpriteBatch::SpriteBatch(sptr<GraphicsDevice> const& device) : GraphicsResource(device) { SpriteBatch::SpriteBatch(sptr<GraphicsDevice> const& device) : GraphicsResource(device) {
Exception::ThrowIfNull(device, nameof(device)); Exception::ThrowIfNull(device, nameof(device));
Exception::ThrowIfNull(device->Implementation->Context.Get(), nameof(device->Implementation->Context)); Exception::ThrowIfNull(device->Implementation->Context.Get(), nameof(device->Implementation->Context));
impl = unew<PlatformImplementation>(); Implementation = unew<SpriteBatchImplementation>();
impl->dxSpriteBatch = snew<DxSpriteBatch>( Implementation->SpriteBatch = snew<DxSpriteBatch>(
//ID3D11DeviceContext* deviceContext //ID3D11DeviceContext* deviceContext
device->Implementation->Context.Get() device->Implementation->Context.Get()
); );
@ -128,12 +127,12 @@ namespace xna {
if (effect) { if (effect) {
bool dxEffectBufferChanged = false; bool dxEffectBufferChanged = false;
if (!impl->dxEffectBuffer || impl->dxEffectBuffer != effect->impl->dxEffect) { if (!Implementation->EffectBuffer || Implementation->EffectBuffer != effect->impl->dxEffect) {
impl->dxEffectBuffer = effect->impl->dxEffect; Implementation->EffectBuffer = effect->impl->dxEffect;
dxEffectBufferChanged = true; dxEffectBufferChanged = true;
} }
if (!impl->dxInputLayout || dxEffectBufferChanged) { if (!Implementation->InputLayout || dxEffectBufferChanged) {
void const* shaderByteCode; void const* shaderByteCode;
size_t byteCodeLength; size_t byteCodeLength;
@ -143,21 +142,21 @@ namespace xna {
DirectX::VertexPositionColorTexture::InputElements, DirectX::VertexPositionColorTexture::InputElements,
DirectX::VertexPositionColorTexture::InputElementCount, DirectX::VertexPositionColorTexture::InputElementCount,
shaderByteCode, byteCodeLength, shaderByteCode, byteCodeLength,
impl->dxInputLayout.GetAddressOf()); Implementation->InputLayout.GetAddressOf());
} }
auto& context = BaseGraphicsDevice->Implementation->Context; auto& context = BaseGraphicsDevice->Implementation->Context;
effectFunc = [=] { effectFunc = [=] {
impl->dxEffectBuffer->Apply(context.Get()); Implementation->EffectBuffer->Apply(context.Get());
context->IASetInputLayout(impl->dxInputLayout.Get()); context->IASetInputLayout(Implementation->InputLayout.Get());
}; };
} }
auto _sortMode = DxHelpers::SpriteSortToDx(sortMode); auto _sortMode = DxHelpers::SpriteSortToDx(sortMode);
auto _transformMatrix = DxHelpers::MatrixToDx(transformMatrix); auto _transformMatrix = DxHelpers::MatrixToDx(transformMatrix);
impl->dxSpriteBatch->Begin( Implementation->SpriteBatch->Begin(
_sortMode, _sortMode,
blendState ? blendState->Implementation->BlendState.Get() : nullptr, blendState ? blendState->Implementation->BlendState.Get() : nullptr,
samplerState ? samplerState->impl->_samplerState.Get() : nullptr, samplerState ? samplerState->impl->_samplerState.Get() : nullptr,
@ -169,7 +168,7 @@ namespace xna {
} }
void SpriteBatch::End() { void SpriteBatch::End() {
impl->dxSpriteBatch->End(); Implementation->SpriteBatch->End();
} }
void SpriteBatch::Draw(Texture2D& texture, Vector2 const& position, Color const& color) { void SpriteBatch::Draw(Texture2D& texture, Vector2 const& position, Color const& color) {
@ -177,7 +176,7 @@ namespace xna {
const auto v4 = color.ToVector4(); const auto v4 = color.ToVector4();
const auto _color = DxHelpers::VectorToDx(v4); const auto _color = DxHelpers::VectorToDx(v4);
impl->dxSpriteBatch->Draw( Implementation->SpriteBatch->Draw(
texture.impl->dxShaderResource.Get(), texture.impl->dxShaderResource.Get(),
_position, _position,
_color _color
@ -195,7 +194,7 @@ namespace xna {
_sourceRect = DxHelpers::RectangleToDx(sourceRectangle.value()); _sourceRect = DxHelpers::RectangleToDx(sourceRectangle.value());
}; };
impl->dxSpriteBatch->Draw( Implementation->SpriteBatch->Draw(
texture.impl->dxShaderResource.Get(), texture.impl->dxShaderResource.Get(),
_position, _position,
sourceRectangle ? &_sourceRect : nullptr, sourceRectangle ? &_sourceRect : nullptr,
@ -216,7 +215,7 @@ namespace xna {
const DxSpriteEffects _effects = static_cast<DxSpriteEffects>(effects); const DxSpriteEffects _effects = static_cast<DxSpriteEffects>(effects);
impl->dxSpriteBatch->Draw( Implementation->SpriteBatch->Draw(
texture.impl->dxShaderResource.Get(), texture.impl->dxShaderResource.Get(),
_position, _position,
sourceRectangle ? &_sourceRect : nullptr, sourceRectangle ? &_sourceRect : nullptr,
@ -243,7 +242,7 @@ namespace xna {
const auto _effects = static_cast<DxSpriteEffects>(effects); const auto _effects = static_cast<DxSpriteEffects>(effects);
const XMFLOAT2 _scale = { scale.X, scale.Y }; const XMFLOAT2 _scale = { scale.X, scale.Y };
impl->dxSpriteBatch->Draw( Implementation->SpriteBatch->Draw(
texture.impl->dxShaderResource.Get(), texture.impl->dxShaderResource.Get(),
_position, _position,
sourceRectangle ? &_sourceRect : nullptr, sourceRectangle ? &_sourceRect : nullptr,
@ -261,7 +260,7 @@ namespace xna {
const auto v4 = color.ToVector4(); const auto v4 = color.ToVector4();
const XMVECTORF32 _color = { v4.X, v4.Y, v4.Z, v4.W }; const XMVECTORF32 _color = { v4.X, v4.Y, v4.Z, v4.W };
impl->dxSpriteBatch->Draw(texture.impl->dxShaderResource.Get(), _destinationRect, _color); Implementation->SpriteBatch->Draw(texture.impl->dxShaderResource.Get(), _destinationRect, _color);
} }
void SpriteBatch::Draw(Texture2D& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color) { void SpriteBatch::Draw(Texture2D& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color) {
@ -279,7 +278,7 @@ namespace xna {
_sourceRect.bottom = sourceRectangle->Y + sourceRectangle->Height; _sourceRect.bottom = sourceRectangle->Y + sourceRectangle->Height;
}; };
impl->dxSpriteBatch->Draw(texture.impl->dxShaderResource.Get(), _destinationRect, sourceRectangle ? &_sourceRect : nullptr, _color); Implementation->SpriteBatch->Draw(texture.impl->dxShaderResource.Get(), _destinationRect, sourceRectangle ? &_sourceRect : nullptr, _color);
} }
void SpriteBatch::Draw(Texture2D& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color, float rotation, Vector2 const& origin, SpriteEffects effects, float layerDepth) { void SpriteBatch::Draw(Texture2D& texture, Rectangle const& destinationRectangle, std::optional<Rectangle> const& sourceRectangle, Color const& color, float rotation, Vector2 const& origin, SpriteEffects effects, float layerDepth) {
@ -297,7 +296,7 @@ namespace xna {
auto _origin = XMFLOAT2(origin.X, origin.Y); auto _origin = XMFLOAT2(origin.X, origin.Y);
const auto _effects = static_cast<DxSpriteEffects>(effects); const auto _effects = static_cast<DxSpriteEffects>(effects);
impl->dxSpriteBatch->Draw( Implementation->SpriteBatch->Draw(
texture.impl->dxShaderResource.Get(), texture.impl->dxShaderResource.Get(),
_destinationRect, _destinationRect,
sourceRectangle ? &_sourceRect : nullptr, sourceRectangle ? &_sourceRect : nullptr,
@ -306,20 +305,15 @@ namespace xna {
_origin, _origin,
_effects, _effects,
layerDepth); layerDepth);
} }
void SpriteBatch::Viewport(xna::Viewport const& value) {
const auto _view = DxHelpers::ViewportToDx(value);
impl->dxSpriteBatch->SetViewport(_view);
}
void SpriteBatch::DrawString(SpriteFont& spriteFont, String const& text, Vector2 const& position, Color const& color) { void SpriteBatch::DrawString(SpriteFont& spriteFont, String const& text, Vector2 const& position, Color const& color) {
const auto _position = XMFLOAT2(position.X, position.Y); const auto _position = XMFLOAT2(position.X, position.Y);
const auto v4 = color.ToVector4(); const auto v4 = color.ToVector4();
const XMVECTORF32 _color = { v4.X, v4.Y, v4.Z, v4.W }; const XMVECTORF32 _color = { v4.X, v4.Y, v4.Z, v4.W };
spriteFont.impl->dxSpriteFont->DrawString( spriteFont.Implementation->SpriteFont->DrawString(
impl->dxSpriteBatch.get(), Implementation->SpriteBatch.get(),
text.c_str(), text.c_str(),
_position, _position,
_color _color
@ -334,8 +328,8 @@ namespace xna {
const XMVECTORF32 _color = { v4.X, v4.Y, v4.Z, v4.W }; const XMVECTORF32 _color = { v4.X, v4.Y, v4.Z, v4.W };
const auto _effects = static_cast<DxSpriteEffects>(effects); const auto _effects = static_cast<DxSpriteEffects>(effects);
spriteFont.impl->dxSpriteFont->DrawString( spriteFont.Implementation->SpriteFont->DrawString(
impl->dxSpriteBatch.get(), Implementation->SpriteBatch.get(),
text.c_str(), text.c_str(),
_position, _position,
_color, _color,