PhysicsFieldComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Components/PrimitiveComponent.h"
#include "Field/FieldSystem.h"
#include "UObject/ObjectMacros.h"
#include "RHI.h"
#include "RHIUtilities.h"
#include "RenderResource.h"
#include "PrimitiveSceneProxy.h"
#include "Kismet/BlueprintFunctionLibrary.h"
 
#include "PhysicsFieldComponent.generated.h"
 
enum class EFieldCommandBuffer : uint8
{
    GPUFieldBuffer = 0,
    CPUReadBuffer = 1,
    CPUWriteBuffer = 2,
    GPUDebugBuffer = 3,
    NumFieldBuffers = 4
};
 
struct FPhysicsFieldInfos
{
    using BufferOffsets = TStaticArray<UE::Core::TAlignedElement<int32, 16>, MAX_PHYSICS_FIELD_TARGETS>;
 
    int32 TargetCount = 1;
 
    TArray<EFieldPhysicsType> TargetTypes;
 
    BufferOffsets VectorTargets;
 
    BufferOffsets ScalarTargets;
 
    BufferOffsets IntegerTargets;
 
    BufferOffsets PhysicsTargets;
 
    BufferOffsets ValidTargets;
 
    TStaticArray<UE::Core::TAlignedElement<FIntVector4, 16>, MAX_PHYSICS_FIELD_TARGETS> PhysicsBounds;
 
    FVector ClipmapCenter = FVector::ZeroVector;
 
    float ClipmapDistance = 10000;
 
    int32 ValidCount = 0;
 
    int32 ClipmapCount = 4;
 
    int32 ClipmapExponent = 2;
 
    int32 ClipmapResolution = 64;
 
    FVector ViewOrigin = FVector::ZeroVector;
 
    TArray<int32> CellsOffsets;
 
    TArray<FIntVector4> CellsMin;
 
    TArray<FIntVector4> CellsMax;
 
    TStaticArray<UE::Core::TAlignedElement<int32, 16>, MAX_PHYSICS_FIELD_TARGETS> BoundsOffsets;
 
    float TimeSeconds;
 
    bool bBuildClipmap;
 
    bool bShowFields;
};
 
class FPhysicsFieldResource : public FRenderResource
{
public:
 
    FRWBuffer ClipmapBuffer;
 
    FRWBuffer NodesParams;
 
    FRWBuffer NodesOffsets;
 
    FRWBuffer TargetsOffsets;
 
    FRWBuffer CellsOffsets;
 
    FRWBuffer CellsMin;
 
    FRWBuffer CellsMax;
 
    FRWBuffer BoundsMin;
 
    FRWBuffer BoundsMax;
 
    FPhysicsFieldInfos FieldInfos;
 
    FPhysicsFieldResource(const int32 TargetCount, const TArray<EFieldPhysicsType>& TargetTypes,
        const FPhysicsFieldInfos::BufferOffsets& VectorTargets, const FPhysicsFieldInfos::BufferOffsets& ScalarTargets,
        const FPhysicsFieldInfos::BufferOffsets& IntegerTargets, const FPhysicsFieldInfos::BufferOffsets& PhysicsTargets,
        const TStaticArray<UE::Core::TAlignedElement<FIntVector4, 16>, MAX_PHYSICS_FIELD_TARGETS>& PhysicsBounds, const bool bBuildClipmap);
 
    virtual void ReleaseRHI() override;
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
 
    void UpdateResource(FRHICommandList& RHICmdList,
        const TStaticArray<int32, EFieldPhysicsType::Field_PhysicsType_Max + 1>& TargetsOffsetsDatas, const TArray<int32>& NodesOffsetsDatas, const TArray<float>& NodesParamsDatas,
        const TArray<FVector>& TargetsMinDatas, const TArray<FVector>& TargetsMaxDatas, const float TimeSeconds, 
        const TArray<FVector4>& BoundsMinDatas, const TArray<FVector4>& BoundsMaxDatas, const TStaticArray<int32, EFieldPhysicsType::Field_PhysicsType_Max + 1>& BoundsOffsetsDatas);
 
    void UpdateBounds(const TArray<FVector>& TargetsMin, const TArray<FVector>& TargetsMax, const TStaticArray<int32, EFieldPhysicsType::Field_PhysicsType_Max + 1>& TargetOffsets,
                      const TStaticArray<int32, EFieldPhysicsType::Field_PhysicsType_Max + 1>& BoundsOffsets);
};
 
 
class FPhysicsFieldInstance
{
public:
 
    FPhysicsFieldInstance()
        : FieldResource(nullptr)
    {}
 
    ~FPhysicsFieldInstance() {}
 
    void InitInstance(const TArray<EFieldPhysicsType>& TargetTypes, const bool bBuildClipmap);
 
    void ReleaseInstance();
 
    void UpdateInstance(const float TimeSeconds, const bool bIsDebugBuffer);
 
    FPhysicsFieldResource* FieldResource = nullptr;
 
    TStaticArray<int32, EFieldPhysicsType::Field_PhysicsType_Max + 1> TargetsOffsets;
    
    TStaticArray<int32, EFieldPhysicsType::Field_PhysicsType_Max + 1> BoundsOffsets;
 
    TArray<int32> NodesOffsets;
 
