FieldSystemNodes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Field/FieldSystem.h"
#include "Math/Vector.h"
#include "Chaos/Box.h"
 
class FUniformInteger : public FFieldNode<int32>
{
    typedef FFieldNode<int32> Super;
 
public:
 
    FUniformInteger(int32 MagnitudeIn = 0)
        : Super()
        , Magnitude(MagnitudeIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FUniformInteger(Magnitude); }
    virtual ~FUniformInteger() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<int32>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FUniformInteger; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    int32 Magnitude;
};
 
 
class FRadialIntMask : public FFieldNode<int32>
{
    typedef FFieldNode<int32> Super;
 
public:
 
    FRadialIntMask(float RadiusIn = 0, 
        FVector PositionIn = FVector(0, 0, 0), 
        int32 InteriorValueIn = 1.0, 
        int32 ExteriorValueIn = 0, 
        ESetMaskConditionType SetMaskConditionIn = ESetMaskConditionType::Field_Set_Always)
        : Super()
        , Radius(RadiusIn)
        , Position(PositionIn)
        , InteriorValue(InteriorValueIn)
        , ExteriorValue(ExteriorValueIn)
        , SetMaskCondition(SetMaskConditionIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FRadialIntMask(Radius,Position,InteriorValue,ExteriorValue,SetMaskCondition); }
    virtual ~FRadialIntMask() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<int32>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FRadialIntMask; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    float Radius;
    FVector Position;
    int32 InteriorValue;
    int32 ExteriorValue;
    ESetMaskConditionType SetMaskCondition;
};
 
 
class FUniformScalar : public FFieldNode<float>
{
    typedef FFieldNode<float> Super;
 
public:
 
    FUniformScalar(float MagnitudeIn = 1.f)
        : Super()
        , Magnitude(MagnitudeIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FUniformScalar(Magnitude); }
 
    virtual ~FUniformScalar() {}
 
    CHAOS_API void Evaluate(FFieldContext&, TFieldArrayView<float>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node);
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FUniformScalar; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    float Magnitude;
};
 
class FWaveScalar : public FFieldNode<float>
{
    typedef FFieldNode<float> Super;
 
public:
 
    FWaveScalar(float MagnitudeIn = 1.f, const FVector& PositionIn = FVector(0,0,0), const float WavelengthIn = 1000, const float PeriodIn = 1.0, 
        const EWaveFunctionType FunctionIn = EWaveFunctionType::Field_Wave_Cosine, const EFieldFalloffType FallofffIn = EFieldFalloffType::Field_Falloff_Linear)
        : Super()
        , Magnitude(MagnitudeIn)
        , Position(PositionIn)
        , Wavelength(WavelengthIn)
        , Period(PeriodIn)
        , Function(FunctionIn)
        , Falloff(FallofffIn)
    {}
    virtual FFieldNodeBase* NewCopy() const override { return new FWaveScalar(Magnitude, Position, Wavelength, Period, Function, Falloff); }
 
    virtual ~FWaveScalar() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<float>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FWaveScalar; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    float Magnitude;
    FVector Position;
    float Wavelength;
    float Period;
    EWaveFunctionType Function;
    EFieldFalloffType Falloff;
};
 
class FRadialFalloff : public FFieldNode<float>
{
    typedef FFieldNode<float> Super;
 
public:
 
    FRadialFalloff( 
        float MagnitudeIn = 1.f,
        float MinRangeIn = 0.f,
        float MaxRangeIn = 1.f,
        float DefaultIn = 0.f,
        float RadiusIn = 0.f,
        FVector PositionIn = FVector(0, 0, 0),
        EFieldFalloffType FalloffIn = EFieldFalloffType::Field_Falloff_Linear)
        : Super()
        , Magnitude(MagnitudeIn)
        , MinRange(MinRangeIn)
        , MaxRange(MaxRangeIn)
        , Default(DefaultIn)
        , Radius(RadiusIn)
        , Position(PositionIn)
        , Falloff(FalloffIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FRadialFalloff(Magnitude,MinRange,MaxRange,Default,Radius,Position,Falloff); }
 
    virtual ~FRadialFalloff() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<float>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FRadialFalloff; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    float Magnitude;
    float MinRange;
    float MaxRange;
    float Default;
    float Radius;
    FVector Position;
    EFieldFalloffType Falloff;
 
protected:
    template<EFieldFalloffType> void Evaluator(const FFieldContext& Context, TFieldArrayView<float>& Results) const;
};
 
 
class FPlaneFalloff : public FFieldNode<float>
{
    typedef FFieldNode<float> Super;
 
public:
 
