izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
bb9ed201650b1303c825750794335750464fd0ff
UnrealEngineUWP/Engine/Source/Runtime/CoreUObject/Classes/Object.h
Richard TalbotWatkin a3cfc2f2bb Big revamp to SplineComponent (continuing work-in-progress). 
#jira UE-11822 - Add up vector, roll and scale properties to USplineComponent which can be used when calculating rotations/transforms at a point on the spline
#jira UE-13333 - BP spline components do not update when setting points
#jira UE-3637 - SplineComponent: Add a get transform at distance accessor

Summary of changes:
- FInterpCurve now natively understands looping. A input key can be set, at which point the spline will loop back to its start point.  Adjusted FInterpCurve methods to take looped curves into account.
- Fixed bugs in FInterpCurve regarding returning default values (T(ForceInit) instead of T() otherwise FVectors and FQuats are not initialized correctly).
- SplineComponent now holds three separate splines (location, rotation and scale).
- The SplineReparamTable is no longer transient, but is built and saved as part of the asset.
- Changed the SplineComponent API. All methods now take a ESplineCoordinateSpace value which specifies whether the values are intended for use in local or world space. The old methods have been deprecated but not removed (for now).
- bAllowSplineEditingPerInstance is deprecated. A new member (bSplineHasBeenEdited) has superseded it, and is set automatically when editing the spline with the visualizer. Added "Reset to Default" option in the visualizer, which restores the archetype defaults.
- SplineComponentVisualizer determines if spline points have been initialized by the user construction script, and, if so, will disallow editing. This is to conform with the general idea that the UCS always overrides property values.
- Fixed a number of bugs in the visualizer, and added new facilities to allow the scale and rotation to be edited (still work-in-progress).

[CL 2524087 by Richard TalbotWatkin in Main branch]
2015-04-24 06:25:50 -04:00

1006 lines
23 KiB
C++
Raw Blame History

// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
//=============================================================================
// Unreal base structures.
// Temporary mirrors of C++ structs, used mainly as forward declarations for the core object module
// to avoid including the full engine source. In most cases the full class definition is in another
// file and is noted as such. More complete documentation will generally be found in those files.
#pragma once
#if !CPP //noexport class
/** String search case used in UnrealString.h */
UENUM()
namespace ESearchCase
{
enum Type
{
CaseSensitive,
IgnoreCase,
};
}
/** String search dir used in UnrealString.h */
UENUM()
namespace ESearchDir
{
enum Type
{
FromStart,
FromEnd,
};
}
/**
* Enum that defines how the log times are to be displayed (mirrored from OutputDevice.h).
*/
UENUM()
namespace ELogTimes
{
enum Type
{
// Do not display log timestamps
None UMETA(DisplayName = "None"),
// Display log timestamps in UTC
UTC UMETA(DisplayName = "UTC"),
// Display log timestamps in seconds elapsed since GStartTime
SinceGStartTime UMETA(DisplayName = "Time since application start"),
};
}
/** Generic axis enum (mirrored for native use in Axis.h). */
UENUM()
namespace EAxis
{
enum Type
{
None,
X,
Y,
Z
};
}
// Interpolation data types.
UENUM()
enum EInterpCurveMode
{
CIM_Linear UMETA(DisplayName="Linear"),
CIM_CurveAuto UMETA(DisplayName="Curve Auto"),
CIM_Constant UMETA(DisplayName="Constant"),
CIM_CurveUser UMETA(DisplayName="Curve User"),
CIM_CurveBreak UMETA(DisplayName="Curve Break"),
CIM_CurveAutoClamped UMETA(DisplayName="Curve Auto Clamped"),
CIM_MAX,
};
// @warning: When you update this, you must add an entry to GPixelFormats(see RenderUtils.cpp)
// @warning: When you update this, you must add an entries to PixelFormat.h, usually just copy the generated section on the header into EPixelFormat
// @warning: The *Tools DLLs will also need to be recompiled if the ordering is changed, but should not need code changes.
UENUM()
enum EPixelFormat
{
PF_Unknown,
PF_A32B32G32R32F,
PF_B8G8R8A8,
// UNORM red (0..1)
PF_G8,
PF_G16,
PF_DXT1,
PF_DXT3,
PF_DXT5,
PF_UYVY,
// A RGB FP format with platform-specific implementation, for use with render targets
PF_FloatRGB,
// A RGBA FP format with platform-specific implementation, for use with render targets
PF_FloatRGBA,
// A depth+stencil format with platform-specific implementation, for use with render targets
PF_DepthStencil,
// A depth format with platform-specific implementation, for use with render targets
PF_ShadowDepth,
PF_R32_FLOAT,
PF_G16R16,
PF_G16R16F,
PF_G16R16F_FILTER,
PF_G32R32F,
PF_A2B10G10R10,
PF_A16B16G16R16,
PF_D24,
PF_R16F,
PF_R16F_FILTER,
PF_BC5,
// SNORM red, green (-1..1)
PF_V8U8,
PF_A1,
// A low precision floating point format.
PF_FloatR11G11B10,
PF_A8,
PF_R32_UINT,
PF_R32_SINT,
PF_PVRTC2,
PF_PVRTC4,
PF_R16_UINT,
PF_R16_SINT,
PF_R16G16B16A16_UINT,
PF_R16G16B16A16_SINT,
PF_R5G6B5_UNORM,
PF_R8G8B8A8,
// Only used for legacy loading; do NOT use!
PF_A8R8G8B8,
// High precision single channel block compressed, equivalent to a single channel BC5, 8 bytes per 4x4 block.
PF_BC4,
// UNORM red, green (0..1)
PF_R8G8,
// ATITC formats
PF_ATC_RGB,
PF_ATC_RGBA_E,
PF_ATC_RGBA_I,
// Used for creating SRVs to alias a DepthStencil buffer to read Stencil. Don't use for creating textures.
PF_X24_G8,
PF_ETC1,
PF_ETC2_RGB,
PF_ETC2_RGBA,
PF_R32G32B32A32_UINT,
PF_R16G16_UINT,
PF_ASTC_4x4, // 8.00 bpp
PF_ASTC_6x6, // 3.56 bpp
PF_ASTC_8x8, // 2.00 bpp
PF_ASTC_10x10, // 1.28 bpp
PF_ASTC_12x12, // 0.89 bpp
PF_BC6H,
PF_BC7,
PF_MAX,
};
UENUM()
namespace EMouseCursor
{
enum Type
{
/** Causes no mouse cursor to be visible */
None,
/** Default cursor (arrow) */
Default,
/** Text edit beam */
TextEditBeam,
/** Resize horizontal */
ResizeLeftRight,
/** Resize vertical */
ResizeUpDown,
/** Resize diagonal */
ResizeSouthEast,
/** Resize other diagonal */
ResizeSouthWest,
/** MoveItem */
CardinalCross,
/** Target Cross */
Crosshairs,
/** Hand cursor */
Hand,
/** Grab Hand cursor */
GrabHand,
/** Grab Hand cursor closed */
GrabHandClosed,
/** a circle with a diagonal line through it */
SlashedCircle,
/** Eye-dropper cursor for picking colors */
EyeDropper,
};
}
/** A set of numerical unit types supported by the engine. Mirrored from UnitConversion.h */
UENUM(BlueprintType)
enum class EUnit
{
/** Scalar distance/length units */
Micrometers, Millimeters, Centimeters, Meters, Kilometers,
Inches, Feet, Yards, Miles,
Lightyears,
/** Angular units */
Degrees, Radians,
/** Speed units */
MetersPerSecond, KilometersPerHour, MilesPerHour,
/** Temperature units */
Celsius, Farenheit, Kelvin,
/** Mass units */
Micrograms, Milligrams, Grams, Kilograms, MetricTons,
Ounces, Pounds, Stones,
/** Force units */
Newtons, PoundsForce, KilogramsForce,
/** Frequency units */
Hertz, Kilohertz, Megahertz, Gigahertz, RevolutionsPerMinute,
/** Data Size units */
Bytes, Kilobytes, Megabytes, Gigabytes, Terabytes,
/** Luminous flux units */
Lumens,
/** Time units */
Milliseconds, Seconds, Minutes, Hours, Days, Months, Years,
/** Symbolic entry, not specifyable on meta data */
Unspecified
};
// A globally unique identifier.
USTRUCT(immutable, noexport, BlueprintType)
struct FGuid
{
UPROPERTY(EditAnywhere, SaveGame, Category=Guid)
int32 A;
UPROPERTY(EditAnywhere, SaveGame, Category=Guid)
int32 B;
UPROPERTY(EditAnywhere, SaveGame, Category=Guid)
int32 C;
UPROPERTY(EditAnywhere, SaveGame, Category=Guid)
int32 D;
};
/**
* A point or direction FVector in 3d space.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector.h
*/
USTRUCT(immutable, noexport, BlueprintType, meta=(HasNativeMake="Engine.KismetMathLibrary.MakeVector", HasNativeBreak="Engine.KismetMathLibrary.BreakVector"))
struct FVector
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector, SaveGame)
float X;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector, SaveGame)
float Y;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector, SaveGame)
float Z;
};
/**
* A 4-D homogeneous vector.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector4.h
*/
USTRUCT(immutable, noexport)
struct FVector4
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector4, SaveGame)
float X;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector4, SaveGame)
float Y;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector4, SaveGame)
float Z;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector4, SaveGame)
float W;
};
/**
* A point or direction FVector in 2d space.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Vector2D.h
*/
USTRUCT(immutable, noexport, BlueprintType, meta=(HasNativeMake="Engine.KismetMathLibrary.MakeVector2D", HasNativeBreak="Engine.KismetMathLibrary.BreakVector2D"))
struct FVector2D
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector2D, SaveGame)
float X;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Vector2D, SaveGame)
float Y;
};
USTRUCT(immutable, noexport)
struct FTwoVectors
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=TwoVectors, SaveGame)
FVector v1;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=TwoVectors, SaveGame)
FVector v2;
};
/**
* A plane definition in 3D space.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Plane.h
*/
USTRUCT(immutable, noexport)
struct FPlane : public FVector
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Plane, SaveGame)
float W;
};
/**
* An orthogonal rotation in 3d space.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Rotator.h
*/
USTRUCT(immutable, noexport, BlueprintType, meta=(HasNativeMake="Engine.KismetMathLibrary.MakeRot", HasNativeBreak="Engine.KismetMathLibrary.BreakRot"))
struct FRotator
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Rotator, SaveGame)
float Pitch;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Rotator, SaveGame)
float Yaw;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Rotator, SaveGame)
float Roll;
};
/**
* Quaternion.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Quat.h
*/
USTRUCT(immutable, noexport)
struct FQuat
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Quat, SaveGame)
float X;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Quat, SaveGame)
float Y;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Quat, SaveGame)
float Z;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Quat, SaveGame)
float W;
};
/**
* A packed normal.
* The full C++ class is located here: Engine\Source\Runtime\RenderCore\Public\PackedNormal.h
*/
USTRUCT(immutable, noexport)
struct FPackedNormal
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PackedNormal, SaveGame)
uint8 X;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PackedNormal, SaveGame)
uint8 Y;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PackedNormal, SaveGame)
uint8 Z;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PackedNormal, SaveGame)
uint8 W;
};
/**
* Screen coordinates.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\IntPoint.h
*/
USTRUCT(immutable, noexport)
struct FIntPoint
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntPoint, SaveGame)
int32 X;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntPoint, SaveGame)
int32 Y;
};
/**
* An integer vector in 3D space.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\IntVector.h
*/
USTRUCT(immutable, noexport)
struct FIntVector
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntVector, SaveGame)
int32 X;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntVector, SaveGame)
int32 Y;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=IntVector, SaveGame)
int32 Z;
};
/**
* A Color (BGRA).
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Color.h
*/
USTRUCT(immutable, noexport)
struct FColor
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Color, SaveGame, meta=(ClampMin="0", ClampMax="255"))
uint8 B;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Color, SaveGame, meta=(ClampMin="0", ClampMax="255"))
uint8 G;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Color, SaveGame, meta=(ClampMin="0", ClampMax="255"))
uint8 R;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Color, SaveGame, meta=(ClampMin="0", ClampMax="255"))
uint8 A;
};
/**
* A linear color.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Color.h
*/
USTRUCT(immutable, noexport, BlueprintType)
struct FLinearColor
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LinearColor, SaveGame)
float R;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LinearColor, SaveGame)
float G;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LinearColor, SaveGame)
float B;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LinearColor, SaveGame)
float A;
};
/**
* A bounding box.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Box.h
*/
USTRUCT(immutable, noexport, BlueprintType)
struct FBox
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Box, SaveGame)
FVector Min;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Box, SaveGame)
FVector Max;
UPROPERTY()
uint8 IsValid;
};
/**
* A bounding box and bounding sphere with the same origin.
* The full C++ class is located here : Engine\Source\Runtime\Core\Public\Math\BoxSphereBounds.h
*/
USTRUCT(noexport)
struct FBoxSphereBounds
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BoxSphereBounds, SaveGame)
FVector Origin;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BoxSphereBounds, SaveGame)
FVector BoxExtent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=BoxSphereBounds, SaveGame)
float SphereRadius;
};
/**
* Structure for arbitrarily oriented boxes (i.e. not necessarily axis-aligned).
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\OrientedBox.h
*/
USTRUCT(immutable, noexport)
struct FOrientedBox
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
FVector Center;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
FVector AxisX;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
FVector AxisY;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
FVector AxisZ;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
float ExtentX;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
float ExtentY;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=OrientedBox, SaveGame)
float ExtentZ;
};
/*
* A 4x4 matrix.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Matrix.h
*/
USTRUCT(immutable, noexport)
struct FMatrix
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Matrix, SaveGame)
FPlane XPlane;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Matrix, SaveGame)
FPlane YPlane;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Matrix, SaveGame)
FPlane ZPlane;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Matrix, SaveGame)
FPlane WPlane;
};
USTRUCT(noexport)
struct FInterpCurvePointFloat
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
float InVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
float OutVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
float ArriveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
float LeaveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointFloat)
TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
USTRUCT(noexport)
struct FInterpCurveFloat
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveFloat)
TArray<FInterpCurvePointFloat> Points;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveFloat)
bool bIsLooped;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveFloat)
float LoopKeyOffset;
};
USTRUCT(noexport)
struct FInterpCurvePointVector2D
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
float InVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
FVector2D OutVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
FVector2D ArriveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
FVector2D LeaveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector2D)
TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
USTRUCT(noexport)
struct FInterpCurveVector2D
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector2D)
TArray<FInterpCurvePointVector2D> Points;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector2D)
bool bIsLooped;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector2D)
float LoopKeyOffset;
};
USTRUCT(noexport)
struct FInterpCurvePointVector
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
float InVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
FVector OutVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
FVector ArriveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
FVector LeaveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointVector)
TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
USTRUCT(noexport)
struct FInterpCurveVector
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector)
TArray<FInterpCurvePointVector> Points;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector)
bool bIsLooped;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveVector)
float LoopKeyOffset;
};
USTRUCT(noexport)
struct FInterpCurvePointQuat
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
float InVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
FQuat OutVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
FQuat ArriveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
FQuat LeaveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointQuat)
TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
USTRUCT(noexport)
struct FInterpCurveQuat
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveQuat)
TArray<FInterpCurvePointQuat> Points;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveQuat)
bool bIsLooped;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveQuat)
float LoopKeyOffset;
};
USTRUCT(noexport)
struct FInterpCurvePointTwoVectors
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
float InVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
FTwoVectors OutVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
FTwoVectors ArriveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
FTwoVectors LeaveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointTwoVectors)
TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
USTRUCT(noexport)
struct FInterpCurveTwoVectors
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveTwoVectors)
TArray<FInterpCurvePointTwoVectors> Points;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveTwoVectors)
bool bIsLooped;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveTwoVectors)
float LoopKeyOffset;
};
USTRUCT(noexport)
struct FInterpCurvePointLinearColor
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
float InVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
FLinearColor OutVal;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
FLinearColor ArriveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
FLinearColor LeaveTangent;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurvePointLinearColor)
TEnumAsByte<enum EInterpCurveMode> InterpMode;
};
USTRUCT(noexport)
struct FInterpCurveLinearColor
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveLinearColor)
TArray<FInterpCurvePointLinearColor> Points;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveLinearColor)
bool bIsLooped;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InterpCurveLinearColor)
float LoopKeyOffset;
};
/**
* Transform composed of Quat/Translation/Scale.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\Transform.h
*/
USTRUCT(noexport, BlueprintType, meta=(HasNativeMake="Engine.KismetMathLibrary.MakeTransform", HasNativeBreak="Engine.KismetMathLibrary.BreakTransform"))
struct FTransform
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Transform, SaveGame)
FQuat Rotation;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Transform, SaveGame)
FVector Translation;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Transform, SaveGame, meta=(MakeStructureDefaultValue = "1,1,1"))
FVector Scale3D;
};
/**
* Thread-safe RNG.
* The full C++ class is located here: Engine\Source\Runtime\Core\Public\Math\RandomStream.h
*/
USTRUCT(noexport, BlueprintType, meta = (HasNativeMake = "Engine.KismetMathLibrary.MakeRandomStream", HasNativeBreak = "Engine.KismetMathLibrary.BreakRandomStream"))
struct FRandomStream
{
public:
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=RandomStream, SaveGame)
int32 InitialSeed;
UPROPERTY()
int32 Seed;
};
// A date/time value.
USTRUCT(immutable, noexport, BlueprintType)
struct FDateTime
{
int64 Ticks;
};
// A time span value.
USTRUCT(immutable, noexport, BlueprintType)
struct FTimespan
{
int64 Ticks;
};
// A string asset reference
USTRUCT(noexport)
struct FStringAssetReference
{
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=StringAssetReference)
FString AssetLongPathname;
};
// A string class reference
USTRUCT(noexport)
struct FStringClassReference : public FStringAssetReference
{
};
// A struct used as stub for deleted ones.
USTRUCT(noexport)
struct FFallbackStruct
{
};
UENUM()
namespace ERangeBoundTypes
{
/**
* Enumerates the valid types of range bounds.
*/
enum Type
{
/**
* The range excludes the bound.
*/
Exclusive,
/**
* The range includes the bound.
*/
Inclusive,
/**
* The bound is open.
*/
Open
};
}
// A float range bound
USTRUCT(noexport)
struct FFloatRangeBound
{
UPROPERTY(EditAnywhere, Category=Range)
TEnumAsByte<ERangeBoundTypes::Type> Type;
UPROPERTY(EditAnywhere, Category=Range)
float Value;
};
// A float range
USTRUCT(noexport)
struct FFloatRange
{
UPROPERTY(EditAnywhere, Category=Range)
FFloatRangeBound LowerBound;
UPROPERTY(EditAnywhere, Category=Range)
FFloatRangeBound UpperBound;
};
// An int32 range bound
USTRUCT(noexport)
struct FInt32RangeBound
{
UPROPERTY(EditAnywhere, Category = Range)
TEnumAsByte<ERangeBoundTypes::Type> Type;
UPROPERTY(EditAnywhere, Category = Range)
int32 Value;
};
// An int32 range
USTRUCT(noexport)
struct FInt32Range
{
UPROPERTY(EditAnywhere, Category = Range)
FInt32RangeBound LowerBound;
UPROPERTY(EditAnywhere, Category = Range)
FInt32RangeBound UpperBound;
};
// A float interval
USTRUCT(noexport)
struct FFloatInterval
{
UPROPERTY(EditAnywhere, Category=Interval)
float Min;
UPROPERTY(EditAnywhere, Category=Interval)
float Max;
};
// An int32 interval
USTRUCT(noexport)
struct FInt32Interval
{
UPROPERTY(EditAnywhere, Category=Interval)
int32 Min;
UPROPERTY(EditAnywhere, Category=Interval)
int32 Max;
};
//=============================================================================
/**
* Object: The base class all objects.
* This is a built-in Unreal class and it shouldn't be modified by mod authors.
* The full C++ class is located here: Engine\Source\Runtime\CoreUObject\Public\UObject\UObject.h
*/
//=============================================================================
UCLASS(abstract, noexport)
class UObject
{
GENERATED_BODY()
public:
/**
* Default UObject constructor.
*/
UObject(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
#if WITH_HOT_RELOAD_CTORS
/** DO NOT USE. This constructor is for internal usage only for hot-reload purposes. */
UObject(FVTableHelper& Helper);
#endif // WITH_HOT_RELOAD_CTORS
//=============================================================================
// K2 support functions.
/**
* Executes some portion of the ubergraph.
*
* @param EntryPoint The entry point to start code execution at.
*/
UFUNCTION(BlueprintImplementableEvent, meta=(BlueprintInternalUseOnly = "true"))
void ExecuteUbergraph(int32 EntryPoint);
};
#endif
Reference in New Issue View Git Blame Copy Permalink