/// <summary>
/// Add a hitbox to the hud
/// @param Position Coordinates of the top left of the hit box.
/// @param Size Size of the hit box.
/// @param Name Name of the hit box.
/// @param bConsumesInput Whether click processing should continue if this hit box is clicked.
/// @param Priority The priority of the box used for layering. Larger values are considered first. Equal values are considered in the order they were added.
/// </summary>
public void AddHitBox(FVector2D Position, FVector2D Size, string InName, bool bConsumesInput, int Priority = 0)
{
CheckIsValid();
AddHitBox(_this.Get(), ref Position, ref Size, InName, bConsumesInput?1:0, Priority);
}
/// <summary> /// Vector transformation is equivalent to point transformation as our matrix is not homogeneous. /// </summary> public FVector2D TransformVector(FVector2D vector) => E_FMatrix2x2_TransformVector(this, vector);
extern static void SetEndScale(IntPtr _this, ref FVector2D EndScale, int bUpdateMesh);
public void SetRenderShear(FVector2D Shear)
{
CheckIsValid();
SetRenderShear(_this.Get(), ref Shear);
}
public void SetRenderScale(FVector2D Scale)
{
CheckIsValid();
SetRenderScale(_this.Get(), ref Scale);
}
public void SetRenderTransformPivot(FVector2D Pivot)
{
CheckIsValid();
SetRenderTransformPivot(_this.Get(), ref Pivot);
}
public void SetRenderTranslation(FVector2D Translation)
{
CheckIsValid();
SetRenderTranslation(_this.Get(), ref Translation);
}
static extern void DrawMaterial(IntPtr _this, IntPtr Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float MaterialU, float MaterialV, float MaterialUWidth, float MaterialVHeight, float Scale, int bScalePosition, float Rotation, ref FVector2D RotPivot);
/// <summary> /// Draws text. /// @param Text The string to draw. /// @param Position The starting position where the text is drawn in local space. /// @param Tint Color to render the line. /// </summary> public extern static void DrawTextFormatted(out FPaintContext Context, FText Text, FVector2D Position, UFont Font, int FontSize = 16, FName FontTypeFace = default(FName), FLinearColor Tint = default(FLinearColor));
public void DrawMaterialTriangle(UMaterialInterface Material, FVector2D V0_Pos, FVector2D V1_Pos, FVector2D V2_Pos, FVector2D V0_UV, FVector2D V1_UV, FVector2D V2_UV, FLinearColor V0_Color = default(FLinearColor), FLinearColor V1_Color = default(FLinearColor), FLinearColor V2_Color = default(FLinearColor))
{
CheckIsValid();
DrawMaterialTriangle(_this.Get(), Material, ref V0_Pos, ref V1_Pos, ref V2_Pos, ref V0_UV, ref V1_UV, ref V2_UV, ref V0_Color, ref V1_Color, ref V2_Color);
}
static extern void AddHitBox(IntPtr _this, ref FVector2D Position, ref FVector2D Size, string InName, int bConsumesInput, int Priority);
static extern void DrawMaterialTriangle(IntPtr _this, IntPtr Material, ref FVector2D V0_Pos, ref FVector2D V1_Pos, ref FVector2D V2_Pos, ref FVector2D V0_UV, ref FVector2D V1_UV, ref FVector2D V2_UV, ref FLinearColor V0_Color, ref FLinearColor V1_Color, ref FLinearColor V2_Color);
/// <summary>
/// Returns the array of actors inside a selection rectangle, with a class filter.
/// Sample usage:
/// TArray<AStaticMeshActor*> ActorsInSelectionRect;
/// Canvas->GetActorsInSelectionRectangle<AStaticMeshActor>(FirstPoint,SecondPoint,ActorsInSelectionRect);
/// @param FirstPoint The first point, or anchor of the marquee box. Where the dragging of the marquee started in screen space.
/// @param SecondPoint The second point, where the mouse cursor currently is / the other point of the box selection, in screen space.
/// @return OutActors The actors that are within the selection box according to selection rule
/// @param bIncludeNonCollidingComponents Whether to include even non-colliding components of the actor when determining its bounds
/// @param bActorMustBeFullyEnclosed The Selection rule: whether the selection box can partially intersect Actor, or must fully enclose the Actor.
/// </summary>
public void GetActorsInSelectionRectangle(TSubclassOf <AActor> ClassFilter, FVector2D FirstPoint, FVector2D SecondPoint, out AActor[] OutActors, bool bIncludeNonCollidingComponents = true, bool bActorMustBeFullyEnclosed = false)
{
CheckIsValid();
IntPtr[] OutActors_temp;
GetActorsInSelectionRectangle(_this.Get(), ClassFilter.NativeClass, ref FirstPoint, ref SecondPoint, out OutActors_temp, bIncludeNonCollidingComponents?1:0, bActorMustBeFullyEnclosed?1:0);
OutActors = MarshalUtil.IntPtrArrayToObjectArray <AActor>(OutActors_temp);
}
static extern void GetActorsInSelectionRectangle(IntPtr _this, IntPtr ClassFilter, ref FVector2D FirstPoint, ref FVector2D SecondPoint, out IntPtr[] OutActors, int bIncludeNonCollidingComponents, int bActorMustBeFullyEnclosed);
/// <summary>Sets the inner slot padding goes between slots sharing borders</summary> public extern void SetInnerSlotPadding(FVector2D InPadding);
/// <summary> /// Draws a line. /// @param PositionA Starting position of the line in local space. /// @param PositionB Ending position of the line in local space. /// @param Thickness How many pixels thick this line should be. /// @param Tint Color to render the line. /// </summary> public extern static void DrawLine(out FPaintContext Context, FVector2D PositionA, FVector2D PositionB, FLinearColor Tint = default(FLinearColor), bool bAntiAlias = true);
extern static void SetRenderTransformPivot(IntPtr _this, ref FVector2D Pivot);
/// <summary>Draws a box</summary> public extern static void DrawBox(out FPaintContext Context, FVector2D Position, FVector2D Size, USlateBrushAsset Brush, FLinearColor Tint = default(FLinearColor));
extern static void SetRenderTranslation(IntPtr _this, ref FVector2D Translation);
/// <summary>Gets the amount of padding that needs to be added when accounting for the safe zone on TVs.</summary> public extern static void GetSafeZonePadding(UObject WorldContextObject, out FVector2D SafePadding, out FVector2D SafePaddingScale, out FVector2D SpillOverPadding);
extern static void SetRenderShear(IntPtr _this, ref FVector2D Shear);
public extern static FEventReply SetMousePosition(out FEventReply Reply, FVector2D NewMousePosition);
extern static void SetRenderScale(IntPtr _this, ref FVector2D Scale);
/// <summary> /// Tell client to fade camera /// @Param bEnableFading - true if we should apply FadeColor/FadeAmount to the screen /// @Param FadeColor - Color to fade to /// @Param FadeAlpha - Amount of fading to apply /// @Param FadeTime - length of time for fade to occur over /// @Param bFadeAudio - true to apply fading of audio alongside the video /// </summary> public extern virtual void ClientSetCameraFade(bool bEnableFading, FColor FadeColor, FVector2D FadeAlpha, float FadeTime, bool bFadeAudio);
/// <summary> /// Transform a 2D point /// <para>[X Y] * [m00 m01] </para> /// [m10 m11] /// </summary> public FVector2D TransformPoint(FVector2D point) => E_FMatrix2x2_TransformPoint(this, point);
/// <summary> /// Convert a World Space 3D position into a 2D Screen Space position. /// @return true if the world coordinate was successfully projected to the screen. /// </summary> public extern bool ProjectWorldLocationToScreen(FVector WorldLocation, out FVector2D ScreenLocation, bool bPlayerViewportRelative = false);
/// <summary>
/// Creates and initializes a new vector from the specified 2D vectors.
/// </summary>
/// <param name="inXY">A 2D vector holding the X- and Y-components.</param>
/// <param name="inZW">A 2D vector holding the Z- and W-components.</param>
public FVector4(FVector2D inXY, FVector2D inZW) :
base(E_CreateStruct_FVector4_FVector2D_FVector2D(inXY, inZW), false)
{
}
/// <summary> /// Sets the offset that the text drop shadow should be drawn at /// @param InShadowOffset The new offset /// </summary> public extern void SetShadowOffset(FVector2D InShadowOffset);
/// <summary>Set the end scaling</summary>
public void SetEndScale(FVector2D EndScale = default(FVector2D), bool bUpdateMesh = true)
{
CheckIsValid();
SetEndScale(_this.Get(), ref EndScale, bUpdateMesh?1:0);
}
/// <summary>
/// Draws a textured quad on the HUD.
/// @param Texture Texture to draw.
/// @param ScreenX Screen-space X coordinate of upper left corner of the quad.
/// @param ScreenY Screen-space Y coordinate of upper left corner of the quad.
/// @param ScreenW Screen-space width of the quad (in pixels).
/// @param ScreenH Screen-space height of the quad (in pixels).
/// @param TextureU Texture-space U coordinate of upper left corner of the quad
/// @param TextureV Texture-space V coordinate of upper left corner of the quad.
/// @param TextureUWidth Texture-space width of the quad (in normalized UV distance).
/// @param TextureVHeight Texture-space height of the quad (in normalized UV distance).
/// @param TintColor Vertex color for the quad.
/// @param BlendMode Controls how to blend this quad with the scene. Translucent by default.
/// @param Scale Amount to scale the entire texture (horizontally and vertically)
/// @param bScalePosition Whether the "Scale" parameter should also scale the position of this draw call.
/// @param Rotation Amount to rotate this quad
/// @param RotPivot Location (as proportion of quad, 0-1) to rotate about
/// </summary>
public void DrawTexture(UTexture Texture, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float TextureU, float TextureV, float TextureUWidth, float TextureVHeight, FLinearColor TintColor = default(FLinearColor), EBlendMode BlendMode = EBlendMode.BLEND_Translucent, float Scale = 1.000000f, bool bScalePosition = false, float Rotation = 0.000000f, FVector2D RotPivot = default(FVector2D))
{
CheckIsValid();
DrawTexture(_this.Get(), Texture, ScreenX, ScreenY, ScreenW, ScreenH, TextureU, TextureV, TextureUWidth, TextureVHeight, ref TintColor, (int)BlendMode, Scale, bScalePosition?1:0, Rotation, ref RotPivot);
}
