MassDebuggerBreakpoints.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
#include "MassEntityMacros.h"
 
#if WITH_MASSENTITY_DEBUG
#define MASS_BREAKPOINT(bShouldBreak)                   \
    do {                                                \
        if (UNLIKELY(bShouldBreak))                     \
        {                                               \
            UE::Mass::Debug::FBreakpoint::DebugBreak(); \
        }                                               \
    } while (0)
 
#include "MassEntityHandle.h"
#include "Misc/TVariant.h"
#include "UObject/ObjectKey.h"
#include "MassRequirements.h"
 
struct FMassDebugger;
class UMassProcessor;
class UScriptStruct;
 
namespace UE::Mass::Debug
{
    struct FBreakpointHandle
    {
        int32 Handle = 0;
 
        FBreakpointHandle(int32 InHandle)
            : Handle(InHandle)
        {
        }
 
        FBreakpointHandle() = default;
 
        friend bool operator==(const FBreakpointHandle& A, const FBreakpointHandle& B)
        {
            return A.Handle == B.Handle;
        }
 
        bool IsValid() const
        {
            return Handle > 0;
        }
 
        operator bool() const
        {
            return IsValid();
        }
 
        static FBreakpointHandle CreateHandle()
        {
            static int32 LastHandle = 0;
            return FBreakpointHandle{ ++LastHandle };
        }
 
        static FBreakpointHandle Invalid()
        {
            return FBreakpointHandle();
        }
    };
 
    struct FBreakpoint
    {
        friend FMassDebugger;
 
        MASSENTITY_API FBreakpoint();
 
        enum class ETriggerType : uint8
        {
            None,
            ProcessorExecute,
            FragmentWrite,
            EntityCreate,
            EntityDestroy,
            FragmentAdd,
            FragmentRemove,
            TagAdd,
            TagRemove,
            MAX
        };
        static MASSENTITY_API  FString TriggerTypeToString(FBreakpoint::ETriggerType InType);
        static MASSENTITY_API bool StringToTriggerType(const FString& InString, FBreakpoint::ETriggerType& OutType);
 
        enum class EFilterType : uint8
        {
            None,
            SpecificEntity,
            SelectedEntity,
            Query
        };
 
        static MASSENTITY_API FString FilterTypeToString(FBreakpoint::EFilterType InType);
        static MASSENTITY_API bool StringToFilterType(const FString& InString, FBreakpoint::EFilterType& OutType);
 
        using TriggerVariant = TVariant<
            TObjectKey<const UMassProcessor>,
            TObjectKey<const UScriptStruct>
        >;
 
        using FilterVariant = TVariant<
            FMassEntityHandle,
            FMassFragmentRequirements
        >;
 
        FBreakpointHandle Handle;
        mutable uint64 HitCount = 0;
        ETriggerType TriggerType = ETriggerType::None;
        EFilterType FilterType = EFilterType::None;
        TriggerVariant Trigger;
        FilterVariant Filter;
        bool bEnabled = false;
 
        MASSENTITY_API bool ApplyEntityFilterByFragments(const TArray<const UScriptStruct*>& Fragments) const;
 
        MASSENTITY_API bool ApplyEntityFilterByArchetype(const FMassArchetypeHandle& ArchetypeHandle) const;
 
        MASSENTITY_API bool ApplyEntityFilter(const FMassEntityManager& EntityManager, const FMassEntityHandle& Entity) const;
 
        static MASSENTITY_API bool CheckFragmentAddBreakpoints(const FMassEntityHandle& Handle, const UScriptStruct* FragmentType);
 
        template<typename... TFragments>
        static bool CheckFragmentAddBreakpoints(const FMassEntityHandle& Handle, TFragments... InFragments)
        {
            if (LIKELY(!bHasBreakpoint))
            {
                return false;
            }
            return (... || CheckFragmentAddBreakpoints(Handle, TFragments::StaticStruct()));
        }
 
        static MASSENTITY_API bool CheckFragmentAddBreakpoints(TConstArrayView<FMassEntityHandle> Entities, const UScriptStruct* FragmentType);
 
