EngineTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Misc/EnumClassFlags.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
#include "Templates/SubclassOf.h"
#include "Engine/TimerHandle.h"
#include "Engine/NaniteAssemblyData.h"
#include "UObject/StrProperty.h"
#include "EngineTypes.generated.h"
 
class AActor;
class UDecalComponent;
class UPhysicalMaterial;
class UPhysicalMaterialMask;
class UPrimitiveComponent;
class USceneComponent;
class USubsurfaceProfile;
class USpecularProfile;
 
enum { NumInlinedActorComponents = 24 };
 
UENUM()
enum EAspectRatioAxisConstraint : int
{
    AspectRatio_MaintainYFOV UMETA(DisplayName="Maintain Y-Axis FOV"),
    AspectRatio_MaintainXFOV UMETA(DisplayName="Maintain X-Axis FOV"),
    AspectRatio_MajorAxisFOV UMETA(DisplayName="Maintain Major Axis FOV"),
    AspectRatio_MAX,
};
 
namespace EBrowseReturnVal
{
    enum Type
    {
        Success,
        Failure,
        Pending,
    };
}
 
UENUM()
enum class EAttachmentRule : uint8
{
    KeepRelative,
 
    KeepWorld,
 
    SnapToTarget,
};
 
struct FAttachmentTransformRules
{
    static ENGINE_API FAttachmentTransformRules KeepRelativeTransform;
    static ENGINE_API FAttachmentTransformRules KeepWorldTransform;
    static ENGINE_API FAttachmentTransformRules SnapToTargetNotIncludingScale;
    static ENGINE_API FAttachmentTransformRules SnapToTargetIncludingScale;
 
    FAttachmentTransformRules(EAttachmentRule InRule, bool bInWeldSimulatedBodies)
        : LocationRule(InRule)
        , RotationRule(InRule)
        , ScaleRule(InRule)
        , bWeldSimulatedBodies(bInWeldSimulatedBodies)
    {}
 
    FAttachmentTransformRules(EAttachmentRule InLocationRule, EAttachmentRule InRotationRule, EAttachmentRule InScaleRule, bool bInWeldSimulatedBodies)
        : LocationRule(InLocationRule)
        , RotationRule(InRotationRule)
        , ScaleRule(InScaleRule)
        , bWeldSimulatedBodies(bInWeldSimulatedBodies)
    {}
 
    EAttachmentRule LocationRule;
 
    EAttachmentRule RotationRule;
 
    EAttachmentRule ScaleRule;
 
    bool bWeldSimulatedBodies;
};
 
UENUM()
enum class EDetachmentRule : uint8
{
    KeepRelative,
 
    KeepWorld,
};
 
struct FDetachmentTransformRules
{
    static ENGINE_API FDetachmentTransformRules KeepRelativeTransform;
    static ENGINE_API FDetachmentTransformRules KeepWorldTransform;
 
    FDetachmentTransformRules(EDetachmentRule InRule, bool bInCallModify)
        : LocationRule(InRule)
        , RotationRule(InRule)
        , ScaleRule(InRule)
        , bCallModify(bInCallModify)
    {}
 
    FDetachmentTransformRules(EDetachmentRule InLocationRule, EDetachmentRule InRotationRule, EDetachmentRule InScaleRule, bool bInCallModify)
        : LocationRule(InLocationRule)
        , RotationRule(InRotationRule)
        , ScaleRule(InScaleRule)
        , bCallModify(bInCallModify)
    {}
 
    FDetachmentTransformRules(const FAttachmentTransformRules& AttachmentRules, bool bInCallModify)
        : LocationRule(AttachmentRules.LocationRule == EAttachmentRule::KeepRelative ? EDetachmentRule::KeepRelative : EDetachmentRule::KeepWorld)
        , RotationRule(AttachmentRules.RotationRule == EAttachmentRule::KeepRelative ? EDetachmentRule::KeepRelative : EDetachmentRule::KeepWorld)
        , ScaleRule(AttachmentRules.ScaleRule == EAttachmentRule::KeepRelative ? EDetachmentRule::KeepRelative : EDetachmentRule::KeepWorld)
        , bCallModify(bInCallModify)
    {}
 
    EDetachmentRule LocationRule;
 
    EDetachmentRule RotationRule;
 
    EDetachmentRule ScaleRule;
 
    bool bCallModify;
};
 
UENUM()
namespace EAttachLocation
{
    enum Type : int
    {
        KeepRelativeOffset,
        
        KeepWorldPosition,
 
        SnapToTarget                    UMETA(DisplayName = "Snap to Target, Keep World Scale"),
        
        SnapToTargetIncludingScale      UMETA(DisplayName = "Snap to Target, Including Scale"),
    };
}
 
UENUM()
enum ESceneDepthPriorityGroup : int
{
    SDPG_World,
    SDPG_Foreground,
    SDPG_MAX,
};
 
UENUM()
enum EIndirectLightingCacheQuality : int
{
    ILCQ_Off,
    ILCQ_Point,
    ILCQ_Volume
};
 
UENUM()
enum class ELightmapType : uint8
{
    Default,
    ForceSurface,
    ForceVolumetric
};
 
UENUM()
enum EOcclusionCombineMode : int
{
    OCM_Minimum,
    OCM_Multiply,
    OCM_MAX,
};
 
UENUM(BlueprintType)
enum EBlendMode : int
{
    BLEND_Opaque UMETA(DisplayName="Opaque"),
    BLEND_Masked UMETA(DisplayName="Masked"),
    BLEND_Translucent UMETA(DisplayName="Translucent"),
    BLEND_Additive UMETA(DisplayName="Additive"),
    BLEND_Modulate UMETA(DisplayName="Modulate"),
    BLEND_AlphaComposite UMETA(DisplayName = "AlphaComposite (Premultiplied Alpha)"),
    BLEND_AlphaHoldout UMETA(DisplayName = "AlphaHoldout"),
    BLEND_TranslucentColoredTransmittance UMETA(DisplayName = "SUBSTRATE_ONLY - Translucent - Colored Transmittance"), /*Substrate only */
    BLEND_MAX UMETA(Hidden),
    // Renamed blend modes. These blend modes are remapped onto legacy ones and kept hidden for not confusing users in legacy mode, while allowing to use the new blend mode names into code.
    BLEND_TranslucentGreyTransmittance = BLEND_Translucent UMETA(Hidden, DisplayName = "Translucent - Grey Transmittance"), /*Substrate only */
    BLEND_ColoredTransmittanceOnly = BLEND_Modulate UMETA(Hidden, DisplayName = "Colored Transmittance Only"), /*Substrate only */
};
 
class FMaterial;
class UMaterialInterface;
 
UENUM()
enum EMaterialFloatPrecisionMode : int
{
    MFPM_Default UMETA(DisplayName = "Default"),
    MFPM_Full_MaterialExpressionOnly UMETA(DisplayName = "Use Full-precision for MaterialExpressions only"),
    MFPM_Full UMETA(DisplayName = "Use Full-precision for every float"),
    MFPM_Half UMETA(DisplayName = "Use Half-precision"),
    MFPM_MAX,
};
 
UENUM()
enum ESamplerSourceMode : int
{
    SSM_FromTextureAsset UMETA(DisplayName="From texture asset"),
    SSM_Wrap_WorldGroupSettings UMETA(DisplayName="Shared: Wrap"),
    SSM_Clamp_WorldGroupSettings UMETA(DisplayName="Shared: Clamp"),
    SSM_TerrainWeightmapGroupSettings UMETA(Hidden)
};
 
UENUM()
enum ETextureMipValueMode : int
{
    /* Use hardware computed sample's mip level with automatic anisotropic filtering support. */
    TMVM_None UMETA(DisplayName="None (use computed mip level)"),
 
    /* Explicitly compute the sample's mip level. Disables anisotropic filtering. */
    TMVM_MipLevel UMETA(DisplayName="MipLevel (absolute, 0 is full resolution)"),
    
    /* Bias the hardware computed sample's mip level. Disables anisotropic filtering. */
    TMVM_MipBias UMETA(DisplayName="MipBias (relative to the computed mip level)"),
    
    /* Explicitly compute the sample's DDX and DDY for anisotropic filtering. */
    TMVM_Derivative UMETA(DisplayName="Derivative (explicit derivative to compute mip level)"),
 
    TMVM_MAX,
};
 
UENUM()
enum ETranslucencyLightingMode : int
{
    TLM_VolumetricNonDirectional UMETA(DisplayName="Volumetric NonDirectional"),
 
    TLM_VolumetricDirectional UMETA(DisplayName="Volumetric Directional"),
 
    TLM_VolumetricPerVertexNonDirectional UMETA(DisplayName="Volumetric PerVertex NonDirectional"),
 
    TLM_VolumetricPerVertexDirectional UMETA(DisplayName="Volumetric PerVertex Directional"),
 
    TLM_Surface UMETA(DisplayName="Surface TranslucencyVolume"),
 
    TLM_SurfacePerPixelLighting UMETA(DisplayName="Surface ForwardShading"),
 
    TLM_MAX,
};
 
UENUM()
enum ERefractionMode : int
{
    RM_IndexOfRefraction UMETA(DisplayName="Index Of Refraction"),
 
    RM_PixelNormalOffset UMETA(DisplayName="Pixel Normal Offset"),
 
    RM_2DOffset UMETA(DisplayName = "2D Offset"),
 
    RM_None UMETA(DisplayName = "None"),
 
    RM_IndexOfRefractionFromF0 UMETA(DisplayName = "Index Of Refraction From F0"),
};
 
UENUM()
enum ERefractionCoverageMode : int
{
    RCM_CoverageIgnored UMETA(DisplayName = "Coverage Ignored"),
 
    RCM_CoverageAccountedFor UMETA(DisplayName = "Coverage Accounted For"),
};
 
UENUM()
enum EPixelDepthOffsetMode : int
{
    PDOM_Legacy UMETA(DisplayName = "Legacy"),
 
    PDOM_AlongCameraVector UMETA(DisplayName = "Along Camera Vector"),
};
 
UENUM()
namespace ETranslucentSortPolicy
{
    enum Type : int
    {
        SortByDistance = 0,
 
        SortByProjectedZ = 1,
 
        SortAlongAxis = 2,
    };
}
 
// Note: Must match r.DynamicGlobalIlluminationMethod, this is used in URendererSettings
UENUM()
namespace EDynamicGlobalIlluminationMethod
{
    enum Type : int
    {
        None, 
 
        Lumen,
 
        ScreenSpace UMETA(DisplayName="Screen Space (Beta)"),
 
        Plugin UMETA(DisplayName="Plugin"),
    };
}
 
// Note: Must match r.ReflectionMethod, this is used in URendererSettings
UENUM()
namespace EReflectionMethod
{
    enum Type : int
    {
        None, 
 
        Lumen,
 
        ScreenSpace UMETA(DisplayName="Screen Space"),
    };
}
 
// Note: Must match r.Shadow.Virtual.Enable, this is used in URendererSettings
UENUM()
namespace EShadowMapMethod
{
    enum Type : int
    {
        ShadowMaps UMETA(DisplayName = "Shadow Maps"),
 
        VirtualShadowMaps UMETA(DisplayName = "Virtual Shadow Maps")
    };
}
 
UENUM()
namespace ECastRayTracedShadow 
{
    enum Type : int
    {
        Disabled,
        UseProjectSetting,
        Enabled,
    };
}
 
UENUM()
namespace EMegaLightsShadowMethod
{
    enum Type : int
    {
        Default,
        RayTracing,
        VirtualShadowMap,
    };
}
 
UENUM()
enum ESceneCaptureSource : int
{ 
    SCS_SceneColorHDR UMETA(DisplayName="SceneColor (HDR) in RGB, Inv Opacity in A"),
    SCS_SceneColorHDRNoAlpha UMETA(DisplayName="SceneColor (HDR) in RGB, 0 in A"),
    SCS_FinalColorLDR UMETA(DisplayName="Final Color (LDR) in RGB"),
    SCS_SceneColorSceneDepth UMETA(DisplayName="SceneColor (HDR) in RGB, SceneDepth in A"),
    SCS_SceneDepth UMETA(DisplayName="SceneDepth in R"),
    SCS_DeviceDepth UMETA(DisplayName = "DeviceDepth in RGB"),
    SCS_Normal UMETA(DisplayName="Normal in RGB (Deferred Renderer only)"),
    SCS_BaseColor UMETA(DisplayName = "BaseColor in RGB (Deferred Renderer only)"),
    SCS_FinalColorHDR UMETA(DisplayName = "Final Color (HDR) in Linear Working Color Space"),
    SCS_FinalToneCurveHDR UMETA(DisplayName = "Final Color (with tone curve) in Linear sRGB gamut"),
 
    SCS_MAX
};
 
UENUM()
enum ESceneCaptureCompositeMode : int
{ 
    SCCM_Overwrite UMETA(DisplayName="Overwrite"),
    SCCM_Additive UMETA(DisplayName="Additive"),
    SCCM_Composite UMETA(DisplayName="Composite")
};
 
#define NUM_LIGHTING_CHANNELS 3
 
USTRUCT(BlueprintType)
struct FLightingChannels
{
    GENERATED_BODY()
 
    FLightingChannels() :
        bChannel0(true),
        bChannel1(false),
        bChannel2(false)
    {}
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Channels)
    uint8 bChannel0:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Channels)
    uint8 bChannel1:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Channels)
    uint8 bChannel2:1;
};
 
inline uint8 GetLightingChannelMaskForStruct(FLightingChannels Value)
{
    // Note: this is packed into 3 bits of a stencil channel
    return (uint8)((Value.bChannel0 ? 1 : 0) | (Value.bChannel1 << 1) | (Value.bChannel2 << 2));
}
 
