Creating a Physics Component

Integrate basic physics simulation into entities using a dedicated component

This lesson is part of the course:

Game Dev with SDL2

Learn C++ and SDL development by creating hands on, practical projects inspired by classic retro games

Get Started for Free

Abstract art representing computer programming

Ryan McCombe

Posted 4 hours ago

In this lesson, we'll enhance our entity-component system by adding basic physics simulation. We'll create a dedicated PhysicsComponent responsible for managing an entity's physical properties and behavior. You'll learn how to:

Store and manage physical state like Velocity, Acceleration, and Mass.
Implement core physics updates within the component's Tick() method, including gravity.
Provide methods - ApplyForce() and ApplyImpulse() - for external factors to influence the entity's motion.
Integrate the PhysicsComponent with the EntityComponent and TransformComponent.
Connect player input to the physics system using commands.

By the end, you'll have a reusable component that allows entities to move realistically under the influence of forces like gravity and player input.

Starting Point

Before we build our new PhysicsComponent, let's review the relevant parts of our existing entity-component structure. Our foundation includes an Entity class that manages a collection of Component objects.

We already have components like TransformComponent (handling position and scale), ImageComponent (rendering visuals), and InputComponent (processing player input via commands). The Component base class provides common functionality and interfaces.

Below are the key files we'll be building upon. Familiarity with these components, especially Entity, Component, and TransformComponent, will be helpful as we integrate physics. The current version of those classes are provided below:

Entity.h

1#pragma once
2#include <memory>
3#include <vector>
4#include <SDL.h>
5#include "Component.h"
6#include "TransformComponent.h"
7#include "InputComponent.h"
8#include "Commands.h"
9#include "ImageComponent.h"
10
11class Scene;
12using ComponentPtr = std::unique_ptr<Component>;
13using ComponentPtrs = std::vector<ComponentPtr>;
14
15class Entity {
16public:
17  Entity(Scene& Scene) : OwningScene{Scene} {}
18  Scene& GetScene() const { return OwningScene; }
19
20  virtual void HandleEvent(const SDL_Event& E) {
21    for (ComponentPtr& C : Components) {
22      C->HandleEvent(E);
23    }
24  }
25
26  virtual void Tick(float DeltaTime) {
27    for (ComponentPtr& C : Components) {
28      C->Tick(DeltaTime);
29    }
30  }
31
32  virtual void Render(SDL_Surface* Surface) {
33    for (ComponentPtr& C : Components) {
34      C->Render(Surface);
35    }
36    for (ComponentPtr& C : Components) {
37      C->DrawDebugHelpers(Surface);
38    }
39  }
40
41  virtual ~Entity() = default;
42  
43  virtual void HandleCommand(
44    std::unique_ptr<Command> Cmd
45  ) {
46    Cmd->Execute(this);
47  }
48
49  TransformComponent* AddTransformComponent() {
50    if (GetTransformComponent()) {
51      std::cout << "Error: Cannot have "
52        "multiple transform components";
53      return nullptr;
54    }
55
56    std::unique_ptr<Component>& NewComponent{
57      Components.emplace_back(
58        std::make_unique<
59          TransformComponent>(this))};
60
61    NewComponent->Initialize();
62
63    return static_cast<TransformComponent*>(
64      NewComponent.get());
65  }
66
67  TransformComponent* GetTransformComponent() const {
68    for (const ComponentPtr& C : Components) {
69      if (auto Ptr{
70        dynamic_cast<TransformComponent*>(C.get())
71      }) {
72        return Ptr;
73      }
74    }
75    return nullptr;
76  }
77
78  ImageComponent* AddImageComponent(
79    const std::string& FilePath
80  ) {
81    std::unique_ptr<Component>& NewComponent{
82      Components.emplace_back(
83        std::make_unique<ImageComponent>(
84          this, FilePath))};
85
86    NewComponent->Initialize();
87
88    return static_cast<ImageComponent*>(
89      NewComponent.get());
90  }
91
92  using ImageComponents =
93    std::vector<ImageComponent*>;
94  ImageComponents GetImageComponents() const {
95    ImageComponents Result;
96    for (const ComponentPtr& C : Components) {
97      if (auto Ptr{dynamic_cast<
98        ImageComponent*>(C.get())}
99      ) {
100        Result.push_back(Ptr);
101      }
102    }
103    return Result;
104  }
105
106  InputComponent* AddInputComponent() {
107    if (GetInputComponent()) {
108      std::cout << "Error: Cannot have "
109        "multiple input components";
110      return nullptr;
111    }
112
113    std::unique_ptr<Component>& NewComponent{
114      Components.emplace_back(
115        std::make_unique<
116          InputComponent>(this))};
117
118    NewComponent->Initialize();
119
120    return static_cast<InputComponent*>(
121      NewComponent.get());
122  }
123
124  InputComponent* GetInputComponent() const {
125    for (const ComponentPtr& C : Components) {
126      if (auto Ptr{
127        dynamic_cast<InputComponent*>(C.get())
128      }) {
129        return Ptr;
130      }
131    }
132    return nullptr;
133  }
134
135  void RemoveComponent(Component* PtrToRemove) {
136    for (size_t i{0}; i < Components.size(); ++i) {
137      if (Components[i].get() == PtrToRemove) {
138        Components.erase(Components.begin() + i);
139        return;
140      }
141    }
142
143    std::cout << "Warning: Attempted to remove "
144      "a component not found on this entity.\n";
145  }
146
147protected:
148  ComponentPtrs Components;
149  Scene& OwningScene;
150};

