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

Implementações em GameComponent

Browse Source
This commit is contained in:
Danilo 2024-04-27 15:21:47 -03:00
parent 3a66eaf746
commit 2518d7584d
5 changed files with 113 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
framework/game/component.cpp
View File

@ -1,4 +1,53 @@
#include "component.hpp"
namespace xna {
namespace xna {
sptr<IGameComponent> GameComponentCollection::operator[](size_t index) const
{
if (index >= components.size())
return nullptr;
return components[index];
}
sptr<IGameComponent> GameComponentCollection::At(size_t index) const
{
if (index >= components.size())
return nullptr;
return components[index];
}
bool GameComponentCollection::UpdateOrderComparer(sptr<IGameComponent> const& x, sptr<IGameComponent> const& y)
{
auto comp1 = std::reinterpret_pointer_cast<GameComponent>(x);
auto comp2 = std::reinterpret_pointer_cast<GameComponent>(y);
if (!comp1 && !comp2)
return false;
if (!comp1)
return true;
if (!comp2)
return false;
return comp1->UpdateOrder() < comp2->UpdateOrder();
}
bool GameComponentCollection::DrawOrderComparer(sptr<IGameComponent> const& x, sptr<IGameComponent> const& y)
{
auto comp1 = std::reinterpret_pointer_cast<DrawableGameComponent>(x);
auto comp2 = std::reinterpret_pointer_cast<DrawableGameComponent>(y);
if (!comp1 && !comp2)
return false;
if (!comp1)
return true;
if (!comp2)
return false;
return comp1->DrawOrder() < comp2->DrawOrder();
}
}

74
framework/game/component.hpp
View File

@ -104,84 +104,60 @@ namespace xna {
class GameComponentCollection {
public:
void InsertItem(size_t index, sptr<IGameComponent> const& item) {
constexpr void InsertItem(size_t index, sptr<IGameComponent> const& item) {
const auto it = components.begin();
components.insert(it + index, item);
std::sort(components.begin(), components.end(), UpdateOrderComparer);
if (AutoSort)
std::sort(components.begin(), components.end(), UpdateOrderComparer);
}
void RemoveItem(size_t index) {
constexpr void RemoveItem(size_t index) {
if (index >= components.size())
return;
const auto it = components.begin();
components.erase(it + index);
std::sort(components.begin(), components.end(), UpdateOrderComparer);
if (AutoSort)
std::sort(components.begin(), components.end(), UpdateOrderComparer);
}
void ClearItems() {
constexpr void ClearItems() {
components.clear();
}
void Add(sptr<IGameComponent> const& item) {
constexpr void Add(sptr<IGameComponent> const& item) {
components.push_back(item);
std::sort(components.begin(), components.end(), UpdateOrderComparer);
if(AutoSort) std::sort(components.begin(), components.end(), UpdateOrderComparer);
}
constexpr size_t Count() const {
return components.size();
}
sptr<IGameComponent> operator[](size_t index) const {
if (index >= components.size())
return nullptr;
sptr<IGameComponent> operator[](size_t index) const;
return components[index];
sptr<IGameComponent> At(size_t index) const;
constexpr void Sort() {
std::sort(components.begin(), components.end(), UpdateOrderComparer);
}
static bool UpdateOrderComparer(sptr<IGameComponent> const& x, sptr<IGameComponent> const& y);
static bool DrawOrderComparer(sptr<IGameComponent> const& x, sptr<IGameComponent> const& y);
static constexpr void UpdateSort(std::vector<sptr<IGameComponent>>& components) {
std::sort(components.begin(), components.end(), UpdateOrderComparer);
}
sptr<IGameComponent> At(size_t index) const {
if (index >= components.size())
return nullptr;
return components[index];
}
static bool UpdateOrderComparer(sptr<IGameComponent> const& x, sptr<IGameComponent> const& y) {
auto comp1 = std::reinterpret_pointer_cast<GameComponent>(x);
auto comp2 = std::reinterpret_pointer_cast<GameComponent>(y);
if (!comp1 && !comp2)
return false;
if (!comp1)
return true;
if (!comp2)
return false;
return comp1->UpdateOrder() < comp2->UpdateOrder();
}
static bool DrawOrderComparer(sptr<IGameComponent> const& x, sptr<IGameComponent> const& y) {
auto comp1 = std::reinterpret_pointer_cast<GameComponent>(x);
auto comp2 = std::reinterpret_pointer_cast<GameComponent>(y);
if (!comp1 && !comp2)
return false;
if (!comp1)
return true;
if (!comp2)
return false;
return comp1->UpdateOrder() < comp2->UpdateOrder();
static constexpr void DrawSort(std::vector<sptr<IGameComponent>>& components) {
std::sort(components.begin(), components.end(), DrawOrderComparer);
}
public:
std::vector<sptr<IGameComponent>> components;
std::vector<sptr<IGameComponent>> components;
bool AutoSort{ false };
};
}

1
framework/game/game.hpp
View File

@ -18,7 +18,6 @@ namespace xna {
virtual sptr<GameWindow> Window() = 0;
virtual sptr<GraphicsDevice> GetGraphicsDevice() = 0;
virtual sptr<GameComponentCollection> Components() = 0;
virtual void DisableGameComponets(bool value) = 0;
protected:
virtual void Draw(GameTime const& gameTime) = 0;

61
framework/platform/game-dx.cpp
View File

@ -36,28 +36,7 @@ namespace xna {
}
return startLoop();
}
void Game::Draw(GameTime const& gameTime) {
if (!_disableGameComponent) {
std::sort(_drawableGameComponents.begin(), _drawableGameComponents.end(), GameComponentCollection::DrawOrderComparer);
for (size_t i = 0; i < _drawableGameComponents.size(); ++i) {
auto& component = _drawableGameComponents[i];
if (!component) continue;
auto drawable = reinterpret_pointer_cast<IDrawable>(component);
if(drawable && drawable->Visible())
drawable->Draw(gameTime);
}
_drawableGameComponents.clear();
}
_graphicsDevice->Present();
}
}
void Game::Initialize() {
Keyboard::Initialize();
@ -82,23 +61,51 @@ namespace xna {
LoadContent();
}
void Game::Draw(GameTime const& gameTime) {
if (_enabledGameComponents && !_drawableGameComponents.empty()) {
const auto count = _drawableGameComponents.size();
if (count != _drawableGameComponentsCount && _gameComponents->AutoSort) {
GameComponentCollection::DrawSort(_drawableGameComponents);
_drawableGameComponentsCount = count;
}
for (size_t i = 0; i < count; ++i) {
auto& component = _drawableGameComponents[i];
if (!component) continue;
auto drawable = reinterpret_pointer_cast<IDrawable>(component);
if (drawable && drawable->Visible())
drawable->Draw(gameTime);
}
_drawableGameComponents.clear();
}
_graphicsDevice->Present();
}
void Game::Update(GameTime const& gameTime) {
_audioEngine->Update();
if (!_disableGameComponent) {
for (size_t i = 0; i < _gameComponents->Count(); ++i) {
if (_enabledGameComponents && _gameComponents->Count() > 0) {
const auto count = _gameComponents->Count();
for (size_t i = 0; i < count; ++i) {
auto component = _gameComponents->At(i);
if (!component) continue;
if (component->Type() == GameComponentType::Drawable)
_drawableGameComponents.push_back(component);
if (component->Type() == GameComponentType::Drawable) {
_drawableGameComponents.push_back(component);
}
auto updatable = reinterpret_pointer_cast<IUpdateable>(component);
if(updatable && updatable->Enabled())
updatable->Update(gameTime);
}
}
}
}

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

@ -30,8 +30,8 @@ namespace xna {
return _gameComponents;
}
void DisableGameComponets(bool value) override {
_disableGameComponent = value;
constexpr void EnableGameComponents(bool value) {
_enabledGameComponents = value;
}
protected:
@ -58,7 +58,8 @@ namespace xna {
void step();
sptr<GameComponentCollection> _gameComponents = nullptr;
std::vector<sptr<IGameComponent>> _drawableGameComponents;
bool _disableGameComponent{ false };
Uint _drawableGameComponentsCount{ 0 };
bool _enabledGameComponents{ false };
};
}