SDL 错误:使用SDL_CreateTextureFromSurface时呈现器无效

Question

当我运行程序时，我会在控制台上写出以下内容：

Unable to create texture from Textures/background.png! SDL Error: Invalid renderer
Failed to load background texture image!
Failed to load media!

所以这是我的完整程序，所有类都在单独的文件中：

//main.cpp
#include <SDL.h>
#include <SDL_image.h>
#include <stdio.h>
#include <string>
class LTexture;
#include "LTexture.h"
class Engine;
#include "Engine.h"
int main( int argc, char* args[] )
{
    Engine start;
    return 0;
}

引擎.h 文件：

#ifndef ENGINE_H
#define ENGINE_H
#include "LTexture.h"
#include "v.h"
#include <SDL.h>
#include <SDL_image.h>
#include <stdio.h>
#include <string>
class Engine: public v
{
    public:
        Engine();
        ~Engine();
        bool init();
        bool loadMedia();
        void close();
        //LTexture gFooTexture;
        LTexture gBackgroundTexture;
};
#endif // ENGINE_H

引擎.cpp文件：

#include "Engine.h"
#include <SDL.h>
#include <SDL_image.h>
#include <stdio.h>
#include <string>
Engine::Engine()
{
    if( !init() )
    {
        printf( "Failed to initialize!n" );
    }
    else
    {
        if( !loadMedia() )
        {
            printf( "Failed to load media!n" );
        }
        else
        {
            bool quit = false;
            SDL_Event e;
            while( !quit )
            {
                while( SDL_PollEvent( &e ) != 0 )
                {
                    if( e.type == SDL_QUIT )
                    {
                        quit = true;
                    }
                }
                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                SDL_RenderClear( gRenderer );
                gBackgroundTexture.render( 0, 0 );
                gFooTexture.render( 240, 190 );
                SDL_RenderPresent( gRenderer );
            }
        }
    }
}
Engine::~Engine()
{
    close();
}
bool Engine::init()
{
    bool success = true;
    if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "SDL could not initialize! SDL Error: %sn", SDL_GetError() );
        success = false;
    }
    else
    {
        if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
        {
            printf( "Warning: Linear texture filtering not enabled!" );
        }
        gWindow = SDL_CreateWindow( "SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
        if( gWindow == NULL )
        {
            printf( "Window could not be created! SDL Error: %sn", SDL_GetError() );
            success = false;
        }
        else
        {
            gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED );
            if( gRenderer == NULL )
            {
                printf( "Renderer could not be created! SDL Error: %sn", SDL_GetError() );
                success = false;
            }
            else
            {
                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                int imgFlags = IMG_INIT_PNG;
                if( !( IMG_Init( imgFlags ) & imgFlags ) )
                {
                    printf( "SDL_image could not initialize! SDL_image Error: %sn", IMG_GetError() );
                    success = false;
                }
            }
        }
    }
    return success;
}
bool Engine::loadMedia()
{
    bool success = true;
    if( !gFooTexture.loadFromFile( "Textures/foo.png" ) )
    {
        printf( "Failed to load Foo' texture image!n" );
        success = false;
    }
    if( !gBackgroundTexture.loadFromFile( "Textures/background.png" ) )
    {
        printf( "Failed to load background texture image!n" );
        success = false;
    }
    return success;
}
void Engine::close()
{
    gFooTexture.freeup();
    gBackgroundTexture.freeup();
    SDL_DestroyRenderer( gRenderer );
    SDL_DestroyWindow( gWindow );
    gWindow = NULL;
    gRenderer = NULL;
    IMG_Quit();
    SDL_Quit();
}

LTexture.h 文件：

#ifndef LTEXTURE_H
#define LTEXTURE_H
#include "v.h"
#include <SDL.h>
#include <SDL_image.h>
#include <stdio.h>
#include <string>
class LTexture: public v
{
public:
    LTexture();
    ~LTexture();
    bool loadFromFile( std::string path );
    void freeup();
    void render( int x, int y );
    int getWidth();
    int getHeight();
private:
    SDL_Texture* mTexture;
    int mWidth;
    int mHeight;
};
#endif // LTEXTURE_H

LTexture.cpp file：

#include "LTexture.h"
#include <SDL.h>
#include <SDL_image.h>
#include <stdio.h>
#include <string>
LTexture::LTexture()
{
    mTexture = NULL;
    mWidth = 0;
    mHeight = 0;
}
LTexture::~LTexture()
{
    freeup();
}
bool LTexture::loadFromFile( std::string path )
{
    freeup();
    SDL_Texture* newTexture = NULL;
    SDL_Surface* loadedSurface = IMG_Load( path.c_str() );
    if( loadedSurface == NULL )
    {
        printf( "Unable to load image %s! SDL_image Error: %sn", path.c_str(), IMG_GetError() );
    }
    else
    {
        SDL_SetColorKey( loadedSurface, SDL_TRUE, SDL_MapRGB( loadedSurface->format, 0, 0xFF, 0xFF ) );
        newTexture = SDL_CreateTextureFromSurface( gRenderer, loadedSurface );
        if( newTexture == NULL )
        {
            printf( "Unable to create texture from %s! SDL Error: %sn", path.c_str(), SDL_GetError() );
        }
        else
        {
            mWidth = loadedSurface->w;
            mHeight = loadedSurface->h;
        }
        SDL_FreeSurface( loadedSurface );
    }
    mTexture = newTexture;
    return mTexture != NULL;
}
void LTexture::freeup()
{
    if( mTexture != NULL )
    {
        SDL_DestroyTexture( mTexture );
        mTexture = NULL;
        mWidth = 0;
        mHeight = 0;
    }
}
void LTexture::render( int x, int y )
{
    SDL_Rect renderQuad = { x, y, mWidth, mHeight };
    SDL_RenderCopy( gRenderer, mTexture, NULL, &renderQuad );
}
int LTexture::getWidth()
{
    return mWidth;
}
int LTexture::getHeight()
{
    return mHeight;
}

V.H 文件：

#ifndef V_H
#define V_H
#include <SDL.h>
#include <SDL_image.h>
#include <stdio.h>
#include <string>
class v
{
    public:
        v();
        ~v();
        const int SCREEN_WIDTH = 640;
        const int SCREEN_HEIGHT = 480;
        SDL_Window* gWindow = NULL;
        SDL_Renderer* gRenderer = NULL;
};
#endif // V_H

v.cpp文件：

#include "v.h"
v::v()
{
    //ctor
}
v::~v()
{
    //dtor
}

Answer 1

你的问题实际上在一个词内——"类"。您将渲染器存储在基类中，但从不初始化LTexture v部分，因此对于纹理gRenderer是NULL，这实际上是无效的渲染器。