Component.h

1// Component.h
2// ...
3#pragma once
4#include <SDL.h>
5
6class Entity;
7class Scene;
8class AssetManager;
9class Vec2;
10
11class Component {
12 public:
13  Component(Entity* Owner) : Owner(Owner) {}
14  virtual void Initialize() {}
15  virtual void HandleEvent(const SDL_Event& E) {}
16  virtual void Tick(float DeltaTime) {}
17  virtual void Render(SDL_Surface* Surface) {}
18  virtual void DrawDebugHelpers(
19    SDL_Surface* Surface) {}
20  virtual ~Component() = default;
21
22  Entity* GetOwner() const { return Owner; }
23  Scene& GetScene() const;
24  AssetManager& GetAssetManager() const;
25  Vec2 ToScreenSpace(const Vec2& Pos) const;
26  Vec2 GetOwnerPosition() const;
27  void SetOwnerPosition(const Vec2& Pos) const;
28  Vec2 GetOwnerScreenSpacePosition() const;
29
30  float GetOwnerScale() const;
31
32private:
33  Entity* Owner{nullptr};
34};

Component.cpp

1#include "Component.h"
2#include "Entity.h"
3#include "Scene.h"
4
5Scene& Component::GetScene() const {
6  return GetOwner()->GetScene();
7}
8
9AssetManager& Component::GetAssetManager() const {
10  return GetScene().GetAssetManager();
11}
12
13Vec2 Component::ToScreenSpace(const Vec2& Pos) const {
14  return GetScene().ToScreenSpace(Pos);
15}
16
17Vec2 Component::GetOwnerPosition() const {
18  TransformComponent* Transform{
19    GetOwner()->GetTransformComponent()};
20  if (!Transform) {
21    std::cerr << "Error: attempted to get position"
22      " of an entity with no transform component\n";
23    return {0, 0};
24  }
25  return Transform->GetPosition();
26}
27
28void Component::SetOwnerPosition(const Vec2& Pos) const {
29  TransformComponent* Transform{
30    GetOwner()->GetTransformComponent()};
31  if (!Transform) {
32    std::cerr << "Error: attempted to set position"
33      " of an entity with no transform component\n";
34  } else {
35    Transform->SetPosition(Pos);
36  }
37}
38
39Vec2 Component::GetOwnerScreenSpacePosition() const {
40  return ToScreenSpace(GetOwnerPosition());
41}
42
43float Component::GetOwnerScale() const {
44  TransformComponent* Transform{
45    GetOwner()->GetTransformComponent()};
46  if (!Transform) {
47    std::cerr << "Error: attempted to get scale"
48      " of an entity with no transform component\n";
49    return 1.0;
50  }
51  return Transform->GetScale();
52}

TransformComponent.h

1#pragma once
2#include <SDL.h>
3#include "Utilities.h"
4#include "Vec2.h"
5#include "Component.h"
6
7class TransformComponent : public Component {
8 public:
9  using Component::Component;
10
11  Vec2 GetPosition() const { return Position; }
12  void SetPosition(const Vec2& NewPosition) {
13    Position = NewPosition;
14  }
15
16  float GetScale() const { return Scale; }    
17  void SetScale(float NewScale) {
18    Scale = NewScale;
19  }
20
21  void DrawDebugHelpers(SDL_Surface* S) override {
22    auto [x, y]{ToScreenSpace(Position)};
23    SDL_Rect Square{Utilities::Round({
24      x - 10, y - 10, 20, 20
25    })};
26    SDL_FillRect(S, &Square, SDL_MapRGB(
27      S->format, 255, 0, 0));
28  }
29
30 private:
31  Vec2 Position{0, 0};
32  float Scale{1.0f};
33};

Note that this lesson is using concepts we covered in our physics section earlier in the course, so familiarity with those topics is recommended:

Creating a `PhysicsComponent`

We'll start by defining the header file for our new component, PhysicsComponent.h. It will inherit from our base Component class and contain members to store the entity's physical state: Velocity, Acceleration, and Mass.

1// PhysicsComponent.h
2#pragma once
3#include "Component.h"
4#include "Vec2.h"
5
6class PhysicsComponent : public Component {
7 public:
8  // Inherit constructor
9  using Component::Component;
10
11  Vec2 GetVelocity() const { return Velocity; }
12  void SetVelocity(const Vec2& NewVelocity) {
13    Velocity = NewVelocity;
14  }
15  
16  float GetMass() const { return Mass; }
17  void SetMass(float NewMass);
18
19 private:
20  Vec2 Velocity{0.0, 0.0}; // m/s
21  Vec2 Acceleration{0.0, 0.0}; // m/s^2
22  float Mass{1.0}; // kg, default to 1kg
23};

