/// <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);
}
public AActor Spawn(TSubclassOf<AActor> ActorClass)
{
CheckIsValid();
IntPtr ___ret = Spawn(_this.Get(),ActorClass.NativeClass);
if(___ret==IntPtr.Zero) return null; AActor ___ret2= new AActor(){ _this = ___ret }; return ___ret2;
}
/// <summary>
/// Returns a list of actors that this component is overlapping.
/// @param OverlappingActors [out] Returned list of overlapping actors
/// @param ClassFilter [optional] If set, only returns actors of this class or subclasses
/// </summary>
public void GetOverlappingActors(out AActor[] OverlappingActors, TSubclassOf <AActor> ClassFilter)
{
CheckIsValid();
IntPtr[] OverlappingActors_temp;
GetOverlappingActors(_this.Get(), out OverlappingActors_temp, ClassFilter.NativeClass);
OverlappingActors = MarshalUtil.IntPtrArrayToObjectArray <AActor>(OverlappingActors_temp);
}
/// <summary>
/// Creates a new drag and drop operation that can be returned from a drag begin to inform the UI what i
/// being dragged and dropped and what it looks like.
/// </summary>
public static UDragDropOperation CreateDragDropOperation(TSubclassOf <UDragDropOperation> OperationClass)
{
IntPtr ___ret = CreateDragDropOperation(IntPtr.Zero, OperationClass.NativeClass);
if (___ret == IntPtr.Zero)
{
return(null);
}
UDragDropOperation ___ret2 = new UDragDropOperation()
{
_this = ___ret
}; return(___ret2);
}
/// <summary>Creates a widget</summary>
public static UUserWidget Create(UObject WorldContextObject, TSubclassOf <UUserWidget> WidgetType, APlayerController OwningPlayer)
{
IntPtr ___ret = Create(IntPtr.Zero, WorldContextObject, WidgetType.NativeClass, OwningPlayer);
if (___ret == IntPtr.Zero)
{
return(null);
}
UUserWidget ___ret2 = new UUserWidget()
{
_this = ___ret
}; return(___ret2);
}
/// <summary>
/// Creates and initializes a new camera modifier of the specified class.
/// @param ModifierClass - The class of camera modifier to create.
/// @return Returns the newly created camera modifier.
/// </summary>
public UCameraModifier AddNewCameraModifier(TSubclassOf <UCameraModifier> ModifierClass)
{
CheckIsValid();
IntPtr ___ret = AddNewCameraModifier(_this.Get(), ModifierClass.NativeClass);
if (___ret == IntPtr.Zero)
{
return(null);
}
UCameraModifier ___ret2 = new UCameraModifier()
{
_this = ___ret
}; return(___ret2);
}
/// <summary>
/// Creates a camera lens effect of the given class on this camera.
/// @param LensEffectEmitterClass - Class of lens effect emitter to create.
/// @return Returns the new emitter actor.
/// </summary>
public AEmitterCameraLensEffectBase AddCameraLensEffect(TSubclassOf <AEmitterCameraLensEffectBase> LensEffectEmitterClass)
{
CheckIsValid();
IntPtr ___ret = AddCameraLensEffect(_this.Get(), LensEffectEmitterClass.NativeClass);
if (___ret == IntPtr.Zero)
{
return(null);
}
AEmitterCameraLensEffectBase ___ret2 = new AEmitterCameraLensEffectBase()
{
_this = ___ret
}; return(___ret2);
}
/// <summary>
/// Plays a camera shake on this camera.
/// @param Shake - The class of camera shake to play.
/// @param Scale - Scalar defining how "intense" to play the shake. 1.0 is normal (as authored).
/// @param PlaySpace - Which coordinate system to play the shake in (affects oscillations and camera anims)
/// @param UserPlaySpaceRot - Coordinate system to play shake when PlaySpace == CAPS_UserDefined.
/// </summary>
public UCameraShake PlayCameraShake(TSubclassOf <UCameraShake> ShakeClass, float Scale = 1.000000f, ECameraAnimPlaySpace PlaySpace = ECameraAnimPlaySpace.CameraLocal, FRotator UserPlaySpaceRot = default(FRotator))
{
CheckIsValid();
IntPtr ___ret = PlayCameraShake(_this.Get(), ShakeClass.NativeClass, Scale, (int)PlaySpace, ref UserPlaySpaceRot);
if (___ret == IntPtr.Zero)
{
return(null);
}
UCameraShake ___ret2 = new UCameraShake()
{
_this = ___ret
}; return(___ret2);
}
/// <summary>
/// Performs navigation raycast on NavigationData appropriate for given Querier.
/// @param Querier if not passed default navigation data will be used
/// @param HitLocation if line was obstructed this will be set to hit location. Otherwise it contains SegmentEnd
/// @return true if line from RayStart to RayEnd was obstructed. Also, true when no navigation data present
/// </summary>
public static bool NavigationRaycast(UObject WorldContext, FVector RayStart, FVector RayEnd, out FVector HitLocation, TSubclassOf <UNavigationQueryFilter> FilterClass, AController Querier)
{
int ___ret = NavigationRaycast(IntPtr.Zero, WorldContext, ref RayStart, ref RayEnd, out HitLocation, FilterClass.NativeClass, Querier);
return(___ret != 0);
}
/// <summary>
/// Finds path instantly, in a FindPath Synchronously. Main advantage over FindPathToLocationSynchronously is that
/// the resulting path will automatically get updated if goal actor moves more than TetherDistance away from last path node
/// @param PathfindingContext could be one of following: NavigationData (like Navmesh actor), Pawn or Controller. This parameter determines parameters of specific pathfinding query
/// </summary>
public static UNavigationPath FindPathToActorSynchronously(UObject WorldContext, FVector PathStart, AActor GoalActor, float TetherDistance = 50.000000f, AActor PathfindingContext = default(AActor), TSubclassOf <UNavigationQueryFilter> FilterClass = default(TSubclassOf <UNavigationQueryFilter>))
{
IntPtr ___ret = FindPathToActorSynchronously(IntPtr.Zero, WorldContext, ref PathStart, GoalActor, TetherDistance, PathfindingContext, FilterClass.NativeClass);
if (___ret == IntPtr.Zero)
{
return(null);
}
UNavigationPath ___ret2 = new UNavigationPath()
{
_this = ___ret
}; return(___ret2);
}
/// <summary>
/// Find all widgets of a certain class.
/// @param FoundWidgets The widgets that were found matching the filter.
/// @param WidgetClass The widget class to filter by.
/// @param TopLevelOnly Only the widgets that are direct children of the viewport will be returned.
/// </summary>
public static void GetAllWidgetsOfClass(UObject WorldContextObject, out UUserWidget[] FoundWidgets, TSubclassOf <UUserWidget> WidgetClass, bool TopLevelOnly = true)
{
IntPtr[] FoundWidgets_temp;
GetAllWidgetsOfClass(IntPtr.Zero, WorldContextObject, out FoundWidgets_temp, WidgetClass.NativeClass, TopLevelOnly?1:0);
FoundWidgets = MarshalUtil.IntPtrArrayToObjectArray <UUserWidget>(FoundWidgets_temp);
}
/// <summary>View from the point of view of an AActor of class DesiredClass. Each subsequent ViewClass cycles through the list of actors of that class.</summary> public extern virtual void ViewClass(TSubclassOf <AActor> DesiredClass);
/// <summary>Destroy all actors of class aClass</summary> public extern virtual void DestroyAll(TSubclassOf <AActor> aClass);
/// <summary>Destroys (by calling destroy directly) all non-player pawns of class aClass in the level</summary> public extern virtual void DestroyPawns(TSubclassOf <APawn> aClass);
/// <summary> /// Finds path instantly, in a FindPath Synchronously. /// @param PathfindingContext could be one of following: NavigationData (like Navmesh actor), Pawn or Controller. This parameter determines parameters of specific pathfinding query /// </summary> public extern static UNavigationPath FindPathToLocationSynchronously(UObject WorldContext, FVector PathStart, FVector PathEnd, AActor PathfindingContext, TSubclassOf <UNavigationQueryFilter> FilterClass);
/// <summary>Project a point onto the NavigationData</summary>
public static bool ProjectPointToNavigation(UObject WorldContext, FVector Point, out FVector ProjectedLocation, ANavigationData NavData, TSubclassOf <UNavigationQueryFilter> FilterClass, FVector QueryExtent)
{
int ___ret = K2_ProjectPointToNavigation(IntPtr.Zero, WorldContext, ref Point, out ProjectedLocation, NavData, FilterClass.NativeClass, ref QueryExtent);
return(___ret != 0);
}
/// <summary>Toggles 'ShowDebug' from showing debug info between reticle target actor (of subclass <DesiredClass>) and camera view target</summary>
public void ShowDebugForReticleTargetToggle(TSubclassOf <AActor> DesiredClass)
{
CheckIsValid();
ShowDebugForReticleTargetToggle(_this.Get(), DesiredClass.NativeClass);
}
/// <summary>Project a point onto the NavigationData</summary> public extern static FVector ProjectPointToNavigation(UObject WorldContext, FVector Point, ANavigationData NavData, TSubclassOf <UNavigationQueryFilter> FilterClass, FVector QueryExtent);
public extern static FVector GetRandomReachablePointInRadius(UObject WorldContext, FVector Origin, float Radius, ANavigationData NavData, TSubclassOf <UNavigationQueryFilter> FilterClass);
/// <summary>Potentially expensive. Use with caution. Consider using UPathFollowingComponent::GetRemainingPathCost instead</summary> public extern static ENavigationQueryResult GetPathCost(UObject WorldContext, FVector PathStart, FVector PathEnd, out float PathCost, ANavigationData NavData, TSubclassOf <UNavigationQueryFilter> FilterClass);
/// <summary>
/// Find all widgets in the world with the specified interface.
/// This is a slow operation, use with caution e.g. do not use every frame.
/// @param Interface The interface to find. Must be specified or result array will be empty.
/// @param FoundWidgets Output array of widgets that implement the specified interface.
/// @param TopLevelOnly Only the widgets that are direct children of the viewport will be returned.
/// </summary>
public static void GetAllWidgetsWithInterface(UObject WorldContextObject, TSubclassOf <UInterface> Interface, out UUserWidget[] FoundWidgets, bool TopLevelOnly)
{
IntPtr[] FoundWidgets_temp;
GetAllWidgetsWithInterface(IntPtr.Zero, WorldContextObject, Interface.NativeClass, out FoundWidgets_temp, TopLevelOnly?1:0);
FoundWidgets = MarshalUtil.IntPtrArrayToObjectArray <UUserWidget>(FoundWidgets_temp);
}
/// <summary> /// Performs navigation raycast on NavigationData appropriate for given Querier. /// @param Querier if not passed default navigation data will be used /// @param HitLocation if line was obstructed this will be set to hit location. Otherwise it contains SegmentEnd /// @return true if line from RayStart to RayEnd was obstructed. Also, true when no navigation data present /// </summary> public extern static bool NavigationRaycast(UObject WorldContext, FVector RayStart, FVector RayEnd, out FVector HitLocation, TSubclassOf <UNavigationQueryFilter> FilterClass, AController Querier);
/// <summary>Stops playing CameraShake of the given class.</summary>
public void StopAllInstancesOfCameraShake(TSubclassOf <UCameraShake> Shake, bool bImmediately = true)
{
CheckIsValid();
StopAllInstancesOfCameraShake(_this.Get(), Shake.NativeClass, bImmediately?1:0);
}
/// <summary> /// Finds path instantly, in a FindPath Synchronously. Main advantage over FindPathToLocationSynchronously is that /// the resulting path will automatically get updated if goal actor moves more than TetherDistance away from last path node /// @param PathfindingContext could be one of following: NavigationData (like Navmesh actor), Pawn or Controller. This parameter determines parameters of specific pathfinding query /// </summary> public extern static UNavigationPath FindPathToActorSynchronously(UObject WorldContext, FVector PathStart, AActor GoalActor, float TetherDistance = 50.000000f, AActor PathfindingContext = default(AActor), TSubclassOf <UNavigationQueryFilter> FilterClass = default(TSubclassOf <UNavigationQueryFilter>));
public void SetChildActorClass(TSubclassOf <AActor> InClass)
{
CheckIsValid();
SetChildActorClass(_this.Get(), InClass.NativeClass);
}
/// <summary>
/// Generates a random location reachable from given Origin location.
/// @return Return Value represents if the call was successful
/// </summary>
public static bool GetRandomReachablePointInRadius(UObject WorldContext, FVector Origin, out FVector RandomLocation, float Radius, ANavigationData NavData, TSubclassOf <UNavigationQueryFilter> FilterClass)
{
int ___ret = K2_GetRandomReachablePointInRadius(IntPtr.Zero, WorldContext, ref Origin, out RandomLocation, Radius, NavData, FilterClass.NativeClass);
return(___ret != 0);
}
/// <summary>
/// Creates a new canvas render target and initializes it to the specified dimensions
/// @param WorldContextObject The world where this render target will be rendered for
/// @param CanvasRenderTarget2DClass Class of the render target. Unless you want to use a special sub-class, you can simply pass UCanvasRenderTarget2D::StaticClass() here.
/// @param Width Width of the render target.
/// @param Height Height of the render target.
/// @return Returns the instanced render target.
/// </summary>
public static UCanvasRenderTarget2D CreateCanvasRenderTarget2D(UObject WorldContextObject, TSubclassOf <UCanvasRenderTarget2D> CanvasRenderTarget2DClass, int Width = 1024, int Height = 1024)
{
IntPtr ___ret = CreateCanvasRenderTarget2D(IntPtr.Zero, WorldContextObject, CanvasRenderTarget2DClass.NativeClass, Width, Height);
if (___ret == IntPtr.Zero)
{
return(null);
}
UCanvasRenderTarget2D ___ret2 = new UCanvasRenderTarget2D()
{
_this = ___ret
}; return(___ret2);
}
/// <summary>Script exposed version of FindComponentByClass</summary> public extern UActorComponent GetComponentByClass(TSubclassOf <UActorComponent> ComponentClass);
/// <summary>Toggles 'ShowDebug' from showing debug info between reticle target actor (of subclass <DesiredClass>) and camera view target</summary> public extern void ShowDebugForReticleTargetToggle(TSubclassOf <AActor> DesiredClass);
public extern void SetAreaClass(TSubclassOf <UNavArea> NewAreaClass);
