FieldSystemObjects.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Queue.h"
#include "Field/FieldSystemTypes.h"
#include "Field/FieldSystem.h"
#include "Field/FieldSystemNodes.h"
#include "Math/Vector.h"
#include "Components/PrimitiveComponent.h"
#include "PhysicsField/PhysicsFieldComponent.h"
 
#include "FieldSystemObjects.generated.h"
 
UCLASS(MinimalAPI)
class UFieldSystemMetaData : public UActorComponent
{
    GENERATED_BODY()
 
public:
    virtual ~UFieldSystemMetaData() {}
    virtual FFieldSystemMetaData::EMetaType Type() const { return FFieldSystemMetaData::EMetaType::ECommandData_None; }
    virtual FFieldSystemMetaData* NewMetaData() const { return nullptr; }
};
 
/*
* UFieldSystemMetaDataIteration : Not used anymore, just hiding it right now but will probably be deprecated if not used in the future
*/
UCLASS(MinimalAPI)
class UFieldSystemMetaDataIteration : public UFieldSystemMetaData
{
    GENERATED_BODY()
 
public:
    virtual ~UFieldSystemMetaDataIteration() {}
    virtual FFieldSystemMetaData::EMetaType Type() const override { return  FFieldSystemMetaData::EMetaType::ECommandData_Iteration; }
 
    FIELDSYSTEMENGINE_API virtual FFieldSystemMetaData* NewMetaData() const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Iterations = "1"))
    FIELDSYSTEMENGINE_API UFieldSystemMetaDataIteration* SetMetaDataIteration(UPARAM(DisplayName = "Iteration Count") int Iterations);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Iteration Count")
    int Iterations;
};
 
/*
* UFieldSystemMetaDataProcessingResolution
*/
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Control the set of particles on which the field will be applied"), ShowCategories = ("Field"), DisplayName = "MetaDataResolution", MinimalAPI)
class UFieldSystemMetaDataProcessingResolution : public UFieldSystemMetaData
{
    GENERATED_BODY()
 
public:
    virtual ~UFieldSystemMetaDataProcessingResolution() {}
    virtual FFieldSystemMetaData::EMetaType Type() const override { return  FFieldSystemMetaData::EMetaType::ECommandData_ProcessingResolution; }
    FIELDSYSTEMENGINE_API virtual FFieldSystemMetaData* NewMetaData() const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", DisplayName = "Set Meta Data Resolution")
    FIELDSYSTEMENGINE_API UFieldSystemMetaDataProcessingResolution* SetMetaDataaProcessingResolutionType(EFieldResolutionType ResolutionType);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Field")
    TEnumAsByte<EFieldResolutionType> ResolutionType;
};
 
/*
* UFieldSystemMetaDataFilter
*/
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Filter the particles on which the field will be applied"), ShowCategories = ("Field"), DisplayName = "MetaDataFilter", MinimalAPI)
class UFieldSystemMetaDataFilter : public UFieldSystemMetaData
{
    GENERATED_BODY()
 
public:
    virtual ~UFieldSystemMetaDataFilter() {}
    virtual FFieldSystemMetaData::EMetaType Type() const override { return  FFieldSystemMetaData::EMetaType::ECommandData_Filter; }
    FIELDSYSTEMENGINE_API virtual FFieldSystemMetaData* NewMetaData() const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", DisplayName = "Set Meta Data Filter")
    FIELDSYSTEMENGINE_API UFieldSystemMetaDataFilter* SetMetaDataFilterType(UPARAM(DisplayName = "State Type") EFieldFilterType FilterType, 
                                                      UPARAM(DisplayName = "Object Type") EFieldObjectType ObjectType,
                                                      UPARAM(DisplayName = "Position Type") EFieldPositionType PositionType );
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Field", DisplayName = "State Type")
    TEnumAsByte<EFieldFilterType> FilterType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Field", DisplayName = "Object Type")
    TEnumAsByte<EFieldObjectType> ObjectType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Field", DisplayName = "Position Type")
    TEnumAsByte<EFieldPositionType> PositionType;
};
 
