Building the Actor Menu

In the previous lesson, we set up the foundational classes for our level editor: the main window, the scene manager, and helper classes for images, text, buttons, and assets. We now have a blank window ready to be populated.

This lesson builds upon that foundation by adding the first major UI component: the Actor Menu. This menu will serve as a palette on the right side of the editor, displaying all the available objects (Actors) that users can place into their levels.

We'll create a dedicated ActorMenu class to manage this area's rendering and logic. We will also define a base Actor class, which will represent any object that can exist in our level, like blocks, enemies, or power-ups.

Finally, we'll implement our first concrete Actor type – a simple blue block – and add an instance of it to the ActorMenu, making it visible and ready for interaction in later steps.

Adding an ActorMenu Class

The right side of our editor will contain a list of available "Actors" (game objects) that can be placed in the level. Let's create a dedicated class, ActorMenu, to manage this UI element.

As with our Scene and other core components, it will follow the standard pattern of having HandleEvent(), Tick(), and Render() methods. It also needs access to the main Scene it belongs to, so we'll store a reference to the ParentScene.

1// Editor/ActorMenu.h
2#pragma once
3#include <SDL.h>
4
5namespace Editor {
6class Scene;
7
8class ActorMenu {
9 public:
10  ActorMenu(Scene& ParentScene)
11  : ParentScene{ParentScene}
12  {}
13
14  void HandleEvent(const SDL_Event& E) {}
15  void Tick(float DeltaTime) {}
16  void Render(SDL_Surface* Surface) {}
17
18  Scene& GetScene() const {
19    return ParentScene;
20  }
21
22 private:
23  Scene& ParentScene;
24};
25}

Now that we have the ActorMenu class defined, we need to create an instance of it within our Editor::Scene. The Scene will own and manage the ActorMenu.

We'll add an ActorMenu member variable to the Scene class, passing *this (a reference to the Scene itself) to the ActorMenu constructor.

We also need to update the Scene's HandleEvent(), Tick(), and Render() methods to delegate calls to the corresponding methods in the ActorMenu instance.

1// Editor/Scene.h
2#pragma once
3#include <SDL.h>
4#include "ActorMenu.h"
5#include "AssetManager.h"
6#include "Window.h"
7
8namespace Editor{
9class Scene {
10 public:
11  Scene(Window& ParentWindow)
12  : ParentWindow{ParentWindow}
13  {}
14
15  void HandleEvent(const SDL_Event& E) {
16    ActorShelf.HandleEvent(E);
17  }
18
19  void Tick(float DeltaTime) {
20    ActorShelf.Tick(DeltaTime);
21  }
22
23  void Render(SDL_Surface* Surface) {
24    ActorShelf.Render(Surface);
25  }
26  
27  // ...
28
29 private:
30  ActorMenu ActorShelf{*this};
31  // ...
32};
33}

Rendering ActorMenu

With the ActorMenu integrated into the Scene, let's make it visible. We need to define its appearance and position within the editor window.

We'll add some constants to our Config.h file, specifically within the Config::Editor namespace. These will define the menu's width, its X-coordinate (anchored to the right edge of the window), its background color, and some padding for spacing elements inside it later.

1// Config.h
2#pragma once
3// ...
4
5#ifdef WITH_EDITOR
6namespace Config::Editor {
7// Window
8// ...
9
10// ActorMenu
11inline const int ACTOR_MENU_WIDTH{70};
12inline const int ACTOR_MENU_POSITION_X{
13  WINDOW_WIDTH - ACTOR_MENU_WIDTH};
14inline const SDL_Color ACTOR_MENU_BACKGROUND{
15  15, 15, 15, 255};
16inline const int PADDING{10};
17}
18#endif
19
20// ...

Time to implement ActorMenu::Render(). This function needs to draw the visual representation of the menu panel. We'll start with just the background.

Using the ACTOR_MENU_BACKGROUND color and the position/size defined by ACTOR_MENU_POSITION_X, ACTOR_MENU_WIDTH, and WINDOW_HEIGHT from Config::Editor, we call SDL_FillRect(). To avoid recalculating the menu's rectangle every frame, we'll store it in a private SDL_Rect member variable initialized once.

