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 unsafe Dictionary<int, IntPtr> Load(IntPtr* events, IntPtr funct
 				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 Pawn(string name = null, Blueprint blueprint = 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"/>
+		/// 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 PlayerController GetPlayerController() {
 
 			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 {