1// PhysicsComponent.cpp
2#include <iostream>
3#include "PhysicsComponent.h"
4
5void PhysicsComponent::SetMass(float NewMass) {
6  if (NewMass <= 0.0) {
7    std::cerr << "Error: Mass must be positive. "
8                 "Setting to 1.0kg instead.\n";
9    Mass = 1.0;
10  } else {
11    Mass = NewMass;
12  }
13}

Applying Forces and Impulses

We need to implement the methods that allow external factors (like player input commands, explosions, or collisions) to affect the physics state.

As a reminder, a force affects the Acceleration, which in turn influences Velocity. The relationship between force, mass, and acceleration is $\text{F=MA}$ or, equivalently, $\text{A = F/M}$ .

In contrast, an impulse directly changes Velocity directly. To calculate the velocity change caused by an impulse, we divide the impulse by the mass.

Let’s implement our force handling as a public ApplyForce() function. It takes a force vector (in Newtons) and converts it into acceleration using $\text{A = F/M}$ . This acceleration is added to the component's current Acceleration, which will then influence the Velocity change during the next Tick(). We’ll add Tick() in the next section, but let’s add ApplyForce() now:

1// PhysicsComponent.h
2// ...
3
4class PhysicsComponent : public Component {
5 public:
6  // ...
7
8  // Apply force (in Newtons) - affects acceleration
9  void ApplyForce(const Vec2& Force);
10  
11  // ...
12};

1// PhysicsComponent.cpp
2// ...
3
4void PhysicsComponent::ApplyForce(
5  const Vec2& Force
6) {
7  // A = F/M
8  if (Mass > 0.0f) { // Avoid division by zero
9    Acceleration += Force / Mass;
10  }
11}

ApplyImpulse() takes an impulse vector (change in momentum, $kg \cdot m/s$ ). It directly changes the Velocity using $\Delta v = \text{Impulse / M}$ . This causes an instantaneous change in speed/direction.

1// PhysicsComponent.h
2// ...
3
4class PhysicsComponent : public Component {
5 public:
6  // ...
7   
8  // Apply impulse - affects velocity directly
9  void ApplyImpulse(const Vec2& Impulse);
10  
11  // ...
12};

1// PhysicsComponent.cpp
2// ...
3
4void PhysicsComponent::ApplyImpulse(
5  const Vec2& Impulse
6) {
7  // Change in Velocity = Impulse / Mass
8  if (Mass > 0.0f) { // Avoid division by zero
9    Velocity += Impulse / Mass;
10  }
11}

Physics Update Logic - `Tick()`

The core of our physics simulation happens in the Tick() method. Let’s override it:

1// PhysicsComponent.h
2// ...
3
4class PhysicsComponent : public Component {
5 public:
6  // ...
7  void Tick(float DeltaTime) override;
8  // ...
9};

For the implementation, here is the sequence of actions that our Tick() function needs to perform:

Apply Persistent Forces Gravity: We need to apply acceleration from forces that continuously act on our entity, such as gravity.
Update Velocity: Adjust the current Velocity based on the current Acceleration and the time elapsed (DeltaTime).
Update Position: Adjust the entity's position based on the new Velocity and DeltaTime.
Reset Acceleration: Clear the acceleration for the next frame. Forces applied during the next tick will rebuild the acceleration.

This method needs to interact with the TransformComponent to get and set the entity's position using the helper functions we previously added to the base Component class - GetOwnerPosition() and SetOwnerPosition():

1// PhysicsComponent.cpp
2// ...
3
4void PhysicsComponent::Tick(float DeltaTime) {
5  // Define gravity constant
6  const Vec2 GRAVITY{0.0f, -9.8f};
7
8  // 1. Apply persistent forces like gravity
9  //    See note below
10  ApplyForce(GRAVITY * Mass);
11
12  // 2. Update velocity based on acceleration
13  Velocity += Acceleration * DeltaTime;
14
15  // 3. Update position based on velocity
16  //    Get current position, add velocity
17  //    and set new position
18  SetOwnerPosition(
19    GetOwnerPosition() + Velocity * DeltaTime
20  );
21
22  // 4. Reset acceleration for the next frame.
23  //    Forces applied before the next Tick
24  //    will accumulate here.
25  Acceleration = {0.0, 0.0};
26}
27
28// ...

Gravitational Force

In our previous chapter, we applied gravity directly to the Acceleration variable but, in this component, we’re instead applying it in the form of a force.

This is functionally equivalent, however, we should note that the gravitational force scales in proportion with the object’s mass, which is why we perform this multiplication:

1ApplyForce(GRAVITY * Mass);

Within our ApplyForce() method (which we implement next) we calculate acceleration by dividing forces by the entity’s mass, as per the $\text{A=F/M}$ relationship.

This multiplication and division cancels out, so the effect of ApplyForce(GRAVITY * Mass) is equivalent to just adding GRAVITY directly to the Acceleration:

1Acceleration += GRAVITY;

We covered the gravitational force in a dedicated section in our earlier lesson:

Force, Drag, and Friction

Learn how to implement realistic forces like gravity, friction, and drag in our physics simulations

Dependencies and Initialization

Physics calculations inherently rely on the entity having a position in the world. Therefore, our PhysicsComponent depends on a TransformComponent being present on the same Entity.

Let's override the Initialize() method to enforce this dependency. As with our other components that rely on a transform, if no TransformComponent is found, we’ll log an error and requests our own own removal:

1// PhysicsComponent.h
2// ...
3
4class PhysicsComponent : public Component {
5 public:
6  // ...
7  void Initialize() override;
8  // ...
9};

1// PhysicsComponent.cpp
2#include <iostream>
3#include "PhysicsComponent.h"
4#include "Entity.h" // For GetOwner()
5
6void PhysicsComponent::Initialize() {
7  // Physics needs a Transform to know where
8  // the entity is
9  if (!GetOwner()->GetTransformComponent()) {
10    std::cerr << "Error: PhysicsComponent "
11      "requires TransformComponent on its Owner.\n";
12
13    // Request self-removal
14    GetOwner()->RemoveComponent(this);
15  }
16}
17
18// ...

`Entity` Integration

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};

Example Usage

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.

Screenshot showing the trajectory of an entity

Drawing Trajectory Indicators

Drawing debug helpers that persist across multiple frames is a little more complicated, because our window surface is cleared of all its historic content in every iteration of our application loop. This is done in the GameWindow.Render() call, which overwrites all of our pixels with a solid gray color.

To draw content that persists across multiple frames, we need to draw it on a different surface. For example, let’s create an SDL_Surface in our Scene and:

1// Scene.h
2// ...
3
4class Scene {
5 public:
6  // ...
7  
8  #ifdef DRAW_DEBUG_HELPERS
9  SDL_Surface* Trajectories{
10    SDL_CreateRGBSurfaceWithFormat(
11      0, 700, 300, 32, SDL_PIXELFORMAT_RGBA32
12    )
13  };
14  #endif
15  
16  // ...
17};

Note that this surface assumes our window dimensions are 700x300. We’re also neglecting to safely manage the memory of this surface by calling SDL_FreeSurface(). We assume we only ever have one Scene and that it survives until the end of our application, at which point the surface will be freed by SDL_Quit().

In a larger project, we’d want to be more robust here, but let’s continue for the sake of this example.

To see the latest content of our Trajectories surface, let’s blit it into our window surface on every frame. The window surface is currently being provided to the Render() function on every frame:

1// Scene.h
2// ...
3
4class Scene {
5 public:
6  // ...
7  
8  void Render(SDL_Surface* Surface) {
9    SDL_GetClipRect(Surface, &Viewport);
10    for (EntityPtr& Entity : Entities) {
11      Entity->Render(Surface);
12    }
13
14    #ifdef DRAW_DEBUG_HELPERS
15    SDL_BlitSurface(
16      Trajectories, nullptr, Surface, nullptr
17    );
18    #endif
19  }
20  
21  // ...
22};

The content of this Trajectories surface is never cleared - if we draw something on the surface, it remains there until something else overwrites it.

Any component with access to the Scene can access this public Trajectories surface. Let’s update our PhysicsComponent to draw onto this surface. We’ll override DrawDebugHelpers():

1// PhysicsComponent.h
2// ...
3
4class PhysicsComponent : public Component {
5 public:
6  // ...
7  void DrawDebugHelpers(
8    SDL_Surface* Surface) override;
9  // ...
10};

Within the implementation, we’ll draw a small blue rectangle at our owner’s current screen space position:

1// PhysicsComponent.cpp
2// ...
3#include "Utilities.h"
4
5// ...
6
7void PhysicsComponent::DrawDebugHelpers(
8  SDL_Surface* Surface
9) {
10#ifdef DRAW_DEBUG_HELPERS
11  auto [x, y]{GetOwnerScreenSpacePosition()};
12  SDL_Rect PositionIndicator{
13    int(x) - 2, int(y) - 2, 4, 4};
14  SDL_FillRect(
15    GetScene().Trajectories,
16    &PositionIndicator,
17    SDL_MapRGB(
18      GetScene().Trajectories->format,
19      0, 0, 255
20    )
21  );
22#endif
23}

Our collection of frame-by-frame rectangles will now accumulate on our Trajectories surface over time. And, on every frame, the full contents of the Trajectories surface is blitted onto our window surface, allowing us to view the movement history of our entities:

Static Entities

In our earlier physics lessons, our entities included a boolean value indicating whether they were movable by physical forces such as gravity:

1// GameObject.cpp
2// ...
3
4void GameObject::Tick(float DeltaTime) {
5  if (!isMovable) {
6    // Skip physics simulation
7    return; 
8  };
9  
10  // Do physics stuff...
11}
12
13// ...

This is much easier to replicate in our component-based system. If we don’t want an entity to be affected by physics, we simply don’t give it a physics component.

Input Integration

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