UCLASS(MinimalAPI)
class UFieldNodeBase : public UActorComponent
{
    GENERATED_BODY()
 
public:
    virtual ~UFieldNodeBase() {}
    virtual FFieldNodeBase::EFieldType Type() const { return FFieldNodeBase::EFieldType::EField_None; }
    virtual bool ResultsExpector() const { return false; }
    virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const { return nullptr; }
};
 
 
UCLASS(MinimalAPI)
class UFieldNodeInt : public UFieldNodeBase
{
    GENERATED_BODY()
 
public:
    virtual ~UFieldNodeInt() {}
    virtual FFieldNodeBase::EFieldType Type() const override { return  FFieldNodeBase::EFieldType::EField_Int32; }
};
 
UCLASS(MinimalAPI)
class UFieldNodeFloat : public UFieldNodeBase
{
    GENERATED_BODY()
 
public:
    virtual ~UFieldNodeFloat() {}
    virtual FFieldNodeBase::EFieldType Type() const override { return  FFieldNodeBase::EFieldType::EField_Float; }
};
 
UCLASS(MinimalAPI)
class UFieldNodeVector : public UFieldNodeBase
{
    GENERATED_BODY()
public:
    virtual ~UFieldNodeVector() {}
    virtual FFieldNodeBase::EFieldType Type() const override { return  FFieldNodeBase::EFieldType::EField_FVector; }
};
 
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Set a uniform integer value independently of the sample position. The output is equal to magnitude"), ShowCategories = ("Field"), MinimalAPI)
class UUniformInteger : public UFieldNodeInt
{
    GENERATED_BODY()
public:
 
    UUniformInteger()
        : Super()
        , Magnitude(0)
    {}
 
    virtual ~UUniformInteger() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "0"))
    FIELDSYSTEMENGINE_API UUniformInteger* SetUniformInteger(UPARAM(DisplayName = "Field Magnitude") int32 Magnitude);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    int32 Magnitude;
};
 
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "This function first defines a radial integer field equal to Interior-value inside a sphere / Exterior-value outside. This field will be used alongside the particle input value and the mask condition to compute the particle output value."), ShowCategories = ("Field"), MinimalAPI)
class URadialIntMask : public UFieldNodeInt
{
    GENERATED_BODY()
public:
 
    URadialIntMask()
        : Super()
        , Radius(0)
        , Position(FVector(0, 0, 0))
        , InteriorValue(1)
        , ExteriorValue(0)
        , SetMaskCondition(ESetMaskConditionType::Field_Set_Always)
    {}
    virtual ~URadialIntMask() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (InteriorValue = "1"), DisplayName = "Set Radial Mask")
    FIELDSYSTEMENGINE_API URadialIntMask* SetRadialIntMask(UPARAM(DisplayName = "Mask Radius") float Radius,
            UPARAM(DisplayName = "Center Position") FVector Position,
            UPARAM(DisplayName = "Interior Value") int32 InteriorValue,
            UPARAM(DisplayName = "Exterior Value") int32 ExteriorValue,
            UPARAM(DisplayName = "Mask Condition") ESetMaskConditionType SetMaskConditionIn);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Mask Radius")
    float Radius;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Center Position")
    FVector Position;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Interior Value")
    int32 InteriorValue;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Exterior Value")
    int32 ExteriorValue;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Mask Condition")
    TEnumAsByte<ESetMaskConditionType> SetMaskCondition;
};
 
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Set a uniform scalar value independently of the sample position. The output is equal to magnitude"), ShowCategories = ("Field"), MinimalAPI)
class UUniformScalar : public UFieldNodeFloat
{
    GENERATED_BODY()
public:
 
    UUniformScalar()
        : Super()
        , Magnitude(1.0)
    {}
 
    virtual ~UUniformScalar() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0"))
    FIELDSYSTEMENGINE_API UUniformScalar* SetUniformScalar(UPARAM(DisplayName = "Field Magnitude") float Magnitude);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
 
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Set a temporal wave scalar value according to the sample distance from the field position."), ShowCategories = ("Field"), MinimalAPI)
class UWaveScalar : public UFieldNodeFloat
{
    GENERATED_BODY()
public:
 
    UWaveScalar()
        : Super()
        , Magnitude(1.0)
        , Position(0, 0, 0)
        , Wavelength(10000)
        , Period(1.0)
        , Function(EWaveFunctionType::Field_Wave_Cosine)
        , Falloff(EFieldFalloffType::Field_Falloff_Linear)
    {}
 
