Expose pawn yaw, pitch, and roll control rotation matching functionality

API/Pawn-ControllerRotationPitch.md

@@ -0,0 +1,8 @@
+### [UnrealEngine.Framework](./UnrealEngine-Framework.md 'UnrealEngine.Framework').[Pawn](./Pawn.md 'UnrealEngine.Framework.Pawn')
+## Pawn.ControllerRotationPitch Property
+Gets or sets whether pitch will be updated to match the controller's control rotation pitch, if controlled by a [PlayerController](./PlayerController.md 'UnrealEngine.Framework.PlayerController') 
+```csharp
+public bool ControllerRotationPitch { get; set; }
+```
+#### Property Value
+[System.Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean 'System.Boolean') 

API/Pawn-ControllerRotationRoll.md

@@ -0,0 +1,8 @@
+### [UnrealEngine.Framework](./UnrealEngine-Framework.md 'UnrealEngine.Framework').[Pawn](./Pawn.md 'UnrealEngine.Framework.Pawn')
+## Pawn.ControllerRotationRoll Property
+Gets or sets whether roll will be updated to match the controller's control rotation roll, if controlled by a [PlayerController](./PlayerController.md 'UnrealEngine.Framework.PlayerController') 
+```csharp
+public bool ControllerRotationRoll { get; set; }
+```
+#### Property Value
+[System.Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean 'System.Boolean') 

API/Pawn-ControllerRotationYaw.md

