Collision Response

Make entities react realistically to collisions, stopping, bouncing, and interacting based on type.

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 physics collision responses

Ryan McCombe

Posted 7 hours ago

Our entities can now detect collisions thanks to the CollisionComponent, but they still pass through each other like ghosts. This lesson bridges the gap from detection to reaction. We'll implement two fundamental collision responses:

Stopping, such as a character landing on a floor.
Bouncing, such as a ball reflecting off surfaces.

We'll approach this by adding a virtual HandleCollision() function to our Entity() base class, allowing different entity types to define their unique reactions.

Starting Point

In the previous lesson, we created the CollisionComponent which calculates a world-space bounding box (WorldBounds) each frame:

CollisionComponent.h

1#pragma once
2#include "Component.h"
3#include "Vec2.h"
4#include <SDL.h>
5
6class CollisionComponent : public Component {
7 public:
8  // Inherit constructor
9  using Component::Component;
10
11  // Setters for defining the collision shape
12  void SetOffset(const Vec2& NewOffset);
13  void SetSize(float NewWidth, float NewHeight);
14
15  // Getter for the calculated world-space bounds
16  const SDL_FRect& GetWorldBounds() const;
17
18  // Check collision with another component
19  bool IsCollidingWith(
20    const CollisionComponent& Other
21  ) const;
22
23  bool GetCollisionRectangle( // <h>
24    const CollisionComponent& Other, // <h>
25    SDL_FRect* OutIntersection // <h>
26  ) const; // <h>
27
28  // Called each frame to update WorldBounds
29  void Tick(float DeltaTime) override;
30  // Dependency check
31  void Initialize() override;
32  // Draw the bounding box
33  void DrawDebugHelpers(SDL_Surface*) override;
34
35 private:
36  // Shape definition relative to owner's origin
37  Vec2 Offset{0.0, 0.0};
38  float Width{1.0};  // Default 1m x 1m
39  float Height{1.0};
40
41  // Calculated bounds updated each tick
42  SDL_FRect WorldBounds{0.0, 0.0, 0.0, 0.0};
43};

CollisionComponent.cpp

1// CollisionComponent.cpp
2#include <iostream>
3#include "CollisionComponent.h"
4
5// For DrawRectOutline(), Round()
6#include "Utilities.h" 
7#include "Scene.h"
8
9void CollisionComponent::Tick(float DeltaTime) {
10  Vec2 OwnerPos{GetOwnerPosition()};
11  float OwnerScale{GetOwnerScale()};
12
13  // Calculate world-space position and dimensions
14  WorldBounds.x = OwnerPos.x + Offset.x;
15  WorldBounds.y = OwnerPos.y + Offset.y;
16  WorldBounds.w = Width * OwnerScale;
17  WorldBounds.h = Height * OwnerScale;
18}
19
20void CollisionComponent::Initialize() {
21  if (!GetOwner()->GetTransformComponent()) {
22    std::cerr << "Error: CollisionComponent "
23      "requires TransformComponent on its Owner.\n";
24    GetOwner()->RemoveComponent(this);
25  }
26}
27
28void CollisionComponent::SetOffset(
29  const Vec2& NewOffset
30) {
31  Offset = NewOffset;
32  // WorldBounds will be recalculated in Tick()
33}
34
35void CollisionComponent::SetSize(
36  float NewWidth, float NewHeight
37) {
38  if (NewWidth < 0 || NewHeight < 0) {
39    std::cerr << "Warning: CollisionComponent "
40      "width/height cannot be negative. "
41      "Using absolute values.\n";
42    Width = std::abs(NewWidth);
43    Height = std::abs(NewHeight);
44  } else {
45    Width = NewWidth;
46    Height = NewHeight;
47  }
48  // WorldBounds will be recalculated in Tick()
49}
50
51const SDL_FRect&
52CollisionComponent::GetWorldBounds() const {
53  return WorldBounds;
54}
55
56bool CollisionComponent::IsCollidingWith(
57  const CollisionComponent& Other
58) const {
59  // Get the world bounds rectangles
60  const SDL_FRect& A_world{GetWorldBounds()};
61  const SDL_FRect& B_world{
62    Other.GetWorldBounds()};
63
64  // Convert to SDL's coordinate system (Y-down)
65  // by subtracting height from Y
66  SDL_FRect A_sdl{A_world};
67  A_sdl.y -= A_world.h;  // Convert A to Y-down
68
69  SDL_FRect B_sdl{B_world};
70  B_sdl.y -= B_world.h;  // Convert B to Y-down
71
72  // Use SDL's built-in intersection check
73  return SDL_HasIntersectionF(&A_sdl, &B_sdl);
74}
75
76void CollisionComponent::DrawDebugHelpers(
77  SDL_Surface* Surface
78) {
79  // Convert world bounds to screen space for
80  // drawing onto the surface
81  SDL_FRect ScreenBoundsF{
82    GetScene().ToScreenSpace(WorldBounds)};
83  SDL_Rect ScreenBounds{
84    Utilities::Round(ScreenBoundsF)};
85
86  // Draw outline using the helper
87  Utilities::DrawRectOutline(
88    Surface,
89    ScreenBounds,
90    // Yellow
91    SDL_MapRGB(Surface->format, 255, 255, 0),
92    1 // Thin line
93  );
94}
95
96bool CollisionComponent::GetCollisionRectangle(
97  const CollisionComponent& Other,
98  SDL_FRect* OutIntersection
99) const {
100  // Ensure the output pointer is valid
101  if (!OutIntersection) {
102    std::cerr << "Error: OutIntersection pointer "
103      "is null in GetCollisionRectangle.\n";
104    return false;
105  }
106
107  // Get world bounds (Y-up)
108  const SDL_FRect& A_world{GetWorldBounds()};
109  const SDL_FRect& B_world{
110    Other.GetWorldBounds()};
111
112  // Convert to SDL's Y-down system
113  SDL_FRect A_sdl{A_world};
114  A_sdl.y -= A_world.h; // Convert A to Y-down
115
116  SDL_FRect B_sdl{B_world};
117  B_sdl.y -= B_world.h; // Convert B to Y-down
118
119  // Calculate intersection in Y-down system
120  SDL_FRect Intersection_sdl;
121  if (SDL_IntersectFRect(
122      &A_sdl, &B_sdl, &Intersection_sdl))
123  {
124    // Collision occurred! Convert intersection
125    // back to Y-up world space
126    *OutIntersection = Intersection_sdl;
127    OutIntersection->y += Intersection_sdl.h; 
128
129    return true;
130  }
131
132  // No collision
133  return false;
134}