    virtual ~UWaveScalar() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0", Wavelength = "1000", Period = "1", HidePin = "Time"), DisplayName = "Set Wave Scalar")
    FIELDSYSTEMENGINE_API UWaveScalar* SetWaveScalar(UPARAM(DisplayName = "Field Magnitude") float Magnitude,
            UPARAM(DisplayName = "Center Position") FVector Position,
            UPARAM(DisplayName = "Wave Length") float Wavelength,
            UPARAM(DisplayName = "Wave Period") float Period,
            UPARAM(DisplayName = "Time Offset") float Time,
            UPARAM(DisplayName = "Wave Function") EWaveFunctionType Function,
            UPARAM(DisplayName = "Falloff Type") EFieldFalloffType Falloff);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Center Position")
    FVector Position;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Wave Length")
    float Wavelength;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Wave Period")
    float Period;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Wave Function")
    TEnumAsByte<EWaveFunctionType> Function;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Falloff Type")
    TEnumAsByte<EFieldFalloffType> Falloff;
};
 
 
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Sphere scalar field that will be defined only within a sphere"), ShowCategories = ("Field"), MinimalAPI)
class URadialFalloff : public UFieldNodeFloat
{
    GENERATED_BODY()
public:
 
    URadialFalloff()
        : Super()
        , Magnitude(1.0)
        , MinRange(0.f)
        , MaxRange(1.f)
        , Default(0.f)
        , Radius(0)
        , Position(FVector(0, 0, 0))
        , Falloff(EFieldFalloffType::Field_Falloff_Linear)
    {}
 
    virtual ~URadialFalloff() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0", MinRange = "0.0", MaxRange = "1.0"), DisplayName = "Set Radial Falloff")
    FIELDSYSTEMENGINE_API URadialFalloff* SetRadialFalloff(UPARAM(DisplayName = "Field Magnitude") float Magnitude,
            UPARAM(DisplayName = "Min Range") float MinRange,
            UPARAM(DisplayName = "Max Range") float MaxRange,
            UPARAM(DisplayName = "Default Value") float Default,
            UPARAM(DisplayName = "Sphere Radius") float Radius,
            UPARAM(DisplayName = "Center Position") FVector Position,
            UPARAM(DisplayName = "Falloff Type") EFieldFalloffType Falloff);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Min Range")
    float MinRange;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Max Range")
    float MaxRange;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Default Value")
    float Default;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Sphere Radius")
    float Radius;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Center Position")
    FVector Position;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Falloff Type")
    TEnumAsByte<EFieldFalloffType> Falloff;
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Plane scalar field that will be defined only within a distance from a plane"), ShowCategories = ("Field"), MinimalAPI)
class UPlaneFalloff : public UFieldNodeFloat
{
    GENERATED_BODY()
 
public:
 
    UPlaneFalloff()
        : Super()
        , Magnitude(1.0)
        , MinRange(0.f)
        , MaxRange(1.f)
        , Default(0.f)
        , Distance(0.f)
        , Position(FVector(0, 0, 0))
        , Normal(FVector(0, 0, 1))
        , Falloff(EFieldFalloffType::Field_Falloff_Linear)
    {}
 
    virtual ~UPlaneFalloff() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0", MinRange = "0.0", MaxRange = "1.0"))
    FIELDSYSTEMENGINE_API UPlaneFalloff* SetPlaneFalloff(UPARAM(DisplayName = "Field Magnitude") float Magnitude,
            UPARAM(DisplayName = "Min Range") float MinRange,
            UPARAM(DisplayName = "Max Range") float MaxRange,
            UPARAM(DisplayName = "Default Value") float Default,
            UPARAM(DisplayName = "Plane Distance") float Distance,
            UPARAM(DisplayName = "Center Position") FVector Position,
            UPARAM(DisplayName = "Plane Normal") FVector Normal,
            UPARAM(DisplayName = "Falloff Type") EFieldFalloffType Falloff);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Min Range")
    float MinRange;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Max Range")
    float MaxRange;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Default Value")
    float Default;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Plane Distance")
    float Distance;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Center Position")
    FVector Position;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Plane Normal")
    FVector Normal;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Falloff Type")
    TEnumAsByte<EFieldFalloffType> Falloff;
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Box scalar field that will be defined only within a box"), ShowCategories = ("Field"), MinimalAPI)
class UBoxFalloff : public UFieldNodeFloat
{
    GENERATED_BODY()
 
public:
 
