Asset Management

Our previous ImageComponent loads images but duplicates data and requires complex manual memory management. In this lesson, we'll refactor it using std::shared_ptr and an AssetManager to share image resources efficiently.

This will significantly reduce memory usage and simplifying our code by achieving the rule of zero. You'll learn:

• How std::shared_ptr manages shared resources.
• How to build a caching AssetManager for SDL_Surface data.
• How these techniques eliminate the need for custom copy/move/destructor code.
• How to dynamically change an entity's image.

Starting Point

In the previous lesson, we created the following ImageComponent class. We’ll continue working on it in this lesson.

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

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

Design Problems

The current version of our component is a good foundation - it has established all the basics and is managing it’s SDL_Surface effectively without risking memory issues. But, it has a couple of design problems.

The first is related to maintainability - this is a lot of code for a component that isn’t doing much yet. The second is a potential performance issue - when we have a lot of ImageComponent instances in our scene, that correponds to a lot of SDL_Surface objects being in memory, and many of them may be storing the exact same image.

We’ll fix both of these problems in this lesson.

Code Maintainability

The reason we wrote so much code was to implement the rule of five - the destructor, copy constructor, copy assignment operator, move constructor, and move assignment operator.

Aside from the large amount of code we have already written, this represents an ongoing maintenance issue. Every time we add a new member variable to our component, we need to update most of these functions and, if we forget, we have a bug.

We could make this easier - for example, they could all call some private helper function - but ideally, we’d like to create a situation where we don’t need any of these functions at all. This design is sometimes called the rule of zero, which we’ll implement in this section.

Memory Usage

Think about a game with lots of identical enemies, environment assets, or background tiles. Our current ImageComponent, with its deep copy behavior, creates a separate SDL_Surface in memory for every single component, even if they loaded the exact same file (like "tree.png").

If you have 100 trees in your scene, you're storing the tree pixel data 100 times. This can consume a lot of memory unnecessarily.

Implementing the Rule of Zero

Let’s address the code maintainability problem first. Our ImageComponent needs to manage a dynamically allocated resource (the SDL_Surface) to do its job. So, how can we delete the destructor, copy, and move semantics whilst ensuring this resource is still managed correctly?

The key principle that lets us achieve the rule of zero is that, when a dynamically allocated resource needs managed, we enlist the help of a type whose single responsibility is the managing of that resource.

This requires less work than we might thing, as the process of resource management is often easy to generalise into a reusable type. In fact, we’ve already been using such a type: std::unique_ptr.

When a type manages a resource through a std::unique_ptr, we rarely need to write any additional code to manage the memory of that resource. The unique_ptr takes care of that for us.

One restriction of std::unique_ptr is that it prevents our object from being copied. We’ll introduce std::shared_ptr in this lesson, which can be copied but, for scenarios where we don’t need to support copying, std::unique_ptr lets us go from this huge blob of code:

1class Component {
2public:
3  Component()
4  : Resource{new int{42}}
5  {}
6
7  ~Component() { delete Resource; }
8
9  // We don't support copying
10  Component(const Component& Other) = delete;
11  Component& operator=(const Component& Other)
12    = delete;
13
14  // Move Semantics
15  Component(Component&& Other) {
16    Resource = Other.Resource;
17    Other.Resource = nullptr;
18  }
19
20  Component& operator=(Component&& Other) {
21    if (&Other == this) return *this;
22    delete Resource;
23    Resource = Other.Resource;
24    Other.Resource = nullptr;
25  }
26
27private:
28  int* Resource{nullptr};
29};

To this, which behaves in substantitively the same way whilst being much easier to create and maintain:

1#include <memory>
2
3class Component {
4public:
5  Component()
6  : Resource{std::make_unique<int>(42)}
7  {}
8  
9private:
10  std::unique_ptr<int> Resource{nullptr};  
11};

Custom Deleters

There is some additional complexity involved if we wanted to let a std::unique_ptr manage a resource like an SDL_Surface: a std::unique_ptr doesn’t know how to delete an SDL_Surface.