1// Editor/ActorMenu.h
2#pragma once
3#include <SDL.h>
4#include "Config.h"
5
6namespace Editor {
7// ...
8class ActorMenu {
9 public:
10  // ...
11
12  void Render(SDL_Surface* Surface) {
13    using namespace Config::Editor;
14    auto [r, g, b, a]{ACTOR_MENU_BACKGROUND};
15
16    SDL_FillRect(
17      Surface,
18      &Rect,
19      SDL_MapRGB(Surface->format, r, g, b)
20    );
21  }
22
23 private:
24  Scene& ParentScene;
25  SDL_Rect Rect{
26    Config::Editor::ACTOR_MENU_POSITION_X, 0,
27    Config::Editor::ACTOR_MENU_WIDTH,
28    Config::Editor::WINDOW_HEIGHT
29  };
30};
31}

We should now see our menu rendered at the side of our application, using the width and color defined within our configuration file:

Actor Classes

Our editor will handle various types of objects that can be placed in the level – blocks, enemies, items, etc. We'll call these "Actors". To manage them effectively, we need a common base class, Actor.

This Actor class will define the fundamental properties and interface shared by all actor types, such as position (SDL_Rect), visual representation (Image&), and core methods like HandleEvent(), Tick(), and Render().

Because Actor needs a reference to the Scene but Scene will eventually hold Actors (via ActorMenu), we must forward-declare Scene in Actor.h to prevent a circular include dependency.

1// Editor/Actor.h
2#pragma once
3#include <SDL.h>
4#include "Image.h"
5
6namespace Editor {
7class Scene;
8class Actor {
9 public:
10  Actor(
11    Scene& ParentScene,
12    const SDL_Rect& Rect,
13    Image& Image
14  ) : ParentScene{ParentScene},
15      Rect{Rect},
16      Art{Image}
17  {}
18
19  virtual void HandleEvent(const SDL_Event& E){}
20  void Tick(float DeltaTime) {}
21
22  void Render(SDL_Surface* Surface) {
23    Art.Render(Surface, Rect);
24  }
25
26protected:
27  Scene& ParentScene;
28  SDL_Rect Rect;
29  Image& Art;
30};
31}

Let's create our first usable Actor. We'll define a BlueBlock class in Editor/Blocks.h that inherits from our base Actor class.

We’ll store this in a file called "Blocks" rather than something like "BlueBlock", as we’ll have many block types in the future, and their classes will be quite small so we can just define them all in a single file. However, it would be equally valid to separate our block types into their own files - it’s just a question of personal preference.

This BlueBlock class represents a simple blue brick. We'll give it fixed dimensions using constexpr static members. The constructor needs to initialize the base Actor part, including fetching the "BlueBlock" image from the AssetManager via the Scene.

This interaction necessitates the full Scene definition. To avoid issues with include order and dependencies, we declare the BlueBlock constructor in the .h file but defer its implementation to Editor/Source/Blocks.cpp, where including Editor/Scene.h is straightforward.

1// Editor/Blocks.h
2#pragma once
3#include "Actor.h"
4
5namespace Editor{
6class BlueBlock : public Actor {
7public:
8  static constexpr int WIDTH{50};
9  static constexpr int HEIGHT{25};
10
11  BlueBlock(
12    Scene& ParentScene, SDL_Rect Rect
13  );
14};
15}

In the new Editor/Source/Blocks.cpp file, we provide the definition for BlueBlock::BlueBlock (that is, the constructor). Make sure to include Editor/Scene.h here.

The constructor's main task is to initialize the base Actor class correctly, passing along the scene, setting the block's rectangle dimensions using its static constants, and getting the corresponding Image reference from the AssetManager.

1// Editor/Source/Blocks.cpp
2#include "Editor/Blocks.h"
3#include "Editor/Scene.h"
4
5using namespace Editor;
6
7BlueBlock::BlueBlock(
8  Scene& ParentScene, SDL_Rect Rect
9) : Actor{
10    ParentScene,
11    SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT},
12    ParentScene.GetAssets().BlueBlock
13  }
14{}

Adding Actors to the Menu

Our ActorMenu needs to store the different Actor types that the user can select. Since these will be instances of classes derived from Actor (like BlueBlock), we need to store them in a way that handles polymorphism.

We'll use a std::vector to hold pointers to Actor objects. To manage memory automatically and correctly handle ownership, we'll use std::unique_ptr<Actor>. We add using aliases (ActorPtr, ActorPtrs) for clarity and declare a std::vector<ActorPtr> named Actors as a member of ActorMenu.

1// Editor/ActorMenu.h
2// ...
3#include <vector>
4#include <memory>
5#include "Actor.h"
6
7namespace Editor {
8class Scene;
9using ActorPtr = std::unique_ptr<Actor>;
10using ActorPtrs = std::vector<ActorPtr>;
11
12class ActorMenu {
13 public:
14  // ...
15
16 private:
17  ActorPtrs Actors;
18  // ...
19};
20}