inline uint8 GetDefaultLightingChannelMask()
{
    return 1;
}
 
inline int32 GetFirstLightingChannelFromMask(uint8 Mask)
{
    return Mask ? FPlatformMath::CountTrailingZeros(Mask) : -1;
}
 
USTRUCT(BlueprintType)
struct FViewLightingChannels
{
    GENERATED_BODY()
 
    FViewLightingChannels() :
        bViewChannel0(true),
        bViewChannel1(false),
        bViewChannel2(false),
        bViewChannel3(false),
        bViewChannel4(false)
    {}
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Channels)
    uint8 bViewChannel0:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Channels)
    uint8 bViewChannel1:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Channels)
    uint8 bViewChannel2:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Channels)
    uint8 bViewChannel3:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Channels)
    uint8 bViewChannel4:1;
 
    inline uint8 GetMaskForStruct() const
    {
        return (uint8)((bViewChannel0 << 0) | (bViewChannel1 << 1) | (bViewChannel2 << 2) | (bViewChannel3 << 3) | (bViewChannel4 << 4));
    }
 
    static inline constexpr uint8 GetMaskDefault() { return 0x1; }
};
 
UENUM()
namespace EGBufferFormat
{
    enum Type : int
    {
        Force8BitsPerChannel = 0 UMETA(DisplayName = "Force 8 Bits Per Channel"),
        Default = 1,
        HighPrecisionNormals = 3,
        Force16BitsPerChannel = 5 UMETA(DisplayName = "Force 16 Bits Per Channel"),
    };
}
 
 
UENUM()
enum EMobileLocalLightSetting : int
{
    LOCAL_LIGHTS_DISABLED UMETA(DisplayName = "Local Lights Disabled"),
    LOCAL_LIGHTS_ENABLED UMETA(DisplayName = "Local Lights Enabled"),
    LOCAL_LIGHTS_BUFFER UMETA(DisplayName = "Local Lights Buffer Enabled")
};
 
UENUM()
enum ETrailWidthMode : int
{
    ETrailWidthMode_FromCentre UMETA(DisplayName = "From Centre"),
    ETrailWidthMode_FromFirst UMETA(DisplayName = "From First Socket"),
    ETrailWidthMode_FromSecond UMETA(DisplayName = "From Second Socket"),
};
 
UENUM()
namespace EParticleCollisionMode
{
    enum Type : int
    {
        SceneDepth UMETA(DisplayName="Scene Depth"),
        DistanceField UMETA(DisplayName="Distance Field")
    };
}
 
UENUM()
enum EMaterialShadingModel : int
{
    MSM_Unlit                   UMETA(DisplayName="Unlit"),
    MSM_DefaultLit              UMETA(DisplayName="Default Lit"),
    MSM_Subsurface              UMETA(DisplayName="Subsurface"),
    MSM_PreintegratedSkin       UMETA(DisplayName="Preintegrated Skin"),
    MSM_ClearCoat               UMETA(DisplayName="Clear Coat"),
    MSM_SubsurfaceProfile       UMETA(DisplayName="Subsurface Profile"),
    MSM_TwoSidedFoliage         UMETA(DisplayName="Two Sided Foliage"),
    MSM_Hair                    UMETA(DisplayName="Hair"),
    MSM_Cloth                   UMETA(DisplayName="Cloth"),
    MSM_Eye                     UMETA(DisplayName="Eye"),
    MSM_SingleLayerWater        UMETA(DisplayName="SingleLayerWater"),
    MSM_ThinTranslucent         UMETA(DisplayName="Thin Translucent"),
    MSM_Strata                  UMETA(DisplayName="Substrate", Hidden),
    MSM_NUM                     UMETA(Hidden),
    MSM_FromMaterialExpression  UMETA(DisplayName="From Material Expression"),
    MSM_MAX
};
 
static_assert(MSM_NUM <= 16, "Do not exceed 16 shading models without expanding FMaterialShadingModelField to support uint32 instead of uint16!");
 
USTRUCT()
struct FMaterialShadingModelField
{
    GENERATED_USTRUCT_BODY()
 
public:
    FMaterialShadingModelField() {}
    FMaterialShadingModelField(EMaterialShadingModel InShadingModel)        { AddShadingModel(InShadingModel); }
 
    void AddShadingModel(EMaterialShadingModel InShadingModel)              { check(InShadingModel < MSM_NUM); ShadingModelField |= (1 << (uint16)InShadingModel); }
    void RemoveShadingModel(EMaterialShadingModel InShadingModel)           { ShadingModelField &= ~(1 << (uint16)InShadingModel); }
    void ClearShadingModels()                                               { ShadingModelField = 0; }
 
    // Check if any of the given shading models are present
    bool HasAnyShadingModel(const TArray<EMaterialShadingModel>& InShadingModels) const 
    { 
        for (EMaterialShadingModel ShadingModel : InShadingModels)
        {
            if (HasShadingModel(ShadingModel))
            {
                return true;
            }
        }
        return false; 
    }
 
    bool HasShadingModel(EMaterialShadingModel InShadingModel) const        { return (ShadingModelField & (1 << (uint16)InShadingModel)) != 0; }
    bool HasOnlyShadingModel(EMaterialShadingModel InShadingModel) const    { return ShadingModelField == (1 << (uint16)InShadingModel); }
    bool IsUnlit() const                                                    { return HasShadingModel(MSM_Unlit); }
    bool IsLit() const                                                      { return !IsUnlit(); }
    bool IsValid() const                                                    { return (ShadingModelField > 0) && (ShadingModelField < (1 << MSM_NUM)); }
    uint16 GetShadingModelField() const                                     { return ShadingModelField; }
    void SetShadingModelField(uint16 InShadingModelField)                   { ShadingModelField = InShadingModelField; }
    int32 CountShadingModels() const                                        { return FMath::CountBits(ShadingModelField); }
    EMaterialShadingModel GetFirstShadingModel() const                      { check(IsValid()); return (EMaterialShadingModel)FMath::CountTrailingZeros(ShadingModelField); }
 
    bool operator==(const FMaterialShadingModelField& Other) const          { return ShadingModelField == Other.GetShadingModelField(); }
    bool operator!=(const FMaterialShadingModelField& Other) const          { return ShadingModelField != Other.GetShadingModelField(); }
 
private:
    UPROPERTY()
    uint16 ShadingModelField = 0;
};
 
UENUM()
namespace ESubstrateStorageFormat
{
    enum Type : int
    {
        BlendableGBuffer = 0 UMETA(DisplayName = "Blendable GBuffer"),
 
        AdaptiveBuffer = 1 UMETA(DisplayName = "Adaptive GBuffer"),
    };
}
 
UENUM()
namespace ESubstrateClosureConfig
{
    enum Type : int
    {
        UseMinProjectAndPlatforClosuresPerPixel = 0 UMETA(DisplayName = "Min of project's and platfom's closure count"),
 
        ForceProjectClosuresPerPixel = 1 UMETA(DisplayName = "Force Closure Count"),
    };
}
 
enum ESubstrateShadingModel : int
{
    SSM_Unlit,
    SSM_DefaultLit,
    SSM_ThinTranslucent,
    SSM_SubsurfaceMFP,
    SSM_SubsurfaceProfile,
    SSM_SubsurfaceWrap,
    SSM_SubsurfaceThinTwoSided,
    SSM_VolumetricFogCloud,
    SSM_Hair,
    SSM_Eye,
    SSM_Cloth,
    SSM_ClearCoat,
    SSM_SingleLayerWater,
    SSM_LightFunction,
    SSM_PostProcess,
    SSM_Decal,
    SSM_UI,
    SSM_NUM,
};
static_assert(SSM_NUM <= 32, "Do not exceed 32 shading models without expanding FSubstrateMaterialInfo::ShadingModelField to support more bits!");
 
// This used to track cyclic graph which we do not support. We only support acyclic graph and a depth of 128 is already too high for a realistic use case.
#define SUBSTRATE_TREE_MAX_DEPTH 48
 
struct FSubstrateMaterialInfo
{
public:
    FSubstrateMaterialInfo(bool bGatherGuids = false) { bGatherMaterialExpressionGuids = bGatherGuids; }
    FSubstrateMaterialInfo(ESubstrateShadingModel InShadingModel) { AddShadingModel(InShadingModel); }
 
    // Shading model
    void AddShadingModel(ESubstrateShadingModel InShadingModel) { check(InShadingModel < SSM_NUM); ShadingModelField |= (1u << (uint32)InShadingModel); }
    void SetSingleShadingModel(ESubstrateShadingModel InShadingModel) { check(InShadingModel < SSM_NUM); ShadingModelField = (1u << (uint32)InShadingModel); }
    bool HasShadingModel(ESubstrateShadingModel InShadingModel) const { return (ShadingModelField & (1u << (uint32)InShadingModel)) != 0; }
    bool HasOnlyShadingModel(ESubstrateShadingModel InShadingModel) const { return ShadingModelField == (1u << (uint32)InShadingModel); }
    uint32 GetShadingModelField() const { return ShadingModelField; }
    int32 CountShadingModels() const { return FMath::CountBits(ShadingModelField); }
 
    // Subsurface profiles
    void AddSubsurfaceProfile(USubsurfaceProfile* InProfile) { if (InProfile) SubsurfaceProfiles.Add(InProfile); }
    int32 CountSubsurfaceProfiles() const { return SubsurfaceProfiles.Num(); }
    USubsurfaceProfile* GetSubsurfaceProfile(int32 Index) const { return SubsurfaceProfiles.IsValidIndex(Index) ? SubsurfaceProfiles[Index] : nullptr; }
 
    // Specular profiles
    void AddSpecularProfile(USpecularProfile* InProfile) { if (InProfile) SpecularProfiles.Add(InProfile); }
    int32 CountSpecularProfiles() const { return SpecularProfiles.Num(); }
    USpecularProfile* GetSpecularProfile(int32 Index) const { return SpecularProfiles.IsValidIndex(Index) ? SpecularProfiles[Index] : nullptr; }
 
    // Shading model from expression
    void SetShadingModelFromExpression(bool bIn) { bHasShadingModelFromExpression = bIn ? 1u : 0u; }
    bool HasShadingModelFromExpression() const { return bHasShadingModelFromExpression > 0u; }
 
    // Substrate material expression GUIDs
    void AddGuid(const FGuid& In) { if (bGatherMaterialExpressionGuids) { MaterialExpressionGuids.Add(In); } }
    const TArray<FGuid>& GetGuids() const { return MaterialExpressionGuids; }
 
    uint64 GetPropertyConnected() const { return ConnectedPropertyMask; }
    void AddPropertyConnected(uint64 In) { ConnectedPropertyMask |= (1ull << In); }
    bool HasPropertyConnected(uint64 In) const { return !!(ConnectedPropertyMask & (1ull << In)); }
    static bool HasPropertyConnected(uint64 InConnectedPropertyMask, uint64 In) { return !!(InConnectedPropertyMask & (1ull << In)); }
 
    bool IsValid() const { return (ShadingModelField > 0) && (ShadingModelField < (1 << SSM_NUM)); }
 
    bool operator==(const FSubstrateMaterialInfo& Other) const { return ShadingModelField == Other.GetShadingModelField(); }
    bool operator!=(const FSubstrateMaterialInfo& Other) const { return ShadingModelField != Other.GetShadingModelField(); }
 
#if WITH_EDITOR
    // Returns true if everything went fine (not out of Substrate tree stack)
    bool PushSubstrateTreeStack()
    {
        bOutOfStackDepthWhenParsing = bOutOfStackDepthWhenParsing || (++ParsingStackDepth > SUBSTRATE_TREE_MAX_DEPTH);
        return !bOutOfStackDepthWhenParsing;
    }
    void PopSubstrateTreeStack()
    {
        ParsingStackDepth--;
        check(ParsingStackDepth >= 0);
    }
    bool GetSubstrateTreeOutOfStackDepthOccurred() 
    {
        return bOutOfStackDepthWhenParsing;
    }
#endif
 
private:
    uint32 ShadingModelField = 0;
 
    /* Indicates if the shading model is constant or data-driven from the shader graph */
    uint8 bHasShadingModelFromExpression = 0;
 
    /* Indicates which (legacy) inputs are connected */
    uint64 ConnectedPropertyMask = 0;
 
    TArray<TObjectPtr<USubsurfaceProfile>> SubsurfaceProfiles;
 
    TArray<TObjectPtr<USpecularProfile>> SpecularProfiles;
    
    /* Material expression GUIDs for all the traversed Substrate nodes */
    bool bGatherMaterialExpressionGuids = false;
    TArray<FGuid> MaterialExpressionGuids;
 
#if WITH_EDITOR
    // A simple way to detect and prevent node re-entry due to cycling graph; stop the compilation and avoid crashing.
    bool bOutOfStackDepthWhenParsing = false;
    int32 ParsingStackDepth = 0;
#endif
};
 
template<>
struct TStructOpsTypeTraits<FSubstrateMaterialInfo> : public TStructOpsTypeTraitsBase2<FSubstrateMaterialInfo>
{
    enum
    {
        WithSerializer = true,
        WithPostSerialize = true,
    };
};
 
UENUM(BlueprintType)
enum EMaterialSamplerType : int
{
    SAMPLERTYPE_Color UMETA(DisplayName="Color"),
    SAMPLERTYPE_Grayscale UMETA(DisplayName="Grayscale"),
    SAMPLERTYPE_Alpha UMETA(DisplayName="Alpha"),
    SAMPLERTYPE_Normal UMETA(DisplayName="Normal"),
    SAMPLERTYPE_Masks UMETA(DisplayName="Masks"),
    SAMPLERTYPE_DistanceFieldFont UMETA(DisplayName="Distance Field Font"),
    SAMPLERTYPE_LinearColor UMETA(DisplayName = "Linear Color"),
    SAMPLERTYPE_LinearGrayscale UMETA(DisplayName = "Linear Grayscale"),
    SAMPLERTYPE_Data UMETA(DisplayName = "Data"),
    SAMPLERTYPE_External UMETA(DisplayName = "External"),
 