InputComponent.h

1#pragma once
2#include <functional>
3#include <memory>
4#include <unordered_map>
5#include <SDL.h>
6#include "Component.h"
7
8class Command;
9using CommandPtr = std::unique_ptr<Command>;
10using CommandFactory = std::function<
11  CommandPtr()>;
12using KeyToFactoryMap = std::unordered_map<
13  SDL_Keycode, CommandFactory>;
14
15class InputComponent : public Component {
16 public:
17  using Component::Component;
18  void Initialize() override;
19  void Tick(float DeltaTime) override;
20
21  void HandleEvent(const SDL_Event& E) override;
22
23  void BindKeyDown(
24    SDL_Keycode Key, CommandFactory Factory
25  ) {
26    KeyDownBindings[Key] = Factory;
27  }
28
29  void BindKeyHeld(
30    SDL_Keycode Key, CommandFactory Factory
31  ) {
32    KeyHeldBindings[Key] = Factory;
33  }
34
35private:
36  // Map for discrete key presses (events)
37  KeyToFactoryMap KeyDownBindings;
38  // Map for continuous key holds (polling)
39  KeyToFactoryMap KeyHeldBindings;
40};

InputComponent.cpp

1#include <SDL.h>
2#include "InputComponent.h"
3#include "Entity.h"
4#include "Commands.h"
5#include "Vec2.h"
6
7namespace{
8CommandPtr CreateMoveLeftCommand() {
9  return std::make_unique<MovementCommand>(
10    Vec2{-5.0, 0.0});
11}
12
13CommandPtr CreateMoveRightCommand() {
14  return std::make_unique<MovementCommand>(
15    Vec2{5.0, 0.0});
16}
17}
18
19void InputComponent::Initialize() {
20  BindKeyHeld(SDLK_LEFT, CreateMoveLeftCommand);
21  BindKeyHeld(SDLK_RIGHT, CreateMoveRightCommand);
22  // Bind other keys...
23}
24
25void InputComponent::Tick(float DeltaTime) {
26  Entity* Owner{GetOwner()};
27  if (!Owner) return; // Safety check
28
29  // Get the current keyboard state
30  const Uint8* CurrentKeyStates{
31    SDL_GetKeyboardState(nullptr)};
32
33  // Check bindings for keys being held down
34  for (const auto& [Key, Factory] : KeyHeldBindings) {
35    SDL_Scancode Scancode{SDL_GetScancodeFromKey(Key)};
36    if (CurrentKeyStates[Scancode]) {
37      // Key is held, create and handle command
38      Owner->HandleCommand(Factory());
39    }
40  }
41}
42
43void InputComponent::HandleEvent(const SDL_Event& E) {
44  if (E.type == SDL_KEYDOWN) {
45    Entity* Owner{GetOwner()};
46    if (!Owner) return;
47    SDL_Keycode Key{E.key.keysym.sym};
48    if (KeyDownBindings.contains(Key)) {
49      Owner->HandleCommand(KeyDownBindings[Key]());
50      // Alternatively:
51      // KeyDownBindings[Key]()->Execute(Owner);
52    }
53  }
54}

Commands.h

1#pragma once
2#include "Vec2.h"
3
4class Entity;
5
6class Command {
7 public:
8  virtual void Execute(Entity* Target) {}
9  virtual ~Command() = default;
10};
11
12class MovementCommand : public Command {
13public:
14  MovementCommand(Vec2 Movement)
15  : Movement{Movement} {}
16  void Execute(Entity* Target) override;
17  Vec2 Movement;
18};

Commands.cpp

1#include "Commands.h"
2#include "Entity.h"
3#include "TransformComponent.h"
4
5void MovementCommand::Execute(Entity* Target) {
6  if (!Target) return;  // Safety Check
7  Target->GetTransformComponent()
8        ->Move(Movement);
9}

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};

Drag and Friction

Our previous physics chapter included drag and friction in our physics simulation. Our new PhysicsComponent does not include those forces. This means that our objects don’t slow down when the movement input ceases.

For an arcade-feeling game where our entity stops moving as soon as the input stops, we can reset the horizontal velocity to 0 at the end of our Tick():

1// PhysicsComponent.cpp
2// ...
3
4void PhysicsComponent::Tick(float DeltaTime) {
26  
27  // Reset horizontal velocity for every frame
28  Velocity.x = 0;
29}

However, resetting our horizontal velocity at the start of every frame can create unnatural motion in other contexts, such as when movement input stops whilst the character is flying through the air.

If we want to implement drag and friction to handle these scenarios more naturally, our earlier lesson introduced the concepts we need:

Force, Drag, and Friction

Learn how to implement realistic forces like gravity, friction, and drag in our physics simulations

Remember, the idea of composition is that entities shouldn’t have features they don’t require. Not every entity with a PhysicsComponent requires drag and friction. As such, if our game required these capabilities, it’s usually recommended that they be separate components that can be attached only to the entities that need it.

These hypothetical DragComponent and FrictionComponent types can still depend on the entity having a PhysicsComponent, and interact with that physics component much like how our physics component interacts with the TransformComponent.