    UBoxFalloff()
        : Super()
        , Magnitude(1.0)
        , MinRange(0.f)
        , MaxRange(1.f)
        , Default(0.0)
        , Transform(FTransform::Identity)
        , Falloff(EFieldFalloffType::Field_Falloff_Linear)
    {}
 
    virtual ~UBoxFalloff() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0", MinRange = "0.0", MaxRange = "1.0"))
    FIELDSYSTEMENGINE_API UBoxFalloff* SetBoxFalloff(UPARAM(DisplayName = "Field Magnitude")  float Magnitude,
            UPARAM(DisplayName = "Min Range")  float MinRange,
            UPARAM(DisplayName = "Max Range")  float MaxRange,
            UPARAM(DisplayName = "Default Value")  float Default,
            UPARAM(DisplayName = "Box Transform")  FTransform Transform,
            UPARAM(DisplayName = "Falloff Type")  EFieldFalloffType Falloff);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Min Range")
    float MinRange;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Max Range")
    float MaxRange;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Default Value")
    float Default;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Box Transform")
    FTransform Transform;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Falloff Type")
    TEnumAsByte<EFieldFalloffType> Falloff;
};
 
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Defines a perlin noise scalar value if the sample is within a box"), ShowCategories = ("Field"), MinimalAPI)
class UNoiseField : public UFieldNodeFloat
{
    GENERATED_BODY()
 
public:
 
    UNoiseField()
        : Super()
        , MinRange(0.f)
        , MaxRange(1.f)
        , Transform()
    {}
 
    virtual ~UNoiseField() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (MinRange = "0.0", MaxRange = "1.0"), DisplayName = "Set Noise Field")
    FIELDSYSTEMENGINE_API UNoiseField* SetNoiseField(UPARAM(DisplayName = "Min Range") float MinRange,
            UPARAM(DisplayName = "Max Range") float MaxRange,
            UPARAM(DisplayName = "Noise Transform")  FTransform Transform);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Min Range")
    float MinRange;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Max Range")
    float MaxRange;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Noise Transform")
    FTransform Transform;
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Set a uniform vector value independently of the sample position.The output is equal to magnitude * direction"), ShowCategories = ("Field"), MinimalAPI)
class UUniformVector : public UFieldNodeVector
{
    GENERATED_BODY()
public:
 
    UUniformVector()
        : Super()
        , Magnitude(1.0)
        , Direction(FVector(0, 0, 0))
    {}
 
    virtual ~UUniformVector() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0"))
    FIELDSYSTEMENGINE_API UUniformVector* SetUniformVector(UPARAM(DisplayName = "Field Magnitude") float Magnitude,
            UPARAM(DisplayName = "Uniform Direction") FVector Direction);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Uniform Direction")
    FVector Direction;
};
 
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Set a radial vector value, the direction being the vector from the sample position to the field one. The output is equal to magnitude * direction"), ShowCategories = ("Field"), MinimalAPI)
class URadialVector : public UFieldNodeVector
{
    GENERATED_BODY()
public:
 
    URadialVector()
        : Super()
        , Magnitude(1.0)
        , Position(FVector(0, 0, 0))
    {}
 
    virtual ~URadialVector() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0"))
    FIELDSYSTEMENGINE_API URadialVector* SetRadialVector(UPARAM(DisplayName = "Field Magnitude") float Magnitude,
                                   UPARAM(DisplayName = "Center Position") FVector Position);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Center Position")
    FVector Position;
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Set a random vector value independently of the sample position. The output is equal to magnitude * random direction "), ShowCategories = ("Field"), MinimalAPI)
class URandomVector : public UFieldNodeVector
{
    GENERATED_BODY()
public:
 
    URandomVector()
        : Super()
        , Magnitude(1.0)
    {}
 
    virtual ~URandomVector() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0"))
    FIELDSYSTEMENGINE_API URandomVector* SetRandomVector(UPARAM(DisplayName = "Field Magnitude") float Magnitude);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
};
 
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Compute an operation between 2 incoming fields"), ShowCategories = ("Field"), MinimalAPI)
class UOperatorField : public UFieldNodeBase
{
    GENERATED_BODY()
public:
 