    SAMPLERTYPE_VirtualColor UMETA(DisplayName = "Virtual Color"),
    SAMPLERTYPE_VirtualGrayscale UMETA(DisplayName = "Virtual Grayscale"),
    SAMPLERTYPE_VirtualAlpha UMETA(DisplayName = "Virtual Alpha"),
    SAMPLERTYPE_VirtualNormal UMETA(DisplayName = "Virtual Normal"),
    SAMPLERTYPE_VirtualMasks UMETA(DisplayName = "Virtual Mask"),
    /*No DistanceFiledFont Virtual*/
    SAMPLERTYPE_VirtualLinearColor UMETA(DisplayName = "Virtual Linear Color"),
    SAMPLERTYPE_VirtualLinearGrayscale UMETA(DisplayName = "Virtual Linear Grayscale"),
    /*No External Virtual*/
 
    SAMPLERTYPE_MAX,
};
 
inline bool IsVirtualSamplerType(EMaterialSamplerType Value)
{
    return ((int32)Value >= (int32)SAMPLERTYPE_VirtualColor && (int32)Value <= (int32)SAMPLERTYPE_VirtualLinearGrayscale);
}
UENUM()
enum EMaterialStencilCompare : int
{
    MSC_Less            UMETA(DisplayName = "Less Than"),
    MSC_LessEqual       UMETA(DisplayName = "Less Than or Equal"),
    MSC_Greater         UMETA(DisplayName = "Greater Than"),
    MSC_GreaterEqual    UMETA(DisplayName = "Greater Than or Equal"),
    MSC_Equal           UMETA(DisplayName = "Equal"),
    MSC_NotEqual        UMETA(DisplayName = "Not Equal"),
    MSC_Never           UMETA(DisplayName = "Never"),
    MSC_Always          UMETA(DisplayName = "Always"),
    MSC_Count           UMETA(Hidden),
};
 
UENUM()
enum EMaterialShadingRate : int
{
    MSR_1x1             UMETA(DisplayName = "1x1"),
    MSR_2x1             UMETA(DisplayName = "2x1"),
    MSR_1x2             UMETA(DisplayName = "1x2"),
    MSR_2x2             UMETA(DisplayName = "2x2"),
    MSR_4x2             UMETA(DisplayName = "4x2"),
    MSR_2x4             UMETA(DisplayName = "2x4"),
    MSR_4x4             UMETA(DisplayName = "4x4"),
    MSR_Count           UMETA(Hidden),
};
 
 
UENUM(BlueprintType)
enum ELightingBuildQuality : int
{
    Quality_Preview     UMETA(DisplayName = "Preview"),
    Quality_Medium      UMETA(DisplayName = "Medium"),
    Quality_High        UMETA(DisplayName = "High"),
    Quality_Production  UMETA(DisplayName = "Production"),
    Quality_MAX         UMETA(Hidden),
};
 
UENUM(BlueprintType)
enum EMovementMode : int
{
    MOVE_None       UMETA(DisplayName="None"),
 
    MOVE_Walking    UMETA(DisplayName="Walking"),
 
    MOVE_NavWalking UMETA(DisplayName="Navmesh Walking"),
 
    MOVE_Falling    UMETA(DisplayName="Falling"),
 
    MOVE_Swimming   UMETA(DisplayName="Swimming"),
 
    MOVE_Flying     UMETA(DisplayName="Flying"),
 
    MOVE_Custom     UMETA(DisplayName="Custom"),
 
    MOVE_MAX        UMETA(Hidden),
};
 
UENUM(BlueprintType)
enum class ENetworkSmoothingMode : uint8
{
    Disabled        UMETA(DisplayName="Disabled"),
 
    Linear          UMETA(DisplayName="Linear"),
 
    Exponential     UMETA(DisplayName="Exponential"),
 
};
 
// Number of bits used currently from FMaskFilter.
enum { NumExtraFilterBits = 6 };
 
// NOTE!!Some of these values are used to index into FCollisionResponseContainers and must be kept in sync.
// @see FCollisionResponseContainer::SetResponse().
 
// @NOTE!!!! This DisplayName [DISPLAYNAME] SHOULD MATCH suffix of ECC_DISPLAYNAME
// Otherwise it will mess up collision profile loading
// If you change this, please also change FCollisionResponseContainers
//
// If you add any more TraceQuery="1", you also should change UCollisionProfile::LoadProfileConfig
// Metadata doesn't work outside of editor, so you'll need to add manually
 
// @NOTE : when you add more here for predefined engine channel
// please change the max in the CollisionProfile
// search ECC_Destructible
 
// in order to use this custom channels
// we recommend to define in your local file
// - i.e. #define COLLISION_WEAPON      ECC_GameTraceChannel1
// and make sure you customize these it in INI file by
// 
// in DefaultEngine.ini
//
// [/Script/Engine.CollisionProfile]
// GameTraceChannel1="Weapon"
// 
// also in the INI file, you can override collision profiles that are defined by simply redefining
// note that Weapon isn't defined in the BaseEngine.ini file, but "Trigger" is defined in Engine
// +Profiles=(Name="Trigger",CollisionEnabled=QueryOnly,ObjectTypeName=WorldDynamic, DefaultResponse=ECR_Overlap, CustomResponses=((Channel=Visibility, Response=ECR_Ignore), (Channel=Weapon, Response=ECR_Ignore)))
 
 
UENUM(BlueprintType)
enum ECollisionChannel : int
{
 
    ECC_WorldStatic UMETA(DisplayName="WorldStatic"),
    ECC_WorldDynamic UMETA(DisplayName="WorldDynamic"),
    ECC_Pawn UMETA(DisplayName="Pawn"),
    ECC_Visibility UMETA(DisplayName="Visibility" , TraceQuery="1"),
    ECC_Camera UMETA(DisplayName="Camera" , TraceQuery="1"),
    ECC_PhysicsBody UMETA(DisplayName="PhysicsBody"),
    ECC_Vehicle UMETA(DisplayName="Vehicle"),
    ECC_Destructible UMETA(DisplayName="Destructible"),
 
    ECC_EngineTraceChannel1 UMETA(Hidden),
 
    ECC_EngineTraceChannel2 UMETA(Hidden),
    ECC_EngineTraceChannel3 UMETA(Hidden),
    ECC_EngineTraceChannel4 UMETA(Hidden), 
    ECC_EngineTraceChannel5 UMETA(Hidden),
    ECC_EngineTraceChannel6 UMETA(Hidden),
 
    ECC_GameTraceChannel1 UMETA(Hidden),
    ECC_GameTraceChannel2 UMETA(Hidden),
    ECC_GameTraceChannel3 UMETA(Hidden),
    ECC_GameTraceChannel4 UMETA(Hidden),
    ECC_GameTraceChannel5 UMETA(Hidden),
    ECC_GameTraceChannel6 UMETA(Hidden),
    ECC_GameTraceChannel7 UMETA(Hidden),
    ECC_GameTraceChannel8 UMETA(Hidden),
    ECC_GameTraceChannel9 UMETA(Hidden),
    ECC_GameTraceChannel10 UMETA(Hidden),
    ECC_GameTraceChannel11 UMETA(Hidden),
    ECC_GameTraceChannel12 UMETA(Hidden),
    ECC_GameTraceChannel13 UMETA(Hidden),
    ECC_GameTraceChannel14 UMETA(Hidden),
    ECC_GameTraceChannel15 UMETA(Hidden),
    ECC_GameTraceChannel16 UMETA(Hidden),
    ECC_GameTraceChannel17 UMETA(Hidden),
    ECC_GameTraceChannel18 UMETA(Hidden),
    
    // NOTE!!!! THESE ARE BEING DEPRECATED BUT STILL THERE FOR BLUEPRINT. PLEASE DO NOT USE THEM IN CODE
 
    ECC_OverlapAll_Deprecated UMETA(Hidden),
    ECC_MAX,
};
 
DECLARE_DELEGATE_OneParam(FOnConstraintBroken, int32 /*ConstraintIndex*/);
DECLARE_DELEGATE_ThreeParams(FOnConstraintViolated, int32 /*ConstraintIndex*/, float /*LinearViolation*/, float /*AngularViolation*/);
DECLARE_DELEGATE_OneParam(FOnPlasticDeformation, int32 /*ConstraintIndex*/);
 
#define COLLISION_GIZMO ECC_EngineTraceChannel1
 
UENUM(BlueprintType)
enum EOverlapFilterOption : int
{
    OverlapFilter_All UMETA(DisplayName="AllObjects"),
    OverlapFilter_DynamicOnly UMETA(DisplayName="AllDynamicObjects"),
    OverlapFilter_StaticOnly UMETA(DisplayName="AllStaticObjects"),
};
 
UENUM(BlueprintType)
enum EObjectTypeQuery : int
{
    ObjectTypeQuery1 UMETA(Hidden), 
    ObjectTypeQuery2 UMETA(Hidden), 
    ObjectTypeQuery3 UMETA(Hidden), 
    ObjectTypeQuery4 UMETA(Hidden), 
    ObjectTypeQuery5 UMETA(Hidden), 
    ObjectTypeQuery6 UMETA(Hidden), 
    ObjectTypeQuery7 UMETA(Hidden), 
    ObjectTypeQuery8 UMETA(Hidden), 
    ObjectTypeQuery9 UMETA(Hidden), 
    ObjectTypeQuery10 UMETA(Hidden), 
    ObjectTypeQuery11 UMETA(Hidden), 
    ObjectTypeQuery12 UMETA(Hidden), 
    ObjectTypeQuery13 UMETA(Hidden), 
    ObjectTypeQuery14 UMETA(Hidden), 
    ObjectTypeQuery15 UMETA(Hidden), 
    ObjectTypeQuery16 UMETA(Hidden), 
    ObjectTypeQuery17 UMETA(Hidden), 
    ObjectTypeQuery18 UMETA(Hidden), 
    ObjectTypeQuery19 UMETA(Hidden), 
    ObjectTypeQuery20 UMETA(Hidden), 
    ObjectTypeQuery21 UMETA(Hidden), 
    ObjectTypeQuery22 UMETA(Hidden), 
    ObjectTypeQuery23 UMETA(Hidden), 
    ObjectTypeQuery24 UMETA(Hidden), 
    ObjectTypeQuery25 UMETA(Hidden), 
    ObjectTypeQuery26 UMETA(Hidden), 
    ObjectTypeQuery27 UMETA(Hidden), 
    ObjectTypeQuery28 UMETA(Hidden), 
    ObjectTypeQuery29 UMETA(Hidden), 
    ObjectTypeQuery30 UMETA(Hidden), 
    ObjectTypeQuery31 UMETA(Hidden), 
    ObjectTypeQuery32 UMETA(Hidden),
 
    ObjectTypeQuery_MAX UMETA(Hidden)
};
 
UENUM(BlueprintType)
enum ETraceTypeQuery : int
{
    TraceTypeQuery1 UMETA(Hidden), 
    TraceTypeQuery2 UMETA(Hidden), 
    TraceTypeQuery3 UMETA(Hidden), 
    TraceTypeQuery4 UMETA(Hidden), 
    TraceTypeQuery5 UMETA(Hidden), 
    TraceTypeQuery6 UMETA(Hidden), 
    TraceTypeQuery7 UMETA(Hidden), 
    TraceTypeQuery8 UMETA(Hidden), 
    TraceTypeQuery9 UMETA(Hidden), 
    TraceTypeQuery10 UMETA(Hidden), 
    TraceTypeQuery11 UMETA(Hidden), 
    TraceTypeQuery12 UMETA(Hidden), 
    TraceTypeQuery13 UMETA(Hidden), 
    TraceTypeQuery14 UMETA(Hidden), 
    TraceTypeQuery15 UMETA(Hidden), 
    TraceTypeQuery16 UMETA(Hidden), 
    TraceTypeQuery17 UMETA(Hidden), 
    TraceTypeQuery18 UMETA(Hidden), 
    TraceTypeQuery19 UMETA(Hidden), 
    TraceTypeQuery20 UMETA(Hidden), 
    TraceTypeQuery21 UMETA(Hidden), 
    TraceTypeQuery22 UMETA(Hidden), 
    TraceTypeQuery23 UMETA(Hidden), 
    TraceTypeQuery24 UMETA(Hidden), 
    TraceTypeQuery25 UMETA(Hidden), 
    TraceTypeQuery26 UMETA(Hidden), 
    TraceTypeQuery27 UMETA(Hidden), 
    TraceTypeQuery28 UMETA(Hidden), 
    TraceTypeQuery29 UMETA(Hidden), 
    TraceTypeQuery30 UMETA(Hidden), 
    TraceTypeQuery31 UMETA(Hidden), 
    TraceTypeQuery32 UMETA(Hidden),
 
    TraceTypeQuery_MAX  UMETA(Hidden)
};
 
UENUM(BlueprintType, meta=(ScriptName="CollisionResponseType"))
enum ECollisionResponse : int
{
    ECR_Ignore UMETA(DisplayName="Ignore"),
    ECR_Overlap UMETA(DisplayName="Overlap"),
    ECR_Block UMETA(DisplayName="Block"),
    ECR_MAX,
};
 
