EngineBaseTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/TaskGraphFwd.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
#include "UObject/WeakObjectPtr.h"
#include "Misc/CoreMisc.h"
#include "Net/Core/Connection/NetEnums.h"
#include <atomic>
 
#include "EngineBaseTypes.generated.h"
 
class UActorComponent;
struct FSlateBrush;
struct FSlateIcon;
struct FTickContext;
 
//
//  EInputEvent
//
UENUM( BlueprintType, meta=(ScriptName="InputEventType"))
enum EInputEvent : int
{
    IE_Pressed              =0,
    IE_Released             =1,
    IE_Repeat               =2,
    IE_DoubleClick          =3,
    IE_Axis                 =4,
    IE_MAX                  =5,
};
 
UENUM()
enum class EMouseCaptureMode : uint8
{
    NoCapture,
    CapturePermanently,
    CapturePermanently_IncludingInitialMouseDown,
    CaptureDuringMouseDown,
    CaptureDuringRightMouseDown,
};
 
UENUM()
enum class EMouseLockMode : uint8
{
    DoNotLock,
    LockOnCapture,
    LockAlways,
    LockInFullscreen,
};
 
enum ELevelTick
{
    LEVELTICK_TimeOnly = 0,
    LEVELTICK_ViewportsOnly = 1,
    LEVELTICK_All = 2,
    LEVELTICK_PauseTick = 3,
};
 
UENUM(BlueprintType)
enum ETickingGroup : int
{
    TG_PrePhysics UMETA(DisplayName="Pre Physics"),
 
    TG_StartPhysics UMETA(Hidden, DisplayName="Start Physics"),
 
    TG_DuringPhysics UMETA(DisplayName="During Physics"),
 
    TG_EndPhysics UMETA(Hidden, DisplayName="End Physics"),
 
    TG_PostPhysics UMETA(DisplayName="Post Physics"),
 
    TG_PostUpdateWork UMETA(DisplayName="Post Update Work"),
 
    TG_LastDemotable UMETA(Hidden, DisplayName = "Last Demotable"),
 
    TG_NewlySpawned UMETA(Hidden, DisplayName="Newly Spawned"),
 
    TG_MAX,
};
 
USTRUCT()
struct FTickPrerequisite
{
    GENERATED_USTRUCT_BODY()
 
    
    TWeakObjectPtr<class UObject> PrerequisiteObject;
 
    struct FTickFunction*       PrerequisiteTickFunction;
 
    FTickPrerequisite()
    : PrerequisiteTickFunction(nullptr)
    {
    }
    FTickPrerequisite(UObject* TargetObject, struct FTickFunction& TargetTickFunction)
    : PrerequisiteObject(TargetObject)
    , PrerequisiteTickFunction(&TargetTickFunction)
    {
        check(PrerequisiteTickFunction);
    }
    bool operator==(const FTickPrerequisite& Other) const
    {
        return PrerequisiteObject == Other.PrerequisiteObject &&
            PrerequisiteTickFunction == Other.PrerequisiteTickFunction;
    }
    struct FTickFunction* Get()
    {
        if (PrerequisiteObject.IsValid(true))
        {
            return PrerequisiteTickFunction;
        }
        return nullptr;
    }
    
    const struct FTickFunction* Get() const
    {
        if (PrerequisiteObject.IsValid(true))
        {
            return PrerequisiteTickFunction;
        }
        return nullptr;
    }
};
 
USTRUCT()
struct FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
public:
    // The following UPROPERTYs are for configuration and inherited from the CDO/archetype/blueprint etc
 
    UPROPERTY(EditDefaultsOnly, Category="Tick", AdvancedDisplay)
    TEnumAsByte<enum ETickingGroup> TickGroup;
 
    UPROPERTY(EditDefaultsOnly, Category="Tick", AdvancedDisplay)
    TEnumAsByte<enum ETickingGroup> EndTickGroup;
 