Now that ActorMenu has a container for Actors, we need to make sure these actors participate in the application loop. We must iterate through the Actors vector in the ActorMenu's HandleEvent(), Tick(), and Render() methods.

In each of these methods, we add a range-based for loop that goes through each ActorPtr in the Actors vector and calls the corresponding method - HandleEvent(), Tick(), and Render() - on the pointed-to Actor object.

Note that rendering actors should happen after rendering the menu's background, to ensure they get rendered on top of the background.

1// Editor/ActorMenu.h
2// ...
3
4namespace Editor {
5// ...
6
7class ActorMenu {
8 public:
9  // ...
10
11  void HandleEvent(const SDL_Event& E) {
12    for (ActorPtr& A : Actors) {
13      A->HandleEvent(E);
14    }
15  }
16
17  void Tick(float DeltaTime) {
18    for (ActorPtr& A : Actors) {
19      A->Tick(DeltaTime);
20    }
21  }
22
23  void Render(SDL_Surface* Surface) {
24    using namespace Config::Editor;
25    auto [r, g, b, a]{ACTOR_MENU_BACKGROUND};
26
27    SDL_FillRect(
28      Surface,
29      &Rect,
30      SDL_MapRGB(Surface->format, r, g, b)
31    );
32
33    for (ActorPtr& A : Actors) {
34      A->Render(Surface);
35    }
36  }
37
38 private:
39  ActorPtrs Actors;
40  // ...
41};
42}

We have the ActorMenu, the Actor base class, the BlueBlock derived class, and the mechanism to store and process actors. Now, let's actually create an instance of BlueBlock and add it to the ActorMenu.

We'll do this in the ActorMenu's constructor.

Using Actors.emplace_back() and std::make_unique<BlueBlock>(), we create a new BlueBlock in dynamic memory, managed by a unique_ptr. We pass the required Scene reference using GetScene() and an initial SDL_Rect defining its position within the menu, using the PADDING configuration for spacing.

We’ll set the width and height in the SDL_Rect to 0, but the value doesn’t matter as the BlueBlock constructor will set the correct dimensions itself before forwarding it to the Actor base constructor.

1// Editor/ActorMenu.h
2// ...
3#include "Blocks.h"
4
5namespace Editor {
6// ...
7
8class ActorMenu {
9 public:
10  ActorMenu(Scene& ParentScene)
11  : ParentScene{ParentScene}
12  {
13    using namespace Config::Editor;
14    Actors.emplace_back(
15      std::make_unique<BlueBlock>(
16        GetScene(),
17        SDL_Rect{
18          ACTOR_MENU_POSITION_X + PADDING,
19          PADDING,
20          0, 0
21        }
22      )
23    );
24  }
25
26  // ...
27};
28}

If you run the program after these changes, the blue block should appear inside the actor menu panel.

This confirms that the ActorMenu is being rendered, the BlueBlock is being created correctly, added to the Actors vector, and its Render() method is being called by loop within the ActorMenu::Render() function.

Complete Code

We've created several new files and modified existing ones to implement the ActorMenu and the first Actor.

Below are the full contents of Editor/ActorMenu.h, Editor/Actor.h, Editor/Blocks.h, and Editor/Source/Blocks.cpp reflecting the changes made in this lesson.

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
32  void HandleEvent(const SDL_Event& E) {
33    for (ActorPtr& A : Actors) {
34      A->HandleEvent(E);
35    }
36  }
37
38  void Tick(float DeltaTime) {
39    for (ActorPtr& A : Actors) {
40      A->Tick(DeltaTime);
41    }
42  }
43
44  void Render(SDL_Surface* Surface) {
45    using namespace Config::Editor;
46    auto [r, g, b, a]{ACTOR_MENU_BACKGROUND};
47
48    SDL_FillRect(
49      Surface,
50      &Rect,
51      SDL_MapRGB(Surface->format, r, g, b)
52    );
53
54    for (ActorPtr& A : Actors) {
55      A->Render(Surface);
56    }
57  }
58
59  Scene& GetScene() const {
60    return ParentScene;
61  }
62
63 private:
64  Scene& ParentScene;
65  ActorPtrs Actors;
66  SDL_Rect Rect{
67    Config::Editor::ACTOR_MENU_POSITION_X, 0,
68    Config::Editor::ACTOR_MENU_WIDTH,
69    Config::Editor::WINDOW_HEIGHT
70  };
71};
72}

