BlackMATov/ecs.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/ecs.hpp.git synced 2025-12-16 22:19:21 +07:00
Code Issues Packages Projects Releases Wiki Activity

rename world to registry

Browse Source
This commit is contained in:
Matvey Cherevko
2018-12-26 18:23:13 +07:00
parent 8a7f6c26a3
commit 7460832dc6
2 changed files with 64 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
ecs.hpp
View File

@@ -30,8 +30,8 @@
namespace ecs_hpp namespace ecs_hpp
{ {
class world;
class entity; class entity;
class registry;
using family_id = std::uint16_t; using family_id = std::uint16_t;
using entity_id = std::uint32_t; using entity_id = std::uint32_t;
@@ -116,7 +116,7 @@ namespace ecs_hpp
template < typename T > template < typename T >
class component_storage : public component_storage_base { class component_storage : public component_storage_base {
public: public:
component_storage(world& owner); component_storage(registry& owner);
template < typename... Args > template < typename... Args >
void assign(entity_id id, Args&&... args); void assign(entity_id id, Args&&... args);
@@ -130,12 +130,12 @@ namespace ecs_hpp
template < typename F > template < typename F >
void for_each_component(F&& f) const noexcept; void for_each_component(F&& f) const noexcept;
private: private:
world& owner_; registry& owner_;
std::unordered_map<entity_id, T> components_; std::unordered_map<entity_id, T> components_;
}; };
template < typename T > template < typename T >
component_storage<T>::component_storage(world& owner) component_storage<T>::component_storage(registry& owner)
: owner_(owner) {} : owner_(owner) {}
template < typename T > template < typename T >
@@ -213,10 +213,10 @@ namespace ecs_hpp
{ {
class entity final { class entity final {
public: public:
entity(world& owner); entity(registry& owner);
entity(world& owner, entity_id id); entity(registry& owner, entity_id id);
const world& owner() const noexcept; const registry& owner() const noexcept;
entity_id id() const noexcept; entity_id id() const noexcept;
bool destroy(); bool destroy();
@@ -255,7 +255,7 @@ namespace ecs_hpp
template < typename... Ts > template < typename... Ts >
std::tuple<const Ts*...> find_components() const noexcept; std::tuple<const Ts*...> find_components() const noexcept;
private: private:
world& owner_; registry& owner_;
entity_id id_{0u}; entity_id id_{0u};
}; };
@@ -277,16 +277,16 @@ namespace std
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// //
// world // registry
// //
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
namespace ecs_hpp namespace ecs_hpp
{ {
class world final { class registry final {
public: public:
world(); registry();
~world() noexcept; ~registry() noexcept;
entity create_entity(); entity create_entity();
bool destroy_entity(const entity& ent); bool destroy_entity(const entity& ent);
@@ -381,14 +381,14 @@ namespace ecs_hpp
namespace ecs_hpp namespace ecs_hpp
{ {
inline entity::entity(world& owner) inline entity::entity(registry& owner)
: owner_(owner) {} : owner_(owner) {}
inline entity::entity(world& owner, entity_id id) inline entity::entity(registry& owner, entity_id id)
: owner_(owner) : owner_(owner)
, id_(id) {} , id_(id) {}
inline const world& entity::owner() const noexcept { inline const registry& entity::owner() const noexcept {
return owner_; return owner_;
} }
@@ -477,16 +477,16 @@ namespace ecs_hpp
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// //
// world impl // registry impl
// //
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
namespace ecs_hpp namespace ecs_hpp
{ {
inline world::world() = default; inline registry::registry() = default;
inline world::~world() noexcept = default; inline registry::~registry() noexcept = default;
inline entity world::create_entity() { inline entity registry::create_entity() {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
assert(last_entity_id_ < std::numeric_limits<entity_id>::max()); assert(last_entity_id_ < std::numeric_limits<entity_id>::max());
auto ent = entity(*this, ++last_entity_id_); auto ent = entity(*this, ++last_entity_id_);
@@ -494,19 +494,19 @@ namespace ecs_hpp
return ent; return ent;
} }
inline bool world::destroy_entity(const entity& ent) { inline bool registry::destroy_entity(const entity& ent) {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
remove_all_components_impl_(ent); remove_all_components_impl_(ent);
return entities_.erase(ent) > 0u; return entities_.erase(ent) > 0u;
} }
inline bool world::is_entity_alive(const entity& ent) const noexcept { inline bool registry::is_entity_alive(const entity& ent) const noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
return is_entity_alive_impl_(ent); return is_entity_alive_impl_(ent);
} }
template < typename T, typename... Args > template < typename T, typename... Args >
bool world::assign_component(const entity& ent, Args&&... args) { bool registry::assign_component(const entity& ent, Args&&... args) {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
if ( !is_entity_alive_impl_(ent) ) { if ( !is_entity_alive_impl_(ent) ) {
return false; return false;
@@ -518,7 +518,7 @@ namespace ecs_hpp
} }
template < typename T > template < typename T >
bool world::remove_component(const entity& ent) { bool registry::remove_component(const entity& ent) {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
if ( !is_entity_alive_impl_(ent) ) { if ( !is_entity_alive_impl_(ent) ) {
return false; return false;
@@ -530,7 +530,7 @@ namespace ecs_hpp
} }
template < typename T > template < typename T >
bool world::exists_component(const entity& ent) const noexcept { bool registry::exists_component(const entity& ent) const noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
if ( !is_entity_alive_impl_(ent) ) { if ( !is_entity_alive_impl_(ent) ) {
return false; return false;
@@ -541,13 +541,13 @@ namespace ecs_hpp
: false; : false;
} }
inline std::size_t world::remove_all_components(const entity& ent) const noexcept { inline std::size_t registry::remove_all_components(const entity& ent) const noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
return remove_all_components_impl_(ent); return remove_all_components_impl_(ent);
} }
template < typename T > template < typename T >
T& world::get_component(const entity& ent) { T& registry::get_component(const entity& ent) {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
T* component = find_component_impl_<T>(ent); T* component = find_component_impl_<T>(ent);
if ( component ) { if ( component ) {
@@ -557,7 +557,7 @@ namespace ecs_hpp
} }
template < typename T > template < typename T >
const T& world::get_component(const entity& ent) const { const T& registry::get_component(const entity& ent) const {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
const T* component = find_component_impl_<T>(ent); const T* component = find_component_impl_<T>(ent);
if ( component ) { if ( component ) {
@@ -567,39 +567,39 @@ namespace ecs_hpp
} }
template < typename T > template < typename T >
T* world::find_component(const entity& ent) noexcept { T* registry::find_component(const entity& ent) noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
return find_component_impl_<T>(ent); return find_component_impl_<T>(ent);
} }
template < typename T > template < typename T >
const T* world::find_component(const entity& ent) const noexcept { const T* registry::find_component(const entity& ent) const noexcept {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
return find_component_impl_<T>(ent); return find_component_impl_<T>(ent);
} }
template < typename... Ts > template < typename... Ts >
std::tuple<Ts&...> world::get_components(const entity& ent) { std::tuple<Ts&...> registry::get_components(const entity& ent) {
return std::make_tuple(std::ref(get_component<Ts>(ent))...); return std::make_tuple(std::ref(get_component<Ts>(ent))...);
} }
template < typename... Ts > template < typename... Ts >
std::tuple<const Ts&...> world::get_components(const entity& ent) const { std::tuple<const Ts&...> registry::get_components(const entity& ent) const {
return std::make_tuple(std::cref(get_component<Ts>(ent))...); return std::make_tuple(std::cref(get_component<Ts>(ent))...);
} }
template < typename... Ts > template < typename... Ts >
std::tuple<Ts*...> world::find_components(const entity& ent) noexcept { std::tuple<Ts*...> registry::find_components(const entity& ent) noexcept {
return std::make_tuple(find_component<Ts>(ent)...); return std::make_tuple(find_component<Ts>(ent)...);
} }
template < typename... Ts > template < typename... Ts >
std::tuple<const Ts*...> world::find_components(const entity& ent) const noexcept { std::tuple<const Ts*...> registry::find_components(const entity& ent) const noexcept {
return std::make_tuple(find_component<Ts>(ent)...); return std::make_tuple(find_component<Ts>(ent)...);
} }
template < typename T, typename F > template < typename T, typename F >
void world::for_each_component(F&& f) { void registry::for_each_component(F&& f) {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
detail::component_storage<T>* storage = find_storage_<T>(); detail::component_storage<T>* storage = find_storage_<T>();
if ( storage ) { if ( storage ) {
@@ -608,7 +608,7 @@ namespace ecs_hpp
} }
template < typename T, typename F > template < typename T, typename F >
void world::for_each_component(F&& f) const { void registry::for_each_component(F&& f) const {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
const detail::component_storage<T>* storage = find_storage_<T>(); const detail::component_storage<T>* storage = find_storage_<T>();
if ( storage ) { if ( storage ) {
@@ -617,19 +617,19 @@ namespace ecs_hpp
} }
template < typename... Ts, typename F > template < typename... Ts, typename F >
void world::for_joined_components(F&& f) { void registry::for_joined_components(F&& f) {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
for_joined_components_impl_<Ts...>(std::forward<F>(f)); for_joined_components_impl_<Ts...>(std::forward<F>(f));
} }
template < typename... Ts, typename F > template < typename... Ts, typename F >
void world::for_joined_components(F&& f) const { void registry::for_joined_components(F&& f) const {
std::lock_guard<std::mutex> guard(mutex_); std::lock_guard<std::mutex> guard(mutex_);
for_joined_components_impl_<Ts...>(std::forward<F>(f)); for_joined_components_impl_<Ts...>(std::forward<F>(f));
} }
template < typename T > template < typename T >
detail::component_storage<T>* world::find_storage_() noexcept { detail::component_storage<T>* registry::find_storage_() noexcept {
const auto family = detail::type_family<T>::id(); const auto family = detail::type_family<T>::id();
const auto iter = storages_.find(family); const auto iter = storages_.find(family);
if ( iter != storages_.end() ) { if ( iter != storages_.end() ) {
@@ -639,7 +639,7 @@ namespace ecs_hpp
} }
template < typename T > template < typename T >
const detail::component_storage<T>* world::find_storage_() const noexcept { const detail::component_storage<T>* registry::find_storage_() const noexcept {
const auto family = detail::type_family<T>::id(); const auto family = detail::type_family<T>::id();
const auto iter = storages_.find(family); const auto iter = storages_.find(family);
if ( iter != storages_.end() ) { if ( iter != storages_.end() ) {
@@ -649,7 +649,7 @@ namespace ecs_hpp
} }
template < typename T > template < typename T >
detail::component_storage<T>& world::get_or_create_storage_() { detail::component_storage<T>& registry::get_or_create_storage_() {
detail::component_storage<T>* storage = find_storage_<T>(); detail::component_storage<T>* storage = find_storage_<T>();
if ( storage ) { if ( storage ) {
return *storage; return *storage;
@@ -663,11 +663,11 @@ namespace ecs_hpp
emplace_r.first->second.get()); emplace_r.first->second.get());
} }
inline bool world::is_entity_alive_impl_(const entity& ent) const noexcept { inline bool registry::is_entity_alive_impl_(const entity& ent) const noexcept {
return entities_.count(ent) > 0u; return entities_.count(ent) > 0u;
} }
inline std::size_t world::remove_all_components_impl_(const entity& ent) const noexcept { inline std::size_t registry::remove_all_components_impl_(const entity& ent) const noexcept {
if ( !is_entity_alive_impl_(ent) ) { if ( !is_entity_alive_impl_(ent) ) {
return 0u; return 0u;
} }
@@ -681,7 +681,7 @@ namespace ecs_hpp
} }
template < typename T > template < typename T >
T* world::find_component_impl_(const entity& ent) noexcept { T* registry::find_component_impl_(const entity& ent) noexcept {
detail::component_storage<T>* storage = find_storage_<T>(); detail::component_storage<T>* storage = find_storage_<T>();
return storage return storage
? storage->find(ent.id()) ? storage->find(ent.id())
@@ -689,7 +689,7 @@ namespace ecs_hpp
} }
template < typename T > template < typename T >
const T* world::find_component_impl_(const entity& ent) const noexcept { const T* registry::find_component_impl_(const entity& ent) const noexcept {
const detail::component_storage<T>* storage = find_storage_<T>(); const detail::component_storage<T>* storage = find_storage_<T>();
return storage return storage
? storage->find(ent.id()) ? storage->find(ent.id())
@@ -697,14 +697,14 @@ namespace ecs_hpp
} }
template < typename... Ts, typename F > template < typename... Ts, typename F >
void world::for_joined_components_impl_(F&& f) { void registry::for_joined_components_impl_(F&& f) {
for ( const auto& e : entities_ ) { for ( const auto& e : entities_ ) {
for_joined_components_impl_<Ts...>(e, std::forward<F>(f)); for_joined_components_impl_<Ts...>(e, std::forward<F>(f));
} }
} }
template < typename T, typename... Ts, typename F, typename... Cs > template < typename T, typename... Ts, typename F, typename... Cs >
void world::for_joined_components_impl_(const entity& e, F&& f, Cs&&... cs) { void registry::for_joined_components_impl_(const entity& e, F&& f, Cs&&... cs) {
T* c = find_component_impl_<T>(e); T* c = find_component_impl_<T>(e);
if ( c ) { if ( c ) {
for_joined_components_impl_<Ts...>( for_joined_components_impl_<Ts...>(
@@ -716,19 +716,19 @@ namespace ecs_hpp
} }
template < typename F, typename... Cs > template < typename F, typename... Cs >
void world::for_joined_components_impl_(const entity& e, F&& f, Cs&&... cs) { void registry::for_joined_components_impl_(const entity& e, F&& f, Cs&&... cs) {
f(e, std::forward<Cs>(cs)...); f(e, std::forward<Cs>(cs)...);
} }
template < typename... Ts, typename F > template < typename... Ts, typename F >
void world::for_joined_components_impl_(F&& f) const { void registry::for_joined_components_impl_(F&& f) const {
for ( const auto& e : entities_ ) { for ( const auto& e : entities_ ) {
for_joined_components_impl_<Ts...>(e, std::forward<F>(f)); for_joined_components_impl_<Ts...>(e, std::forward<F>(f));
} }
} }
template < typename T, typename... Ts, typename F, typename... Cs > template < typename T, typename... Ts, typename F, typename... Cs >
void world::for_joined_components_impl_(const entity& e, F&& f, Cs&&... cs) const { void registry::for_joined_components_impl_(const entity& e, F&& f, Cs&&... cs) const {
const T* c = find_component_impl_<T>(e); const T* c = find_component_impl_<T>(e);
if ( c ) { if ( c ) {
for_joined_components_impl_<Ts...>( for_joined_components_impl_<Ts...>(
@@ -740,7 +740,7 @@ namespace ecs_hpp
} }
template < typename F, typename... Cs > template < typename F, typename... Cs >
void world::for_joined_components_impl_(const entity& e, F&& f, Cs&&... cs) const { void registry::for_joined_components_impl_(const entity& e, F&& f, Cs&&... cs) const {
f(e, std::forward<Cs>(cs)...); f(e, std::forward<Cs>(cs)...);
} }
} }

28
ecs_tests.cpp
View File

@@ -52,10 +52,10 @@ TEST_CASE("detail") {
} }
} }
TEST_CASE("world") { TEST_CASE("registry") {
SECTION("entities") { SECTION("entities") {
{ {
ecs::world w; ecs::registry w;
ecs::entity e1{w}; ecs::entity e1{w};
ecs::entity e2{w}; ecs::entity e2{w};
@@ -68,7 +68,7 @@ TEST_CASE("world") {
REQUIRE_FALSE(w.destroy_entity(e2)); REQUIRE_FALSE(w.destroy_entity(e2));
} }
{ {
ecs::world w; ecs::registry w;
auto e1 = w.create_entity(); auto e1 = w.create_entity();
auto e2 = w.create_entity(); auto e2 = w.create_entity();
@@ -91,7 +91,7 @@ TEST_CASE("world") {
} }
SECTION("component_assigning") { SECTION("component_assigning") {
{ {
ecs::world w; ecs::registry w;
ecs::entity e1 = w.create_entity(); ecs::entity e1 = w.create_entity();
{ {
@@ -130,7 +130,7 @@ TEST_CASE("world") {
} }
} }
{ {
ecs::world w; ecs::registry w;
auto e1 = w.create_entity(); auto e1 = w.create_entity();
auto e2 = w.create_entity(); auto e2 = w.create_entity();
@@ -150,7 +150,7 @@ TEST_CASE("world") {
REQUIRE(w.exists_component<velocity_c>(e2)); REQUIRE(w.exists_component<velocity_c>(e2));
} }
{ {
ecs::world w; ecs::registry w;
auto e1 = w.create_entity(); auto e1 = w.create_entity();
REQUIRE(e1.destroy()); REQUIRE(e1.destroy());
REQUIRE_FALSE(e1.assign_component<position_c>()); REQUIRE_FALSE(e1.assign_component<position_c>());
@@ -159,7 +159,7 @@ TEST_CASE("world") {
} }
SECTION("component_accessing") { SECTION("component_accessing") {
{ {
ecs::world w; ecs::registry w;
auto e1 = w.create_entity(); auto e1 = w.create_entity();
auto e2 = w.create_entity(); auto e2 = w.create_entity();
@@ -180,7 +180,7 @@ TEST_CASE("world") {
REQUIRE_THROWS_AS(e2.get_component<position_c>(), ecs::basic_exception); REQUIRE_THROWS_AS(e2.get_component<position_c>(), ecs::basic_exception);
} }
{ {
ecs::world w; ecs::registry w;
const auto e1 = w.create_entity(); const auto e1 = w.create_entity();
const auto e2 = w.create_entity(); const auto e2 = w.create_entity();
@@ -195,7 +195,7 @@ TEST_CASE("world") {
REQUIRE(e2.find_component<velocity_c>()->y == 4); REQUIRE(e2.find_component<velocity_c>()->y == 4);
{ {
const ecs::world& ww = w; const ecs::registry& ww = w;
REQUIRE(ww.get_component<position_c>(e1).x == 1); REQUIRE(ww.get_component<position_c>(e1).x == 1);
REQUIRE(ww.get_component<position_c>(e1).y == 2); REQUIRE(ww.get_component<position_c>(e1).y == 2);
@@ -213,7 +213,7 @@ TEST_CASE("world") {
} }
} }
{ {
ecs::world w; ecs::registry w;
auto e1 = w.create_entity(); auto e1 = w.create_entity();
@@ -284,7 +284,7 @@ TEST_CASE("world") {
} }
SECTION("for_each_component") { SECTION("for_each_component") {
{ {
ecs::world w; ecs::registry w;
auto e1 = w.create_entity(); auto e1 = w.create_entity();
auto e2 = w.create_entity(); auto e2 = w.create_entity();
@@ -306,7 +306,7 @@ TEST_CASE("world") {
} }
{ {
const ecs::world& ww = w; const ecs::registry& ww = w;
ecs::entity_id acc1 = 0; ecs::entity_id acc1 = 0;
int acc2 = 0; int acc2 = 0;
ww.for_each_component<position_c>([&acc1, &acc2](ecs::entity e, const position_c& p){ ww.for_each_component<position_c>([&acc1, &acc2](ecs::entity e, const position_c& p){
@@ -321,7 +321,7 @@ TEST_CASE("world") {
SECTION("for_joined_components") { SECTION("for_joined_components") {
{ {
ecs::world w; ecs::registry w;
auto e1 = w.create_entity(); auto e1 = w.create_entity();
auto e2 = w.create_entity(); auto e2 = w.create_entity();
@@ -351,7 +351,7 @@ TEST_CASE("world") {
} }
{ {
const ecs::world& ww = w; const ecs::registry& ww = w;
ecs::entity_id acc1 = 0; ecs::entity_id acc1 = 0;
int acc2 = 0; int acc2 = 0;
ww.for_joined_components<position_c, velocity_c>([&acc1, &acc2]( ww.for_joined_components<position_c, velocity_c>([&acc1, &acc2](