public:
    UPROPERTY(EditDefaultsOnly, Category="Tick", AdvancedDisplay)
    uint8 bTickEvenWhenPaused:1;
 
    UPROPERTY()
    uint8 bCanEverTick:1;
 
    UPROPERTY(EditDefaultsOnly, Category="Tick")
    uint8 bStartWithTickEnabled:1;
 
    UPROPERTY(EditDefaultsOnly, Category="Tick", AdvancedDisplay)
    uint8 bAllowTickOnDedicatedServer:1;
 
    uint8 bAllowTickBatching:1;
 
    uint8 bHighPriority:1;
 
    uint8 bRunOnAnyThread:1;
 
    uint8 bRunTransactionally:1;
 
    uint8 bDispatchManually : 1;
 
private:
    uint8 bWasDispatchedManually:1;
 
    enum class ETickState : uint8
    {
        Disabled,
        Enabled,
        CoolingDown
    };
 
    ETickState TickState : 2;
 
public:
    UPROPERTY(EditDefaultsOnly, Category="Tick", meta=(DisplayName="Tick Interval (secs)"))
    float TickInterval;
 
private:
 
    TArray<struct FTickPrerequisite> Prerequisites;
 
    enum class ETickTaskState : uint8
    {
        // Has not been queued yet for the current frame, or has already executed
        NotQueued,
        // In the process of being queued, but no actual task yet
        Pending,
        // Has an actual task and a completion event, may be executing
        HasTask,
        // Directly points to a completion event, probably in a batched tick
        HasCompletionEvent,
    };
 
    struct FInternalData
    {
        FInternalData();
 
        bool bRegistered : 1;
 
        bool bWasInterval:1;
 
        ETickTaskState TaskState;
 
        TEnumAsByte<enum ETickingGroup> ActualStartTickGroup;
 
        TEnumAsByte<enum ETickingGroup> ActualEndTickGroup;
        
        std::atomic<uint32> TickVisitedGFrameCounter;
 
        std::atomic<uint32> TickQueuedGFrameCounter;
    
        void* TaskPointer;
 
        FTickFunction* Next;
 
        float RelativeTickCooldown;
 
        float LastTickGameTimeSeconds;
 
        class FTickTaskLevel*                       TickTaskLevel;
    };
 
    TUniquePtr<FInternalData> InternalData;
 
public:
    ENGINE_API FTickFunction();
    ENGINE_API virtual ~FTickFunction();
 
    ENGINE_API void RegisterTickFunction(class ULevel* Level);
    ENGINE_API void UnRegisterTickFunction();
    bool IsTickFunctionRegistered() const { return (InternalData && InternalData->bRegistered); }
 
    ENGINE_API void SetTickFunctionEnable(bool bInEnabled);
    bool IsTickFunctionEnabled() const { return TickState != ETickState::Disabled; }
 
    ENGINE_API void UpdateTickIntervalAndCoolDown(float NewTickInterval);
 
    ENGINE_API bool IsCompletionHandleValid() const;
 
    ENGINE_API FGraphEventRef GetCompletionHandle() const;
 
    ENGINE_API virtual bool CanDispatchManually() const;
 
    ENGINE_API virtual bool DispatchManually();
 
    TEnumAsByte<enum ETickingGroup> GetActualTickGroup() const
    {
        return (InternalData ? InternalData->ActualStartTickGroup : TickGroup);
    }
 
    TEnumAsByte<enum ETickingGroup> GetActualEndTickGroup() const
    {
        return (InternalData ? InternalData->ActualEndTickGroup : EndTickGroup);
    }
 
    ENGINE_API void AddPrerequisite(UObject* TargetObject, struct FTickFunction& TargetTickFunction);
 
    ENGINE_API void RemovePrerequisite(UObject* TargetObject, struct FTickFunction& TargetTickFunction);
 
    ENGINE_API void SetPriorityIncludingPrerequisites(bool bInHighPriority);
 
    TArray<struct FTickPrerequisite>& GetPrerequisites()
    {
        return Prerequisites;
    }
 
    const TArray<struct FTickPrerequisite>& GetPrerequisites() const
    {
        return Prerequisites;
    }
 
    float GetLastTickGameTime() const { return (InternalData ? InternalData->LastTickGameTimeSeconds : -1.f); }
     
    ENGINE_API void ExecuteNestedTick(float DeltaTime, ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent);
 