    UOperatorField()
        : Super()
        , Magnitude(1.0)
        , RightField(nullptr)
        , LeftField(nullptr)
        , Operation(EFieldOperationType::Field_Multiply)
    {}
 
    virtual ~UOperatorField() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase::EFieldType Type() const;
    virtual bool ResultsExpector() const override { return true; }
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", meta = (Magnitude = "1.0"))
    FIELDSYSTEMENGINE_API UOperatorField* SetOperatorField(UPARAM(DisplayName = "Field Magnitude") float Magnitude,
            UPARAM(DisplayName = "Left Field") const UFieldNodeBase* LeftField,
            UPARAM(DisplayName = "Right Field") const UFieldNodeBase* RightField,
            UPARAM(DisplayName = "Field Operation") EFieldOperationType Operation);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Magnitude")
    float Magnitude;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Right Field")
    TObjectPtr<const UFieldNodeBase> RightField;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Left Field")
    TObjectPtr<const UFieldNodeBase> LeftField;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Field Operation")
    TEnumAsByte<EFieldOperationType> Operation;
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Convert a scalar field to a integer one"), ShowCategories = ("Field"), MinimalAPI)
class UToIntegerField : public UFieldNodeInt
{
    GENERATED_BODY()
public:
 
    UToIntegerField()
        : Super()
        , FloatField(nullptr)
    {}
 
    virtual ~UToIntegerField() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", DisplayName = "Set To Integer Field")
    FIELDSYSTEMENGINE_API UToIntegerField* SetToIntegerField(UPARAM(DisplayName = "Float Field") const UFieldNodeFloat* FloatField);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Float Field")
    TObjectPtr<const UFieldNodeFloat> FloatField;
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Convert an integer field to a scalar one"), ShowCategories = ("Field"), MinimalAPI)
class UToFloatField : public UFieldNodeFloat
{
    GENERATED_BODY()
public:
 
    UToFloatField()
        : Super()
        , IntField(nullptr)
    {}
 
    virtual ~UToFloatField() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    UFUNCTION(BlueprintPure, Category = "Field", DisplayName = "Set To Float Field")
    FIELDSYSTEMENGINE_API UToFloatField* SetToFloatField(UPARAM(DisplayName = "Integer Field") const UFieldNodeInt* IntegerField);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Integer Field")
    TObjectPtr<const UFieldNodeInt> IntField;
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Evaluate the input field according to the result of the culling field"), ShowCategories = ("Field"), MinimalAPI)
class UCullingField : public UFieldNodeBase
{
    GENERATED_BODY()
public:
 
    UCullingField()
        : Super()
        , Culling(nullptr)
        , Field(nullptr)
        , Operation(EFieldCullingOperationType::Field_Culling_Inside)
    {}
 
    virtual ~UCullingField() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase::EFieldType Type() const override;
 
    UFUNCTION(BlueprintPure, Category = "Field")
    FIELDSYSTEMENGINE_API UCullingField* SetCullingField(UPARAM(DisplayName = "Culling Field") const UFieldNodeBase* Culling,
            UPARAM(DisplayName = "Input Field") const UFieldNodeBase* Field,
            UPARAM(DisplayName = "Culling Operation") EFieldCullingOperationType Operation);
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Culling Field")
    TObjectPtr<const UFieldNodeBase> Culling;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Input Field")
    TObjectPtr<const UFieldNodeBase> Field;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Culling Operation")
    TEnumAsByte<EFieldCullingOperationType> Operation;
};
 
UCLASS(ClassGroup = "Field", meta = (BlueprintSpawnableComponent, ToolTip = "Terminal field of a graph"), ShowCategories = ("Field"), MinimalAPI)
class UReturnResultsTerminal : public UFieldNodeBase
{
    GENERATED_BODY()
public:
 
    UReturnResultsTerminal() : Super()
    {}
 
    virtual ~UReturnResultsTerminal() {}
 
    FIELDSYSTEMENGINE_API virtual FFieldNodeBase* NewEvaluationGraph(TArray<const UFieldNodeBase*>& Nodes) const override;
    virtual FFieldNodeBase::EFieldType Type() const override { return  FFieldNodeBase::EFieldType::EField_Results; }
 