UENUM()
enum EFilterInterpolationType : int
{
    BSIT_Average UMETA(DisplayName = "Averaged"),
    BSIT_Linear UMETA(DisplayName = "Linear"),
    BSIT_Cubic UMETA(DisplayName = "Cubic"),
    BSIT_EaseInOut UMETA(DisplayName = "Ease In/Out"),
    BSIT_ExponentialDecay UMETA(DisplayName = "Exponential"),
    BSIT_SpringDamper UMETA(DisplayName = "Spring Damper"),
    BSIT_MAX
};
 
namespace EWorldType
{
    enum Type
    {
        None,
 
        Game,
 
        Editor,
 
        PIE,
 
        EditorPreview,
 
        GamePreview,
 
        GameRPC,
 
        Inactive
    };
}
 
ENGINE_API const TCHAR* LexToString(const EWorldType::Type Value);
 
enum class EFlushLevelStreamingType : uint8
{
    None,           
    Full,           
    Visibility,     
};
 
USTRUCT()
struct FResponseChannel
{
    GENERATED_BODY()
 
    
     UPROPERTY(EditAnywhere, Category = FResponseChannel)
    FName Channel;
 
    UPROPERTY(EditAnywhere, Category = FResponseChannel)
    TEnumAsByte<enum ECollisionResponse> Response;
 
    FResponseChannel()
        : Response(ECR_Block) {}
 
    FResponseChannel( FName InChannel, ECollisionResponse InResponse )
        : Channel(InChannel)
        , Response(InResponse) {}
 
    bool operator==(const FResponseChannel& Other) const
    {
        return Channel == Other.Channel && Response == Other.Response;
    }
};
 
 
USTRUCT(BlueprintType)
struct FCollisionResponseContainer
{
    GENERATED_BODY()
 
#if !CPP      //noexport property
 
    // Reserved Engine Trace Channels
    // 
    // Note -   If you change this (add/remove/modify) 
    //          you should make sure it matches with ECollisionChannel (including DisplayName)
    //          They has to be mirrored if serialized
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer, meta=(DisplayName="WorldStatic"))
    TEnumAsByte<enum ECollisionResponse> WorldStatic;    // 0
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer, meta=(DisplayName="WorldDynamic"))
    TEnumAsByte<enum ECollisionResponse> WorldDynamic;    // 1.
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer, meta=(DisplayName="Pawn"))
    TEnumAsByte<enum ECollisionResponse> Pawn;          // 2
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer, meta=(DisplayName="Visibility"))
    TEnumAsByte<enum ECollisionResponse> Visibility;    // 3
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer, meta=(DisplayName="Camera"))
    TEnumAsByte<enum ECollisionResponse> Camera;    // 4
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer, meta=(DisplayName="PhysicsBody"))
    TEnumAsByte<enum ECollisionResponse> PhysicsBody;    // 5
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer, meta=(DisplayName="Vehicle"))
    TEnumAsByte<enum ECollisionResponse> Vehicle;    // 6
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer, meta=(DisplayName="Destructible"))
    TEnumAsByte<enum ECollisionResponse> Destructible;    // 7
 
 
    // Unspecified Engine Trace Channels
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> EngineTraceChannel1;    // 8
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> EngineTraceChannel2;    // 9
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> EngineTraceChannel3;    // 10
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> EngineTraceChannel4;    // 11
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> EngineTraceChannel5;    // 12
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> EngineTraceChannel6;    // 13
 
    // in order to use this custom channels
    // we recommend to define in your local file
    // - i.e. #define COLLISION_WEAPON      ECC_GameTraceChannel1
    // and make sure you customize these it in INI file by
    // 
    // in DefaultEngine.ini
    //  
    // [/Script/Engine.CollisionProfile]
    // GameTraceChannel1="Weapon"
    // 
    // also in the INI file, you can override collision profiles that are defined by simply redefining
    // note that Weapon isn't defined in the BaseEngine.ini file, but "Trigger" is defined in Engine
    // +Profiles=(Name="Trigger",CollisionEnabled=QueryOnly,ObjectTypeName=WorldDynamic, DefaultResponse=ECR_Overlap, CustomResponses=((Channel=Visibility, Response=ECR_Ignore), (Channel=Weapon, Response=ECR_Ignore)))
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel1;    // 14
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel2;    // 15
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel3;    // 16
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel4;    // 17
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel5;    // 18
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel6;    // 19
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel7;    // 20
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel8;    // 21
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel9;    // 22
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel10;    // 23
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel11;    // 24
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel12;    // 25
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel13;    // 26
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel14;    // 27
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel15;    // 28
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel16;    // 28
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel17;    // 30
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=CollisionResponseContainer)
    TEnumAsByte<enum ECollisionResponse> GameTraceChannel18;    // 31
 
#endif
 
    union
    {
        struct
        {
            //Reserved Engine Trace Channels
            uint8 WorldStatic;          // 0
            uint8 WorldDynamic;         // 1
            uint8 Pawn;                 // 2
            uint8 Visibility;           // 3
            uint8 Camera;               // 4
            uint8 PhysicsBody;          // 5
            uint8 Vehicle;              // 6
            uint8 Destructible;         // 7
 
            // Unspecified Engine Trace Channels
            uint8 EngineTraceChannel1;   // 8
            uint8 EngineTraceChannel2;   // 9
            uint8 EngineTraceChannel3;   // 10
            uint8 EngineTraceChannel4;   // 11
            uint8 EngineTraceChannel5;   // 12
            uint8 EngineTraceChannel6;   // 13
 
            // Unspecified Game Trace Channels
            uint8 GameTraceChannel1;     // 14
            uint8 GameTraceChannel2;     // 15
            uint8 GameTraceChannel3;     // 16
            uint8 GameTraceChannel4;     // 17
            uint8 GameTraceChannel5;     // 18
            uint8 GameTraceChannel6;     // 19
            uint8 GameTraceChannel7;     // 20
            uint8 GameTraceChannel8;     // 21
            uint8 GameTraceChannel9;     // 22
            uint8 GameTraceChannel10;    // 23
            uint8 GameTraceChannel11;    // 24 
            uint8 GameTraceChannel12;    // 25
            uint8 GameTraceChannel13;    // 26
            uint8 GameTraceChannel14;    // 27
            uint8 GameTraceChannel15;    // 28
            uint8 GameTraceChannel16;    // 29 
            uint8 GameTraceChannel17;    // 30
            uint8 GameTraceChannel18;    // 31
        };
        uint8 EnumArray[32];
    };
 
    ENGINE_API FCollisionResponseContainer();
    ENGINE_API FCollisionResponseContainer(ECollisionResponse DefaultResponse);
 
    ENGINE_API bool SetResponse(ECollisionChannel Channel, ECollisionResponse NewResponse);
 
    ENGINE_API bool SetAllChannels(ECollisionResponse NewResponse);
 
    ENGINE_API bool ReplaceChannels(ECollisionResponse OldResponse, ECollisionResponse NewResponse);
 
    inline ECollisionResponse GetResponse(ECollisionChannel Channel) const { return (ECollisionResponse)EnumArray[Channel]; }
 
    ENGINE_API void UpdateResponsesFromArray(TArray<FResponseChannel> & ChannelResponses);
    ENGINE_API int32 FillArrayFromResponses(TArray<FResponseChannel> & ChannelResponses);
 
    static ENGINE_API FCollisionResponseContainer CreateMinContainer(const FCollisionResponseContainer& A, const FCollisionResponseContainer& B);
 
    static const struct FCollisionResponseContainer& GetDefaultResponseContainer() { return DefaultResponseContainer; }
 
    bool operator==(const FCollisionResponseContainer& Other) const
    {
        return FMemory::Memcmp(EnumArray, Other.EnumArray, sizeof(Other.EnumArray)) == 0;
    }
    bool operator!=(const FCollisionResponseContainer& Other) const
    {
        return FMemory::Memcmp(EnumArray, Other.EnumArray, sizeof(Other.EnumArray)) != 0;
    }
 
private:
 
    static ENGINE_API FCollisionResponseContainer DefaultResponseContainer;
 
    friend class UCollisionProfile;
};
 
UENUM()
enum ETimelineSigType : int
{
    ETS_EventSignature,
    ETS_FloatSignature,
    ETS_VectorSignature,
    ETS_LinearColorSignature,
    ETS_InvalidSignature,
    ETS_MAX,
};
 
UENUM(BlueprintType)
namespace ECollisionEnabled 
{ 
    enum Type : int
    { 
        NoCollision UMETA(DisplayName="No Collision"), 
        QueryOnly UMETA(DisplayName="Query Only (No Physics Collision)"),
        PhysicsOnly UMETA(DisplayName="Physics Only (No Query Collision)"),
        QueryAndPhysics UMETA(DisplayName="Collision Enabled (Query and Physics)"),
        ProbeOnly UMETA(DisplayName="Probe Only (Contact Data, No Query or Physics Collision)"),
        QueryAndProbe UMETA(DisplayName="Query and Probe (Query Collision and Contact Data, No Physics Collision)")
    }; 
} 
 
struct FCollisionEnabledMask
{
    int8 Bits;
 
    ENGINE_API FCollisionEnabledMask(int8 InBits = 0);
    ENGINE_API FCollisionEnabledMask(ECollisionEnabled::Type CollisionEnabled);
 
    ENGINE_API operator int8() const;
    ENGINE_API operator bool() const;
    ENGINE_API FCollisionEnabledMask operator&(const FCollisionEnabledMask Other) const;
    ENGINE_API FCollisionEnabledMask operator&(const ECollisionEnabled::Type Other) const;
    ENGINE_API FCollisionEnabledMask operator|(const FCollisionEnabledMask Other) const;
    ENGINE_API FCollisionEnabledMask operator|(const ECollisionEnabled::Type Other) const;
};
 
extern FCollisionEnabledMask ENGINE_API operator&(const ECollisionEnabled::Type A, const ECollisionEnabled::Type B);
extern FCollisionEnabledMask ENGINE_API operator&(const ECollisionEnabled::Type A, const FCollisionEnabledMask B);
extern FCollisionEnabledMask ENGINE_API operator|(const ECollisionEnabled::Type A, const ECollisionEnabled::Type B);
extern FCollisionEnabledMask ENGINE_API operator|(const ECollisionEnabled::Type A, const FCollisionEnabledMask B);
 
inline bool CollisionEnabledHasPhysics(ECollisionEnabled::Type CollisionEnabled)
{
    return  (CollisionEnabled == ECollisionEnabled::PhysicsOnly) ||
            (CollisionEnabled == ECollisionEnabled::QueryAndPhysics);
}
 
inline bool CollisionEnabledHasQuery(ECollisionEnabled::Type CollisionEnabled)
{
    return  (CollisionEnabled == ECollisionEnabled::QueryOnly) ||
            (CollisionEnabled == ECollisionEnabled::QueryAndPhysics) ||
            (CollisionEnabled == ECollisionEnabled::QueryAndProbe);
}
 
inline bool CollisionEnabledHasProbe(ECollisionEnabled::Type CollisionEnabled)
{
    return (CollisionEnabled == ECollisionEnabled::ProbeOnly) ||
            (CollisionEnabled == ECollisionEnabled::QueryAndProbe);
}
 
inline ECollisionEnabled::Type CollisionEnabledIntersection(ECollisionEnabled::Type CollisionEnabledA, ECollisionEnabled::Type CollisionEnabledB)
{
    // Combine collision two enabled data.
    //
    // The intersection follows the following rules:
    //
    // * For the result to have Query, both data must have Query
    // * For the result to have Probe, either data must have Probe
    // * For the result to have Physics, both data must have Physics and the result must not have Probe
    //
    // This way if an object is query-only, for example, but one of its shapes is query-and-physics,
    // the object's settings win and the shape ends up being query-only. And if the object is marked
    // as physics, but the child is marked as probe (or vice versa), use probe.
    //
    // The following matrix represents the intersection relationship.
    // NOTE: The order of types must match the order declared in ECollisionEnabled!
    using namespace ECollisionEnabled;
    static constexpr ECollisionEnabled::Type IntersectionMatrix[5][5] = {
        /*                 |        QueryOnly       PhysicsOnly     QueryAndPhysics     ProbeOnly     QueryAndProbe   */
        /*-----------------+------------------------------------------------------------------------------------------*/
        /* QueryOnly       | */ {   QueryOnly,      NoCollision,    QueryOnly,          NoCollision,  QueryOnly       },
        /* PhysicsOnly     | */ {   NoCollision,    PhysicsOnly,    PhysicsOnly,        ProbeOnly,    ProbeOnly       },
        /* QueryAndPhysics | */ {   QueryOnly,      PhysicsOnly,    QueryAndPhysics,    ProbeOnly,    QueryAndProbe   },
        /* ProbeOnly       | */ {   NoCollision,    ProbeOnly,      ProbeOnly,          ProbeOnly,    ProbeOnly       },
        /* QueryAndProbe   | */ {   QueryOnly,      ProbeOnly,      QueryAndProbe,      ProbeOnly,    QueryAndProbe   }
    };
 
    // Subtract 1 because the first index is NoCollision.
    // If both indices indicate _some_ collision setting (ie, greater than -1),
    // lookup their intersection setting in the matrix.
    const int32 IndexA = (int32)CollisionEnabledA - 1;
    const int32 IndexB = (int32)CollisionEnabledB - 1;
    if (IndexA >= 0 && IndexB >= 0)
    {
        return IntersectionMatrix[IndexA][IndexB];
    }
 
    // Either of the two settings were set to NoCollision which trumps all
    return ECollisionEnabled::NoCollision;
}
 
