Loading Saved Levels

Complete the save/load cycle by implementing level deserialization using SDL_RWops and actor factories.

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 a video game map editor

Level Editor: Part 8

Ryan McCombe

Posted 14 hours ago

We've learned how to save our level designs, translating the in-memory state of actors and grid settings into a binary file using SDL's file I/O capabilities. Now, we need the ability to bring those saved designs back to life in the editor.

This lesson focuses entirely on deserialization – the process of reading the binary data and reconstructing the original objects. We'll implement the Level::Load() function, carefully using SDL_ReadU8(), SDL_ReadLE32(), and other SDL_RWops functions to read data in the sequence it was saved.

A major focus will be the Factory Pattern. Since we only store a type identifier (like 1 for BlueBlock), we need a way to invoke the correct constructor. We'll achieve this by:

Adding static Construct() methods to actor subclasses.
Storing pointers to these methods (using std::function).
Using the type identifier read from the file to select and call the right factory function.

This ensures our loading logic is flexible and can handle different actor types correctly.

By the end of this lesson, we’ll have completed our level editor project!

Screenshot showing our completed level editor

Level Deserialization

With the serialization logic in place, we can now turn our attention to the reverse process: deserialization. The Level::Load() function is where we'll read the binary data from a .bin file and reconstruct the level state within the editor.

The first step mirrors saving: we need to open the file. We construct the filename using the LoadedLevel number and attempt to open it using SDL_RWFromFile(), this time with the mode "rb" for reading in binary.

If the file doesn't exist or cannot be opened, SDL_RWFromFile() returns nullptr, which we check for. Before reading any data, we also call Actors.clear() to remove any existing actors from the level currently loaded in the editor.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::Load() {
5  Actors.clear();
6  std::string FileName{std::format(
7    "Assets/Level{}.bin", LoadedLevel
8  )};
9  SDL_RWops* Handle{SDL_RWFromFile(
10    FileName.c_str(), "rb")};
11  if (!Handle) {
12    CheckSDLError("Loading Level");
13    return;
14  }
15
16  // TODO: Deserialize stuff
17
18  SDL_RWclose(Handle);
19}

Our deserializing code must closely align with our serialization code. We must deserialize our objects respecting the size, order, and endianness in which they were serialized.

Our serialized data has three Uint8 values representing the version, grid width and grid height in that order, followed by a little-endian Uint32 representing the number of actors in the level.

Let’s deserialize them in that order, and log out what we found:

1// Editor/Source/Level.cpp
2// ...
3
4void Level::Load() {
15  
16  Uint8 FileVersion{SDL_ReadU8(Handle)};
17  if (FileVersion != VERSION) {
18    // This file is from a different version of
19    // our software - react as needed
20  }
21  Uint8 GridWidth{SDL_ReadU8(Handle)};
22  Uint8 GridHeight{SDL_ReadU8(Handle)};
23  Uint32 ActorCount{SDL_ReadLE32(Handle)};
24
25  std::cout << std::format( "Loading a version "
26    "{} level ({}x{}) with {} actors\n",
27    FileVersion, GridWidth,
28    GridHeight, ActorCount
29  );
30
31  // TODO: Load Actors
32
33  SDL_RWclose(Handle);
34}

Currently, our loading code exists but isn't called automatically when the editor starts. To make the editor load Level 1 immediately on launch, we can call Load() directly from the Level class's constructor.

Since the LoadedLevel member defaults to 1, adding Load() inside the constructor body will trigger the loading sequence for "Assets/Level1.bin" as soon as the Level object is created within the Scene.

1// Editor/Level.h
2// ...
3
4namespace Editor {
5// ...
6
7class Level {
8 public:
9  Level(Scene& ParentScene)
10  : ParentScene{ParentScene} {
11    Load();
12  }
13  // ...
14};
15}

If a "Level1.bin" file exists from a previous save, its data should now be read and logged.

1Loading a version 1 level (13x6) with 2 actors

Actor Factories

To load our actors, let’s use some of the techniques we covered in our lesson on function pointers. Each specific Actor subtype that can exist in our serialized data will have a function that is responsible for deserializing that data, constructing the object based on that data, and returning a pointer to it.

The natural place to define these functions is alongside the types themselves, so we’ll add them as a static functions to our Actor subtypes, like BlueBlock and GreenBlock.

Let’s start with BlueBlock. To construct a BlueBlock, we need two things:

A reference to the parent Scene. Our Level ’s Load() function can pass this when it’s calling our factory function.
An SDL_Rect representing its position and size. The position (x, y) can be calculated from the grid row and grid column values in the serialized data. The size (w, h) is the same for all BlueBlock instances, and is currently stored as static WIDTH and HEIGHT values.

All of our block types will need to calculate this SDL_Rect, so let’s add a helper function to the Actor base class that they can all use:

1// Editor/Actor.h
2// ...
3
4namespace Editor {
5class Scene;
6class Actor {
7 public:
8  // ...
9  static SDL_Rect GeneratePositionRectangle(
10    SDL_RWops* Handle, int Width, int Height
11  ) {
12    using namespace Config::Editor;
13    Uint8 GridRow{SDL_ReadU8(Handle)};
14    Uint8 GridCol{SDL_ReadU8(Handle)};
15    SDL_Rect R{0, 0, Width, Height};
16    R.x = GridCol * HORIZONTAL_GRID_SNAP;
17    R.y = GridRow * VERTICAL_GRID_SNAP;
18    return R;
19  }
20  // ...
21};
22}

Back in BlueBlock, let’s add our static Construct() function:

1// Editor/Blocks.h
2// ...
3
4namespace Editor{
5class BlueBlock : public Actor {
6public:
7  // ...
8
9  static std::unique_ptr<Actor> Construct(
10    SDL_RWops* Handle,
11    Scene& ParentScene
12  ) {
13    return std::make_unique<BlueBlock>(
14      ParentScene,
15      GeneratePositionRectangle(
16        Handle, WIDTH, HEIGHT));
17  }
18};
19}

Deserializing Green Blocks

GreenBlock::Construct() will be similar - we’ll also just grab the contrived SomeNumber and SomeArray data from the file and apply it to the object we create:

1// Editor/Blocks.h
2// ...
3
4namespace Editor{
5// ...
6
7class GreenBlock : public Actor {
8public:
9  // ...
10
11  static std::unique_ptr<Actor> Construct(
12    SDL_RWops* Handle,
13    Scene& ParentScene
14  ) {
15    auto NewActor{std::make_unique<GreenBlock>(
16      ParentScene,
17      GeneratePositionRectangle(
18        Handle, WIDTH, HEIGHT))};
19
20    NewActor->SomeNumber = SDL_ReadLE16(Handle);
21
22    Uint32 ArraySize{SDL_ReadLE32(Handle)};
23    NewActor->SomeArray.resize(ArraySize);
24    for (int i{0}; i < ArraySize; ++i) {
25      NewActor->SomeArray[i] = SDL_ReadLE32(Handle);
26    }
27    return NewActor;
28  }
29};
30}

Using the Factories

Back in Level::Load(), let’s use these factories to recreate our full level. We’ll store our loaders as std::function wrappers. We only need them in our Level.cpp file, so let’s add them in an anonymous namespace in that file, above our Load() function:

1// Editor/Source/Level.cpp
2// ...
3#include <functional>
4// ...
5
6namespace{
7using namespace Config;
8using ActorLoaderFunc = std::function<
9  std::unique_ptr<Actor>(SDL_RWops*, Scene&)>;
10
11std::vector<ActorLoaderFunc> ActorLoaders{
12  {},                    // Index 0
13  BlueBlock::Construct,  // Index 1
14  GreenBlock::Construct, // Index 2
15};
16}
17// ...

The effect of putting ActorLoaders in an anonymous namespace is that it can now only be accessed from within this same source file, Level.cpp. This prevents us from polluting our global scope with symbols that are only relevant to one area of our program.

