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