/// <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); }