The indices of this ActorLoaders array corresponds to the numeric actor types in our serialized data. As a reminder, our ActorType enum is set up like this:

1enum class ActorType : Uint8 {
2  Actor = 0,
3  BlueBlock = 1,
4  GreenBlock = 2,
5};

So, we store the loader for BlueBlock at index 1, and GreenBlock at index 2. Our program doesn’t allow basic Actor instances to be added to the level, so we’ll never need to deserialize those. As such, we just store an empty std::functional at the base Actor index (0).

Design Improvements and Maps

When our design requires us to keep two values in sync, we should generally try to improve our approach. Inevitably we, or someone on our team, will make some change that breaks that link, thereby introducing a bug.

We’ll learn better techniques for implementing these patterns later, but one simple improvement is to use a std::unordered_map as an alternative to a std::vector. This lets make the mapping from ActorType values to their corresponding std::functional factory more explicit:

1// Editor/Source/Level.cpp
2// ...
3#include <unordered_map>
4
5// ... 
6namespace{
7using namespace Config;
8using ActorLoaderFunc = std::function<
9  std::unique_ptr<Actor>(SDL_RWops*, Scene&)>;
10
11using enum ActorType;
12std::unordered_map<
13  ActorType, ActorLoaderFunc
14> ActorLoaders{
15  {Actor, {}},
16  {BlueBlock, BlueBlock::Construct},
17  {GreenBlock, GreenBlock::Construct}
18};
19}
20
21// ...

Our Load() function can use this std::unordered_map in much the same way it uses a std::vector, using the [] operator to access the correct loader. The only difference is that it needs to cast the Uint8 representing the actor’s type back to the Config::ActorType enum value it originated from:

1Uint8 Type{SDL_ReadU8(Handle)};
2
3auto Loader{ActorLoaders[
4  // When ActorLoaders is a vector:
5  Type
6  
7  // When ActorLoaders is an unordered_map:
8  static_cast<ActorType>(Type)
9]};

We cover maps in more detail later in the course.

All that’s left to do is update our Load() function to loop ActorCount times, grab the type of each actor, call the corresponding std::functional to create it, and then add it to the level:

1// Editor/Source/Level.cpp
2// ...
3
4void Level::Load() {
29
30  for (size_t i{0}; i < ActorCount; ++i) {
31    Uint8 ActorType{SDL_ReadU8(Handle)};
32    auto Loader{ActorLoaders[ActorType]};
33    if (Loader) {
34      ActorPtr NewActor{Loader(Handle, ParentScene)};
35      NewActor->SetLocation(ActorLocation::Level);
36      AddToLevel(std::move(NewActor));
37    } else {
38      std::cout << "Error: No Loader for Actor "
39        "Type " << ActorType << '\n';
40    }
41  }
42
43  SDL_RWclose(Handle);
44}

With all our plumbing in place, we can just add new actors to our editor as needed. In the Complete Code section below, we’ve added RedBlock, OrangeBlock, and YellowBlock actors by following the exact same pattern.

Add our new types to the ActorType enum
Add new classes that inherit from Actor
Add our necessary functions - Construct(), Clone(), GetActorType(), and the constructor. This can be done manually of using our preprocessor macro if we created one
Add an instance of our new type to the ActorMenu.

With that, our program is now be complete! We can create levels which get saved in the Assets/ directory alongside our program executable. We can also load those levels later, and see them restored in our Editor for us to modify.

Complete Code

Complete versions of the files we changed in this lesson are provided below:

Config.h

1#pragma once
2#include <iostream>
3#include <SDL.h>
4#include <string>
5#include <vector>
6
7namespace UserEvents{
8#ifdef WITH_EDITOR
9inline Uint32 ACTOR_DRAG{SDL_RegisterEvents(1)};
10inline Uint32 LOAD_LEVEL{SDL_RegisterEvents(1)};
11inline Uint32 SAVE_LEVEL{SDL_RegisterEvents(1)};
12inline Uint32 SAVE_AND_PLAY_LEVEL{
13  SDL_RegisterEvents(1)};
14inline Uint32 LEVEL_EDIT{SDL_RegisterEvents(1)};
15#endif
16inline Uint32 LAUNCH_LEVEL{
17  SDL_RegisterEvents(1)};
18}
19
20namespace Config {
21enum class ActorType : Uint8 {
22  Actor = 0,
23  BlueBlock = 1,
24  GreenBlock = 2,
25  CyanBlock = 3,
26  OrangeBlock = 4,
27  RedBlock = 5,
28  YellowBlock = 6,
29};
30
31inline const std::vector BUTTON_COLORS{
32  SDL_Color{15, 15, 15, 255},  // Normal
33  SDL_Color{15, 155, 15, 255}, // Hover
34  SDL_Color{225, 15, 15, 255}, // Active
35  SDL_Color{60, 60, 60, 255}   // Disabled
36};
37
38inline constexpr SDL_Color FONT_COLOR{
39  255, 255, 255, 255};
40
41inline const std::string FONT{
42  "Assets/Rubik-SemiBold.ttf"};
43}
44
45#ifdef WITH_EDITOR
46namespace Config::Editor {
47inline const Uint8 VERSION{1};
48// Level
49inline const int HORIZONTAL_GRID_SNAP{50};
50inline const int VERTICAL_GRID_SNAP{25};
51inline const Uint8 GRID_WIDTH{13};
52inline const Uint8 GRID_HEIGHT{6};
53inline const int LEVEL_WIDTH{
54  HORIZONTAL_GRID_SNAP * GRID_WIDTH};
55inline const int LEVEL_HEIGHT{
56  VERTICAL_GRID_SNAP * GRID_HEIGHT};
57inline constexpr SDL_Color LEVEL_BACKGROUND{
58  50, 50, 50, 255};
59
60// ActorMenu
61inline const int ACTOR_MENU_WIDTH{70};
62inline const int ACTOR_MENU_POSITION_X{LEVEL_WIDTH};
63inline const SDL_Color ACTOR_MENU_BACKGROUND{
64  15, 15, 15, 255};
65inline const int PADDING{10};
66
67// Window
68inline const std::string WINDOW_TITLE{"Editor"};
69inline const int WINDOW_WIDTH{
70  LEVEL_WIDTH + ACTOR_MENU_WIDTH};
71inline const int WINDOW_HEIGHT{LEVEL_HEIGHT + 50};
72inline const SDL_Color WINDOW_BACKGROUND{
73  35, 35, 35, 255};
74}
75#endif
76
77inline void CheckSDLError(
78  const std::string& Msg) {
79#ifdef CHECK_ERRORS
80  const char* error = SDL_GetError();
81  if (*error != '\0') {
82    std::cerr << Msg << " Error: "
83      << error << '\n';
84    SDL_ClearError();
85  }
86#endif
87}

Editor/Actor.h

