Creating an Image Component

In this lesson, we’ll start building our ImageComponent, converting it from its current placeholder state to something much more useful.  We will walk through using SDL_image to load assets, storing image data using SDL_Surface, and handling the associated resource management. You will learn:

• How to load images from files and check for errors.
• Why manual memory management necessitates implementing the Rule of Five (destructor, copy/move constructor, copy/move assignment).
• How to prevent dangling pointers and double-free errors associated with raw pointers like SDL_Surface*.

Starting Point

Currently, we have Entity objects, and they can have a TransformComponent to know where they are in the world. But right now, they're completely invisible.

Our current ImageComponent is just a placeholder that prints text:

1// ImageComponent.h
2#pragma once
3#include "Component.h"
4
5class ImageComponent : public Component {
6 public:
7  using Component::Component;
8  void Initialize() override;
9  void Render(SDL_Surface* Surface) override;
10};

1// ImageComponent.cpp
2#include "ImageComponent.h"
3#include "Entity.h"
4
5void ImageComponent::Render(
6  SDL_Surface* Surface
7) {
8  TransformComponent* Transform{
9    GetOwner()->GetTransformComponent()
10  };
11
12  std::cout << "ImageComponent rendering at: "
13    << Transform->GetPosition() << '\n';
14}
15
16void ImageComponent::Initialize() {
17  Entity* Owner{GetOwner()};
18  if (!Owner->GetTransformComponent()) {
19    std::cout << "Error: ImageComponent requires"
20      " TransformComponent on its Owner\n";
21
22    // Request removal
23    Owner->RemoveComponent(this);
24  }
25}

It's time to give it the power to actually load and display images.

We'll be using the SDL_image library for this, which helps us load common formats like PNG and JPG. You should have SDL_image set up from earlier in the course.

SDL_Init() and SDL_Quit()

Before we use SDL_image, we should initialize. We do this by calling IMG_Init() and telling it which image formats we want to support (like PNG and JPG) as a bitmask:

1IMG_Init(IMG_INIT_PNG | IMG_INIT_JPG);

The IMG_Init function returns a bitmask of the formats it initialized. We can compare this return value to the bitmask we requested to check if anything went wrong.

We can call SDL_GetError() or, equivalently, IMG_GetError() for an explanation of the most recent error:

1int IMG_FLAGS{IMG_INIT_PNG | IMG_INIT_JPG};
2if (!(IMG_Init(IMG_FLAGS) & IMG_FLAGS)) {
3  std::cerr << "IMG_Init failed! "
4    << "IMG_Error: " << IMG_GetError() << '\n';
5} else {
6  std::cout << "IMG_Init successful\n";
7}

We cover bitmasks, the | operator, and the & operator in more detail here:

Bitwise Operators and Bit Flags

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

When our program no longer need SDL_image , we should call IMG_Quit() to let it clean up any resources it was using. Let’s add IMG_Init() and IMG_Quit() to our main.cpp:

1// main.cpp
2#include <SDL.h>
3#include <SDL_image.h>
4#include "Window.h"
5#include "Scene.h"
6
7int main(int argc, char** argv) {
8  SDL_Init(SDL_INIT_VIDEO);
9
10  int IMG_FLAGS{IMG_INIT_PNG | IMG_INIT_JPG};
11  if (!(IMG_Init(IMG_FLAGS) & IMG_FLAGS)) {
12    std::cerr << "IMG_Init failed! "
13      << "IMG_Error: " << IMG_GetError() << '\n';
14  } else {
15    std::cout << "IMG_Init successful\n";
16  }
17
18  Window GameWindow;
19  Scene GameScene;
20
21  Uint64 LastTick{SDL_GetPerformanceCounter()};
22  SDL_Event Event;
23  while (true) {
24    while (SDL_PollEvent(&Event)) {
25      GameScene.HandleEvent(Event);
26      if (Event.type == SDL_QUIT) {
27        IMG_Quit();
28        SDL_Quit();
29        return 0;
30      }
31    }
32    
Tick and Render Logic (Unchanged)|Show
49  }
50
51  return 0;
52}

File Loading

Now that our program is handling the initialization and cleanup of SDL_image, let’s start working on our image component. First things first, our ImageComponent needs a place to store the actual image data once it's loaded.

