diff --git a/CMakelists.txt b/CMakelists.txt
index e7bfb4c887764963f55edb078f61e8ff9350583c..2de7e4f48d328208dc9c2562ce80b1536c03bc65 100644
--- a/CMakelists.txt
+++ b/CMakelists.txt
@@ -59,21 +59,17 @@ set_property(TARGET ${CURRENT_TARGET} PROPERTY RUNTIME_OUTPUT_DIRECTORY $<1:${CM
target_include_directories(${CURRENT_TARGET} PRIVATE ${INCLUDE})
-#list(APPEND CMAKE_PREFIX_PATH "/amuhome/b20017738/Bureau/vcpkg/packages/glew_x64-linux")
-#list(APPEND CMAKE_PREFIX_PATH "/amuhome/b20017738/Bureau/vcpkg/packages/glm_x64-linux")
-#list(APPEND CMAKE_PREFIX_PATH "/amuhome/b20017738/Bureau/vcpkg/packages/imgui_x64-linux")
+list(APPEND CMAKE_PREFIX_PATH "/amuhome/b20017738/Bureau/vcpkg/packages/glew_x64-linux")
+list(APPEND CMAKE_PREFIX_PATH "/amuhome/b20017738/Bureau/vcpkg/packages/glm_x64-linux")
+list(APPEND CMAKE_PREFIX_PATH "/amuhome/b20017738/Bureau/vcpkg/packages/imgui_x64-linux")
-list(APPEND CMAKE_PREFIX_PATH "C:/vcpkg/packages/freetype_x64-windows")
-
-find_package(glfw3 REQUIRED)
-find_package(GLEW REQUIRED)
-find_package(glm CONFIG REQUIRED)
-find_package(imgui REQUIRED)
-find_package(Freetype REQUIRED)
+find_package(glfw3 REQUIRED)
+find_package(GLEW REQUIRED)
+find_package(glm CONFIG REQUIRED)
+find_package(imgui REQUIRED)
target_link_libraries(${CURRENT_TARGET} PRIVATE glfw)
target_link_libraries(${CURRENT_TARGET} PRIVATE GLEW::GLEW)
target_link_libraries(${CURRENT_TARGET} PRIVATE glm::glm-header-only)
target_link_libraries(${CURRENT_TARGET} PRIVATE imgui::imgui)
-target_link_libraries(${CURRENT_TARGET} PRIVATE Freetype::Freetype)
diff --git a/source/engine/graphics/front/engine/Engine.cpp b/source/engine/graphics/front/engine/Engine.cpp
index 9adda5a3d7ad97f0769c82d6c124c7725618d18c..a7dc5a5e1c010d63227be7fece89837704ec5086 100644
--- a/source/engine/graphics/front/engine/Engine.cpp
+++ b/source/engine/graphics/front/engine/Engine.cpp
@@ -24,6 +24,15 @@ namespace megu {
}
}
+ void GraphicEngine::remove(const Identifiable & identifiable) {
+ for(auto & [priority, layer] : this->_layers) {
+ auto r = layer.get()->get(identifiable);
+ if(r.has_value()) {
+ layer.get()->remove(identifiable);
+ }
+ }
+ }
+
std::optional<std::reference_wrapper<const Layer>> GraphicEngine::get(Priority priority) const {
const auto it = this->_layers.find(priority);
if(it != this->_layers.end()) {
diff --git a/source/engine/graphics/front/engine/Engine.hpp b/source/engine/graphics/front/engine/Engine.hpp
index f85a3365579a61074d38235cffbb8f582c358b94..38dce9fde7967b660bb902945f75d2bb011b8f9b 100644
--- a/source/engine/graphics/front/engine/Engine.hpp
+++ b/source/engine/graphics/front/engine/Engine.hpp
@@ -19,8 +19,8 @@ namespace megu {
void push(Priority, Renderer &);
template <class T>
- void push(Priority layer_priority, Priority object_priority, T & object, Module<T> * modul) {
- this->_layers[layer_priority].get()->push<T>(object_priority, object, modul);
+ size_t push(Priority layer_priority, Priority object_priority, T & object, Module<T> * modul) {
+ return this->_layers[layer_priority].get()->push<T>(object_priority, object, modul);
}
/*void push(Priority layer_priority, Priority object_priority, Renderable & renderable) {
@@ -28,6 +28,7 @@ namespace megu {
}*/
void remove(Priority);
+ void remove(const Identifiable &);
std::optional<std::reference_wrapper<const Layer>> get(Priority) const;
std::optional<std::reference_wrapper<const Renderable>> get(const Identifiable &) const;
diff --git a/source/engine/graphics/front/engine/Layer.hpp b/source/engine/graphics/front/engine/Layer.hpp
index 5b6febabf6437f522ba55db61b002cdb34ae10fc..3efa4ddc636103b8e727effb4be5e58346fed159 100644
--- a/source/engine/graphics/front/engine/Layer.hpp
+++ b/source/engine/graphics/front/engine/Layer.hpp
@@ -26,16 +26,23 @@ namespace megu {
inline const Renderer & renderer() const {return this->_renderer;}
template <class T>
- void push(Priority priority, T & object, Module<T> * modul) {
- if(this->_objects.contains(priority)) {
+ size_t push(Priority priority, T & object, Module<T> * modul) {
+
+ if(!this->_objects.contains(priority)) {
this->_objects.erase(priority);
}
this->_objects.insert({priority, Renderable{ object, modul }});
+ return this->_objects.at(priority).id();
}
- /*void push(Priority priority, Renderable & renderable) {
- this->_objects[priority] = renderable;
- }*/
+ void remove(const Identifiable & identifiable) {
+ for(auto & [priority, renderable] : this->_objects) {
+ if(renderable.id() == identifiable.id()) {
+ this->_objects.erase(priority);
+ break;
+ }
+ }
+ }
std::optional<std::reference_wrapper<const Renderable>> get(const Identifiable & id) const {
for(const auto & [priority, object] : this->_objects) {
@@ -43,6 +50,7 @@ namespace megu {
return object;
}
}
+ return {};
}
const Texture & draw(const Window & w, const TextureArray & a) {
diff --git a/source/engine/graphics/front/object/Text.cpp b/source/engine/graphics/front/object/Text.cpp
index ff65d548093719b444a2fd8d2b8ae9ce5fe20996..6b16ea6d12983b4ef57776d8c470f42e436895ef 100644
--- a/source/engine/graphics/front/object/Text.cpp
+++ b/source/engine/graphics/front/object/Text.cpp
@@ -1,9 +1,6 @@
#include "Text.hpp"
#include <exception>
-#include <ft2build.h>
-#include FT_FREETYPE_H
-
#include <iostream>
namespace megu {
diff --git a/source/engine/physic/front/engine/Engine.cpp b/source/engine/physic/front/engine/Engine.cpp
index 6aa664b5fa088acc05fe41dec8e99f1352318231..d32f1b3d6d37a74e455b2b449fc64686ac1bbb79 100644
--- a/source/engine/physic/front/engine/Engine.cpp
+++ b/source/engine/physic/front/engine/Engine.cpp
@@ -19,6 +19,26 @@ namespace megu {
}
}
+ void PhysicEngine::remove(TangibleStatic & t) {
+ for(auto & [p, objs] : this->_statics) {
+ auto it = std::find(objs.begin(), objs.end(), t);
+ if(it != objs.end()) {
+ objs.erase(it);
+ break;
+ }
+ }
+ }
+
+ void PhysicEngine::remove(TangibleMovable & t) {
+ for(auto & [p, objs] : this->_dynamic) {
+ auto it = std::find(objs.begin(), objs.end(), t);
+ if(it != objs.end()) {
+ objs.erase(it);
+ break;
+ }
+ }
+ }
+
void PhysicEngine::step(double time) {
this->_collisions.clear();
for(const auto & [priority, layer] : this->_dynamic) {
diff --git a/source/engine/physic/front/engine/Engine.hpp b/source/engine/physic/front/engine/Engine.hpp
index b1db159b6dec5bd702fa414b79a52301f2d0235d..23b08fcb4da24bb7c8e0a04b3bfe2ccefe5f7d7c 100644
--- a/source/engine/physic/front/engine/Engine.hpp
+++ b/source/engine/physic/front/engine/Engine.hpp
@@ -22,6 +22,9 @@ namespace megu {
void push(Priority, TangibleStatic &);
void push(Priority, TangibleMovable &);
+ void remove(TangibleStatic &);
+ void remove(TangibleMovable &);
+
void step(double);
void step(double, Priority);
diff --git a/source/engine/physic/front/object/Tangible.cpp b/source/engine/physic/front/object/Tangible.cpp
index f514928425089c84e6ab4f29259f7b3c9afe5b08..eb6b3dfc334af60e1c98006ed0c792fd9a42b118 100644
--- a/source/engine/physic/front/object/Tangible.cpp
+++ b/source/engine/physic/front/object/Tangible.cpp
@@ -15,7 +15,7 @@ namespace megu {
return this->_box == entity._box;
}
- bool Tangible::operator!=(const Tangible & entity) const {
+ /*bool Tangible::operator!=(const Tangible & entity) const {
return !(*this == entity);
- }
+ }*/
}
\ No newline at end of file
diff --git a/source/engine/physic/front/object/Tangible.hpp b/source/engine/physic/front/object/Tangible.hpp
index 926a4cacefeb83ec910dde7346e0f93776a0ded3..8345cf52c03fa3e2c6393e434da938f6ac44f923 100644
--- a/source/engine/physic/front/object/Tangible.hpp
+++ b/source/engine/physic/front/object/Tangible.hpp
@@ -27,7 +27,7 @@ namespace megu {
bool isColliding(const Tangible &) const;
bool operator==(const Tangible &) const;
- bool operator!=(const Tangible &) const;
+ //bool operator!=(const Tangible &) const;
using UpdateLambda = std::function<void(double)>;
diff --git a/source/game/Game.cpp b/source/game/Game.cpp
index 65d0899ba9fc8e5715ae10866d4b6b56e5e317ef..badff2fce4c12ed25a9e8f2806c2781f871ad2f5 100644
--- a/source/game/Game.cpp
+++ b/source/game/Game.cpp
@@ -2,11 +2,13 @@
#include <kernel/front/Kernel.hpp>
-#include <engine/io/Window.hpp>
-#include <game/utility/FrameCouter.hpp>
+#include <game/back/object/Player.hpp>
+#include <game/back/object/Enemy.hpp>
#include <game/object/Test.hpp>
+#include <game/utility/FrameCouter.hpp>
+
namespace megu::game {
Game::Game(const std::string & title)
: _title(title) {
@@ -22,13 +24,29 @@ namespace megu::game {
kernel::Kernel kernel(window);
auto path = std::filesystem::path("assets/textures/Neera.png");
megu::game::Object object(path);
- kernel.add(&object);
+ //kernel.add(&object);
+
+ Player player(16, 16, 16, 16, path);
+ Enemy enemy(64, 64, 16, 16, path);
+
+ player.setup(kernel);
+ enemy.setup(kernel);
+
+ std::cout << "..." << std::endl;
+
+ player.apply(kernel);
+ enemy.apply(kernel);
+
+ //kernel.remove(&object);
while(window.isOpen()) {
counter.count(Window::Time());
window.pollEvents();
kernel.step();
}
+
+ player.destroy(kernel);
+ enemy.destroy(kernel);
}
catch(std::exception & error) {
std::cerr << "[Error] : " << error.what() << std::endl;
diff --git a/source/game/back/GameObject.hpp b/source/game/back/GameObject.hpp
index a2c7fd743cefee7b97c9a961212e07f2eee1db0d..29ec8a7343198b83752630b46d4b9df8e7ebd9e9 100644
--- a/source/game/back/GameObject.hpp
+++ b/source/game/back/GameObject.hpp
@@ -1,9 +1,12 @@
#pragma once
+#include <kernel/front/Kernel.hpp>
+
namespace megu::game {
class GameObject {
public:
- virtual void setup() = 0;
- virtual void destroy() = 0;
+ virtual void setup(kernel::Kernel &) = 0;
+ virtual void destroy(kernel::Kernel &) = 0;
+ virtual void apply(kernel::Kernel &) = 0;
};
}
\ No newline at end of file
diff --git a/source/game/back/message/Receiver.hpp b/source/game/back/message/Receiver.hpp
deleted file mode 100644
index 326864a5c5d4d2e83e8a0795398efa405bc0c701..0000000000000000000000000000000000000000
--- a/source/game/back/message/Receiver.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <game/back/GameObject.hpp>
-
-namespace megu::game {
- class Message;
-
- class Collider : public GameObject {
- public:
- Collider<>
-
- virtual void setup();
-
- virtual void on(Message &);
- virtual Message make()
- };
-}
\ No newline at end of file
diff --git a/source/game/back/object/Enemy.cpp b/source/game/back/object/Enemy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f635637b58aa13101f854d84a643f1593a240d3f
--- /dev/null
+++ b/source/game/back/object/Enemy.cpp
@@ -0,0 +1,33 @@
+#include "Enemy.hpp"
+
+#include <kernel/front/Kernel.hpp>
+
+namespace megu::game {
+ Enemy::Enemy(float x, float y, float w, float h, std::filesystem::path & path)
+ : kernel::PropsDynamic(this->_sprite, this->_movable), _sprite(path), _movable(x, y, w, h) {
+ this->_sprite.setPosition({x, y});
+ }
+
+ void Enemy::move(float x, float y) {
+ this->_movable.move(x, y);
+ this->_movable.move(x, y);
+ }
+
+ void Enemy::setup(kernel::Kernel &) {
+ this->_sprite.setFrame({0.f, 0.f, 51.f, 98.f});
+ this->_sprite.setSize({51.f, 98.f});
+
+ this->_movable.setCollideLambda([this](kernel::Kernel & kernel, const kernel::PhysicEngine &, const megu::kernel::Physical<kernel::PhysicEngine> &, double) {
+ std::cout << "Enemy Collide !" << std::endl;
+ kernel.remove(this);
+ });
+ }
+
+ void Enemy::destroy(kernel::Kernel &) {
+
+ }
+
+ void Enemy::apply(kernel::Kernel & kernel) {
+ kernel.add(this);
+ }
+}
\ No newline at end of file
diff --git a/source/game/back/object/Enemy.hpp b/source/game/back/object/Enemy.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3d240d3eddd6e69ee36db46f3f0489c1947286c
--- /dev/null
+++ b/source/game/back/object/Enemy.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <game/back/GameObject.hpp>
+#include <kernel/front/props/PropsDynamic.hpp>
+
+namespace megu::game {
+ class Enemy : public kernel::PropsDynamic, public GameObject {
+ public:
+ Enemy(float, float, float, float, std::filesystem::path &);
+
+ void move(float, float);
+
+ void setup(kernel::Kernel &) override;
+ void destroy(kernel::Kernel &) override;
+
+ void apply(kernel::Kernel &) override;
+
+ private:
+ kernel::Sprite _sprite;
+ kernel::Movable _movable;
+ };
+}
\ No newline at end of file
diff --git a/source/game/back/object/Level.cpp b/source/game/back/object/Level.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..844932b05929965e4462f7ee6bfae568a26b0af5
--- /dev/null
+++ b/source/game/back/object/Level.cpp
@@ -0,0 +1,18 @@
+#include "Level.hpp"
+
+namespace megu::game {
+ Level::Level(const std::string & name)
+ : _name(name) {}
+
+ void Level::apply(kernel::Kernel & kernel) {
+ for(auto & [id, prop] : this->_objecs) {
+ kernel.add(prop);
+ }
+ }
+
+ void Level::destroy(kernel::Kernel & kernel) {
+ for(auto & [id, prop] : this->_objecs) {
+ kernel.remove(prop);
+ }
+ }
+}
\ No newline at end of file
diff --git a/source/game/back/object/Level.hpp b/source/game/back/object/Level.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7e7a1eb2e63610b252605a87ccf6fd54bb14207d
--- /dev/null
+++ b/source/game/back/object/Level.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <game/back/GameObject.hpp>
+#include <kernel/front/props/Props.hpp>
+
+namespace megu::game {
+ class Level : public GameObject {
+ private:
+ Level(const std::string &);
+
+ inline const std::string & name() const {return this->_name;}
+
+ virtual void apply(kernel::Kernel &) override final;
+ virtual void destroy(kernel::Kernel &) override final;
+
+ public:
+ std::string _name;
+ std::map<size_t, kernel::Prop *> _objecs;
+
+ };
+}
\ No newline at end of file
diff --git a/source/game/back/object/Player.cpp b/source/game/back/object/Player.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e0164402b7ed2e51edacf766d7d871cee1fefed
--- /dev/null
+++ b/source/game/back/object/Player.cpp
@@ -0,0 +1,34 @@
+#include "Player.hpp"
+
+#include <game/front/profile/PlayerKeys.hpp>
+
+namespace megu::game {
+ Player::Player(float x, float y, float w, float h, std::filesystem::path & path)
+ : kernel::PropsPlayable(this->_sprite, this->_movable), _sprite(path), _movable(x, y, w, h) {
+ this->_sprite.setPosition({x, y});
+ }
+
+ void Player::move(float x, float y) {
+ this->_sprite.move({x, y});
+ this->_movable.move(x, y);
+ }
+
+ void Player::setup(kernel::Kernel & kernel) {
+ this->setControl(kernel.window(), new PlayerKeyProfile(*this));
+
+ this->_sprite.setFrame({0.f, 0.f, 51.f, 98.f});
+ this->_sprite.setSize({51.f, 98.f});
+
+ this->_movable.setCollideLambda([](kernel::Kernel &, const kernel::PhysicEngine &, const megu::kernel::Physical<kernel::PhysicEngine> &, double) {
+ std::cout << "Player Collide !" << std::endl;
+ });
+ }
+
+ void Player::destroy(kernel::Kernel &) {
+
+ }
+
+ void Player::apply(kernel::Kernel & kernel) {
+ kernel.add(this);
+ }
+}
\ No newline at end of file
diff --git a/source/game/back/object/Player.hpp b/source/game/back/object/Player.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..74c7be8b38cdbd298d0e83e3654752282344cd36
--- /dev/null
+++ b/source/game/back/object/Player.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <kernel/front/props/PropsPlayable.hpp>
+#include <game/back/GameObject.hpp>
+
+namespace megu::game {
+ class Player : public kernel::PropsPlayable, public GameObject {
+ public:
+ Player(float x, float y, float w, float h, std::filesystem::path &);
+
+ void move(float, float);
+
+ void setup(kernel::Kernel &) override;
+ void destroy(kernel::Kernel &) override;
+
+ void apply(kernel::Kernel &) override;
+
+ private:
+ kernel::Sprite _sprite;
+ kernel::Movable _movable;
+ };
+}
\ No newline at end of file
diff --git a/source/game/back/object/Terrain.hpp b/source/game/back/object/Terrain.hpp
deleted file mode 100644
index 0058a3c29eac18546dc1eeeb1665439567a213fa..0000000000000000000000000000000000000000
--- a/source/game/back/object/Terrain.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <kernel/front/props/PropsTileMap.hpp>
-
-namespace megu::game {
- class Terrain : public kernel::PropsTileMap {
- public:
- Terrain(float, float);
-
- private:
- kernel::Tilemap _graphicMap;
- kernel::FixedArray _solidMap;
- };
-}
\ No newline at end of file
diff --git a/source/game/front/profile/PlayerKeys.cpp b/source/game/front/profile/PlayerKeys.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d835a9608372fdf2b3bbd79baabec266b103c75
--- /dev/null
+++ b/source/game/front/profile/PlayerKeys.cpp
@@ -0,0 +1,24 @@
+#include "PlayerKeys.hpp"
+
+namespace megu::game {
+ PlayerKeyProfile::PlayerKeyProfile(Player & player)
+ : _player(player) {}
+
+ void PlayerKeyProfile::on(Key key, int code, Action action, Mod mode) {
+ if(key == Keyboard::Key::ARROW_UP) {
+ this->_player.move(0.f, 1.f);
+ }
+
+ if(key == Keyboard::Key::ARROW_DOWN) {
+ this->_player.move(0.f, -1.f);
+ }
+
+ if(key == Keyboard::Key::ARROW_LEFT) {
+ this->_player.move(-1.f, 0.f);
+ }
+
+ if(key == Keyboard::Key::ARROW_RIGHT) {
+ this->_player.move(1.f, 0.f);
+ }
+ }
+}
\ No newline at end of file
diff --git a/source/game/front/profile/PlayerKeys.hpp b/source/game/front/profile/PlayerKeys.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..47b53018767ef87843841b7b850a248c7acdf51b
--- /dev/null
+++ b/source/game/front/profile/PlayerKeys.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <game/back/object/Player.hpp>
+
+#include <engine/io/Keyboard.hpp>
+#include <engine/io/Mouse.hpp>
+
+namespace megu::game {
+ class PlayerKeyProfile : public Keyboard {
+ public:
+ PlayerKeyProfile(Player &);
+
+ virtual void on(Key, int, Action, Mod);
+
+ private:
+ Player & _player;
+ };
+}
\ No newline at end of file
diff --git a/source/kernel/back/component/Component.hpp b/source/kernel/back/component/Component.hpp
index 2a3538ab0b5f27f0d138bad4909da08c8c93e00c..b95d28028461cea183ce507563e4837cf50f5819 100644
--- a/source/kernel/back/component/Component.hpp
+++ b/source/kernel/back/component/Component.hpp
@@ -10,5 +10,6 @@ namespace megu::kernel {
class Component : public virtual Identifiable {
public:
virtual void apply(Kernel & k, E &) = 0;
+ virtual void unapply(Kernel & k, E &) = 0;
};
}
\ No newline at end of file
diff --git a/source/kernel/back/component/Physical.hpp b/source/kernel/back/component/Physical.hpp
index 23028afe98a9de12cdd9d9bd5d685b1ac71a8bd1..3db5579ec82d7baecf8d95b92177745213a04a90 100644
--- a/source/kernel/back/component/Physical.hpp
+++ b/source/kernel/back/component/Physical.hpp
@@ -9,8 +9,8 @@ namespace megu::kernel {
template <class Pe>
class Physical : public Component<Pe> {
public:
- virtual void on_collide(const Kernel &, const Pe &, Physical &, double) = 0;
+ virtual void on_collide(Kernel &, const Pe &, Physical &, double) = 0;
- using CollideLambda = std::function<void(const Kernel &, const Pe &, const Physical &, double)>;
+ using CollideLambda = std::function<void(Kernel &, const Pe &, const Physical &, double)>;
};
}
\ No newline at end of file
diff --git a/source/kernel/back/engine/Engine.hpp b/source/kernel/back/engine/Engine.hpp
index b69f67fff6e3c5c7be5293da146c8f3e7ecd08d2..8842381e573323690742b546eff4e1693399f3c5 100644
--- a/source/kernel/back/engine/Engine.hpp
+++ b/source/kernel/back/engine/Engine.hpp
@@ -15,5 +15,6 @@ namespace megu::kernel {
virtual const O & get(const C &) const = 0;
virtual void add(Kernel &, C &) = 0;
+ virtual void remove(Kernel &, C &) = 0;
};
}
\ No newline at end of file
diff --git a/source/kernel/back/engine/GraphicEngine.cpp b/source/kernel/back/engine/GraphicEngine.cpp
index 2ee0f7050a72b4fede19cae10e8b7e34f06156cf..efb84180ef06817205aed822de9f627433d1a0ba 100644
--- a/source/kernel/back/engine/GraphicEngine.cpp
+++ b/source/kernel/back/engine/GraphicEngine.cpp
@@ -22,6 +22,10 @@ namespace megu::kernel {
graphical.apply(kernel, *this);
}
+ void GraphicEngine::remove(Kernel & kernel, Graphical<GraphicEngine> & graphical) {
+ graphical.unapply(kernel, *this);
+ }
+
const Renderable & GraphicEngine::get(const Graphical<GraphicEngine> & graphical) const {
auto object = this->_engine.get(graphical);
if(object.has_value()) {
diff --git a/source/kernel/back/engine/GraphicEngine.hpp b/source/kernel/back/engine/GraphicEngine.hpp
index d0d9811639d9bbf26f98a36a92af82969d68c016..77ce58f4d206378f1fd31ec4a7c513572b5e149a 100644
--- a/source/kernel/back/engine/GraphicEngine.hpp
+++ b/source/kernel/back/engine/GraphicEngine.hpp
@@ -24,6 +24,7 @@ namespace megu::kernel {
void step(Kernel &, double) override;
void add(Kernel &, Graphical<GraphicEngine> &) override;
+ void remove(Kernel &, Graphical<GraphicEngine> &) override;
const megu::Renderable & get(const Graphical<GraphicEngine> &) const override;
diff --git a/source/kernel/back/engine/PhysicEngine.cpp b/source/kernel/back/engine/PhysicEngine.cpp
index 25e1c3ae57883f723fb61113a178647d3f65d26a..26476f5ccf355024dd1bb79900438d2ad6c03459 100644
--- a/source/kernel/back/engine/PhysicEngine.cpp
+++ b/source/kernel/back/engine/PhysicEngine.cpp
@@ -22,6 +22,10 @@ namespace megu::kernel {
props.apply(kernel, *this);
}
+ void PhysicEngine::remove(Kernel & kernel, Physical<PhysicEngine> & props) {
+ props.unapply(kernel, *this);
+ }
+
const megu::Tangible & PhysicEngine::get(const Physical<PhysicEngine> & props) const {
auto tangible = this->_engine.get(props);
if(tangible.has_value()) {
diff --git a/source/kernel/back/engine/PhysicEngine.hpp b/source/kernel/back/engine/PhysicEngine.hpp
index 7a7f441e83dc878fec796d33bcd1eefee65688a0..59921974c80ad27714b4c106300466a7cd382d6b 100644
--- a/source/kernel/back/engine/PhysicEngine.hpp
+++ b/source/kernel/back/engine/PhysicEngine.hpp
@@ -17,6 +17,7 @@ namespace megu::kernel {
void step(Kernel &, double) override;
void add(Kernel &, Physical<PhysicEngine> &) override;
+ void remove(Kernel &, Physical<PhysicEngine> &) override;
const megu::Tangible & get(const Physical<PhysicEngine> &) const override;
diff --git a/source/kernel/back/linker/GraphicLinker.hpp b/source/kernel/back/linker/GraphicLinker.hpp
index 12d87d04de78f318861350fe7aee28e3f57bd5af..a4947a8a33d9aa086f28e65156913cc85fa465e5 100644
--- a/source/kernel/back/linker/GraphicLinker.hpp
+++ b/source/kernel/back/linker/GraphicLinker.hpp
@@ -1,9 +1,11 @@
#pragma once
#include "Linker.hpp"
-#include "PriorityPair.hpp"
#include <kernel/back/engine/GraphicEngine.hpp>
+#include <stack>
+#include "RenderTrace.hpp"
+
namespace megu::kernel {
template <class T>
class GraphicLinker : public Linker<GraphicEngine> {
@@ -11,17 +13,21 @@ namespace megu::kernel {
GraphicLinker();
void link(T &, Priority, Priority);
+ void unlink(T &);
+
void link(GraphicEngine &) override;
void setModule(Module<ref_set<T>> *);
inline bool haveModule() const {return this->_module.get() != nullptr;}
- inline ref_set<T> & objects() {return this->_object;}
private:
std::unique_ptr<Module<ref_set<T>>> _module;
- std::map<Priority_Pair, ref_set<T>> _objects;
- std::set<Priority_Pair> _waiting;
+
+ std::map<RenderTrace, ref_set<T>> _stored;
+ std::map<RenderTrace, size_t> _ids;
+ std::set<RenderTrace> _await;
+ std::set<RenderTrace> _delete;
};
}
-#include "GraphicLinker.tpp"
\ No newline at end of file
+#include "GraphicLinker.tpp"
diff --git a/source/kernel/back/linker/GraphicLinker.tpp b/source/kernel/back/linker/GraphicLinker.tpp
index 2fccee83be8fe35cbd9154931ffc995a0cc38e52..28c72be827f6535d924bb834329b056c378cb956 100644
--- a/source/kernel/back/linker/GraphicLinker.tpp
+++ b/source/kernel/back/linker/GraphicLinker.tpp
@@ -7,23 +7,61 @@ namespace megu::kernel {
template <class T>
void GraphicLinker<T>::link(T & object, Priority l, Priority o) {
- auto layers = Priority_Pair{l, o};
-
- this->_objects[layers].insert(object);
- this->_waiting.insert(layers);
+ auto layers = RenderTrace{l, o};
+ this->_stored[layers].insert(object);
+ this->_await.insert(layers);
}
template <class T>
void GraphicLinker<T>::link(GraphicEngine & engine) {
- for(const auto & layers : this->_waiting) {
- engine.get().push(layers.layer, layers.object, this->_objects[layers], this->_module.get());
+ for(const auto & layer : this->_delete) {
+ engine.get().remove(Identifiable(this->_ids[layer]));
}
- this->_waiting.clear();
+ this->_delete.clear();
+
+ for(auto & layer : this->_await) {
+ size_t id = engine.get().push(layer.layer, layer.object, this->_stored[layer], this->_module.get());
+ this->_ids[layer] = id;
+ }
+
+ this->_await.clear();
+ }
+
+ template <class T>
+ void GraphicLinker<T>::unlink(T & object) {
+ for(auto it = this->_stored.begin(); it != this->_stored.end();) {
+ bool contains = false;
+ for(auto its = it->second.begin(); its != it->second.end();) {
+ if(&(its->get()) == &object) {
+ contains = true;
+ it->second.erase(its);
+ break;
+ }
+ else {
+ ++its;
+ }
+ }
+
+ if(contains) {
+ this->_delete.insert(it->first);
+ this->_await.insert(it->first);
+ if(it->second.empty()) {
+ it = this->_stored.erase(it);
+ }
+ else {
+ ++it;
+ }
+ break;
+ }
+ else {
+ ++it;
+ }
+ }
}
template <class T>
void GraphicLinker<T>::setModule(Module<ref_set<T>> * mod) {
this->_module = std::unique_ptr<Module<ref_set<T>>>(mod);
}
-}
\ No newline at end of file
+}
diff --git a/source/kernel/back/linker/PriorityPair.hpp b/source/kernel/back/linker/PriorityPair.hpp
deleted file mode 100644
index 091ad26ea15bbe0bdd864aaf6bc265fb6f186f53..0000000000000000000000000000000000000000
--- a/source/kernel/back/linker/PriorityPair.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <engine/utility/Priority.hpp>
-
-namespace megu::kernel {
- struct Priority_Pair {
- Priority layer;
- Priority object;
-
- bool operator<(const Priority_Pair & pp) const {
- if(this->layer == pp.layer) {
- return this->object < pp.object;
- }
- return this->layer < pp.layer;
- }
- };
-}
\ No newline at end of file
diff --git a/source/kernel/back/linker/RenderTrace.hpp b/source/kernel/back/linker/RenderTrace.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..00dcdb0c8a9ccc62d970ab0403bc0f6d7a2fbffd
--- /dev/null
+++ b/source/kernel/back/linker/RenderTrace.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <engine/utility/Priority.hpp>
+
+namespace megu::kernel {
+ struct RenderTrace {
+ Priority layer;
+ Priority object;
+
+ bool operator<(const RenderTrace & trace) const {
+ if(this->layer == trace.layer) {
+ return this->object < trace.object;
+ }
+ return this->layer < trace.layer;
+ }
+ };
+}
\ No newline at end of file
diff --git a/source/kernel/back/linker/UniqueLinker.hpp b/source/kernel/back/linker/UniqueLinker.hpp
index 9453bab77063af9d17b0f882d7fdb23e0b336649..238685627d401ab22c0712dcd1931f303757ca83 100644
--- a/source/kernel/back/linker/UniqueLinker.hpp
+++ b/source/kernel/back/linker/UniqueLinker.hpp
@@ -1,9 +1,10 @@
#pragma once
#include "Linker.hpp"
-#include "PriorityPair.hpp"
#include <kernel/back/engine/GraphicEngine.hpp>
+#include "RenderTrace.hpp"
+
namespace megu::kernel {
template <class T>
class UniqueGraphicLinker : public Linker<GraphicEngine> {
@@ -11,17 +12,22 @@ namespace megu::kernel {
UniqueGraphicLinker();
void link(T &, Priority, Priority);
+ void unlink(T &);
+
void link(GraphicEngine &) override;
void setModule(Module<T> *);
inline bool haveModule() const {return this->_module.get() != nullptr;}
- inline ref_set<T> & objects() {return this->_object;}
private:
std::unique_ptr<Module<T>> _module;
- std::map<Priority_Pair, ref_set<T>> _objects;
- std::set<Priority_Pair> _waiting;
+ std::map<RenderTrace, std::pair<std::reference_wrapper<T>, size_t>> _stored;
+ std::map<RenderTrace, std::reference_wrapper<T>> _await;
+ std::map<RenderTrace, size_t> _ids;
+
+ std::set<RenderTrace> _delete;
+
};
}
-#include "UniqueLinker.tpp"
\ No newline at end of file
+#include "UniqueLinker.tpp"
diff --git a/source/kernel/back/linker/UniqueLinker.tpp b/source/kernel/back/linker/UniqueLinker.tpp
index 9265d6c5541bf9649a1987a16211ed67fc55cea3..907a1069285edf757a78d2645791143bc2531cad 100644
--- a/source/kernel/back/linker/UniqueLinker.tpp
+++ b/source/kernel/back/linker/UniqueLinker.tpp
@@ -7,25 +7,38 @@ namespace megu::kernel {
template <class T>
void UniqueGraphicLinker<T>::link(T & object, Priority l, Priority o) {
- auto layers = Priority_Pair{l, o};
-
- this->_objects[layers].insert(object);
- this->_waiting.insert(layers);
+ auto layers = RenderTrace{l, o};
+ this->_await.insert({layers, object});
}
template <class T>
void UniqueGraphicLinker<T>::link(GraphicEngine & engine) {
- for(const auto & layers : this->_waiting) {
- for(auto & object : this->_objects[layers]) {
- engine.get().push<T>(layers.layer, layers.object, object, this->_module.get());
- }
+ for(const auto & layer : this->_delete) {
+ engine.get().remove(Identifiable(this->_ids[layer]));
+ }
+
+ this->_delete.clear();
+
+ for(auto & [layer, object] : this->_await) {
+ this->_stored.insert({layer, object});
+ size_t id = engine.get().push<T>(layer.layer, layer.object, this->_stored[layer], this->_module.get());
+ this->_ids[layer] = id;
}
- this->_waiting.clear();
+ this->_await.clear();
+ }
+
+ template <class T>
+ void UniqueGraphicLinker<T>::unlink(T & object) {
+ for(auto & [layer, obj] : this->_stored) {
+ if(&(obj.get()) == &object) {
+ this->_delete.insert(layer);
+ }
+ }
}
template <class T>
void UniqueGraphicLinker<T>::setModule(Module<T> * mod) {
this->_module = std::unique_ptr<Module<T>>(mod);
}
-}
\ No newline at end of file
+}
diff --git a/source/kernel/front/Kernel.cpp b/source/kernel/front/Kernel.cpp
index e0a917b1347466f9fa4767289a06eaaa85cea1a8..8e66ea92fb3022de8c6a1c65af9a6fdb41fffbf5 100644
--- a/source/kernel/front/Kernel.cpp
+++ b/source/kernel/front/Kernel.cpp
@@ -38,4 +38,20 @@ namespace megu::kernel {
this->_gResolver.add(*gComponent);
}
}
+
+ void Kernel::remove(Prop * props) {
+ auto * pComponent = props->getPhysicComponent();
+ if(pComponent != nullptr) {
+ this->_pEngine.remove(*this, *pComponent);
+ this->_pResolver.remove(*pComponent);
+ }
+
+ auto * gComponent = props->getGraphicComponent();
+ if(gComponent != nullptr) {
+ this->_gEngine.remove(*this, *gComponent);
+ this->_gResolver.remove(*gComponent);
+ }
+
+ this->_props.erase(props->id());
+ }
}
\ No newline at end of file
diff --git a/source/kernel/front/Kernel.hpp b/source/kernel/front/Kernel.hpp
index f6b7b7ab1af7a36e2f0d9a82af03056ae074010c..e7e7f047c20ad34b87d253b4ed7fad70cbd1ea9c 100644
--- a/source/kernel/front/Kernel.hpp
+++ b/source/kernel/front/Kernel.hpp
@@ -20,12 +20,15 @@ namespace megu::kernel {
void step();
void add(Prop *);
-
+ void remove(Prop *);
+
inline Identifiable_Map<Prop> & props() {return this->_props;}
inline PhysicEngine & getPhysicEngine() {return this->_pEngine;}
inline GraphicEngine & getGraphicEngine() {return this->_gEngine;}
+ inline Window & window() {return this->_window;}
+
private:
Window & _window;
diff --git a/source/kernel/front/component/graphic/Sprite.cpp b/source/kernel/front/component/graphic/Sprite.cpp
index c5f506950b5372680b739e35504f0d5c8eb3678c..ba3cbb9fcbb8b1f790975a8ca4d8637050591798 100644
--- a/source/kernel/front/component/graphic/Sprite.cpp
+++ b/source/kernel/front/component/graphic/Sprite.cpp
@@ -79,4 +79,9 @@ namespace megu::kernel {
Sprite::_Linker.link(*this, this->getLayerPriority(), this->getObjectPriority());
Sprite::_Linker.link(engine);
}
+
+ void Sprite::unapply(Kernel & kernel, GraphicEngine & engine) {
+ Sprite::_Linker.unlink(*this);
+ Sprite::_Linker.link(engine);
+ }
}
\ No newline at end of file
diff --git a/source/kernel/front/component/graphic/Sprite.hpp b/source/kernel/front/component/graphic/Sprite.hpp
index 5d1420fe79bf821e1db8fb633c94f4c8f3875703..b3bcc561717674f1588cb53bdb2800fd7f4a50fa 100644
--- a/source/kernel/front/component/graphic/Sprite.hpp
+++ b/source/kernel/front/component/graphic/Sprite.hpp
@@ -36,6 +36,7 @@ namespace megu::kernel {
void update(double) override;
void apply(Kernel &, GraphicEngine &) override;
+ void unapply(Kernel &, GraphicEngine &) override;
static const GraphicLinker<megu::Sprite> & linker() {return Sprite::_Linker;}
diff --git a/source/kernel/front/component/graphic/TileMap.cpp b/source/kernel/front/component/graphic/TileMap.cpp
index 83cd774011a25a2cf4fccbb408d0befbb0970a80..e0df788668b17bc628f0f9896eccbf71c6ec370a 100644
--- a/source/kernel/front/component/graphic/TileMap.cpp
+++ b/source/kernel/front/component/graphic/TileMap.cpp
@@ -95,4 +95,9 @@ namespace megu::kernel {
Tilemap::_Linker.link(*this, this->getLayerPriority(), this->getObjectPriority());
Tilemap::_Linker.link(engine);
}
+
+ void Tilemap::unapply(Kernel & kernel, GraphicEngine & engine) {
+ Tilemap::_Linker.unlink(*this);
+ Tilemap::_Linker.link(engine);
+ }
}
\ No newline at end of file
diff --git a/source/kernel/front/component/graphic/TileMap.hpp b/source/kernel/front/component/graphic/TileMap.hpp
index bdbc02b043cb5284e96e337882b3ac95759a478d..6d6ad9d8c548d4ca646ce4de432ca6ccd6911fb0 100644
--- a/source/kernel/front/component/graphic/TileMap.hpp
+++ b/source/kernel/front/component/graphic/TileMap.hpp
@@ -37,6 +37,7 @@ namespace megu::kernel {
void update(double) override;
void apply(Kernel &, GraphicEngine &) override;
+ void unapply(Kernel &, GraphicEngine &) override;
private:
std::vector<TilePosition> _tilesPosition;
diff --git a/source/kernel/front/component/physic/Fixed.cpp b/source/kernel/front/component/physic/Fixed.cpp
index e981a4234a7eacbcbcfcab7f4a170bda4c66c41f..8964777a9f1dbb77cdcebe6aaebf7d0a2a9c295c 100644
--- a/source/kernel/front/component/physic/Fixed.cpp
+++ b/source/kernel/front/component/physic/Fixed.cpp
@@ -12,7 +12,7 @@ namespace megu::kernel {
}
}
- void Fixed::on_collide(const Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
+ void Fixed::on_collide(Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
if(this->_collide != nullptr) {
this->_collide(kernel, engine, physical, time);
}
@@ -22,11 +22,15 @@ namespace megu::kernel {
engine.get().push(0, *this);
}
- void Fixed::setCollideLambda(const CollideLambda & lambda) {
+ void Fixed::unapply(Kernel & kernel, PhysicEngine & engine) {
+ engine.get().remove(*this);
+ }
+
+ void Fixed::setCollideLambda(CollideLambda lambda) {
this->_collide = lambda;
}
- void Fixed::setUpdateLambda(const UpdateLambda & lambda) {
+ void Fixed::setUpdateLambda(UpdateLambda lambda) {
this->_update = lambda;
}
}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/Fixed.hpp b/source/kernel/front/component/physic/Fixed.hpp
index 14e086b9367f7d46b0b41e98ae373db1be3a0547..232084ab72cbfbac051dfde9c23f1baff42dd062 100644
--- a/source/kernel/front/component/physic/Fixed.hpp
+++ b/source/kernel/front/component/physic/Fixed.hpp
@@ -13,17 +13,15 @@ namespace megu::kernel {
Fixed(float x, float y, float w, float h);
void update_physic(double) const override;
- void on_collide(const Kernel &, const PhysicEngine &, Physical &, double) override;
+ void on_collide(Kernel &, const PhysicEngine &, Physical &, double) override;
void apply(Kernel & k, PhysicEngine &) override;
+ void unapply(Kernel & k, PhysicEngine &) override;
- void setCollideLambda(const CollideLambda &);
- void setUpdateLambda(const UpdateLambda &);
+ void setCollideLambda(CollideLambda);
+ void setUpdateLambda(UpdateLambda);
private:
CollideLambda _collide;
UpdateLambda _update;
-
-
-
};
}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/FixedArray.cpp b/source/kernel/front/component/physic/FixedArray.cpp
index 427287505bf5493d6f5566773358bc6649e2722b..5e5602dfe943dd4c3f445694b1a38b2677a5fd85 100644
--- a/source/kernel/front/component/physic/FixedArray.cpp
+++ b/source/kernel/front/component/physic/FixedArray.cpp
@@ -22,7 +22,7 @@ namespace megu::kernel {
this->_tangibles.erase(position);
}
- void FixedArray::on_collide(const Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
+ void FixedArray::on_collide(Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
auto & tangible = engine.get(physical);
for(auto & [position, fixed] : this->_tangibles) {
if(fixed.isColliding(tangible)) {
@@ -40,4 +40,16 @@ namespace megu::kernel {
void FixedArray::apply(Kernel & kernel, PhysicEngine & engine) {
engine.get().push(0, *this);
}
+
+ void FixedArray::unapply(Kernel & kernel, PhysicEngine & engine) {
+ engine.get().remove(*this);
+ }
+
+ void FixedArray::setCollideLambda(CollideLambda lambda) {
+ this->_collide = lambda;
+ }
+
+ void FixedArray::setUpdateLambda(UpdateLambda lambda) {
+ this->_update = lambda;
+ }
}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/FixedArray.hpp b/source/kernel/front/component/physic/FixedArray.hpp
index c506453abbc56f5542c424f42c3acef95d015ac0..9f04d44a9c46a74331615647dc96c19ce72d4199 100644
--- a/source/kernel/front/component/physic/FixedArray.hpp
+++ b/source/kernel/front/component/physic/FixedArray.hpp
@@ -16,12 +16,13 @@ namespace megu::kernel {
void erase(const Fixed &);
void erase(const Position &);
- void setCollideLambda(CollideLambda &);
- void setUpdateLambda(UpdateLambda &);
+ void setCollideLambda(CollideLambda);
+ void setUpdateLambda(UpdateLambda);
void update_physic(double) const override;
- void on_collide(const Kernel &, const PhysicEngine &, Physical &, double) override;
+ void on_collide(Kernel &, const PhysicEngine &, Physical &, double) override;
void apply(Kernel & k, PhysicEngine &) override;
+ void unapply(Kernel & k, PhysicEngine &) override;
private:
std::map<Position, Fixed> _tangibles;
diff --git a/source/kernel/front/component/physic/Movable.cpp b/source/kernel/front/component/physic/Movable.cpp
index 0fd7504d963f0d1fbbaed76c1a7853a7d881446a..ac592e601962466e8a3acdb0d4b7cd1c0827f520 100644
--- a/source/kernel/front/component/physic/Movable.cpp
+++ b/source/kernel/front/component/physic/Movable.cpp
@@ -10,21 +10,25 @@ namespace megu::kernel {
}
}
- void Movable::on_collide(const Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
+ void Movable::on_collide(Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
if(this->_collide != nullptr) {
this->_collide(kernel, engine, physical, time);
}
}
void Movable::apply(Kernel & kernel, PhysicEngine & engine) {
- engine.add(kernel, *this);
+ engine.get().push(0, *this);
}
- void Movable::setCollideLambda(CollideLambda & lambda) {
+ void Movable::unapply(Kernel & kernel, PhysicEngine & engine) {
+ engine.get().remove(*this);
+ }
+
+ void Movable::setCollideLambda(CollideLambda lambda) {
this->_collide = lambda;
}
- void Movable::setUpdateLambda(UpdateLambda & lambda) {
+ void Movable::setUpdateLambda(UpdateLambda lambda) {
this->_update = lambda;
}
}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/Movable.hpp b/source/kernel/front/component/physic/Movable.hpp
index 2e83bf9c9935970d04b3c96cb9b7f019e150349f..f1cd9ff7ae544d81faddbc3e7edbc284d29b7a4e 100644
--- a/source/kernel/front/component/physic/Movable.hpp
+++ b/source/kernel/front/component/physic/Movable.hpp
@@ -13,11 +13,12 @@ namespace megu::kernel {
Movable(float x, float y, float w, float h);
void update_physic(double) override;
- void on_collide(const Kernel &, const PhysicEngine &, Physical &, double) override;
+ void on_collide(Kernel &, const PhysicEngine &, Physical &, double) override;
void apply(Kernel & k, PhysicEngine &) override;
+ void unapply(Kernel & k, PhysicEngine &) override;
- void setCollideLambda(CollideLambda &);
- void setUpdateLambda(UpdateLambda &);
+ void setCollideLambda(CollideLambda);
+ void setUpdateLambda(UpdateLambda);
private:
CollideLambda _collide;
diff --git a/source/kernel/front/props/PropsPlayable.cpp b/source/kernel/front/props/PropsPlayable.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cf28c48346fb10106dda2a0132f3026451f74f9c
--- /dev/null
+++ b/source/kernel/front/props/PropsPlayable.cpp
@@ -0,0 +1,18 @@
+#include "PropsPlayable.hpp"
+
+#include <engine/io/Window.hpp>
+
+namespace megu::kernel {
+ PropsPlayable::PropsPlayable(Sprite & graphic, Movable & physic)
+ : _graphic(graphic), _physic(physic) {}
+
+ void PropsPlayable::setControl(Window & window, Keyboard * keyboard) {
+ this->_profiler.set(keyboard);
+ this->_profiler.link(window);
+ }
+
+ void PropsPlayable::setControl(Window & window, Mouse * mouse) {
+ this->_profiler.set(mouse);
+ this->_profiler.link(window);
+ }
+}
\ No newline at end of file
diff --git a/source/kernel/front/props/PropsPlayable.hpp b/source/kernel/front/props/PropsPlayable.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8857cd2f816ddea19f7c21128900e105bdce4a85
--- /dev/null
+++ b/source/kernel/front/props/PropsPlayable.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <kernel/front/props/Props.hpp>
+#include <kernel/front/component/graphic/Sprite.hpp>
+#include <kernel/front/component/physic/Movable.hpp>
+
+#include <engine/io/Profiler.hpp>
+
+namespace megu {
+ class Window;
+}
+
+namespace megu::kernel {
+ class PropsPlayable : public Prop {
+ public:
+ PropsPlayable(Sprite &, Movable &);
+
+ void setControl(Window &, Keyboard *);
+ void setControl(Window &, Mouse *);
+
+ virtual Graphical_Component * getGraphicComponent() {return &this->_graphic;}
+ virtual Physical_Component * getPhysicComponent() {return &this->_physic;}
+
+ private:
+ Sprite & _graphic;
+ Movable & _physic;
+ Profiler _profiler;
+ };
+}
\ No newline at end of file
diff --git a/source/kernel/front/resolver/Resolver.hpp b/source/kernel/front/resolver/Resolver.hpp
index 0e63f12074d32ddbe48436810f4eb263d53fe9ab..40ac2935c7e3a5b0e56ab9690e281babf9edcb0e 100644
--- a/source/kernel/front/resolver/Resolver.hpp
+++ b/source/kernel/front/resolver/Resolver.hpp
@@ -12,7 +12,7 @@ namespace megu::kernel {
inline ref_set<O> & components() {return this->_components;}
void add(O &);
- void erase(const Identifiable &);
+ void remove(const Identifiable &);
std::optional<std::reference_wrapper<O>> get(const Identifiable &);
virtual void resolve(Kernel &, E &, double) = 0;
diff --git a/source/kernel/front/resolver/Resolver.tpp b/source/kernel/front/resolver/Resolver.tpp
index 0a4beb034b0a5519fe55b6a961d0b3e9fc7b8aed..89f265d4c5c7e144d4df10ca53e45dd2cc1a0e18 100644
--- a/source/kernel/front/resolver/Resolver.tpp
+++ b/source/kernel/front/resolver/Resolver.tpp
@@ -7,8 +7,9 @@ namespace megu::kernel {
}
template <class E, class O>
- void Resolver<E, O>::erase(const Identifiable & c) {
- this->_components.erase(c);
+ void Resolver<E, O>::remove(const Identifiable & c) {
+ auto it = std::find(this->_components.begin(), this->_components.end(), c);
+ this->_components.erase(it);
}
template <class E, class O>
diff --git a/source/main.cpp b/source/main.cpp
index 7b12b5b585d2d667e4fdbd2ade24b07c558060ae..b62fee207752590aa4fd4a3ac2a6d799f263f346 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -9,52 +9,4 @@ int main(int argc, const char * argv[]) {
std::cout << "Running..." << std::endl;
return game.run();
-}
-
-/*int main(int argc, const char * argv[]) {
- std::cout << "Program Init" << std::endl;
- try {
- megu::Window window;
- window.open("Kernel Test", WINDOW_WIDTH, WINDOW_HEIGHT);
- std::cout << "Window Init" << std::endl;
-
- megu::kernel::Kernel kernel(window);
- std::cout << "Kernel Init" << std::endl;
-
- auto path = std::filesystem::path("assets/textures/Neera.png");
- megu::game::Object object(path);
-
- megu::game::Object object2(path);
- object2.tmp_setPos(100, 0);
-
- std::cout << "Object Init" << std::endl;
- kernel.add(&object2);
- kernel.add(&object);
-
- double previousTime = megu::Window::Time();
- int frameCount = 0;
-
- std::cout << "Render Loop Init" << std::endl;
- while(window.isOpen()) {
- double currentTime = megu::Window::Time();
- frameCount++;
-
- if(currentTime - previousTime >= 1.0) {
- window.setTitle(std::to_string(frameCount));
-
- frameCount = 0;
- previousTime = currentTime;
- }
-
- window.pollEvents();
- kernel.step();
- }
- std::cout << "Render Loop End" << std::endl;
- }
- catch(std::exception & error) {
- std::cerr << error.what() << std::endl;
- }
-
- std::cout << "Program End" << std::endl;
- return EXIT_SUCCESS;
-}*/
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/source/utility/Identifiable.cpp b/source/utility/Identifiable.cpp
index 02c063ba47bc4c69afb139f2c10275c2068a266e..8490b367f61f0e282585bafce568bb39032c6c3f 100644
--- a/source/utility/Identifiable.cpp
+++ b/source/utility/Identifiable.cpp
@@ -20,9 +20,9 @@ namespace megu {
return this->_id == identifiable._id;
}
- bool Identifiable::operator!=(const Identifiable & identifiable) const {
+ /*bool Identifiable::operator!=(const Identifiable & identifiable) const {
return !(*this == identifiable);
- }
+ }*/
bool Identifiable::operator<=(const Identifiable & identifiable) const {
return this->_id <= identifiable._id;
diff --git a/source/utility/Identifiable.hpp b/source/utility/Identifiable.hpp
index 11e91f565dd752fc3481c6c6d6ad51c38d86f2de..5c1fc1b9c8b6294427485e53da2682eb31d68e7d 100644
--- a/source/utility/Identifiable.hpp
+++ b/source/utility/Identifiable.hpp
@@ -15,7 +15,7 @@ namespace megu {
inline void setId(size_t id) {this->_id = id;}
bool operator==(const Identifiable &) const;
- bool operator!=(const Identifiable &) const;
+ //bool operator!=(const Identifiable &) const;
bool operator>=(const Identifiable &) const;
bool operator<=(const Identifiable &) const;