1#pragma once
2#include <SDL.h>
3#include "Image.h"
4
5enum class ActorLocation { Level, Menu };
6
7namespace Editor {
8class Scene;
9class Actor {
10 public:
11  Actor(
12    Scene& ParentScene,
13    const SDL_Rect& Rect,
14    Image& Image
15  ) : ParentScene{ParentScene},
16      Rect{Rect},
17      Art{Image}
18  {}
19
20  bool HasMouseFocus() const;
21  virtual bool HandleEvent(const SDL_Event& E);
22
23  void Tick(float DeltaTime) {}
24
25  void Render(SDL_Surface* Surface) {
26    if (isVisible) {
27      Art.Render(Surface, Rect);
28    }
29  }
30
31  const SDL_Rect& GetRect() const {
32    return Rect;
33  }
34
35  const SDL_Point& GetDragOffset() const {
36    return DragOffset;
37  }
38
39  const Image& GetArt() const {
40    return Art;
41  }
42
43  SDL_Point GetPosition() const {
44    return {Rect.x, Rect.y};
45  }
46
47  void SetPosition(int x, int y) {
48    Rect.x = x;
49    Rect.y = y;
50  }
51
52  virtual std::unique_ptr<Actor> Clone() const {
53    return std::make_unique<Actor>(*this);
54  }
55
56  ActorLocation GetLocation() const {
57    return Location;
58  }
59
60  void SetLocation(ActorLocation NewLocation) {
61    Location = NewLocation;
62  }
63
64  bool GetIsVisible() const {
65    return isVisible;
66  }
67
68  void SetIsVisible(bool NewVisibility) {
69    isVisible = NewVisibility;
70  }
71
72  virtual Config::ActorType GetActorType() const {
73    return Config::ActorType::Actor;
74  }
75
76  virtual void Serialize(SDL_RWops* Handle) const {
77    using namespace Config::Editor;
78    Uint8 ActorType{static_cast<Uint8>(GetActorType())};
79    SDL_WriteU8(Handle, ActorType);
80
81    Uint8 GridRow = Rect.y / VERTICAL_GRID_SNAP;
82    SDL_WriteU8(Handle, GridRow);
83
84    Uint8 GridCol = Rect.x / HORIZONTAL_GRID_SNAP;
85    SDL_WriteU8(Handle, GridCol);
86  }
87
88  static SDL_Rect GeneratePositionRectangle(
89    SDL_RWops* Handle, int Width, int Height
90  ) {
91    using namespace Config::Editor;
92    Uint8 GridRow{SDL_ReadU8(Handle)};
93    Uint8 GridCol{SDL_ReadU8(Handle)};
94    SDL_Rect R{0, 0, Width, Height};
95    R.x = GridCol * HORIZONTAL_GRID_SNAP;
96    R.y = GridRow * VERTICAL_GRID_SNAP;
97    return R;
98  }
99
100protected:
101  Scene& ParentScene;
102  SDL_Rect Rect;
103  Image& Art;
104  SDL_Point DragOffset{0, 0};
105  ActorLocation Location{ActorLocation::Menu};
106  bool isVisible{true};
107};
108}

Editor/ActorMenu.h

1#pragma once
2#include <SDL.h>
3#include <vector>
4#include <memory>
5#include "Actor.h"
6#include "Blocks.h"
7#include "Config.h"
8
9namespace Editor {
10class Scene;
11using ActorPtr = std::unique_ptr<Actor>;
12using ActorPtrs = std::vector<ActorPtr>;
13
14class ActorMenu {
15 public:
16  ActorMenu(Scene& ParentScene)
17  : ParentScene{ParentScene}
18  {
19    using namespace Config::Editor;
20    Actors.emplace_back(
21      std::make_unique<BlueBlock>(
22        GetScene(),
23        SDL_Rect{
24          ACTOR_MENU_POSITION_X + PADDING,
25          PADDING,
26          0, 0
27        }
28      )
29    );
30
31    Actors.emplace_back(
32      std::make_unique<GreenBlock>(
33        GetScene(),
34        SDL_Rect{
35          ACTOR_MENU_POSITION_X + PADDING,
36          BlueBlock::HEIGHT + PADDING * 2,
37          0, 0
38        }
39      )
40    );
41
42    Actors.emplace_back(
43      std::make_unique<RedBlock>(
44        GetScene(),
45        SDL_Rect{
46          ACTOR_MENU_POSITION_X + PADDING,
47          BlueBlock::HEIGHT * 2 + PADDING * 3,
48          0, 0
49        }
50      )
51    );
52
53    Actors.emplace_back(
54      std::make_unique<OrangeBlock>(
55        GetScene(),
56        SDL_Rect{
57          ACTOR_MENU_POSITION_X + PADDING,
58          BlueBlock::HEIGHT * 3 + PADDING * 4,
59          0, 0
60        }
61      )
62    );
63
64    Actors.emplace_back(
65      std::make_unique<YellowBlock>(
66        GetScene(),
67        SDL_Rect{
68          ACTOR_MENU_POSITION_X + PADDING,
69          BlueBlock::HEIGHT * 4 + PADDING * 5,
70          0, 0
71        }
72      )
73    );
74  }
75
76  void HandleEvent(const SDL_Event& E) {
77    for (ActorPtr& A : Actors) {
78      A->HandleEvent(E);
79    }
80  }
81
82  void Tick(float DeltaTime) {
83    for (ActorPtr& A : Actors) {
84      A->Tick(DeltaTime);
85    }
86  }
87
88  void Render(SDL_Surface* Surface) {
89    using namespace Config::Editor;
90    auto [r, g, b, a]{ACTOR_MENU_BACKGROUND};
91
92    SDL_FillRect(
93      Surface,
94      &Rect,
95      SDL_MapRGB(Surface->format, r, g, b)
96    );
97
98    for (ActorPtr& A : Actors) {
99      A->Render(Surface);
100    }
101  }
102
103  Scene& GetScene() const {
104    return ParentScene;
105  }
106
107 private:
108  Scene& ParentScene;
109  ActorPtrs Actors;
110  SDL_Rect Rect{
111    Config::Editor::ACTOR_MENU_POSITION_X, 0,
112    Config::Editor::ACTOR_MENU_WIDTH,
113    Config::Editor::WINDOW_HEIGHT
114  };
115};
116}

Editor/Blocks.h