We also added a CheckCollisions() loop in the Scene to detect overlaps between entities using CollisionComponent::IsCollidingWith().

Our entities can now detect when they collide, but they don't yet do anything about it. Here's the relevant code we ended with:

Scene.h

1// Scene.h
2#pragma once
3#include <SDL.h>
4#include <vector>
5#include "AssetManager.h"
6#include "Entity.h"
7
8#define DRAW_DEBUG_HELPERS
9
10using EntityPtr = std::unique_ptr<Entity>;
11using EntityPtrs = std::vector<EntityPtr>;
12
13class Scene {
14 public:
15  Scene() {
16    // --- Falling Entity ---
17    EntityPtr& Player{Entities.emplace_back(
18      std::make_unique<Entity>(*this))};
19
20    Player->AddTransformComponent()
21      ->SetPosition({6, 5});
22    Player->AddPhysicsComponent()
23      ->SetMass(50.0);
24    Player->AddImageComponent("player.png");
25    Player
26        ->AddCollisionComponent()
27        ->SetSize(1.9, 1.7);
28
29    // --- Static Entity ---
30    EntityPtr& Floor{Entities.emplace_back(
31      std::make_unique<Entity>(*this))};
32
33    Floor->AddTransformComponent()
34      ->SetPosition({4.5, 1});
35    Floor->AddImageComponent("floor.png");
36    Floor
37        ->AddCollisionComponent()
38        ->SetSize(5.0, 2.0);
39
40    // Note the floor has no physics component
41    // so will not be affected by gravity
42  }
43
44  void HandleEvent(SDL_Event& E) {
45    for (EntityPtr& Entity : Entities) {
46      Entity->HandleEvent(E);
47    }
48  }
49
50  void Tick(float DeltaTime) {
51    for (EntityPtr& Entity : Entities) {
52      Entity->Tick(DeltaTime);
53    }
54    
55    CheckCollisions();
56  }
57
58  void Render(SDL_Surface* Surface) {
59    SDL_GetClipRect(Surface, &Viewport);
60    for (EntityPtr& Entity : Entities) {
61      Entity->Render(Surface);
62    }
63
64#ifdef DRAW_DEBUG_HELPERS
65    SDL_BlitSurface(
66      Trajectories, nullptr, Surface, nullptr);
67#endif
68  }
69
70  Vec2 ToScreenSpace(const Vec2& Pos) const {
71    auto [vx, vy, vw, vh]{Viewport};
72    float HorizontalScaling{
73      vw / WorldSpaceWidth};
74    float VerticalScaling{
75      vh / WorldSpaceHeight};
76
77    return {
78      vx + Pos.x * HorizontalScaling,
79      vy + (WorldSpaceHeight - Pos.y)
80        * VerticalScaling
81    };
82  }
83
84  SDL_FRect ToScreenSpace(
85    const SDL_FRect& Rect
86  ) const {
87    Vec2 ScreenPos{ToScreenSpace(
88      Vec2{Rect.x, Rect.y})};
89    float HorizontalScaling{
90      Viewport.w / WorldSpaceWidth};
91    float VerticalScaling{
92      Viewport.h / WorldSpaceHeight};
93
94    return {
95      ScreenPos.x,
96      ScreenPos.y,
97      Rect.w * HorizontalScaling,
98      Rect.h * VerticalScaling
99    };
100  }
101
102  AssetManager& GetAssetManager() {
103    return Assets;
104  }
105
106#ifdef DRAW_DEBUG_HELPERS
107  SDL_Surface* Trajectories{
108    SDL_CreateRGBSurfaceWithFormat(
109      0, 700, 300, 32, SDL_PIXELFORMAT_RGBA32
110    )
111  };
112#endif
113
114 private:
115  void CheckCollisions();
116  EntityPtrs Entities;
117  AssetManager Assets;
118  SDL_Rect Viewport;
119  float WorldSpaceWidth{14};  // meters
120  float WorldSpaceHeight{6};  // meters
121};