Unless we intervene, smart pointers assume they can delete resources just by using the delete operator. That’s a sensible default, but it’s not always the case. For example, we shouldn’t delete an SDL_Surface. SDL is designed such that we need to pass its pointer to SDL_FreeSurface() instead.

To let a std::unique_ptr know how to delete a resource, we can provide it with an additional argument. This argument will be a function (or something that behaves like a function) that the smart pointer will call when it’s time to delete the resource. The function will be provided with the raw pointer to the resource, and it is responsible for deleting it.

Let’s see a minimalist example of this. We’ll provide our custom deleter as an object that overloads the () operator, thereby allowing it to be called like a function. Such an object is sometimes called a function object or a functor:

1#include <iostream>
2#include <memory>
3
4struct IntDeleter {
5  void operator()(int* Ptr) const {
6    std::cout << "Deleting that " << *Ptr;
7    delete Ptr;
8  }
9};
10
11class Component {
12  std::unique_ptr<int, IntDeleter> Resource{
13    new int{42}};
14};
15
16int main(int argc, char** argv) {
17  Component C;
18  return 0;
19}

1Deleting that 42

Let’s see an SDL_Surface example, where our deleter uses SDL_FreeSurface() rather than delete:

1#include <SDL.h>
2#include <iostream>
3#include <memory>
4
5struct SurfaceDeleter {
6  void operator()(SDL_Surface* Ptr) const {
7    std::cout << "Deleting that surface";
8    SDL_FreeSurface(Ptr);
9  }
10};
11
12using SDLSurfacePtr =
13  std::unique_ptr<SDL_Surface, SurfaceDeleter>;
14class Component {
15  SDLSurfacePtr Resource{new SDL_Surface{}};
16};
17
18int main(int argc, char** argv) {
19  Component C;
20  return 0;
21}

1Deleting that surface

This approach let’s the smart pointer maintain responsibility for when a resource is deleted, whilst we take responsibility for defining how it is deleted.

Note that the std::make_unique() function doesn’t allow us to define a custom deleter. If we need a custom deleter, we need to construct a std::unique_ptr directly.

If you want to learn more about functors, we have a dedicated lesson here:

Function Objects (Functors)

This lesson introduces function objects, or functors. This concept allows us to create objects that can be used as functions, including state management and parameter handling.

Shared Pointers

Letting our SDL_Surface be managed using a unique_ptr with a custom deleter would simplify our ImageComponent quite a lot, but it wouldn’t solve the memory usage problem.

A std::unique_ptr is inherently designed such that the object that holds the unique pointer (the ImageComponent) is the unique owner of the resource (the SDL_Surface).

To solve the memory usage problem, our image components need to be able to share surfaces. Predictably, we have the std::shared_ptr to manage ownership in these scenarios. Below, we’ll introduce the key characteristics of std::shared_ptr that we’ll need for our ImageComponent, but our advanced course has a full lesson if you want more detail:

Shared Pointers using std::shared_ptr

An introduction to shared memory ownership using std::shared_ptr

Shared pointers have two key differences:

• They can be copied, meaning multiple objects and/or functions can have a shared pointer to the same underlying resource. Conceptually, any object with a copy of the shared pointer is sharing ownership of the underlying resource.
• Behind the scenes, the std::shared_ptr keeps track of how many owners it has. It uses a technique called reference counting - a simple integer that is incremented every time a pointer is copied, and decremented very time a copy is destroyed. When the reference count reaches 0, that implies the resource has no owners remaining, and can safely be deleted.

Shared pointers include a use_count() function that lets us return the reference count - that is, how many owners the resource currently has.

Here’s an example that shows a shared pointer in action:

1#include <iostream>
2#include <memory>
3
4struct IntDeleter {
5  void operator()(int* Ptr) const {
6    std::cout << "Finally deleting that resource";
7    delete Ptr;
8  }
9};
10
11struct Component {
12  std::shared_ptr<int> Resource{
13    new int{42}, IntDeleter{}};
14};
15
16int main(int argc, char** argv) {
17  Component* C1{new Component{}};
18  std::cout << "Resource is shared by "
19    << C1->Resource.use_count() << " object\n";
20
21  // Create a copy
22  Component* C2{new Component{*C1}};
23  std::cout << "Resource is shared by "
24    << C1->Resource.use_count() << " objects\n";
25
26  // Delete a copy
27  delete C2;
28  std::cout << "Resource is shared by "
29    << C1->Resource.use_count() << " object\n";
30
31  // Delete the last copy
32  delete C1;
33
34  return 0;
35}

1Resource is shared by 1 object
2Resource is shared by 2 objects
3Resource is shared by 1 object
4Finally deleting that resource

1#include <iostream>
2#include <memory>
3
4int main(int argc, char** argv) {
5  std::shared_ptr<int> Resource{new int{42}};
6  std::cout << "Resource is shared by "
7    << Resource.use_count() << " object\n";
8
9  // Don't do this
10  std::shared_ptr<int> Resource2{Resource.get()};
11
12  std::cout << "Resource still thinks it is "
13    << "shared by only " << Resource.use_count()
14    << " object";
15
16  return 0;
17}

1Resource is shared by 1 object
2Resource still thinks it is shared by only 1 object

Creating an Asset Manager

Let’s apply these concepts to address the memory usage problem in our ImageComponent. We want to let image components that are showing the same image share the SDL_Surface data for that image.

To implement this, we need some central repository - an asset manager - where all of our components can retrieve the shared data from. We’ll create one for SDL_Surface data in this section, but the same technique can be applied to any data type.

Central to this mechanism is the idea of caching. Caching is useful in situations where two things are true:

• Our program needs access to some result that is expensive to generate, such as an SDL_Surface pointer loaded with data from an image file
• Our program needs that result multiple times, such as multiple ImageComponent instances needing that same SDL_Surface.

We can apply caching to this process by storing the result of each unique request. The first time a component requests the data for some image, the asset manager will construct an SDL_Surface containing that data, and will dutifully return it.

However, the asset manager will also cache (remember) that result so, if another component requests the surface for that exact same image, it doesn’t need to load it again. That result is already in our cache, so we can just retrieve it from there and return it.

If a caching system is able to return a result that is stored in its cache, that is called a cache hit. If it wasn’t in the cache and we had to perform the more expensive operation of generating a new result, that is called a cache miss.

An unordered map is one of the easiest ways we can implement a cache:

• The key of each entry will be something that let’s us uniquely identify the surface being requested. The source image’s file name is the natural choice here.
• The value of each entry will be a pointer to SDL_Surface associated with the image. Our goal is to let our ImageComponent instances share the surfaces, and we’d like to automate the memory management, so our values will be std::shared_ptr<SDL_Surface> instances

Let’s create an AssetManager class to manage our cache:

1// AssetManager.h
2#pragma once
3#include <SDL.h>
4#include <memory> // for std::shared_ptr
5#include <string>
6#include <unordered_map>
7
8// Custom deleter for an SDL_Surface
9struct SDLSurfaceDeleter {
10  void operator()(SDL_Surface* Surface) const {
11    SDL_FreeSurface(Surface);
12  }
13};
14
15using SurfacePtr = std::shared_ptr<SDL_Surface>;
16
17// Map file path to shared surface pointer
18using CacheMap =
19  std::unordered_map<std::string, SurfacePtr>;
20
21class AssetManager {
22private:
23  CacheMap SurfaceCache;
24};

When a component requests a surface from our asset manager, it will first check its cache to see if it has already loaded that surface. If it has, it will return it from the cache - no loading necessary:

1// AssetManager.h
2// ...
3
4#include <iostream> // for std::cout
5
6// ...
7
8class AssetManager {
9 public:
10  // Load a surface, reusing if already loaded
11  SurfacePtr LoadSurface(const std::string& Path) {
12    if (SurfaceCache.contains(Path)) {
13      // This surface was previously requested
14      // and is in the cache
15      std::cout << "CACHE HIT: " << Path << '\n';
16      return SurfaceCache[Path];
17    }
18    
19    // We haven't seen a request for this surface
20    // before.  We'll handle this next
21    // ...
22  }
23  
24  // ...
25};

If it is not in the cache, the asset manager will load the resource, store it in the cache in case another component requests the same resource in the future, and then return it:

1// AssetManager.h
2// ...
3
4#include <SDL_image.h> // for IMG_Load
5
6// ...
7
8class AssetManager {
9 public:
10  // Load a surface, reusing if already loaded
11  SurfacePtr LoadSurface(const std::string& Path) {
Cache Hit Logic (Unchanged)|Show
16
17    // Cache Miss - need to load a new surface
18    std::cout << "CACHE MISS: " << Path << '\n';
19    SDL_Surface* Surface{IMG_Load(Path.c_str())};
20    if (!Surface) {
21      std::cerr << "AssetManager failed to load: "
22                << Path << " Error: "
23                << IMG_GetError() << '\n';
24      return nullptr;  // Return null on failure
25    }
26
27    // Create shared_ptr with custom deleter
28    SurfacePtr SharedSurface(
29      Surface, SDLSurfaceDeleter{}
30    );
31
32    // Store in cache and return
33    SurfaceCache[Path] = SharedSurface;
34    return SharedSurface;
35  }
36
37  // ...
38};

Our asset managers don’t need to be movable or copyable, so let’s finish off our class by deleting those operations, and readding the default constructor:

1// AssetManager.h
2// ...
3
4class AssetManager {
5public:
6  AssetManager() = default;
7
8  // Prevent copying/moving
9  AssetManager(const AssetManager&) = delete;
10  AssetManager& operator=(const AssetManager&) = delete;
11  AssetManager(AssetManager&&) = delete;
12  AssetManager& operator=(AssetManager&&) = delete;
13  
14  // ...
15};

If you want to learn more about std::unordered_map, we have a dedicated lesson here:

Hash Maps using std::unordered_map

Creating hash maps using the standard library's std::unordered_map container

Using the AssetManager

Now that we can create asset managers, let’s add one for our scene and give our components access to it.

Constructing the Asset Manager

We’d like to create our asset manager in a single place, and ideally that place is somewhere it can be easily accessed by ImageComponent instances. In out design, the Scene seems like the natural choice, so let’s construct it there, and provide a getter.

We’ll also load some duplicate images so, once our ImageComponent has been updated to use our asset manager, we can see it working:

1// Scene.h
2// ...
3#include "AssetManager.h" 
4// ...
5
6class Scene {
7 public:
8  Scene() {
9    EntityPtr& Forest{Entities.emplace_back(
10      std::make_unique<Entity>())};
11
12    Forest->AddTransformComponent();
13    Forest->AddImageComponent("tree.png");
14    Forest->AddImageComponent("tree.png");
15    Forest->AddImageComponent("tree.png");
16    Forest->AddImageComponent("tree.png");
17    Forest->AddImageComponent("tree.png");
18  }
19
20  // Public access to the Asset Manager if
21  // needed elsewhere
22  AssetManager& GetAssetManager() {
23    return Assets;
24  }
25  
26  // ...
27  
28 private:
29  AssetManager Assets;
30  // ...
31};

Retrieving the Asset Manager from Components

Neither our entities nor our components currently have access to the Scene they’re part of. Let’s fix that.

We’ll update our Entity class to receive the Scene as a constructor argument, store it in a member variable, and provide access to it through a getter:

1// Entity.h
2// ...
3
4class Scene;
5
6class Entity {
7public:
8  Entity(Scene& Scene) : OwningScene{Scene} {}
9  Scene& GetScene() const { return OwningScene; }
10  // ...
11
12private:
13  Scene& OwningScene;
14  // ...
15};