1#pragma once
2#include "Actor.h"
3
4namespace Editor{
5class BlueBlock : public Actor {
6public:
7  static constexpr int WIDTH{50};
8  static constexpr int HEIGHT{25};
9
10  BlueBlock(
11    Scene& ParentScene, SDL_Rect Rect
12  );
13
14  std::unique_ptr<Actor> Clone() const override {
15    return std::make_unique<BlueBlock>(*this);
16  }
17
18  Config::ActorType GetActorType() const override {
19    return Config::ActorType::BlueBlock;
20  }
21
22  static std::unique_ptr<Actor> Construct(
23    SDL_RWops* Handle,
24    Scene& ParentScene
25  ) {
26    return std::make_unique<BlueBlock>(
27      ParentScene,
28      GeneratePositionRectangle(
29        Handle, WIDTH, HEIGHT));
30  }
31};
32
33class GreenBlock : public Actor {
34public:
35  static constexpr int WIDTH{50};
36  static constexpr int HEIGHT{25};
37
38  GreenBlock(Scene& ParentScene,
39             SDL_Rect Rect);
40
41  Config::ActorType GetActorType() const override {
42    return Config::ActorType::GreenBlock;
43  }
44
45  std::unique_ptr<Actor> Clone() const override {
46    return std::make_unique<
47      GreenBlock>(*this);
48  }
49
50  Sint16 SomeNumber{32};
51  std::vector<Sint32> SomeArray{1, 2, 3};
52
53  void Serialize(SDL_RWops* Handle) const override {
54    Actor::Serialize(Handle);
55    SDL_WriteLE16(Handle, SomeNumber);
56    SDL_WriteLE32(Handle, SomeArray.size());
57    for (Sint32 Num : SomeArray) {
58      SDL_WriteLE32(Handle, Num);
59    }
60  }
61
62  static std::unique_ptr<Actor> Construct(
63    SDL_RWops* Handle,
64    Scene& ParentScene
65  ) {
66    auto NewActor{std::make_unique<GreenBlock>(
67      ParentScene,
68      GeneratePositionRectangle(
69        Handle, WIDTH, HEIGHT))};
70
71    NewActor->SomeNumber = SDL_ReadLE16(Handle);
72
73    Uint32 ArraySize{SDL_ReadLE32(Handle)};
74    NewActor->SomeArray.resize(ArraySize);
75    for (int i{0}; i < ArraySize; ++i) {
76      NewActor->SomeArray[i] = SDL_ReadLE32(Handle);
77    }
78    return NewActor;
79  }
80};
81
82  class CyanBlock : public Actor {
83public:
84  static constexpr int WIDTH{50};
85  static constexpr int HEIGHT{25};
86
87  CyanBlock(Scene& ParentScene,
88             SDL_Rect Rect);
89
90  Config::ActorType
91    GetActorType() const override {
92    return Config::ActorType::CyanBlock;
93  }
94
95  std::unique_ptr<Actor>
96    Clone() const override {
97    return std::make_unique<
98      CyanBlock>(*this);
99  }
100
101  void Serialize(
102    SDL_RWops* Handle) const override {
103    Actor::Serialize(Handle);
104  }
105
106  static std::unique_ptr<Actor> Construct(
107    SDL_RWops* Handle,
108    Scene& ParentScene
109  ) {
110    using namespace Config::Editor;
111    return std::make_unique<CyanBlock>(
112      ParentScene,
113      GeneratePositionRectangle(
114        Handle, WIDTH, HEIGHT));
115  }
116};
117
118class OrangeBlock : public Actor {
119public:
120  static constexpr int WIDTH{50};
121  static constexpr int HEIGHT{25};
122
123  OrangeBlock(Scene& ParentScene,
124             SDL_Rect Rect);
125
126  Config::ActorType
127    GetActorType() const override {
128    return Config::ActorType::OrangeBlock;
129  }
130
131  std::unique_ptr<Actor>
132    Clone() const override {
133    return std::make_unique<
134      OrangeBlock>(*this);
135  }
136
137  void Serialize(
138    SDL_RWops* Handle) const override {
139    Actor::Serialize(Handle);
140  }
141
142  static std::unique_ptr<Actor> Construct(
143    SDL_RWops* Handle,
144    Scene& ParentScene
145  ) {
146    using namespace Config::Editor;
147    return std::make_unique<OrangeBlock>(
148      ParentScene,
149      GeneratePositionRectangle(
150        Handle, WIDTH, HEIGHT));
151  }
152};
153
154class RedBlock : public Actor {
155public:
156  static constexpr int WIDTH{50};
157  static constexpr int HEIGHT{25};
158
159  RedBlock(Scene& ParentScene,
160             SDL_Rect Rect);
161
162  Config::ActorType
163    GetActorType() const override {
164    return Config::ActorType::RedBlock;
165  }
166
167  std::unique_ptr<Actor>
168    Clone() const override {
169    return std::make_unique<
170      RedBlock>(*this);
171  }
172
173  void Serialize(
174    SDL_RWops* Handle) const override {
175    Actor::Serialize(Handle);
176  }
177
178  static std::unique_ptr<Actor> Construct(
179    SDL_RWops* Handle,
180    Scene& ParentScene
181  ) {
182    using namespace Config::Editor;
183    return std::make_unique<RedBlock>(
184      ParentScene,
185      GeneratePositionRectangle(
186        Handle, WIDTH, HEIGHT));
187  }
188};
189
190class YellowBlock : public Actor {
191public:
192  static constexpr int WIDTH{50};
193  static constexpr int HEIGHT{25};
194
195  YellowBlock(Scene& ParentScene,
196             SDL_Rect Rect);
197
198  Config::ActorType
199    GetActorType() const override {
200    return Config::ActorType::YellowBlock;
201  }
202
203  std::unique_ptr<Actor>
204    Clone() const override {
205    return std::make_unique<YellowBlock>(*this);
206  }
207
208  void Serialize(
209    SDL_RWops* Handle) const override {
210    Actor::Serialize(Handle);
211  }
212
213  static std::unique_ptr<Actor> Construct(
214    SDL_RWops* Handle,
215    Scene& ParentScene
216  ) {
217    using namespace Config::Editor;
218    return std::make_unique<YellowBlock>(
219      ParentScene,
220      GeneratePositionRectangle(
221        Handle, WIDTH, HEIGHT));
222  }
223};
224}

Editor/Source/Blocks.cpp

1#include "Editor/Blocks.h"
2#include "Editor/Scene.h"
3
4using namespace Editor;
5
6BlueBlock::BlueBlock(
7  Scene& ParentScene, SDL_Rect Rect)
8  : Actor{
9    ParentScene,
10    SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT},
11    ParentScene.GetAssets().BlueBlock} {}
12
13GreenBlock::GreenBlock(
14  Scene& ParentScene, SDL_Rect Rect)
15  : Actor{
16    ParentScene,
17    SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT},
18    ParentScene.GetAssets().GreenBlock} {}
19
20CyanBlock::CyanBlock(
21  Scene& ParentScene, SDL_Rect Rect)
22  : Actor{
23    ParentScene,
24    SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT},
25    ParentScene.GetAssets().CyanBlock} {}
26
27OrangeBlock::OrangeBlock(
28  Scene& ParentScene, SDL_Rect Rect)
29  : Actor{
30    ParentScene,
31    SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT},
32    ParentScene.GetAssets().OrangeBlock} {}
33
34RedBlock::RedBlock(
35  Scene& ParentScene, SDL_Rect Rect)
36  : Actor{
37    ParentScene,
38    SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT},
39    ParentScene.GetAssets().RedBlock} {}
40
41YellowBlock::YellowBlock(
42  Scene& ParentScene, SDL_Rect Rect)
43  : Actor{
44    ParentScene,
45    SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT},
46    ParentScene.GetAssets().YellowBlock} {}

Editor/Level.h

1#pragma once
2#include <SDL.h>
3#include <memory>
4#include <vector>
5#include "Actor.h"
6
7namespace Editor {
8class Scene;
9using ActorPtr = std::unique_ptr<Actor>;
10using ActorPtrs = std::vector<ActorPtr>;
11
12class Level {
13 public:
14  Level(Scene& ParentScene)
15  : ParentScene{ParentScene} {
16    Load();
17  }
18
19  void HandleEvent(const SDL_Event& E);
20  void HandleDrop(Actor* DragActor);
21  void Tick(float DeltaTime);
22  void Render(SDL_Surface* Surface);
23  bool HasMouseFocus() const;
24  void AddToLevel(ActorPtr NewActor);
25  SDL_Point SnapToGridPosition(int x, int y);
26  void DeleteAtPosition(
27    int x, int y, const Actor* Unless);
28  void Load();
29  void Save();
30  void SaveAndPlay();
31
32 private:
33  Scene& ParentScene;
34  ActorPtrs Actors;
35  Actor* SelectedActor{nullptr};
36  int LoadedLevel{1};
37
38  SDL_Rect Rect{
39    0, 0,
40    Config::Editor::LEVEL_WIDTH,
41    Config::Editor::LEVEL_HEIGHT
42  };
43};
44}

Editor/Source/Level.cpp