@@ -0,0 +1,8 @@
+### [UnrealEngine.Framework](./UnrealEngine-Framework.md 'UnrealEngine.Framework').[Pawn](./Pawn.md 'UnrealEngine.Framework.Pawn')
+## Pawn.ControllerRotationYaw Property
+Gets or sets whether yaw will be updated to match the controller's control rotation yaw, if controlled by a [PlayerController](./PlayerController.md 'UnrealEngine.Framework.PlayerController') 
+```csharp
+public bool ControllerRotationYaw { get; set; }
+```
+#### Property Value
+[System.Boolean](https://docs.microsoft.com/en-us/dotnet/api/System.Boolean 'System.Boolean') 

API/Pawn.md

@@ -13,6 +13,9 @@ Derived
 ### Properties
 - [AutoPossessAI](./Pawn-AutoPossessAI.md 'UnrealEngine.Framework.Pawn.AutoPossessAI')
 - [AutoPossessPlayer](./Pawn-AutoPossessPlayer.md 'UnrealEngine.Framework.Pawn.AutoPossessPlayer')
+- [ControllerRotationPitch](./Pawn-ControllerRotationPitch.md 'UnrealEngine.Framework.Pawn.ControllerRotationPitch')
+- [ControllerRotationRoll](./Pawn-ControllerRotationRoll.md 'UnrealEngine.Framework.Pawn.ControllerRotationRoll')
+- [ControllerRotationYaw](./Pawn-ControllerRotationYaw.md 'UnrealEngine.Framework.Pawn.ControllerRotationYaw')
 ### Methods
 - [AddControllerPitchInput(float)](./Pawn-AddControllerPitchInput(float).md 'UnrealEngine.Framework.Pawn.AddControllerPitchInput(float)')
 - [AddControllerRollInput(float)](./Pawn-AddControllerRollInput(float).md 'UnrealEngine.Framework.Pawn.AddControllerRollInput(float)')

Source/Managed/Framework/Codegen.cs

@@ -26,7 +26,7 @@ namespace UnrealEngine.Framework {
  // Automatically generated
 
  internal static class Shared {
- internal const int checksum = 0x29E;
+ internal const int checksum = 0x2A4;
  internal static Dictionary<int, IntPtr> userFunctions = new();
  private const string dynamicTypesAssemblyName = "UnrealEngine.DynamicTypes";
  private static readonly ModuleBuilder moduleBuilder = AssemblyBuilder.DefineDynamicAssembly(new(dynamicTypesAssemblyName), AssemblyBuilderAccess.RunAndCollect).DefineDynamicModule(dynamicTypesAssemblyName);
@@ -306,17 +306,23 @@ internal static class Shared {
  int head = 0;
  IntPtr* pawnFunctions = (IntPtr*)buffer[position++];
 
- Pawn.addControllerYawInput = (delegate* unmanaged[Cdecl]<IntPtr, float, void>)pawnFunctions[head++];
- Pawn.addControllerPitchInput = (delegate* unmanaged[Cdecl]<IntPtr, float, void>)pawnFunctions[head++];
- Pawn.addControllerRollInput = (delegate* unmanaged[Cdecl]<IntPtr, float, void>)pawnFunctions[head++];
- Pawn.addMovementInput = (delegate* unmanaged[Cdecl]<IntPtr, in Vector3, float, Bool, void>)pawnFunctions[head++];
  Pawn.getAutoPossessAI = (delegate* unmanaged[Cdecl]<IntPtr, AutoPossessAI>)pawnFunctions[head++];
  Pawn.getAutoPossessPlayer = (delegate* unmanaged[Cdecl]<IntPtr, AutoReceiveInput>)pawnFunctions[head++];
+ Pawn.getControllerRotationYaw = (delegate* unmanaged[Cdecl]<IntPtr, Bool>)pawnFunctions[head++];
+ Pawn.getControllerRotationPitch = (delegate* unmanaged[Cdecl]<IntPtr, Bool>)pawnFunctions[head++];
+ Pawn.getControllerRotationRoll = (delegate* unmanaged[Cdecl]<IntPtr, Bool>)pawnFunctions[head++];
  Pawn.getGravityDirection = (delegate* unmanaged[Cdecl]<IntPtr, ref Vector3, void>)pawnFunctions[head++];
  Pawn.getAIController = (delegate* unmanaged[Cdecl]<IntPtr, IntPtr>)pawnFunctions[head++];
  Pawn.getPlayerController = (delegate* unmanaged[Cdecl]<IntPtr, IntPtr>)pawnFunctions[head++];
  Pawn.setAutoPossessAI = (delegate* unmanaged[Cdecl]<IntPtr, AutoPossessAI, void>)pawnFunctions[head++];
  Pawn.setAutoPossessPlayer = (delegate* unmanaged[Cdecl]<IntPtr, AutoReceiveInput, void>)pawnFunctions[head++];
+ Pawn.setControllerRotationYaw = (delegate* unmanaged[Cdecl]<IntPtr, Bool, void>)pawnFunctions[head++];
+ Pawn.setControllerRotationPitch = (delegate* unmanaged[Cdecl]<IntPtr, Bool, void>)pawnFunctions[head++];
+ Pawn.setControllerRotationRoll = (delegate* unmanaged[Cdecl]<IntPtr, Bool, void>)pawnFunctions[head++];
+ Pawn.addControllerYawInput = (delegate* unmanaged[Cdecl]<IntPtr, float, void>)pawnFunctions[head++];
+ Pawn.addControllerPitchInput = (delegate* unmanaged[Cdecl]<IntPtr, float, void>)pawnFunctions[head++];
+ Pawn.addControllerRollInput = (delegate* unmanaged[Cdecl]<IntPtr, float, void>)pawnFunctions[head++];
+ Pawn.addMovementInput = (delegate* unmanaged[Cdecl]<IntPtr, in Vector3, float, Bool, void>)pawnFunctions[head++];
  }
 
  unchecked {
@@ -1501,17 +1507,23 @@ unsafe partial class TriggerCapsule { }
  unsafe partial class TriggerSphere { }
 
  unsafe partial class Pawn {
- internal static delegate* unmanaged[Cdecl]<IntPtr, float, void> addControllerYawInput;
- internal static delegate* unmanaged[Cdecl]<IntPtr, float, void> addControllerPitchInput;
- internal static delegate* unmanaged[Cdecl]<IntPtr, float, void> addControllerRollInput;
- internal static delegate* unmanaged[Cdecl]<IntPtr, in Vector3, float, Bool, void> addMovementInput;
  internal static delegate* unmanaged[Cdecl]<IntPtr, AutoPossessAI> getAutoPossessAI;
  internal static delegate* unmanaged[Cdecl]<IntPtr, AutoReceiveInput> getAutoPossessPlayer;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, Bool> getControllerRotationYaw;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, Bool> getControllerRotationPitch;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, Bool> getControllerRotationRoll;
  internal static delegate* unmanaged[Cdecl]<IntPtr, ref Vector3, void> getGravityDirection;
  internal static delegate* unmanaged[Cdecl]<IntPtr, IntPtr> getAIController;
  internal static delegate* unmanaged[Cdecl]<IntPtr, IntPtr> getPlayerController;
  internal static delegate* unmanaged[Cdecl]<IntPtr, AutoPossessAI, void> setAutoPossessAI;
  internal static delegate* unmanaged[Cdecl]<IntPtr, AutoReceiveInput, void> setAutoPossessPlayer;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, Bool, void> setControllerRotationYaw;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, Bool, void> setControllerRotationPitch;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, Bool, void> setControllerRotationRoll;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, float, void> addControllerYawInput;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, float, void> addControllerPitchInput;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, float, void> addControllerRollInput;
+ internal static delegate* unmanaged[Cdecl]<IntPtr, in Vector3, float, Bool, void> addMovementInput;
  }
 
  unsafe partial class Character {

Source/Managed/Framework/Framework.cs

@@ -5294,42 +5294,43 @@ public unsafe partial class Pawn : Actor {
  }
 
  /// <summary>
- /// Adds yaw (turn) input to the controller, if it's a local <see cref="PlayerController"/>
- /// </summary>
- public void AddControllerYawInput(float value) => addControllerYawInput(Pointer, value);
-
- /// <summary>
- /// Adds pitch (look up) input to the controller, if it's a local <see cref="PlayerController"/>
+ /// Gets or sets the automatic possession type by an AI controller
  /// </summary>
- public void AddControllerPitchInput(float value) => addControllerPitchInput(Pointer, value);
+ public AutoPossessAI AutoPossessAI {
+ get => getAutoPossessAI(Pointer);
+ set => setAutoPossessAI(Pointer, value);
+ }
 
  /// <summary>
- /// Adds roll input to the controller, if it's a local <see cref="PlayerController"/>
+ /// Gets or sets the player index for automatic possession by a player controller
  /// </summary>
- public void AddControllerRollInput(float value) => addControllerRollInput(Pointer, value);
+ public AutoReceiveInput AutoPossessPlayer {
+ get => getAutoPossessPlayer(Pointer);
+ set => setAutoPossessPlayer(Pointer, value);
+ }
 
  /// <summary>
- /// Adds movement input along the given world direction vector (usually normalized)
+ /// Gets or sets whether yaw will be updated to match the controller's control rotation yaw, if controlled by a <see cref="PlayerController"/>
  /// </summary>
- /// <param name="worldDirection">Direction in world space to apply input</param>
- /// <param name="scaleValue">Scale to apply to input, 0.5f applies half the normal value, while -1.0 would reverse the direction</param>
- /// <param name="force">If <c>true</c>, always add the input, ignoring the result of <see cref="Controller.IsMoveInputIgnored"/></param>
- public void AddMovementInput(in Vector3 worldDirection, float scaleValue = 1.0f, bool force = false) => addMovementInput(Pointer, worldDirection, scaleValue, force);
+ public bool ControllerRotationYaw {
+  get => getControllerRotationYaw(Pointer);
+  set => setControllerRotationYaw(Pointer, value);
+ }
 
  /// <summary>
- /// Gets or sets the automatic possession type by an AI controller
+ /// Gets or sets whether pitch will be updated to match the controller's control rotation pitch, if controlled by a <see cref="PlayerController"/>
  /// </summary>
- public AutoPossessAI AutoPossessAI {
- get => getAutoPossessAI(Pointer);
- set => setAutoPossessAI(Pointer, value);
+ public bool ControllerRotationPitch {
+ get => getControllerRotationPitch(Pointer);
+ set => setControllerRotationPitch(Pointer, value);
  }
 
  /// <summary>
- /// Gets or sets the player index for automatic possession by a player controller
+ /// Gets or sets whether roll will be updated to match the controller's control rotation roll, if controlled by a <see cref="PlayerController"/>
  /// </summary>
- public AutoReceiveInput AutoPossessPlayer {
- get => getAutoPossessPlayer(Pointer);
- set => setAutoPossessPlayer(Pointer, value);
+ public bool ControllerRotationRoll {
+ get => getControllerRotationRoll(Pointer);
+ set => setControllerRotationRoll(Pointer, value);
  }
 
  /// <summary>
@@ -5371,6 +5372,29 @@ public unsafe partial class Pawn : Actor {
 
  return null;
  }
+
+ /// <summary>
+ /// Adds yaw (turn) input to the controller, if it's a local <see cref="PlayerController"/>
+ /// </summary>
+ public void AddControllerYawInput(float value) => addControllerYawInput(Pointer, value);
+
+ /// <summary>
+ /// Adds pitch (look up) input to the controller, if it's a local <see cref="PlayerController"/>
+ /// </summary>
+ public void AddControllerPitchInput(float value) => addControllerPitchInput(Pointer, value);
+
+ /// <summary>
+ /// Adds roll input to the controller, if it's a local <see cref="PlayerController"/>
+ /// </summary>
+ public void AddControllerRollInput(float value) => addControllerRollInput(Pointer, value);
+
+ /// <summary>
+ /// Adds movement input along the given world direction vector (usually normalized)
+ /// </summary>
+ /// <param name="worldDirection">Direction in world space to apply input</param>
+ /// <param name="scaleValue">Scale to apply to input, 0.5f applies half the normal value, while -1.0 would reverse the direction</param>
+ /// <param name="force">If <c>true</c>, always add the input, ignoring the result of <see cref="Controller.IsMoveInputIgnored"/></param>
+ public void AddMovementInput(in Vector3 worldDirection, float scaleValue = 1.0f, bool force = false) => addMovementInput(Pointer, worldDirection, scaleValue, force);
  }
 
  /// <summary>

Source/Native/Source/UnrealCLR/Private/UnrealCLR.cpp

@@ -433,17 +433,23 @@ void UnrealCLR::Module::StartupModule() {
  int32 head = 0;
  Shared::Functions[position++] = Shared::PawnFunctions;
 
- Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::AddControllerYawInput;
- Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::AddControllerPitchInput;
- Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::AddControllerRollInput;
- Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::AddMovementInput;
  Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::GetAutoPossessAI;
  Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::GetAutoPossessPlayer;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::GetControllerRotationYaw;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::GetControllerRotationPitch;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::GetControllerRotationRoll;
  Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::GetGravityDirection;
  Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::GetAIController;
  Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::GetPlayerController;
  Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::SetAutoPossessAI;
  Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::SetAutoPossessPlayer;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::SetControllerRotationYaw;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::SetControllerRotationPitch;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::SetControllerRotationRoll;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::AddControllerYawInput;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::AddControllerPitchInput;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::AddControllerRollInput;
+ Shared::PawnFunctions[head++] = (void*)&UnrealCLRFramework::Pawn::AddMovementInput;
 
  checksum += head;
  }

Source/Native/Source/UnrealCLR/Private/UnrealCLRFramework.cpp

@@ -1594,28 +1594,24 @@ namespace UnrealCLRFramework {
  }
 
  namespace Pawn {
- void AddControllerYawInput(APawn* Pawn, float Value) {
- Pawn->AddControllerYawInput(Value);
- }
-
- void AddControllerPitchInput(APawn* Pawn, float Value) {
- Pawn->AddControllerPitchInput(Value);
+ AutoPossessAI GetAutoPossessAI(APawn* Pawn) {
+ return Pawn->AutoPossessAI;
  }
 
- void AddControllerRollInput(APawn* Pawn, float Value) {
- Pawn->AddControllerRollInput(Value);
+ AutoReceiveInput GetAutoPossessPlayer(APawn* Pawn) {
+ return Pawn->AutoPossessPlayer;
  }
 
- void AddMovementInput(APawn* Pawn, const Vector3* WorldDirection, float ScaleValue, bool Force) {
- Pawn->AddMovementInput(*WorldDirection, ScaleValue, Force);
+ bool GetControllerRotationYaw(APawn* Pawn) {
+ return Pawn->bUseControllerRotationYaw;
  }
 
- AutoPossessAI GetAutoPossessAI(APawn* Pawn) {
- return Pawn->AutoPossessAI;
+ bool GetControllerRotationPitch(APawn* Pawn) {
+ return Pawn->bUseControllerRotationPitch;
  }
 
- AutoReceiveInput GetAutoPossessPlayer(APawn* Pawn) {
- return Pawn->AutoPossessPlayer;
+ bool GetControllerRotationRoll(APawn* Pawn) {
+ return Pawn->bUseControllerRotationRoll;
  }
 
  void GetGravityDirection(APawn* Pawn, Vector3* Value) {
@@ -1637,6 +1633,34 @@ namespace UnrealCLRFramework {
  void SetAutoPossessPlayer(APawn* Pawn, AutoReceiveInput Value) {
  Pawn->AutoPossessPlayer = Value;
  }
+
+ void SetControllerRotationYaw(APawn* Pawn, bool Value) {
+ Pawn->bUseControllerRotationYaw = Value;
+ }
+
+ void SetControllerRotationPitch(APawn* Pawn, bool Value) {
+ Pawn->bUseControllerRotationPitch = Value;
+ }
+
+ void SetControllerRotationRoll(APawn* Pawn, bool Value) {
+ Pawn->bUseControllerRotationRoll = Value;
+ }
+
+ void AddControllerYawInput(APawn* Pawn, float Value) {
+ Pawn->AddControllerYawInput(Value);
+ }
+
+ void AddControllerPitchInput(APawn* Pawn, float Value) {
+ Pawn->AddControllerPitchInput(Value);
+ }
+
+ void AddControllerRollInput(APawn* Pawn, float Value) {
+ Pawn->AddControllerRollInput(Value);
+ }
+
+ void AddMovementInput(APawn* Pawn, const Vector3* WorldDirection, float ScaleValue, bool Force) {
+ Pawn->AddMovementInput(*WorldDirection, ScaleValue, Force);
+ }
  }
 
  namespace Character {

Source/Native/Source/UnrealCLR/Public/UnrealCLRFramework.h

@@ -528,17 +528,23 @@ namespace UnrealCLRFramework {
  namespace TriggerSphere { }
 
  namespace Pawn {
- static void AddControllerYawInput(APawn* Pawn, float Value);
- static void AddControllerPitchInput(APawn* Pawn, float Value);
- static void AddControllerRollInput(APawn* Pawn, float Value);
- static void AddMovementInput(APawn* Pawn, const Vector3* WorldDirection, float ScaleValue, bool Force);
  static AutoPossessAI GetAutoPossessAI(APawn* Pawn);
  static AutoReceiveInput GetAutoPossessPlayer(APawn* Pawn);
+ static bool GetControllerRotationYaw(APawn* Pawn);
+ static bool GetControllerRotationPitch(APawn* Pawn);
+ static bool GetControllerRotationRoll(APawn* Pawn);
  static void GetGravityDirection(APawn* Pawn, Vector3* Value);
  static AAIController* GetAIController(APawn* Pawn);
  static APlayerController* GetPlayerController(APawn* Pawn);
  static void SetAutoPossessAI(APawn* Pawn, AutoPossessAI Value);
  static void SetAutoPossessPlayer(APawn* Pawn, AutoReceiveInput Value);
+ static void SetControllerRotationYaw(APawn* Pawn, bool Value);
+ static void SetControllerRotationPitch(APawn* Pawn, bool Value);
+ static void SetControllerRotationRoll(APawn* Pawn, bool Value);
+ static void AddControllerYawInput(APawn* Pawn, float Value);
+ static void AddControllerPitchInput(APawn* Pawn, float Value);
+ static void AddControllerRollInput(APawn* Pawn, float Value);
+ static void AddMovementInput(APawn* Pawn, const Vector3* WorldDirection, float ScaleValue, bool Force);
  }
 
  namespace Character {