diff --git a/source/engine/graphics/front/engine/Engine.cpp b/source/engine/graphics/front/engine/Engine.cpp
index a47862c12a3480ea7938e8d605986230b9dd1f61..9adda5a3d7ad97f0769c82d6c124c7725618d18c 100644
--- a/source/engine/graphics/front/engine/Engine.cpp
+++ b/source/engine/graphics/front/engine/Engine.cpp
@@ -32,6 +32,16 @@ namespace megu {
return {};
}
+ std::optional<std::reference_wrapper<const Renderable>> GraphicEngine::get(const Identifiable & id) const {
+ for(const auto & [p, layer] : this->_layers) {
+ auto renderable = layer->get(id);
+ if(renderable.has_value()) {
+ return renderable;
+ }
+ }
+ return {};
+ }
+
void GraphicEngine::step() {
if(this->_window.isOpen()) {
// Draw Layers
diff --git a/source/engine/graphics/front/engine/Engine.hpp b/source/engine/graphics/front/engine/Engine.hpp
index 7d83972c829dd8fd75312a4929a19f28141b1b6d..f85a3365579a61074d38235cffbb8f582c358b94 100644
--- a/source/engine/graphics/front/engine/Engine.hpp
+++ b/source/engine/graphics/front/engine/Engine.hpp
@@ -30,6 +30,7 @@ namespace megu {
void remove(Priority);
std::optional<std::reference_wrapper<const Layer>> get(Priority) const;
+ std::optional<std::reference_wrapper<const Renderable>> get(const Identifiable &) const;
inline bool empty() const {return this->_layers.empty();}
inline const std::map<Priority, std::unique_ptr<Layer>> & layers() const {return this->_layers;}
diff --git a/source/engine/graphics/front/engine/Layer.hpp b/source/engine/graphics/front/engine/Layer.hpp
index a1dbccead8a58e09a502d76f78c6222b7dfd1d82..5b6febabf6437f522ba55db61b002cdb34ae10fc 100644
--- a/source/engine/graphics/front/engine/Layer.hpp
+++ b/source/engine/graphics/front/engine/Layer.hpp
@@ -37,6 +37,14 @@ namespace megu {
this->_objects[priority] = renderable;
}*/
+ std::optional<std::reference_wrapper<const Renderable>> get(const Identifiable & id) const {
+ for(const auto & [priority, object] : this->_objects) {
+ if(object.id() == id.id()) {
+ return object;
+ }
+ }
+ }
+
const Texture & draw(const Window & w, const TextureArray & a) {
this->_frameBuffer.bind();
this->_renderer.clear();
diff --git a/source/engine/physic/front/engine/Engine.cpp b/source/engine/physic/front/engine/Engine.cpp
index 5b21c127b1eef07b800d8ce5d342e92c10780608..6aa664b5fa088acc05fe41dec8e99f1352318231 100644
--- a/source/engine/physic/front/engine/Engine.cpp
+++ b/source/engine/physic/front/engine/Engine.cpp
@@ -43,4 +43,24 @@ namespace megu {
}
}
}
+
+ std::optional<std::reference_wrapper<const Tangible>> PhysicEngine::get(const Identifiable & id) const {
+ for(auto & [priotiy, objects] : this->_statics) {
+ for(auto & object : objects) {
+ if(object.get().id() == id.id()) {
+ return object.get();
+ }
+ }
+ }
+
+ for(auto & [priotiy, objects] : this->_dynamic) {
+ for(auto & object : objects) {
+ if(object.get().id() == id.id()) {
+ return object.get();
+ }
+ }
+ }
+
+ return {};
+ }
}
\ No newline at end of file
diff --git a/source/engine/physic/front/engine/Engine.hpp b/source/engine/physic/front/engine/Engine.hpp
index 79bbabddfd8770c96f7052ccedf8a6fcd8995e19..b1db159b6dec5bd702fa414b79a52301f2d0235d 100644
--- a/source/engine/physic/front/engine/Engine.hpp
+++ b/source/engine/physic/front/engine/Engine.hpp
@@ -3,6 +3,7 @@
#include <vector>
#include <map>
#include <set>
+#include <optional>
#include <engine/physic/front/object/Tangible.hpp>
#include <engine/physic/front/object/TangibleStatic.hpp>
@@ -24,6 +25,8 @@ namespace megu {
void step(double);
void step(double, Priority);
+ std::optional<std::reference_wrapper<const Tangible>> get(const Identifiable &) const;
+
inline void clearCollision() {this->_collisions.clear();}
const std::set<Collision, reference_sorter<Collision>> & collision() const {return this->_collisions;}
diff --git a/source/kernel/back/engine/Engine.hpp b/source/kernel/back/engine/Engine.hpp
index 6a8111da165ae67641792c5f2dea5ba548ff0f88..b69f67fff6e3c5c7be5293da146c8f3e7ecd08d2 100644
--- a/source/kernel/back/engine/Engine.hpp
+++ b/source/kernel/back/engine/Engine.hpp
@@ -4,7 +4,7 @@ namespace megu::kernel {
class Props;
class Kernel;
- template <class T, class C>
+ template <class T, class C, class O>
class Engine {
public:
virtual void boot(Kernel &) = 0;
@@ -12,6 +12,7 @@ namespace megu::kernel {
virtual void step(Kernel &, double) = 0;
virtual T & get() = 0;
+ virtual const O & get(const C &) const = 0;
virtual void add(Kernel &, C &) = 0;
};
diff --git a/source/kernel/back/engine/GraphicEngine.cpp b/source/kernel/back/engine/GraphicEngine.cpp
index 314f19b55e312e7860d3d1a8c2e22281072c534a..2ee0f7050a72b4fede19cae10e8b7e34f06156cf 100644
--- a/source/kernel/back/engine/GraphicEngine.cpp
+++ b/source/kernel/back/engine/GraphicEngine.cpp
@@ -4,12 +4,10 @@
namespace megu::kernel {
GraphicEngine::GraphicEngine(Window & window)
- : _engine(window), _renderer(360, 360), _tmp_ta("assets/textures/Tile_Test_3.png", 1, 1, 32.f) {}
+ : _engine(window), _renderer(360, 360) {}
void GraphicEngine::boot(Kernel &) {
this->_engine.push(0, this->_renderer);
-
- //this->_engine.push(0, 0, this->_tmp_ta, &this->_tmp_mod);
}
void GraphicEngine::stop(Kernel &) {
@@ -23,4 +21,12 @@ namespace megu::kernel {
void GraphicEngine::add(Kernel & kernel, Graphical<GraphicEngine> & graphical) {
graphical.apply(kernel, *this);
}
+
+ const Renderable & GraphicEngine::get(const Graphical<GraphicEngine> & graphical) const {
+ auto object = this->_engine.get(graphical);
+ if(object.has_value()) {
+ return object.value();
+ }
+ throw std::runtime_error("Cannot find in physic object : " + graphical.id());
+ }
}
\ No newline at end of file
diff --git a/source/kernel/back/engine/GraphicEngine.hpp b/source/kernel/back/engine/GraphicEngine.hpp
index 885d7a5705834f9a3d0bea2f1011e34612b9cc0d..41d8546172642a711035f6f5920a9db5fc32f471 100644
--- a/source/kernel/back/engine/GraphicEngine.hpp
+++ b/source/kernel/back/engine/GraphicEngine.hpp
@@ -13,17 +13,19 @@
#include <kernel/back/props/Graphical.hpp>
namespace megu::kernel {
- class GraphicEngine : public Engine<megu::GraphicEngine, Graphical<GraphicEngine>> {
+ class GraphicEngine : public Engine<megu::GraphicEngine, Graphical<GraphicEngine>, Renderable> {
public:
GraphicEngine(Window &);
+ inline megu::GraphicEngine & get() {return this->_engine;}
+
void boot(Kernel &) override;
void stop(Kernel &) override;
void step(Kernel &, double) override;
void add(Kernel &, Graphical<GraphicEngine> &) override;
- inline megu::GraphicEngine & get() {return this->_engine;}
+ const megu::Renderable & get(const Graphical<GraphicEngine> &) const override;
inline const megu::GraphicEngine & engine() const {return this->_engine;}
inline const megu::Renderer & renderer() const {return this->_renderer;}
@@ -31,8 +33,5 @@ namespace megu::kernel {
private:
megu::GraphicEngine _engine;
megu::Renderer _renderer;
-
- megu::TileArray _tmp_ta;
- megu::TileArray_Module _tmp_mod;
};
}
\ No newline at end of file
diff --git a/source/kernel/back/engine/PhysicEngine.cpp b/source/kernel/back/engine/PhysicEngine.cpp
index f6794078c0a360275492f7e18464df4b44bb9db5..25e1c3ae57883f723fb61113a178647d3f65d26a 100644
--- a/source/kernel/back/engine/PhysicEngine.cpp
+++ b/source/kernel/back/engine/PhysicEngine.cpp
@@ -21,4 +21,13 @@ namespace megu::kernel {
void PhysicEngine::add(Kernel & kernel, Physical<PhysicEngine> & props) {
props.apply(kernel, *this);
}
+
+ const megu::Tangible & PhysicEngine::get(const Physical<PhysicEngine> & props) const {
+ auto tangible = this->_engine.get(props);
+ if(tangible.has_value()) {
+ return tangible.value();
+ }
+ throw std::runtime_error("Cannot find in physic object : " + props.id());
+
+ }
}
\ No newline at end of file
diff --git a/source/kernel/back/engine/PhysicEngine.hpp b/source/kernel/back/engine/PhysicEngine.hpp
index d1c100f92d4360b6bacdc8352c70c2b1bce737e0..38919d9583c54140134e9884d1bc475b1cd3e534 100644
--- a/source/kernel/back/engine/PhysicEngine.hpp
+++ b/source/kernel/back/engine/PhysicEngine.hpp
@@ -6,17 +6,19 @@
#include <kernel/back/props/Physical.hpp>
namespace megu::kernel {
- class PhysicEngine : public Engine<megu::PhysicEngine, Physical<PhysicEngine>> {
+ class PhysicEngine : public Engine<megu::PhysicEngine, Physical<PhysicEngine>, Tangible> {
public:
PhysicEngine();
+ inline megu::PhysicEngine & get() override {return this->_engine;}
+
void boot(Kernel &) override;
void stop(Kernel &) override;
void step(Kernel &, double) override;
void add(Kernel &, Physical<PhysicEngine> &) override;
- inline megu::PhysicEngine & get() override {return this->_engine;}
+ const megu::Tangible & get(const Physical<PhysicEngine> &) const override;
private:
megu::PhysicEngine _engine;
diff --git a/source/kernel/back/props/Component.hpp b/source/kernel/back/props/Component.hpp
index 229e22b780900b4b35f8f81dc64907443ae47eff..2a3538ab0b5f27f0d138bad4909da08c8c93e00c 100644
--- a/source/kernel/back/props/Component.hpp
+++ b/source/kernel/back/props/Component.hpp
@@ -1,12 +1,13 @@
#pragma once
#include <kernel/back/engine/Engine.hpp>
+#include <utility/Identifiable.hpp>
namespace megu::kernel {
class Kernel;
template <class E>
- class Component {
+ class Component : public virtual Identifiable {
public:
virtual void apply(Kernel & k, E &) = 0;
};
diff --git a/source/kernel/back/props/Physical.hpp b/source/kernel/back/props/Physical.hpp
index df8505630795306452f329b01c3af7f741a7da0f..92d17ce587f14bd678b1acf8f7e197c93edee22f 100644
--- a/source/kernel/back/props/Physical.hpp
+++ b/source/kernel/back/props/Physical.hpp
@@ -9,8 +9,8 @@ namespace megu::kernel {
template <class Pe>
class Physical : public Component<Pe> {
public:
- virtual void on_collide(double, const Identifiable &, Physical &) = 0;
+ virtual void on_collide(const Kernel &, const Pe &, Physical &, double) = 0;
- using CollideLambda = std::function<void(double, const Identifiable &, Physical &)>;
+ using CollideLambda = std::function<void(const Kernel &, const Pe &, const Physical &, double)>;
};
}
\ No newline at end of file
diff --git a/source/kernel/front/Kernel.cpp b/source/kernel/front/Kernel.cpp
index e5ab814bdf790cd1e0af09d2d9f59256fab45a48..84cd925eb218d45048fd9056c2800a3af6290099 100644
--- a/source/kernel/front/Kernel.cpp
+++ b/source/kernel/front/Kernel.cpp
@@ -13,15 +13,15 @@ namespace megu::kernel {
}
void Kernel::step() {
- double delta = Window::Time();
+ double time = Window::Time();
if(this->_window.isOpen()) {
- this->_gEngine.step(*this, delta);
- this->_gResolver.resolve(delta, this->_gEngine, this->_props);
+ this->_gEngine.step(*this, time);
+ this->_gResolver.resolve(*this, this->_gEngine, time);
}
- this->_pEngine.step(*this, delta);
- this->_pResolver.resolve(delta, this->_pEngine, this->_props);
+ this->_pEngine.step(*this, time);
+ this->_pResolver.resolve(*this, this->_pEngine, time);
}
void Kernel::add(Props * props) {
@@ -29,11 +29,13 @@ namespace megu::kernel {
auto * pComponent = props->getPhysicComponent();
if(pComponent != nullptr) {
this->_pEngine.add(*this, *pComponent);
+ this->_pResolver.add(*pComponent);
}
auto * gComponent = props->getGraphicComponent();
if(gComponent != nullptr) {
this->_gEngine.add(*this, *gComponent);
+ this->_gResolver.add(*gComponent);
}
}
}
\ No newline at end of file
diff --git a/source/kernel/front/Kernel.hpp b/source/kernel/front/Kernel.hpp
index 7ba3eac435a1fd42794e441659b2f28ac988463f..6a89a5063d744501372ac2bbc15fbebebb1e44cd 100644
--- a/source/kernel/front/Kernel.hpp
+++ b/source/kernel/front/Kernel.hpp
@@ -22,6 +22,9 @@ namespace megu::kernel {
inline Identifiable_Map<Props> & props() {return this->_props;}
+ inline PhysicEngine & getPhysicEngine() {return this->_pEngine;}
+ inline GraphicEngine & getGraphicEngine() {return this->_gEngine;}
+
private:
Window & _window;
diff --git a/source/kernel/front/component/physic/Fixed.cpp b/source/kernel/front/component/physic/Fixed.cpp
index f96705912082f42c1d3adaac2fc2ec4a0e2000ef..e981a4234a7eacbcbcfcab7f4a170bda4c66c41f 100644
--- a/source/kernel/front/component/physic/Fixed.cpp
+++ b/source/kernel/front/component/physic/Fixed.cpp
@@ -12,9 +12,9 @@ namespace megu::kernel {
}
}
- void Fixed::on_collide(double time, const Identifiable & identifiable, Physical<PhysicEngine> & physical) {
+ void Fixed::on_collide(const Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
if(this->_collide != nullptr) {
- this->_collide(time, identifiable, physical);
+ this->_collide(kernel, engine, physical, time);
}
}
diff --git a/source/kernel/front/component/physic/Fixed.hpp b/source/kernel/front/component/physic/Fixed.hpp
index e40d35ef8b96d7b228cd65df0b416cbe61cd828d..9439be8a1cda62037de3440aff74cc4bf191478e 100644
--- a/source/kernel/front/component/physic/Fixed.hpp
+++ b/source/kernel/front/component/physic/Fixed.hpp
@@ -13,7 +13,7 @@ namespace megu::kernel {
Fixed(float x, float y, float w, float h);
void update_physic(double) const override;
- void on_collide(double, const Identifiable &, Physical<PhysicEngine> &) override;
+ void on_collide(const Kernel &, const PhysicEngine &, Physical &, double) override;
void apply(Kernel & k, PhysicEngine &) override;
void setCollideLambda(const CollideLambda &);
diff --git a/source/kernel/front/component/physic/FixedArray.cpp b/source/kernel/front/component/physic/FixedArray.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7482b8daf87be9e443040387d46f2d6c7b477d45
--- /dev/null
+++ b/source/kernel/front/component/physic/FixedArray.cpp
@@ -0,0 +1,37 @@
+#include "FixedArray.hpp"
+
+#include <kernel/front/Kernel.hpp>
+
+namespace megu::kernel {
+ std::optional<std::reference_wrapper<const TangibleStatic>> FixedArray::at(const Position & position) const {
+ if(this->_tangibles.contains(position)) {
+ return this->_tangibles.at(position);
+ }
+ return {};
+ }
+
+ void FixedArray::push(const Fixed & tangible) {
+ this->_tangibles.insert({tangible.getPosition(), tangible});
+ }
+
+ void FixedArray::erase(const Fixed & tangible) {
+ this->_tangibles.erase(tangible.getPosition());
+ }
+
+ void FixedArray::erase(const Position & position) {
+ this->_tangibles.erase(position);
+ }
+
+ void FixedArray::on_collide(const Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
+ auto & tangible = engine.get(physical);
+ for(auto & [position, fixed] : this->_tangibles) {
+ if(fixed.isColliding(tangible)) {
+ physical.on_collide(kernel, engine, fixed, time);
+ }
+ }
+ }
+
+ void FixedArray::apply(Kernel & kernel, PhysicEngine & engine) {
+ engine.get().push(0, *this);
+ }
+}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/FixedArray.hpp b/source/kernel/front/component/physic/FixedArray.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..473b06ba38213184153cbacd95ff1519881927d2
--- /dev/null
+++ b/source/kernel/front/component/physic/FixedArray.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <kernel/back/props/Physical.hpp>
+#include <kernel/back/engine/PhysicEngine.hpp>
+#include <vector>
+#include <functional>
+
+#include "Fixed.hpp"
+
+namespace megu::kernel {
+ class FixedArray : public Physical<PhysicEngine>, public TangibleStatic {
+ public:
+ std::optional<std::reference_wrapper<const TangibleStatic>> at(const Position &) const;
+
+ void push(const Fixed &);
+ void erase(const Fixed &);
+ void erase(const Position &);
+
+ void on_collide(const Kernel &, const PhysicEngine &, Physical &, double) override;
+ void apply(Kernel & k, PhysicEngine &) override;
+
+ private:
+ std::map<Position, Fixed> _tangibles;
+ CollideLambda _collide;
+ UpdateLambda _update;
+ };
+}
\ No newline at end of file
diff --git a/source/kernel/front/component/physic/Movable.cpp b/source/kernel/front/component/physic/Movable.cpp
index 01292d3b2eaaccda48158cb12ef9e6c6940d7ec4..0fd7504d963f0d1fbbaed76c1a7853a7d881446a 100644
--- a/source/kernel/front/component/physic/Movable.cpp
+++ b/source/kernel/front/component/physic/Movable.cpp
@@ -10,9 +10,9 @@ namespace megu::kernel {
}
}
- void Movable::on_collide(double time, const Identifiable & identifiable, Physical<PhysicEngine> & physical) {
+ void Movable::on_collide(const Kernel & kernel, const PhysicEngine & engine, Physical & physical, double time) {
if(this->_collide != nullptr) {
- this->_collide(time, identifiable, physical);
+ this->_collide(kernel, engine, physical, time);
}
}
diff --git a/source/kernel/front/component/physic/Movable.hpp b/source/kernel/front/component/physic/Movable.hpp
index 48fd9078c72de360d0084c3e64109ae272d6d04f..f74c85b15059d12dade4c44e1b3b8816491a8ecc 100644
--- a/source/kernel/front/component/physic/Movable.hpp
+++ b/source/kernel/front/component/physic/Movable.hpp
@@ -13,7 +13,7 @@ namespace megu::kernel {
Movable(float x, float y, float w, float h);
void update_physic(double) override;
- void on_collide(double, const Identifiable &, Physical<PhysicEngine> &) override;
+ void on_collide(const Kernel &, const PhysicEngine &, Physical &, double) override;
void apply(Kernel & k, PhysicEngine &) override;
void setCollideLambda(CollideLambda &);
diff --git a/source/kernel/front/resolver/GraphicResolver.cpp b/source/kernel/front/resolver/GraphicResolver.cpp
index a436473b2ebb63e9038db28a2b339de239f8b3f4..b0c2f457d0771486b54e4330ef132f6b7800f3ae 100644
--- a/source/kernel/front/resolver/GraphicResolver.cpp
+++ b/source/kernel/front/resolver/GraphicResolver.cpp
@@ -1,12 +1,9 @@
#include "GraphicResolver.hpp"
namespace megu::kernel {
- void GraphicResolver::resolve(double time, GraphicEngine &, const Identifiable_Map<Props> & props) {
- for(auto & [id, object] : props) {
- auto * component = object->getGraphicComponent();
- if(component != nullptr) {
- component->update(time);
- }
+ void GraphicResolver::resolve(Kernel & kernel, GraphicEngine & engine, double time) {
+ for(auto & component : this->components()) {
+ component.get().update(time);
}
}
}
\ No newline at end of file
diff --git a/source/kernel/front/resolver/GraphicResolver.hpp b/source/kernel/front/resolver/GraphicResolver.hpp
index e1fe0ea8ae92514df0178b1028489df46e553c54..7e2b54131757d688e6df70575aba411c63f5eec7 100644
--- a/source/kernel/front/resolver/GraphicResolver.hpp
+++ b/source/kernel/front/resolver/GraphicResolver.hpp
@@ -5,8 +5,8 @@
#include <kernel/back/props/Props.hpp>
namespace megu::kernel {
- class GraphicResolver : public Resolver<GraphicEngine, Props> {
+ class GraphicResolver : public Resolver<GraphicEngine, Graphical<GraphicEngine>> {
public:
- void resolve(double, GraphicEngine &, const Identifiable_Map<Props> &) override;
+ void resolve(Kernel &, GraphicEngine &, double) override;
};
}
\ No newline at end of file
diff --git a/source/kernel/front/resolver/PhysicResolver.cpp b/source/kernel/front/resolver/PhysicResolver.cpp
index 81ed40e42b57c13571647a6d60389821c54ac8e7..f2b5431512eda627e67c9591ed951330c7075c2c 100644
--- a/source/kernel/front/resolver/PhysicResolver.cpp
+++ b/source/kernel/front/resolver/PhysicResolver.cpp
@@ -1,24 +1,15 @@
#include "PhysicResolver.hpp"
namespace megu::kernel {
- void PhysicResolver::resolve(double time, PhysicEngine & engine, const Identifiable_Map<Props> & props) {
+ void PhysicResolver::resolve(Kernel & kernel, PhysicEngine & engine, double time) {
auto & collisions = engine.get().collision();
for(auto & collision : collisions) {
- const Tangible & source = collision.source();
- const Tangible & target = collision.target();
+ auto source_comp = this->get(collision.source());
+ auto target_comp = this->get(collision.target());
- if(props.contains(source.id()) && props.contains(target.id())) {
- Props * props_source = props.at(source.id());
- Props * props_target = props.at(target.id());
-
- auto * sComponent = props_source->getPhysicComponent();
- auto * tComponent = props_target->getPhysicComponent();
-
- if(sComponent != nullptr && tComponent != nullptr) {
- sComponent->on_collide(time, target, *tComponent);
- }
-
+ if(source_comp.has_value() && target_comp.has_value()) {
+ source_comp.value().get().on_collide(kernel, engine, target_comp.value().get(), time);
}
}
diff --git a/source/kernel/front/resolver/PhysicResolver.hpp b/source/kernel/front/resolver/PhysicResolver.hpp
index 0cd194d649ec522bdfd2f63e09c606aac35a32fa..349c6de7ea426d426e2e56417a48acaa4c3cb7f9 100644
--- a/source/kernel/front/resolver/PhysicResolver.hpp
+++ b/source/kernel/front/resolver/PhysicResolver.hpp
@@ -5,8 +5,8 @@
#include <kernel/back/props/Props.hpp>
namespace megu::kernel {
- class PhysicResolver : public Resolver<PhysicEngine, Props> {
+ class PhysicResolver : public Resolver<PhysicEngine, Physical<PhysicEngine>> {
public:
- void resolve(double, PhysicEngine &, const Identifiable_Map<Props> &) override;
+ void resolve(Kernel &, PhysicEngine &, double) override;
};
}
\ No newline at end of file
diff --git a/source/kernel/front/resolver/Resolver.hpp b/source/kernel/front/resolver/Resolver.hpp
index d7484afdda030c0de6ca3646b87d6b296ed3a980..35b4732383d513041f05ccab6b0d9e01e8a92b66 100644
--- a/source/kernel/front/resolver/Resolver.hpp
+++ b/source/kernel/front/resolver/Resolver.hpp
@@ -1,11 +1,25 @@
#pragma once
#include <utility/Identifiable.hpp>
+#include <kernel/back/props/Component.hpp>
+#include <engine/utility/ref_set.hpp>
+#include <optional>
namespace megu::kernel {
template <class E, class O>
class Resolver {
public:
- virtual void resolve(double, E &, const Identifiable_Map<O> &) = 0;
+ inline ref_set<O> & components() {return this->_components;}
+
+ void add(O &);
+ void erase(const Identifiable &);
+ std::optional<std::reference_wrapper<O>> get(const Identifiable &);
+
+ virtual void resolve(Kernel &, E &, double) = 0;
+
+ private:
+ ref_set<O> _components;
};
-}
\ No newline at end of file
+}
+
+#include "Resolver.tpp"
\ No newline at end of file
diff --git a/source/kernel/front/resolver/Resolver.tpp b/source/kernel/front/resolver/Resolver.tpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a4beb034b0a5519fe55b6a961d0b3e9fc7b8aed
--- /dev/null
+++ b/source/kernel/front/resolver/Resolver.tpp
@@ -0,0 +1,23 @@
+#include "Resolver.hpp"
+
+namespace megu::kernel {
+ template <class E, class O>
+ void Resolver<E, O>::add(O & c) {
+ this->_components.insert(c);
+ }
+
+ template <class E, class O>
+ void Resolver<E, O>::erase(const Identifiable & c) {
+ this->_components.erase(c);
+ }
+
+ template <class E, class O>
+ std::optional<std::reference_wrapper<O>> Resolver<E, O>::get(const Identifiable & c) {
+ for(auto & comp : this->_components) {
+ if(comp.get().id() == c.id()) {
+ return comp;
+ }
+ }
+ return {};
+ }
+}
\ No newline at end of file