1// Editor/Source/Level.cpp
2// ...
3
4#include <ranges>
5#include <format>
6#include "Editor/Level.h"
7
8#include <functional>
9
10#include "Editor/Scene.h"
11
12using namespace Editor;
13
14void Level::HandleEvent(const SDL_Event& E) {
15  using namespace std::views;
16  using namespace UserEvents;
17  for (ActorPtr& A : reverse(Actors)) {
18    if (A->HandleEvent(E)) {
19      break;
20    }
21  }
22
23  if (
24    E.type == SDL_MOUSEBUTTONDOWN &&
25    E.button.button == SDL_BUTTON_LEFT
26  ) {
27    SelectedActor = nullptr;
28  } else if (
29    E.type == SDL_KEYDOWN &&
30    E.key.keysym.sym == SDLK_DELETE &&
31    SelectedActor
32  ) {
33    std::erase_if(Actors,
34      [&](ActorPtr& Actor){
35        return Actor.get() == SelectedActor;
36      }
37    );
38
39    SelectedActor = nullptr;
40  } else if (E.type == LOAD_LEVEL) {
41    LoadedLevel = E.user.code;
42    Load();
43  } else if (E.type == SAVE_LEVEL) {
44    Save();
45  } else if (E.type == SAVE_AND_PLAY_LEVEL) {
46    SaveAndPlay();
47  }
48}
49
50void Level::Tick(float DeltaTime) {
51  for (ActorPtr& A : Actors) {
52    A->Tick(DeltaTime);
53  }
54}
55
56void Level::Render(SDL_Surface* Surface) {
57  auto [r, g, b, a]{
58    Config::Editor::LEVEL_BACKGROUND
59  };
60
61  SDL_FillRect(Surface, &Rect, SDL_MapRGB(
62    Surface->format, r, g, b));
63
64  for (ActorPtr& A : Actors) {
65    if (SelectedActor &&
66      A.get() == SelectedActor &&
67      SelectedActor->GetIsVisible()
68    ) {
69      auto [x, y, w, h]{
70        SelectedActor->GetRect()
71      };
72      SDL_Rect Rect{x - 1, y - 1, w + 2, h + 2};
73      SDL_FillRect(Surface, &Rect, SDL_MapRGB(
74        Surface->format, 255, 255, 255)
75      );
76    }
77    A->Render(Surface);
78  }
79}
80
81void Level::HandleDrop(Actor* DragActor) {
82  DragActor->SetIsVisible(true);
83  if (!HasMouseFocus()) {
84    return;
85  }
86
87  int MouseX, MouseY;
88  SDL_GetMouseState(&MouseX, &MouseY);
89  auto [GridX, GridY]{
90    SnapToGridPosition(
91      MouseX,
92      MouseY
93    )
94  };
95  DeleteAtPosition(GridX, GridY, DragActor);
96
97  using enum ActorLocation;
98  if (DragActor->GetLocation() == Menu) {
99    ActorPtr NewActor{DragActor->Clone()};
100    NewActor->SetPosition(GridX, GridY);
101    SelectedActor = NewActor.get();
102    AddToLevel(std::move(NewActor));
103  } else {
104    DragActor->SetPosition(GridX, GridY);
105    SelectedActor = DragActor;
106  }
107  SDL_Event E{UserEvents::LEVEL_EDIT};
108  SDL_PushEvent(&E);
109}
110
111void Level::AddToLevel(ActorPtr NewActor) {
112  NewActor->SetLocation(ActorLocation::Level);
113  Actors.push_back(std::move(NewActor));
114}
115
116bool Level::HasMouseFocus() const {
117  if (!ParentScene.HasMouseFocus()) {
118    return false;
119  }
120  int x, y;
121  SDL_GetGlobalMouseState(&x, &y);
122  auto [WinX, WinY]{
123    ParentScene.GetWindow().GetPosition()
124  };
125
126  if (
127    x >= WinX + Config::Editor::LEVEL_WIDTH ||
128    y >= WinY + Config::Editor::LEVEL_HEIGHT
129  ) {
130    return false;
131  }
132  return true;
133}
134
135SDL_Point Level::SnapToGridPosition(
136  int x, int y
137) {
138  using namespace Config::Editor;
139  int sx{HORIZONTAL_GRID_SNAP};
140  int sy{VERTICAL_GRID_SNAP};
141  return {
142    (x / sx) * sx,
143    (y / sy) * sy,
144  };
145}
146
147void Level::DeleteAtPosition(
148  int x, int y, const Actor* Unless
149) {
150  std::erase_if(Actors,
151    [&](const ActorPtr& Actor){
152      auto [ax, ay]{Actor->GetPosition()};
153      return
154        ax == x &&
155        ay == y &&
156        Actor.get() != Unless;
157     }
158  );
159}
160
161namespace{
162using namespace Config;
163using ActorLoaderFunc = std::function<
164  std::unique_ptr<Actor>(SDL_RWops*, Scene&)>;
165
166std::vector<ActorLoaderFunc> ActorLoaders{
167  {},
168  BlueBlock::Construct,
169  GreenBlock::Construct,
170  CyanBlock::Construct,
171  OrangeBlock::Construct,
172  RedBlock::Construct,
173  YellowBlock::Construct,
174};
175}
176
177void Level::Load() {
178  Actors.clear();
179  std::string FileName{std::format(
180    "Assets/Level{}.bin", LoadedLevel
181  )};
182  SDL_RWops* Handle{SDL_RWFromFile(
183    FileName.c_str(), "rb")};
184  if (!Handle) {
185    CheckSDLError("Loading Level");
186    return;
187  }
188  Uint8 FileVersion{SDL_ReadU8(Handle)};
189  if (FileVersion != VERSION) {
190    // This file is from a different version of
191    // our software - react as needed
192  }
193  Uint8 GridWidth{SDL_ReadU8(Handle)};
194  Uint8 GridHeight{SDL_ReadU8(Handle)};
195  Uint32 ActorCount{SDL_ReadLE32(Handle)};
196
197  std::cout << std::format( "Loading a version "
198    "{} level ({}x{}) with {} actors\n",
199    FileVersion, GridWidth,
200    GridHeight, ActorCount
201  );
202
203  for (size_t i{0}; i < ActorCount; ++i) {
204    Uint8 ActorType{SDL_ReadU8(Handle)};
205    auto Loader{ActorLoaders[ActorType]};
206    if (Loader) {
207      ActorPtr NewActor{Loader(Handle, ParentScene)};
208      NewActor->SetLocation(ActorLocation::Level);
209      AddToLevel(std::move(NewActor));
210    } else {
211      std::cout << "Error: No Loader for Actor "
212        "Type " << ActorType << '\n';
213    }
214  }
215
216  SDL_RWclose(Handle);
217}
218
219void Level::Save() {
220  std::string FileName{
221    std::format("Assets/Level{}.bin", LoadedLevel)
222  };
223  SDL_RWops* Handle{SDL_RWFromFile(
224    FileName.c_str(), "wb")
225  };
226  if (!Handle) {
227    CheckSDLError("Saving Level");
228    Handle = SDL_RWFromFile(
229      FileName.c_str(), "w+b"
230    );
231  }
232
233  using namespace Config::Editor;
234  SDL_WriteU8(Handle, VERSION);
235  SDL_WriteU8(Handle, GRID_WIDTH);
236  SDL_WriteU8(Handle, GRID_HEIGHT);
237
238  SDL_WriteLE32(Handle, Actors.size());
239  for (const ActorPtr& A : Actors) {
240    A->Serialize(Handle);
241  }
242
243  SDL_RWclose(Handle);
244}
245
246void Level::SaveAndPlay() {
247  Save();
248  SDL_Event E{UserEvents::LAUNCH_LEVEL};
249  E.user.code = LoadedLevel;
250  SDL_PushEvent(&E);
251}

The remaining project files, which were not changed in this lesson, are available below:

Editor/Source/Actor.cpp

1#include "Editor/Actor.h"
2#include "Editor/Scene.h"
3
4using namespace Editor;
5
6bool Actor::HandleEvent(const SDL_Event& E) {
7  if (
8    E.type == SDL_MOUSEBUTTONDOWN &&
9    E.button.button == SDL_BUTTON_LEFT &&
10    HasMouseFocus()
11  ) {
12    DragOffset.x = E.button.x - Rect.x;
13    DragOffset.y = E.button.y - Rect.y;
14
15    if (Location != ActorLocation::Menu) {
16      SetIsVisible(false);
17    }
18
19    SDL_Event DragEvent{UserEvents::ACTOR_DRAG};
20    DragEvent.user.data1 = this;
21    SDL_PushEvent(&DragEvent);
22    return true;
23  }
24  return false;
25}
26
27bool Actor::HasMouseFocus() const {
28  if (!ParentScene.HasMouseFocus()) {
29    return false;
30  }
31
32  int x, y;
33  SDL_GetMouseState(&x, &y);
34
35  if (
36    x < Rect.x ||
37    x > Rect.x + Rect.w ||
38    y < Rect.y ||
39    y > Rect.y + Rect.h
40  ) { return false; }
41
42  return true;
43}

