Creating a Physics Component

Just like our other components, we need to integrate PhysicsComponent into the Entity class. Let's add AddPhysicsComponent() and GetPhysicsComponent() methods to Entity.h, following the familiar pattern.

As with the TransformComponent, an entity should have, at most, one PhysicsComponent. If our entity already has a PhysicsComponent, AddPhysicsComponent() will log an error and return without adding another:

1// Entity.h
2// ...
3#include "PhysicsComponent.h"
4// ...
5
6class Entity {
7public:
8  // ...
9
10  PhysicsComponent* AddPhysicsComponent() {
11    if (GetPhysicsComponent()) {
12      std::cerr << "Error: Cannot add multiple "
13        "PhysicsComponents to an Entity.\n";
14      return nullptr;
15    }
16
17    ComponentPtr& NewComponent{
18      Components.emplace_back(
19        std::make_unique<PhysicsComponent>(this))
20    };
21
22    NewComponent->Initialize();
23    return static_cast<PhysicsComponent*>(
24      NewComponent.get());
25  }
26
27  PhysicsComponent* GetPhysicsComponent() const {
28    for (const ComponentPtr& C : Components) {
29      if (auto Ptr{
30        dynamic_cast<PhysicsComponent*>(C.get())
31      }) {
32        return Ptr;
33      }
34    }
35    return nullptr;
36  }
37
38  // ...
39};

Let's see it in action. We'll update Scene.h to create an entity with TransformComponent and PhysicsComponent. We'll give it an initial velocity and mass:

1// Scene.h
2// ...
3
4class Scene {
5 public:
6  Scene() {
7    EntityPtr& Player{Entities.emplace_back(
8      std::make_unique<Entity>(*this))};
9
10    Player->AddTransformComponent()
11          ->SetPosition({2, 2});
12
13    // Add physics
14    PhysicsComponent* Physics{
15      Player->AddPhysicsComponent()};
16      
17    // Make it 50kg
18    Physics->SetMass(50);
19    // Set initial velocity
20    Physics->SetVelocity({5, 7});
21
22    // Add an image to see it
23    Player->AddImageComponent("player.png");
24  }
25  // ...
26};

If you run this, you should see the player entity start at {2, 2}, moving up and to the right due to its initial velocity, and fall downwards due to the gravity applied by the PhysicsComponent.

Note that this screenshot includes an additional line showing how our entity's trajectory. We cover how to create this line in the following note for those interested.

As a final example, let's update our InputComponent to interact with our physics component. For reference, our InputComponent files are provided below:

To have our inputs apply physics, we'll modify the Command objects created by our InputComponent to interact with the PhysicsComponent.

Instead of a command directly calling TransformComponent::Move(), it should now interact with our new PhysicsComponent instead, applying forces, impulses, or setting the velocity directly. There are many ways we can do this, and the best approach depends on the game feel we're aiming for.

Moving using Forces

In this example, we'll set the entity's velocity directly but, whatever approach we use, we'll implement it through the MovementCommand we created in our input component section.

Our MovementCommand declaration doesn't require any changes. However, let's update our variable's name to Velocity to make it slightly clearer that it's going to be setting the physic's component's Velocity rather than the transform component's Position:

1// Commands.h
2// ...
3
4class MovementCommand : public Command {
5public:
6  // Constructor now takes a Force vector
7  MovementCommand(Vec2 Velocity) 
8  : Velocity(Velocity) {} 
9
10  void Execute(Entity* Target) override;
11  Vec2 Velocity; 
12};

Over in the definition, we'll update its Execute() method in Commands.cpp to work with the PhysicsComponent.

As always, there are many ways we can do this depending on the movement mechanics we're going for. In this example, we'll completely replace the entity's horizontal velocity based on our input, but we'll keep the existing vertical velocity:

1// Commands.cpp
2#include "Commands.h"
3#include "Entity.h"
4#include "TransformComponent.h"
5#include "PhysicsComponent.h"
6
7void MovementCommand::Execute(Entity* Target) {
8  if (!Target) return;  // Safety Check
9  PhysicsComponent* Physics{
10    Target->GetPhysicsComponent()};
11  if (Physics) {
12    Physics->SetVelocity({
13      Velocity.x,
14      Physics->GetVelocity().y
15    });
16  } else {
17    std::cerr << "Error: MovementCommand "
18      "requires a PhysicsComponent on entity\n";
19  }
20}

As a reminder, our MovementCommand objects are currently created using the command factories in InputComponent.cpp.

These don't need to change in this case, as our MovementCommand constructor hasn't changed. However, we can introduce a SPEED variable to reinforce what this constructor argument represents:

1// InputComponent.cpp
2// ...
3
4namespace{
5// Define movement speed (example value)
6const float SPEED{5.0};  
7
8// Factory function for moving left
9CommandPtr CreateMoveLeftCommand() {
10  return std::make_unique<MovementCommand>( 
11    Vec2{-SPEED, 0.0}); 
12}
13
14// Factory function for moving right
15CommandPtr CreateMoveRightCommand() {
16  return std::make_unique<MovementCommand>( 
17    Vec2{SPEED, 0.0}); 
18}
19
20// ...

Jumping using Impulses

Let's add a new JumpCommand by using our new impulse feature provided by the PhysicsComponent. It's declaration is almost identical to MovementCommand - we'll just use a different variable name for the Vec2:

1// Commands.h
2// ...
3
4class JumpCommand : public Command {
5 public:
6  JumpCommand(Vec2 Impulse)
7      : Impulse(Impulse) {}
8  void Execute(Entity* Target) override;
9  Vec2 Impulse;
10};

Its definition is also similar - the only difference for now is that we call ApplyImpulse() instead of SetVelocity()

1// Commands.cpp
2// ...
3
4void JumpCommand::Execute(Entity* Target) {
5  if (!Target) return;  // Safety Check
6  PhysicsComponent* Physics{
7    Target->GetPhysicsComponent()};
8  if (Physics) {
9    Physics->ApplyImpulse(Impulse);
10  } else {
11    std::cerr << "Error: JumpCommand "
12      "requires a PhysicsComponent on entity\n";
13  }
14}

Over in InputComponent.cpp, let's add our CreateJumpCommand() factory:

1// InputComponent.cpp
2// ...
3
4namespace{
5// ...
6
7CommandPtr CreateJumpCommand() {
8  // Example value in kg*m/s
9  const float JUMP_IMPULSE_MAGNITUDE{350.0};   
10  // Return a jump command instead of movement
11  return std::make_unique<JumpCommand>(
12    Vec2{0.0, JUMP_IMPULSE_MAGNITUDE});
13}
14}
15
16// ...

And update InputComponent::Initialize() to bind the spacebar to the jump command factory by default:

1// InputComponent.cpp
2// ...
3
4void InputComponent::Initialize() {
5  BindKeyHeld(SDLK_LEFT, CreateMoveLeftCommand);
6  BindKeyHeld(SDLK_RIGHT, CreateMoveRightCommand);
7  // Bind Space to Jump
8  BindKeyDown(SDLK_SPACE, CreateJumpCommand); 
9}
10
11// ...

Now, pressing left/right applies horizontal movement, and pressing space applies an instantaneous upward impulse, all managed through the PhysicsComponent.

The player entity needs an InputComponent added in the Scene constructor for this to work:

1// Scene.h
2// ...
3
4class Scene{
5public:
6  Scene() {
7    EntityPtr& Player{Entities.emplace_back(
8      std::make_unique<Entity>(*this))};
9
10    Player->AddTransformComponent()
11          ->SetPosition({4, 5});
12    Player->AddPhysicsComponent()
13          ->SetMass(70.0)
14    Player->AddImageComponent("player.png");
15    Player->AddInputComponent(); // Add input! 
16  }
17  // ...
18};

Our complete PhysicsComponent is provided below:

We also updated our Entity class with new AddPhysicsComponent() and GetPhysicsComponent() functions:

Finally, we updated our InputComponent and its related commands. We added and bound a JumpCommand, and updated our existing MovementCommand to use the entity's PhysicsComponent:

In this lesson, we created a dedicated PhysicsComponent to implement physical simulation for entities that require it.

This component manages an entity's velocity, acceleration, and mass, applying physics updates each tick and providing methods to react to external forces and impulses.

Key takeaways:

• A PhysicsComponent centralizes physics state - Velocity, Acceleration, Mass - and behavior -Tick(), ApplyForce(), ApplyImpulse().
• It depends on TransformComponent to read and write the entity's position.
• The Tick() method applies the equations of motion: velocity updates from acceleration, and position updates from velocity.
• Resetting acceleration each frame is crucial for correctly accumulating forces applied during the next frame.
• Gravity can be applied consistently as a force scaled by mass within the Tick() or a helper function.
• ApplyForce() modifies acceleration ($\text{A = F/M}$), affecting velocity over time.
• ApplyImpulse() modifies velocity directly ($\Delta v = \text{Impulse / M}$), causing instant changes.
• Input commands can now target the PhysicsComponent (setting velocity or applying forces and impulses) rather than directly manipulating the TransformComponent.

With this component, our entities can now move and react to forces in a physically plausible way, managed cleanly within our framework. The next step is to handle interactions between these physical entities using collision detection.