    FPlaneFalloff(
        float MagnitudeIn = 1.f,
        float MinRangeIn = 0.f,
        float MaxRangeIn = 1.f,
        float DefaultIn = 0.f,
        float DistanceIn = 0.f,
        FVector PositionIn = FVector(0, 0, 0),
        FVector NormalIn = FVector(0, 0, 1),
        EFieldFalloffType FalloffIn = EFieldFalloffType::Field_Falloff_Linear)
 
        : Super()
        , Magnitude(MagnitudeIn)
        , MinRange(MinRangeIn)
        , MaxRange(MaxRangeIn)
        , Default(DefaultIn)
        , Distance(DistanceIn)
        , Position(PositionIn)
        , Normal(NormalIn)
        , Falloff(FalloffIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FPlaneFalloff(Magnitude, MinRange, MaxRange, Default, Distance, Position, Normal, Falloff); }
    virtual ~FPlaneFalloff() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<float>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FPlaneFalloff; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
 
    float Magnitude;
    float MinRange;
    float MaxRange;
    float Default;
    float Distance;
    FVector Position;
    FVector Normal;
    EFieldFalloffType Falloff;
 
protected :
    template<EFieldFalloffType> void Evaluator(const FFieldContext& Context, const FPlane& Plane, TFieldArrayView<float>& Results) const;
 
};
 
class FBoxFalloff : public FFieldNode<float>
{
    typedef FFieldNode<float> Super;
 
public:
 
    FBoxFalloff(
        float MagnitudeIn = 1.f,
        float MinRangeIn = 0.f,
        float MaxRangeIn = 1.f,
        float DefaultIn = 0.f,
        FTransform TransformIn = FTransform::Identity,
        EFieldFalloffType FalloffIn = EFieldFalloffType::Field_Falloff_Linear)
 
        : Super()
        , Magnitude(MagnitudeIn)
        , MinRange(MinRangeIn)
        , MaxRange(MaxRangeIn)
        , Default(DefaultIn)
        , Transform(TransformIn)
        , Falloff(FalloffIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FBoxFalloff(Magnitude, MinRange, MaxRange, Default, Transform, Falloff); }
    virtual ~FBoxFalloff() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<float>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FBoxFalloff; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    float Magnitude;
    float MinRange;
    float MaxRange;
    float Default;
    FTransform Transform;
    EFieldFalloffType Falloff;
 
protected:
    template<EFieldFalloffType> void Evaluator(const FFieldContext& Context, TFieldArrayView<float>& Results) const;
 
};
 
 
class FNoiseField : public FFieldNode<float>
{
    typedef FFieldNode<float> Super;
 
public:
 
    FNoiseField(float MinRangeIn = 0.f, float MaxRangeIn = 0.f, FTransform TransformIn = FTransform::Identity)
        : Super()
        , MinRange(MinRangeIn)
        , MaxRange(MaxRangeIn)
        , Transform(TransformIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FNoiseField(MinRange,MaxRange,Transform); }
    virtual ~FNoiseField() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<float>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FNoiseField; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    float MinRange;
    float MaxRange;
    FTransform Transform;
};
 
class FUniformVector : public FFieldNode<FVector>
{
    typedef FFieldNode<FVector> Super;
 
public:
 
    FUniformVector(float MagnitudeIn = 1.f,
        FVector DirectionIn =FVector(0, 0, 0))
        : Super()
        , Magnitude(MagnitudeIn)
        , Direction(DirectionIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FUniformVector(Magnitude,Direction); }
    virtual ~FUniformVector() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<FVector>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FUniformVector; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    float Magnitude;
    FVector Direction;
};
 
class FRadialVector : public FFieldNode<FVector>
{
    typedef FFieldNode<FVector> Super;
 
public:
 
    FRadialVector(float MagnitudeIn = 1.f,
        FVector PositionIn = FVector(0, 0, 0))
        : Super()
        , Magnitude(MagnitudeIn)
        , Position(PositionIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FRadialVector(Magnitude,Position); }
    virtual ~FRadialVector() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<FVector>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FRadialVector; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    float Magnitude;
    FVector Position;
 
};
 
class FRandomVector : public FFieldNode<FVector>
{
    typedef FFieldNode<FVector> Super;
 
public:
 
