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

Remove PClass e UClass

Browse Source
This commit is contained in:
Danilo 2024-04-26 11:35:59 -03:00
parent 0525626982
commit cbf70bf079
19 changed files with 175 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
framework/forward.hpp
View File

@ -6,135 +6,67 @@
namespace xna { namespace xna {
//Audio //Audio
class SoundEffect; class SoundEffect;
using PSoundEffect = std::shared_ptr<SoundEffect>;
struct SoundEffectInstance; struct SoundEffectInstance;
using PSoundEffectInstance = std::shared_ptr<SoundEffectInstance>;
class AudioEngine; class AudioEngine;
using PAudioEngine = std::shared_ptr<AudioEngine>;
struct WaveFormat; struct WaveFormat;
using PWaveFormat = std::shared_ptr<WaveFormat>;
//CShap //CShap
struct TimeSpan; struct TimeSpan;
using PTimeSpan = std::shared_ptr<TimeSpan>;
class Stream; class Stream;
using PStream = std::shared_ptr<Stream>;
class FileStream; class FileStream;
using PFileStream = std::shared_ptr<FileStream>;
class MemoryStream; class MemoryStream;
using PMemoryStream = std::shared_ptr<MemoryStream>;
//Framework //Framework
class BoundingBox; class BoundingBox;
using PBoundingBox = std::shared_ptr<BoundingBox>;
class BoundingFrustum; class BoundingFrustum;
using PBoundingFrustum = std::shared_ptr<BoundingFrustum>;
class BoundinSphere; class BoundinSphere;
using PBoundinSphere = std::shared_ptr<BoundinSphere>;
struct Color; struct Color;
using PColor = std::shared_ptr<Color>;
class Curve; class Curve;
using PCurve = std::shared_ptr<Curve>;
class CurveContinuity; class CurveContinuity;
using PCurveContinuity = std::shared_ptr<CurveContinuity>;
class CurveKey; class CurveKey;
using PCurveKey = std::shared_ptr<CurveKey>;
class CurveKeyCollection; class CurveKeyCollection;
using PCurveKeyCollection = std::shared_ptr<CurveKeyCollection>;
struct Matrix; struct Matrix;
using PMatrix = std::shared_ptr<Matrix>;
class Plane; class Plane;
using PPlane = std::shared_ptr<Plane>;
struct Point; struct Point;
using PPoint = std::shared_ptr<Point>;
struct Quaternion; struct Quaternion;
using PQuaternion = std::shared_ptr<Quaternion>;
class Ray; class Ray;
using PRay = std::shared_ptr<Ray>;
struct Rectangle; struct Rectangle;
using PRectangle = std::shared_ptr<Rectangle>;
struct Vector2; struct Vector2;
using PVector2 = std::shared_ptr<Vector2>;
struct Vector3; struct Vector3;
using PVector3 = std::shared_ptr<Vector3>;
struct Vector4; struct Vector4;
using PVector4 = std::shared_ptr<Vector4>;
//Game //Game
class DrawableGameComponent;
using PDrawableGameComponent = std::shared_ptr<DrawableGameComponent>;
class Game; class Game;
using PGame = std::shared_ptr<Game>;
class GameComponent;
using PGameComponent = std::shared_ptr<GameComponent>;
class GameComponentCollection;
using PGameComponentCollection = std::shared_ptr<GameComponentCollection>;
class GameClock; class GameClock;
using PGameClock = std::shared_ptr<GameClock>;
class GameTime; class GameTime;
using PGameTime = std::shared_ptr<GameTime>;
class GameWindow; class GameWindow;
using PGameWindow = std::shared_ptr<GameWindow>;
class GraphicsDeviceInformation; class GraphicsDeviceInformation;
using PGraphicsDeviceInformation = std::shared_ptr<GraphicsDeviceInformation>;
class GraphicsDeviceManager; class GraphicsDeviceManager;
using PGraphicsDeviceManager = std::shared_ptr<GraphicsDeviceManager>;
class IDrawable;
using PIDrawable = std::shared_ptr<IDrawable>;
class IGameComponent;
using PIGameComponent = std::shared_ptr<IGameComponent>;
class IUpdatable;
using PIUpdatable = std::shared_ptr<IUpdatable>;
//Graphics //Graphics
class BlendState; class BlendState;
using PBlendState = std::shared_ptr<BlendState>;
class ConstantBuffer; class ConstantBuffer;
using PConstantBuffer = std::shared_ptr<ConstantBuffer>;
class DataBuffer; class DataBuffer;
using PDataBuffer = std::shared_ptr<DataBuffer>;
class DepthStencilState; class DepthStencilState;
using PDepthStencilState = std::shared_ptr<DepthStencilState>;
class DisplayMode; class DisplayMode;
using PDisplayMode = std::shared_ptr<DisplayMode>;
using UDisplayMode = std::unique_ptr<DisplayMode>;
class DisplayModeCollection; class DisplayModeCollection;
using PDisplayModeCollection = std::shared_ptr<DisplayModeCollection>;
using UDisplayModeCollection = std::unique_ptr<DisplayModeCollection>;
class GraphicsAdapter; class GraphicsAdapter;
using PGraphicsAdapter = std::shared_ptr<GraphicsAdapter>;
using UGraphicsAdapter = std::unique_ptr<GraphicsAdapter>;
class GraphicsDevice; class GraphicsDevice;
using PGraphicsDevice = std::shared_ptr<GraphicsDevice>;
class GraphicsDeviceInformation; class GraphicsDeviceInformation;
using PGraphicsDeviceInformation = std::shared_ptr<GraphicsDeviceInformation>;
class PresentationParameters; class PresentationParameters;
using PPresentationParameters = std::shared_ptr< PresentationParameters>;
class RenderTarget2D; class RenderTarget2D;
using PRenderTarget2D = std::shared_ptr<RenderTarget2D>;
class SwapChain; class SwapChain;
using PSwapChain = std::shared_ptr<SwapChain>;
class Texture; class Texture;
using PTexture = std::shared_ptr<Texture>;
class Texture2D; class Texture2D;
using PTexture2D = std::shared_ptr<Texture2D>;
class RasterizerState; class RasterizerState;
using PRasterizerState = std::shared_ptr<RasterizerState>;
class SamplerState; class SamplerState;
using PSamplerState = std::shared_ptr<SamplerState>;
class Shader; class Shader;
using PShader = std::shared_ptr<Shader>;
class SpriteBatch; class SpriteBatch;
using PSpriteBatch = std::shared_ptr<SpriteBatch>;
class SpriteFont; class SpriteFont;
using PSpriteFont = std::shared_ptr<SpriteFont>;
struct VertexPositionColor; struct VertexPositionColor;
using PVertexPositionColor = std::shared_ptr<VertexPositionColor>;
class VertexShader; class VertexShader;
using pVertexShader = std::shared_ptr<VertexShader>;
struct Viewport; struct Viewport;
using PViewport = std::shared_ptr<Viewport>;
//Input //Input
struct GamePadTriggers; struct GamePadTriggers;

4
framework/game/game.hpp
View File

@ -14,8 +14,8 @@ namespace xna {
virtual void Exit() = 0; virtual void Exit() = 0;
virtual int Run() = 0; virtual int Run() = 0;
virtual PGameWindow Window() = 0; virtual sptr<GameWindow> Window() = 0;
virtual PGraphicsDevice GetGraphicsDevice() = 0; virtual sptr<GraphicsDevice> GetGraphicsDevice() = 0;
protected: protected:
virtual void Draw(GameTime const& gameTime) = 0; virtual void Draw(GameTime const& gameTime) = 0;

8
framework/game/gdeviceinfo.hpp
View File

@ -8,14 +8,14 @@ namespace xna {
class IGraphicsDeviceInformation { class IGraphicsDeviceInformation {
public: public:
virtual ~IGraphicsDeviceInformation(){} virtual ~IGraphicsDeviceInformation(){}
virtual PGraphicsAdapter Adapter() const = 0; virtual sptr<GraphicsAdapter> Adapter() const = 0;
virtual void Adapter(PGraphicsAdapter const& value) = 0; virtual void Adapter(sptr<GraphicsAdapter> const& value) = 0;
virtual xna::PresentationParameters PresentationParameters() const = 0; virtual xna::PresentationParameters PresentationParameters() const = 0;
virtual void PresentationParameters(xna::PresentationParameters const& value) = 0; virtual void PresentationParameters(xna::PresentationParameters const& value) = 0;
virtual xna::GraphicsProfile GraphicsProfile() const = 0; virtual xna::GraphicsProfile GraphicsProfile() const = 0;
virtual void GraphicsProfile(xna::GraphicsProfile value) = 0; virtual void GraphicsProfile(xna::GraphicsProfile value) = 0;
virtual PGameWindow Window() const = 0; virtual sptr<GameWindow> Window() const = 0;
virtual void Window(PGameWindow const& window) = 0; virtual void Window(sptr<GameWindow> const& window) = 0;
}; };
} }

12
framework/graphics/adapter.hpp
View File

@ -16,14 +16,14 @@ namespace xna {
virtual Uint Revision() const = 0; virtual Uint Revision() const = 0;
virtual Uint SubSystemId() const = 0; virtual Uint SubSystemId() const = 0;
virtual Uint VendorId() const = 0; virtual Uint VendorId() const = 0;
virtual UDisplayModeCollection SupportedDisplayModes() const = 0; virtual uptr<DisplayModeCollection> SupportedDisplayModes() const = 0;
virtual UDisplayModeCollection SupportedDisplayModes(SurfaceFormat surfaceFormat) const = 0; virtual uptr<DisplayModeCollection> SupportedDisplayModes(SurfaceFormat surfaceFormat) const = 0;
virtual PDisplayMode CurrentDisplayMode() = 0; virtual sptr<DisplayMode> CurrentDisplayMode() = 0;
virtual void CurrentDisplayMode(SurfaceFormat surfaceFormat, Uint width, Uint height) = 0; virtual void CurrentDisplayMode(SurfaceFormat surfaceFormat, Uint width, Uint height) = 0;
static UGraphicsAdapter DefaultAdapter(); static uptr<GraphicsAdapter> DefaultAdapter();
static void Adapters(std::vector<PGraphicsAdapter>& adapters); static void Adapters(std::vector<sptr<GraphicsAdapter>>& adapters);
static void Adapters(std::vector<UGraphicsAdapter>& adapters); static void Adapters(std::vector<uptr<GraphicsAdapter>>& adapters);
}; };
} }