Scene.cpp

1// Scene.cpp
2#include <vector>
3#include "Scene.h"
4#include "CollisionComponent.h"
5
6void Scene::CheckCollisions() {
7  for (size_t i{0}; i < Entities.size(); ++i) {
8    CollisionComponent* ColA{
9      Entities[i]->GetCollisionComponent()};
10
11    // Skip if no collision component
12    if (!ColA) continue;
13
14    for (
15      size_t j{i + 1}; j < Entities.size(); ++j
16    ) {
17      CollisionComponent* ColB{
18        Entities[j]->GetCollisionComponent()};
19
20      // Skip if no collision component
21      if (!ColB) continue;
22
23      if (ColA->IsCollidingWith(*ColB)) {
24        std::cout <<
25          "Collision detected between "
26          "Entity " << i << " and Entity " << j
27          << "!\n";
28      }
29    }
30  }
31}

Currently, our program has the following characteristics:

Our Scene constructor creates Player and Floor objects, which are both Entity instances.
The Player has a PhysicsComponent, causing it to fall downwards due to gravity. It falls through the Floor.
The CheckCollisions() loop in our Scene is detecting the Floor and Player, intersection, but our entities don’t currently react to it:

Screenshot showing our collision debug helpers

1Collision detected between Entity 0 and Entity 1!
2Collision detected between Entity 0 and Entity 1!
3Collision detected between Entity 0 and Entity 1!
4// ...

Reacting to Collisions

Instead of putting all collision response logic inside the central Scene::CheckCollisions() loop, we'll use a more distributed approach. Each entity type will be responsible for defining how it reacts when it collides with other specific entity types.

We can achieve this by adding a virtual function to the base Entity class. Let's call it HandleCollision().

1// Entity.h
2// ...
3
4class Entity {
5public:
6  // ...
7
8  // Called when this entity collides with 'Other'
9  virtual void HandleCollision(Entity& Other) {} 
10
11  // ...
12};

When the Scene detects a collision between EntityA and EntityB, it will notify both entities:

EntityA->HandleCollision(EntityB);
EntityB->HandleCollision(EntityA);

This allows EntityA to decide how to react to EntityB, and EntityB to decide how to react to EntityA. Let’s add it to our CheckCollisions() function, replacing our basic logging statement:

1// Scene.cpp
2// ...
3
4void Scene::CheckCollisions() {
5  for (size_t i{0}; i < Entities.size(); ++i) {
6    CollisionComponent* ColA{
7      Entities[i]->GetCollisionComponent()};
8
9    // Skip if no collision component
10    if (!ColA) continue;
11
12    for (
13      size_t j{i + 1}; j < Entities.size(); ++j
14    ) {
15      CollisionComponent* ColB{
16        Entities[j]->GetCollisionComponent()};
17
18      // Skip if no collision component
19      if (!ColB) continue;
20
21      if (ColA->IsCollidingWith(*ColB)) {
22        std::cout <<
23          "Collision detected between "
24          "Entity " << i << " and Entity " << j
25          << "!\n";
26        Entities[i]->HandleCollision(*Entities[j]); 
27        Entities[j]->HandleCollision(*Entities[i]); 
28      }
29    }
30  }
31}

With this structure, the base Entity does nothing on collision, but derived classes can override HandleCollision() to implement specific reactions. Let’s implement a couple of examples.

Example 1: Character Landing on Floor

First, let’s see how we can make our existing Player entity land on the floor, without falling through it.

Creating Entity Subtypes

We need specific entity types. Let's define Character and Floor classes that inherit from Entity.

We’ll also move the initial component configuration for our two objects (currently defined in the Scene constructor) to these classes. This will help remove some clutter from our Scene later:

1// Character.h
2#pragma once
3#include "Entity.h"
4
5class Scene;
6class Character : public Entity {
7 public:
8  Character(Scene& Scene)
9  : Entity{Scene}
10  {
11    AddTransformComponent()->SetPosition({6, 5});
12    AddPhysicsComponent()->SetMass(50.0);
13    AddImageComponent("player.png");
14    AddCollisionComponent()->SetSize(1.9, 1.7);
15  }
16};

1// Floor.h
2#pragma once
3#include "Entity.h"
4
5class Scene;
6class Floor : public Entity {
7 public:
8  Floor(Scene& Scene) : Entity{Scene} {
9    AddTransformComponent()->SetPosition({4.5, 1});
10    AddImageComponent("floor.png");
11    AddCollisionComponent()->SetSize(5.0, 2.0);
12  }
13};

Over in our Scene, let’s update the constructor to use these new types. We can also delete all of their component setup, as that is now handled by the Character and Floor classes:

1// Scene.h
2// ...
3#include "Entity.h"
4#include "Character.h"
5#include "Floor.h"
6
7// ...
8
9class Scene {
10 public:
11  Scene() {
12    EntityPtr& Player{Entities.emplace_back(
13      std::make_unique<Entity>(*this))};
14
15    Player->AddTransformComponent()
16      ->SetPosition({6, 5});
17    Player->AddPhysicsComponent()
18      ->SetMass(50.0);
19    Player->AddImageComponent("player.png");
20    Player->AddCollisionComponent()
21      ->SetSize(1.9, 1.7);
22    Entities.emplace_back(
23      std::make_unique<Character>(*this));
24
25    EntityPtr& Floor{Entities.emplace_back(
26      std::make_unique<Entity>(*this))};
27
28    Floor->AddTransformComponent()
29      ->SetPosition({4.5, 1});
30    Floor->AddImageComponent("floor.png");
31    Floor->AddCollisionComponent()
32      ->SetSize(5.0, 2.0);
33    Entities.emplace_back(
34      std::make_unique<Floor>(*this));
35  }
36
37  void HandleEvent(SDL_Event& E) {
38    for (EntityPtr& Entity : Entities) {
39      Entity->HandleEvent(E);
40    }
41  }
42
43  // ...
44};

Implementing Character's Reaction

Now, let's implement Character::HandleCollision() for our Character.

The character only cares about collisions with the Floor. We use dynamic_cast to check if the Other entity it collided with is actually a Floor. We can use dynamic_cast for this and, if it’s not a Floor, we’re not interested in reacting so we’ll just return:

1// Character.h
2// ...
3#include "Floor.h"
4
5// ...
6
7class Character : public Entity {
8 public:
9  // ...
10
11  void HandleCollision(Entity& Other) override {
12    // Check if we collided with a Floor
13    Floor* FloorPtr{dynamic_cast<Floor*>(&Other)};
14    
15    // It's not a floor, so we don't care
16    if (!FloorPtr) return;
17    
18    // It is a floor, so we need to react
19  }
20};

If it is a Floor, we next need to get the collision intersection rectangle using the GetCollisionRectangle() we added to CollisionComponent in the previous lesson. This tells us how much they overlap.

1// Character.h
2// ...
3#include "Floor.h"
4
5// ...
6
7class Character : public Entity {
8 public:
9  // ...
10
11  void HandleCollision(Entity& Other) override {
12    Floor* FloorPtr{dynamic_cast<Floor*>(&Other)};
13    if (!FloorPtr) return;
14    
15    CollisionComponent* MyCollider{
16      GetCollisionComponent()};
17    CollisionComponent* FloorCollider{
18      FloorPtr->GetCollisionComponent()};
19
20    SDL_FRect Intersection;
21    MyCollider->GetCollisionRectangle(
22      *FloorCollider, &Intersection);
23   
24   // ...
25  }
26};

Next, to resolve the penetration, we’ll push the Character upwards out of the Floor. The distance to push is the height of the intersection rectangle. We modify the TransformComponent's position:

1// Character.h
2// ...
3#include "Floor.h"
4
5// ...
6
7class Character : public Entity {
8 public:
9  // ...
10
11  void HandleCollision(Entity& Other) override {
12    Floor* FloorPtr{dynamic_cast<Floor*>(&Other)};
13    if (!FloorPtr) return;
14    
15    CollisionComponent* MyCollider{
16      GetCollisionComponent()};
17    CollisionComponent* FloorCollider{
18      FloorPtr->GetCollisionComponent()};
19
20    SDL_FRect Intersection;
21    MyCollider->GetCollisionRectangle(
22      *FloorCollider, &Intersection);
23   
24   Vec2 CurrentPos{GetTransformComponent()
25     ->GetPosition()};
26   GetTransformComponent()->SetPosition({
27     CurrentPos.x,
28     CurrentPos.y + Intersection.h
29   });
30   
31   // ...
32  }
33};

Finally, we’ll stop the downward motion of the Character by setting the vertical component of its PhysicsComponent's velocity to zero.

This prevents gravity from constantly accelerating the entity, to the point where it is travelling fast enough that it can fully penetrate the Floor within a single tick of our physics simulation:

1// Character.h
2// ...
3#include "Floor.h"
4
5// ...
6
7class Character : public Entity {
8 public:
9  // ...
10
11  void HandleCollision(Entity& Other) override {
12    Floor* FloorPtr{dynamic_cast<Floor*>(&Other)};
13    if (!FloorPtr) return;
14    
15    CollisionComponent* MyCollider{
16      GetCollisionComponent()};
17    CollisionComponent* FloorCollider{
18      FloorPtr->GetCollisionComponent()};
19
20    SDL_FRect Intersection;
21    MyCollider->GetCollisionRectangle(
22      *FloorCollider, &Intersection);
23   
24    Vec2 CurrentPos{GetTransformComponent()->GetPosition()};
25    GetTransformComponent()->SetPosition({
26      CurrentPos.x,
27      CurrentPos.y + Intersection.h
28    });
29   
30    PhysicsComponent* Physics{GetPhysicsComponent()};
31    if (Physics) {
32      Vec2 CurrentVel{Physics->GetVelocity()};
33      // Stop vertical movement upon landing
34      if (CurrentVel.y < 0) {  // Only if falling
35        Physics->SetVelocity({CurrentVel.x, 0.0});
36      }
37    }
38  }
39};