    FRandomVector(float MagnitudeIn = 1.f)
        : Super()
        , Magnitude(MagnitudeIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override { return new FRandomVector(Magnitude); }
    virtual ~FRandomVector() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<FVector>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FRandomVector; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    float Magnitude;
};
 
class FSumScalar : public FFieldNode<float>
{
    typedef FFieldNode<float> Super;
 
public:
 
    FSumScalar(float MagnitudeIn = 1.f,
        FFieldNode<float> * ScalarRightIn = nullptr,
        FFieldNode<float> * ScalarLeftIn = nullptr,
        EFieldOperationType OperationIn = EFieldOperationType::Field_Multiply)
        : Super()
        , Magnitude(MagnitudeIn)
        , ScalarRight(TUniquePtr< FFieldNode<float> >(ScalarRightIn))
        , ScalarLeft(TUniquePtr< FFieldNode<float> >(ScalarLeftIn))
        , Operation(OperationIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override
    {
        return new FSumScalar(Magnitude,
            ScalarRight.Get() ? static_cast<FFieldNode<float> *>(ScalarRight->NewCopy()) : nullptr,
            ScalarLeft.Get() ? static_cast<FFieldNode<float> *>(ScalarLeft->NewCopy()) : nullptr,
            Operation);
    }
    virtual ~FSumScalar() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<float>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FSumScalar; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    static void FillDefaultSetup(TArray<int32>& NodesOffsets, TArray<float>& NodesParams)
    {
        NodesOffsets.Add(NodesParams.Num());
        NodesParams.Add(static_cast<float>(Super::StaticType()));
        NodesParams.Add(static_cast<float>(FFieldNodeBase::ESerializationType::FieldNode_FSumScalar));
        NodesParams.Add(1.0);
        NodesParams.Add(1.0);
        NodesParams.Add(1.0);
        NodesParams.Add(static_cast<float>(EFieldOperationType::Field_Add));
    }
 
    float Magnitude;
    TUniquePtr< FFieldNode<float> > ScalarRight;
    TUniquePtr< FFieldNode<float> > ScalarLeft;
    EFieldOperationType Operation;
};
 
class FSumVector : public FFieldNode<FVector>
{
    typedef FFieldNode<FVector> Super;
 
public:
 
    FSumVector(float MagnitudeIn = 1.f,
        FFieldNode<float> * ScalarIn = nullptr,
        FFieldNode<FVector> * VectorRightIn = nullptr,
        FFieldNode<FVector> * VectorLeftIn = nullptr,
        EFieldOperationType OperationIn = EFieldOperationType::Field_Multiply )
        : Super()
        , Magnitude(MagnitudeIn)
        , Scalar(TUniquePtr< FFieldNode<float> >(ScalarIn) )
        , VectorRight(TUniquePtr< FFieldNode<FVector> >(VectorRightIn) )
        , VectorLeft(TUniquePtr< FFieldNode<FVector> >(VectorLeftIn) )
        , Operation(OperationIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override
    {
        return new FSumVector(Magnitude,
            Scalar.Get() ? static_cast<FFieldNode<float> *>(Scalar->NewCopy()) : nullptr,
            VectorRight.Get() ? static_cast<FFieldNode<FVector> *>(VectorRight->NewCopy()) : nullptr,
            VectorLeft.Get() ? static_cast<FFieldNode<FVector> *>(VectorLeft->NewCopy()) : nullptr,
            Operation);
    }
    virtual ~FSumVector() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<FVector>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FSumVector; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    static void FillDefaultSetup(TArray<int32>& NodesOffsets, TArray<float>& NodesParams)
    {
        NodesOffsets.Add(NodesParams.Num());
        NodesParams.Add(static_cast<float>(Super::StaticType()));
        NodesParams.Add(static_cast<float>(FFieldNodeBase::ESerializationType::FieldNode_FSumVector));
        NodesParams.Add(1.0);
        NodesParams.Add(0.0);
        NodesParams.Add(1.0);
        NodesParams.Add(1.0);
        NodesParams.Add(static_cast<float>(EFieldOperationType::Field_Add));
    }
 
    float Magnitude;
    TUniquePtr< FFieldNode<float> > Scalar;
    TUniquePtr< FFieldNode<FVector> > VectorRight;
    TUniquePtr< FFieldNode<FVector> > VectorLeft;
    EFieldOperationType Operation;
};
 
 
template<class InT, class OutT>
class FConversionField : public FFieldNode<OutT>
{
    typedef FFieldNode<OutT> Super;
 
public:
 