        template<typename... TFragments>
        static bool CheckFragmentAddBreakpoints(TConstArrayView<FMassEntityHandle> Entities, TFragments... InFragments)
        {
            if (LIKELY(!bHasBreakpoint))
            {
                return false;
            }
 
            return (... || CheckFragmentAddBreakpoints(Entities, TFragments::StaticStruct()));
        }
 
        template<typename... TFragments>
        static bool CheckFragmentAddBreakpointsByInstances(const FMassEntityHandle& Handle, TFragments... InFragments)
        {
            if (LIKELY(!bHasBreakpoint))
            {
                return false;
            }
            return (... || CheckFragmentAddBreakpoints(Handle, std::remove_reference_t<decltype(InFragments)>::StaticStruct()));
        }
 
        template<typename... TFragments>
        static bool CheckFragmentAddBreakpointsByInstances(TConstArrayView<FMassEntityHandle> Entities, TFragments... InFragments)
        {
            if (LIKELY(!bHasBreakpoint))
            {
                return false;
            }
 
            return (... || CheckFragmentAddBreakpoints(Entities, std::remove_reference_t<decltype(InFragments)>::StaticStruct()));
        }
 
        static MASSENTITY_API bool CheckFragmentRemoveBreakpoints(const FMassEntityHandle& Handle, const UScriptStruct* FragmentType);
 
        template<typename... TFragments>
        static bool CheckFragmentRemoveBreakpoints(const FMassEntityHandle& Handle, TFragments... InFragments)
        {
            if (LIKELY(!bHasBreakpoint))
            {
                return false;
            }
            return (... || CheckFragmentRemoveBreakpoints(Handle, std::remove_reference_t<decltype(InFragments)>::StaticStruct()));
        }
 
        static MASSENTITY_API bool CheckFragmentRemoveBreakpoints(TConstArrayView<FMassEntityHandle> Entities, const UScriptStruct* FragmentType);
 
        template<typename... TFragments>
        static bool CheckFragmentRemoveBreakpoints(TConstArrayView<FMassEntityHandle> Entities, TFragments... InFragments)
        {
            if (LIKELY(!bHasBreakpoint))
            {
                return false;
            }
            return (... || CheckFragmentRemoveBreakpoints(Entities, TFragments::StaticStruct()));
        }
 
        static bool CheckCreateEntityBreakpoints(TArray<const UScriptStruct*> Fragments);
 
        template<typename... TFragments>
        static bool CheckCreateEntityBreakpoints(TFragments... InFragments)
        {
            if (LIKELY(!bHasBreakpoint))
            {
                return false;
            }
 
            return CheckCreateEntityBreakpoints({ TFragments::StaticStruct()... });
        }
 
        static MASSENTITY_API bool CheckCreateEntityBreakpoints(const FMassArchetypeHandle& ArchetypeHandle);
 
        static MASSENTITY_API bool CheckDestroyEntityBreakpoints(const FMassEntityHandle& Entity);
 
        static MASSENTITY_API bool CheckDestroyEntityBreakpoints(TConstArrayView<FMassEntityHandle> Entities);
 
        static MASSENTITY_API void DisableActiveBreakpoint();
 
        static inline bool HasBreakpoint()
        {
            return bHasBreakpoint;
        }
 
        static MASSENTITY_API void DebugBreak();
 
    private:
        static bool bHasBreakpoint;
        static FBreakpointHandle LastBreakpointHandle;
    };
    
} // namespace UE::Mass::Debug
 
#else // WITH_MASSENTITY_DEBUG
namespace UE::Mass::Debug
{
    struct FBreakpointHandle
    {
    };
 
    struct FBreakpoint
    {
        enum class ETriggerType : uint8
        {
        };
        enum class EFilterType : uint8
        {
        };
    };
}
 
#define MASS_BREAKPOINT(...)    \
        do { } while (0)
 
#endif // WITH_MASSENTITY_DEBUG