inline ECollisionEnabled::Type CollisionEnabledFromFlags(const bool bQuery, const bool bPhysics, const bool bProbe)
{
    // Convert to ints for bit manipulation
    const int32 QueryBit = static_cast<uint32>(bQuery);
    const int32 PhysicsBit = static_cast<uint32>(bPhysics);
    const int32 ProbeBit = static_cast<uint32>(bProbe);
 
    // NOTE:
    // We use &~ between physics and probe because we cannot have a case with
    // both enabled, and in every case probe "beats" physics. See the collision
    // type rules outlined in the comments in CollisionEnabledIntersection.
    //
    // index    type              bits: probe/physics/query
    // ----------------------------------------------------
    // 0        NoCollision       000
    // 1        QueryOnly         001
    // 2        PhysicsOnly       010
    // 3        QueryAndPhysics   011
    // 4        ProbeOnly         100 (& 110)
    // 5        QueryAndProbe     101 (& 111)
    return static_cast<ECollisionEnabled::Type>(
        (QueryBit << 0) |
        (PhysicsBit & (~ProbeBit)) << 1 |
        (ProbeBit << 2));
}
 
inline void CollisionEnabledToFlags(const ECollisionEnabled::Type CollisionEnabled, bool& bQuery, bool& bPhysics, bool& bProbe)
{
    const int32 Bits = static_cast<int32>(CollisionEnabled);
    bQuery   = ((Bits & 0x1) != 0);
    bPhysics = ((Bits & 0x2) != 0);
    bProbe   = ((Bits & 0x4) != 0);
}
 
enum class ESleepEvent : uint8
{
    SET_Wakeup,
    SET_Sleep
};
 
USTRUCT()
struct FRigidBodyErrorCorrection
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category = "Replication")
    float PingExtrapolation;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float PingLimit;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float ErrorPerLinearDifference;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float ErrorPerAngularDifference;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float MaxRestoredStateError;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float MaxLinearHardSnapDistance;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float PositionLerp;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float AngleLerp;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float LinearVelocityCoefficient;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float AngularVelocityCoefficient;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float ErrorAccumulationSeconds;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float ErrorAccumulationDistanceSq;
 
    UPROPERTY(EditAnywhere, Category = "Replication")
    float ErrorAccumulationSimilarity;
 
    FRigidBodyErrorCorrection()
        : PingExtrapolation(0.1f)
        , PingLimit(100.f)
        , ErrorPerLinearDifference(1.0f)
        , ErrorPerAngularDifference(1.0f)
        , MaxRestoredStateError(1.0f)
        , MaxLinearHardSnapDistance(400.f)
        , PositionLerp(0.0f)
        , AngleLerp(0.4f)
        , LinearVelocityCoefficient(100.0f)
        , AngularVelocityCoefficient(10.0f)
        , ErrorAccumulationSeconds(0.5f)
        , ErrorAccumulationDistanceSq(15.0f)
        , ErrorAccumulationSimilarity(100.0f)
    { }
};
 
USTRUCT()
struct FRigidBodyContactInfo
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FVector ContactPosition;
 
    UPROPERTY()
    FVector ContactNormal;
 
    UPROPERTY()
    float ContactPenetration;
 
    UPROPERTY()
    bool bContactProbe;
 
    UPROPERTY()
    TObjectPtr<class UPhysicalMaterial> PhysMaterial[2];
 
 
    FRigidBodyContactInfo()
        : ContactPosition(ForceInit)
        , ContactNormal(ForceInit)
        , ContactPenetration(0)
        , bContactProbe(false)
    {
        for (int32 ElementIndex = 0; ElementIndex < 2; ElementIndex++)
        {
            PhysMaterial[ElementIndex] = nullptr;
        }
    }
 
    FRigidBodyContactInfo(  const FVector& InContactPosition, 
                            const FVector& InContactNormal, 
                            float InPenetration, 
                            bool bInProbe,
                            UPhysicalMaterial* InPhysMat0, 
                            UPhysicalMaterial* InPhysMat1 )
        : ContactPosition(InContactPosition)
        , ContactNormal(InContactNormal)
        , ContactPenetration(InPenetration)
        , bContactProbe(bInProbe)
    {
        PhysMaterial[0] = InPhysMat0;
        PhysMaterial[1] = InPhysMat1;
    }
 
    ENGINE_API void SwapOrder();
};
 
 
USTRUCT()
struct FCollisionImpactData
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    TArray<struct FRigidBodyContactInfo> ContactInfos;
 
    UPROPERTY()
    FVector TotalNormalImpulse;
 
    UPROPERTY()
    FVector TotalFrictionImpulse;
 
    UPROPERTY()
    bool bIsVelocityDeltaUnderThreshold;
 
    FCollisionImpactData()
    : TotalNormalImpulse(ForceInit)
    , TotalFrictionImpulse(ForceInit)
    , bIsVelocityDeltaUnderThreshold(true)
    {}
 
    ENGINE_API void SwapContactOrders();
};
 
USTRUCT(BlueprintType)
struct FFractureEffect
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=FractureEffect)
    TObjectPtr<class UParticleSystem> ParticleSystem;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=FractureEffect)
    TObjectPtr<class USoundBase> Sound;
 
    FFractureEffect()
        : ParticleSystem(nullptr)
        , Sound(nullptr)
    { }
};
 
USTRUCT(BlueprintType)
struct FBasedPosition
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BasedPosition)
    TObjectPtr<class AActor> Base;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BasedPosition)
    FVector Position;
 
    UPROPERTY()
    mutable FVector CachedBaseLocation;
 
    UPROPERTY()
    mutable FRotator CachedBaseRotation;
 
    UPROPERTY()
    mutable FVector CachedTransPosition;
 
    ENGINE_API FBasedPosition();
    ENGINE_API explicit FBasedPosition( class AActor *InBase, const FVector& InPosition );
 
    ENGINE_API FVector operator*() const;
 
    ENGINE_API void Set( class AActor* InBase, const FVector& InPosition );
 
    ENGINE_API void Clear();
 
    friend FArchive& operator<<( FArchive& Ar, FBasedPosition& T );
};
 
struct FRotationConversionCache
{
    FRotationConversionCache()
    {
    }
 
    inline FQuat RotatorToQuat(const FRotator& InRotator) const
    {
        FPayload& Payload = GetOrCreatePayload();
        if (LIKELY(Payload.CachedRotator != InRotator))
        {
            Payload.CachedRotator = InRotator.GetNormalized();
            Payload.CachedQuat = Payload.CachedRotator.Quaternion();
        }
        return Payload.CachedQuat;
    }
 
    inline FQuat RotatorToQuat_ReadOnly(const FRotator& InRotator) const
    {
        if (LIKELY(PayloadPtr.IsValid()))
        {
            FPayload& Payload = *PayloadPtr;
            if (LIKELY(Payload.CachedRotator == InRotator))
            {
                return Payload.CachedQuat;
            }
        }
        return InRotator.Quaternion();
    }
 
    inline FRotator QuatToRotator(const FQuat& InQuat) const
    {
        FPayload& Payload = GetOrCreatePayload();
        if (LIKELY(Payload.CachedQuat != InQuat))
        {
            Payload.CachedQuat = InQuat.GetNormalized();
            Payload.CachedRotator = Payload.CachedQuat.Rotator();
        }
        return Payload.CachedRotator;
    }
 
    inline FRotator QuatToRotator_ReadOnly(const FQuat& InQuat) const
    {
        if (LIKELY(PayloadPtr.IsValid()))
        {
            FPayload& Payload = *PayloadPtr;
            if (LIKELY(Payload.CachedQuat == InQuat))
            {
                return Payload.CachedRotator;
            }
        }
        return InQuat.GetNormalized().Rotator();
    }
 
    inline FRotator NormalizedQuatToRotator(const FQuat& InNormalizedQuat) const
    {
        FPayload& Payload = GetOrCreatePayload();
        if (LIKELY(Payload.CachedQuat != InNormalizedQuat))
        {
            Payload.CachedQuat = InNormalizedQuat;
            Payload.CachedRotator = InNormalizedQuat.Rotator();
        }
        return Payload.CachedRotator;
    }
 
    inline FRotator NormalizedQuatToRotator_ReadOnly(const FQuat& InNormalizedQuat) const
    {
        if (LIKELY(PayloadPtr.IsValid()))
        {
            FPayload& Payload = *PayloadPtr;
            if (LIKELY(Payload.CachedQuat == InNormalizedQuat))
            {
                return Payload.CachedRotator;
            }
        }
        return InNormalizedQuat.Rotator();
    }
 
    inline FQuat GetCachedQuat() const
    {
        if (UNLIKELY(!PayloadPtr.IsValid()))
        {
            return FQuat::Identity;
        }
        return PayloadPtr->CachedQuat;
    }
 
    inline FRotator GetCachedRotator() const
    {
        if (UNLIKELY(!PayloadPtr.IsValid()))
        {
            return FRotator::ZeroRotator;
        }
        return PayloadPtr->CachedRotator;
    }
 
    FRotationConversionCache& operator=(const FRotationConversionCache& Other)
    {
        if (LIKELY(PayloadPtr.IsValid() || Other.PayloadPtr.IsValid()))
        {
            FPayload& Payload = GetOrCreatePayload();
            Payload.CachedQuat = Other.GetCachedQuat();
            Payload.CachedRotator = Other.GetCachedRotator();
        }
        return *this;
    }
 
private:
 
    struct FPayload
    {
        mutable FQuat               CachedQuat;     // FQuat matching CachedRotator such that CachedQuat.Rotator() == CachedRotator.
        mutable FRotator            CachedRotator;  // FRotator matching CachedQuat such that CachedRotator.Quaternion() == CachedQuat.
 
        FPayload()
        : CachedQuat(FQuat::Identity)
        , CachedRotator(FRotator::ZeroRotator)
        {}
    };
 
    inline FPayload&                GetOrCreatePayload() const
    {
        if (UNLIKELY(!PayloadPtr.IsValid()))
        {
            PayloadPtr = MakeUnique<FPayload>();
        }
        return *PayloadPtr;
    }
 
    mutable TUniquePtr<FPayload>    PayloadPtr;
};
 
USTRUCT(BlueprintType)
struct FSubtitleCue
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=SubtitleCue)
    FText Text;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=SubtitleCue)
    float Time;
 
    FSubtitleCue()
        : Time(0)
    { }
};
 
USTRUCT()
struct FLightmassLightSettings
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=Lightmass, meta=(UIMin = "0.0", UIMax = "4.0"))
    float IndirectLightingSaturation;
 
    UPROPERTY(EditAnywhere, Category=Lightmass, meta=(UIMin = "0.1", UIMax = "4.0"))
    float ShadowExponent;
 
    UPROPERTY(EditAnywhere, Category=Lightmass)
    bool bUseAreaShadowsForStationaryLight;
 
    FLightmassLightSettings()
        : IndirectLightingSaturation(1.0f)
        , ShadowExponent(2.0f)
        , bUseAreaShadowsForStationaryLight(false)
    { }
};
 
USTRUCT()
struct FLightmassPointLightSettings : public FLightmassLightSettings
{
    GENERATED_BODY()
};
 
USTRUCT()
struct FLightmassDirectionalLightSettings : public FLightmassLightSettings
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=Lightmass, meta=(UIMin = ".0001", UIMax = "5"))
    float LightSourceAngle;
 
    FLightmassDirectionalLightSettings()
        : LightSourceAngle(1.0f)
    {
    }
};
 
USTRUCT()
struct FLightmassPrimitiveSettings
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=Lightmass)
    uint32 bUseTwoSidedLighting:1;
 
    UPROPERTY(EditAnywhere, Category=Lightmass)
    uint32 bShadowIndirectOnly:1;
 
    UPROPERTY(EditAnywhere, Category=Lightmass)
    uint32 bUseEmissiveForStaticLighting:1;
 
    UPROPERTY(EditAnywhere, Category=Lightmass)
    uint32 bUseVertexNormalForHemisphereGather:1;
 
    UPROPERTY()
    float EmissiveLightFalloffExponent;
 
    UPROPERTY()
    float EmissiveLightExplicitInfluenceRadius;
 
    UPROPERTY(EditAnywhere, Category=Lightmass)
    float EmissiveBoost;
 
    UPROPERTY(EditAnywhere, Category=Lightmass)
    float DiffuseBoost;
 
    UPROPERTY(EditAnywhere, Category=Lightmass)
    float FullyOccludedSamplesFraction;
 
    FLightmassPrimitiveSettings()
    {
        bUseTwoSidedLighting = false;
        bShadowIndirectOnly = false;
        bUseEmissiveForStaticLighting = false;
        bUseVertexNormalForHemisphereGather = false;
        EmissiveLightFalloffExponent = 8.0f;
        EmissiveLightExplicitInfluenceRadius = 0.0f;
        EmissiveBoost = 1.0f;
        DiffuseBoost = 1.0f;
        FullyOccludedSamplesFraction = 1.0f;
    }
 
    friend bool operator==(const FLightmassPrimitiveSettings& A, const FLightmassPrimitiveSettings& B)
    {
        //@todo Do we want a little 'leeway' in joining 
        if ((A.bUseTwoSidedLighting != B.bUseTwoSidedLighting) ||
            (A.bShadowIndirectOnly != B.bShadowIndirectOnly) || 
            (A.bUseEmissiveForStaticLighting != B.bUseEmissiveForStaticLighting) || 
            (A.bUseVertexNormalForHemisphereGather != B.bUseVertexNormalForHemisphereGather) || 
            (fabsf(A.EmissiveLightFalloffExponent - B.EmissiveLightFalloffExponent) > UE_SMALL_NUMBER) ||
            (fabsf(A.EmissiveLightExplicitInfluenceRadius - B.EmissiveLightExplicitInfluenceRadius) > UE_SMALL_NUMBER) ||
            (fabsf(A.EmissiveBoost - B.EmissiveBoost) > UE_SMALL_NUMBER) ||
            (fabsf(A.DiffuseBoost - B.DiffuseBoost) > UE_SMALL_NUMBER) ||
            (fabsf(A.FullyOccludedSamplesFraction - B.FullyOccludedSamplesFraction) > UE_SMALL_NUMBER))
        {
            return false;
        }
        return true;
    }
 
    // Functions.
    friend FArchive& operator<<(FArchive& Ar, FLightmassPrimitiveSettings& Settings);
};
 