    FConversionField(FFieldNode<InT> * InFieldIn = nullptr)
        : Super()
        , InputField(TUniquePtr< FFieldNode<InT> >(InFieldIn))
    {}
    virtual FFieldNodeBase * NewCopy() const override 
    { 
        return new FConversionField(InputField.Get() ? static_cast<FFieldNode<InT> *>(InputField->NewCopy()) : nullptr);
    }
    virtual ~FConversionField() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<OutT>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FConversionField; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    static void FillDefaultSetup(TArray<int32>& NodesOffsets, TArray<float>& NodesParams)
    {
        NodesOffsets.Add(NodesParams.Num());
        NodesParams.Add(static_cast<float>(Super::StaticType()));
        NodesParams.Add(static_cast<float>(FFieldNodeBase::ESerializationType::FieldNode_FConversionField));
        NodesParams.Add(1.0);
    }
 
    TUniquePtr< FFieldNode<InT> > InputField;
};
 
template<class T>
class FCullingField : public FFieldNode<T>
{
    typedef FFieldNode<T> Super;
 
public:
 
    FCullingField( 
        FFieldNode<float> * CullingIn = nullptr,
        FFieldNode<T> * InputIn = nullptr,
        EFieldCullingOperationType OperationIn = EFieldCullingOperationType::Field_Culling_Inside)
 
        : Super()
        , Culling(TUniquePtr< FFieldNode<float> >(CullingIn))
        , Input(TUniquePtr< FFieldNode<T> >(InputIn))
        , Operation(OperationIn)
    {}
    virtual FFieldNodeBase * NewCopy() const override
    {
        return new FCullingField<T>(
            Culling.Get() ? static_cast<FFieldNode<float> *>(Culling->NewCopy()) : nullptr,
            Input.Get() ? static_cast<FFieldNode<T> *>(Input->NewCopy()) : nullptr,
            Operation);
    }
    virtual ~FCullingField() {}
 
    CHAOS_API virtual void Evaluate(FFieldContext&, TFieldArrayView<T>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node) override;
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const override { return FFieldNodeBase::ESerializationType::FieldNode_FCullingField; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
 
    CHAOS_API virtual void FillSetupCount(int32& NumOffsets, int32& NumParams) const override;
 
    CHAOS_API virtual void FillSetupDatas(TArray<int32>& NodesOffsets, TArray<float>& NodesParams, const float CommandTime) const override;
 
    CHAOS_API virtual float EvalMaxMagnitude() const override;
 
    CHAOS_API virtual void ComputeFieldBounds(FVector& MinBounds, FVector& MaxBounds, FVector& CenterPosition) const override;
 
    TUniquePtr< FFieldNode<float> > Culling;
    TUniquePtr< FFieldNode<T> > Input;
    EFieldCullingOperationType Operation;
};
 
#if PLATFORM_MAC
extern template class CHAOS_API FCullingField<int32>;
extern template class CHAOS_API FCullingField<float>;
extern template class CHAOS_API FCullingField<FVector>;
#endif
 
template<class T>
class FReturnResultsTerminal : public FFieldNode<T>
{
    typedef FFieldNode<T> Super;
 
public:
 
    FReturnResultsTerminal() : Super()
    {}
    virtual FFieldNodeBase * NewCopy() const override
    {
        return new FReturnResultsTerminal<T>();
    }
    virtual ~FReturnResultsTerminal() {}
 
    CHAOS_API void Evaluate(FFieldContext&, TFieldArrayView<T>& Results) const override;
    CHAOS_API virtual bool operator==(const FFieldNodeBase& Node);
 
    virtual FFieldNodeBase::ESerializationType SerializationType() const { return FFieldNodeBase::ESerializationType::FieldNode_FReturnResultsTerminal; }
    CHAOS_API virtual void Serialize(FArchive& Ar) override;
};
 
#if PLATFORM_MAC
extern template class CHAOS_API FReturnResultsTerminal<int32>;
extern template class CHAOS_API FReturnResultsTerminal<float>;
extern template class CHAOS_API FReturnResultsTerminal<FVector>;
#endif
 
/*
* Serialization Factory
*/
FFieldNodeBase * FieldNodeFactory(FFieldNodeBase::EFieldType BaseType, FFieldNodeBase::ESerializationType Type);