How did a Renderer pass to the rest of the classes?

Question

I have a Game class that through its constructor initializes the window and the SDL renderer. I understand from what I read so far (not much) that there should only be one renderer for each window.

Then I have a Player class where through the constructor I want to load a texture with an image, for which I need the renderer, therefore, I put the renderer as the constructor parameter and in this way I am forced to pass from the constructor from Game the renderer to the Player constructor (since it instantiated the Player class in The Game class).

The fact is that the renderer is passed before being created, and I don't know if there is another way to invoke the constructor of the Player from Game, since it forces me to put it that way. I leave the code for you to see:

Game class:

#pragma once
#include <iostream>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include "player.hpp"
//#include "helpers.hpp"
using namespace std;

#define WINDOW_WIDHT 640
#define WINDOW_HEIGTH 480

class Game
{
public:
  Game();
  ~Game();

  void loop();
  void update() {}
  void input();
  void render();
  void draw() {}

private:
  SDL_Window *window;
  SDL_Renderer *renderer = nullptr;
  SDL_Event event;
  SDL_Texture *gTexture;
  bool running;

  Player player;
};

Game::Game() : player(renderer)
{
  SDL_Init(0);
  SDL_CreateWindowAndRenderer(WINDOW_WIDHT, WINDOW_HEIGTH, 0, &window, &renderer);
  SDL_SetWindowTitle(window, "Intento...");

  //inicializa la carga de pngs
  int imgFlags = IMG_INIT_PNG;
  if (!IMG_Init(imgFlags) & imgFlags)
  {
    cout << "No se puede inicializar SDL_Img" << endl;
  }
  
  running = true;
  loop();
}

Game::~Game()
{
  SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
  IMG_Quit();
  SDL_Quit();
}

void Game::loop()
{
  while (running)
  {
    input();
    render();
    update();
  }
}

void Game::render()
{
  SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
  SDL_Rect rect;
  rect.x = rect.y = 0;
  rect.w = WINDOW_WIDHT;
  rect.h = WINDOW_HEIGTH;

  SDL_RenderFillRect(renderer, &rect);

  SDL_RenderPresent(renderer);
}

void Game::input()
{
  while (SDL_PollEvent(&event) > 0)
  {
    switch (event.type)
    {
    case SDL_QUIT:
      running = false;
      break;
    }
  }
}

Clase Player:

#pragma once
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <iostream>
//#include "helpers.hpp"
using namespace std;

class Player
{
  public:
    Player(SDL_Renderer *renderer);
    ~Player() = default;
    const SDL_Rect getDest() { return dest; }
    const SDL_Rect getSrc() { return src; }
    void setDest(int x, int y, int w, int h);
    void setSrc(int x, int y, int w, int h);
    SDL_Texture *loadTexture(std::string path, SDL_Renderer *renderer);

  private:
    SDL_Rect dest;
    SDL_Rect src;
};

Player::Player(SDL_Renderer *renderer){
  loadTexture("mario.png", renderer);
  /* setSrc(48, 48, 48, 48);
  setDest(100, 100, 48, 48);
  SDL_Rect playerRectSrc = getSrc();
  SDL_Rect playerRectDest = getDest(); */
}

void Player::setDest(int x, int y, int w, int h){
  dest.x = x;
  dest.y = y;
  dest.w = w;
  dest.h = h;
}
void Player::setSrc(int x, int y, int w, int h){
  src.x = x;
  src.y = y;
  src.w = w;
  src.h = h;
}

SDL_Texture* Player::loadTexture(std::string path, SDL_Renderer *renderer)
{
  SDL_Texture *newTexture = NULL;
  SDL_Surface *loadedSurface = IMG_Load(path.c_str());
  if (loadedSurface == NULL)
  {
    cout << "No se pudo cargar la imagen" << endl;
  }
  else
  {
    newTexture = SDL_CreateTextureFromSurface(renderer, loadedSurface);
    if (newTexture == NULL)
    {
      cout << "No se pudo generar la textura para player" << endl;
    }
    SDL_FreeSurface(loadedSurface);
  }
  return newTexture;
}

The question is how to call the Player constructor after the renderer has been created? The only thing I can think of is not to create the texture through the constructor, but through a function, but it wouldn't be the right thing to do, right? that's what the constructor is for

Answer 1

The only thing I can think of is not to create the texture through the constructor, but through a function, but it wouldn't be the right thing to do, right? that's what the constructor is for

Right. However, SDL is a C library so it doesn't use C++ RAII, which is responsible for construction/destruction. First, we call constructors in the member initializer list (: foo{}, bar{foo}), which provides us with fully constructed member objects. Then, we do whatever we want in the constructor body ({ use(foo); }). However, in your case the constructor body ({ SDL_CreateWindowAndRenderer(...); } ) is needed before member initialization (: player{renderer}).

The question is how to call the Player constructor after the renderer has been created?

Construct all that SDL_ stuff before constructing the Player:

class RenderWindow {
    SDL_Window* window;
    SDL_Renderer* renderer;
public:
    RenderWindow() {
        SDL_Init(0);
        SDL_CreateWindowAndRenderer(WINDOW_WIDHT, WINDOW_HEIGTH, 0, &window, &renderer);
        SDL_SetWindowTitle(window, "Intento...");
    }
    // an easy double-free protection, you can use anything else
    RenderWindow(RenderWindow&&) = delete;
    ~RenderWindow() {
        SDL_DestroyRenderer(renderer);
        SDL_DestroyWindow(window);
        SDL_Quit();
    }
    // lvalue-only to forbid dangling like RenderWindow{}.raw_renderer()
    auto raw_renderer() & { return renderer; }
};

Now, your Player and Game can be implemented in a natural RAII construct-then-use way:

class Player {
public:
    Player(SDL_Renderer*); // TODO implement
};

class Game {
    // note the declaration order: construction goes from top to bottom
    RenderWindow render_window;
    Player player;
public:
    // SDL_* happens in render_window{},
    // so player{render_window.raw_renderer()} gets an initialized SDL_Renderer
    Game(): /*render_window{},*/ player{render_window.raw_renderer()} {}
};