MassBitSetRegistry.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "StructUtils/StructUtilsTypes.h"
#include "TypeBitSetBuilder.h"
#include "MassEntityElementTypes.h"
#include "MassEntityConcepts.h"
 
template <>
struct TTypeBitSetTraits<FMassTag> final
{
    template<typename TTestedType>
    static constexpr bool IsValidType = UE::Mass::CTag<TTestedType>;
 
    static constexpr bool RequiresBaseType = true;
};
 
template <>
struct TTypeBitSetTraits<FMassFragment> final
{
    template<typename TTestedType>
    static constexpr bool IsValidType = UE::Mass::CFragment<TTestedType>;
 
    static constexpr bool RequiresBaseType = true;
};
 
namespace UE::Mass
{
    namespace Private
    {
        template<typename T, typename TUStructType = UScriptStruct>
        struct TBitTypeRegistry
        {
            using FBitSetBuilder = TTypeBitSetBuilder<T, TUStructType, /*bTestInheritanceAtRuntime=*/TTypeBitSetTraits<T>::RequiresBaseType>;
 
            using FBitSet = typename FBitSetBuilder::FConstBitSet;
 
            struct FBitSetFactory : FBitSetBuilder
            {
                FBitSetFactory(FStructTracker& InStructTracker)
                    : FBitSetBuilder(InStructTracker, BitSetInstance)
                {
                }
 
                FBitSet BitSetInstance; 
            };
 
            TBitTypeRegistry()
                : StructTracker([](){ return StructUtils::GetAsUStruct<T>(); })
            {
            }
 
            [[nodiscard]] inline FBitSetBuilder MakeBuilder(FBitSet& BitSet) const
            {
                return FBitSetBuilder(StructTracker, BitSet);
            }
 
            [[nodiscard]] inline FBitSetFactory MakeBuilder() const
            {
                return FBitSetFactory(StructTracker);
            }
 
            inline int32 RegisterType(const UScriptStruct* Type)
            {
                return StructTracker.Register(*Type);
            }
 
            template<typename TType>
            inline int32 RegisterType()
            {
                return RegisterType(TType::StaticStrict());
            }
 
            struct FBitSetStructTracker : public FStructTracker
            {
                FBitSetStructTracker(const UStruct* InBaseType, const FTypeValidation& InTypeValidation = FTypeValidation())
                    : FStructTracker(InBaseType, InTypeValidation)
                {
                    // Disable serialization, temporarily, until serialization is implemented for the new bitset type
                    bIsSerializable = false;
                }
            };
 
            mutable FBitSetStructTracker StructTracker; 
        };
    } // namespace Private
 
    using FFragmentBitRegistry = Private::TBitTypeRegistry<FMassFragment>;
    using FFragmentBitSetBuilder = FFragmentBitRegistry::FBitSetBuilder;
    using FFragmentBitSetReader = const FFragmentBitSetBuilder;
    using FFragmentBitSetFactory = FFragmentBitRegistry::FBitSetFactory;
 
    using FTagBitRegistry = Private::TBitTypeRegistry<FMassTag>;
    using FTagBitSetBuilder = FTagBitRegistry::FBitSetBuilder;
    using FTagBitSetReader = const FTagBitSetBuilder;
    using FTagBitSetFactory = FTagBitRegistry::FBitSetFactory;
 
    template<>
    MASSENTITY_API FFragmentBitRegistry::TBitTypeRegistry();
 
    template<>
    MASSENTITY_API FTagBitRegistry::TBitTypeRegistry();
 
} // namespace UE::Mass
 
using FMassFragmentBitSet_WIP = UE::Mass::FFragmentBitRegistry::FBitSet;
using FMassTagBitSet_WIP = UE::Mass::FTagBitRegistry::FBitSet;