private:
    void* GetTaskPointer(ETickTaskState RequiredState) const
    {
        return (InternalData && InternalData->TaskState == RequiredState ? InternalData->TaskPointer : nullptr);
    }
 
    void SetTaskPointer(ETickTaskState NewState, void* InTaskPointer);
 
    void QueueTickFunction(class FTickTaskSequencer& TTS, const FTickContext& TickContext);
 
    void QueueTickFunctionParallel(const FTickContext& TickContext, TArray<FTickFunction*, TInlineAllocator<8> >& StackForCycleDetection);
 
public:
    // Functions to be used by executing tasks, don't call these directly from user code
 
    ENGINE_API float CalculateDeltaTime(float DeltaTime, const class UWorld* TickingWorld);
 
    ENGINE_API void LogTickFunction(ENamedThreads::Type CurrentThread, bool bLogPrerequisites, int32 Indent = 0);
 
    ENGINE_API void ShowPrerequistes(int32 Indent = 1);
 
    ENGINE_API void ClearTaskInformation();
 
 
    virtual void ExecuteTick(float DeltaTime, ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) PURE_VIRTUAL(,);
    
#if UE_WITH_REMOTE_OBJECT_HANDLE
    FName CachedDiagnosticContext;
    FString CachedDiagnosticMessage;
#endif
 
    virtual FString DiagnosticMessage() PURE_VIRTUAL(, return TEXT("DiagnosticMessage() not implemented"););
    
    virtual FName DiagnosticContext(bool bDetailed)
    {
        return NAME_None;
    }
 
    virtual void ForEachNestedTick(TFunctionRef<void(FTickFunction&)> InFunc) const {}
    
    friend class FTickTaskSequencer;
    friend class FTickTaskManager;
    friend class FTickTaskLevel;
 
    // It is unsafe to copy FTickFunctions and any subclasses of FTickFunction should specify the type trait WithCopy = false
    FTickFunction& operator=(const FTickFunction&) = delete;
};
 
template<>
struct TStructOpsTypeTraits<FTickFunction> : public TStructOpsTypeTraitsBase2<FTickFunction>
{
    enum
    {
        WithCopy = false,
        WithPureVirtual = true
    };
};
 
USTRUCT()
struct FActorTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
    
#if UE_WITH_REMOTE_OBJECT_HANDLE
    TObjectPtr<AActor> Target;
#else
    class AActor*   Target;
#endif
 
    ENGINE_API virtual void ExecuteTick(float DeltaTime, ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
    ENGINE_API virtual FString DiagnosticMessage() override;
    ENGINE_API virtual FName DiagnosticContext(bool bDetailed) override;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    ENGINE_API void AddStructReferencedObjects(FReferenceCollector& Collector);
#endif
};
 
template<>
struct TStructOpsTypeTraits<FActorTickFunction> : public TStructOpsTypeTraitsBase2<FActorTickFunction>
{
    enum
    {
#if UE_WITH_REMOTE_OBJECT_HANDLE
        WithAddStructReferencedObjects = true,
#endif
        WithCopy = false
    };
};
 
USTRUCT()
struct FActorComponentTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    TObjectPtr<class UActorComponent> Target;
#else
    class UActorComponent*  Target;
#endif
 
    ENGINE_API virtual void ExecuteTick(float DeltaTime, ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
    ENGINE_API virtual FString DiagnosticMessage() override;
    ENGINE_API virtual FName DiagnosticContext(bool bDetailed) override;
 
    //NOTE: This already creates a UObject stat so don't double count in your own functions
 
    template <typename ExecuteTickLambda>
    static void ExecuteTickHelper(UActorComponent* Target, bool bTickInEditor, float DeltaTime, ELevelTick TickType, const ExecuteTickLambda& ExecuteTickFunc); 
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    ENGINE_API void AddStructReferencedObjects(FReferenceCollector& Collector);
#endif
};
 
 
template<>
struct TStructOpsTypeTraits<FActorComponentTickFunction> : public TStructOpsTypeTraitsBase2<FActorComponentTickFunction>
{
    enum
    {
#if UE_WITH_REMOTE_OBJECT_HANDLE
        WithAddStructReferencedObjects = true,
#endif
        WithCopy = false
    };
};
 
 
UENUM()
namespace ENetworkLagState
{
    enum Type : int
    {
        NotLagging,
        Lagging
    };
}
 
 
namespace ENetworkLagState
{
    inline const TCHAR* ToString(ENetworkLagState::Type LagType)
    {
        switch (LagType)
        {
            case NotLagging:
                return TEXT("NotLagging");
            case Lagging:
                return TEXT("Lagging");
        }
        return TEXT("Unknown lag type occurred.");
    }
}
 
