How to controll an rigidbody

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • How to controll an rigidbody

      In this tutorial, I’ll explain how to control a Rigidbody to move an entity around—this is especially useful for character controllers or other physics-based moving entities.

      First, it’s important to understand that as soon as you attach a Rigidbody component to an entity, you no longer control the entity’s position or rotation directly through its properties. Instead, the Rigidbody now governs the entity's transformations, updating its position and rotation based on physics calculations.

      For character movement, you can use the LinearVelocity function, which allows you to set movement along specific axes. For rotation, the AngularVelocity function works similarly, controlling rotational movement around the specified axes. Both functions take a Vec3 as input, allowing you to define the exact axis on which you want to move or rotate the entity.


      If you want to move the character forward in the direction it’s currently facing, you can calculate the forward vector using the CalculateForwardVector function. Below is an example of how to move a character around:

      C Source Code

      1. using Genesis.Core;
      2. using Genesis.Core.Behaviors.Physics3D;
      3. using Genesis.Core.GameElements;
      4. using Genesis.Graphics;
      5. using Genesis.Math;
      6. using Genesis.Physics;
      7. using System;
      8. using System.Collections.Generic;
      9. using System.Linq;
      10. using System.Text;
      11. using System.Threading.Tasks;
      13. namespace Test3D
      14. {
      15. public class ThirdPersonController : IGameBehavior
      16. {
      17. public enum Animation
      18. {
      19. ANIMATION_IDLE,
      20. ANIMATION_WALK,
      21. ANIMATION_RUNNING,
      22. ANIMATION_JUMPING,
      23. ANIMATION_STRAFE_RIGHT,
      24. ANIMATION_STRAFE_LEFT,
      25. }
      27. public RigidBodyBehavior3D RigidBody { get; set; }
      29. public String IdleAnimation { get; set; }
      30. public String WalkAnimation { get; set; }
      31. public String RunningAnimation { get; set; }
      32. public String JumpingAnimation { get; set; }
      33. public String StrafeLeftAnimation { get; set; }
      34. public String StrafeRightAnimation { get; set; }
      36. public bool Airborn { get; set; }
      38. private long lastJump = 0;
      40. public ThirdPersonController(RigidBodyBehavior3D rigidBody)
      41. {
      42. this.RigidBody = rigidBody;
      43. rigidBody.OnCollide += RigidBody_OnCollide;
      44. }
      46. private void RigidBody_OnCollide(Scene scene, Game game, GameElement collision)
      47. {
      48. Console.WriteLine($"Coliding with {collision.Name}");
      49. this.Airborn = false;
      50. }
      52. public override void OnDestroy(Game game, GameElement parent)
      53. {
      54. }
      56. public override void OnInit(Game game, GameElement parent)
      57. {
      58. game.BeforeUpdate += Game_BeforeUpdate;
      59. }
      61. private void Game_BeforeUpdate(Game game, IRenderDevice renderDevice)
      62. {
      63. if(this.Airborn)
      64. {
      65. this.Airborn = false;
      66. }
      67. }
      69. public override void OnRender(Game game, GameElement parent)
      70. {
      71. }
      73. public override void OnUpdate(Game game, GameElement parent)
      74. {
      75. // Defines the used variables
      76. var model = (Model)parent;
      77. var animation = Animation.ANIMATION_IDLE;
      78. Vec3 linearVelocity = RigidBody.GetLinearVelocity();
      79. float angularVelocity = 0f;
      80. float speed = ((float)game.DeltaTime) * 0.2f;
      82. // Moving forwards & backwards
      83. if (Input.IsKeyDown(Input.Keys.W))
      84. {
      85. animation = Animation.ANIMATION_WALK;
      86. if (Input.IsKeyDown(Input.Keys.Shift))
      87. {
      88. speed = ((float)game.DeltaTime) * 0.5f;
      89. animation = Animation.ANIMATION_RUNNING;
      90. }
      91. var vec = RigidBody.CalculateForwardVector(-speed);
      92. linearVelocity.X = vec.X;
      93. linearVelocity.Z = vec.Z;
      94. }
      95. else if (Input.IsKeyDown(Input.Keys.S))
      96. {
      97. var vec = RigidBody.CalculateForwardVector(speed);
      98. linearVelocity.X = vec.X;
      99. linearVelocity.Z = vec.Z;
      100. animation = Animation.ANIMATION_WALK;
      101. }
      103. // Straving
      104. if(Input.IsKeyDown(Input.Keys.A))
      105. {
      106. var vec = RigidBody.CalculateRightVector(speed);
      107. linearVelocity.X = vec.X;
      108. linearVelocity.Z = vec.Z;
      109. animation = Animation.ANIMATION_STRAFE_LEFT;
      110. }
      111. else if(Input.IsKeyDown(Input.Keys.D))
      112. {
      113. var vec = RigidBody.CalculateRightVector(-speed);
      114. linearVelocity.X = vec.X;
      115. linearVelocity.Z = vec.Z;
      116. animation = Animation.ANIMATION_STRAFE_RIGHT;
      117. }
      119. // Jumping
      120. if (Input.IsKeyDown(Input.Keys.Space) && this.CanJump())
      121. {
      122. linearVelocity.Y += 10f;
      123. animation = Animation.ANIMATION_JUMPING;
      124. lastJump = Utils.GetCurrentTimeMillis();
      125. }
      126. // Turning the model
      127. if (Input.IsKeyDown(Input.Keys.Q))
      128. {
      129. angularVelocity += 0.5f;
      130. }
      131. else if (Input.IsKeyDown(Input.Keys.E))
      132. {
      133. angularVelocity -= 0.5f;
      134. }
      136. // Setup the velocity for the behavior
      137. RigidBody.LinearVelocity(linearVelocity);
      138. RigidBody.AngularVelocity(0f, angularVelocity, 0f);
      140. // Animation
      141. switch (animation)
      142. {
      143. case Animation.ANIMATION_IDLE:
      144. this.PlayAnimation(this.IdleAnimation, model);
      145. break;
      146. case Animation.ANIMATION_WALK:
      147. this.PlayAnimation(this.WalkAnimation, model);
      148. break;
      149. case Animation.ANIMATION_RUNNING:
      150. this.PlayAnimation(this.RunningAnimation, model);
      151. break;
      152. case Animation.ANIMATION_JUMPING:
      153. this.PlayAnimation(this.JumpingAnimation, model);
      154. break;
      155. case Animation.ANIMATION_STRAFE_RIGHT:
      156. this.PlayAnimation(this.StrafeRightAnimation, model);
      157. break;
      158. case Animation.ANIMATION_STRAFE_LEFT:
      159. this.PlayAnimation(this.StrafeLeftAnimation, model);
      160. break;
      161. default:
      162. this.PlayAnimation(this.IdleAnimation, model);
      163. break;
      164. }
      166. // Setup the camera
      167. var camera = game.SelectedScene.Camera;
      168. var fwd = RigidBody.CalculateForwardVector(1.5f);
      169. camera.Location = RigidBody.GetLocation() + fwd;
      170. camera.Location.Y += 0.75f;
      171. Utils.LookAt(camera, RigidBody.GetLocation());
      172. }
      175. private void PlayAnimation(String animation, Model model)
      176. {
      177. if (model.Animator.CurrentAnimation.Name != animation)
      178. {
      179. model.PlayAnimation(animation);
      180. }
      181. }
      183. private bool CanJump()
      184. {
      185. var now = Utils.GetCurrentTimeMillis();
      186. if(now > lastJump + 500)
      187. {
      188. return true;
      189. }
      190. return false;
      191. }
      193. }
      194. }
      Display All