Let’s provide this argument from our Scene:

1// Scene.h
2// ...
3
4class Scene {
5 public:
6  Scene() {
7    EntityPtr& Forest{Entities.emplace_back(
8      std::make_unique<Entity>(*this))};
9    // ...
10  }
11  
12  // ...
13};

Components can now access the scene and asset manager through a chain of getters:

1GetOwner()->GetScene().GetAssetManager()

We can make this easier for our components by providing some helpers in the Component base class:

1// Component.h
2// ...
3
4class Scene;
5class AssetManager;
6
7class Component {
8 public:
9  // ...
10  Scene& GetScene() const;
11  AssetManager& GetAssetManager() const;
12  // ...
13};

1// Component.cpp
2#include "Component.h"
3#include "Entity.h"
4#include "Scene.h"
5
6Scene& Component::GetScene() const {
7  return GetOwner()->GetScene();
8}
9
10AssetManager& Component::GetAssetManager() const {
11  return GetScene().GetAssetManager();
12}

Components can now retrieve the scene and asset manager through GetScene() and GetAssetManager() respectively.

Updating ImageComponent

Let’s update our ImageComponent to make use of our asset manager. Thankfully, this mostly involves deleting things, which is a good indicator that our code is becoming easier to maintain

The ImageComponent would then be modified in the following ways:

1. Instead of holding a raw SDL_Surface*, we hold a shared_ptr<SDL_Surface>. Any time we need the raw SDL_Surface* - such as for use with functions like SDL_BlitSurface() - we can retrieve it using the shared pointer’s get() method.
2. We’ll replace any calls to IMG_Load() with a call to our asset manager’s LoadSurface() function. We are currently calling IMG_Load() in the ImageComponent constructor.
3. Because shared_ptr handles all the ownership and cleanup logic correctly, the ImageComponent doesn’t need custom destructor, copy constructor, copy assignment, move constructor, or move assignment operators anymore. The default compiler-generated versions would work perfectly with the shared_ptr member (following the Rule of Zero).

Here are our changes:

1// ImageComponent.h
2#pragma once
3#include <memory> // for std::shared_ptr 
4#include <string>
5#include <SDL.h>
6#include "Component.h"
7
8class ImageComponent : public Component {
9 public:
10  using Component::Component;
11  ImageComponent(
12    Entity* Owner,
13    const std::string& FilePath
14  );
15
16  // No custom destructor, copy/move ops needed! 
17  ~ImageComponent() override; 
18  ImageComponent(const ImageComponent& Other); 
19  ImageComponent& operator=(const ImageComponent& Other); 
20  ImageComponent(ImageComponent&& Other) noexcept; 
21  ImageComponent& operator=(ImageComponent&& Other) noexcept; 
22
23  void Initialize() override;
24  void Render(SDL_Surface* Surface) override;
25
26private:
27  // ImageSurface has a new type
28  SDL_Surface* ImageSurface{nullptr};
29  std::shared_ptr<SDL_Surface> ImageSurface{nullptr};
30  std::string ImageFilePath;
31  
32  // We don't need this any more, either
33  void LoadSurfaceInternal();
34};

1// ImageComponent.cpp
2#include "ImageComponent.h"
3#include "Entity.h"
4#include "SDL_image.h" 
5#include "AssetManager.h" 
6
7ImageComponent::ImageComponent(
8  Entity* Owner,
9  const std::string& FilePath
10) : Component(Owner),
11    ImageFilePath(FilePath) {
12  ImageSurface = IMG_Load(FilePath.c_str()); 
13  ImageSurface = GetAssetManager()
14    .LoadSurface(ImageFilePath);
15}
16
17void ImageComponent::Render(
18  SDL_Surface* Surface
19) {
20  // ...
21  // The render function is unchanged for now, but
22  // in the future, we will need the SDL_Surface*
23  // raw pointer for interaction with SDL functions
24  // such as SDL_BlitSurface().  We can retrieve it
25  // from the shared_ptr using ImageSurface.get()
26}
27
Initialize Function (Unchanged)|Show
28void ImageComponent::Initialize() {/*...*/}
39
40// All other functions are deleted