SDL provides the SDL_Surface structure for this purpose. It essentially holds the raw pixel data for an image in the computer's main memory. We'll use a raw pointer, SDL_Surface*, to point to this data.

Because we're managing this resource ourselves (the SDL_Surface is created dynamically), we also need to be responsible for cleaning it up when the ImageComponent is destroyed. This means we'll need a destructor - ~ImageComponent().

Let's modify ImageComponent.h to add the SDL_Surface* ImageSurface member, and also a std::string ImageFilePath to remember which file we loaded.

We'll update the constructor to take the file path as an argument and declare that all-important destructor:

1// ImageComponent.h
2#pragma once
3#include <string>
4#include <SDL.h>
5#include "Component.h"
6
7class ImageComponent : public Component {
8 public:
9  using Component::Component;
10  // Constructor takes entity owner and image file path
11  ImageComponent(
12    Entity* Owner,
13    const std::string& FilePath  
14  );
15  ~ImageComponent() override; 
16
17  void Initialize() override;
18  void Render(SDL_Surface* Surface) override;
19  
20private:
21  // Pointer to the loaded surface data
22  SDL_Surface* ImageSurface{nullptr};  
23  // Store the path used to load this image
24  std::string ImageFilePath;  
25};

Implementing the Constructor

Now, let's jump over to ImageComponent.cpp to implement the constructor. The first step in the constructor is to actually load the image file specified by FilePath.

We use the IMG_Load() function for this. It takes the file path as a C-style string, so we use .c_str() and, if successful, returns a pointer to a newly created SDL_Surface containing the image data.

It's important to check if IMG_Load() succeeded. If it returns nullptr, something went wrong (maybe the file doesn't exist, or it's a format SDL_image couldn't handle).

We should print an error message so we know about the problem. If it does succeed, we store the returned pointer in our ImageSurface member.

1// ImageComponent.cpp
2#include "ImageComponent.h"
3#include <iostream>
4
5ImageComponent::ImageComponent(
6  Entity* Owner,
7  const std::string& FilePath
8) : Component(Owner),
9    ImageFilePath(FilePath)
10{
11  // Load the image from the file path
12  ImageSurface = IMG_Load(FilePath.c_str());  
13
14  // Check if IMG_Load returned a valid surface pointer
15  if (!ImageSurface) {  
16    // If null, loading failed. Print an error.
17    std::cerr
18      << "Failed to load image: " << FilePath
19      << " Error: " << IMG_GetError() << '\n';
20  } else {
21    // Loading succeeded!
22    std::cout << "Loaded image: "
23      << FilePath << '\n';
24  }
25}

Implementing the Destructor

Now for the cleanup crew! We need to implement the destructor ~ImageComponent(). Its main job is to free the memory used by the SDL_Surface we loaded.

We do this using SDL_FreeSurface(). We should ensure we don’t call it too early, or that we don’t call it with a pointer that was previously freed. It is, however, safe to call SDL_FreeSurface() with a nullptr.

1// ImageComponent.cpp
2// ... 
3
4// Implement the destructor
5ImageComponent::~ImageComponent() { 
6  SDL_FreeSurface(ImageSurface); 
7  // Set pointer to null after freeing to be safe
8  ImageSurface = nullptr; 
9}

Updating Render()

Let's replace our placeholder Render() implementation. We’ll implement rendering for real in the next lesson but, for now, Render() will just print a message confirming everything is ready:

1// ImageComponent.cpp
2// ...
3
4void ImageComponent::Render(
5  SDL_Surface* Surface
6) {
7  // Only proceed if we have a surface loaded
8  if (!ImageSurface) return;
9
10  // Check for transform component (needed for position)
11  TransformComponent* Transform{
12    GetOwner()->GetTransformComponent()};
13
14  if (Transform) {
15    // Just print a message for now
16    std::cout << "ImageComponent ("
17      << ImageFilePath
18      << ") ready to render at: "
19      << Transform->GetPosition() << '\n';
20  } else {
21    // Handle case where transform is missing
22    std::cout << "ImageComponent ("
23      << ImageFilePath
24      << ") ready, but no TransformComponent found\n";
25  }
26}

Great! Our ImageComponent knows how to load and clean up its image. Now we need the Entity class to be able to create it.

Providing Image Paths

