MassProcessingContext.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "MassExecutionContext.h"
#include "MassCommandBuffer.h"
#include "MassEntityManager.h"
#include "StructUtils/InstancedStruct.h"
 
 
namespace UE::Mass
{
    struct FProcessingContext
    {
        UE_DEPRECATED_FORGAME(5.6, "This constructor is deprecated. Use one of the other ones.")
        FProcessingContext() = default;
        UE_DEPRECATED_FORGAME(5.6, "This constructor is deprecated. Use one of the other ones.")
        FProcessingContext(const FProcessingContext&) = default;
 
        FProcessingContext(FProcessingContext&&) = default;
 
        explicit FProcessingContext(FMassEntityManager& InEntityManager, const float InDeltaSeconds = 0.f, const bool bInFlushCommandBuffer = true);
        explicit FProcessingContext(const TSharedRef<FMassEntityManager>& InEntityManager, const float InDeltaSeconds = 0.f, const bool bInFlushCommandBuffer = true);
        explicit FProcessingContext(TSharedRef<FMassEntityManager>&& InEntityManager, const float InDeltaSeconds = 0.f, const bool bInFlushCommandBuffer = true);
        explicit FProcessingContext(const TSharedPtr<FMassEntityManager>& InEntityManager, const float InDeltaSeconds = 0.f, const bool bInFlushCommandBuffer = true);
        MASSENTITY_API ~FProcessingContext();
        
        [[nodiscard]] FMassExecutionContext& GetExecutionContext() &;
        [[nodiscard]] FMassExecutionContext&& GetExecutionContext() &&;
        bool GetWillFlushCommands() const;
        float GetDeltaSeconds() const;
 
        void SetCommandBuffer(TSharedPtr<FMassCommandBuffer>&& InCommandBuffer);
        void SetCommandBuffer(const TSharedPtr<FMassCommandBuffer>& InCommandBuffer);
 
        const TSharedRef<FMassEntityManager>& GetEntityManager() const;
 
        UE_DEPRECATED_FORGAME(5.6, "Direct access to FProcessingContext.EntityManager has been deprecated. Use GetEntityManager instead.")
        TSharedRef<FMassEntityManager> EntityManager;
 
        UE_DEPRECATED_FORGAME(5.6, "Direct access to FProcessingContex.DeltaSeconds has been deprecated. Set it via the constructor instead, read via the getter.")
        float DeltaSeconds = 0.f;
 
        FInstancedStruct AuxData;
 
        UE_DEPRECATED_FORGAME(5.6, "Direct access to FProcessingContex.bFlushCommandBuffer has been deprecated. Set it via the constructor instead, read via the GetWillFlushCommands getter.")
        bool bFlushCommandBuffer = true; 
 
        UE_DEPRECATED_FORGAME(5.6, "Direct access to FProcessingContext's CommandBuffer has been deprecated. Use SetCommandBuffer()")
        TSharedPtr<FMassCommandBuffer> CommandBuffer;
 
    protected:
        uint8 ExecutionContextBuffer[sizeof(FMassExecutionContext)];
        FMassExecutionContext* ExecutionContextPtr = nullptr;
    };
 
    //----------------------------------------------------------------------//
    // INLINES
    //----------------------------------------------------------------------//
    // @todo remove the depracation disabling once CommandBuffer and EntityManager are moved to `protected` and un-deprecated (around UE5.8)
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    inline FProcessingContext::FProcessingContext(FMassEntityManager& InEntityManager, const float InDeltaSeconds, const bool bInFlushCommandBuffer)
        : FProcessingContext(/*MoveTemp*/(InEntityManager.AsShared()), InDeltaSeconds, bInFlushCommandBuffer)
    {
 
    }
 
    inline FProcessingContext::FProcessingContext(const TSharedRef<FMassEntityManager>& InEntityManager, const float InDeltaSeconds, const bool bInFlushCommandBuffer)
        : EntityManager(InEntityManager)
        , DeltaSeconds(InDeltaSeconds)
        , bFlushCommandBuffer(bInFlushCommandBuffer)
    {
        
    }
 
    inline FProcessingContext::FProcessingContext(TSharedRef<FMassEntityManager>&& InEntityManager, const float InDeltaSeconds, const bool bInFlushCommandBuffer)
        : EntityManager(MoveTemp(InEntityManager))
        , DeltaSeconds(InDeltaSeconds)
        , bFlushCommandBuffer(bInFlushCommandBuffer)
    {
        
    }
 
    inline FProcessingContext::FProcessingContext(const TSharedPtr<FMassEntityManager>& InEntityManager, const float InDeltaSeconds, const bool bInFlushCommandBuffer)
        : FProcessingContext(InEntityManager.ToSharedRef(), InDeltaSeconds, bInFlushCommandBuffer)
    {
        
    }
 
    inline FMassExecutionContext& FProcessingContext::GetExecutionContext() &
    {
        if (ExecutionContextPtr == nullptr)
        {
            ExecutionContextPtr = new(&ExecutionContextBuffer) FMassExecutionContext(*EntityManager, DeltaSeconds);
 
            if (CommandBuffer.IsValid() == false)
            {
                CommandBuffer = MakeShareable(new FMassCommandBuffer());
            }
 
            ExecutionContextPtr->SetDeferredCommandBuffer(CommandBuffer);
            
            ExecutionContextPtr->SetFlushDeferredCommands(false);
            ExecutionContextPtr->SetAuxData(AuxData);
            ExecutionContextPtr->SetExecutionType(EMassExecutionContextType::Processor);
        }
        return *ExecutionContextPtr;
    }
 
    inline FMassExecutionContext&& FProcessingContext::GetExecutionContext() &&
    {
        // Note: it's fine to store a reference to created execution context
        // while nulling-out the pointer, since the FMassExecutionContext data
        // lives in the ExecutionContextBuffer buffer. Nulling out ExecutionContextPtr
        // only signals that the execution context has been moved out.
 
        FMassExecutionContext& LocalExecutionContext = GetExecutionContext();
        ExecutionContextPtr = nullptr;
        CommandBuffer.Reset();
 
        return MoveTemp(LocalExecutionContext);
    }
 
    inline void FProcessingContext::SetCommandBuffer(TSharedPtr<FMassCommandBuffer>&& InCommandBuffer)
    {
        checkf(ExecutionContextPtr == nullptr, TEXT("Setting command buffer after ExecutionContext creation is not supported"));
        if (ExecutionContextPtr == nullptr)
        {
            CommandBuffer = MoveTemp(InCommandBuffer);
        }
    }
 
    inline void FProcessingContext::SetCommandBuffer(const TSharedPtr<FMassCommandBuffer>& InCommandBuffer)
    {
        checkf(ExecutionContextPtr == nullptr, TEXT("Setting command buffer after ExecutionContext creation is not supported"));
        if (ExecutionContextPtr == nullptr)
        {
            CommandBuffer = InCommandBuffer;
        }
    }
 
    inline const TSharedRef<FMassEntityManager>& FProcessingContext::GetEntityManager() const
    {
        return EntityManager;
    }
 
    inline bool FProcessingContext::GetWillFlushCommands() const
    {
        return bFlushCommandBuffer;
    }
 
    inline float FProcessingContext::GetDeltaSeconds() const
    {
        return DeltaSeconds;
    }
 
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
} // namespace UE::Mass