UENUM(BlueprintType)
namespace ETravelFailure
{
    enum Type : int
    {
        NoLevel,
        LoadMapFailure,
        InvalidURL,
        PackageMissing,
        PackageVersion,
        NoDownload,
        TravelFailure,
        CheatCommands,
        PendingNetGameCreateFailure,
        CloudSaveFailure,
        ServerTravelFailure,
        ClientTravelFailure,
    };
}
 
namespace ETravelFailure
{
    inline const TCHAR* ToString(ETravelFailure::Type FailureType)
    {
        switch (FailureType)
        {
        case NoLevel:
            return TEXT("NoLevel");
        case LoadMapFailure:
            return TEXT("LoadMapFailure");
        case InvalidURL:
            return TEXT("InvalidURL");
        case PackageMissing:
            return TEXT("PackageMissing");
        case PackageVersion:
            return TEXT("PackageVersion");
        case NoDownload:
            return TEXT("NoDownload");
        case TravelFailure:
            return TEXT("TravelFailure");
        case CheatCommands:
            return TEXT("CheatCommands");
        case PendingNetGameCreateFailure:
            return TEXT("PendingNetGameCreateFailure");
        case ServerTravelFailure:
            return TEXT("ServerTravelFailure");
        case ClientTravelFailure:
            return TEXT("ClientTravelFailure");
        case CloudSaveFailure:
            return TEXT("CloudSaveFailure");
        }
        return TEXT("Unknown ETravelFailure error occurred.");
    }
}
 
// Traveling from server to server.
UENUM()
enum ETravelType : int
{
    TRAVEL_Absolute,
    TRAVEL_Partial,
    TRAVEL_Relative,
    TRAVEL_MAX,
};
 
UENUM(BlueprintType)
namespace EDemoPlayFailure
{
    enum UE_DEPRECATED(5.1, "No longer used in favor of EReplayResult") Type : int
    {
        Generic,
        DemoNotFound,
        Corrupt,
        InvalidVersion,
        InitBase,
        GameSpecificHeader,
        ReplayStreamerInternal,
        LoadMap,
        Serialization
    };
}
 
namespace EDemoPlayFailure
{
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.1, "EDemoPlayFailure is now deprecated")
    inline const TCHAR* ToString(EDemoPlayFailure::Type FailureType)
    {
        switch (FailureType)
        {
        case Generic:
            return TEXT("Generic");
        case DemoNotFound:
            return TEXT("DemoNotFound");
        case Corrupt:
            return TEXT("Corrupt");
        case InvalidVersion:
            return TEXT("InvalidVersion");
        case InitBase:
            return TEXT("InitBase");
        case GameSpecificHeader:
            return TEXT("GameSpecificHeader");
        case ReplayStreamerInternal:
            return TEXT("ReplayStreamerInternal");
        case LoadMap:
            return TEXT("LoadMap");
        case Serialization:
            return TEXT("Serialization");
        }
 
        return TEXT("Unknown EDemoPlayFailure error occurred.");
    }
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
}
 
//URL structure.
USTRUCT()
struct FURL
{
    GENERATED_USTRUCT_BODY()
 
    // Protocol, i.e. "unreal" or "http".
    UPROPERTY()
    FString Protocol;
 
    // Optional hostname, i.e. "204.157.115.40" or "unreal.epicgames.com", blank if local.
    UPROPERTY()
    FString Host;
 
    // Optional host port.
    UPROPERTY()
    int32 Port;
 
    UPROPERTY()
    int32 Valid;
 
    // Map name, i.e. "SkyCity", default is "Entry".
    UPROPERTY()
    FString Map;
 
    // Optional place to download Map if client does not possess it
    UPROPERTY()
    FString RedirectURL;
 
    // Options.
    UPROPERTY()
    TArray<FString> Op;
 
    // Portal to enter through, default is "".
    UPROPERTY()
    FString Portal;
 