USTRUCT()
struct FLightmassDebugOptions
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bDebugMode:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bStatsEnabled:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bGatherBSPSurfacesAcrossComponents:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    float CoplanarTolerance;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bUseImmediateImport:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bImmediateProcessMappings:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bSortMappings:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bDumpBinaryFiles:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bDebugMaterials:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bPadMappings:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bDebugPaddings:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bOnlyCalcDebugTexelMappings:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bUseRandomColors:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bColorBordersGreen:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    uint32 bColorByExecutionTime:1;
 
    UPROPERTY(EditAnywhere, Category=LightmassDebugOptions)
    float ExecutionTimeDivisor;
 
    ENGINE_API FLightmassDebugOptions();
};
 
USTRUCT()
struct FSwarmDebugOptions
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=SwarmDebugOptions)
    uint32 bDistributionEnabled:1;
 
    UPROPERTY(EditAnywhere, Category=SwarmDebugOptions)
    uint32 bForceContentExport:1;
 
    UPROPERTY()
    uint32 bInitialized:1;
 
    FSwarmDebugOptions()
        : bDistributionEnabled(true)
        , bForceContentExport(false)
        , bInitialized(false)
    {
    }
 
    //@todo For some reason, the global instance is not initializing to the default settings...
    // Be sure to update this function to properly set the desired initial values!!!!
    void Touch();
};
 
UENUM()
enum ELightMapPaddingType : int
{
    LMPT_NormalPadding,
    LMPT_PrePadding,
    LMPT_NoPadding
};
 
UENUM()
enum EShadowMapFlags : int
{
    SMF_None            = 0,
    SMF_Streamed        = 0x00000001
};
 
UENUM()
enum class ETeleportType : uint8
{
    None,
 
    TeleportPhysics,
 
    ResetPhysics,
};
 
inline ETeleportType TeleportFlagToEnum(bool bTeleport) { return bTeleport ? ETeleportType::TeleportPhysics : ETeleportType::None; }
inline bool TeleportEnumToFlag(ETeleportType Teleport) { return ETeleportType::TeleportPhysics == Teleport; }
 
USTRUCT()
struct FMTDResult
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FVector Direction;
 
    UPROPERTY()
    float Distance;
 
    FMTDResult()
    {
        FMemory::Memzero(this, sizeof(FMTDResult));
    }
};
 
USTRUCT()
struct FAnimSlotDesc
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FName SlotName;
 
    UPROPERTY()
    int32 NumChannels;
 
    FAnimSlotDesc()
        : NumChannels(0)
    { }
};
 
UENUM()
enum class EUpdateRateShiftBucket : uint8
{
    ShiftBucket0 = 0,
    ShiftBucket1,
    ShiftBucket2,
    ShiftBucket3,
    ShiftBucket4,
    ShiftBucket5,
    ShiftBucketMax
};
 
USTRUCT()
struct FAnimUpdateRateParameters
{
    GENERATED_BODY()
 
public:
    enum EOptimizeMode : uint8
    {
        TrailMode,
        LookAheadMode,
    };
 
    EOptimizeMode OptimizeMode;
 
    UPROPERTY()
    EUpdateRateShiftBucket ShiftBucket;
 
    UPROPERTY()
    uint8 bInterpolateSkippedFrames : 1;
 
    UPROPERTY()
    uint8 bShouldUseLodMap : 1;
 
    UPROPERTY()
    uint8 bShouldUseMinLod : 1;
 
    UPROPERTY()
    uint8 bSkipUpdate : 1;
 
    UPROPERTY()
    uint8 bSkipEvaluation : 1;
 
    UPROPERTY()
    int32 UpdateRate;
 
    UPROPERTY()
    int32 EvaluationRate;
 
    UPROPERTY(Transient)
    float TickedPoseOffestTime;
 
    UPROPERTY(Transient)
    float AdditionalTime;
 
    float ThisTickDelta;
 
    UPROPERTY()
    int32 BaseNonRenderedUpdateRate;
 
    UPROPERTY()
    int32 MaxEvalRateForInterpolation;
 
    UPROPERTY()
    TArray<float> BaseVisibleDistanceFactorThesholds;
 
    UPROPERTY()
    TMap<int32, int32> LODToFrameSkipMap;
 
    UPROPERTY()
    int32 SkippedUpdateFrames;
 
    UPROPERTY()
    int32 SkippedEvalFrames;
 
public:
 
    FAnimUpdateRateParameters()
        : OptimizeMode(TrailMode)
        , ShiftBucket(EUpdateRateShiftBucket::ShiftBucket0)
        , bInterpolateSkippedFrames(false)
        , bShouldUseLodMap(false)
        , bShouldUseMinLod(false)
        , bSkipUpdate(false)
        , bSkipEvaluation(false)
        , UpdateRate(1)
        , EvaluationRate(1)
        , TickedPoseOffestTime(0.f)
        , AdditionalTime(0.f)
        , ThisTickDelta(0.f)
        , BaseNonRenderedUpdateRate(4)
        , MaxEvalRateForInterpolation(4)
        , SkippedUpdateFrames(0)
        , SkippedEvalFrames(0)
    { 
        BaseVisibleDistanceFactorThesholds.Add(0.24f);
        BaseVisibleDistanceFactorThesholds.Add(0.12f);
    }
 
    void SetTrailMode(float DeltaTime, uint8 UpdateRateShift, int32 NewUpdateRate, int32 NewEvaluationRate, bool bNewInterpSkippedFrames);
 
    void SetLookAheadMode(float DeltaTime, uint8 UpdateRateShift, float LookAheadAmount);
 
    float GetInterpolationAlpha() const;
 
    float GetRootMotionInterp() const;
 
    bool DoEvaluationRateOptimizations() const
    {
        return OptimizeMode == LookAheadMode || EvaluationRate > 1;
    }
 
    bool ShouldSkipUpdate() const
    {
        return bSkipUpdate;
    }
 
    bool ShouldSkipEvaluation() const
    {
        return bSkipEvaluation;
    }
 
    bool ShouldInterpolateSkippedFrames() const
    {
        return bInterpolateSkippedFrames;
    }
 
    float GetTimeAdjustment()
    {
        return AdditionalTime;
    }
 
    FColor GetUpdateRateDebugColor() const
    {
        if (OptimizeMode == TrailMode)
        {
            switch (UpdateRate)
            {
            case 1: return FColor::Red;
            case 2: return FColor::Green;
            case 3: return FColor::Blue;
            }
            return FColor::Black;
        }
        else
        {
            if (bSkipUpdate)
            {
                return FColor::Yellow;
            }
            return FColor::Green;
        }
    }
};
 
USTRUCT(BlueprintType)
struct FPOV
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=POV)
    FVector Location;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=POV)
    FRotator Rotation;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=POV)
    float FOV;
 
    FPOV() 
    : Location(ForceInit),Rotation(ForceInit), FOV(90.0f)
    {}
 
    FPOV(FVector InLocation, FRotator InRotation, float InFOV)
    : Location(InLocation), Rotation(InRotation), FOV(InFOV) 
    {}
 
    // Serializer.
    friend FArchive& operator<<(FArchive& Ar, FPOV& POV)
    {
        return Ar << POV.Location << POV.Rotation << POV.FOV;
    }
};
 
USTRUCT(BlueprintType)
struct FMeshBuildSettings
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bUseMikkTSpace:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bRecomputeNormals:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bRecomputeTangents:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    uint8 bComputeWeightedNormals : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bRemoveDegenerates:1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bBuildReversedIndexBuffer:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    uint8 bUseHighPrecisionTangentBasis:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bUseFullPrecisionUVs:1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings, AdvancedDisplay)
    uint8 bUseBackwardsCompatibleF16TruncUVs:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bGenerateLightmapUVs:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings, meta=(DisplayName="Two-Sided Distance Field Generation"))
    uint8 bGenerateDistanceFieldAsIfTwoSided:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings, meta=(DisplayName="Enable Physical Material Mask"))
    uint8 bSupportFaceRemap : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    int32 MinLightmapResolution;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings, meta=(DisplayName="Source Lightmap Index"))
    int32 SrcLightmapIndex;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings, meta=(DisplayName="Destination Lightmap Index"))
    int32 DstLightmapIndex;
 
    UPROPERTY()
    float BuildScale_DEPRECATED;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings, meta=(DisplayName="Build Scale"))
    FVector BuildScale3D;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    float DistanceFieldResolutionScale;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(NotReplicated)
    float DistanceFieldBias_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    TObjectPtr<class UStaticMesh> DistanceFieldReplacementMesh;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    int32 MaxLumenMeshCards;
 
    FMeshBuildSettings()
        : bUseMikkTSpace(true)
        , bRecomputeNormals(true)
        , bRecomputeTangents(true)
        , bComputeWeightedNormals(false)
        , bRemoveDegenerates(true)
        , bBuildReversedIndexBuffer(true)
        , bUseHighPrecisionTangentBasis(false)
        , bUseFullPrecisionUVs(false)
        , bUseBackwardsCompatibleF16TruncUVs(false)
        , bGenerateLightmapUVs(true)
        , bGenerateDistanceFieldAsIfTwoSided(false)
        , bSupportFaceRemap(false)
        , MinLightmapResolution(64)
        , SrcLightmapIndex(0)
        , DstLightmapIndex(1)
        , BuildScale_DEPRECATED(1.0f)
        , BuildScale3D(1.0f, 1.0f, 1.0f)
        , DistanceFieldResolutionScale(1.0f)
#if WITH_EDITORONLY_DATA
        , DistanceFieldBias_DEPRECATED(0.0f)
#endif
        , DistanceFieldReplacementMesh(nullptr)
        , MaxLumenMeshCards(12)
    { }
 
    bool operator==(const FMeshBuildSettings& Other) const
    {
        return bRecomputeNormals == Other.bRecomputeNormals
            && bRecomputeTangents == Other.bRecomputeTangents
            && bComputeWeightedNormals == Other.bComputeWeightedNormals
            && bUseMikkTSpace == Other.bUseMikkTSpace
            && bRemoveDegenerates == Other.bRemoveDegenerates
            && bBuildReversedIndexBuffer == Other.bBuildReversedIndexBuffer
            && bUseHighPrecisionTangentBasis == Other.bUseHighPrecisionTangentBasis
            && bUseFullPrecisionUVs == Other.bUseFullPrecisionUVs
            && bUseBackwardsCompatibleF16TruncUVs == Other.bUseBackwardsCompatibleF16TruncUVs
            && bGenerateLightmapUVs == Other.bGenerateLightmapUVs
            && MinLightmapResolution == Other.MinLightmapResolution
            && SrcLightmapIndex == Other.SrcLightmapIndex
            && DstLightmapIndex == Other.DstLightmapIndex
            && BuildScale3D == Other.BuildScale3D
            && DistanceFieldResolutionScale == Other.DistanceFieldResolutionScale
            && bGenerateDistanceFieldAsIfTwoSided == Other.bGenerateDistanceFieldAsIfTwoSided
            && DistanceFieldReplacementMesh == Other.DistanceFieldReplacementMesh
            && MaxLumenMeshCards == Other.MaxLumenMeshCards;
    }
 
    bool operator!=(const FMeshBuildSettings& Other) const
    {
        return !(*this == Other);
    }
};
 
USTRUCT(BlueprintType)
struct FSkeletalMeshBuildSettings
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bRecomputeNormals:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bRecomputeTangents:1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bUseMikkTSpace:1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    uint8 bComputeWeightedNormals : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bRemoveDegenerates:1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    uint8 bUseHighPrecisionTangentBasis:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    uint8 bUseHighPrecisionSkinWeights:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings)
    uint8 bUseFullPrecisionUVs:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BuildSettings, AdvancedDisplay)
    uint8 bUseBackwardsCompatibleF16TruncUVs:1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    float ThresholdPosition;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    float ThresholdTangentNormal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    float ThresholdUV;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    float MorphThresholdPosition;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = BuildSettings)
    int32 BoneInfluenceLimit;
 
    FSkeletalMeshBuildSettings()
        : bRecomputeNormals(true)
        , bRecomputeTangents(true)
        , bUseMikkTSpace(true)
        , bComputeWeightedNormals(false)
        , bRemoveDegenerates(true)
        , bUseHighPrecisionTangentBasis(false)
        , bUseHighPrecisionSkinWeights(false)
        , bUseFullPrecisionUVs(false)
        , bUseBackwardsCompatibleF16TruncUVs(false)
        , ThresholdPosition(0.00002f)
        , ThresholdTangentNormal(0.00002f)
        , ThresholdUV(0.0009765625f)
        , MorphThresholdPosition(0.015f)
        , BoneInfluenceLimit(0)
    {}
 
    bool operator==(const FSkeletalMeshBuildSettings& Other) const
    {
        return bRecomputeNormals == Other.bRecomputeNormals
            && bRecomputeTangents == Other.bRecomputeTangents
            && bUseMikkTSpace == Other.bUseMikkTSpace
            && bComputeWeightedNormals == Other.bComputeWeightedNormals
            && bRemoveDegenerates == Other.bRemoveDegenerates
            && bUseHighPrecisionTangentBasis == Other.bUseHighPrecisionTangentBasis
            && bUseHighPrecisionSkinWeights == Other.bUseHighPrecisionSkinWeights
            && bUseFullPrecisionUVs == Other.bUseFullPrecisionUVs
            && bUseBackwardsCompatibleF16TruncUVs == Other.bUseBackwardsCompatibleF16TruncUVs
            && ThresholdPosition == Other.ThresholdPosition
            && ThresholdTangentNormal == Other.ThresholdTangentNormal
            && ThresholdUV == Other.ThresholdUV
            && MorphThresholdPosition == Other.MorphThresholdPosition
            && BoneInfluenceLimit == Other.BoneInfluenceLimit;
    }
 
    bool operator!=(const FSkeletalMeshBuildSettings& Other) const
    {
        return !(*this == Other);
    }
};
 