Editor/Source/ActorTooltip.cpp

1#include "Editor/ActorTooltip.h"
2#include "Editor/Scene.h"
3
4using namespace Editor;
5
6ActorTooltip::ActorTooltip(Scene& ParentScene)
7  : ParentScene{ParentScene} {
8  SDLWindow = SDL_CreateWindow(
9    "Tooltip",
10    SDL_WINDOWPOS_UNDEFINED,
11    SDL_WINDOWPOS_UNDEFINED,
12    100,
13    100,
14    SDL_WINDOW_HIDDEN
15    | SDL_WINDOW_TOOLTIP
16    | SDL_WINDOW_BORDERLESS
17    | SDL_WINDOW_SKIP_TASKBAR
18    | SDL_WINDOW_ALWAYS_ON_TOP
19  );
20  CheckSDLError("Creating Tooltip Window");
21
22  DenyCursor = SDL_CreateSystemCursor(
23    SDL_SYSTEM_CURSOR_NO
24  );
25  CheckSDLError("Creating DenyCursor");
26}
27
28ActorTooltip::~ActorTooltip() {
29  if (!SDL_WasInit(SDL_INIT_VIDEO)) return;
30  if (SDLWindow) {
31    SDL_DestroyWindow(SDLWindow);
32  }
33  if (DenyCursor) {
34    SDL_FreeCursor(DenyCursor);
35  }
36}
37
38void ActorTooltip::Render() {
39  if (!isVisible) return;
40  DragActor->GetArt().Render(
41    GetSurface(),
42    SDL_Rect{
43      0, 0,
44      DragActor->GetRect().w,
45      DragActor->GetRect().h
46    });
47
48  SDL_UpdateWindowSurface(SDLWindow);
49}
50
51void ActorTooltip::Tick(float DeltaTime) {
52  if (!isVisible) return;
53
54  auto Buttons{
55    SDL_GetGlobalMouseState(
56      nullptr, nullptr)};
57  if (!(Buttons & SDL_BUTTON_LEFT)) {
58    SetIsVisible(false);
59    ParentScene.GetLevel().HandleDrop(DragActor);
60  } else {
61    PositionWindow();
62  }
63}
64
65void ActorTooltip::PositionWindow() {
66  int x, y;
67  SDL_GetGlobalMouseState(&x, &y);
68
69  if (ParentScene.GetLevel().HasMouseFocus()) {
70    SDL_SetWindowOpacity(SDLWindow, 1);
71    SDL_SetCursor(SDL_GetDefaultCursor());
72    auto [WinX, WinY]{
73      ParentScene.GetWindow().GetPosition()
74    };
75
76    auto [GridX, GridY]{
77      ParentScene.GetLevel().SnapToGridPosition(
78        x - WinX, y - WinY
79      )
80    };
81
82    SDL_SetWindowPosition(
83      SDLWindow, WinX + GridX, WinY + GridY
84    );
85  } else {
86    auto [DragOffsetX, DragOffsetY]{
87      DragActor->GetDragOffset()
88    };
89
90    SDL_SetWindowPosition(
91      SDLWindow, x - DragOffsetX, y - DragOffsetY
92    );
93    SDL_SetWindowOpacity(SDLWindow, 0.5);
94    SDL_SetCursor(DenyCursor);
95  }
96}
97
98void ActorTooltip::HandleEvent(
99  const SDL_Event& E) {
100  using namespace UserEvents;
101  if (E.type == ACTOR_DRAG) {
102    DragActor = static_cast<Actor*>(
103      E.user.data1
104    );
105    SDL_SetWindowSize(
106      SDLWindow,
107      DragActor->GetRect().w,
108      DragActor->GetRect().h
109    );
110    SetIsVisible(true);
111  }
112}
113
114void ActorTooltip::SetIsVisible(bool Visible) {
115  isVisible = Visible;
116  if (isVisible) {
117    SDL_ShowWindow(SDLWindow);
118  } else {
119    SDL_HideWindow(SDLWindow);
120    SDL_SetCursor(SDL_GetDefaultCursor());
121    SDL_SetWindowOpacity(SDLWindow, 1);
122  }
123}

Editor/Source/Button.cpp

1#include "Editor/Button.h"
2#include "Editor/Scene.h"
3
4using namespace Editor;
5
6void Button::HandleEvent(const SDL_Event& E) {
7  using enum ButtonState;
8  if (E.type == SDL_MOUSEBUTTONDOWN &&
9      E.button.button == SDL_BUTTON_LEFT &&
10      State == Hover
11  ) {
12    HandleLeftClick();
13  } else if (
14    E.type == SDL_MOUSEMOTION &&
15    ParentScene.HasMouseFocus()
16  ) {
17    SDL_Point Pos{E.motion.x, E.motion.y};
18    bool Hovering(SDL_PointInRect(&Pos, &Rect));
19    if (State == Normal && Hovering) {
20      State = Hover;
21    } else if (State == Hover && !Hovering) {
22      State = Normal;
23    }
24  }
25}
26
27void Button::Render(SDL_Surface* Surface) {
28  using namespace Config;
29  auto [r, g, b, a]{
30    BUTTON_COLORS[static_cast<int>(State)]};
31
32  SDL_FillRect(Surface, &Rect, SDL_MapRGB(
33                 Surface->format, r, g, b
34               ));
35
36  ButtonText.Render(Surface, &Rect);
37}

Editor/ActorTooltip.h

1#pragma once
2#include <SDL.h>
3#include "Actor.h"
4
5namespace Editor{
6class Scene;
7
8class ActorTooltip {
9public:
10  ActorTooltip(Scene& ParentScene);
11  ~ActorTooltip();
12  ActorTooltip(const ActorTooltip&) = delete;
13  ActorTooltip& operator=(const ActorTooltip&)
14  = delete;
15  void Render();
16  void Tick(float DeltaTime);
17  void PositionWindow();
18  void HandleEvent(const SDL_Event& E);
19  void SetIsVisible(bool NewVisibility);
20
21  SDL_Surface* GetSurface() const {
22    return SDL_GetWindowSurface(SDLWindow);
23  }
24
25private:
26  bool isVisible{false};
27  SDL_Window* SDLWindow{nullptr};
28  Actor* DragActor{nullptr};
29  Scene& ParentScene;
30  SDL_Cursor* DenyCursor{nullptr};
31};
32}

Editor/AssetManager.h

1#pragma once
2#include "Image.h"
3
4namespace Editor {
5struct AssetManager {
6  Image BlueBlock{"Assets/Brick_Blue_A.png"};
7  Image GreenBlock{"Assets/Brick_Green_A.png"};
8  Image CyanBlock{"Assets/Brick_Cyan_A.png"};
9  Image OrangeBlock{"Assets/Brick_Orange_A.png"};
10  Image RedBlock{"Assets/Brick_Red_A.png"};
11  Image YellowBlock{"Assets/Brick_Yellow_A.png"};
12};
13}

Editor/Button.h

1#pragma once
2#include <SDL.h>
3#include <string>
4#include "Text.h"
5
6enum class ButtonState {
7  Normal = 0,
8  Hover = 1,
9  Active = 2,
10  Disabled = 3
11};
12
13namespace Editor{
14class Scene;
15class Button {
16public:
17  Button(
18    Scene& ParentScene,
19    const std::string& Text,
20    SDL_Rect Rect
21  ) : ButtonText{Text, 20},
22      Rect{Rect},
23      ParentScene{ParentScene} {}
24
25  virtual void HandleLeftClick() {}
26  void HandleEvent(const SDL_Event& E);
27  void Render(SDL_Surface* Surface);
28  void Tick(float DeltaTime) {}
29
30  ButtonState GetState() const {
31    return State;
32  }
33
34  void SetState(ButtonState NewState) {
35    State = NewState;
36  }
37
38private:
39  Scene& ParentScene;
40  ButtonState State{ButtonState::Normal};
41  Text ButtonText;
42  SDL_Rect Rect;
43};
44}

