Tag: message

When SDL_RenderCopy() gets called, it fails and SDL_GetError()returns the error “Invalid texture”.

Here’s my code:

main.cpp

#include "Game.cpp"
#include <iostream>

using namespace std;

int main(int argc, char* args()) {
    
    try {

        Game game("Test", 1280, 720, 60);
        GameObject object("Immagine.bmp");
        game.addObject(object);
        game.run();
    }
    catch(const char* message) {

        cerr<<message;
    }

    return 0;
}

Game.cpp

#include "GameGraphics.cpp"

class Game {

    private:
        bool running;
        GameGraphics* graphics;
        vector<GameObject> objects;

    public:
        Game(const char* title, int width, int height, int targetFps) {

            running = false;

            if(SDL_Init(SDL_INIT_EVERYTHING) != 0) {

                throw SDL_GetError(); 
            }

            try {

                graphics = new GameGraphics(title, width, height, targetFps);
            }
            catch(const char* message) {

                SDL_Quit();
                throw;
            }
        }

        void addObject(GameObject& object) {

            objects.push_back(object);
            graphics->loadTexture(object);
        }

        void run() {

            running = true;

            while(running) {

                SDL_Event e;

                if(SDL_PollEvent(&e)) {

                    if(e.type == SDL_QUIT) {

                        running = false;
                    }
                }

                graphics->render(objects);
            }
        }
};

GameGraphics.cpp

#include <SDL2/SDL.h>
#include <vector>
#include "GameObject.cpp"
#include <iostream>

using namespace std;
class GameGraphics {

    private:
        int targetFps, ticksPerFrame;
        SDL_Renderer* renderer;
        SDL_Window* window;

    public:
        GameGraphics(const char* title, int width, int height, int targetFps) {

            if(SDL_WasInit(SDL_INIT_EVERYTHING) < 0) {

                throw "Can't construct GameGraphics object without initializing SDL first";
            }

            window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, 0);

            if(window == NULL) {

                throw SDL_GetError();
            }

            renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);

            if(renderer == NULL) {

                SDL_DestroyWindow(window);
                throw SDL_GetError();
            }
        }

        void render(vector<GameObject>& objects) {

            if(SDL_RenderClear(renderer)) {

                throw SDL_GetError();
            }

            for(auto it = objects.begin(); it != objects.end(); ++it) {

                GameObject object = *it;
                
                if(SDL_RenderCopy(renderer, object.getTexture(), NULL, NULL) == -1) {

                    throw SDL_GetError();
                }
            }

            SDL_RenderPresent(renderer);
        }

        void loadTexture(GameObject& object) {

            SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, object.getSurface());
            
            if(texture == NULL) {

                throw SDL_GetError();
            }

            object.setTexture(texture);
        }
};

GameObject.cpp

#include <SDL2/SDL.h>
#include <string.h>

class GameObject {

    private:
        SDL_Surface* surface;
        SDL_Texture* texture;

    public:
        GameObject(const char* bmpFile) {

            char* basePath = strcat(SDL_GetBasePath(), "resources/images/");
            surface = SDL_LoadBMP(strcat(basePath, bmpFile));

            if(surface == NULL) {

                throw SDL_GetError();
            }

            texture = NULL;
        }

        void setSurface(SDL_Surface* surface) {

            this->surface = surface;
        }

        void setTexture(SDL_Texture* texture) {

            this->texture = texture;
        }

        SDL_Surface* getSurface() {

            return surface;
        }

        SDL_Texture* getTexture() {

            return texture;
        }
};

I’m really new to C++ (coming from C, Java, Python, Javascript/Typescript) and I think I might be getting something wrong about the mechanism of passing an object by reference. What I suspect that’s happening is that in GameGraphics::loadTexture() the formal parameter object is being treated as if its value is just a copy of the actual parameter (basically, as if I was passing it by value). So when the texture member of object is modified, I’m just modifying the copy, not a reference to an external object. So when SDL_RenderCopy() gets invoked (inside GameGraphics::render()), it gets a NULL instead of a pointer to the texture to render, therefore the error gets printed.
But according to countless sources I’ve read through the last few hours, this is the correct way to pass an object by reference. What am I getting wrong then?