UENUM()
enum class ENaniteGenerateFallback : uint8
{
    PlatformDefault,
    Enabled,
};
 
UENUM()
enum class ENaniteFallbackTarget : uint8
{
    Auto,
    PercentTriangles,
    RelativeError
};
 
USTRUCT(BlueprintType)
struct FMeshDisplacementMap
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category = Displacement)
    TObjectPtr<class UTexture2D> Texture = nullptr;
 
    UPROPERTY(EditAnywhere, Category = Displacement)
    float Magnitude = 0.0f;
 
    UPROPERTY(EditAnywhere, Category = Displacement)
    float Center = 0.0f;
 
    FMeshDisplacementMap()
    {}
 
    bool operator==(const FMeshDisplacementMap& Other) const
    {
        return Texture      == Other.Texture
            && Magnitude    == Other.Magnitude
            && Center       == Other.Center;
    }
 
    bool operator!=(const FMeshDisplacementMap& Other) const
    {
        return !(*this == Other);
    }
};
 
UENUM()
enum class ENaniteShapePreservation : uint8
{
    None,
    PreserveArea,
    Voxelize
};
 
USTRUCT(BlueprintType)
struct FMeshNaniteSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    uint8 bEnabled : 1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    uint8 bExplicitTangents : 1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    uint8 bLerpUVs : 1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    uint8 bSeparable : 1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    uint8 bVoxelNDF : 1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    uint8 bVoxelOpacity : 1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    ENaniteShapePreservation ShapePreservation = ENaniteShapePreservation::None;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    int32 PositionPrecision = MIN_int32;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    int32 NormalPrecision = -1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    int32 TangentPrecision = -1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    int32 BoneWeightPrecision = -1;
 
    UPROPERTY(EditAnywhere, Category = NaniteSettings)
    uint32 TargetMinimumResidencyInKB = 0;
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    float KeepPercentTriangles = 1.0f;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    float TrimRelativeError = 0.0f;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings, meta = (DisplayName = "Generate Fallback Mesh"))
    ENaniteGenerateFallback GenerateFallback = ENaniteGenerateFallback::PlatformDefault;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    ENaniteFallbackTarget FallbackTarget = ENaniteFallbackTarget::Auto;
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    float FallbackPercentTriangles = 1.0f;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    float FallbackRelativeError = 1.0f;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    float MaxEdgeLengthFactor = 0.0f;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    int32 NumRays = 64;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    int32 VoxelLevel = 0;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    float RayBackUp = 0.0f;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = NaniteSettings)
    int32 DisplacementUVChannel = 0;
 
    UPROPERTY(EditAnywhere, Category = NaniteSettings)
    TArray<FMeshDisplacementMap> DisplacementMaps;
 
    UPROPERTY(VisibleAnywhere, Category = NaniteSettings)
    FNaniteAssemblyData NaniteAssemblyData;
 
    FMeshNaniteSettings()
    : bEnabled(false)
    , bExplicitTangents(false) // TODO: Should this be the default?
    , bLerpUVs(true)
    , bSeparable(false)
    , bVoxelNDF(true)
    , bVoxelOpacity(false)
    {}
 
 
    bool operator==(const FMeshNaniteSettings& Other) const
    {
        if( DisplacementMaps.Num() != Other.DisplacementMaps.Num() )
            return false;
 
        for( int32 i = 0; i < DisplacementMaps.Num(); i++ )
        {
            if( DisplacementMaps[i] != Other.DisplacementMaps[i] )
                return false;
        }
 
        return bEnabled == Other.bEnabled
            && bExplicitTangents == Other.bExplicitTangents
            && bLerpUVs == Other.bLerpUVs
            && ShapePreservation == Other.ShapePreservation
            && PositionPrecision == Other.PositionPrecision
            && NormalPrecision == Other.NormalPrecision
            && TangentPrecision == Other.TangentPrecision
            && BoneWeightPrecision == Other.BoneWeightPrecision
            && TargetMinimumResidencyInKB == Other.TargetMinimumResidencyInKB
            && KeepPercentTriangles == Other.KeepPercentTriangles
            && TrimRelativeError == Other.TrimRelativeError
            && GenerateFallback == Other.GenerateFallback
            && FallbackTarget == Other.FallbackTarget
            && FallbackPercentTriangles == Other.FallbackPercentTriangles
            && FallbackRelativeError == Other.FallbackRelativeError
            && MaxEdgeLengthFactor == Other.MaxEdgeLengthFactor
            && DisplacementUVChannel == Other.DisplacementUVChannel
            && NumRays == Other.NumRays
            && VoxelLevel == Other.VoxelLevel
            && RayBackUp == Other.RayBackUp
            && bSeparable == Other.bSeparable
            && bVoxelNDF == Other.bVoxelNDF
            && bVoxelOpacity == Other.bVoxelOpacity
            && NaniteAssemblyData == Other.NaniteAssemblyData;
    }
 
    bool operator!=(const FMeshNaniteSettings& Other) const
    {
        return !(*this == Other);
    }
};
 
USTRUCT(BlueprintType)
struct FDisplacementScaling
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Displacement, meta = (NoSpinbox = true, ClampMin = "0.0", UIMin = "0.0"))
    float Magnitude;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Displacement, meta = (NoSpinbox = true, ClampMin = "0.0", ClampMax = "1.0", UIMin = "0.0", UIMax = "1.0"))
    float Center;
 
public:
    FDisplacementScaling()
    : Magnitude(4.0f)
    , Center(0.5f)
    {
    }
 
    bool operator==(const FDisplacementScaling& Other) const
    {
        return
            FMath::Abs(Magnitude - Other.Magnitude) <= UE_SMALL_NUMBER &&
            FMath::Abs(Center - Other.Center) <= UE_SMALL_NUMBER;
    }
 
    bool operator!=(const FDisplacementScaling& Other) const
    {
        return !(*this == Other);
    }
};
 
USTRUCT(BlueprintType)
struct FDisplacementFadeRange
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Displacement, meta = (DisplayName="Start Fade Size (Pixels)", NoSpinbox=true, ClampMin="0.0001", UIMin="0.0001"))
    float StartSizePixels;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Displacement, meta = (DisplayName="End Fade Size (Pixels)", NoSpinbox=true, ClampMin="0.0001", UIMin="0.0001"))
    float EndSizePixels;
 
public:
    static FDisplacementFadeRange Invalid()
    {
        return FDisplacementFadeRange(0.0f, 0.0f);
    }
    
    FDisplacementFadeRange()
    : StartSizePixels(4.0f)
    , EndSizePixels(1.0f)
    {
    }
    
    FDisplacementFadeRange(float InStartSizePixels, float InEndSizePixels)
    : StartSizePixels(InStartSizePixels)
    , EndSizePixels(InEndSizePixels)
    {
    }
 
    bool operator==(const FDisplacementFadeRange& Other) const
    {
        return FMath::IsNearlyEqual(StartSizePixels, Other.StartSizePixels) &&
            FMath::IsNearlyEqual(EndSizePixels, Other.EndSizePixels);
    }
 
    bool operator!=(const FDisplacementFadeRange& Other) const
    {
        return !(*this == Other);
    }
 
    bool IsValid() const
    {
        return StartSizePixels > 0.0f && EndSizePixels > 0.0f;
    }
};
 
USTRUCT(BlueprintType)
struct FMeshRayTracingProxySettings
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = RayTracing)
    uint8 bEnabled : 1;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = RayTracing)
    ENaniteFallbackTarget FallbackTarget = ENaniteFallbackTarget::Auto;
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = RayTracing)
    float FallbackPercentTriangles = 1.0f;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = RayTracing)
    float FallbackRelativeError = 2.0f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RayTracing, meta = (NoSpinbox = true, ClampMin = "0.0", ClampMax = "1.0", UIMin = "0.0", UIMax = "1.0"))
    float LOD1PercentTriangles = 0.15f;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = RayTracing, meta = (NoSpinbox = true, ClampMin = "0.0", ClampMax = "1.0", UIMin = "0.0", UIMax = "1.0"))
    float FoliageOverOcclusionBias = 0.0f;
 
public:
    FMeshRayTracingProxySettings()
    : bEnabled(false)
    {}
 
    bool operator==(const FMeshRayTracingProxySettings& Other) const
    {
        return bEnabled == Other.bEnabled &&
            Other.FallbackTarget == FallbackTarget &&
            Other.FallbackPercentTriangles == FallbackPercentTriangles &&
            Other.FallbackRelativeError == FallbackRelativeError &&
            Other.LOD1PercentTriangles == LOD1PercentTriangles &&
            Other.FoliageOverOcclusionBias == FoliageOverOcclusionBias;
    }
 
    bool operator!=(const FMeshRayTracingProxySettings& Other) const
    {
        return !(*this == Other);
    }
};
 
UENUM(BlueprintType)
enum ENetRole : int
{
    ROLE_None UMETA(DisplayName = "None"),
    ROLE_SimulatedProxy UMETA(DisplayName = "Simulated Proxy"),
    ROLE_AutonomousProxy UMETA(DisplayName = "Autonomous Proxy"),
    ROLE_Authority UMETA(DisplayName = "Authority"),
    ROLE_MAX UMETA(Hidden),
};
 
UENUM(BlueprintType)
enum ENetDormancy : int
{
    DORM_Never UMETA(DisplayName = "Never"),
    DORM_Awake UMETA(DisplayName = "Awake"),
    DORM_DormantAll UMETA(DisplayName = "Dormant All"),
    DORM_DormantPartial UMETA(DisplayName = "Dormant Partial"),
    DORM_Initial UMETA(DisplayName = "Initial"),
 
    DORM_MAX UMETA(Hidden),
};
 
UENUM(BlueprintType)
enum class EPhysicsReplicationMode : uint8
{
    Default UMETA(DisplayName = "Default"),
 
    PredictiveInterpolation UMETA(DisplayName = "Predictive Interpolation (WIP)"),
 
    Resimulation UMETA(DisplayName = "Resimulation (WIP)"),
};
 
UENUM()
namespace EAutoReceiveInput
{
    enum Type : int
    {
        Disabled,
        Player0,
        Player1,
        Player2,
        Player3,
        Player4,
        Player5,
        Player6,
        Player7,
    };
}
 
UENUM()
enum class EAutoPossessAI : uint8
{
    Disabled,
    PlacedInWorld,
    Spawned,
    PlacedInWorldOrSpawned,
};
 
UENUM(BlueprintType)
namespace EEndPlayReason
{
    enum Type : int
    {
        Destroyed,
        LevelTransition,
        EndPlayInEditor,
        RemovedFromWorld,
        Quit,
    };
}
 
 
UENUM(BlueprintType)
enum EWalkableSlopeBehavior : int
{
    WalkableSlope_Default       UMETA(DisplayName="Unchanged"),
 
    WalkableSlope_Increase      UMETA(DisplayName="Increase Walkable Slope"),
 
    WalkableSlope_Decrease      UMETA(DisplayName="Decrease Walkable Slope"),
 
    WalkableSlope_Unwalkable    UMETA(DisplayName="Unwalkable"),
    
    WalkableSlope_Max       UMETA(Hidden),
};
 
USTRUCT(BlueprintType)
struct FWalkableSlopeOverride
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=WalkableSlopeOverride)
    TEnumAsByte<EWalkableSlopeBehavior> WalkableSlopeBehavior;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=WalkableSlopeOverride, meta=(ClampMin="0", ClampMax="90", UIMin="0", UIMax="90"))
    float WalkableSlopeAngle;
 
private:
 
    // Cached angle for which we computed a cosine.
    mutable float CachedSlopeAngle;
    // Cached cosine of angle.
    mutable float CachedSlopeCos;
 
public:
 
    FWalkableSlopeOverride()
        : WalkableSlopeBehavior(WalkableSlope_Default)
        , WalkableSlopeAngle(0.f)
        , CachedSlopeAngle(0.f)
        , CachedSlopeCos(1.f)
    { }
 
    FWalkableSlopeOverride(EWalkableSlopeBehavior NewSlopeBehavior, float NewSlopeAngle)
        : WalkableSlopeBehavior(NewSlopeBehavior)
        , WalkableSlopeAngle(NewSlopeAngle)
        , CachedSlopeAngle(0.f)
        , CachedSlopeCos(1.f)
    {
    }
 
    inline EWalkableSlopeBehavior GetWalkableSlopeBehavior() const
    {
        return WalkableSlopeBehavior;
    }
 
    inline float GetWalkableSlopeAngle() const
    {
        return WalkableSlopeAngle;
    }
 
    inline void SetWalkableSlopeBehavior(EWalkableSlopeBehavior NewSlopeBehavior)
    {
        WalkableSlopeBehavior = NewSlopeBehavior;
    }
 
    inline void SetWalkableSlopeAngle(float NewSlopeAngle)
    {
        WalkableSlopeAngle = FMath::Clamp(NewSlopeAngle, 0.f, 90.f);
    }
 
    float ModifyWalkableFloorZ(float InWalkableFloorZ) const
    {
        switch(WalkableSlopeBehavior)
        {
            case WalkableSlope_Default:
            {
                return InWalkableFloorZ;
            }
 
            case WalkableSlope_Increase:
            {
                CheckCachedData();
                return FMath::Min(InWalkableFloorZ, CachedSlopeCos);
            }
 
            case WalkableSlope_Decrease:
            {
                CheckCachedData();
                return FMath::Max(InWalkableFloorZ, CachedSlopeCos);
            }
 
            case WalkableSlope_Unwalkable:
            {
                // Z component of a normal will always be less than this, so this will be unwalkable.
                return 2.0f;
            }
 
            case WalkableSlope_Max:
            default:
            {
                return InWalkableFloorZ;
            }
        }
    }
 