4
framework/graphics/device.hpp
View File

@ -19,8 +19,8 @@ namespace xna {
virtual void Clear(Color const& color) = 0; virtual void Clear(Color const& color) = 0;
virtual bool Initialize(GameWindow& gameWindow) = 0; virtual bool Initialize(GameWindow& gameWindow) = 0;
virtual bool Present() = 0; virtual bool Present() = 0;
virtual PGraphicsAdapter Adapter() const = 0; virtual sptr<GraphicsAdapter> Adapter() const = 0;
virtual void Adapter(PGraphicsAdapter const& adapter) = 0; virtual void Adapter(sptr<GraphicsAdapter> const& adapter) = 0;
virtual xna::Viewport Viewport() const = 0; virtual xna::Viewport Viewport() const = 0;
virtual void Viewport(xna::Viewport const& viewport) = 0; virtual void Viewport(xna::Viewport const& viewport) = 0;
virtual void UseVSync(bool use) = 0; virtual void UseVSync(bool use) = 0;

12
framework/graphics/samplerstate.hpp
View File

@ -7,7 +7,8 @@ namespace xna {
class ISamplerState { class ISamplerState {
public: public:
virtual ~ISamplerState(){} virtual ~ISamplerState(){}
virtual bool Initialize(GraphicsDevice& device, xna_error_nullarg) = 0; virtual bool Initialize(xna_error_nullarg) = 0;
virtual bool Apply(xna_error_nullarg) = 0;
virtual void Filter(TextureFilter value) = 0; virtual void Filter(TextureFilter value) = 0;
virtual void AddressU(TextureAddressMode value) = 0; virtual void AddressU(TextureAddressMode value) = 0;
virtual void AddressV(TextureAddressMode value) = 0; virtual void AddressV(TextureAddressMode value) = 0;
@ -25,14 +26,7 @@ namespace xna {
virtual float MipLODBias() const = 0; virtual float MipLODBias() const = 0;
virtual float MinLOD() const = 0; virtual float MinLOD() const = 0;
virtual float MaxLOD() const = 0; virtual float MaxLOD() const = 0;
virtual Uint MaxAnisotropy() const = 0; virtual Uint MaxAnisotropy() const = 0;
static PSamplerState PoinWrap();
static PSamplerState PointClamp();
static PSamplerState LinearWrap();
static PSamplerState LinearClamp();
static PSamplerState AnisotropicWrap();
static PSamplerState AnisotropicClamp();
}; };
} }

20
framework/platform/adapter-dx.cpp
View File

@ -3,9 +3,9 @@
namespace xna { namespace xna {
static size_t getDisplayModesCount(IDXGIAdapter* adapter); static size_t getDisplayModesCount(IDXGIAdapter* adapter);
static UDisplayModeCollection createDisplayModeCollection(std::vector<DXGI_MODE_DESC> const& source); static uptr<DisplayModeCollection> createDisplayModeCollection(std::vector<DXGI_MODE_DESC> const& source);
UGraphicsAdapter IGraphicsAdapter::DefaultAdapter() { uptr<GraphicsAdapter> IGraphicsAdapter::DefaultAdapter() {
IDXGIFactory1* pFactory = nullptr; IDXGIFactory1* pFactory = nullptr;
if FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory)) if FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory))
@ -28,7 +28,7 @@ namespace xna {
return nullptr; return nullptr;
} }
void IGraphicsAdapter::Adapters(std::vector<PGraphicsAdapter>& adapters){ void IGraphicsAdapter::Adapters(std::vector<sptr<GraphicsAdapter>>& adapters){
IDXGIFactory1* pFactory = nullptr; IDXGIFactory1* pFactory = nullptr;
if FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory)) if FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory))
@ -50,7 +50,7 @@ namespace xna {
pFactory = nullptr; pFactory = nullptr;
} }
void IGraphicsAdapter::Adapters(std::vector<UGraphicsAdapter>& adapters) { void IGraphicsAdapter::Adapters(std::vector<uptr<GraphicsAdapter>>& adapters) {
IDXGIFactory1* pFactory = nullptr; IDXGIFactory1* pFactory = nullptr;
if FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory)) if FAILED(CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&pFactory))
@ -154,7 +154,7 @@ namespace xna {
return static_cast<Uint>(desc.VendorId); return static_cast<Uint>(desc.VendorId);
} }
UDisplayModeCollection GraphicsAdapter::SupportedDisplayModes() const { uptr<DisplayModeCollection> GraphicsAdapter::SupportedDisplayModes() const {
if (!dxadapter) return nullptr; if (!dxadapter) return nullptr;
const auto totalDisplay = getDisplayModesCount(dxadapter); const auto totalDisplay = getDisplayModesCount(dxadapter);
@ -193,7 +193,7 @@ namespace xna {
return createDisplayModeCollection(buffer); return createDisplayModeCollection(buffer);
} }
UDisplayModeCollection GraphicsAdapter::SupportedDisplayModes(SurfaceFormat surfaceFormat) const uptr<DisplayModeCollection> GraphicsAdapter::SupportedDisplayModes(SurfaceFormat surfaceFormat) const
{ {
if (!dxadapter) return nullptr; if (!dxadapter) return nullptr;
@ -222,7 +222,7 @@ namespace xna {
return uNew<DisplayModeCollection>(); return uNew<DisplayModeCollection>();
} }
PDisplayMode GraphicsAdapter::CurrentDisplayMode() { sptr<DisplayMode> GraphicsAdapter::CurrentDisplayMode() {
if (!_currentDisplayMode) { if (!_currentDisplayMode) {
CurrentDisplayMode(SurfaceFormat::Color, GraphicsDeviceManager::DefaultBackBufferWidth, GraphicsDeviceManager::DefaultBackBufferHeight); CurrentDisplayMode(SurfaceFormat::Color, GraphicsDeviceManager::DefaultBackBufferWidth, GraphicsDeviceManager::DefaultBackBufferHeight);
} }
@ -278,11 +278,11 @@ namespace xna {
return numModes; return numModes;
} }
static UDisplayModeCollection createDisplayModeCollection(std::vector<DXGI_MODE_DESC> const& source) { static uptr<DisplayModeCollection> createDisplayModeCollection(std::vector<DXGI_MODE_DESC> const& source) {
auto collection = uNew<DisplayModeCollection>(); auto collection = uNew<DisplayModeCollection>();
DisplayMode currentDisplayMode; DisplayMode currentDisplayMode;
std::vector<PDisplayMode> displayList; std::vector<sptr<DisplayMode>> displayList;
PDisplayMode pDisplay = nullptr; sptr<DisplayMode> pDisplay = nullptr;
for (size_t i = 0; i < source.size(); ++i) { for (size_t i = 0; i < source.size(); ++i) {
auto& modedesc = source[i]; auto& modedesc = source[i];

9
framework/platform/adapter-dx.hpp
View File

@ -5,7 +5,6 @@
#include "displaymode-dx.hpp" #include "displaymode-dx.hpp"
#include "dxheaders.hpp" #include "dxheaders.hpp"
namespace xna { namespace xna {
class GraphicsAdapter : public IGraphicsAdapter { class GraphicsAdapter : public IGraphicsAdapter {
public: public:
@ -27,9 +26,9 @@ namespace xna {
virtual Uint Revision() const override; virtual Uint Revision() const override;
virtual Uint SubSystemId() const override; virtual Uint SubSystemId() const override;
virtual Uint VendorId() const override; virtual Uint VendorId() const override;
virtual UDisplayModeCollection SupportedDisplayModes() const override; virtual uptr<DisplayModeCollection> SupportedDisplayModes() const override;
virtual UDisplayModeCollection SupportedDisplayModes(SurfaceFormat surfaceFormat) const override; virtual uptr<DisplayModeCollection> SupportedDisplayModes(SurfaceFormat surfaceFormat) const override;
virtual PDisplayMode CurrentDisplayMode() override; virtual sptr<DisplayMode> CurrentDisplayMode() override;
virtual void CurrentDisplayMode(SurfaceFormat surfaceFormat, Uint width, Uint height) override; virtual void CurrentDisplayMode(SurfaceFormat surfaceFormat, Uint width, Uint height) override;
virtual constexpr bool IsDefaultAdapter() const { return _index == 0; } virtual constexpr bool IsDefaultAdapter() const { return _index == 0; }
bool GetOutput(UINT slot, IDXGIOutput*& output); bool GetOutput(UINT slot, IDXGIOutput*& output);
@ -38,7 +37,7 @@ namespace xna {
IDXGIAdapter1* dxadapter{ nullptr }; IDXGIAdapter1* dxadapter{ nullptr };
private: private:
Uint _index{ 0 }; Uint _index{ 0 };
PDisplayMode _currentDisplayMode = nullptr; sptr<DisplayMode> _currentDisplayMode = nullptr;
public: public:
static constexpr DXGI_FORMAT ConvertSurfaceToDXGIFORMAT(SurfaceFormat format) static constexpr DXGI_FORMAT ConvertSurfaceToDXGIFORMAT(SurfaceFormat format)

12
framework/platform/device-dx.hpp
View File

@ -41,11 +41,11 @@ namespace xna {
virtual bool Initialize(GameWindow& gameWindow) override; virtual bool Initialize(GameWindow& gameWindow) override;
virtual bool Present() override; virtual bool Present() override;
virtual PGraphicsAdapter Adapter() const override { virtual sptr<GraphicsAdapter> Adapter() const override {
return _adapter; return _adapter;
} }
virtual void Adapter(PGraphicsAdapter const& adapter) override { virtual void Adapter(sptr<GraphicsAdapter> const& adapter) override {
_adapter = adapter; _adapter = adapter;
} }
@ -75,10 +75,10 @@ namespace xna {
ID3D11Device* _device{ nullptr }; ID3D11Device* _device{ nullptr };
ID3D11DeviceContext* _context{ nullptr }; ID3D11DeviceContext* _context{ nullptr };
IDXGIFactory1* _factory = nullptr; IDXGIFactory1* _factory = nullptr;
PSwapChain _swapChain{ nullptr }; sptr<SwapChain> _swapChain{ nullptr };
PGraphicsAdapter _adapter{ nullptr }; sptr<GraphicsAdapter> _adapter{ nullptr };
PRenderTarget2D _renderTarget2D{ nullptr }; sptr<RenderTarget2D> _renderTarget2D{ nullptr };
PBlendState _blendState{ nullptr }; sptr<BlendState> _blendState{ nullptr };
xna::Viewport _viewport{}; xna::Viewport _viewport{};
xna::PresentationParameters _presentationParameters; xna::PresentationParameters _presentationParameters;

8
framework/platform/displaymode-dx.cpp
View File

@ -14,12 +14,12 @@ namespace xna {
return counter; return counter;
} }
std::vector<PDisplayMode> DisplayModeCollection::Query(SurfaceFormat format) const std::vector<sptr<DisplayMode>> DisplayModeCollection::Query(SurfaceFormat format) const
{ {
const auto count = SurfaceCount(format); const auto count = SurfaceCount(format);
size_t index = 0; size_t index = 0;
std::vector<PDisplayMode> modes(count); std::vector<sptr<DisplayMode>> modes(count);
for (size_t i = 0; i < _displayModes.size(); ++i) { for (size_t i = 0; i < _displayModes.size(); ++i) {
if (_displayModes[i]->Format() == format) { if (_displayModes[i]->Format() == format) {
@ -34,9 +34,9 @@ namespace xna {
return modes; return modes;
} }
PDisplayMode DisplayModeCollection::Query(SurfaceFormat format, Uint width, Uint height) const sptr<DisplayMode> DisplayModeCollection::Query(SurfaceFormat format, Uint width, Uint height) const
{ {
PDisplayMode matched = nullptr; sptr<DisplayMode> matched = nullptr;
for (size_t i = 0; i < _displayModes.size(); ++i) { for (size_t i = 0; i < _displayModes.size(); ++i) {
const auto& mode = _displayModes[i]; const auto& mode = _displayModes[i];

8
framework/platform/displaymode-dx.hpp
View File

@ -85,16 +85,16 @@ namespace xna {
DisplayModeCollection(size_t count) : _displayModes(count) {} DisplayModeCollection(size_t count) : _displayModes(count) {}
DisplayModeCollection(std::vector<PDisplayMode> const& displayModes) : DisplayModeCollection(std::vector<sptr<DisplayMode>> const& displayModes) :
_displayModes(displayModes) {} _displayModes(displayModes) {}
virtual size_t SurfaceCount(SurfaceFormat format) const override; virtual size_t SurfaceCount(SurfaceFormat format) const override;
std::vector<PDisplayMode> Query(SurfaceFormat format) const; std::vector<sptr<DisplayMode>> Query(SurfaceFormat format) const;
PDisplayMode Query(SurfaceFormat format, Uint width, Uint height) const; sptr<DisplayMode> Query(SurfaceFormat format, Uint width, Uint height) const;
public: public:
std::vector<PDisplayMode> _displayModes; std::vector<sptr<DisplayMode>> _displayModes;
}; };
} }

10
framework/platform/game-dx.hpp
View File

@ -18,11 +18,11 @@ namespace xna {
virtual int Run() override; virtual int Run() override;
virtual PGameWindow Window() override { virtual sptr<GameWindow> Window() override {
return _gameWindow; return _gameWindow;
} }
virtual PGraphicsDevice GetGraphicsDevice() override { virtual sptr<GraphicsDevice> GetGraphicsDevice() override {
return _graphicsDevice; return _graphicsDevice;
} }
@ -36,11 +36,11 @@ namespace xna {
virtual void Update(GameTime const& gameTime) override; virtual void Update(GameTime const& gameTime) override;
public: public:
PGraphicsDevice _graphicsDevice{ nullptr }; sptr<GraphicsDevice> _graphicsDevice{ nullptr };
protected: protected:
PGameWindow _gameWindow{ nullptr }; sptr<GameWindow> _gameWindow{ nullptr };
PAudioEngine _audioEngine = nullptr; sptr<AudioEngine> _audioEngine = nullptr;
GameTime _currentGameTime{}; GameTime _currentGameTime{};
DX::StepTimer _stepTimer; DX::StepTimer _stepTimer;

12
framework/platform/gdeviceinfo-dx.hpp
View File

@ -11,11 +11,11 @@ namespace xna {
public: public:
virtual ~GraphicsDeviceInformation() override {} virtual ~GraphicsDeviceInformation() override {}
inline virtual PGraphicsAdapter Adapter() const override { inline virtual sptr<GraphicsAdapter> Adapter() const override {
return _adapter; return _adapter;
}; };
inline virtual void Adapter(PGraphicsAdapter const& value) override { inline virtual void Adapter(sptr<GraphicsAdapter> const& value) override {
_adapter = value; _adapter = value;
} }
@ -35,19 +35,19 @@ namespace xna {
_profile = value; _profile = value;
}; };
inline virtual PGameWindow Window() const override { inline virtual sptr<GameWindow> Window() const override {
return _window; return _window;
} }
inline virtual void Window(PGameWindow const& window) override { inline virtual void Window(sptr<GameWindow> const& window) override {
_window = window; _window = window;
} }
public: public:
PGraphicsAdapter _adapter{ nullptr }; sptr<GraphicsAdapter> _adapter{ nullptr };
xna::GraphicsProfile _profile{xna::GraphicsProfile::Reach}; xna::GraphicsProfile _profile{xna::GraphicsProfile::Reach};
xna::PresentationParameters _parameters{}; xna::PresentationParameters _parameters{};
PGameWindow _window{ nullptr }; sptr<GameWindow> _window{ nullptr };
}; };
} }

2
framework/platform/gdevicemanager-dx.hpp
View File

@ -39,7 +39,7 @@ namespace xna {
Int _backBufferWidth{ DefaultBackBufferWidth }; Int _backBufferWidth{ DefaultBackBufferWidth };
Int _backBufferHeight{ DefaultBackBufferHeight }; Int _backBufferHeight{ DefaultBackBufferHeight };
bool _isDeviceDirty{ false }; bool _isDeviceDirty{ false };
PGraphicsDevice _device = nullptr; sptr<GraphicsDevice> _device = nullptr;
bool _isFullScreen{ false }; bool _isFullScreen{ false };
GraphicsDeviceInformation _information{}; GraphicsDeviceInformation _information{};

132
framework/platform/samplerstate-dx.cpp
View File

@ -2,64 +2,80 @@
#include "device-dx.hpp" #include "device-dx.hpp"
namespace xna { namespace xna {
PSamplerState ISamplerState::PoinWrap() { bool SamplerState::Apply(xna_error_ptr_arg)
auto state = New<SamplerState>();
state->_description.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
return state;
}
PSamplerState ISamplerState::PointClamp() {
auto state = New<SamplerState>();
state->_description.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
return state;
}
PSamplerState ISamplerState::LinearWrap() {
auto state = New<SamplerState>();
state->_description.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
return state;
}
PSamplerState ISamplerState::LinearClamp() {
auto state = New<SamplerState>();
state->_description.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
return state;
}
PSamplerState ISamplerState::AnisotropicWrap() {
auto state = New<SamplerState>();
state->_description.Filter = D3D11_FILTER_ANISOTROPIC;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
return state;
}
PSamplerState ISamplerState::AnisotropicClamp() {
auto state = New<SamplerState>();
state->_description.Filter = D3D11_FILTER_ANISOTROPIC;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
return state;
}
bool SamplerState::Initialize(GraphicsDevice& device, xna_error_ptr_arg)
{ {
if (!device._device) { if (!m_device || !m_device->_context) {
xna_error_apply(err, XnaErrorCode::ARGUMENT_IS_NULL); xna_error_apply(err, XnaErrorCode::INVALID_OPERATION);
return false;
}
if (!_samplerState) {
xna_error_apply(err, XnaErrorCode::UNINTIALIZED_RESOURCE);
return false;
}
m_device->_context->PSSetSamplers(0, 1, &_samplerState);
return true;
}
uptr<SamplerState> SamplerState::PoinWrap() {
auto state = std::unique_ptr<SamplerState>(new SamplerState());
state->_description.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
return state;
}
uptr<SamplerState> SamplerState::PointClamp() {
auto state = std::unique_ptr<SamplerState>(new SamplerState());
state->_description.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
return state;
}
uptr<SamplerState> SamplerState::LinearWrap() {
auto state = std::unique_ptr<SamplerState>(new SamplerState());
state->_description.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
return state;
}
uptr<SamplerState> SamplerState::LinearClamp() {
auto state = std::unique_ptr<SamplerState>(new SamplerState());
state->_description.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
return state;
}
uptr<SamplerState> SamplerState::AnisotropicWrap() {
auto state = std::unique_ptr<SamplerState>(new SamplerState());
state->_description.Filter = D3D11_FILTER_ANISOTROPIC;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
return state;
}
uptr<SamplerState> SamplerState::AnisotropicClamp() {
auto state = std::unique_ptr<SamplerState>(new SamplerState());
state->_description.Filter = D3D11_FILTER_ANISOTROPIC;
state->_description.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
state->_description.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
return state;
}
bool SamplerState::Initialize(xna_error_ptr_arg)
{
if (!m_device || !m_device->_device) {
xna_error_apply(err, XnaErrorCode::INVALID_OPERATION);
return false; return false;
} }
@ -68,7 +84,7 @@ namespace xna {
_samplerState = nullptr; _samplerState = nullptr;
} }
const auto hr = device._device->CreateSamplerState(&_description, &_samplerState); const auto hr = m_device->_device->CreateSamplerState(&_description, &_samplerState);
if (FAILED(hr)) { if (FAILED(hr)) {
xna_error_apply(err, XnaErrorCode::FAILED_OPERATION); xna_error_apply(err, XnaErrorCode::FAILED_OPERATION);

64
framework/platform/samplerstate-dx.hpp
View File

@ -2,13 +2,14 @@
#define XNA_PLATFORM_SAMPLERSTATE_DX_HPP #define XNA_PLATFORM_SAMPLERSTATE_DX_HPP
#include "../graphics/samplerstate.hpp" #include "../graphics/samplerstate.hpp"
#include "../graphics/gresource.hpp"
#include "dxheaders.hpp" #include "dxheaders.hpp"
namespace xna { namespace xna {
class SamplerState : public ISamplerState { class SamplerState : public ISamplerState, public GraphicsResource {
public: public:
SamplerState() { SamplerState(GraphicsDevice* device) : GraphicsResource(device) {
_description.MaxAnisotropy = 4; _description.MaxAnisotropy = 4;
} }
virtual ~SamplerState() override { virtual ~SamplerState() override {
@ -18,7 +19,8 @@ namespace xna {
} }
} }
virtual bool Initialize(GraphicsDevice& device, xna_error_nullarg) override; virtual bool Initialize(xna_error_nullarg) override;
virtual bool Apply(xna_error_nullarg) override;
virtual constexpr void Filter(TextureFilter value) override { virtual constexpr void Filter(TextureFilter value) override {
switch (value) switch (value)
@ -50,7 +52,7 @@ namespace xna {
case xna::TextureFilter::MinPointMagLinearMipPoint: case xna::TextureFilter::MinPointMagLinearMipPoint:
_description.Filter = D3D11_FILTER::D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT; _description.Filter = D3D11_FILTER::D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;
break; break;
default: default:
break; break;
} }
} }
@ -68,7 +70,7 @@ namespace xna {
} }
virtual constexpr void Comparison(ComparisonFunction value) override { virtual constexpr void Comparison(ComparisonFunction value) override {
_description.ComparisonFunc = static_cast<D3D11_COMPARISON_FUNC>(static_cast<int>(value) + 1); _description.ComparisonFunc = static_cast<D3D11_COMPARISON_FUNC>(static_cast<int>(value) + 1);
} }
virtual constexpr void MipLODBias(float value) override { virtual constexpr void MipLODBias(float value) override {
@ -91,26 +93,26 @@ namespace xna {
switch (_description.Filter) switch (_description.Filter)
{ {
case D3D11_FILTER::D3D11_FILTER_MIN_MAG_MIP_LINEAR: case D3D11_FILTER::D3D11_FILTER_MIN_MAG_MIP_LINEAR:
return xna::TextureFilter::Linear; return xna::TextureFilter::Linear;
case D3D11_FILTER_MIN_MAG_MIP_POINT: case D3D11_FILTER_MIN_MAG_MIP_POINT:
return xna::TextureFilter::Point; return xna::TextureFilter::Point;
case D3D11_FILTER_ANISOTROPIC: case D3D11_FILTER_ANISOTROPIC:
return xna::TextureFilter::Anisotropic; return xna::TextureFilter::Anisotropic;
case D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT: case D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT:
return xna::TextureFilter::LinearMipPoint; return xna::TextureFilter::LinearMipPoint;
case D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR: case D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR:
return xna::TextureFilter::PointMipLinear; return xna::TextureFilter::PointMipLinear;
case D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR: case D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return xna::TextureFilter::MinLinearMagPointMipLinear; return xna::TextureFilter::MinLinearMagPointMipLinear;
case D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT: case D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT:
return xna::TextureFilter::MinLinearMagPointMipPoint; return xna::TextureFilter::MinLinearMagPointMipPoint;
case D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR: case D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR:
return xna::TextureFilter::MinPointMagLinearMipLinear; return xna::TextureFilter::MinPointMagLinearMipLinear;
case D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT: case D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT:
return xna::TextureFilter::MinPointMagLinearMipPoint; return xna::TextureFilter::MinPointMagLinearMipPoint;
default: default:
return xna::TextureFilter::Linear; return xna::TextureFilter::Linear;
} }
} }
virtual constexpr TextureAddressMode AddressU() const override { virtual constexpr TextureAddressMode AddressU() const override {
@ -118,7 +120,7 @@ namespace xna {
ConvertAddressMode(_description.AddressU, mode); ConvertAddressMode(_description.AddressU, mode);
return mode; return mode;
} }
virtual constexpr TextureAddressMode AddressV() const override { virtual constexpr TextureAddressMode AddressV() const override {
TextureAddressMode mode; TextureAddressMode mode;
ConvertAddressMode(_description.AddressV, mode); ConvertAddressMode(_description.AddressV, mode);
@ -132,17 +134,17 @@ namespace xna {
} }
virtual ComparisonFunction Comparison() const override { virtual ComparisonFunction Comparison() const override {
return static_cast<ComparisonFunction>(_description.ComparisonFunc - 1); return static_cast<ComparisonFunction>(_description.ComparisonFunc - 1);
} }
virtual constexpr float MipLODBias() const override { virtual constexpr float MipLODBias() const override {
return _description.MipLODBias; return _description.MipLODBias;
} }
virtual constexpr float MinLOD() const override { virtual constexpr float MinLOD() const override {
return _description.MinLOD; return _description.MinLOD;
} }
virtual constexpr float MaxLOD() const override { virtual constexpr float MaxLOD() const override {
return _description.MaxLOD; return _description.MaxLOD;
} }
@ -151,18 +153,28 @@ namespace xna {
return _description.MaxAnisotropy; return _description.MaxAnisotropy;
} }
static uptr<SamplerState> PoinWrap();
static uptr<SamplerState> PointClamp();
static uptr<SamplerState> LinearWrap();
static uptr<SamplerState> LinearClamp();
static uptr<SamplerState> AnisotropicWrap();
static uptr<SamplerState> AnisotropicClamp();
public: public:
ID3D11SamplerState* _samplerState = nullptr; ID3D11SamplerState* _samplerState = nullptr;
D3D11_SAMPLER_DESC _description{}; D3D11_SAMPLER_DESC _description{};
public: public:
static constexpr void ConvertAddressMode(TextureAddressMode value, D3D11_TEXTURE_ADDRESS_MODE& target) { static constexpr void ConvertAddressMode(TextureAddressMode value, D3D11_TEXTURE_ADDRESS_MODE& target) {
target = static_cast<D3D11_TEXTURE_ADDRESS_MODE>(static_cast<int>(value) + 1); target = static_cast<D3D11_TEXTURE_ADDRESS_MODE>(static_cast<int>(value) + 1);
} }
static constexpr void ConvertAddressMode(D3D11_TEXTURE_ADDRESS_MODE value, TextureAddressMode& target) { static constexpr void ConvertAddressMode(D3D11_TEXTURE_ADDRESS_MODE value, TextureAddressMode& target) {
target = static_cast<TextureAddressMode>(value - 1); target = static_cast<TextureAddressMode>(value - 1);
} }
private:
SamplerState() : GraphicsResource(nullptr) {}
}; };
} }

2
framework/platform/texture-dx.cpp
View File

@ -7,7 +7,7 @@ namespace xna {
Texture2D::Texture2D() { Texture2D::Texture2D() {
} }
PTexture2D Texture2D::FromStream(GraphicsDevice& device, String const& fileName, xna_error_ptr_arg) sptr<Texture2D> Texture2D::FromStream(GraphicsDevice& device, String const& fileName, xna_error_ptr_arg)
{ {
auto texture2d = New<Texture2D>(); auto texture2d = New<Texture2D>();
ID3D11Resource* resource = nullptr; ID3D11Resource* resource = nullptr;

2
framework/platform/texture-dx.hpp
View File

@ -31,7 +31,7 @@ namespace xna {
return _description.Height; return _description.Height;
} }
static PTexture2D FromStream(GraphicsDevice& device, String const& fileName, xna_error_nullarg); static sptr<Texture2D> FromStream(GraphicsDevice& device, String const& fileName, xna_error_nullarg);
public: public:
ID3D11Texture2D* _texture2D{nullptr}; ID3D11Texture2D* _texture2D{nullptr};

6
framework/xna.cpp
View File

@ -48,9 +48,9 @@ namespace xna {
} }
private: private:
PGraphicsDeviceManager graphics = nullptr; sptr<GraphicsDeviceManager> graphics = nullptr;
PSpriteBatch spriteBatch = nullptr; sptr<SpriteBatch> spriteBatch = nullptr;
PTexture2D texture = nullptr; //200x200 sptr<Texture2D> texture = nullptr; //200x200
Vector2 position{}; Vector2 position{};
std::vector<Vector2> points; std::vector<Vector2> points;
MouseState currentState{}; MouseState currentState{};