Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

view:

Browse Source 
* prepare to storage getters for filters
* support both const and non-const excluded types
This commit is contained in:
Michele Caini
2022-04-29 12:18:12 +02:00
parent c4f430d0d0
commit b682e58df7
4 changed files with 37 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
TODO
View File

@@ -11,6 +11,9 @@ DOC:
* examples (and credits) from @alanjfs :)
WIP:
* add storage getter for filters to views and groups
* also add const/non-const filter to groups (see view)
* no () = default ctor for iterators with uninitialized members
* remove storage::base_type, make views extract the sparse set directly
* make non-const registry::get use const assure or the like
* emitter: runtime handlers, allocator support (ready for both already)

6
src/entt/entity/registry.hpp
View File

@@ -1220,14 +1220,14 @@ public:
* @return A newly created view.
*/
template<typename Component, typename... Other, typename... Exclude>
[[nodiscard]] basic_view<entity_type, get_t<std::add_const_t<Component>, std::add_const_t<Other>...>, exclude_t<Exclude...>> view(exclude_t<Exclude...> = {}) const {
return {assure<std::remove_const_t<Component>>(), assure<std::remove_const_t<Other>>()..., assure<Exclude>()...};
[[nodiscard]] basic_view<entity_type, get_t<const Component, const Other...>, exclude_t<const Exclude...>> view(exclude_t<Exclude...> = {}) const {
return {assure<std::remove_const_t<Component>>(), assure<std::remove_const_t<Other>>()..., assure<std::remove_const_t<Exclude>>()...};
}
/*! @copydoc view */
template<typename Component, typename... Other, typename... Exclude>
[[nodiscard]] basic_view<entity_type, get_t<Component, Other...>, exclude_t<Exclude...>> view(exclude_t<Exclude...> = {}) {
return {assure<std::remove_const_t<Component>>(), assure<std::remove_const_t<Other>>()..., assure<Exclude>()...};
return {assure<std::remove_const_t<Component>>(), assure<std::remove_const_t<Other>>()..., assure<std::remove_const_t<Exclude>>()...};
}
/**

62
src/entt/entity/view.hpp
View File

@@ -25,14 +25,16 @@ namespace entt {
namespace internal {
template<typename Type, std::size_t Component, std::size_t Exclude>
class view_iterator final {
template<typename, typename, typename>
class view_iterator;
template<typename Type, std::size_t... AllOf, std::size_t... AnyOf>
class view_iterator<Type, std::index_sequence<AllOf...>, std::index_sequence<AnyOf...>> final {
static constexpr std::size_t pool_count = sizeof...(AllOf) + sizeof...(AnyOf);
using iterator_type = typename Type::const_iterator;
[[nodiscard]] bool valid() const ENTT_NOEXCEPT {
return ((Component != 0u) || (*it != tombstone))
&& std::apply([entt = *it](const auto *...curr) { return (curr->contains(entt) && ...); }, pools)
&& std::apply([entt = *it](const auto *...curr) { return (!curr->contains(entt) && ...); }, filter);
return ((sizeof...(AllOf) != 0u) || (*it != tombstone)) && (std::get<AllOf>(pools)->contains(*it) && ...) && (!std::get<AnyOf>(pools)->contains(*it) && ...);
}
public:
@@ -44,11 +46,10 @@ public:
view_iterator() ENTT_NOEXCEPT = default;
view_iterator(iterator_type curr, iterator_type to, std::array<const Type *, Component> all_of, std::array<const Type *, Exclude> none_of) ENTT_NOEXCEPT
view_iterator(iterator_type curr, iterator_type to, std::array<const Type *, pool_count> ref) ENTT_NOEXCEPT
: it{curr},
last{to},
pools{all_of},
filter{none_of} {
pools{ref} {
if(it != last && !valid()) {
++(*this);
}
@@ -72,22 +73,21 @@ public:
return *operator->();
}
template<typename LhsType, auto... LhsArgs, typename RhsType, auto... RhsArgs>
template<typename LhsType, typename... LhsArgs, typename RhsType, typename... RhsArgs>
friend bool operator==(const view_iterator<LhsType, LhsArgs...> &, const view_iterator<RhsType, RhsArgs...> &) ENTT_NOEXCEPT;
private:
iterator_type it;
iterator_type last;
std::array<const Type *, Component> pools;
std::array<const Type *, Exclude> filter;
std::array<const Type *, pool_count> pools;
};
template<typename LhsType, auto... LhsArgs, typename RhsType, auto... RhsArgs>
template<typename LhsType, typename... LhsArgs, typename RhsType, typename... RhsArgs>
[[nodiscard]] bool operator==(const view_iterator<LhsType, LhsArgs...> &lhs, const view_iterator<RhsType, RhsArgs...> &rhs) ENTT_NOEXCEPT {
return lhs.it == rhs.it;
}
template<typename LhsType, auto... LhsArgs, typename RhsType, auto... RhsArgs>
template<typename LhsType, typename... LhsArgs, typename RhsType, typename... RhsArgs>
[[nodiscard]] bool operator!=(const view_iterator<LhsType, LhsArgs...> &lhs, const view_iterator<RhsType, RhsArgs...> &rhs) ENTT_NOEXCEPT {
return !(lhs == rhs);
}
@@ -190,11 +190,12 @@ class basic_view<Entity, get_t<Component...>, exclude_t<Exclude...>> {
using storage_type = constness_as_t<typename storage_traits<Entity, std::remove_const_t<Comp>>::storage_type, Comp>;
template<std::size_t... Index>
[[nodiscard]] auto pools_to_array(std::index_sequence<Index...>) const ENTT_NOEXCEPT {
[[nodiscard]] auto opaque_set(std::index_sequence<Index...>) const ENTT_NOEXCEPT {
std::size_t pos{};
std::array<const base_type *, sizeof...(Component) - 1u> other{};
(static_cast<void>(std::get<Index>(pools) == view ? void() : void(other[pos++] = std::get<Index>(pools))), ...);
return other;
std::array<const base_type *, sizeof...(Component) + sizeof...(Exclude) - 1u> arr{};
(static_cast<void>(std::get<Index>(pools) == view ? void() : void(arr[pos++] = std::get<Index>(pools))), ...);
std::apply([&arr, &pos](auto *...curr) mutable { ((arr[pos++] = curr), ...); }, filter);
return arr;
}
template<std::size_t Comp, std::size_t Other, typename... Args>
@@ -213,7 +214,7 @@ class basic_view<Entity, get_t<Component...>, exclude_t<Exclude...>> {
if(((sizeof...(Component) != 1u) || (entt != tombstone))
&& ((Comp == Index || std::get<Index>(pools)->contains(entt)) && ...)
&& std::apply([entt](const auto *...cpool) { return (!cpool->contains(entt) && ...); }, filter)) {
&& std::apply([entt](const auto *...epool) { return (!epool->contains(entt) && ...); }, filter)) {
if constexpr(is_applicable_v<Func, decltype(std::tuple_cat(std::tuple<entity_type>{}, std::declval<basic_view>().get({})))>) {
std::apply(func, std::tuple_cat(std::make_tuple(entt), dispatch_get<Comp, Index>(curr)...));
} else {
@@ -236,7 +237,7 @@ public:
/*! @brief Common type among all storage types. */
using base_type = std::common_type_t<typename storage_type<Component>::base_type...>;
/*! @brief Bidirectional iterator type. */
using iterator = internal::view_iterator<base_type, sizeof...(Component) - 1u, sizeof...(Exclude)>;
using iterator = internal::view_iterator<base_type, std::make_index_sequence<sizeof...(Component) - 1u>, std::index_sequence_for<Exclude...>>;
/*! @brief Iterable view type. */
using iterable = iterable_adaptor<internal::extended_view_iterator<iterator, storage_type<Component>...>>;
@@ -251,7 +252,7 @@ public:
* @param component The storage for the types to iterate.
* @param epool The storage for the types used to filter the view.
*/
basic_view(storage_type<Component> &...component, const storage_type<Exclude> &...epool) ENTT_NOEXCEPT
basic_view(storage_type<Component> &...component, storage_type<Exclude> &...epool) ENTT_NOEXCEPT
: pools{&component...},
filter{&epool...},
view{(std::min)({&static_cast<const base_type &>(component)...}, [](auto *lhs, auto *rhs) { return lhs->size() < rhs->size(); })} {}
@@ -325,7 +326,7 @@ public:
* @return An iterator to the first entity of the view.
*/
[[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
return iterator{view->begin(), view->end(), pools_to_array(std::index_sequence_for<Component...>{}), filter};
return iterator{view->begin(), view->end(), opaque_set(std::index_sequence_for<Component...>{})};
}
/**
@@ -338,7 +339,7 @@ public:
* @return An iterator to the entity following the last entity of the view.
*/
[[nodiscard]] iterator end() const ENTT_NOEXCEPT {
return iterator{view->end(), view->end(), pools_to_array(std::index_sequence_for<Component...>{}), filter};
return iterator{view->end(), view->end(), opaque_set(std::index_sequence_for<Component...>{})};
}
/**
@@ -369,7 +370,7 @@ public:
* iterator otherwise.
*/
[[nodiscard]] iterator find(const entity_type entt) const ENTT_NOEXCEPT {
return contains(entt) ? iterator{view->find(entt), view->end(), pools_to_array(std::index_sequence_for<Component...>{}), filter} : end();
return contains(entt) ? iterator{view->find(entt), view->end(), opaque_set(std::index_sequence_for<Component...>{})} : end();
}
/**
@@ -492,16 +493,12 @@ public:
template<typename... Get, typename... Excl>
[[nodiscard]] auto operator|(const basic_view<Entity, get_t<Get...>, exclude_t<Excl...>> &other) const ENTT_NOEXCEPT {
using view_type = basic_view<Entity, get_t<Component..., Get...>, exclude_t<Exclude..., Excl...>>;
return std::make_from_tuple<view_type>(std::tuple_cat(
std::apply([](auto *...curr) { return std::forward_as_tuple(*curr...); }, pools),
std::apply([](auto *...curr) { return std::forward_as_tuple(*curr...); }, other.pools),
std::apply([](const auto *...curr) { return std::forward_as_tuple(static_cast<const storage_type<Exclude> &>(*curr)...); }, filter),
std::apply([](const auto *...curr) { return std::forward_as_tuple(static_cast<const storage_type<Excl> &>(*curr)...); }, other.filter)));
return std::make_from_tuple<view_type>(std::apply([](auto *...curr) { return std::forward_as_tuple(*curr...); }, std::tuple_cat(pools, other.pools, filter, other.filter)));
}
private:
std::tuple<storage_type<Component> *...> pools;
std::array<const base_type *, sizeof...(Exclude)> filter;
std::tuple<storage_type<Exclude> *...> filter;
const base_type *view;
};
@@ -815,15 +812,12 @@ public:
template<typename... Get, typename... Excl>
[[nodiscard]] auto operator|(const basic_view<Entity, get_t<Get...>, exclude_t<Excl...>> &other) const ENTT_NOEXCEPT {
using view_type = basic_view<Entity, get_t<Component, Get...>, exclude_t<Excl...>>;
return std::make_from_tuple<view_type>(std::tuple_cat(
std::forward_as_tuple(*std::get<0>(pools)),
std::apply([](auto *...curr) { return std::forward_as_tuple(*curr...); }, other.pools),
std::apply([](const auto *...curr) { return std::forward_as_tuple(static_cast<const typename view_type::template storage_type<Excl> &>(*curr)...); }, other.filter)));
return std::make_from_tuple<view_type>(std::apply([this](auto *...curr) { return std::forward_as_tuple(*std::get<0>(pools), *curr...); }, std::tuple_cat(other.pools, other.filter)));
}
private:
std::tuple<storage_type *> pools;
std::array<const base_type *, 0u> filter;
std::tuple<> filter;
const base_type *view;
};

6
test/entt/entity/helper.cpp
View File

@@ -22,8 +22,8 @@ TEST(Helper, AsView) {
([](entt::view<entt::get_t<int>>) {})(entt::as_view{registry});
([](entt::view<entt::get_t<char, double>, entt::exclude_t<int>>) {})(entt::as_view{registry});
([](entt::view<entt::get_t<const char, double>, entt::exclude_t<int>>) {})(entt::as_view{registry});
([](entt::view<entt::get_t<const char, const double>, entt::exclude_t<int>>) {})(entt::as_view{cregistry});
([](entt::view<entt::get_t<const char, double>, entt::exclude_t<const int>>) {})(entt::as_view{registry});
([](entt::view<entt::get_t<const char, const double>, entt::exclude_t<const int>>) {})(entt::as_view{cregistry});
}
TEST(Helper, AsGroup) {
@@ -32,7 +32,7 @@ TEST(Helper, AsGroup) {
([](entt::group<entt::owned_t<double>, entt::get_t<char>, entt::exclude_t<int>>) {})(entt::as_group{registry});
([](entt::group<entt::owned_t<double>, entt::get_t<const char>, entt::exclude_t<int>>) {})(entt::as_group{registry});
([](entt::group<entt::owned_t<const double>, entt::get_t<const char>, entt::exclude_t<int>>) {})(entt::as_group{cregistry});
([](entt::group<entt::owned_t<const double>, entt::get_t<const char>, entt::exclude_t<const int>>) {})(entt::as_group{cregistry});
}
TEST(Helper, Invoke) {