EnTT源码分析【四】：storage

1
2
3

//> src/entt/storage.hpp 235
template<typename Type, typename Entity, typename Allocator, typename>
class basic_storage: public basic_sparse_set<Entity, typename std::allocator_traits<Allocator>::template rebind_alloc<Entity>> { ... }

1
2
3
4
5
6
7
8
9

storage:
payloads: _ _ _
packed  : _ _ _
sparse  : _ _ _
    
插入实体1和组件V:
payloads: V _ _
packed  : 1 _ _
sparse  : _ 0 _

1
2
3

//> src/entt/storage.hpp 955
class basic_storage<Entity, Entity, Allocator>
    : public basic_sparse_set<Entity, Allocator> { ... }

1
2
3
4
5
6

// 一个tag类，只是为了标记某个entity是玩家操控的而已
struct Player {};

registry.emplace<Player>(entity);

// 之后可在system中对含有Player类的entity进行特殊操作（比如按键响应等）

1
2
3

//> src/entt/storage.hpp 780
template<typename Type, typename Entity, typename Allocator>
class basic_storage<Type, Entity, Allocator, std::enable_if_t<component_traits<Type>::page_size == 0u>>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

template<typename Type, typename = void>
struct component_traits {
    static_assert(std::is_same_v<std::decay_t<Type>, Type>, "Unsupported type");

    /*! @brief Component type. */
    using type = Type;

    /*! @brief Pointer stability, default is `false`. */
    static constexpr bool in_place_delete = internal::in_place_delete<Type>::value;
    /*! @brief Page size, default is `ENTT_PACKED_PAGE` for non-empty types. */
    static constexpr std::size_t page_size = internal::page_size<Type>::value;
};

1
2
3
4
5
6
7
8
9

template<typename Type, typename Entity, typename Allocator, typename>
class basic_storage: public basic_sparse_set<Entity, typename std::allocator_traits<Allocator>::template rebind_alloc<Entity>> {
    using alloc_traits = std::allocator_traits<Allocator>;
    static_assert(std::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
    using container_type = std::vector<typename alloc_traits::pointer, typename alloc_traits::template rebind_alloc<typename alloc_traits::pointer>>;
    using underlying_type = basic_sparse_set<Entity, typename alloc_traits::template rebind_alloc<Entity>>;
    using underlying_iterator = typename underlying_type::basic_iterator;

    static constexpr bool is_pinned_type_v = !(std::is_move_constructible_v<Type> && std::is_move_assignable_v<Type>);

1
2

//> src/entt/entity/storage.hpp 404    
using traits_type = component_traits<value_type>;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

//> src/entt/entity/storage.hpp 249
auto assure_at_least(const std::size_t pos) {
    const auto idx = pos / traits_type::page_size;

    if(!(idx < payload.size())) {
        auto curr = payload.size();
        allocator_type allocator{get_allocator()};
        payload.resize(idx + 1u, nullptr);

        ENTT_TRY {
            for(const auto last = payload.size(); curr < last; ++curr) {
                payload[curr] = alloc_traits::allocate(allocator, traits_type::page_size);
            }
        }
        ENTT_CATCH {
            payload.resize(curr);
            ENTT_THROW;
        }
    }

    return payload[idx] + fast_mod(pos, traits_type::page_size);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

//> src/entt/entity/storage.hpp 271
template<typename... Args>
auto emplace_element(const Entity entt, const bool force_back, Args &&...args) {
    const auto it = base_type::try_emplace(entt, force_back);

    ENTT_TRY {
        auto elem = assure_at_least(static_cast<size_type>(it.index()));
        entt::uninitialized_construct_using_allocator(to_address(elem), get_allocator(), std::forward<Args>(args)...);
    }
    ENTT_CATCH {
        base_type::pop(it, it + 1u);
        ENTT_THROW;
    }

    return it;
}

1
2
3
4

template<typename Type, typename Allocator, typename... Args>
constexpr Type *uninitialized_construct_using_allocator(Type *value, const Allocator &allocator, Args &&...args) {
    return std::apply([value](auto &&...curr) { return new(value) Type(std::forward<decltype(curr)>(curr)...); }, internal::uses_allocator_construction<Type>::args(allocator, std::forward<Args>(args)...));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

增加元素1
packed: 1
sparse: _ 0
    
增加元素2
packed: 1 2
sparse: _ 0 1

删除元素1
packed: 2
sparse: _ _ 0
 
增加元素3
packed: 2 3
sparse: _ _ 0 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

length = 0
packed:
sparse:

创建三次实体：
创建实体时，如果没有可复用实体，会将packed.size()的值作为实体插入。所以创建三次会插入0, 1, 2

length = 3
packed: 0 1 2
sparse: 0 1 2
    
删除 1
length = 2
packed: 0 2 1/1		这里的1/1代表ID为1，版本为1的实体。删除并不会真的删掉，而是将元素移动到 length-1 处并自增版本号，同时sparse也会更改
sparse: 0 2 1
    
创建新实体：
这时存在可复用实体，那么直接返回length处值即可
length = 3
packed: 0 2 1/1
sparse: 0 2 1