If we run our game now. The Character should fall due to its PhysicsComponent, collide with the Floor, and stop correctly on top of it, thanks to the logic in Character::HandleCollision().

Screenshot showing character stopped on the floor

Example 2: Bouncing Ball

Now for a different reaction: a ball that bounces off surfaces.

Creating the `BouncingBall` Entity

Similar to Character, let's define a BouncingBall entity type, with some initial components and state:

1// BouncingBall.h
2#pragma once
3#include "Entity.h"
4
5class Scene;
6
7class BouncingBall: public Entity {
8public:
9  BouncingBall(Scene& Scene) : Entity{Scene} {
10    AddTransformComponent()->SetPosition({3, 4});
11    AddPhysicsComponent()->SetVelocity({5, 3});
12    AddImageComponent("basketball.png");
13    AddCollisionComponent();
14  }
15};

We’ll update our Scene to include a BouncingBall, and two simple entities that it can bounce off:

1// Scene.h
2// ...
3#include "BouncingBall.h"
4// ...
5
6class Scene {
7 public:
8  Scene() {
9    Entities.emplace_back(
10      std::make_unique<BouncingBall>(*this));
11
12    EntityPtr& Floor{Entities.emplace_back(
13      std::make_unique<Entity>(*this))};
14    Floor->AddTransformComponent()
15      ->SetPosition({3, 1});
16    Floor->AddCollisionComponent()
17      ->SetSize(7, 2);
18
19    EntityPtr& Wall{Entities.emplace_back(
20      std::make_unique<Entity>(*this))};
21    Wall->AddTransformComponent()
22      ->SetPosition({10, 5});
23    Wall->AddCollisionComponent()
24      ->SetSize(2, 5);
25  }
26
27  // ...
28};

For now, our ball just falls through the floor:

Screenshot showing ball falling through the floor

Resolving Penetration

Let’s implement our bouncing behaviour by overriding the HandleCollision() function, in the same way we did for our Character. Let’s get started by grabbing the physics and transform components as we did before, as well as the collision intersection. In this case, we’ll let our ball bounce of anything, so we’ll skip checking what the Other entity is:

1// BouncingBall.h
2// ...
3
4class BouncingBall : public Entity {
5public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
9    SDL_FRect Intersection;
10    
11    GetCollisionComponent()->GetCollisionRectangle(
12      *Other.GetCollisionComponent(), &Intersection
13    );
14
15    PhysicsComponent* Physics{
16      GetPhysicsComponent()};
17    TransformComponent* Transform{
18      GetTransformComponent()};
19    
20    // Safety check - we need these to bounce
21    if (!(Physics && Transform)) return;
22    
23    // ...
24  }
25};

Let’s start by pushing the ball out of the object it collided with, similar to how we pushed our Character out from the Floor. The additional challenge here is that we don’t just always assume we need to push our ball up. We need to determine the direction based on the nature of the collision.

Collision Normal

In physics and geometry, a normal (or normal vector) is a vector that is perpendicular to a surface at a given point. Think of it as an arrow pointing directly "out" from the surface.

When two objects collide, the collision normal represents the primary direction of the impact force. It's the direction along which the objects push against each other. For simple shapes like our Axis-Aligned Bounding Boxes (AABBs), the normal is usually aligned with one of the major axes (X or Y).

Flat Horizontal Surface (like our Floor): If an object hits it from above, the collision normal points straight up along the positive Y-axis, e.g., {0, 1}. This is the direction the floor "pushes back".
Vertical Surface (like a Wall): If an object hits it from the right, the normal points straight left along the negative X-axis, e.g., {-1, 0}. If hit from the left, it points right, {1, 0}.
Angled Surface: For more complex shapes or angled surfaces, the normal wouldn't align perfectly with the X or Y axis, but would still point perpendicularly away from the surface at the point of impact.

Knowing the collision normal is useful for realistic physics responses. It tells us the direction to push objects apart to resolve penetration and the axis along which velocity should be reflected for bouncing.

For AABB collisions, we can guess what the collision normal is based on the nature of the collision intersection rectangle:

If the intersection rectangle is wider than it is tall, we guess the collision is primarily vertical. If the ball was moving up, we push it back down. If the ball was moving down, we push it back up.
If the intersection rectangle is taller than it is wide, we guess the collision is primarily horizontal. If the ball was moving left, we push it back to the right. If the ball was moving right, we push it back to the left.

Let’s implement this logic:

1// BouncingBall.h
2// ...
3
4class BouncingBall : public Entity {
5public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
9    SDL_FRect Intersection;
10    
11    GetCollisionComponent()->GetCollisionRectangle(
12      *Other.GetCollisionComponent(), &Intersection
13    );
14
15    PhysicsComponent* Physics{
16      GetPhysicsComponent()};
17    TransformComponent* Transform{
18      GetTransformComponent()};
19
20    if (!(Physics && Transform)) return;
21
22    Vec2 CurrentPos{Transform->GetPosition()};
23    if (Intersection.w < Intersection.h) {
24      if (Physics->GetVelocity().x > 0)
25        CurrentPos.x -= Intersection.w;
26      else
27        CurrentPos.x += Intersection.w;
28    } else {
29      if (Physics->GetVelocity().y <0)
30        CurrentPos.y += Intersection.h;
31      else
32        CurrentPos.y -= Intersection.h;
33    }
34    Transform->SetPosition(CurrentPos);
35    
36    // ...
37  }
38};

We should now see our ball hit the floor and then slide along it until it gets stuck in the corner:

Screenshot showing our ball reacting to collisions

Implementing Bouncing

Finally, let’s implement our bouncing behaviour. This involves reversing one of the components of our ball’s velocity. If the collision is primarily vertical, we’ll reverse the ball’s y velocity whilst, if it’s horizontal, we’ll reverse it’s x velocity:

1// BouncingBall.h
2// ...
3
4class BouncingBall : public Entity {
5public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
9    SDL_FRect Intersection;
10    
11    GetCollisionComponent()->GetCollisionRectangle(
12      *Other.GetCollisionComponent(), &Intersection
13    );
14
15    PhysicsComponent* Physics{
16      GetPhysicsComponent()};
17    TransformComponent* Transform{
18      GetTransformComponent()};
19
20    if (!(Physics && Transform)) return;
21
22    Vec2 CurrentPos{Transform->GetPosition()};
23    if (Intersection.w < Intersection.h) {
24      if (Physics->GetVelocity().x > 0)
25        CurrentPos.x -= Intersection.w;
26      else
27        CurrentPos.x += Intersection.w;
28    } else {
29      if (Physics->GetVelocity().y <0)
30        CurrentPos.y += Intersection.h;
31      else
32        CurrentPos.y -= Intersection.h;
33    }
34    Transform->SetPosition(CurrentPos);
35
36    Vec2 CurrentVel{Physics->GetVelocity()};
37    // Wider intersection = vertical collision
38    if (Intersection.w > Intersection.h) {
39      Physics->SetVelocity({
40        CurrentVel.x,
41        -CurrentVel.y
42      });
43    } else {
44      Physics->SetVelocity({
45        -CurrentVel.x,
46        CurrentVel.y
47      });
48    }
49  }
50};

With these changes, our ball should now bounce off our other entities:

We can make this more realistic by applying a dampening effect, reducing the ball’s speed on each impact:

1// BouncingBall.h
2// ...
3
4class BouncingBall : public Entity {
5public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
32    
33    float DAMPENING{0.8};
34    Vec2 CurrentVel{Physics->GetVelocity()};
35    if (Intersection.w > Intersection.h) {
36      Physics->SetVelocity({
37        CurrentVel.x,
38        -CurrentVel.y * DAMPENING  
39      });
40    } else {
41      Physics->SetVelocity({
42        -CurrentVel.x * DAMPENING,
43        CurrentVel.y
44      });
45    }
46  }
47};

Screenshot showing our ball bouncing with dampening

More Robust Penetration Resolution

The penetration resolution logic above is quite simple. It pushes the ball out based only on the smallest overlap dimension. This can sometimes cause slightly incorrect behavior if the ball hits a corner, or if the "push out" moves the object into a position where it’s now colliding with something else.

A more robust (but complex) methods involve techniques like calculating the exact time of impact and "rewinding" the physics state to that exact moment. Examining the world at the specific moment the collision happened lets us better understand how it happened, so we can apply the bounce reaction more accurately.

Having implemented the reaction (eg, the change in the ball’s velocity), we then re-simulate the remaining portion of the timestep to determine if that change caused any further collisions.

This technique is called Continuous Collision Detection (CCD) and is beyond the scope of this course, but is often used in more advanced physics engines. Our simpler "push-out" method is still commonly used, as it is less expensive and sufficiently accurate for less important objects.

Handling Different Reactions

The use of virtual functions allows for polymorphic collision handling. The Scene doesn't need to know the specific types involved; it simply calls HandleCollision(), and the runtime system ensures the correct overridden version for each Entity subtype is executed.

This makes our system easy to extend without requiring us to add additional complexity to important classes such as Scene. For example, let’s reintroduce our Character and Floor to the Scene:

1// Scene.h
2// ...
3
4#include "BouncingBall.h"
5#include "Character.h"
6#include "Floor.h"
7
8// ...
9
10class Scene {
11 public:
12  Scene() {
13    Entities.emplace_back(
14      std::make_unique<BouncingBall>(*this));
15    Entities.emplace_back(
16      std::make_unique<Character>(*this));
17    Entities.emplace_back(
18      std::make_unique<Floor>(*this));
19  }
20};

Without any further changes, our bouncing ball now reacts with our Character and Floor, because it reacts with any Entity in our scene that has a CollisionComponent:

Screenshot showing our ball bouncing off the character

Updating our Character to react to being hit by a BouncingBall just takes a few lines of code in our Character class. In this example, we’ve also moved our floor collision logic into a new private function, to keep things organized:

1// Character.h
2// ...
3#include "BouncingBall.h"
4
5class Character : public Entity {
6 public:
7  // ...
8
9  void HandleCollision(Entity& Other) override {
10    auto* FloorPtr{dynamic_cast<Floor*>(&Other)};
11    if (FloorPtr) HandleCollision(FloorPtr);
12
13    auto* BallPtr{dynamic_cast<BouncingBall*>(&Other)};
14    if (BallPtr) HandleCollision(BallPtr);
15  }
16
17private:
18  void HandleCollision(Floor* FloorPtr){/*...*}
43
44  void HandleCollision(BouncingBall* BallPtr) {
45    std::cout << "A ball hit me!\n";
46  }
47};

1A ball hit me!

Complete Code

Below, we’ve provided all the files we created and updated in this lesson. Our new Floor, BouncingBall, and Character classes are here:

Floor.h

1#pragma once
2#include "Entity.h"
3
4class Scene;
5class Floor : public Entity {
6 public:
7  Floor(Scene& Scene) : Entity{Scene} {
8    AddTransformComponent()->SetPosition({4.5, 1});
9    AddImageComponent("floor.png");
10    AddCollisionComponent()->SetSize(5.0, 2.0);
11  }
12};

BouncingBall.h

1#pragma once
2#include "Entity.h"
3
4class Scene;
5
6class BouncingBall : public Entity {
7public:
8  BouncingBall(Scene& Scene) : Entity{Scene} {
9    AddTransformComponent()->SetPosition({3, 4});
10    AddPhysicsComponent()->SetVelocity({5, 3});
11    AddImageComponent("basketball.png");
12    AddCollisionComponent();
13  }
14
15  void HandleCollision(Entity& Other) override {
16    SDL_FRect Intersection;
17
18    GetCollisionComponent()->GetCollisionRectangle(
19        *Other.GetCollisionComponent(), &Intersection);
20
21    PhysicsComponent* Physics{GetPhysicsComponent()};
22    TransformComponent* Transform{GetTransformComponent()};
23
24    if (!(Physics && Transform)) return;
25
26    Vec2 CurrentPos{Transform->GetPosition()};
27    if (Intersection.w < Intersection.h) {
28      if (Physics->GetVelocity().x > 0)
29        CurrentPos.x -= Intersection.w;
30      else
31        CurrentPos.x += Intersection.w;
32    } else {
33      if (Physics->GetVelocity().y < 0)
34        CurrentPos.y += Intersection.h;
35      else
36        CurrentPos.y -= Intersection.h;
37    }
38    Transform->SetPosition(CurrentPos);
39
40    Vec2 CurrentVel{Physics->GetVelocity()};
41    if (Intersection.w > Intersection.h) {
42      Physics->SetVelocity({
43          CurrentVel.x,
44          -CurrentVel.y * 0.8f
45      });
46    } else {
47      Physics->SetVelocity({
48          -CurrentVel.x * 0.8f,
49          CurrentVel.y
50      });
51    }
52  }
53};

Character.h

1#pragma once
2#include "BouncingBall.h"
3#include "Entity.h"
4#include "Floor.h"
5
6class Scene;
7class Floor;
8
9class Character : public Entity {
10 public:
11  Character(Scene& Scene)
12  : Entity{Scene}
13  {
14    AddTransformComponent()->SetPosition({6, 5});
15    AddPhysicsComponent()->SetMass(50.0);
16    AddImageComponent("player.png");
17    AddCollisionComponent()->SetSize(1.9, 1.7);
18  }
19
20  void HandleCollision(Entity& Other) override {
21    auto* FloorPtr{dynamic_cast<Floor*>(&Other)};
22    if (FloorPtr) HandleCollision(FloorPtr);
23
24    auto* BallPtr{dynamic_cast<BouncingBall*>(&Other)};
25    if (BallPtr) HandleCollision(BallPtr);
26  }
27
28private:
29  void HandleCollision(Floor* FloorPtr) {
30    CollisionComponent* MyCollider{
31      GetCollisionComponent()};
32    CollisionComponent* FloorCollider{
33      FloorPtr->GetCollisionComponent()};
34
35    SDL_FRect Intersection;
36    MyCollider->GetCollisionRectangle(
37      *FloorCollider, &Intersection);
38   
39    Vec2 CurrentPos{GetTransformComponent()->GetPosition()};
40    GetTransformComponent()->SetPosition({
41      CurrentPos.x,
42      CurrentPos.y + Intersection.h
43    });
44   
45    PhysicsComponent* Physics{GetPhysicsComponent()};
46    if (Physics) {
47      Vec2 CurrentVel{Physics->GetVelocity()};
48      if (CurrentVel.y < 0) {
49        Physics->SetVelocity({CurrentVel.x, 0.0});
50      }
51    }
52  }
53
54  void HandleCollision(BouncingBall* BallPtr) {
55    std::cout << "Ouch!\n";
56  }
57};

Our updated Scene and Entity files are provided below, with the changes we made in this lesson highlighted:

Scene.h

1// Scene.h
2#pragma once
3#include <SDL.h>
4#include <vector>
5#include "AssetManager.h"
6#include "Character.h"
7#include "BouncingBall.h"
8#include "Floor.h"
9
10#define DRAW_DEBUG_HELPERS
11
12using EntityPtr = std::unique_ptr<Entity>;
13using EntityPtrs = std::vector<EntityPtr>;
14
15class Scene {
16 public:
17  Scene() {
18    Entities.emplace_back(
19      std::make_unique<BouncingBall>(*this));
20    Entities.emplace_back(
21      std::make_unique<Character>(*this));
22    Entities.emplace_back(
23      std::make_unique<Floor>(*this));
24  }
25
26  void HandleEvent(SDL_Event& E) {
27    for (EntityPtr& Entity : Entities) {
28      Entity->HandleEvent(E);
29    }
30  }
31
32  void Tick(float DeltaTime) {
33    for (EntityPtr& Entity : Entities) {
34      Entity->Tick(DeltaTime);
35    }
36
37    CheckCollisions();
38  }
39
40  void Render(SDL_Surface* Surface) {
41    SDL_GetClipRect(Surface, &Viewport);
42    for (EntityPtr& Entity : Entities) {
43      Entity->Render(Surface);
44    }
45
46#ifdef DRAW_DEBUG_HELPERS
47    SDL_BlitSurface(
48      Trajectories, nullptr, Surface, nullptr);
49#endif
50  }
51
52  Vec2 ToScreenSpace(const Vec2& Pos) const {
53    auto [vx, vy, vw, vh]{Viewport};
54    float HorizontalScaling{
55      vw / WorldSpaceWidth};
56    float VerticalScaling{
57      vh / WorldSpaceHeight};
58
59    return {
60      vx + Pos.x * HorizontalScaling,
61      vy + (WorldSpaceHeight - Pos.y)
62        * VerticalScaling
63    };
64  }
65
66  SDL_FRect ToScreenSpace(
67    const SDL_FRect& Rect
68  ) const {
69    Vec2 ScreenPos{ToScreenSpace(
70      Vec2{Rect.x, Rect.y})};
71    float HorizontalScaling{
72      Viewport.w / WorldSpaceWidth};
73    float VerticalScaling{
74      Viewport.h / WorldSpaceHeight};
75
76    return {
77      ScreenPos.x,
78      ScreenPos.y,
79      Rect.w * HorizontalScaling,
80      Rect.h * VerticalScaling
81    };
82  }
83
84  AssetManager& GetAssetManager() {
85    return Assets;
86  }
87
88#ifdef DRAW_DEBUG_HELPERS
89  SDL_Surface* Trajectories{
90    SDL_CreateRGBSurfaceWithFormat(
91      0, 700, 300, 32, SDL_PIXELFORMAT_RGBA32
92    )
93  };
94#endif
95
96 private:
97  void CheckCollisions();
98  EntityPtrs Entities;
99  AssetManager Assets;
100  SDL_Rect Viewport;
101  float WorldSpaceWidth{14};  // meters
102  float WorldSpaceHeight{6};  // meters
103};

Scene.cpp

1// Scene.cpp
2#include <vector>
3#include "Scene.h"
4#include "CollisionComponent.h"
5
6void Scene::CheckCollisions() {
7  for (size_t i{0}; i < Entities.size(); ++i) {
8    CollisionComponent* ColA{
9      Entities[i]->GetCollisionComponent()};
10    if (!ColA) continue;
11
12    for (size_t j{i + 1}; j < Entities.size(); ++j) {
13      CollisionComponent* ColB{
14        Entities[j]->GetCollisionComponent()};
15      if (!ColB) continue;
16
17      if (ColA->IsCollidingWith(*ColB)) {
18        Entities[i]->HandleCollision(*Entities[j]);
19        Entities[j]->HandleCollision(*Entities[i]);
20      }
21    }
22  }
23}

Entity.h

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

Summary

In this lesson, we transitioned from simply detecting collisions to implementing meaningful reactions. We adopted a distributed response model using a virtual HandleCollision(Entity& Other) method in the base Entity class.

We created specific entity subtypes (Character, Floor, BouncingBall) that override HandleCollision() to define their unique behaviors when interacting with other types, identified using dynamic_cast.

Key takeaways:

Collision Response: The actions taken after a collision is detected.
Distributed Response: Using virtual functions - HandleCollision() - allows entity types to define their own reactions to specific collision partners.
Identifying Participants: dynamic_cast is used within HandleCollision() to determine the type of the Other entity involved.
Penetration Resolution: Pushing entities apart based on the intersection rectangle is used to prevent objects from occupying the same space in an unrealistic way. We adjusted TransformComponent::Position to push them apart.
Motion Correction: Modifying PhysicsComponent::Velocity is used for realistic reactions like stopping or bouncing.
Stopping: Typically involves setting the velocity component along the collision normal to zero (e.g., vertical velocity when landing).
Bouncing: Involves reversing the velocity component along the collision normal (approximated for AABBs by comparing intersection width/height).
The Scene::CheckCollisions() loop now triggers the response by calling HandleCollision() on both colliding entities.

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 7 hours ago

Lesson Contents