private:
 
    void CheckCachedData() const
    {
        if (CachedSlopeAngle != WalkableSlopeAngle)
        {
            const float AngleRads = FMath::DegreesToRadians(WalkableSlopeAngle);
            CachedSlopeCos = FMath::Clamp(FMath::Cos(AngleRads), 0.f, 1.f);
            CachedSlopeAngle = WalkableSlopeAngle;
        }
    }
};
 
template<> struct TIsPODType<FWalkableSlopeOverride> { enum { Value = true }; };
 
struct FReplicationFlags
{
    union
    {
        struct
        {
            uint32 bNetOwner:1;
            uint32 bNetInitial:1;
            uint32 bNetSimulated:1;
            uint32 bRepPhysics:1;
            uint32 bReplay:1;
            uint32 bIgnoreRPCs:1;
            uint32 bSkipRoleSwap:1;
            uint32 bRolesOnly:1;
            uint32 bForceInitialDirty:1;
            uint32 bSerializePropertyNames : 1;
            uint32 bUseCustomSubobjectReplication : 1;
            uint32 bClientReplay : 1;
            uint32 Padding0 : 4;
 
            uint32 CondDynamicChangeCounter : 16;
        };
 
        uint32 Value;
    };
    FReplicationFlags()
    {
        Value = 0;
    }
};
 
static_assert(sizeof(FReplicationFlags) == 4, "FReplicationFlags has invalid size.");
 
USTRUCT()
struct FConstrainComponentPropName
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=Constraint)
    FName   ComponentName;
};
 
USTRUCT(BlueprintType)
struct FBaseComponentReference
{
    GENERATED_BODY()
 
    FBaseComponentReference()  {}
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Component, meta = (DisplayName = "Component Name"))
    FName ComponentProperty;
 
    UPROPERTY(EditDefaultsOnly, Category=Component, meta =(EditCondition="false", EditConditionHides))
    FString PathToComponent;
 
    TWeakObjectPtr<class UActorComponent> OverrideComponent;
 
    ENGINE_API class UActorComponent* ExtractComponent(AActor* SearchActor) const;
 
    bool operator== (const FBaseComponentReference& Other) const
    {
        return ComponentProperty == Other.ComponentProperty && PathToComponent == Other.PathToComponent && OverrideComponent == Other.OverrideComponent;
    }
};
 
inline uint32 GetTypeHash(const FBaseComponentReference& Reference)
{
    return HashCombineFast(
        HashCombineFast(
            GetTypeHash(Reference.ComponentProperty),
            GetTypeHash(Reference.PathToComponent)),
            GetTypeHash(Reference.OverrideComponent));
}
 
USTRUCT(BlueprintType)
struct FComponentReference : public FBaseComponentReference
{
    GENERATED_BODY()
 
    FComponentReference() : OtherActor(nullptr) {}
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=Component, meta = (DisplayName = "Referenced Actor"))
    TWeakObjectPtr<AActor> OtherActor;
 
    ENGINE_API class UActorComponent* GetComponent(AActor* OwningActor) const;
 
    bool operator== (const FComponentReference& Other) const
    {
        return (OtherActor == Other.OtherActor) && (FBaseComponentReference::operator==(Other));
    }
};
 
USTRUCT(BlueprintType)
struct FSoftComponentReference : public FBaseComponentReference
{
    GENERATED_BODY()
 
    FSoftComponentReference() : OtherActor(nullptr) {}
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=Component, meta = (DisplayName = "Referenced Actor"))
    TSoftObjectPtr<AActor> OtherActor;
 
    ENGINE_API class UActorComponent* GetComponent(AActor* OwningActor) const;
 
    bool operator== (const FSoftComponentReference& Other) const
    {
        return (OtherActor == Other.OtherActor) && (FBaseComponentReference::operator==(Other));
    }
 
    ENGINE_API bool SerializeFromMismatchedTag(const FPropertyTag& Tag, FStructuredArchive::FSlot Slot);
};
 
template<>
struct TStructOpsTypeTraits<FSoftComponentReference> : public TStructOpsTypeTraitsBase2<FSoftComponentReference>
{
    enum
    {
        WithStructuredSerializeFromMismatchedTag = true,
    };
};
 
 
UENUM(BlueprintType)
namespace EPhysicalMaterialMaskColor
{
    enum Type : int
    {
        Red,
        Green,
        Blue,
        Cyan,
        Magenta,
        Yellow,
        White,
        Black,
        MAX
    };
}
 
UENUM(BlueprintType)
namespace EComponentMobility
{
    enum Type : int
    {
        Static,
 
        Stationary,
 
        Movable
    };
}
 
UCLASS(abstract, config=Engine, MinimalAPI)
class UEngineTypes : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
    static ENGINE_API ECollisionChannel ConvertToCollisionChannel(ETraceTypeQuery TraceType);
 
    static ENGINE_API ECollisionChannel ConvertToCollisionChannel(EObjectTypeQuery ObjectType);
 
    static ENGINE_API EObjectTypeQuery ConvertToObjectType(ECollisionChannel CollisionChannel);
 
    static ENGINE_API ETraceTypeQuery ConvertToTraceType(ECollisionChannel CollisionChannel);
};
 
UENUM()
namespace EComponentSocketType
{
    enum Type : int
    {
        Invalid,
 
        Bone,
 
        Socket,
    };
}
 
struct FComponentSocketDescription
{
    FName Name;
 
    TEnumAsByte<EComponentSocketType::Type> Type;
 
    FComponentSocketDescription()
        : Name(NAME_None)
        , Type(EComponentSocketType::Invalid)
    {
    }
 
    FComponentSocketDescription(FName SocketName, EComponentSocketType::Type SocketType)
        : Name(SocketName)
        , Type(SocketType)
    {
    }
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FConstraintBrokenSignature, int32, ConstraintIndex);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlasticDeformationEventSignature, int32, ConstraintIndex);
 
 
USTRUCT(BlueprintType)
struct FCollectionReference
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CollectionReference)
    FName CollectionName;
};
 
USTRUCT()
struct FRedirector
{
    GENERATED_BODY()
 
    UPROPERTY()
    FName OldName;
 
    UPROPERTY()
    FName NewName;
 
    FRedirector()
        : OldName(NAME_None)
        , NewName(NAME_None)
    { }
 
    FRedirector(FName InOldName, FName InNewName)
        : OldName(InOldName)
        , NewName(InNewName)
    { }
};
 
USTRUCT(BlueprintType)
struct FDebugFloatHistory
{
    GENERATED_BODY()
 
private:
    UPROPERTY(Transient)
    TArray<float> Samples;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="DebugFloatHistory")
    int32 MaxSamples;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DebugFloatHistory")
    float MinValue;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DebugFloatHistory")
    float MaxValue;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DebugFloatHistory")
    bool bAutoAdjustMinMax;
 
    FDebugFloatHistory()
        : MaxSamples(100)
        , MinValue(0.f)
        , MaxValue(0.f)
        , bAutoAdjustMinMax(true)
    { }
 
    FDebugFloatHistory(int32 const & InMaxSamples, float const & InMinValue, float const & InMaxValue, bool const & InbAutoAdjustMinMax)
        : MaxSamples(InMaxSamples)
        , MinValue(InMinValue)
        , MaxValue(InMaxValue)
        , bAutoAdjustMinMax(InbAutoAdjustMinMax)
    { }
 
    void AddSample(float const & FloatValue)
    {
        if (bAutoAdjustMinMax)
        {
            // Adjust bounds and record value.
            MinValue = FMath::Min(MinValue, FloatValue);
            MaxValue = FMath::Max(MaxValue, FloatValue);
            Samples.Insert(FloatValue, 0);
        }
        else
        {
            // Record clamped value.
            Samples.Insert(FMath::Clamp(FloatValue, MinValue, MaxValue), 0);
        }
 
        // Do not exceed MaxSamples recorded.
        if( Samples.Num() > MaxSamples )
        {
            Samples.RemoveAt(MaxSamples, Samples.Num() - MaxSamples);
        }
    }
 
    float GetMinMaxRange() const
    {
        return (MaxValue - MinValue);
    }
 
    float GetMinValue() const
    {
        return MinValue;
    }
 
    float GetMaxValue() const
    {
        return MaxValue;
    }
 
    int GetNumSamples() const
    {
        return Samples.Num();
    }
 
    TArray<float> const & GetSamples() const
    {
        return Samples;
    }
};
 
USTRUCT(BlueprintType)
struct FDepthFieldGlowInfo
{
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, Category="Glow")
    uint32 bEnableGlow:1;
 
    UPROPERTY(BlueprintReadWrite, Category="Glow")
    FLinearColor GlowColor;
 
    UPROPERTY(BlueprintReadWrite, Category="Glow")
    FVector2D GlowOuterRadius;
 
    UPROPERTY(BlueprintReadWrite, Category="Glow")
    FVector2D GlowInnerRadius;
 
 
    FDepthFieldGlowInfo()
        : bEnableGlow(false)
        , GlowColor(ForceInit)
        , GlowOuterRadius(ForceInit)
        , GlowInnerRadius(ForceInit)
    { }
 
    bool operator==(const FDepthFieldGlowInfo& Other) const
    {
        if (Other.bEnableGlow != bEnableGlow)
        {
            return false;
        }
        else if (!bEnableGlow)
        {
            // if the glow is disabled on both, the other values don't matter
            return true;
        }
        else
        {
            return (Other.GlowColor == GlowColor && Other.GlowOuterRadius == GlowOuterRadius && Other.GlowInnerRadius == GlowInnerRadius);
        }
    }
 
    bool operator!=(const FDepthFieldGlowInfo& Other) const
    {
        return !(*this == Other);
    }   
};
 
USTRUCT(BlueprintType)
struct FFontRenderInfo
{
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, Category="FontInfo")
    uint32 bClipText:1;
 
    UPROPERTY(BlueprintReadWrite, Category="FontInfo")
    uint32 bEnableShadow:1;
 
    UPROPERTY(BlueprintReadWrite, Category="FontInfo")
    struct FDepthFieldGlowInfo GlowInfo;
 
    FFontRenderInfo()
        : bClipText(false), bEnableShadow(false)
    {}
};
 
USTRUCT(BlueprintType)
struct FCanvasUVTri
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FVector2D V0_Pos;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FVector2D V0_UV;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FLinearColor V0_Color;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FVector2D V1_Pos;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FVector2D V1_UV;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FLinearColor V1_Color;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FVector2D V2_Pos;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FVector2D V2_UV;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CanvasUVTri)
    FLinearColor V2_Color;
 
    FCanvasUVTri()
        : V0_Pos(ForceInit)
        , V0_UV(ForceInit)
        , V0_Color(ForceInit)
        , V1_Pos(ForceInit)
        , V1_UV(ForceInit)
        , V1_Color(ForceInit)
        , V2_Pos(ForceInit)
        , V2_UV(ForceInit)
        , V2_Color(ForceInit)
    { }
};
 
template <> struct TIsZeroConstructType<FCanvasUVTri> { enum { Value = true }; };
 
UENUM(BlueprintType)
enum class ESpawnActorCollisionHandlingMethod : uint8
{
    Undefined                               UMETA(DisplayName = "Default"),
    AlwaysSpawn                             UMETA(DisplayName = "Always Spawn, Ignore Collisions"),
    AdjustIfPossibleButAlwaysSpawn          UMETA(DisplayName = "Try To Adjust Location, But Always Spawn"),
    AdjustIfPossibleButDontSpawnIfColliding UMETA(DisplayName = "Try To Adjust Location, Don't Spawn If Still Colliding"),
    DontSpawnIfColliding                    UMETA(DisplayName = "Do Not Spawn"),
};
 
enum class EUserActivityContext : uint8
{
    Game,
    Editor,
    Other
};
 
USTRUCT(BlueprintType)
struct FUserActivity
{
    GENERATED_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, Category = "Activity")
    FString ActionName;
 
    EUserActivityContext Context;
 
    FUserActivity()
        : Context(EUserActivityContext::Game)
    { }
 
    FUserActivity(const FString& InActionName)
        : ActionName(InActionName)
        , Context(EUserActivityContext::Game)
    { }
 
    FUserActivity(const FString& InActionName, EUserActivityContext InContext)
        : ActionName(InActionName)
        , Context(InContext)
    { }
};
 
UENUM()
enum class EMeshBufferAccess: uint8
{
    Default,
 
    ForceCPUAndGPU
};
 
enum class ELevelCollectionType : uint8
{
    DynamicSourceLevels,
 
    DynamicDuplicatedLevels,
 
    StaticLevels,
 
    MAX
};
 
enum class EPackageAutoSaveType : uint8
{
    None = 0,
    Transient = 1 << 0,
    Persistent = 1 << 1,
    Any = Transient | Persistent,
};
ENUM_CLASS_FLAGS(EPackageAutoSaveType);
 
#if WITH_EDITOR
 
ENGINE_API void SerializeNaniteSettingsForDDC(FArchive& Ar, FMeshNaniteSettings& NaniteSettings, bool bIsNaniteForceEnabled);
ENGINE_API void SerializeRayTracingProxySettingsForDDC(FArchive& Ar, FMeshRayTracingProxySettings& Settings);
 
#endif