    // Statics.
    static ENGINE_API FUrlConfig UrlConfig;
    static ENGINE_API bool bDefaultsInitialized;
 
    explicit FURL( ENoInit ) { }
 
    ENGINE_API FURL( const TCHAR* Filename=nullptr );
 
    ENGINE_API FURL( FURL* Base, const TCHAR* TextURL, ETravelType Type );
 
    static ENGINE_API void StaticInit();
    static ENGINE_API void StaticExit();
 
    static ENGINE_API void FilterURLString( FString& Str );
 
    ENGINE_API bool IsInternal() const;
 
    ENGINE_API bool IsLocalInternal() const;
 
    ENGINE_API bool HasOption( const TCHAR* Test ) const;
 
    ENGINE_API const TCHAR* GetOption( const TCHAR* Match, const TCHAR* Default ) const;
 
    ENGINE_API void LoadURLConfig( const TCHAR* Section, const FString& Filename=GGameIni );
 
    ENGINE_API void SaveURLConfig( const TCHAR* Section, const TCHAR* Item, const FString& Filename=GGameIni ) const;
 
    ENGINE_API void AddOption( const TCHAR* Str );
 
    ENGINE_API void RemoveOption( const TCHAR* Key, const TCHAR* Section = nullptr, const FString& Filename = GGameIni);
 
    ENGINE_API FString ToString( bool FullyQualified=0 ) const;
 
    ENGINE_API FString GetHostPortString() const;
 
    ENGINE_API friend FArchive& operator<<( FArchive& Ar, FURL& U );
 
    ENGINE_API bool operator==( const FURL& Other ) const;
};
 
enum ENetMode : int
{
    NM_Standalone,
 
    NM_DedicatedServer,
 
    NM_ListenServer,
 
    NM_Client,
 
    NM_MAX,
};
 
UENUM()
enum EViewModeIndex : int
{
    VMI_BrushWireframe = 0 UMETA(DisplayName = "Wireframe"),
    VMI_Wireframe = 1 UMETA(DisplayName = "CSG Wireframe"),
    VMI_Unlit = 2 UMETA(DisplayName = "Unlit"),
    VMI_Lit = 3 UMETA(DisplayName = "Lit"),
    VMI_Lit_DetailLighting = 4 UMETA(DisplayName = "Detail Lighting"),
    VMI_LightingOnly = 5 UMETA(DisplayName = "Lighting Only"),
    VMI_LightComplexity = 6 UMETA(DisplayName = "Light Complexity"),
    VMI_ShaderComplexity = 8 UMETA(DisplayName = "Shader Complexity"),
    VMI_LightmapDensity = 9 UMETA(DisplayName = "Lightmap Density"),
    VMI_LitLightmapDensity = 10 UMETA(DisplayName = "Lit Lightmap Density"),
    VMI_ReflectionOverride = 11 UMETA(DisplayName = "Reflections"),
    VMI_VisualizeBuffer = 12 UMETA(DisplayName = "Buffer Visualization"),
    //  VMI_VoxelLighting = 13,
 
    VMI_StationaryLightOverlap = 14 UMETA(DisplayName = "Stationary Light Overlap"),
 
    VMI_CollisionPawn = 15 UMETA(DisplayName = "Player Collision"),
    VMI_CollisionVisibility = 16 UMETA(DisplayName = "Visibility Collision"),
    //VMI_UNUSED = 17,
    VMI_LODColoration = 18 UMETA(DisplayName = "Mesh LOD Coloration"),
    VMI_QuadOverdraw = 19 UMETA(DisplayName = "Quad Overdraw"),
    VMI_PrimitiveDistanceAccuracy = 20 UMETA(DisplayName = "Primitive Distance"),
    VMI_MeshUVDensityAccuracy = 21  UMETA(DisplayName = "Mesh UV Density"),
    VMI_ShaderComplexityWithQuadOverdraw = 22 UMETA(DisplayName = "Shader Complexity & Quads"),
    VMI_HLODColoration = 23  UMETA(DisplayName = "Hierarchical LOD Coloration"),
    VMI_GroupLODColoration = 24  UMETA(DisplayName = "Group LOD Coloration"),
    VMI_MaterialTextureScaleAccuracy = 25 UMETA(DisplayName = "Material Texture Scales"),
    VMI_RequiredTextureResolution = 26 UMETA(DisplayName = "Required Texture Resolution"),
 