1// FrictionComponent.h (Conceptual)
2// ...
3
4class FrictionComponent : public Component {
5 public:
6  // ...
7  void Tick(float DeltaTime) override {
8    // Assume I exist
9    PhysicsComponent* Physics{
10      GetOwner()->GetPhysicsComponent()
11    }
12    
13    Vec2 Friction{/* Calculate me */};
14    
15    PhysicsComponent->ApplyForce(Friction);
16  }
17  // ...
18};

This separation has the added benefit of keeping our code easy to work with, preventing our PhysicsComponent from getting large and cumbersome.

Complete Code

Our complete PhysicsComponent is provided below:

PhysicsComponent.h

1#pragma once
2#include "Component.h"
3#include "Vec2.h"
4
5class PhysicsComponent : public Component {
6 public:
7  using Component::Component;
8  void Initialize() override;
9
10  void Tick(float DeltaTime) override;
11  void DrawDebugHelpers(SDL_Surface* Surface) override;
12
13  // Apply force (in Newtons) - affects acceleration
14  void ApplyForce(const Vec2& Force);
15  // Apply impulse - affects velocity directly
16  void ApplyImpulse(const Vec2& Impulse);
17
18  Vec2 GetVelocity() const { return Velocity; }
19  void SetVelocity(const Vec2& NewVelocity) {
20    Velocity = NewVelocity;
21  }
22  
23  float GetMass() const { return Mass; }
24  void SetMass(float NewMass);
25
26 private:
27  Vec2 Velocity{0.0, 0.0}; // m/s
28  Vec2 Acceleration{0.0, 0.0}; // m/s^2
29  float Mass{1.0}; // kg, default to 1kg
30};

PhysicsComponent.cpp

1#include <iostream>
2#include "Entity.h"
3#include "PhysicsComponent.h"
4#include "Scene.h"
5
6void PhysicsComponent::Initialize() {
7  // Physics needs a Transform to know where
8  // the entity is
9  if (!GetOwner()->GetTransformComponent()) {
10    std::cerr << "Error: PhysicsComponent "
11      "requires TransformComponent on its Owner.\n";
12
13    // Request self-removal
14    GetOwner()->RemoveComponent(this);
15  }
16}
17
18void PhysicsComponent::SetMass(float NewMass) {
19  if (NewMass <= 0.0) {
20    std::cerr << "Error: Mass must be positive. "
21                 "Setting to 1.0kg instead.\n";
22    Mass = 1.0;
23  } else {
24    Mass = NewMass;
25  }
26}
27
28void PhysicsComponent::ApplyForce(
29  const Vec2& Force
30) {
31  // A = F/M
32  if (Mass > 0.0f) {  // Avoid division by zero
33    Acceleration += Force / Mass;
34  }
35}
36
37void PhysicsComponent::ApplyImpulse(
38  const Vec2& Impulse
39) {
40  // Change in Velocity = Impulse / Mass
41  if (Mass > 0.0f) {  // Avoid division by zero
42    Velocity += Impulse / Mass;
43  }
44}
45
46void PhysicsComponent::Tick(float DeltaTime) {
47  // Define gravity constant
48  const Vec2 GRAVITY{0.0f, -9.8f};
49
50  // 1. Apply persistent forces like gravity
51  //    See note below
52  ApplyForce(GRAVITY * Mass);
53
54  // 2. Update velocity based on acceleration
55  Velocity += Acceleration * DeltaTime;
56
57  // 3. Update position based on velocity
58  //    Get current position, add velocity
59  //    and set new position
60  SetOwnerPosition(
61    GetOwnerPosition() + Velocity * DeltaTime
62  );
63
64  // 4. Reset acceleration for the next frame.
65  //    Forces applied before the next Tick
66  //    will accumulate here.
67  Acceleration = {0.0, 0.0};
68}
69
70void PhysicsComponent::DrawDebugHelpers(
71  SDL_Surface* Surface
72) {
73#ifdef DRAW_DEBUG_HELPERS
74  auto [x, y]{GetOwnerScreenSpacePosition()};
75  SDL_Rect PositionIndicator{
76    int(x) - 2, int(y) - 2, 4, 4};
77  SDL_FillRect(
78    GetScene().Trajectories,
79    &PositionIndicator,
80    SDL_MapRGB(
81      GetScene().Trajectories->format, 0, 0, 255
82    )
83  );
84#endif
85}

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

Entity.h