Now, even though our Scene is showing five tree images, we only load and store the data from tree.png the first time it is requested. All subsequent requests receive a pointer to the data we already have in the cache:

1CACHE MISS: tree.png
2CACHE HIT: tree.png
3CACHE HIT: tree.png
4CACHE HIT: tree.png
5CACHE HIT: tree.png

Image Switching

What if we want our character to change its appearance during the game? Maybe it picks up a power-up, takes damage, or equips different armor. We need a way for an existing ImageComponent to switch to displaying a different image file.

Let's add a public method called LoadNewImage(). It will take the file path of the new image as an argument:

It's helpful if this method returns bool to indicate whether loading the new image was successful. First, let’s declare LoadNewImage() in ImageComponent.h.

1// ImageComponent.h
2// ...
3
4class ImageComponent : public Component {
5 public:
6  // ... 
7
8  bool LoadNewImage(const std::string& NewPath);  
9
10 // ...
11};

Inside, it should update the component's ImageFilePath, loading the new surface from the asset manager:

1// ImageComponent.cpp
2// ...
3
4bool ImageComponent::LoadNewImage(
5  const std::string& NewPath
6) {
7  // Store the new file path
8  ImageFilePath = NewPath;
9  
10  // Use our asset manager
11  ImageSurface = GetAssetManager()
12    .LoadSurface(NewPath);
13    
14  // Return true if the load was
15  // successful (surface is not null)
16  return ImageSurface != nullptr;
17}

Now, code elsewhere in our game can easily change an entity's image on the fly! For example, imagine some game logic:

1// Somewhere in your game (e.g., Player class)
2
3void Player::TakeDamage() {
4  // Assume Health is a member variable
5  Health -= 10;
6  if (Health < 50) {
7    // Load damaged state if health is low
8    // Assume Img is an ImageComponent
9    Img->LoadNewImage("player_damaged.png");
10  }
11}
12
13void Player::PickupPowerup() {
14  if (Img->LoadNewImage("player_powered_up.png")) {
15    std::cout << "Player image changed!\n";
16  } else {
17    std::cerr << "Failed to load powerup image!\n";
18    // Maybe revert to old image or handle error
19  }
20}

This gives us a lot more dynamic control over the visual representation of our entities without needing to destroy and recreate components.

Complete Code

Below, we’ve provided the complete AssetManager and ImageComponent classes we created in this lesson. We’ll continue working on these in the next lesson.

1#pragma once
2#include <memory>
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  void Initialize() override;
16  void Render(SDL_Surface* Surface) override;
17  bool LoadNewImage(const std::string& NewPath);
18
19private:
20  std::shared_ptr<SDL_Surface> ImageSurface{nullptr};
21  std::string ImageFilePath;
22};

1#include "ImageComponent.h"
2#include "Entity.h"
3#include "AssetManager.h"
4
5ImageComponent::ImageComponent(
6  Entity* Owner,
7  const std::string& FilePath
8) : Component(Owner),
9    ImageFilePath(FilePath
10) {
11  ImageSurface = GetAssetManager()
12    .LoadSurface(ImageFilePath);
13}
14
15void ImageComponent::Render(
16  SDL_Surface* Surface
17) {
18  if (!ImageSurface) return;
19
20  TransformComponent* Transform{
21    GetOwner()->GetTransformComponent()};
22
23  if (Transform) {
24    std::cout << "ImageComponent ("
25      << ImageFilePath
26      << ") ready to render at: "
27      << Transform->GetPosition() << '\n';
28  } else {
29    std::cout << "ImageComponent ("
30      << ImageFilePath
31      << ") ready, but no TransformComponent found\n";
32  }
33}
34
35bool ImageComponent::LoadNewImage(
36  const std::string& NewPath
37) {
38  ImageFilePath = NewPath;
39  ImageSurface = GetAssetManager()
40    .LoadSurface(NewPath);
41  return ImageSurface != nullptr;
42}
43
44void ImageComponent::Initialize() {
45  Entity* Owner{GetOwner()};
46  if (!Owner->GetTransformComponent()) {
47    std::cout <<
48      "Error: ImageComponent requires"
49      " TransformComponent on its Owner\n";
50
51    Owner->RemoveComponent(this);
52  }
53}