    // Ray tracing modes
 
    VMI_PathTracing = 27 UMETA(DisplayName = "Path Tracing"),
    VMI_RayTracingDebug = 28 UMETA(DisplayName = "Ray Tracing Debug"),
 
    VMI_VisualizeNanite = 29 UMETA(DisplayName = "Nanite Visualization"),
 
    VMI_VisualizeVirtualTexture = 30 UMETA(DisplayName = "Virtual Texture Visualization"),
 
    VMI_VisualizeLumen = 31 UMETA(DisplayName = "Lumen Visualization"),
 
    VMI_VisualizeVirtualShadowMap = 32 UMETA(DisplayName = "Virtual Shadow Map Visualization"),
 
    VMI_VisualizeGPUSkinCache = 33 UMETA(DisplayName = "GPU Skin Cache Visualization"),
 
    VMI_VisualizeSubstrate = 34 UMETA(DisplayName = "Substrate Visualization"),
 
    VMI_VisualizeGroom = 35 UMETA(DisplayName = "Groom Visualization"),
 
    VMI_LWCComplexity = 36 UMETA(DisplayName = "Material LWC Function Usage"),
    
    VMI_Lit_Wireframe = 37 UMETA(DisplayName = "Lit Wireframe"),
 
    VMI_VisualizeActorColoration = 38 UMETA(DisplayName = "Actor Coloration Visualization"),
 
    VMI_ShadowCasters = 39 UMETA(DisplayName = "Shadow Casters Visualization"),
 
    VMI_Clay = 40 UMETA(DisplayName = "Clay"),
 
    VMI_Zebra = 41 UMETA(DisplayName = "Zebra"),
 
    VMI_FrontBackFace = 42 UMETA(DisplayName = "Front/Back Face"),
 
    VMI_RandomColor = 43 UMETA(DisplayName = "Random"),
 
    VMI_Max UMETA(Hidden),
 
    // VMI_Unknown - The value assigned to VMI_Unknown must be the highest possible of any member of EViewModeIndex, or GetViewModeName might seg-fault
    VMI_Unknown = 255 UMETA(DisplayName = "Unknown"),
};
 
UCLASS(config = Engine, MinimalAPI)
class UViewModeUtils : public UObject
{
    GENERATED_BODY()
 
public:
    static ENGINE_API FText GetViewModeDisplayName(const EViewModeIndex ViewModeIndex);
    static ENGINE_API const FSlateBrush* GetViewModeDisplayIcon(const EViewModeIndex ViewModeIndex);
    static ENGINE_API FSlateIcon GetViewModeDisplaySlateIcon(const EViewModeIndex InViewModeIndex);
};
 
 
USTRUCT()
struct FExposureSettings
{
    GENERATED_USTRUCT_BODY()
 
    FExposureSettings() : FixedEV100(1), bFixed(false)
    {
    }
 
    FString ToString() const
    {
        return FString::Printf(TEXT("%f,%d"), FixedEV100, bFixed ? 1 : 0);
    }
 
    void SetFromString(const TCHAR *In)
    {
        // set to default
        *this = FExposureSettings();
 
        const TCHAR* Comma = FCString::Strchr(In, TEXT(','));
        check(Comma);
 
        const int32 BUFFER_SIZE = 128;
        TCHAR Buffer[BUFFER_SIZE];
        check((Comma-In)+1 < BUFFER_SIZE);
        
        FCString::Strncpy(Buffer, In, UE_PTRDIFF_TO_INT32((Comma-In)+1));
        FixedEV100 = FCString::Atof(Buffer);
        bFixed = !!FCString::Atoi(Comma+1);
    }
 
    // EV100 settings for fixed mode
    UPROPERTY()
    float FixedEV100;
    // true: fixed exposure using the LogOffset value, false: automatic eye adaptation
    UPROPERTY()
    bool bFixed;
};
 
 
UCLASS(abstract, config=Engine)
class UEngineBaseTypes : public UObject
{
    GENERATED_UCLASS_BODY()
 
};