internal static unsafe void Invoke(IntPtr obj, ETeleportType InTeleportType)
{
long *p = stackalloc long[] { 0L, 0L };
byte *b = (byte *)p;
*(b + 0) = (byte)InTeleportType;
Main.GetProcessEvent(obj, ResetDynamics_ptr, new IntPtr(p));;
}
}
/// <summary>
/// Move the actor instantly to the specified location and rotation.
/// </summary>
/// <param name="newLocation">The new location to teleport the Actor to.</param>
/// <param name="newRotation">The new rotation for the Actor.</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">How we teleport the physics state (if physics collision is enabled for this object).
/// If equal to ETeleportType::TeleportPhysics, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If equal to ETeleportType::None, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
/// <returns>Whether the rotation was successfully set.</returns>
public bool SetActorLocationAndRotation(FVector newLocation, FQuat newRotation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
return(Native_AActor.SetActorLocationAndRotationQuat(this.Address, ref newLocation, ref newRotation, sweep, (int)teleport));
}
protected virtual bool MoveUpdatedComponentImpl(FVector Delta, FQuat NewRotation, bool bSweep, FHitResult OutHit, ETeleportType Teleport) => E_UMovementComponent_MoveUpdatedComponentImpl(this, Delta, NewRotation, bSweep, OutHit, (byte)Teleport);
public bool SafeMoveUpdatedComponent(FVector delta, FRotator newRotation, bool bSweep, FHitResult outHit, ETeleportType teleport) => E_UMovementComponent_SafeMoveUpdatedComponent_o1(this, delta, newRotation, bSweep, outHit, (byte)teleport);
///<summary>Reset any dynamics running simulation-style updates (e.g. on teleport, time skip etc.)</summary> public void ResetDynamics(ETeleportType InTeleportType) => AnimInstance_methods.ResetDynamics_method.Invoke(ObjPointer, InTeleportType);
/// <summary>
/// Set the actor's RootComponent to the specified relative rotation
/// </summary>
/// <param name="NewRelativeRotation">New relative rotation of the actor's root component</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
public void SetActorRelativeRotation(FQuat newRelativeRotation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_AActor.SetActorRelativeRotationQuat(this.Address, ref newRelativeRotation, sweep, (int)teleport);
}
/// <summary>
/// Adds a delta to the transform of this component in its local reference frame
/// </summary>
/// <param name="newTransform">The change in transform in local space.</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
public void AddActorLocalTransform(FTransform newTransform, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_AActor.AddActorLocalTransform(this.Address, ref newTransform, sweep, (int)teleport);
}
/// <summary>
/// Adds a delta to the location of this component in its local reference frame.
/// </summary>
/// <param name="deltaLocation">The change in location in local space.</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
public void AddActorLocalOffset(FVector deltaLocation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_AActor.AddActorLocalOffset(this.Address, ref deltaLocation, sweep, (int)teleport);
}
/// <summary>
/// Adds a delta to the transform of the component in world space. Scale is unchanged.
/// </summary>
/// <param name="deltaTransform">Change in transform in world space for the component. Scale is unchanged.</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire sweep volume.</param>
public void AddWorldTransform(FTransform deltaTransform, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_USceneComponent.AddWorldTransform(this.Address, ref deltaTransform, sweep, (int)teleport);
}
/// <summary>
/// Adds a delta to the rotation of the component in world space.
/// </summary>
/// <param name="deltaRotation">Change in rotation in world space for the component.</param>
/// <param name="sweep">Whether we sweep to the destination (currently not supported for rotation).</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire sweep volume.</param>
public void AddWorldRotation(FQuat deltaRotation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_USceneComponent.AddWorldRotationQuat(this.Address, ref deltaRotation, sweep, (int)teleport);
}
/// <summary>
/// Adds a delta to the location of the component in world space.
/// </summary>
/// <param name="deltaLocation">Change in location in world space for the component.</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire sweep volume.</param>
public void AddWorldOffset(FVector deltaLocation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_USceneComponent.AddWorldOffset(this.Address, ref deltaLocation, sweep, (int)teleport);
}
/// <summary>
/// Put this component at the specified rotation in world space. Updates relative rotation to achieve the final world rotation.
/// </summary>
/// <param name="newRotation">New rotation in world space for the component.</param>
/// <param name="sweep">Whether we sweep to the destination (currently not supported for rotation).</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire sweep volume.</param>
public void SetWorldRotation(FRotator newRotation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_USceneComponent.SetWorldRotation(this.Address, ref newRotation, sweep, (int)teleport);
}
/// <summary>
/// Adds a delta to the rotation of the component in its local reference frame
/// </summary>
/// <param name="deltaRotation">Change in rotation of the component in its local reference frame.</param>
/// <param name="sweep">Whether we sweep to the destination (currently not supported for rotation).</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).</param>
public void AddLocalRotation(FRotator deltaRotation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_USceneComponent.AddLocalRotation(this.Address, ref deltaRotation, sweep, (int)teleport);
}
/// <summary>
/// Set the transform of the component relative to its parent
/// </summary>
/// <param name="newTransform">New transform of the component relative to its parent.</param>
/// <param name="sweep">Whether we sweep to the destination (currently not supported for rotation).</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).</param>
public void SetRelativeTransform(FTransform newTransform, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_USceneComponent.SetRelativeTransform(this.Address, ref newTransform, sweep, (int)teleport);
}
/// <summary>
/// Adds a delta to the rotation of this actor in world space.
/// </summary>
/// <param name="deltaRotation">The change in rotation.</param>
/// <param name="sweep">Whether to sweep to the target rotation (not currently supported for rotation).</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
public void AddActorWorldRotation(FRotator deltaRotation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_AActor.AddActorWorldRotation(this.Address, ref deltaRotation, sweep, (int)teleport);
}
/// <summary>
/// Set the Actors transform to the specified one.
/// </summary>
/// <param name="newTransform">The new transform.</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
/// <returns></returns>
public bool SetActorTransform(FTransform newTransform, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
return(Native_AActor.SetActorTransform(this.Address, ref newTransform, sweep, (int)teleport));
}
public unsafe bool MoveComponent(FVector delta, FRotator newRotation, bool sweep, out FHitResult hit, EMoveComponentFlags moveFlags = EMoveComponentFlags.NoFlags, ETeleportType teleport = ETeleportType.None)
{
byte *buff = stackalloc byte[StructDefault <FHitResult> .Size];
bool result = Native_USceneComponent.MoveComponentRot(this.Address, ref delta, ref newRotation, sweep, (IntPtr)buff, (int)moveFlags, (int)teleport);
hit = new FHitResult((IntPtr)buff);
return(result);
}
/// <summary>
/// Adds a delta to the rotation of this component in its local reference frame
/// </summary>
/// <param name="deltaRotation">The change in rotation in local space.</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.
/// Whether we teleport the physics state (if physics collision is enabled for this object).</param>
/// <param name="teleport">If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
public void AddActorLocalRotation(FQuat deltaRotation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_AActor.AddActorLocalRotationQuat(this.Address, ref deltaRotation, sweep, (int)teleport);
}
public bool MoveComponent(FVector delta, FRotator newRotation, bool sweep, EMoveComponentFlags moveFlags = EMoveComponentFlags.NoFlags, ETeleportType teleport = ETeleportType.None)
{
return(Native_USceneComponent.MoveComponentRotNoHit(this.Address, ref delta, ref newRotation, sweep, (int)moveFlags, (int)teleport));
}
/// <summary>
/// Set the actor's RootComponent to the specified relative location.
/// </summary>
/// <param name="newRelativeLocation">New relative location of the actor's root component</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
public void SetActorRelativeLocation(FVector newRelativeLocation, bool sweep, ETeleportType teleport = ETeleportType.None)
{
Native_AActor.SetActorRelativeLocation(this.Address, ref newRelativeLocation, sweep, (int)teleport);
}
/// <summary>
/// Set the rotation of the component relative to its parent and force RelativeRotation to be equal to new rotation.
/// This allows us to set and save Rotators with angles out side the normalized range, Note that doing so may break the
/// RotatorCache so use with care.
/// </summary>
/// <param name="newRotation"></param>
/// <param name="hitResult">Hit result from any impact if sweep is true.</param>
/// <param name="sweep">Whether we sweep to the destination (currently not supported for rotation).</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).</param>
public unsafe void SetRelativeRotationExact(FRotator newRotation, out FHitResult hitResult, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
byte *buff = stackalloc byte[StructDefault <FHitResult> .Size];
Native_USceneComponent.SetRelativeRotationExactHR(this.Address, ref newRotation, sweep, (IntPtr)buff, (int)teleport);
hitResult = new FHitResult((IntPtr)buff);
}
/// <summary>
/// Set the actor's RootComponent to the specified relative transform
/// </summary>
/// <param name="newRelativeTransform">New relative transform of the actor's root component</param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire swept volume.</param>
public void SetActorRelativeTransform(FTransform newRelativeTransform, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_AActor.SetActorRelativeTransform(this.Address, ref newRelativeTransform, sweep, (int)teleport);
}
/// <summary>
/// Set the location of the component relative to its parent
/// </summary>
/// <param name="newLocation">New location of the component relative to its parent. </param>
/// <param name="sweep">Whether we sweep to the destination location, triggering overlaps along the way and stopping short of the target if blocked by something.
/// Only the root component is swept and checked for blocking collision, child components move without sweeping. If collision is off, this has no effect.</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).
/// If CCD is on and not teleporting, this will affect objects along the entire sweep volume.</param>
public void SetRelativeLocation(FVector newLocation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_USceneComponent.SetRelativeLocation(this.Address, ref newLocation, sweep, (int)teleport);
}
protected virtual bool MoveUpdatedComponentImpl(FVector delta, FQuat newRotation, bool bSweep, FHitResult outHit, ETeleportType teleport) => E_UMovementComponent_MoveUpdatedComponentImpl(this, delta, newRotation, bSweep, outHit, (byte)teleport);
/// <summary>
/// Set the rotation of the component relative to its parent
/// </summary>
/// <param name="newRotation">New rotation of the component relative to its parent</param>
/// <param name="sweep">Whether we sweep to the destination (currently not supported for rotation).</param>
/// <param name="teleport">Whether we teleport the physics state (if physics collision is enabled for this object).
/// If true, physics velocity for this object is unchanged (so ragdoll parts are not affected by change in location).
/// If false, physics velocity is updated based on the change in position (affecting ragdoll parts).</param>
public void SetRelativeRotation(FQuat newRotation, bool sweep = false, ETeleportType teleport = ETeleportType.None)
{
Native_USceneComponent.SetRelativeRotationQuat(this.Address, ref newRotation, sweep, (int)teleport);
}
/// <summary>
/// <para>Recalculate the value of our component to world transform </para>
/// </summary>
public override void UpdateComponentToWorld(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport)
{
}
/// <summary>
/// Native callback when this component is moved
/// </summary>
protected override void OnUpdateTransform(EUpdateTransformFlags updateTransformFlags, ETeleportType teleport)
{
}