1#pragma once
2#include <SDL.h>
3#include <memory>
4#include <string>
5#include <unordered_map>
6#include <SDL_image.h>
7#include <iostream>
8
9struct SDLSurfaceDeleter {
10  void operator()(SDL_Surface* Surface) const {
11    SDL_FreeSurface(Surface);
12  }
13};
14
15using SurfacePtr = std::shared_ptr<SDL_Surface>;
16using CacheMap =
17  std::unordered_map<std::string, SurfacePtr>;
18
19class AssetManager {
20 public:
21  SurfacePtr LoadSurface(const std::string& Path) {
22    if (SurfaceCache.contains(Path)) {
23      std::cout << "CACHE HIT: " << Path << '\n';
24      return SurfaceCache[Path];
25    }
26
27    std::cout << "CACHE MISS: " << Path << '\n';
28    SDL_Surface* Surface{IMG_Load(Path.c_str())};
29    if (!Surface) {
30      std::cerr << "AssetManager failed to load: "
31                << Path << " Error: "
32                << IMG_GetError() << '\n';
33      return nullptr;  // Return null on failure
34    }
35
36    SurfacePtr SharedSurface(
37      Surface, SDLSurfaceDeleter{}
38    );
39
40    SurfaceCache[Path] = SharedSurface;
41    return SharedSurface;
42  }
43
44  // Prevent copying/moving
45  AssetManager() = default;
46  AssetManager(const AssetManager&) = delete;
47  AssetManager& operator=(const AssetManager&) = delete;
48  AssetManager(AssetManager&&) = delete;
49  AssetManager& operator=(AssetManager&&) = delete;
50
51 private:
52  CacheMap SurfaceCache;
53};

We also made smaller changes to our Scene, Entity, and Component classes. These are provided below, with our changes highlighted:

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

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

1#pragma once
2#include <SDL.h>
3
4class Entity;
5class Scene;
6class AssetManager;
7
8class Component {
9 public:
10  Component(Entity* Owner) : Owner(Owner) {}
11  virtual void Initialize() {}
12  virtual void HandleEvent(const SDL_Event& E) {}
13  virtual void Tick(float DeltaTime) {}
14  virtual void Render(SDL_Surface* Surface) {}
15  virtual ~Component() = default;
16
17  Entity* GetOwner() const { return Owner; }
18  Scene& GetScene() const;
19  AssetManager& GetAssetManager() const;
20
21private:
22  Entity* Owner{nullptr};
23};

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}

Summary

This lesson focused on optimizing the ImageComponent. We moved away from individual components managing their own unique SDL_Surface copies and the associated Rule of Five complexity. Instead, we implemented a shared resource model using std::shared_ptr and an AssetManager.

This central manager caches surfaces, ensuring that an image file is loaded only once, and components share pointers to this cached data, saving memory and simplifying the component's implementation to follow the Rule of Zero.

Key Takeaways:

• The Rule of Five becomes necessary when a class directly manages raw resources, increasing code complexity.
• Storing duplicate data (e.g., identical images) consumes unnecessary memory.
• std::shared_ptr enables shared ownership, deleting the resource only when the last owner is destroyed.
• SDL resources like SDL_Surface require custom cleanup - SDL_FreeSurface() - which can be handled by custom deleters in smart pointers.
• An asset manager acts as a central repository and cache for shared resources, typically using a map from an identifier (like a file path) to the resource pointer.
• By delegating resource management to smart pointers and manager classes, components can often avoid needing any custom destructor/copy/move logic (Rule of Zero).

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