Let's hop over to Entity.h and update the AddImageComponent() method so it takes the std::string FilePath as an argument, and forward it to the ImageComponent constructor:

1// Entity.h
2// ...
3
4class Entity {
5public:
6  // ...
7
8  ImageComponent* AddImageComponent(
9    const std::string& FilePath
10  ) {
11    std::unique_ptr<Component>& NewComponent{
12      Components.emplace_back(
13        std::make_unique<ImageComponent>(
14          this, FilePath))};
15
16    NewComponent->Initialize();
17
18    return static_cast<ImageComponent*>(
19      NewComponent.get());
20  }
21
22  // ...
23};

The final step is to actually use this in our Scene. Let’s visit Scene.h and modify the constructor to create entities and call the new AddImageComponent() method, providing the filenames for the images we want to load.

Make sure you have files named "player.png" and "dragon.png" (or whatever you choose) in a place your program can find them (usually the same directory as the executable):

1// Scene.h
2#pragma once
3#include <SDL.h>
4#include <vector>
5#include <memory>
6#include <string> // For file paths 
7#include "Entity.h"
8
9using EntityPtr = std::unique_ptr<Entity>;
10using EntityPtrs = std::vector<EntityPtr>;
11
12class Scene {
13 public:
14  Scene() {
15    EntityPtr& Player{Entities.emplace_back(
16      std::make_unique<Entity>())};
17
18    Player->AddTransformComponent();
19    Player->AddImageComponent("player.png");
20
21    EntityPtr& Enemy{Entities.emplace_back(
22      std::make_unique<Entity>())};
23
24    Enemy->AddTransformComponent();
25    Enemy->AddImageComponent("dragon.png");
26  }
27
28  // ...
29};

If we compile and run our program, we shouldn't see any images drawn yet, but we should see messages confirming "player.png" and "crate.png" were loaded successfully (or error messages if something went wrong).

We should also see a message telling us the components are ready to render on every iteration of our game loop:

1IMG_Init successful
2Loaded image: player.png
3IMG_Init successful
4Loaded image: dragon.png
5ImageComponent (player.png) ready to render at: { x = 0, y = 0 }
6ImageComponent (dragon.png) ready to render at: { x = 0, y = 0 }
7ImageComponent (player.png) ready to render at: { x = 0, y = 0 }
8ImageComponent (dragon.png) ready to render at: { x = 0, y = 0 }
9...

Copy Semantics

Note: Feel free to skip this section if you’re already familiar and comfortable with copy semantics. In the next lesson, we’ll replace the code we write here with a more advanced design that does not require custom copy semantics.

When we have components that are manually managing memory, such as our SDL_Surface, we need to consider a boring but important topic: how those objects are copied.

If we were to simply copy an ImageComponent (e.g., ImageComponent Copy{Original};), C++'s default behavior would perform a shallow copy. It copies the values of each member variable directly. For the ImageSurface pointer, this means both the Original and the Copy would end up holding the exact same memory address, pointing to the same SDL_Surface.

This is a recipe for disaster. When the first component (say, Copy) gets destroyed, its destructor will call SDL_FreeSurface(), deleting the image data. Now, the Original component has a dangling pointer – it points to memory that's no longer valid. That will be problematic the next time Original tries to use that pointer.

And there is a second problem: later, when Original is destroyed, it will try to call SDL_FreeSurface() on that same invalid address, likely leading to a crash (a double free error).

To handle this correctly, we need to define our own copying behavior. This usually involves implementing the copy constructor and the copy assignment operator.

The Rule of Three

This principle is sometimes called the Rule of Three, a C++ rule of thumb which states that if our type defines a custom destructor, a custom copy constructor, or a custom copy assignment operator, it probably needs to define all three of them.

We covered copy semantics and the Rule of Three in our introductory course:

Copy Constructors and Operators

Explore advanced techniques for managing object copying and resource allocation

For ImageComponent, we want a deep copy: that is, when an ImageComponent is copied, the new copy should load its own, independent SDL_Surface from the ImageFilePath.

First, let's declare these two special functions in ImageComponent.h. We'll also declare a private helper function, LoadSurfaceInternal(), which will contain the logic for freeing an old surface (if any) and loading a new one. This helps avoid repeating code:

1// ImageComponent.h
2// ...
3
4class ImageComponent : public Component {
5 public:
6  // ...
7
8  // Copy Semantics
9  ImageComponent(const ImageComponent& Other); 
10  ImageComponent& operator=(
11    const ImageComponent& Other); 
12
13 private:
14  // ...
15
16  // Helper to load/reload the surface
17  void LoadSurfaceInternal(); 
18};

Now, let's implement LoadSurfaceInternal() in ImageComponent.cpp. It first checks if ImageSurface currently points to something; if so, it frees it.

Then, if ImageFilePath isn't empty, it tries to load the image using IMG_Load() and updates ImageSurface.

1// ImageComponent.cpp
2// ...
3
4void ImageComponent::LoadSurfaceInternal() {
5  // 1. Free existing surface if there is one
6  if (ImageSurface) {
7    SDL_FreeSurface(ImageSurface);
8    ImageSurface = nullptr;
9  }
10
11  // 2. Load new surface if path is not empty
12  if (!ImageFilePath.empty()) {
13    ImageSurface = IMG_Load(
14      ImageFilePath.c_str());
15    if (!ImageSurface) {
16      std::cerr
17        << "Failed to load image: "
18        << ImageFilePath
19        << " Error: " << IMG_GetError() << '\n';
20    } else {
21      std::cout << "Loaded image: "
22        << ImageFilePath << '\n';
23    }
24  }
25}

Let's update our existing constructor to use this new helper function:

1// ImageComponent.cpp
2// ...
3
4ImageComponent::ImageComponent(
5  Entity* Owner,
6  const std::string& FilePath
7) : Component(Owner),
8    ImageFilePath(FilePath)
9{
10  LoadSurfaceInternal();
11}

Now we can implement the copy constructor. It's called when a new ImageComponent is created as a copy of an existing one (which we’ll call Other). It needs to copy the basic members (just ImageFilePath, in this case), and then call LoadSurfaceInternal() to perform the deep copy of the SDL_Surface:

1// ImageComponent.cpp
2// ...
3
4// Copy Constructor
5ImageComponent::ImageComponent(
6  const ImageComponent& Other
7)
8  : Component(Other.GetOwner()),
9    ImageFilePath(Other.ImageFilePath)
10{
11  // Now load our *own* copy of the surface
12  LoadSurfaceInternal();
13}

Next, the copy assignment operator. This is called when an existing component is assigned the value of another (ExistingComponent = OtherComponent;).

It must handle self-assignment (assigning an object to itself), copy the basic members, and then use LoadSurfaceInternal() to release its old surface and load a fresh copy based on the Other component's file path. It should return a reference to itself, which it can retrieve using *this.

1// ImageComponent.cpp
2// ...
3
4// Copy Assignment Operator Implementation
5ImageComponent& ImageComponent::operator=(
6    const ImageComponent& Other
7) {
8  // 1. Check for self-assignment
9  if (this == &Other) {
10    return *this;
11  }
12
13  // 2. Copy base class members (the Owner
14  // entity, in this case)
15  Component::operator=(Other);
16
17  // 3. Copy this class's members
18  ImageFilePath = Other.ImageFilePath;
19
20  // 4. Handle the resource (deep copy)
21  // LoadSurfaceInternal() conveniently freeing
22  // the old surface and loading the new one.
23  LoadSurfaceInternal();
24
25  // 5. Return reference to self
26  return *this;
27}

With our copy operations defined, ImageComponent now handles copying correctly, ensuring each copy gets its own independent image data.

Move Semantics

Note: Feel free to skip this section if you’re already familiar and comfortable with move semantics. In the next lesson, we’ll replace the code we write here with a more advanced design that does not require custom move semantics.

We've made copying safe with deep copies, but reloading the image file every time we copy can be slow. Think about scenarios where you might be moving components around.

For example, our components are stored in a std::vector within our Entity class. When the std::vector needs to move to a new memory location, it needs to do a lot of work behind the scenes. It will need to copy all of our image components to that new location using the copy semantics we provided, and then delete the original versions in the old location.

If the original component (the source) is just going to be destroyed or discarded immediately after the "copy", reloading the image seems wasteful.

This is where move semantics come in handy. Instead of making a deep copy, we can move the resources. We cover move semantics in detail in a dedicated lesson in our advanced course:

Move Semantics

Learn how we can improve the performance of our types using move constructors, move assignment operators and std::move()

For our ImageComponent, move semantics involves the new component (the destination) simply taking ownership of the existing SDL_Surface* pointer from the source component. After all, the source component about to be deleted, so it no longer needs them.

The source object's pointer is then set to nullptr so it doesn't try to free the resource later. We also move other data like the ImageFilePath. This is typically much faster than copying because we avoid file I/O and memory allocation.

C++ provides two special functions for this: the move constructor and the move assignment operator. They take rvalue references (&&) as parameters. This && syntax signals that the object it references is no longer needed and is likely going to be deleted soon. As such, we can steal its resources if doing so is more efficient than copying them.

Let's declare our move constructor and move assignment operator in ImageComponent.h:

1// ImageComponent.h
2// ...
3
4class ImageComponent : public Component {
5 public:
6  // ...
7
8  // Move Semantics
9  ImageComponent(
10    ImageComponent&& Other) noexcept;
11  ImageComponent& operator=(
12    ImageComponent&& Other) noexcept;
13
14  // ...
15};

Note: we explain the noexcept keyword at the end of this section

Now for the implementation in ImageComponent.cpp. The move constructor - ImageComponent(ImageComponent&& Other) - initializes the new object by stealing the ImageSurface pointer from Other.

To move other members, like the ImageFilePath, we can use std::move(). This is more efficient because it means we’ll use move semantics if the type has implemented it, and fall back to the slower copy semantics if not.

Crucially, we then set Other.ImageSurface to nullptr so Other's destructor won't free the surface we just took.

1// ImageComponent.cpp
2#include <utility> // for std::move
3// ...
4
5// Move Constructor Implementation
6ImageComponent::ImageComponent(
7  ImageComponent&& Other) noexcept
8  : Component(Other.GetOwner()),
9    // Steal the resource pointer
10    ImageSurface(Other.ImageSurface),
11    // Move the file path string efficiently
12    ImageFilePath(std::move(
13      Other.ImageFilePath))
14{
15  // Important: Null out Other's pointer so its
16  // destructor doesn't free the surface we just took!
17  Other.ImageSurface = nullptr;
18}

The move assignment operator - operator=(ImageComponent&& Other) - is similar but handles assigning to an existing object. It must:

1. Check for self-assignment.
2. Release its own current resource using SDL_FreeSurface(ImageSurface) before taking the new one.
3. Steal the ImageSurface pointer
4. Move other members, with help from the base class movement operator and std::move() if needed
5. Set Other.ImageSurface to nullptr.
6. Return a reference to itself - *this.

1// ImageComponent.cpp
2// ...
3
4// Move Assignment Operator Implementation
5ImageComponent& ImageComponent::operator=(
6  ImageComponent&& Other) noexcept {
7  // 1. Check for self-assignment
8  if (this == &Other) {
9    return *this;
10  }
11
12  // 2. Release *our* current resource *before*
13  // taking Other's
14  SDL_FreeSurface(ImageSurface);
15  
16
17  // 3. Steal Other's resource pointer
18  ImageSurface = Other.ImageSurface;  
19
20  // 4. Move other members
21  Component::operator=(std::move(Other));
22  ImageFilePath = std::move(Other.ImageFilePath);
23
24  // 5. Null out Other's pointer
25  Other.ImageSurface = nullptr;  
26
27  // 6. Return reference to self
28  return *this;
29}

With move semantics implemented, operations that can take advantage of moving temporary or expiring objects will now be much more efficient for our ImageComponent, avoiding unnecessary file loading and memory management overhead.

Advanced: noexcept

Moving objects is an inherently destructive operation - we’re stealing resources from an existing object, leaving that object in a broken, dilapidated state. This state often called the moved-from state.

If our move process fails, we could have a problem. It could have damaged the original object, but not fully created the new object yet. In this context, "failing" means throwing an exception, which is one way that functions can signal that something went wrong. We cover exceptions in more detail here:

Exceptions: throw, try and catch

This lesson provides an introduction to exceptions, detailing the use of throw, try, and catch.

Move operations are often used by standard containers like std::vector when they resize. These containers sometimes need to guarantee that operations won't fail halfway through (strong exception guarantee). If a move operation could potentially throw an exception, the container might decide to use the slower (but safer) copy operation instead.