1#pragma once
2#include <memory>
3#include <vector>
4#include <SDL.h>
5#include "Component.h"
6#include "TransformComponent.h"
7#include "InputComponent.h"
8#include "Commands.h"
9#include "ImageComponent.h"
10#include "PhysicsComponent.h"
11
12class Scene;
13using ComponentPtr = std::unique_ptr<Component>;
14using ComponentPtrs = std::vector<ComponentPtr>;
15
16class Entity {
17public:
18  Entity(Scene& Scene) : OwningScene{Scene} {}
19  Scene& GetScene() const { return OwningScene; }
20
21  virtual void HandleEvent(const SDL_Event& E) {
22    for (ComponentPtr& C : Components) {
23      C->HandleEvent(E);
24    }
25  }
26
27  virtual void Tick(float DeltaTime) {
28    for (ComponentPtr& C : Components) {
29      C->Tick(DeltaTime);
30    }
31  }
32
33  virtual void Render(SDL_Surface* Surface) {
34    for (ComponentPtr& C : Components) {
35      C->Render(Surface);
36    }
37    for (ComponentPtr& C : Components) {
38      C->DrawDebugHelpers(Surface);
39    }
40  }
41
42  virtual ~Entity() = default;
43
44  virtual void HandleCommand(
45    std::unique_ptr<Command> Cmd
46  ) {
47    Cmd->Execute(this);
48  }
49
50  TransformComponent* AddTransformComponent() {
51    if (GetTransformComponent()) {
52      std::cout << "Error: Cannot have "
53        "multiple transform components";
54      return nullptr;
55    }
56
57    std::unique_ptr<Component>& NewComponent{
58      Components.emplace_back(
59        std::make_unique<
60          TransformComponent>(this))};
61
62    NewComponent->Initialize();
63
64    return static_cast<TransformComponent*>(
65      NewComponent.get());
66  }
67
68  TransformComponent* GetTransformComponent() const {
69    for (const ComponentPtr& C : Components) {
70      if (auto Ptr{
71        dynamic_cast<TransformComponent*>(C.get())
72      }) {
73        return Ptr;
74      }
75    }
76    return nullptr;
77  }
78
79  ImageComponent* AddImageComponent(
80    const std::string& FilePath
81  ) {
82    std::unique_ptr<Component>& NewComponent{
83      Components.emplace_back(
84        std::make_unique<ImageComponent>(
85          this, FilePath))};
86
87    NewComponent->Initialize();
88
89    return static_cast<ImageComponent*>(
90      NewComponent.get());
91  }
92
93  using ImageComponents =
94    std::vector<ImageComponent*>;
95  ImageComponents GetImageComponents() const {
96    ImageComponents Result;
97    for (const ComponentPtr& C : Components) {
98      if (auto Ptr{dynamic_cast<
99        ImageComponent*>(C.get())}
100      ) {
101        Result.push_back(Ptr);
102      }
103    }
104    return Result;
105  }
106
107  InputComponent* AddInputComponent() {
108    if (GetInputComponent()) {
109      std::cout << "Error: Cannot have "
110        "multiple input components";
111      return nullptr;
112    }
113
114    std::unique_ptr<Component>& NewComponent{
115      Components.emplace_back(
116        std::make_unique<
117          InputComponent>(this))};
118
119    NewComponent->Initialize();
120
121    return static_cast<InputComponent*>(
122      NewComponent.get());
123  }
124
125  InputComponent* GetInputComponent() const {
126    for (const ComponentPtr& C : Components) {
127      if (auto Ptr{
128        dynamic_cast<InputComponent*>(C.get())
129      }) {
130        return Ptr;
131      }
132    }
133    return nullptr;
134  }
135
136  PhysicsComponent* AddPhysicsComponent() {
137    if (GetPhysicsComponent()) {
138      std::cerr << "Error: Cannot add multiple "
139        "PhysicsComponents to an Entity.\n";
140      return nullptr;
141    }
142
143    ComponentPtr& NewComponent{
144      Components.emplace_back(
145        std::make_unique<PhysicsComponent>(this))
146    };
147
148    NewComponent->Initialize();
149    return static_cast<PhysicsComponent*>(
150      NewComponent.get());
151  }
152
153  PhysicsComponent* GetPhysicsComponent() const {
154    for (const ComponentPtr& C : Components) {
155      if (auto Ptr{
156        dynamic_cast<PhysicsComponent*>(C.get())
157      }) {
158        return Ptr;
159      }
160    }
161    return nullptr;
162  }
163
164  void RemoveComponent(Component* PtrToRemove) {
165    for (size_t i{0}; i < Components.size(); ++i) {
166      if (Components[i].get() == PtrToRemove) {
167        Components.erase(Components.begin() + i);
168        return;
169      }
170    }
171
172    std::cout << "Warning: Attempted to remove "
173      "a component not found on this entity.\n";
174  }
175
176protected:
177  ComponentPtrs Components;
178  Scene& OwningScene;
179};

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:

InputComponent.cpp