1#pragma once
2#include <SDL.h>
3#include "Image.h"
4
5namespace Editor {
6class Scene;
7class Actor {
8 public:
9  Actor(
10    Scene& ParentScene,
11    const SDL_Rect& Rect,
12    Image& Image
13  ) : ParentScene{ParentScene},
14      Rect{Rect},
15      Art{Image}
16  {}
17
18  virtual void HandleEvent(const SDL_Event& E){}
19  void Tick(float DeltaTime) {}
20
21  void Render(SDL_Surface* Surface) {
22    Art.Render(Surface, Rect);
23  }
24
25protected:
26  Scene& ParentScene;
27  SDL_Rect Rect;
28  Image& Art;
29};
30}

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}

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

We also made modifications to Editor/Scene.h to include and manage the ActorMenu, and to Config.h to add layout constants. The updated versions of these files are shown below.

1#pragma once
2#include <SDL.h>
3#include "ActorMenu.h"
4#include "AssetManager.h"
5#include "Window.h"
6
7namespace Editor{
8class Scene {
9 public:
10  Scene(Window& ParentWindow)
11  : ParentWindow{ParentWindow}
12  {}
13
14  void HandleEvent(const SDL_Event& E) {
15    ActorShelf.HandleEvent(E);
16  }
17
18  void Tick(float DeltaTime) {
19    ActorShelf.Tick(DeltaTime);
20  }
21
22  void Render(SDL_Surface* Surface) {
23    ActorShelf.Render(Surface);
24  }
25
26  AssetManager& GetAssets() {
27    return Assets;
28  }
29
30  bool HasMouseFocus() const {
31    return ParentWindow.HasMouseFocus();
32  }
33
34  Window& GetWindow() const {
35    return ParentWindow;
36  }
37
38 private:
39  ActorMenu ActorShelf{*this};
40  Window& ParentWindow;
41  AssetManager Assets;
42};
43}

1#pragma once
2#include <iostream>
3#include <SDL.h>
4#include <string>
5#include <vector>
6
7namespace Config {
8inline const std::vector BUTTON_COLORS{
9  SDL_Color{15, 15, 15, 255},  // Normal
10  SDL_Color{15, 155, 15, 255}, // Hover
11  SDL_Color{225, 15, 15, 255}, // Active
12  SDL_Color{60, 60, 60, 255}   // Disabled
13};
14
15inline constexpr SDL_Color FONT_COLOR{
16  255, 255, 255, 255};
17
18inline const std::string FONT{
19  "Assets/Rubik-SemiBold.ttf"};
20}
21
22#ifdef WITH_EDITOR
23namespace Config::Editor {
24// Window
25inline const std::string WINDOW_TITLE{"Editor"};
26inline const int WINDOW_WIDTH{730};
27inline const int WINDOW_HEIGHT{300};
28inline const SDL_Color WINDOW_BACKGROUND{35, 35, 35, 255};
29
30// ActorMenu
31inline const int ACTOR_MENU_WIDTH{70};
32inline const int ACTOR_MENU_POSITION_X{
33  WINDOW_WIDTH - ACTOR_MENU_WIDTH};
34inline const SDL_Color ACTOR_MENU_BACKGROUND{
35  15, 15, 15, 255};
36inline const int PADDING{10};
37}
38#endif
39
40inline void CheckSDLError(
41  const std::string& Msg) {
42#ifdef CHECK_ERRORS
43  const char* error = SDL_GetError();
44  if (*error != '\0') {
45    std::cerr << Msg << " Error: "
46      << error << '\n';
47    SDL_ClearError();
48  }
49#endif
50}

Summary

We've added the first major piece of the editor's user interface: the Actor Menu. Here's what we did:

• ActorMenu Class: Created a new class to manage the menu panel, including its rendering and event handling. Added an instance of it to the Scene.
• Configuration: Defined constants in Config.h for the menu's width, position, background color, and padding.
• Rendering: Implemented ActorMenu::Render() to draw the background rectangle.
• Actor Hierarchy: Introduced a base Actor class for all placeable items, using forward declaration for Scene to prevent include cycles.
• BlueBlock Actor: Created the first concrete Actor subclass, BlueBlock, defining its dimensions and implementing its constructor in a separate .cpp file to handle dependencies correctly.
• Actor Storage: Used std::vector<std::unique_ptr<Actor>> within ActorMenu to store and manage actor instances polymorphically and safely.
• Integration: Updated ActorMenu's methods to process the contained actors and added a BlueBlock instance to the menu in the constructor.

The editor now displays the menu on the right with a blue block ready to be used in future lessons.

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