To signal that our move semantics are safe to use - that is, they cannot throw an exception - we can mark them as noexcept. This allows containers and algorithms to use the faster move path confidently.

We cover noexcept in a dedicated lesson in our advanced course:

std::terminate() and the noexcept specifier

This lesson explores the std::terminate() function and noexcept specifier, with particular focus on their interactions with move semantics.

Complete Code

Below, we’ve provided the Image.h and ImageComponent.cpp complete with all the changes we made in this lesson. We’ll continue working on these in the next lesson.

1// ImageComponent.h
2#pragma once
3#include <string>
4#include <SDL.h>
5#include "Component.h"
6
7class ImageComponent : public Component {
8 public:
9  using Component::Component;
10  ImageComponent(
11    Entity* Owner,
12    const std::string& FilePath
13  );
14
15  // Copy Semantics
16  ImageComponent(const ImageComponent& Other);
17  ImageComponent& operator=(
18    const ImageComponent& Other);
19
20  // Move Semantics
21  ImageComponent(
22    ImageComponent&& Other) noexcept;
23  ImageComponent& operator=(
24    ImageComponent&& Other) noexcept;
25
26  ~ImageComponent() override;
27
28  void Initialize() override;
29  void Render(SDL_Surface* Surface) override;
30
31private:
32  SDL_Surface* ImageSurface{nullptr};
33  std::string ImageFilePath;
34  void LoadSurfaceInternal();
35};

1#include "ImageComponent.h"
2#include "Entity.h"
3#include "SDL_image.h"
4
5ImageComponent::ImageComponent(
6  Entity* Owner,
7  const std::string& FilePath
8) : Component(Owner),
9    ImageFilePath(FilePath) {
10  ImageSurface = IMG_Load(FilePath.c_str());
11
12  if (!ImageSurface) {
13    std::cerr
14      << "Failed to load image: " << FilePath
15      << " Error: " << IMG_GetError() << '\n';
16  } else {
17    std::cout << "Loaded image: "
18      << FilePath << '\n';
19  }
20}
21
22ImageComponent::~ImageComponent() {
23  SDL_FreeSurface(ImageSurface);
24  ImageSurface = nullptr;
25}
26
27// Copy Constructor
28ImageComponent::ImageComponent(
29  const ImageComponent& Other)
30  : Component(Other.GetOwner()),
31    ImageFilePath(Other.ImageFilePath) {
32  LoadSurfaceInternal();
33}
34
35// Copy Assignment
36ImageComponent& ImageComponent::operator=(
37  const ImageComponent& Other
38) {
39  if (this == &Other) {return *this;}
40
41  Component::operator=(Other);
42  ImageFilePath = Other.ImageFilePath;
43  LoadSurfaceInternal();
44  return *this;
45}
46
47// Move Constructor
48ImageComponent::ImageComponent(
49  ImageComponent&& Other) noexcept
50  : Component(Other.GetOwner()),
51    ImageSurface(Other.ImageSurface),
52    ImageFilePath(std::move(
53      Other.ImageFilePath)) {
54  Other.ImageSurface = nullptr;
55}
56
57// Move Assignment
58ImageComponent& ImageComponent::operator=(
59  ImageComponent&& Other) noexcept {
60  if (this == &Other) { return *this; }
61  
62  Component::operator=(std::move(Other));
63  
64  SDL_FreeSurface(ImageSurface);
65  ImageSurface = Other.ImageSurface;
66  ImageFilePath = std::move(Other.ImageFilePath);
67  Other.ImageSurface = nullptr;
68  return *this;
69}
70
71void ImageComponent::Render(
72  SDL_Surface* Surface
73) {
74  if (!ImageSurface) return;
75
76  TransformComponent* Transform{
77    GetOwner()->GetTransformComponent()};
78
79  if (Transform) {
80    std::cout << "ImageComponent ("
81      << ImageFilePath
82      << ") ready to render at: "
83      << Transform->GetPosition() << '\n';
84  } else {
85    std::cout << "ImageComponent ("
86      << ImageFilePath
87      << ") ready, but no TransformComponent found\n";
88  }
89}
90
91void ImageComponent::Initialize() {
92  Entity* Owner{GetOwner()};
93  if (!Owner->GetTransformComponent()) {
94    std::cout <<
95      "Error: ImageComponent requires"
96      " TransformComponent on its Owner\n";
97
98    Owner->RemoveComponent(this);
99  }
100}
101
102void ImageComponent::LoadSurfaceInternal() {
103  if (ImageSurface) {
104    SDL_FreeSurface(ImageSurface);
105    ImageSurface = nullptr;
106  }
107
108  if (!ImageFilePath.empty()) {
109    ImageSurface = IMG_Load(
110      ImageFilePath.c_str());
111    if (!ImageSurface) {
112      std::cerr
113        << "Failed to load image: "
114        << ImageFilePath
115        << " Error: " << IMG_GetError() << '\n';
116    } else {
117      std::cout << "Loaded image: "
118        << ImageFilePath << '\n';
119    }
120  }
121}