1#include <SDL.h>
2#include "InputComponent.h"
3#include "Commands.h"
4#include "Entity.h"
5#include "Vec2.h"
6
7namespace{
8const float SPEED{5.0};
9
10CommandPtr CreateMoveLeftCommand() {
11  return std::make_unique<MovementCommand>(
12    Vec2{-SPEED, 0.0} 
13  );
14}
15
16CommandPtr CreateMoveRightCommand() {
17  return std::make_unique<MovementCommand>(
18    Vec2{SPEED, 0.0} 
19  );
20}
21
22CommandPtr CreateJumpCommand() { 
23  const float JUMP_IMPULSE_MAGNITUDE{350.0}; 
24  return std::make_unique<JumpCommand>( 
25    Vec2{0.0, JUMP_IMPULSE_MAGNITUDE}); 
26  } 
27} 
28
29void InputComponent::Initialize() {
30  BindKeyHeld(SDLK_LEFT, CreateMoveLeftCommand);
31  BindKeyHeld(SDLK_RIGHT,
32              CreateMoveRightCommand);
33  BindKeyDown(SDLK_SPACE, CreateJumpCommand); 
34  // Bind other keys...
35}
36
37void InputComponent::Tick(float DeltaTime) {
38  Entity* Owner{GetOwner()};
39  if (!Owner) return; // Safety check
40
41  // Get the current keyboard state
42  const Uint8* CurrentKeyStates{
43    SDL_GetKeyboardState(nullptr)};
44
45  // Check bindings for keys being held down
46  for (const auto& [Key, Factory] :
47       KeyHeldBindings) {
48    SDL_Scancode Scancode{
49      SDL_GetScancodeFromKey(Key)};
50    if (CurrentKeyStates[Scancode]) {
51      // Key is held, create and handle command
52      Owner->HandleCommand(Factory());
53    }
54  }
55}
56
57void InputComponent::HandleEvent(
58  const SDL_Event& E) {
59  if (E.type == SDL_KEYDOWN) {
60    Entity* Owner{GetOwner()};
61    if (!Owner) return;
62    SDL_Keycode Key{E.key.keysym.sym};
63    if (KeyDownBindings.contains(Key)) {
64      Owner->HandleCommand(
65        KeyDownBindings[Key]());
66    }
67  }
68}

Commands.h

1#pragma once
2#include "Vec2.h"
3
4class Entity;
5
6class Command {
7 public:
8  virtual void Execute(Entity* Target) {}
9  virtual ~Command() = default;
10};
11
12class MovementCommand : public Command {
13public:
14  MovementCommand(Vec2 Velocity)
15  : Velocity{Velocity} {}
16  void Execute(Entity* Target) override;
17  Vec2 Velocity;
18};
19
20class JumpCommand : public Command {
21 public:
22  JumpCommand(Vec2 Impulse)
23    : Impulse(Impulse) {}
24  void Execute(Entity* Target) override;
25  Vec2 Impulse;
26};

Commands.cpp

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

Summary

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.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

Ryan McCombe

Posted 4 hours ago

Lesson Contents

Creating a Physics Component

Integrate basic physics simulation into entities using a dedicated component

This lesson is part of the course:

Game Dev with SDL2

Learn C++ and SDL development by creating hands on, practical projects inspired by classic retro games

Get Started for Free

Whirlwind Tour of C++ Basics

Setting up an SDL2 Development Environment

Creating an SDL Application

Implementing User Interaction

Rendering Images and Text

Project: Minesweeper

Ticks, Timers and Callbacks

Keyboard Input

Window Management

Monitors and Display Modes

Project: Snake

Mouse Input

Reading and Writing (RWops)

Geometry and Vectors

Spaces and Transformations

Motion and Collisions

Components and Composition

Creating Components

107. Creating a Physics Component

Integrate basic physics simulation into entities using a dedicated component

This lesson is part of the course:

Game Dev with SDL2

Learn C++ and SDL development by creating hands on, practical projects inspired by classic retro games

This course includes:

108 Lessons
92% Positive Reviews
Regularly Updated
Help and FAQs

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

Contact|Privacy Policy|Terms of Use

Creating a Physics Component

Game Dev with SDL2

Ryan McCombe

Starting Point

Entity.h

Component.h

Component.cpp

TransformComponent.h

Physical Motion

Force, Drag, and Friction

Momentum and Impulse Forces

Creating a PhysicsComponent

Applying Forces and Impulses

Physics Update Logic - Tick()

Gravitational Force

Force, Drag, and Friction

Dependencies and Initialization

Entity Integration

Example Usage

Drawing Trajectory Indicators

Static Entities

Input Integration

InputComponent.h

InputComponent.cpp

Commands.h

Commands.cpp

Moving using Forces

Jumping using Impulses

Drag and Friction

Force, Drag, and Friction

Complete Code

PhysicsComponent.h

PhysicsComponent.cpp

Entity.h

InputComponent.cpp

Commands.h

Commands.cpp

Summary

Professional C++

Ryan McCombe

Creating a Physics Component

Game Dev with SDL2

Whirlwind Tour of C++ Basics

Setting up an SDL2 Development Environment

Creating an SDL Application

Implementing User Interaction

Rendering Images and Text

Project: Minesweeper

Ticks, Timers and Callbacks

Keyboard Input

Window Management

Monitors and Display Modes

Project: Snake

Mouse Input

Reading and Writing (RWops)

Geometry and Vectors

Spaces and Transformations

Motion and Collisions

Components and Composition

Creating Components

107.

Creating a Physics Component

Course Content

Game Dev with SDL2

This course includes:

Professional C++

Creating a `PhysicsComponent`

Physics Update Logic - `Tick()`

`Entity` Integration