    TArray<float> NodesParams;
 
    TArray<FVector4> BoundsMin;
 
    TArray<FVector4> BoundsMax;
 
    TArray<FFieldSystemCommand> FieldCommands;
 
    TArray<FVector> TargetsMin;
 
    TArray<FVector> TargetsMax;
};
 
UCLASS(meta = (BlueprintSpawnableComponent), MinimalAPI)
class UPhysicsFieldComponent : public USceneComponent
{
    GENERATED_BODY()
 
public:
 
    ENGINE_API UPhysicsFieldComponent();
 
    //~ Begin UActorComponent Interface.
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
    ENGINE_API virtual void SendRenderDynamicData_Concurrent() override;
    ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
    ENGINE_API virtual void DestroyRenderState_Concurrent() override;
    //~ End UActorComponent Interface.
 
    ENGINE_API void AddTransientCommand(const FFieldSystemCommand& FieldCommand, const bool bIsGPUField);
 
    ENGINE_API void AddPersistentCommand(const FFieldSystemCommand& FieldCommand, const bool bIsGPUField);
 
    ENGINE_API void AddConstructionCommand(const FFieldSystemCommand& FieldCommand);
 
    ENGINE_API void RemoveTransientCommand(const FFieldSystemCommand& FieldCommand, const bool bIsGPUField);
 
    ENGINE_API void RemovePersistentCommand(const FFieldSystemCommand& FieldCommand, const bool bIsGPUField);
 
    ENGINE_API void FillTransientCommands(const bool bIsWorldField, const FBox& BoundingBox, const float TimeSeconds, TArray<FFieldSystemCommand>& OutputCommands) const;
 
    ENGINE_API void FillPersistentCommands(const bool bIsWorldField, const FBox& BoundingBox, const float TimeSeconds, TArray<FFieldSystemCommand>& OutputCommands) const;
 
    static ENGINE_API void BuildCommandBounds(FFieldSystemCommand& FieldCommand);
 
    // These types are not static since we probably want in the future to be able to pick the vector/scalar/integer fields we are interested in
 
    TArray<FFieldSystemCommand> TransientCommands[(uint8)(EFieldCommandBuffer::NumFieldBuffers)];
 
    TArray<FFieldSystemCommand> PersistentCommands[(uint8)(EFieldCommandBuffer::NumFieldBuffers)];
 
    TArray<FFieldSystemCommand> ConstructionCommands[(uint8)(EFieldCommandBuffer::NumFieldBuffers)];
 
    FPhysicsFieldInstance* FieldInstance = nullptr;
 
    FPhysicsFieldInstance* DebugInstance = nullptr;
 
    class FPhysicsFieldSceneProxy* FieldProxy = nullptr;
};
 
void ENGINE_API GetFieldIndex(const uint32 FieldType, int32& FieldIndex, EFieldOutputType& FieldOutput);
 
//class FPhysicsFieldSceneProxy final : public FPrimitiveSceneProxy
class FPhysicsFieldSceneProxy 
{
public:
    //SIZE_T GetTypeHash() const override;
 
    explicit FPhysicsFieldSceneProxy(class UPhysicsFieldComponent* PhysicsFieldComponent);
 
    ~FPhysicsFieldSceneProxy();
 
    FPhysicsFieldResource* FieldResource = nullptr;
 
    FPhysicsFieldResource* DebugResource = nullptr;
};
 
UCLASS(MinimalAPI)
class UPhysicsFieldStatics : public UBlueprintFunctionLibrary
{
    GENERATED_UCLASS_BODY()
    
public:
    
    UFUNCTION(BlueprintCallable, Category="Field", meta=(WorldContext="WorldContextObject"))
    static ENGINE_API FVector EvalPhysicsVectorField(const UObject* WorldContextObject, const FVector& WorldPosition, const EFieldVectorType VectorType);
 
    UFUNCTION(BlueprintCallable, Category="Field", meta=(WorldContext="WorldContextObject"))
    static ENGINE_API float EvalPhysicsScalarField(const UObject* WorldContextObject, const FVector& WorldPosition, const EFieldScalarType ScalarType);
 
    UFUNCTION(BlueprintCallable, Category="Field", meta=(WorldContext="WorldContextObject"))
    static ENGINE_API int32 EvalPhysicsIntegerField(const UObject* WorldContextObject, const FVector& WorldPosition, const EFieldIntegerType IntegerType);
};
 
void ENGINE_API EvaluateFieldVectorNodes(TArray<FFieldSystemCommand>& FieldCommands, const EFieldPhysicsType FieldType, FFieldContext& FieldContext, 
    TArray<FVector>& ResultsArray, TArray<FVector>& MaxArray);
 
void ENGINE_API EvaluateFieldScalarNodes(TArray<FFieldSystemCommand>& FieldCommands, const EFieldPhysicsType FieldType, FFieldContext& FieldContext, 
    TArray<float>& ResultsArray, TArray<float>& MaxArray);
 
void ENGINE_API EvaluateFieldIntegerNodes(TArray<FFieldSystemCommand>& FieldCommands, const EFieldPhysicsType FieldType, FFieldContext& FieldContext, 
    TArray<int32>& ResultsArray, TArray<int32>& MaxArray);