MovieSceneEntityRange.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Delegates/IntegerSequence.h"
#include "Templates/UnrealTemplate.h"
 
template<typename... T> struct TTuple;
 
namespace UE
{
namespace MovieScene
{
 
 
template<typename... T> struct TEntityPtr;
template<typename... T> struct TEntityRangeImpl;
 
template<typename... T>
struct TEntityRange : TEntityRangeImpl<TMakeIntegerSequence<int, sizeof...(T)>, T...>
{
    using PtrType = TEntityPtr<T...>;
    using Super   = TEntityRangeImpl<TMakeIntegerSequence<int, sizeof...(T)>, T...>;
 
    TEntityRange()
        : Super(0)
    {}
 
 
    explicit TEntityRange(int32 InNum)
        : Super(InNum)
    {}
 
 
    explicit TEntityRange(int32 InNum, T*... InComponentArrays)
        : Super(InNum, InComponentArrays...)
    {}
 
 
    int32 Num() const
    {
        return this->NumEntities;
    }
 
 
    TEntityPtr<T...> operator[](int32 Index) const
    {
        check(Index >= 0 && Index < this->NumEntities);
        return TEntityPtr<T...>(Index, this);
    }
 
 
    template<int ComponentTypeIndex>
    auto*& GetComponentArrayReference()
    {
        return this->ComponentArrays.template Get<ComponentTypeIndex>();
    }
 
 
    template<int ComponentTypeIndex>
    auto* GetRawUnchecked() const
    {
        return this->ComponentArrays.template Get<ComponentTypeIndex>();
    }
 
 
    template<int32 ComponentTypeIndex>
    auto GetAll() const
    {
        auto* Ptr = this->ComponentArrays.template Get<ComponentTypeIndex>();
        return MakeArrayView(Ptr, Ptr ? this->NumEntities : 0);
    }
 
 
    template<int ComponentTypeIndex>
    auto& GetComponent(int32 EntityIndex) const
    {
        auto* Ptr = this->ComponentArrays.template Get<ComponentTypeIndex>();
        checkSlow(Ptr);
        return *(Ptr + EntityIndex);
    }
 
 
    template<int ComponentTypeIndex>
    auto* GetComponentOptional(int32 EntityIndex) const
    {
        auto* Ptr = this->ComponentArrays.template Get<ComponentTypeIndex>();
        return Ptr ? (Ptr + EntityIndex) : nullptr;
    }
 
 
    template<int ComponentTypeIndex, typename ValueType>
    void SetComponent(int32 EntityIndex, ValueType&& InValue) const
    {
        auto* Ptr = this->ComponentArrays.template Get<ComponentTypeIndex>();
        checkSlow(Ptr);
        *(Ptr + EntityIndex) = Forward<ValueType>(InValue);
    }
 
 
    /*~ stl-like range-for iterator */
    TEntityPtr<T...> begin() const { return TEntityPtr<T...>(0, this); }
    TEntityPtr<T...> end() const   { return TEntityPtr<T...>(Num(), this); }
};
 
 
template<int... Indices, typename... T>
struct TEntityRangeImpl<TIntegerSequence<int, Indices...>, T...>
{
    void Slice(int32 Index, int32 NewNum)
    {
        check(Index >= 0 && Index + NewNum <= NumEntities);
 
        int Temp[] = {
            ( (ComponentArrays.template Get<Indices>() ? (ComponentArrays.template Get<Indices>() = ComponentArrays.template Get<Indices>() + Index, 0) : 0), 0)...
        };
        (void)Temp;
 
        NumEntities = NewNum;
    }
 
 
protected:
 
    explicit TEntityRangeImpl(int32 InNum)
        : NumEntities(InNum)
    {}
 
    explicit TEntityRangeImpl(int32 InNum, T*... InBasePtrs)
        : ComponentArrays(InBasePtrs...)
        , NumEntities(InNum)
    {}
 
    TTuple<T*...> ComponentArrays;
 
    int32 NumEntities;
};
 
 
 
template<typename... T>
struct TEntityPtr
{
    TEntityPtr(int32 InEntityIndex, const TEntityRange<T...>* InOwner)
        : Owner(InOwner)
        , EntityIndex(InEntityIndex)
    {
        checkSlow(Owner != nullptr);
    }
 
    TEntityPtr& operator++()
    {
        ++EntityIndex;
        return *this;
    }
 
 
    TEntityPtr& operator--()
    {
        --EntityIndex;
        return *this;
    }
 
    TEntityPtr& operator*()
    {
        return *this;
    }
 
 
    friend bool operator !=(const TEntityPtr& A, const TEntityPtr& B)
    {
        return A.EntityIndex != B.EntityIndex || A.Owner != B.Owner;
    }
 
 
    explicit operator bool() const
    {
        return EntityIndex >= 0 && EntityIndex < Owner->Num;
    }
 
 
    template<int ComponentTypeIndex>
    auto& Get() const
    {
        return Owner->template GetComponent<ComponentTypeIndex>(EntityIndex);
    }
 
 
    template<int ComponentTypeIndex>
    auto* GetOptional() const
    {
        return Owner->template GetComponentOptional<ComponentTypeIndex>(EntityIndex);
    }
 
 
    template<int ComponentTypeIndex, typename ValueType>
    void Set(ValueType&& InValue) const
    {
        Owner->SetComponent<ComponentTypeIndex>(EntityIndex, Forward<ValueType>(InValue));
    }
 
 
private:
 
    const TEntityRange<T...>* Owner;
 
    int32 EntityIndex;
};
 
template<typename T>
struct TEntityPtr<T>
{
    TEntityPtr(int32 InEntityIndex, const TEntityRange<T>* InOwner)
        : Owner(InOwner)
        , EntityIndex(InEntityIndex)
    {
        checkSlow(Owner != nullptr);
    }
 
    TEntityPtr& operator++()
    {
        ++EntityIndex;
        return *this;
    }
 
 
    TEntityPtr& operator--()
    {
        --EntityIndex;
        return *this;
    }
 
    T& operator*()
    {
        return *this;
    }
 
 
    friend bool operator !=(const TEntityPtr& A, const TEntityPtr& B)
    {
        return A.EntityIndex != B.EntityIndex || A.Owner != B.Owner;
    }
 
 
    explicit operator bool() const
    {
        return EntityIndex >= 0 && EntityIndex < Owner->Num;
    }
 
 
    template<int ComponentTypeIndex>
    auto& Get() const
    {
        return Owner->GetComponent<ComponentTypeIndex>(EntityIndex);
    }
 
 
    template<int ComponentTypeIndex>
    auto* GetOptional() const
    {
        return Owner->GetComponentOptional<ComponentTypeIndex>(EntityIndex);
    }
 
 
    template<int ComponentTypeIndex, typename ValueType>
    void Set(ValueType&& InValue) const
    {
        Owner->SetComponent<ComponentTypeIndex>(EntityIndex, Forward<ValueType>(InValue));
    }
 
 
private:
 
    const TEntityRange<T>* Owner;
 
    int32 EntityIndex;
};
 
 
} // namespace MovieScene
} // namespace UE