829 lines
31 KiB
TypeScript
829 lines
31 KiB
TypeScript
/// <reference path="puerts.d.ts" />
|
|
declare module "ue" {
|
|
import {$Ref, $Nullable} from "puerts"
|
|
class Guid {
|
|
constructor();
|
|
constructor(InA: number, InB: number, InC: number, InD: number);
|
|
A: number;
|
|
B: number;
|
|
C: number;
|
|
D: number;
|
|
set_Item(Index: number): $Ref<number>;
|
|
get_Item(Index: number): number;
|
|
Invalidate(): void;
|
|
IsValid(): boolean;
|
|
ToString(): string;
|
|
ToString(Format: number): string;
|
|
static NewGuid(): Guid;
|
|
static Parse(GuidString: string, OutGuid: $Ref<Guid>): boolean;
|
|
static ParseExact(GuidString: string, Format: number, OutGuid: $Ref<Guid>): boolean;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Guid__: boolean;
|
|
|
|
}
|
|
class Box2D {
|
|
constructor();
|
|
constructor(Param1: number);
|
|
constructor(InMin: Vector2D, InMax: Vector2D);
|
|
constructor(Points: Vector2D, Count: number);
|
|
Min: Vector2D;
|
|
Max: Vector2D;
|
|
bIsValid: boolean;
|
|
op_Equality(Other: Box2D): boolean;
|
|
op_Inequality(Other: Box2D): boolean;
|
|
op_Addition(Other: Vector2D): Box2D;
|
|
op_Addition(Other: Box2D): Box2D;
|
|
set_Item(Index: number): $Ref<Vector2D>;
|
|
ComputeSquaredDistanceToPoint(Point: Vector2D): number;
|
|
ExpandBy(W: number): Box2D;
|
|
GetArea(): number;
|
|
GetCenter(): Vector2D;
|
|
GetCenterAndExtents(center: $Ref<Vector2D>, Extents: $Ref<Vector2D>): void;
|
|
GetClosestPointTo(Point: Vector2D): Vector2D;
|
|
GetExtent(): Vector2D;
|
|
GetSize(): Vector2D;
|
|
Init(): void;
|
|
Intersect(other: Box2D): boolean;
|
|
IsInside(TestPoint: Vector2D): boolean;
|
|
IsInside(Other: Box2D): boolean;
|
|
ShiftBy(Offset: Vector2D): Box2D;
|
|
ToString(): string;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Box2D__: boolean;
|
|
|
|
}
|
|
class Color {
|
|
constructor();
|
|
constructor(Param1: number);
|
|
constructor(InR: number, InG: number, InB: number, InA: number);
|
|
constructor(InColor: number);
|
|
DWColor(): $Ref<number>;
|
|
DWColor(): number;
|
|
op_Equality(C: Color): boolean;
|
|
op_Inequality(C: Color): boolean;
|
|
FromRGBE(): LinearColor;
|
|
static FromHex(HexString: string): Color;
|
|
static MakeRandomColor(): Color;
|
|
static MakeRedToGreenColorFromScalar(Scalar: number): Color;
|
|
static MakeFromColorTemperature(Temp: number): Color;
|
|
WithAlpha(Alpha: number): Color;
|
|
ReinterpretAsLinear(): LinearColor;
|
|
ToHex(): string;
|
|
ToString(): string;
|
|
InitFromString(InSourceString: string): boolean;
|
|
ToPackedARGB(): number;
|
|
ToPackedABGR(): number;
|
|
ToPackedRGBA(): number;
|
|
ToPackedBGRA(): number;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Color__: boolean;
|
|
|
|
}
|
|
class LinearColor {
|
|
constructor();
|
|
constructor(Param1: number);
|
|
constructor(InR: number, InG: number, InB: number, InA: number);
|
|
constructor(Color: Color);
|
|
constructor(Vector: Vector);
|
|
constructor(Vector: Vector4);
|
|
R: number;
|
|
G: number;
|
|
B: number;
|
|
A: number;
|
|
ToRGBE(): Color;
|
|
static FromSRGBColor(Color: Color): LinearColor;
|
|
static FromPow22Color(Color: Color): LinearColor;
|
|
Component(Index: number): $Ref<number>;
|
|
Component(Index: number): number;
|
|
op_Addition(ColorB: LinearColor): LinearColor;
|
|
op_Subtraction(ColorB: LinearColor): LinearColor;
|
|
op_Multiply(ColorB: LinearColor): LinearColor;
|
|
op_Multiply(Scalar: number): LinearColor;
|
|
op_Division(ColorB: LinearColor): LinearColor;
|
|
op_Division(Scalar: number): LinearColor;
|
|
GetClamped(InMin: number, InMax: number): LinearColor;
|
|
op_Equality(ColorB: LinearColor): boolean;
|
|
op_Inequality(Other: LinearColor): boolean;
|
|
Equals(ColorB: LinearColor, Tolerance: number): boolean;
|
|
CopyWithNewOpacity(NewOpacicty: number): LinearColor;
|
|
static MakeRandomColor(): LinearColor;
|
|
static MakeFromColorTemperature(Temp: number): LinearColor;
|
|
static Dist(V1: LinearColor, V2: LinearColor): number;
|
|
LinearRGBToHSV(): LinearColor;
|
|
HSVToLinearRGB(): LinearColor;
|
|
static LerpUsingHSV(From: LinearColor, To: LinearColor, Progress: number): LinearColor;
|
|
Quantize(): Color;
|
|
QuantizeRound(): Color;
|
|
ToFColor(bSRGB: boolean): Color;
|
|
Desaturate(Desaturation: number): LinearColor;
|
|
ComputeLuminance(): number;
|
|
GetMax(): number;
|
|
IsAlmostBlack(): boolean;
|
|
GetMin(): number;
|
|
GetLuminance(): number;
|
|
ToString(): string;
|
|
InitFromString(InSourceString: string): boolean;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_LinearColor__: boolean;
|
|
|
|
}
|
|
class Quat {
|
|
constructor();
|
|
constructor(Param1: number);
|
|
constructor(InX: number, InY: number, InZ: number, InW: number);
|
|
constructor(R: Rotator);
|
|
constructor(Axis: Vector, AngleRad: number);
|
|
X: number;
|
|
Y: number;
|
|
Z: number;
|
|
W: number;
|
|
op_Addition(Q: Quat): Quat;
|
|
op_Subtraction(Q: Quat): Quat;
|
|
Equals(Q: Quat, Tolerance: number): boolean;
|
|
IsIdentity(Tolerance: number): boolean;
|
|
op_Multiply(Q: Quat): Quat;
|
|
op_Multiply(V: Vector): Vector;
|
|
op_Multiply(Scale: number): Quat;
|
|
op_Division(Scale: number): Quat;
|
|
op_Equality(Q: Quat): boolean;
|
|
op_Inequality(Q: Quat): boolean;
|
|
op_BitwiseOr(Q: Quat): number;
|
|
static MakeFromEuler(Euler: Vector): Quat;
|
|
Euler(): Vector;
|
|
Normalize(Tolerance: number): void;
|
|
GetNormalized(Tolerance: number): Quat;
|
|
IsNormalized(): boolean;
|
|
Size(): number;
|
|
SizeSquared(): number;
|
|
GetAngle(): number;
|
|
ToAxisAndAngle(Axis: $Ref<Vector>, Angle: $Ref<number>): void;
|
|
ToSwingTwist(InTwistAxis: Vector, OutSwing: $Ref<Quat>, OutTwist: $Ref<Quat>): void;
|
|
RotateVector(V: Vector): Vector;
|
|
UnrotateVector(V: Vector): Vector;
|
|
Log(): Quat;
|
|
Exp(): Quat;
|
|
Inverse(): Quat;
|
|
EnforceShortestArcWith(OtherQuat: Quat): void;
|
|
GetAxisX(): Vector;
|
|
GetAxisY(): Vector;
|
|
GetAxisZ(): Vector;
|
|
GetForwardVector(): Vector;
|
|
GetRightVector(): Vector;
|
|
GetUpVector(): Vector;
|
|
Vector(): Vector;
|
|
Rotator(): Rotator;
|
|
GetRotationAxis(): Vector;
|
|
AngularDistance(Q: Quat): number;
|
|
ContainsNaN(): boolean;
|
|
ToString(): string;
|
|
InitFromString(InSourceString: string): boolean;
|
|
DiagnosticCheckNaN(): void;
|
|
static FindBetween(Vector1: Vector, Vector2: Vector): Quat;
|
|
static FindBetweenNormals(Normal1: Vector, Normal2: Vector): Quat;
|
|
static FindBetweenVectors(Vector1: Vector, Vector2: Vector): Quat;
|
|
static Error(Q1: Quat, Q2: Quat): number;
|
|
static ErrorAutoNormalize(A: Quat, B: Quat): number;
|
|
static FastLerp(A: Quat, B: Quat, Alpha: number): Quat;
|
|
static FastBilerp(P00: Quat, P10: Quat, P01: Quat, P11: Quat, FracX: number, FracY: number): Quat;
|
|
static Slerp_NotNormalized(Quat1: Quat, Quat2: Quat, Slerp: number): Quat;
|
|
static Slerp(Quat1: Quat, Quat2: Quat, Slerp: number): Quat;
|
|
static SlerpFullPath_NotNormalized(quat1: Quat, quat2: Quat, Alpha: number): Quat;
|
|
static SlerpFullPath(quat1: Quat, quat2: Quat, Alpha: number): Quat;
|
|
static Squad(quat1: Quat, tang1: Quat, quat2: Quat, tang2: Quat, Alpha: number): Quat;
|
|
static SquadFullPath(quat1: Quat, tang1: Quat, quat2: Quat, tang2: Quat, Alpha: number): Quat;
|
|
static CalcTangents(PrevP: Quat, P: Quat, NextP: Quat, Tension: number, OutTan: $Ref<Quat>): void;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Quat__: boolean;
|
|
|
|
}
|
|
class Rotator {
|
|
constructor();
|
|
constructor(InF: number);
|
|
constructor(InPitch: number, InYaw: number, InRoll: number);
|
|
constructor(Param1: number);
|
|
constructor(Quat: Quat);
|
|
Pitch: number;
|
|
Yaw: number;
|
|
Roll: number;
|
|
DiagnosticCheckNaN(): void;
|
|
op_Addition(R: Rotator): Rotator;
|
|
op_Subtraction(R: Rotator): Rotator;
|
|
op_Multiply(Scale: number): Rotator;
|
|
op_Equality(R: Rotator): boolean;
|
|
op_Inequality(V: Rotator): boolean;
|
|
IsNearlyZero(Tolerance: number): boolean;
|
|
IsZero(): boolean;
|
|
Equals(R: Rotator, Tolerance: number): boolean;
|
|
Add(DeltaPitch: number, DeltaYaw: number, DeltaRoll: number): Rotator;
|
|
GetInverse(): Rotator;
|
|
GridSnap(RotGrid: Rotator): Rotator;
|
|
Vector(): Vector;
|
|
Quaternion(): Quat;
|
|
Euler(): Vector;
|
|
RotateVector(V: Vector): Vector;
|
|
UnrotateVector(V: Vector): Vector;
|
|
Clamp(): Rotator;
|
|
GetNormalized(): Rotator;
|
|
GetDenormalized(): Rotator;
|
|
GetComponentForAxis(Axis: number): number;
|
|
SetComponentForAxis(Axis: number, Component: number): void;
|
|
Normalize(): void;
|
|
GetWindingAndRemainder(Winding: $Ref<Rotator>, Remainder: $Ref<Rotator>): void;
|
|
GetManhattanDistance(Rotator: Rotator): number;
|
|
GetEquivalentRotator(): Rotator;
|
|
SetClosestToMe(MakeClosest: $Ref<Rotator>): void;
|
|
ToString(): string;
|
|
ToCompactString(): string;
|
|
InitFromString(InSourceString: string): boolean;
|
|
ContainsNaN(): boolean;
|
|
static ClampAxis(Angle: number): number;
|
|
static NormalizeAxis(Angle: number): number;
|
|
static CompressAxisToByte(Angle: number): number;
|
|
static DecompressAxisFromByte(Angle: number): number;
|
|
static CompressAxisToShort(Angle: number): number;
|
|
static DecompressAxisFromShort(Angle: number): number;
|
|
static MakeFromEuler(Euler: Vector): Rotator;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Rotator__: boolean;
|
|
|
|
}
|
|
class Transform {
|
|
constructor();
|
|
constructor(InTranslation: Vector);
|
|
constructor(InRotation: Quat);
|
|
constructor(InRotation: Rotator);
|
|
constructor(InRotation: Quat, InTranslation: Vector, InScale3D: Vector);
|
|
constructor(InRotation: Rotator, InTranslation: Vector, InScale3D: Vector);
|
|
constructor(Param1: number);
|
|
constructor(InX: Vector, InY: Vector, InZ: Vector, InTranslation: Vector);
|
|
DiagnosticCheckNaN_Translate(): void;
|
|
DiagnosticCheckNaN_Rotate(): void;
|
|
DiagnosticCheckNaN_Scale3D(): void;
|
|
DiagnosticCheckNaN_All(): void;
|
|
DiagnosticCheck_IsValid(): void;
|
|
DebugPrint(): void;
|
|
ToHumanReadableString(): string;
|
|
ToString(): string;
|
|
InitFromString(InSourceString: string): boolean;
|
|
Inverse(): Transform;
|
|
Blend(Atom1: Transform, Atom2: Transform, Alpha: number): void;
|
|
BlendWith(OtherAtom: Transform, Alpha: number): void;
|
|
op_Addition(Atom: Transform): Transform;
|
|
op_Multiply(Other: Transform): Transform;
|
|
op_Multiply(Other: Quat): Transform;
|
|
static AnyHasNegativeScale(InScale3D: Vector, InOtherScale3D: Vector): boolean;
|
|
ScaleTranslation(InScale3D: Vector): void;
|
|
ScaleTranslation(Scale: number): void;
|
|
RemoveScaling(Tolerance: number): void;
|
|
GetMaximumAxisScale(): number;
|
|
GetMinimumAxisScale(): number;
|
|
GetRelativeTransform(Other: Transform): Transform;
|
|
GetRelativeTransformReverse(Other: Transform): Transform;
|
|
SetToRelativeTransform(ParentTransform: Transform): void;
|
|
TransformFVector4(V: Vector4): Vector4;
|
|
TransformFVector4NoScale(V: Vector4): Vector4;
|
|
TransformPosition(V: Vector): Vector;
|
|
TransformPositionNoScale(V: Vector): Vector;
|
|
InverseTransformPosition(V: Vector): Vector;
|
|
InverseTransformPositionNoScale(V: Vector): Vector;
|
|
TransformVector(V: Vector): Vector;
|
|
TransformVectorNoScale(V: Vector): Vector;
|
|
InverseTransformVector(V: Vector): Vector;
|
|
InverseTransformVectorNoScale(V: Vector): Vector;
|
|
TransformRotation(Q: Quat): Quat;
|
|
InverseTransformRotation(Q: Quat): Quat;
|
|
GetScaled(Scale: number): Transform;
|
|
GetScaled(Scale: Vector): Transform;
|
|
GetScaledAxis(InAxis: number): Vector;
|
|
GetUnitAxis(InAxis: number): Vector;
|
|
Mirror(MirrorAxis: number, FlipAxis: number): void;
|
|
static GetSafeScaleReciprocal(InScale: Vector, Tolerance: number): Vector;
|
|
GetLocation(): Vector;
|
|
Rotator(): Rotator;
|
|
GetDeterminant(): number;
|
|
SetLocation(Origin: Vector): void;
|
|
ContainsNaN(): boolean;
|
|
IsValid(): boolean;
|
|
static AreRotationsEqual(A: Transform, B: Transform, Tolerance: number): boolean;
|
|
static AreTranslationsEqual(A: Transform, B: Transform, Tolerance: number): boolean;
|
|
static AreScale3DsEqual(A: Transform, B: Transform, Tolerance: number): boolean;
|
|
RotationEquals(Other: Transform, Tolerance: number): boolean;
|
|
TranslationEquals(Other: Transform, Tolerance: number): boolean;
|
|
Scale3DEquals(Other: Transform, Tolerance: number): boolean;
|
|
Equals(Other: Transform, Tolerance: number): boolean;
|
|
EqualsNoScale(Other: Transform, Tolerance: number): boolean;
|
|
static Multiply(OutTransform: Transform, A: Transform, B: Transform): void;
|
|
SetComponents(InRotation: Quat, InTranslation: Vector, InScale3D: Vector): void;
|
|
SetIdentity(): void;
|
|
MultiplyScale3D(Scale3DMultiplier: Vector): void;
|
|
SetTranslation(NewTranslation: Vector): void;
|
|
CopyTranslation(Other: Transform): void;
|
|
ConcatenateRotation(DeltaRotation: Quat): void;
|
|
AddToTranslation(DeltaTranslation: Vector): void;
|
|
static AddTranslations(A: Transform, B: Transform): Vector;
|
|
static SubtractTranslations(A: Transform, B: Transform): Vector;
|
|
SetRotation(NewRotation: Quat): void;
|
|
CopyRotation(Other: Transform): void;
|
|
SetScale3D(NewScale3D: Vector): void;
|
|
CopyScale3D(Other: Transform): void;
|
|
SetTranslationAndScale3D(NewTranslation: Vector, NewScale3D: Vector): void;
|
|
Accumulate(SourceAtom: Transform): void;
|
|
NormalizeRotation(): void;
|
|
IsRotationNormalized(): boolean;
|
|
GetRotation(): Quat;
|
|
GetTranslation(): Vector;
|
|
GetScale3D(): Vector;
|
|
CopyRotationPart(SrcBA: Transform): void;
|
|
CopyTranslationAndScale3D(SrcBA: Transform): void;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Transform__: boolean;
|
|
|
|
}
|
|
class Vector {
|
|
constructor();
|
|
constructor(InF: number);
|
|
constructor(InX: number, InY: number, InZ: number);
|
|
constructor(V: Vector2D, InZ: number);
|
|
constructor(V: Vector4);
|
|
constructor(InColor: LinearColor);
|
|
constructor(InVector: IntVector);
|
|
constructor(A: IntPoint);
|
|
constructor(Param1: number);
|
|
X: number;
|
|
Y: number;
|
|
Z: number;
|
|
DiagnosticCheckNaN(): void;
|
|
op_ExclusiveOr(V: Vector): Vector;
|
|
static CrossProduct(A: Vector, B: Vector): Vector;
|
|
op_BitwiseOr(V: Vector): number;
|
|
static DotProduct(A: Vector, B: Vector): number;
|
|
op_Addition(V: Vector): Vector;
|
|
op_Addition(Bias: number): Vector;
|
|
op_Subtraction(V: Vector): Vector;
|
|
op_Subtraction(Bias: number): Vector;
|
|
op_Multiply(Scale: number): Vector;
|
|
op_Multiply(V: Vector): Vector;
|
|
op_Division(Scale: number): Vector;
|
|
op_Division(V: Vector): Vector;
|
|
op_Equality(V: Vector): boolean;
|
|
op_Inequality(V: Vector): boolean;
|
|
Equals(V: Vector, Tolerance: number): boolean;
|
|
AllComponentsEqual(Tolerance: number): boolean;
|
|
op_UnaryNegation(): Vector;
|
|
set_Item(Index: number): $Ref<number>;
|
|
get_Item(Index: number): number;
|
|
Component(Index: number): $Ref<number>;
|
|
Component(Index: number): number;
|
|
GetComponentForAxis(Axis: number): number;
|
|
SetComponentForAxis(Axis: number, Component: number): void;
|
|
Set(InX: number, InY: number, InZ: number): void;
|
|
GetMax(): number;
|
|
GetAbsMax(): number;
|
|
GetMin(): number;
|
|
GetAbsMin(): number;
|
|
ComponentMin(Other: Vector): Vector;
|
|
ComponentMax(Other: Vector): Vector;
|
|
GetAbs(): Vector;
|
|
Size(): number;
|
|
SizeSquared(): number;
|
|
Size2D(): number;
|
|
SizeSquared2D(): number;
|
|
IsNearlyZero(Tolerance: number): boolean;
|
|
IsZero(): boolean;
|
|
IsUnit(LengthSquaredTolerance: number): boolean;
|
|
IsNormalized(): boolean;
|
|
Normalize(Tolerance: number): boolean;
|
|
GetUnsafeNormal(): Vector;
|
|
GetSafeNormal(Tolerance: number): Vector;
|
|
GetSafeNormal2D(Tolerance: number): Vector;
|
|
ToDirectionAndLength(OutDir: $Ref<Vector>, OutLength: $Ref<number>): void;
|
|
GetSignVector(): Vector;
|
|
Projection(): Vector;
|
|
GetUnsafeNormal2D(): Vector;
|
|
GridSnap(GridSz: number): Vector;
|
|
BoundToCube(Radius: number): Vector;
|
|
BoundToBox(Min: Vector, Max: Vector): Vector;
|
|
GetClampedToSize(Min: number, Max: number): Vector;
|
|
GetClampedToSize2D(Min: number, Max: number): Vector;
|
|
GetClampedToMaxSize(MaxSize: number): Vector;
|
|
GetClampedToMaxSize2D(MaxSize: number): Vector;
|
|
AddBounded(V: Vector, Radius: number): void;
|
|
Reciprocal(): Vector;
|
|
IsUniform(Tolerance: number): boolean;
|
|
MirrorByVector(MirrorNormal: Vector): Vector;
|
|
MirrorByPlane(Plane: FPlane): Vector;
|
|
RotateAngleAxis(AngleDeg: number, Axis: Vector): Vector;
|
|
CosineAngle2D(B: Vector): number;
|
|
ProjectOnTo(A: Vector): Vector;
|
|
ProjectOnToNormal(Normal: Vector): Vector;
|
|
ToOrientationRotator(): Rotator;
|
|
ToOrientationQuat(): Quat;
|
|
Rotation(): Rotator;
|
|
FindBestAxisVectors(Axis1: $Ref<Vector>, Axis2: $Ref<Vector>): void;
|
|
UnwindEuler(): void;
|
|
ContainsNaN(): boolean;
|
|
ToString(): string;
|
|
ToText(): string;
|
|
ToCompactString(): string;
|
|
ToCompactText(): string;
|
|
InitFromString(InSourceString: string): boolean;
|
|
UnitCartesianToSpherical(): Vector2D;
|
|
HeadingAngle(): number;
|
|
static CreateOrthonormalBasis(XAxis: $Ref<Vector>, YAxis: $Ref<Vector>, ZAxis: $Ref<Vector>): void;
|
|
static PointsAreSame(P: Vector, Q: Vector): boolean;
|
|
static PointsAreNear(Point1: Vector, Point2: Vector, Dist: number): boolean;
|
|
static PointPlaneDist(Point: Vector, PlaneBase: Vector, PlaneNormal: Vector): number;
|
|
static PointPlaneProject(Point: Vector, Plane: FPlane): Vector;
|
|
static PointPlaneProject(Point: Vector, A: Vector, B: Vector, C: Vector): Vector;
|
|
static PointPlaneProject(Point: Vector, PlaneBase: Vector, PlaneNormal: Vector): Vector;
|
|
static VectorPlaneProject(V: Vector, PlaneNormal: Vector): Vector;
|
|
static Dist(V1: Vector, V2: Vector): number;
|
|
static Distance(V1: Vector, V2: Vector): number;
|
|
static DistXY(V1: Vector, V2: Vector): number;
|
|
static Dist2D(V1: Vector, V2: Vector): number;
|
|
static DistSquared(V1: Vector, V2: Vector): number;
|
|
static DistSquaredXY(V1: Vector, V2: Vector): number;
|
|
static DistSquared2D(V1: Vector, V2: Vector): number;
|
|
static BoxPushOut(Normal: Vector, Size: Vector): number;
|
|
static Parallel(Normal1: Vector, Normal2: Vector, ParallelCosineThreshold: number): boolean;
|
|
static Coincident(Normal1: Vector, Normal2: Vector, ParallelCosineThreshold: number): boolean;
|
|
static Orthogonal(Normal1: Vector, Normal2: Vector, OrthogonalCosineThreshold: number): boolean;
|
|
static Coplanar(Base1: Vector, Normal1: Vector, Base2: Vector, Normal2: Vector, ParallelCosineThreshold: number): boolean;
|
|
static Triple(X: Vector, Y: Vector, Z: Vector): number;
|
|
static RadiansToDegrees(RadVector: Vector): Vector;
|
|
static DegreesToRadians(DegVector: Vector): Vector;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Vector__: boolean;
|
|
|
|
}
|
|
class Vector2D {
|
|
constructor();
|
|
constructor(InX: number, InY: number);
|
|
constructor(InPos: IntPoint);
|
|
constructor(Param1: number);
|
|
constructor(Param1: number);
|
|
constructor(V: Vector);
|
|
constructor(V: Vector4);
|
|
X: number;
|
|
Y: number;
|
|
op_Addition(V: Vector2D): Vector2D;
|
|
op_Addition(A: number): Vector2D;
|
|
op_Subtraction(V: Vector2D): Vector2D;
|
|
op_Subtraction(A: number): Vector2D;
|
|
op_Multiply(Scale: number): Vector2D;
|
|
op_Multiply(V: Vector2D): Vector2D;
|
|
op_Division(Scale: number): Vector2D;
|
|
op_Division(V: Vector2D): Vector2D;
|
|
op_BitwiseOr(V: Vector2D): number;
|
|
op_ExclusiveOr(V: Vector2D): number;
|
|
op_Equality(V: Vector2D): boolean;
|
|
op_Inequality(V: Vector2D): boolean;
|
|
op_UnaryNegation(): Vector2D;
|
|
set_Item(Index: number): $Ref<number>;
|
|
get_Item(Index: number): number;
|
|
Component(Index: number): $Ref<number>;
|
|
Component(Index: number): number;
|
|
static DotProduct(A: Vector2D, B: Vector2D): number;
|
|
static DistSquared(V1: Vector2D, V2: Vector2D): number;
|
|
static Distance(V1: Vector2D, V2: Vector2D): number;
|
|
static CrossProduct(A: Vector2D, B: Vector2D): number;
|
|
Equals(V: Vector2D, Tolerance: number): boolean;
|
|
Set(InX: number, InY: number): void;
|
|
GetMax(): number;
|
|
GetAbsMax(): number;
|
|
GetMin(): number;
|
|
Size(): number;
|
|
SizeSquared(): number;
|
|
GetRotated(AngleDeg: number): Vector2D;
|
|
GetSafeNormal(Tolerance: number): Vector2D;
|
|
Normalize(Tolerance: number): void;
|
|
IsNearlyZero(Tolerance: number): boolean;
|
|
ToDirectionAndLength(OutDir: $Ref<Vector2D>, OutLength: $Ref<number>): void;
|
|
IsZero(): boolean;
|
|
IntPoint(): IntPoint;
|
|
RoundToVector(): Vector2D;
|
|
ClampAxes(MinAxisVal: number, MaxAxisVal: number): Vector2D;
|
|
GetSignVector(): Vector2D;
|
|
GetAbs(): Vector2D;
|
|
ToString(): string;
|
|
InitFromString(InSourceString: string): boolean;
|
|
DiagnosticCheckNaN(): void;
|
|
ContainsNaN(): boolean;
|
|
SphericalToUnitCartesian(): Vector;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Vector2D__: boolean;
|
|
|
|
}
|
|
class Vector4 {
|
|
constructor(InVector: Vector, InW: number);
|
|
constructor(InColor: LinearColor);
|
|
constructor(InX: number, InY: number, InZ: number, InW: number);
|
|
constructor(InXY: Vector2D, InZW: Vector2D);
|
|
constructor(Param1: number);
|
|
X: number;
|
|
Y: number;
|
|
Z: number;
|
|
W: number;
|
|
set_Item(ComponentIndex: number): $Ref<number>;
|
|
get_Item(ComponentIndex: number): number;
|
|
op_UnaryNegation(): Vector4;
|
|
op_Addition(V: Vector4): Vector4;
|
|
op_Subtraction(V: Vector4): Vector4;
|
|
op_Multiply(Scale: number): Vector4;
|
|
op_Multiply(V: Vector4): Vector4;
|
|
op_Division(Scale: number): Vector4;
|
|
op_Division(V: Vector4): Vector4;
|
|
op_Equality(V: Vector4): boolean;
|
|
op_Inequality(V: Vector4): boolean;
|
|
op_ExclusiveOr(V: Vector4): Vector4;
|
|
Component(Index: number): $Ref<number>;
|
|
Component(Index: number): number;
|
|
Equals(V: Vector4, Tolerance: number): boolean;
|
|
IsUnit3(LengthSquaredTolerance: number): boolean;
|
|
ToString(): string;
|
|
InitFromString(InSourceString: string): boolean;
|
|
GetSafeNormal(Tolerance: number): Vector4;
|
|
GetUnsafeNormal3(): Vector4;
|
|
ToOrientationRotator(): Rotator;
|
|
ToOrientationQuat(): Quat;
|
|
Rotation(): Rotator;
|
|
Set(InX: number, InY: number, InZ: number, InW: number): void;
|
|
Size3(): number;
|
|
SizeSquared3(): number;
|
|
Size(): number;
|
|
SizeSquared(): number;
|
|
ContainsNaN(): boolean;
|
|
IsNearlyZero3(Tolerance: number): boolean;
|
|
Reflect3(Normal: Vector4): Vector4;
|
|
FindBestAxisVectors3(Axis1: $Ref<Vector4>, Axis2: $Ref<Vector4>): void;
|
|
DiagnosticCheckNaN(): void;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_Vector4__: boolean;
|
|
|
|
}
|
|
class IntPoint {
|
|
constructor();
|
|
constructor(InX: number, InY: number);
|
|
constructor(Param1: number);
|
|
X: number;
|
|
Y: number;
|
|
op_Equality(Other: IntPoint): boolean;
|
|
op_Inequality(Other: IntPoint): boolean;
|
|
op_Multiply(Scale: number): IntPoint;
|
|
op_Division(Divisor: number): IntPoint;
|
|
op_Division(Other: IntPoint): IntPoint;
|
|
op_Addition(Other: IntPoint): IntPoint;
|
|
op_Subtraction(Other: IntPoint): IntPoint;
|
|
set_Item(Index: number): $Ref<number>;
|
|
get_Item(Index: number): number;
|
|
ComponentMin(Other: IntPoint): IntPoint;
|
|
ComponentMax(Other: IntPoint): IntPoint;
|
|
GetMax(): number;
|
|
GetMin(): number;
|
|
Size(): number;
|
|
SizeSquared(): number;
|
|
ToString(): string;
|
|
static DivideAndRoundUp(lhs: IntPoint, Divisor: number): IntPoint;
|
|
static DivideAndRoundUp(lhs: IntPoint, Divisor: IntPoint): IntPoint;
|
|
static DivideAndRoundDown(lhs: IntPoint, Divisor: number): IntPoint;
|
|
static Num(): number;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_IntPoint__: boolean;
|
|
|
|
}
|
|
class IntVector {
|
|
constructor();
|
|
constructor(InX: number, InY: number, InZ: number);
|
|
constructor(InValue: number);
|
|
constructor(InVector: Vector);
|
|
constructor(Param1: number);
|
|
X: number;
|
|
Y: number;
|
|
Z: number;
|
|
get_Item(ComponentIndex: number): number;
|
|
set_Item(ComponentIndex: number): $Ref<number>;
|
|
op_Equality(Other: IntVector): boolean;
|
|
op_Inequality(Other: IntVector): boolean;
|
|
op_Multiply(Scale: number): IntVector;
|
|
op_Division(Divisor: number): IntVector;
|
|
op_Addition(Other: IntVector): IntVector;
|
|
op_Subtraction(Other: IntVector): IntVector;
|
|
IsZero(): boolean;
|
|
GetMax(): number;
|
|
GetMin(): number;
|
|
Size(): number;
|
|
ToString(): string;
|
|
static DivideAndRoundUp(lhs: IntVector, Divisor: number): IntVector;
|
|
static Num(): number;
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_IntVector__: boolean;
|
|
|
|
}
|
|
class FMatrix {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_FMatrix__: boolean;
|
|
|
|
}
|
|
namespace FStructuredArchive {
|
|
class FSlot {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_FSlot__: boolean;
|
|
|
|
}
|
|
}
|
|
class FArchive {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_FArchive__: boolean;
|
|
|
|
}
|
|
class TSizedDefaultAllocator<T> {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_TSizedDefaultAllocatorT__: boolean;
|
|
|
|
}
|
|
class FPlane {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_FPlane__: boolean;
|
|
|
|
}
|
|
class FFloat16Color {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_FFloat16Color__: boolean;
|
|
|
|
}
|
|
class UPackageMap {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_UPackageMap__: boolean;
|
|
|
|
}
|
|
class FIntVector4 {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_FIntVector4__: boolean;
|
|
|
|
}
|
|
class VectorRegister {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_VectorRegister__: boolean;
|
|
|
|
}
|
|
class ScalarRegister {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_ScalarRegister__: boolean;
|
|
|
|
}
|
|
class FOutputDevice {
|
|
constructor();
|
|
|
|
/**
|
|
* @deprecated use StaticStruct instead.
|
|
*/
|
|
static StaticClass(): ScriptStruct;
|
|
static StaticStruct(): ScriptStruct;
|
|
|
|
private __tid_FOutputDevice__: boolean;
|
|
|
|
}
|
|
|
|
} |