Editor/EditorButtons.h

1#pragma once;
2#include "Button.h"
3
4namespace Editor{
5using namespace Config::Editor;
6class LoadLevelButton : public Button {
7public:
8  constexpr static int WIDTH{40};
9  LoadLevelButton(Scene& ParentScene, int Level)
10  : Level{Level},
11    Button {
12      ParentScene,
13      std::to_string(Level),
14      {
15        PADDING * Level + WIDTH * (Level-1),
16        LEVEL_HEIGHT + PADDING,
17        WIDTH, 30
18      }
19    }
20  {
21    if (Level == 1) {
22      SetState(ButtonState::Active);
23    }
24  }
25
26  void HandleEvent(const SDL_Event& E) {
27    Button::HandleEvent(E);
28    if (E.type == UserEvents::LOAD_LEVEL) {
29      if (E.user.code == Level) {
30        SetState(ButtonState::Active);
31      } else {
32        SetState(ButtonState::Normal);
33      }
34    }
35  }
36
37  void HandleLeftClick() override {
38    SDL_Event E{UserEvents::LOAD_LEVEL};
39    E.user.code = Level;
40    SDL_PushEvent(&E);
41  }
42
43private:
44  int Level;
45};
46
47class PlayLevelButton : public Button {
48public:
49  constexpr static int WIDTH{70};
50  PlayLevelButton(Scene& ParentScene)
51  : Button {
52      ParentScene,
53      "PLAY",
54      {
55        LEVEL_WIDTH - WIDTH - PADDING,
56        LEVEL_HEIGHT + PADDING,
57        WIDTH, 30
58      }
59    }
60  {}
61
62  void HandleLeftClick() override {
63    using namespace UserEvents;
64    SDL_Event E{SAVE_AND_PLAY_LEVEL};
65    SDL_PushEvent(&E);
66  }
67};
68
69class SaveLevelButton : public Button {
70public:
71  constexpr static int WIDTH{70};
72  SaveLevelButton(Scene& ParentScene)
73  : Button {
74      ParentScene,
75      "SAVE",
76      {
77        LEVEL_WIDTH - WIDTH
78          - PlayLevelButton::WIDTH - PADDING * 2,
79        LEVEL_HEIGHT + PADDING,
80        WIDTH, 30
81      }
82    }
83  {
84    SetState(ButtonState::Disabled);
85  }
86
87  void HandleEvent(const SDL_Event& E) {
88    Button::HandleEvent(E);
89    using namespace UserEvents;
90    if (E.type == LEVEL_EDIT) {
91      SetState(ButtonState::Normal);
92    } else if (
93      E.type == LOAD_LEVEL ||
94      E.type == SAVE_LEVEL ||
95      E.type == SAVE_AND_PLAY_LEVEL
96    ) {
97      SetState(ButtonState::Disabled);
98    }
99  }
100
101  void HandleLeftClick() override {
102    SDL_Event E{UserEvents::SAVE_LEVEL};
103    SDL_PushEvent(&E);
104  }
105};
106}

Editor/Image.h

1#pragma once
2#include <SDL.h>
3#include <SDL_image.h>
4#include <string>
5#include "Config.h"
6
7namespace Editor{
8class Image {
9 public:
10  Image() = default;
11  Image(const std::string& Path)
12  : ImageSurface{IMG_Load(Path.c_str())
13  } {
14    CheckSDLError("Loading Image");
15  }
16
17  void Render(
18    SDL_Surface* Surface, SDL_Rect Rect
19  ) const {
20    SDL_BlitScaled(
21      ImageSurface, nullptr, Surface, &Rect);
22  }
23
24  Image(Image&& Other) noexcept
25  : ImageSurface(Other.ImageSurface) {
26    Other.ImageSurface = nullptr;
27  }
28  
29  ~Image() {
30    if (ImageSurface) {
31      SDL_FreeSurface(ImageSurface);
32    }
33  }
34
35  Image(const Image&) = delete;
36  Image& operator=(const Image&) = delete;
37
38 private:
39  SDL_Surface* ImageSurface{nullptr};
40};
41}

Editor/Scene.h

1#pragma once
2#include <SDL.h>
3#include "ActorMenu.h"
4#include "ActorTooltip.h"
5#include "AssetManager.h"
6#include "Level.h"
7#include "Window.h"
8#include "EditorButtons.h"
9
10namespace Editor{
11class Scene {
12 public:
13  Scene(Window& ParentWindow)
14  : ParentWindow{ParentWindow}
15  {}
16
17  void HandleEvent(const SDL_Event& E) {
18    ActorShelf.HandleEvent(E);
19    TooltipWindow.HandleEvent(E);
20    CurrentLevel.HandleEvent(E);
21
22    LoadButton1.HandleEvent(E);
23    LoadButton2.HandleEvent(E);
24    LoadButton3.HandleEvent(E);
25    SaveButton.HandleEvent(E);
26    PlayButton.HandleEvent(E);
27  }
28
29  void Tick(float DeltaTime) {
30    ActorShelf.Tick(DeltaTime);
31    TooltipWindow.Tick(DeltaTime);
32    CurrentLevel.Tick(DeltaTime);
33
34    LoadButton1.Tick(DeltaTime);
35    LoadButton2.Tick(DeltaTime);
36    LoadButton3.Tick(DeltaTime);
37    SaveButton.Tick(DeltaTime);
38    PlayButton.Tick(DeltaTime);
39  }
40
41  void Render(SDL_Surface* Surface) {
42    ActorShelf.Render(Surface);
43    TooltipWindow.Render();
44    CurrentLevel.Render(Surface);
45
46    LoadButton1.Render(Surface);
47    LoadButton2.Render(Surface);
48    LoadButton3.Render(Surface);
49    SaveButton.Render(Surface);
50    PlayButton.Render(Surface);
51  }
52
53  AssetManager& GetAssets() {
54    return Assets;
55  }
56
57  bool HasMouseFocus() const {
58    return ParentWindow.HasMouseFocus();
59  }
60
61  Window& GetWindow() const {
62    return ParentWindow;
63  }
64
65  Level& GetLevel() {
66    return CurrentLevel;
67  }
68
69 private:
70  ActorMenu ActorShelf{*this};
71  ActorTooltip TooltipWindow{*this};
72  Level CurrentLevel{*this};
73  Window& ParentWindow;
74  AssetManager Assets;
75
76  LoadLevelButton LoadButton1{*this, 1};
77  LoadLevelButton LoadButton2{*this, 2};
78  LoadLevelButton LoadButton3{*this, 3};
79  SaveLevelButton SaveButton{*this};
80  PlayLevelButton PlayButton{*this};
81};
82}

Editor/Text.h

1#pragma once
2#include <SDL.h>
3#include <SDL_ttf.h>
4#include <string>
5#include "Config.h"
6
7namespace Editor{
8class Text {
9public:
10  Text(
11    const std::string& InitialText,
12    int FontSize
13  ) : Content(InitialText) {
14    Font = TTF_OpenFont(
15      Config::FONT.c_str(), FontSize);
16    CheckSDLError("Opening Font");
17    SetText(InitialText);
18  }
19
20  ~Text() {
21    if (!SDL_WasInit(SDL_INIT_VIDEO)) {
22      return;
23    }
24    if (TextSurface) {
25      SDL_FreeSurface(TextSurface);
26    }
27    if (Font) {
28      TTF_CloseFont(Font);
29    }
30  }
31
32  Text(const Text&) = delete;
33  Text& operator=(const Text&) = delete;
34
35  void SetText(const std::string& NewText) {
36    Content = NewText;
37
38    if (TextSurface) {
39      SDL_FreeSurface(TextSurface);
40    }
41    TextSurface = TTF_RenderText_Blended(Font,
42      Content.c_str(), Config::FONT_COLOR);
43    CheckSDLError("Creating Text Surface");
44  }
45
46  void Render(
47    SDL_Surface* Surface, SDL_Rect* Rect
48  ) {
49    if (!TextSurface) return;
50
51    int TextW{TextSurface->w};
52    int TextH{TextSurface->h};
53
54    // Center the text
55    SDL_Rect Destination {
56      Rect->x + (Rect->w - TextW) / 2,
57      Rect->y + (Rect->h - TextH) / 2,
58      TextW, TextH
59    };
60
61    SDL_BlitSurface(
62      TextSurface, nullptr,
63      Surface, &Destination
64    );
65  }
66
67private:
68  std::string Content;
69  TTF_Font* Font{nullptr};
70  SDL_Surface* TextSurface{nullptr};
71};
72}