    UFUNCTION(BlueprintPure, Category = "Field", DisplayName = "Set Terminal Field")
    FIELDSYSTEMENGINE_API UReturnResultsTerminal* SetReturnResultsTerminal();
 
};
 
USTRUCT(BlueprintType)
struct FFieldObjectCommands
{
    GENERATED_BODY()
 
        FFieldObjectCommands()
        : TargetNames()
        , RootNodes()
        , MetaDatas()
    {}
 
    ~FFieldObjectCommands() {}
 
    void AddFieldCommand(const FName& TargetName, UFieldNodeBase* RootNode, UFieldSystemMetaData* MetaData)
    {
        TargetNames.Add(TargetName);
        RootNodes.Add(RootNode);
        MetaDatas.Add(MetaData);
    }
 
    void ResetFieldCommands()
    {
        TargetNames.Reset();
        RootNodes.Reset();
        MetaDatas.Reset();
    }
 
    int32 GetNumCommands() const
    {
        return TargetNames.Num();
    }
 
    static FFieldSystemCommand CreateFieldCommand(const EFieldPhysicsType PhysicsType, UFieldNodeBase* RootNode, UFieldSystemMetaData* MetaData)
    {
        if (RootNode)
        {
            TArray<const UFieldNodeBase*> Nodes;
            FFieldSystemCommand Command = { PhysicsType, RootNode->NewEvaluationGraph(Nodes) };
            if (ensureMsgf(Command.RootNode,
                TEXT("Failed to generate physics field command for target attribute.")))
            {
                if (MetaData)
                {
                    switch (MetaData->Type())
                    {
                    case FFieldSystemMetaData::EMetaType::ECommandData_ProcessingResolution:
                        Command.MetaData.Add(FFieldSystemMetaData::EMetaType::ECommandData_ProcessingResolution).Reset(new FFieldSystemMetaDataProcessingResolution(static_cast<UFieldSystemMetaDataProcessingResolution*>(MetaData)->ResolutionType));
                        break;
                    case FFieldSystemMetaData::EMetaType::ECommandData_Iteration:
                        Command.MetaData.Add(FFieldSystemMetaData::EMetaType::ECommandData_Iteration).Reset(new FFieldSystemMetaDataIteration(static_cast<UFieldSystemMetaDataIteration*>(MetaData)->Iterations));
                        break;
                    case FFieldSystemMetaData::EMetaType::ECommandData_Filter:
                        Command.MetaData.Add(FFieldSystemMetaData::EMetaType::ECommandData_Filter).Reset(new FFieldSystemMetaDataFilter(static_cast<UFieldSystemMetaDataFilter*>(MetaData)->FilterType, 
                            static_cast<UFieldSystemMetaDataFilter*>(MetaData)->ObjectType, static_cast<UFieldSystemMetaDataFilter*>(MetaData)->PositionType));
                        break;
                    }
                }
                ensure(Command.PhysicsType != EFieldPhysicsType::Field_None);
            }
            UPhysicsFieldComponent::BuildCommandBounds(Command);
            return Command;
        }
        else
        {
            return FFieldSystemCommand();
        }
    }
 
    static FFieldSystemCommand CreateFieldCommand(const EFieldPhysicsType PhysicsType, FFieldNodeBase* RootNode)
    {
        if (RootNode)
        {
            FFieldSystemCommand Command = { PhysicsType, RootNode };
            ensure(Command.PhysicsType != EFieldPhysicsType::Field_None);
            UPhysicsFieldComponent::BuildCommandBounds(Command);
            return Command;
        }
        else
        {
            return FFieldSystemCommand();
        }
    }
 
    FFieldSystemCommand BuildFieldCommand(const int32 CommandIndex) const
    {
        return (CommandIndex < GetNumCommands()) ? CreateFieldCommand(GetFieldPhysicsType(TargetNames[CommandIndex]), RootNodes[CommandIndex], MetaDatas[CommandIndex]) : FFieldSystemCommand();
    }
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Target Names")
    TArray<FName> TargetNames;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Root Nodes")
    TArray<TObjectPtr<UFieldNodeBase>> RootNodes;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Field", DisplayName = "Meta Datas")
    TArray<TObjectPtr<UFieldSystemMetaData>> MetaDatas;
};