BlackMATov/ecs.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/ecs.hpp.git synced 2025-12-13 02:26:27 +07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #33 from BlackMATov/dev

Browse Source 
Dev
This commit is contained in:
Matvey Cherevko
2019-09-01 15:31:51 +07:00
committed by GitHub
parent d32f438684 60c476a291
commit 2303311d55
2 changed files with 178 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
headers/ecs.hpp/ecs.hpp
View File

@@ -105,6 +105,7 @@ namespace ecs_hpp
std::tuple<T, Ts...>&& t,
std::index_sequence<Is...> iseq)
{
(void)t;
(void)iseq;
return std::make_tuple(std::move(std::get<Is + 1u>(t))...);
}
@@ -114,6 +115,7 @@ namespace ecs_hpp
const std::tuple<T, Ts...>& t,
std::index_sequence<Is...> iseq)
{
(void)t;
(void)iseq;
return std::make_tuple(std::get<Is + 1u>(t)...);
}
@@ -289,6 +291,40 @@ namespace ecs_hpp
}
}
namespace ecs_hpp
{
namespace detail
{
template < typename Tag >
class incremental_locker final {
public:
incremental_locker() noexcept {
++lock_count_;
}
~incremental_locker() noexcept {
assert(lock_count_);
--lock_count_;
}
incremental_locker(incremental_locker&&) = delete;
incremental_locker& operator=(incremental_locker&&) = delete;
incremental_locker(const incremental_locker&) = delete;
incremental_locker& operator=(const incremental_locker&) = delete;
static bool is_locked() noexcept {
return !!lock_count_;
}
private:
static std::size_t lock_count_;
};
template < typename Tag >
std::size_t incremental_locker<Tag>::lock_count_ = 0u;
}
}
// -----------------------------------------------------------------------------
//
// detail::sparse_set
@@ -368,11 +404,6 @@ namespace ecs_hpp
return true;
}
template < typename... Args >
bool emplace(Args&&... args) {
return insert(T(std::forward<Args>(args)...));
}
bool unordered_erase(const T& v) noexcept {
if ( !has(v) ) {
return false;
@@ -509,27 +540,14 @@ namespace ecs_hpp
}
template < typename UK, typename UT >
bool insert(UK&& k, UT&& v) {
if ( keys_.has(k) ) {
return false;
std::pair<T*, bool> insert(UK&& k, UT&& v) {
if ( T* value = find(k) ) {
return std::make_pair(value, false);
}
values_.push_back(std::forward<UT>(v));
try {
return keys_.insert(std::forward<UK>(k));
} catch (...) {
values_.pop_back();
throw;
}
}
template < typename UK, typename... Args >
bool emplace(UK&& k, Args&&... args) {
if ( keys_.has(k) ) {
return false;
}
values_.emplace_back(std::forward<Args>(args)...);
try {
return keys_.insert(std::forward<UK>(k));
keys_.insert(std::forward<UK>(k));
return std::make_pair(&values_.back(), true);
} catch (...) {
values_.pop_back();
throw;
@@ -537,13 +555,18 @@ namespace ecs_hpp
}
template < typename UK, typename UT >
bool insert_or_assign(UK&& k, UT&& v) {
if ( keys_.has(k) ) {
get(k) = std::forward<UT>(v);
return false;
} else {
insert(std::forward<UK>(k), std::forward<UT>(v));
return true;
std::pair<T*, bool> insert_or_assign(UK&& k, UT&& v) {
if ( T* value = find(k) ) {
*value = std::forward<UT>(v);
return std::make_pair(value, false);
}
values_.push_back(std::forward<UT>(v));
try {
keys_.insert(std::forward<UK>(k));
return std::make_pair(&values_.back(), true);
} catch (...) {
values_.pop_back();
throw;
}
}
@@ -665,8 +688,21 @@ namespace ecs_hpp
template < typename... Args >
T& assign(entity_id id, Args&&... args) {
components_.insert_or_assign(id, T(std::forward<Args>(args)...));
return components_.get(id);
if ( T* value = components_.find(id) ) {
*value = T(std::forward<Args>(args)...);
return *value;
}
assert(!components_locker::is_locked());
return *components_.insert(id, T(std::forward<Args>(args)...)).first;
}
template < typename... Args >
T& ensure(entity_id id, Args&&... args) {
if ( T* value = components_.find(id) ) {
return *value;
}
assert(!components_locker::is_locked());
return *components_.insert(id, T(std::forward<Args>(args)...)).first;
}
bool exists(entity_id id) const noexcept {
@@ -674,10 +710,12 @@ namespace ecs_hpp
}
bool remove(entity_id id) noexcept override {
assert(!components_locker::is_locked());
return components_.unordered_erase(id);
}
std::size_t remove_all() noexcept {
assert(!components_locker::is_locked());
const std::size_t count = components_.size();
components_.clear();
return count;
@@ -700,14 +738,15 @@ namespace ecs_hpp
}
void clone(entity_id from, entity_id to) override {
const T* c = components_.find(from);
const T* c = find(from);
if ( c ) {
components_.insert_or_assign(to, *c);
assign(to, *c);
}
}
template < typename F >
void for_each_component(F&& f) {
components_locker lock;
for ( const entity_id id : components_ ) {
f(id, components_.get(id));
}
@@ -715,6 +754,7 @@ namespace ecs_hpp
template < typename F >
void for_each_component(F&& f) const {
components_locker lock;
for ( const entity_id id : components_ ) {
f(id, components_.get(id));
}
@@ -726,6 +766,7 @@ namespace ecs_hpp
private:
registry& owner_;
detail::sparse_map<entity_id, T, entity_id_indexer> components_;
using components_locker = detail::incremental_locker<struct components_tag>;
};
template < typename T >
@@ -736,6 +777,20 @@ namespace ecs_hpp
template < typename... Args >
T& assign(entity_id id, Args&&...) {
if ( components_.has(id) ) {
return empty_value_;
}
assert(!components_locker::is_locked());
components_.insert(id);
return empty_value_;
}
template < typename... Args >
T& ensure(entity_id id, Args&&...) {
if ( components_.has(id) ) {
return empty_value_;
}
assert(!components_locker::is_locked());
components_.insert(id);
return empty_value_;
}
@@ -745,10 +800,12 @@ namespace ecs_hpp
}
bool remove(entity_id id) noexcept override {
assert(!components_locker::is_locked());
return components_.unordered_erase(id);
}
std::size_t remove_all() noexcept {
assert(!components_locker::is_locked());
const std::size_t count = components_.size();
components_.clear();
return count;
@@ -775,13 +832,15 @@ namespace ecs_hpp
}
void clone(entity_id from, entity_id to) override {
if ( components_.has(from) ) {
components_.insert(to);
const T* c = find(from);
if ( c ) {
assign(to, *c);
}
}
template < typename F >
void for_each_component(F&& f) {
components_locker lock;
for ( const entity_id id : components_ ) {
f(id, empty_value_);
}
@@ -789,6 +848,7 @@ namespace ecs_hpp
template < typename F >
void for_each_component(F&& f) const {
components_locker lock;
for ( const entity_id id : components_ ) {
f(id, empty_value_);
}
@@ -801,6 +861,7 @@ namespace ecs_hpp
registry& owner_;
static T empty_value_;
detail::sparse_set<entity_id, entity_id_indexer> components_;
using components_locker = detail::incremental_locker<struct components_tag>;
};
template < typename T >
@@ -839,6 +900,9 @@ namespace ecs_hpp
template < typename T, typename... Args >
T& assign_component(Args&&... args);
template < typename T, typename... Args >
T& ensure_component(Args&&... args);
template < typename T >
bool remove_component();
@@ -992,6 +1056,9 @@ namespace ecs_hpp
template < typename... Args >
T& assign(Args&&... args);
template < typename... Args >
T& ensure(Args&&... args);
T& get();
const T& get() const;
@@ -1262,6 +1329,9 @@ namespace ecs_hpp
template < typename T, typename... Args >
T& assign_component(const uentity& ent, Args&&... args);
template < typename T, typename... Args >
T& ensure_component(const uentity& ent, Args&&... args);
template < typename T >
bool remove_component(const uentity& ent);
@@ -1396,6 +1466,7 @@ namespace ecs_hpp
entity_id last_entity_id_{0u};
std::vector<entity_id> free_entity_ids_;
detail::sparse_set<entity_id, detail::entity_id_indexer> entity_ids_;
using entity_ids_locker = detail::incremental_locker<struct entity_ids_tag>;
using storage_uptr = std::unique_ptr<detail::component_storage_base>;
detail::sparse_map<family_id, storage_uptr> storages_;
@@ -1490,6 +1561,13 @@ namespace ecs_hpp
std::forward<Args>(args)...);
}
template < typename T, typename... Args >
T& entity::ensure_component(Args&&... args) {
return (*owner_).ensure_component<T>(
id_,
std::forward<Args>(args)...);
}
template < typename T >
bool entity::remove_component() {
return (*owner_).remove_component<T>(id_);
@@ -1695,6 +1773,13 @@ namespace ecs_hpp
std::forward<Args>(args)...);
}
template < typename T >
template < typename... Args >
T& component<T>::ensure(Args&&... args) {
return owner_.ensure_component<T>(
std::forward<Args>(args)...);
}
template < typename T >
T& component<T>::get() {
return owner_.get_component<T>();
@@ -2105,6 +2190,7 @@ namespace ecs_hpp
}
inline entity registry::create_entity() {
assert(!entity_ids_locker::is_locked());
if ( !free_entity_ids_.empty() ) {
const auto free_ent_id = free_entity_ids_.back();
const auto new_ent_id = detail::upgrade_entity_id(free_ent_id);
@@ -2153,6 +2239,7 @@ namespace ecs_hpp
}
inline void registry::destroy_entity(const uentity& ent) noexcept {
assert(!entity_ids_locker::is_locked());
assert(valid_entity(ent));
remove_all_components(ent);
if ( entity_ids_.unordered_erase(ent) ) {
@@ -2174,6 +2261,14 @@ namespace ecs_hpp
std::forward<Args>(args)...);
}
template < typename T, typename... Args >
T& registry::ensure_component(const uentity& ent, Args&&... args) {
assert(valid_entity(ent));
return get_or_create_storage_<T>().ensure(
ent,
std::forward<Args>(args)...);
}
template < typename T >
bool registry::remove_component(const uentity& ent) {
assert(valid_entity(ent));
@@ -2251,24 +2346,28 @@ namespace ecs_hpp
template < typename... Ts >
std::tuple<Ts&...> registry::get_components(const uentity& ent) {
(void)ent;
assert(valid_entity(ent));
return std::make_tuple(std::ref(get_component<Ts>(ent))...);
}
template < typename... Ts >
std::tuple<const Ts&...> registry::get_components(const const_uentity& ent) const {
(void)ent;
assert(valid_entity(ent));
return std::make_tuple(std::cref(get_component<Ts>(ent))...);
}
template < typename... Ts >
std::tuple<Ts*...> registry::find_components(const uentity& ent) noexcept {
(void)ent;
assert(valid_entity(ent));
return std::make_tuple(find_component<Ts>(ent)...);
}
template < typename... Ts >
std::tuple<const Ts*...> registry::find_components(const const_uentity& ent) const noexcept {
(void)ent;
assert(valid_entity(ent));
return std::make_tuple(find_component<Ts>(ent)...);
}
@@ -2298,6 +2397,7 @@ namespace ecs_hpp
template < typename F >
void registry::for_each_entity(F&& f) {
entity_ids_locker lock;
for ( const auto id : entity_ids_ ) {
f({*this, id});
}
@@ -2305,6 +2405,7 @@ namespace ecs_hpp
template < typename F >
void registry::for_each_entity(F&& f) const {
entity_ids_locker lock;
for ( const auto id : entity_ids_ ) {
f({*this, id});
}
@@ -2351,10 +2452,9 @@ namespace ecs_hpp
[](priority_t pr, const auto& r){
return pr < r.first;
});
systems_.emplace(
systems_.insert(
iter,
priority,
std::make_unique<T>(std::forward<Args>(args)...));
std::make_pair(priority, std::make_unique<T>(std::forward<Args>(args)...)));
}
inline void registry::process_all_systems() {
@@ -2431,7 +2531,7 @@ namespace ecs_hpp
return *storage;
}
const auto family = detail::type_family<T>::id();
storages_.emplace(
storages_.insert(
family,
std::make_unique<detail::component_storage<T>>(*this));
return *static_cast<detail::component_storage<T>*>(

51
untests/ecs_tests.cpp
View File

@@ -177,7 +177,7 @@ TEST_CASE("detail") {
REQUIRE(s.insert(position_c(1,2)));
REQUIRE_FALSE(s.insert(position_c(1,2)));
REQUIRE(s.has(position_c(1,2)));
REQUIRE(s.emplace(3,4));
REQUIRE(s.insert(position_c(3,4)));
REQUIRE(s.has(position_c(3,4)));
REQUIRE(s.get_dense_index(position_c(1,2)) == 0);
REQUIRE(s.get_dense_index(position_c(3,4)) == 1);
@@ -209,16 +209,16 @@ TEST_CASE("detail") {
{
obj_t o{21u};
REQUIRE(m.insert(21u, o));
REQUIRE(m.insert(42u, obj_t{42u}));
REQUIRE(m.emplace(84u, 84u));
REQUIRE(m.insert(21u, o).second);
REQUIRE(m.insert(42u, obj_t{42u}).second);
REQUIRE(m.insert(84u, obj_t(84u)).second);
}
{
obj_t o{21u};
REQUIRE_FALSE(m.insert(21u, o));
REQUIRE_FALSE(m.insert(42u, obj_t{42u}));
REQUIRE_FALSE(m.emplace(84u, 84u));
REQUIRE_FALSE(m.insert(21u, o).second);
REQUIRE_FALSE(m.insert(42u, obj_t{42u}).second);
REQUIRE_FALSE(m.insert(84u, obj_t(84u)).second);
}
REQUIRE_FALSE(m.empty());
@@ -270,10 +270,10 @@ TEST_CASE("detail") {
};
sparse_map<position_c, obj_t, position_c_indexer> s{position_c_indexer()};
REQUIRE(s.insert(position_c(1,2), obj_t{1}));
REQUIRE_FALSE(s.insert(position_c(1,2), obj_t{1}));
REQUIRE(s.insert(position_c(1,2), obj_t{1}).second);
REQUIRE_FALSE(s.insert(position_c(1,2), obj_t{1}).second);
REQUIRE(s.has(position_c(1,2)));
REQUIRE(s.emplace(position_c(3,4), obj_t{3}));
REQUIRE(s.insert(position_c(3,4), obj_t{3}).second);
REQUIRE(s.has(position_c(3,4)));
REQUIRE(s.get(position_c(1,2)).x == 1);
REQUIRE(s.get(position_c(3,4)).x == 3);
@@ -291,14 +291,14 @@ TEST_CASE("detail") {
};
sparse_map<unsigned, obj_t> m;
REQUIRE(m.insert_or_assign(42, obj_t(42)));
REQUIRE(m.insert_or_assign(42, obj_t(42)).second);
REQUIRE(m.has(42));
REQUIRE(m.get(42).x == 42);
REQUIRE_FALSE(m.insert_or_assign(42, obj_t(21)));
REQUIRE_FALSE(m.insert_or_assign(42, obj_t(21)).second);
REQUIRE(m.has(42));
REQUIRE(m.get(42).x == 21);
REQUIRE(m.size() == 1);
REQUIRE(m.insert_or_assign(84, obj_t(84)));
REQUIRE(m.insert_or_assign(84, obj_t(84)).second);
REQUIRE(m.has(84));
REQUIRE(m.get(84).x == 84);
REQUIRE(m.size() == 2);
@@ -813,6 +813,31 @@ TEST_CASE("registry") {
e1.destroy();
}
}
SECTION("component_ensuring") {
{
ecs::registry w;
ecs::entity e1 = w.create_entity();
e1.ensure_component<position_c>(1,2);
e1.ensure_component<movable_c>();
REQUIRE(e1.get_component<position_c>() == position_c(1,2));
REQUIRE(e1.exists_component<movable_c>());
e1.ensure_component<position_c>(10,20).x = 15;
e1.ensure_component<movable_c>();
REQUIRE(e1.get_component<position_c>() == position_c(15,2));
REQUIRE(e1.exists_component<movable_c>());
ecs::component<velocity_c> c1 = w.wrap_component<velocity_c>(e1);
REQUIRE_FALSE(c1.exists());
c1.ensure(2, 1).y = 10;
REQUIRE(c1.get() == velocity_c(2, 10));
c1.ensure(10, 20).x = 20;
REQUIRE(c1.get() == velocity_c(20, 10));
}
}
SECTION("component_accessing") {
{
ecs::registry w;