Editor/Window.h

1#pragma once
2#include <SDL.h>
3#include "Config.h"
4
5namespace Editor{
6class Window {
7public:
8  Window() {
9    SDLWindow = SDL_CreateWindow(
10      Config::Editor::WINDOW_TITLE.c_str(),
11      SDL_WINDOWPOS_UNDEFINED,
12      SDL_WINDOWPOS_UNDEFINED,
13      Config::Editor::WINDOW_WIDTH,
14      Config::Editor::WINDOW_HEIGHT,
15      0
16    );
17    CheckSDLError("Creating Editor Window");
18  }
19
20  ~Window() {
21    if (SDLWindow && SDL_WasInit(SDL_INIT_VIDEO)) {
22      SDL_DestroyWindow(SDLWindow);
23    }
24  }
25
26  Window(const Window&) = delete;
27  Window& operator=(const Window&) = delete;
28
29  void Render() {
30    auto [r, g, b, a]{
31      Config::Editor::WINDOW_BACKGROUND
32    };
33
34    SDL_FillRect(
35      GetSurface(), nullptr,
36      SDL_MapRGB(GetSurface()->format, r, g, b));
37  }
38
39  void Update() {
40    SDL_UpdateWindowSurface(SDLWindow);
41  }
42
43  SDL_Surface* GetSurface() const {
44    return SDL_GetWindowSurface(SDLWindow);
45  }
46
47  bool HasMouseFocus() const {
48    int x, y, w, h, MouseX, MouseY;
49    SDL_GetWindowPosition(SDLWindow, &x, &y);
50    SDL_GetWindowSize(SDLWindow, &w, &h);
51    SDL_GetGlobalMouseState(&MouseX, &MouseY);
52
53    if (
54      MouseX < x ||
55      MouseX > x + w ||
56      MouseY < y ||
57      MouseY > y + h
58    ) {
59      return false;
60    }
61    return true;
62  }
63
64  SDL_Point GetPosition() const {
65    int x, y;
66    SDL_GetWindowPosition(SDLWindow, &x, &y);
67    return {x, y};
68  }
69
70  SDL_Point GetSize() const {
71    int x, y;
72    SDL_GetWindowSize(SDLWindow, &x, &y);
73    return {x, y};
74  }
75
76private:
77  SDL_Window* SDLWindow{nullptr};
78};
79}

main.cpp

1#include <SDL.h>
2#include <SDL_image.h>
3#include <SDL_ttf.h>
4
5#include "Config.h"
6
7#ifdef WITH_EDITOR
8#include "Editor/Scene.h"
9#include "Editor/Window.h"
10#endif
11
12int main(int argc, char** argv) {
13  SDL_Init(SDL_INIT_VIDEO);
14  CheckSDLError("SDL_Init");
15
16  IMG_Init(IMG_INIT_PNG);
17  CheckSDLError("IMG_Init");
18
19  TTF_Init();
20  CheckSDLError("TTF_Init");
21
22#ifdef WITH_EDITOR
23  Editor::Window EditorWindow;
24  Editor::Scene EditorScene{EditorWindow};
25#endif
26
27  Uint64 LastTick{SDL_GetPerformanceCounter()};
28  SDL_Event E;
29  while (true) {
30    while (SDL_PollEvent(&E)) {
31#ifdef WITH_EDITOR
32      EditorScene.HandleEvent(E);
33#endif
34      if (
35        E.type == SDL_QUIT ||
36        E.type == SDL_WINDOWEVENT &&
37        E.window.event == SDL_WINDOWEVENT_CLOSE
38      ) {
39        TTF_Quit();
40        IMG_Quit();
41        SDL_Quit();
42        return 0;
43      }
44    }
45
46    Uint64 CurrentTick{SDL_GetPerformanceCounter()};
47    float DeltaTime{
48      static_cast<float>(CurrentTick - LastTick) /
49        SDL_GetPerformanceFrequency()
50    };
51    LastTick = CurrentTick;
52
53#ifdef WITH_EDITOR
54    EditorScene.Tick(DeltaTime);
55    EditorWindow.Render();
56    EditorScene.Render(EditorWindow.GetSurface());
57    EditorWindow.Update();
58#endif
59  }
60
61  return 0;
62}

CMakeLists.txt

1cmake_minimum_required(VERSION 3.16)
2set(CMAKE_CXX_STANDARD 20)
3project(Editor VERSION 1.0.0)
4
5add_executable(Editor
6  "main.cpp"
7  "Editor/Source/Button.cpp"
8  "Editor/Source/Blocks.cpp"
9  "Editor/Source/Actor.cpp"
10  "Editor/Source/ActorTooltip.cpp"
11  "Editor/Source/Level.cpp"
12)
13
14target_compile_definitions(
15  Editor PUBLIC
16  WITH_EDITOR
17  CHECK_ERRORS
18)
19
20target_include_directories(
21  Editor PUBLIC ${PROJECT_SOURCE_DIR}
22)
23
24add_subdirectory(external/SDL)
25add_subdirectory(external/SDL_image)
26add_subdirectory(external/SDL_ttf)
27
28target_link_libraries(Editor PRIVATE
29  SDL2
30  SDL2_image
31  SDL2_ttf
32)
33
34if (WIN32)
35  target_link_libraries(
36    Editor PRIVATE SDL2main
37  )
38endif()
39
40set(AssetDirectory "${PROJECT_SOURCE_DIR}/Assets")
41add_custom_command(
42  TARGET Editor POST_BUILD
43  COMMAND
44  ${CMAKE_COMMAND} -E copy_if_different
45    "$<TARGET_FILE:SDL2>"
46    "$<TARGET_FILE:SDL2_image>"
47    "$<TARGET_FILE:SDL2_ttf>"
48    "$<TARGET_FILE_DIR:Editor>"
49
50  COMMAND
51  ${CMAKE_COMMAND} -E copy_directory_if_different
52    "${AssetDirectory}"
53    "$<TARGET_FILE_DIR:Editor>/Assets"
54  VERBATIM
55)

Summary

In this final part of the editor's core implementation, we focused on deserialization – loading the saved level data back into the editor. We implemented the Level::Load() method, using SDL_RWops to read the binary file created in the previous lesson.

We emphasized matching the read operations (SDL_ReadU8(), SDL_ReadLE32(), etc) to the write operations used during serialization. To handle reconstructing actors of unknown types, we introduced static factory methods (Construct) within each actor class. These factories read the necessary data from the file handle and returned a unique_ptr<Actor>. A std::vector<std::function> was used to map the serialized actor type ID to the corresponding factory function.

Key Takeaways:

Loading involves opening files with "rb" mode using SDL_RWFromFile().
Error check the result of SDL_RWFromFile().
Read data in the exact sequence and format it was written.
Static factory methods provide a clean way to handle object construction during deserialization.
std::function allows storing pointers to these static methods for dynamic dispatch.
Remember to convert grid coordinates back to rendering coordinates when setting actor positions.

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

Lesson Contents