We also made minor changes to the main.cpp, Scene.h, and Entity.h files. We’ve provided these files below, with the changes highlighted.

1#include <SDL.h>
2#include "SDL_image.h"
3#include "Window.h"
4#include "Scene.h"
5
6int main(int argc, char** argv) {
7  SDL_Init(SDL_INIT_VIDEO);
8
9  int IMG_FLAGS{IMG_INIT_PNG | IMG_INIT_JPG};
10  if (!(IMG_Init(IMG_FLAGS) & IMG_FLAGS)) {
11    std::cerr << "IMG_Init failed! "
12      << "IMG_Error: " << IMG_GetError() << '\n';
13  } else {
14    std::cout << "IMG_Init successful\n";
15  }
16
17  Window GameWindow;
18  Scene GameScene;
19
20  Uint64 LastTick{SDL_GetPerformanceCounter()};
21  SDL_Event Event;
22  while (true) {
23    while (SDL_PollEvent(&Event)) {
24      GameScene.HandleEvent(Event);
25      if (Event.type == SDL_QUIT) {
26        IMG_Quit();
27        SDL_Quit();
28        return 0;
29      }
30    }
31
32    Uint64 CurrentTick{SDL_GetPerformanceCounter()};
33    float DeltaTime{static_cast<float>(
34      CurrentTick - LastTick) /
35      SDL_GetPerformanceFrequency()
36    };
37    LastTick = CurrentTick;
38
39    // Tick
40    GameScene.Tick(DeltaTime);
41
42    // Render
43    GameWindow.Render();
44    GameScene.Render(GameWindow.GetSurface());
45
46    // Swap
47    GameWindow.Update();
48  }
49
50  return 0;
51}

1// Scene.h
2#pragma once
3#include <SDL.h>
4#include <vector>
5#include <string>
6#include "Entity.h"
7
8using EntityPtr = std::unique_ptr<Entity>;
9using EntityPtrs = std::vector<EntityPtr>;
10
11class Scene {
12 public:
13  Scene() {
14    EntityPtr& Player{Entities.emplace_back(
15      std::make_unique<Entity>())};
16
17    Player->AddTransformComponent();
18    Player->AddImageComponent("player.png");
19
20    EntityPtr& Enemy{Entities.emplace_back(
21      std::make_unique<Entity>())};
22
23    Enemy->AddTransformComponent();
24    Enemy->AddImageComponent("dragon.png");
25  }
26
27  void HandleEvent(SDL_Event& E) {
28    for (EntityPtr& Entity : Entities) {
29      Entity->HandleEvent(E);
30    }
31  }
32
33  void Tick(float DeltaTime) {
34    for (EntityPtr& Entity : Entities) {
35      Entity->Tick(DeltaTime);
36    }
37  }
38
39  void Render(SDL_Surface* Surface) {
40    for (EntityPtr& Entity : Entities) {
41      Entity->Render(Surface);
42    }
43  }
44
45 private:
46  EntityPtrs Entities;
47};

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

Summary

In this lesson, we brought our ImageComponent to life! We integrated the SDL_image library to load image files like PNGs and JPGs into SDL_Surface objects held by the component.

We tackled the crucial task of manual resource management for the raw SDL_Surface*, implementing a destructor to call SDL_FreeSurface() and carefully defining copy and move operations (following the Rule of Five) to ensure correct behavior and prevent memory errors like dangling pointers or double frees.

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

View Course