自学教程：C++ IMG_Init函数代码示例

bool init() {	bool success = true;	if (SDL_Init( SDL_INIT_VIDEO | SDL_INIT_AUDIO ) < 0) {		printf( "SDL could not initialize! SDL Error: %s/n", SDL_GetError() );		success = false;	}	else	{		if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )		{			printf( "Warning: Linear texture filtering not enabled!" );		}		gWindow = SDL_CreateWindow( "Mahjong", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );		if( gWindow == NULL )		{			printf( "Window could not be created! SDL Error: %s/n", SDL_GetError() );			success = false;		}		else		{			gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC );			if( gRenderer == NULL )			{				printf( "Renderer could not be created! SDL Error: %s/n", 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: %s/n", IMG_GetError() );					success = false;				}				if( TTF_Init() == -1 )				{					printf( "SDL_ttf could not initialize! SDL_ttf Error: %s/n", TTF_GetError() );					success = false;				}				if( Mix_OpenAudio( 44100, MIX_DEFAULT_FORMAT, 2, 2048 ) < 0 )				{					printf( "SDL_mixer could not initialize! SDL_mixer Error: %s/n", Mix_GetError() );					success = false;				}			}		}	}	return success;}

// Create window and renderer.//Return -1 if it fails.int Renderer::SDLinit(){    sdlwindow = NULL;    screensurface = NULL;    int window_width = 1280;    int window_height = 720;    //Initialize SDL    if( SDL_Init( SDL_INIT_VIDEO ) < 0 )    {        printf( "SDL could not initialize! SDL_Error: %s/n", SDL_GetError() );        return -1;    } else {        //Create window        sdlwindow = SDL_CreateWindow( "SDL Window", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, window_width, window_height, SDL_WINDOW_SHOWN );        if( sdlwindow == NULL )        {            printf( "Window could not be created! SDL_Error: %s/n", SDL_GetError() );            return -1;        } else {            //Get window surface            screensurface = SDL_GetWindowSurface( sdlwindow );            //Create renderer for window            gRenderer = SDL_CreateRenderer( sdlwindow, -1, SDL_RENDERER_ACCELERATED );            if( gRenderer == NULL )            {                printf( "Renderer could not be created! SDL Error: %s/n", SDL_GetError() );                return -1;            } else {                //Initialize renderer color                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );                //Initialize PNG loading                int imgFlags = IMG_INIT_PNG;                if( !( IMG_Init( imgFlags ) & imgFlags ) )                {                    printf( "SDL_image could not initialize! SDL_image Error: %s/n", IMG_GetError() );                    return -1;                }            }        }    }    return 0;}

intinit_sdl(void){	int flags;	/* initialize SDL */	if (SDL_Init(SDL_INIT_VIDEO) == -1) {		fprintf(stderr, "SDL could not initialize! SDL Error: %s/n",			SDL_GetError());		return -1;	}	/* set texture filtering to linear */	if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1"))		fprintf(stderr,			"Warning: Linear texture filtering not enabled!/n");	/* create window */	gWindow = SDL_CreateWindow("SDL Tutorial",			SDL_WINDOWPOS_UNDEFINED,			SDL_WINDOWPOS_UNDEFINED,			SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);	if (gWindow == NULL) {		fprintf(stderr, "window could not be created! SDL Error: %s/n",			SDL_GetError());		return -1;	}	/* create renderer for window */	gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED);	if (gRenderer == NULL) {		fprintf(stderr, "Renderer could not be created! "			"SDL Error: %s/n", SDL_GetError());		return -1;	} else {		/* initialize renderer color */		SDL_SetRenderDrawColor(gRenderer, 0xFF, 0xFF, 0xFF, 0xFF);		/* initialize PNG loading */		flags = IMG_INIT_PNG;		if ((IMG_Init(flags) & flags) == 0) {			fprintf(stderr, "SDL_image could not initialize! "				"SDL_image Error: %s/n", IMG_GetError());			return -1;		}	}	return 0;}

void init(){    SDL_Init(SDL_INIT_VIDEO);    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1");        gWindow = SDL_CreateWindow("batman 1", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);        gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);        batman = new Batman(gRenderer);        SDL_SetRenderDrawColor(gRenderer, 0xFF, 0xFF, 0xFF, 0xFF);        IMG_Init(IMG_INIT_PNG);    }

void GraphicsSDL::init_sdl_img(){    // init SDL_image    int img_flags = IMG_INIT_JPG | IMG_INIT_PNG;    if ((IMG_Init(img_flags) & img_flags) != img_flags) {        printf("[gfx] SDL_image error: %s/n", IMG_GetError());        throw E_INIT_SDL_IMG;    }    // TODO: Remove guards when IMG gets properly supported by Emscripten#ifndef __EMSCRIPTEN__    atexit(IMG_Quit);    print_sdl_img_version();#endif}

bool ModuleTextures::init() {	LOG("init Image library");	bool ret = true;	// load support for the PNG image format	int flags = IMG_INIT_PNG;	int init = IMG_Init(flags);	if ((init & flags) != flags) {		LOG("Could not initialize Image lib. IMG_init: %s", IMG_GetError());		ret = false;	}	return ret;}

//create SDL window and allow for png loadingvoid Game::Start(){    assert( SDL_Init( SDL_INIT_EVERYTHING ) >= 0 );    mWindow = SDL_CreateWindow( "Shmup", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,				SCREEN_HEIGHT, SDL_WINDOW_SHOWN );    assert( mWindow );    mRenderer = SDL_CreateRenderer( mWindow, -1, SDL_RENDERER_ACCELERATED );    assert( mRenderer );    int imgFlags = IMG_INIT_PNG;    assert( IMG_Init( imgFlags ) & imgFlags );    SDL_SetRenderDrawColor( mRenderer, 0x00, 0x00, 0x00, 0xFF );}

void Init() {	bool success = true;	SDL_Init(SDL_INIT_VIDEO);	window = SDL_CreateWindow("Tamagochi", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,		SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);	//Initialize PNG loading	int imgFlags = IMG_INIT_PNG;	if (!(IMG_Init(imgFlags) & imgFlags))	{		printf("SDL_image could not initialize! SDL_image Error: %s/n", IMG_GetError());		success = false;	}}

GraphicsSystem::GraphicsSystem(EntityManager *em, int window_width, int window_height){	_window = SDL_CreateWindow("Objectless", SDL_WINDOWPOS_UNDEFINED,		SDL_WINDOWPOS_UNDEFINED, window_width, window_height, SDL_WINDOW_SHOWN);	_renderer = SDL_CreateRenderer(_window, -1, SDL_RENDERER_ACCELERATED |		SDL_RENDERER_PRESENTVSYNC);	_entitymanager = em;	// Initialize the flags for image lib	if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) {		assert2(false, "IMG_Init failed!! %s", SDL_GetError());		exit(0);	}}

void CResourceManager::StartUp(void){	//SDL_Image	if ( !IMG_Init(IMG_INIT_PNG) )	{		CCoreEngine::Instance().GetLogManager().LogOutput( LOG_INFO, LOGSUB_RESOURCES,"Starting Up! (FAILED LOADING SDL_Image)");	}	else	{		CCoreEngine::Instance().GetLogManager().LogOutput( LOG_INFO, LOGSUB_RESOURCES,"Starting Up! SDL_Image Loaded!");	}	LoadTextures();	LoadAudio();}

int Saloon::init(const char* title, int width, int height, bool windowed, int x, int y) {	if (SDL_Init(SDL_INIT_EVERYTHING) != 0){		logSDLError(std::cout, "SDL_Init");		return 1;	}	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);	SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32);	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);	// Slight optimization to prepare the PNG loader prior to loading any images	if ((IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG) != IMG_INIT_PNG){		logSDLError(std::cout, "IMG_Init");		return 1;	}	if (TTF_Init() != 0){		logSDLError(std::cout, "TTF_Init");		return 1;	}	if(windowed) {		_window = SDL_CreateWindow(title, x, y, width, height,				SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);	}	else {		_window = SDL_CreateWindow(title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,				width, height,				SDL_WINDOW_FULLSCREEN | SDL_WINDOW_OPENGL);	}	if (_window == nullptr){		logSDLError(std::cout, "CreateWindow");		return 2;	}	_displayWidth = width;	_displayHeight = height;	_halfDisplayWidth = width/2.0f;	_halfDisplayHeight = height/2.0f;	return 0;}

bool BackBuffer::Initialise(int width, int height){	m_width = width;	m_height = height;	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0)	{		LogSDLError();		return (false);	}	else	{		m_pWindow = SDL_CreateWindow("717130 Game Framework", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, SDL_WINDOW_SHOWN);		if (m_pWindow == 0)		{			LogSDLError();			return (false);		}		else		{			m_pRenderer = SDL_CreateRenderer(m_pWindow, -1, SDL_RENDERER_ACCELERATED); 			if (m_pRenderer == 0)			{				LogSDLError();				return (false);			}			else			{				int imageResult = IMG_Init(IMG_INIT_PNG);				if (imageResult == 0)				{					LogSDLError();					return (false);				}			}		}	}	m_pTextureManager = new TextureManager();	assert(m_pTextureManager);	m_pTextureManager->Initialise(m_pRenderer);	return (true);}

bool init() {  bool l_success = true;    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {    printf("SDL could not initialize! SDL Error: %s/n",	   SDL_GetError());    l_success = false;  } else {    if(!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {      printf("Warning: Linear texture filtering not enabled");    }      //Create window    g_window = SDL_CreateWindow("SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, 				SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,				SCREEN_HEIGHT, SDL_WINDOW_SHOWN);      if(g_window == NULL) {      printf("Window could not be created! SDL Error: %s/n",	     SDL_GetError());      l_success = false;    } else {      //Creates vsynced renderer for window      g_renderer = SDL_CreateRenderer(g_window, -1,				      SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);      if(g_renderer == NULL) {	printf("Renderer could not be created! SDL Error:%s/n",	       SDL_GetError());	l_success = false;      } else {	SDL_SetRenderDrawColor(g_renderer, 0xFF, 0xFF, 0xFF, 0xFF);	//Initialize PNG loading	int imgFlags = IMG_INIT_PNG;	if(!(IMG_Init(imgFlags) & imgFlags)) {	  printf("SDL_image could not initialize! SDL_image Error: %s/n",		 IMG_GetError());	  l_success = false;	}		//Initialize SDL_mixer	if(Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0) {	  printf("SDL_mixer could not initialize! SDL_mixer Error: %s/n", Mix_GetError());	}      }    }  }  return l_success;}

// Called before render is availablebool Textures::awake(pugi::xml_node &node){	LOG("Init Image library");	bool ret = true;	// load support for the PNG image format	int flags = IMG_INIT_PNG;	int init = IMG_Init(flags);	if((init & flags) != flags)	{		LOG("Could not initialize Image lib. IMG_Init: %s", IMG_GetError());		ret = false;	}	return ret;}

void sdl_init(uint32_t sdl_flags, int img_flags){    sp_logger = common::logging_get_logger("sdlwrap");    sp_logger->info("Initializing SDL");    auto result = SDL_Init(sdl_flags);    if (result){        sdl_throw_error("SDL_Init");    }    sp_logger->info("Initializing SDL image");    result = IMG_Init(img_flags);    if (result != img_flags){        sdl_img_throw_error("IMG_Init");    }}

int main (int argc, char** argv){	//init libraries at the top level to avoid game system dependencies and because I'm using SDL_main anyway	SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);	IMG_Init(IMG_INIT_PNG);	Game game;	game.run();	game.destroy();	//stop libraries	IMG_Quit();	SDL_Quit();	return 0;}

void Game::Init(){    int ret;    ret = SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO);    assert(ret >= 0);    window = SDL_CreateWindow("Chinese Chess", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Config::SCREEN_WIDTH, Config::SCREEN_HEIGHT, SDL_WINDOW_SHOWN);    assert(window != NULL);    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);    assert(renderer != NULL);    SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);    int imgFlags = IMG_INIT_PNG;    ret = IMG_Init(imgFlags) & imgFlags;    assert(ret);    ret = TTF_Init();    assert(ret != -1);}

// Called before render is availablebool j1Textures::Awake(j1IniReader* conf){	LOG("Init Image library");	bool ret = true;	// load support for the PNG image format	int flags = IMG_INIT_PNG;	int init = IMG_Init(flags);	if((init & flags) != flags)	{		LOG("Could not initialize Image lib. IMG_Init: %s", IMG_GetError());		ret = false;	}	return ret;}

int SGL_Init(void){	int error = SDL_Init(SDL_INIT_EVERYTHING);	if(error != 0)	{		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, SDL_GetError());		return error;	}	error = IMG_Init(IMG_INIT_PNG);	if (error == 0)	{		SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, SDL_GetError());		return error;	}	return 0;}

int init_SDL_all(){    SDL_Init(SDL_INIT_VIDEO);              // Initialize SDL2    //init image loader    if ((IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG) != IMG_INIT_PNG){	    logSDLError("IMG_Init");	    return 1;    }    if (TTF_Init() != 0){	    logSDLError("TTF_Init");	    return 1;    }    return 0;}

bool init(){	bool success = true;	// Attempt to initialize SDL, log error on failure	if (SDL_Init(SDL_INIT_VIDEO) < 0)	{		// Oops, something happened with SDL		std::cout << "Cannot initalize SDL. Reason: " << SDL_GetError() << std::endl;		success = false;	}	else	{		// We've made it this far, so let's create the main window		window = SDL_CreateWindow("SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,	screen_width, screen_height, SDL_WINDOW_SHOWN);		if (window == nullptr)		{			// No window, so log the reason why and get out of here			std::cout << "Cannot create window. Reason: " << SDL_GetError() << std::endl;			success = false;		}		else		{			// Now create the window's renderer			renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);			if (renderer == nullptr)			{				std::cout << "Cannot create renderer. Reason: " << SDL_GetError() << std::endl;				success = false;			}			else			{				// Set the rendering color to opaque plain white.				SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);				// Now initalize the image library for PNG loading				int imgFlags = IMG_INIT_PNG;				if (!(IMG_Init(imgFlags) & imgFlags))				{					std::cout << "Cannot load image library. Reason: " << IMG_GetError() << std::endl;					success = false;				}			}		}	}	return success;}

void RenderHelper::Init(){    m_cWindow = nullptr;    m_cWindow = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_SHOWN);    if( m_cWindow == nullptr )    {        logger.LogError( std::string("SDL_CreateWindow: ") + SDL_GetError() );        return 2;    }    else    {        logger.Log("SDL_CreateWindow was successful");    }    m_cRenderer = nullptr;    m_cRenderer = SDL_CreateRenderer(m_cWindow, -1, SDL_RENDERER_PRESENTVSYNC);    if( m_cRenderer == nullptr )    {        logger.LogError( std::string("SDL_CreateRenderer: ") + SDL_GetError() );        return 3;    }    else    {        logger.Log("SDL_CreateRenderer was successful");    }    int img_flags = IMG_INIT_JPG|IMG_INIT_PNG;    if ((IMG_Init(img_flags) != img_flags))    {        logger.LogError("IMG_Init failed to init jpeg with error "  + std::string(SDL_GetError()) );        return 4;    }    else    {        logger.Log("IMG_Init was successful!");    }    if (TTF_Init() == -1)    {        logger.LogError("TTF_Init Failed with error: "  + std::string(TTF_GetError()) );        return 5;    }    else    {        logger.Log("TTF_Init was successful!");    }}

SDLRenderer::SDLRenderer() {    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_EVENTS) != 0) {        Log::error(_("SDL could not be initialized: %s"), SDL_GetError());        return;    }    atexit(SDL_Quit);    Log::info(_("SDL initialized."));    SDL_Surface* surfaceAppIcon = IMG_Load("data/img/appicon.png");    if (surfaceAppIcon == nullptr) {        Log::error(_("Could not load graphic 'data/img/appicon.png': %s"), SDL_GetError());        return;    }    window = SDL_CreateWindow(         "OpenIsles", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_HIDDEN);    if (window == nullptr) {        Log::error(_("SDL could not create window: %s"), SDL_GetError());        return;    }    SDL_SetWindowIcon(window, surfaceAppIcon);    SDL_FreeSurface(surfaceAppIcon);    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);    if (renderer == nullptr) {        Log::error(_("SDL could not create renderer: %s"), SDL_GetError());        SDL_DestroyWindow(window);        return;    }    offscreenTexture = SDL_CreateTexture(         renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, WINDOW_WIDTH, WINDOW_HEIGHT);    if ((IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG) != IMG_INIT_PNG) {        Log::error(_("Could not init SDL-image: %s"), IMG_GetError());        return;    }    atexit(IMG_Quit);    if (TTF_Init() != 0) {        Log::error(_("Could not init SDL-TTF: %s"), TTF_GetError());        return;    }    atexit(TTF_Quit);}

SDL_Window *initSDL(options *opt, int *success){	SDL_Window *temp;	int SDL_Flags, IMG_Flags;	SDL_Flags = SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_AUDIO;	IMG_Flags = IMG_INIT_JPG | IMG_INIT_PNG;	if(SDL_Init(SDL_Flags) < 0)	{		fprintf(stderr, "SDL_Init has failed : %s /n", SDL_GetError());		*success = FAIL;		return NULL;	}	if(TTF_Init() != 0)	{		fprintf(stderr, "TFF_Init has failed : %s /n", TTF_GetError());		*success = FAIL;		return NULL;	}	if(!(IMG_Init(IMG_Flags) & IMG_Flags))	{		fprintf(stderr, "IMG_Init has failed, %s /n", IMG_GetError());		*success = FAIL;		return NULL;		}	if(Mix_OpenAudio(opt->SAMPLE_FREQUENCY, MIX_DEFAULT_FORMAT, opt->NO_CHANNELS, opt->SAMPLE_SIZE) < 0)//first arg : frequency of audio, second arg : format, third arg : Number of audio channels, forth arg : sample size	{		fprintf(stderr, "Mix_OpenAudio has failed, %s /n", Mix_GetError());		*success = FAIL;		return NULL;		}	temp = SDL_CreateWindow(opt->title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, opt->SCREEN_WIDTH, opt->SCREEN_HEIGHT, SDL_WINDOW_SHOWN);	if(!temp)	{		fprintf(stderr, "SDL_CreateWindow has failed : %s /n");		*success = FAIL;		return NULL;		}		return temp;}

SDL_Setup::SDL_Setup(const int width, const int height) 	: SCREEN_WIDTH(width), SCREEN_HEIGHT(height){	e = new SDL_Event();	if (SDL_Init(SDL_INIT_VIDEO) < 0)	{		std::printf("/nUnable to initialize SDL:  %s/n", SDL_GetError());	}	else		if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1"))		{			std::printf("Warning: Linear texture filtering not enabled!");		}	//Create Window	gWindow = SDL_CreateWindow("Game Prototype", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 								SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);	if (gWindow == NULL)	{		std::printf("Window failed to initialize! SDL Error: %s/n", SDL_GetError());	}	else	{		//Create renderer		gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED);		if (gRenderer == NULL)		{			printf("Renderer failed to initialize! SDL Error: %s/n", SDL_GetError());		}		else		{			//Sets resolution for all platforms (letter boxing)			SDL_RenderGetLogicalSize(gRenderer, &resWidth, &resHeight);			//Intitialize render color			SDL_SetRenderDrawColor(gRenderer, 0xFF, 0xFF, 0xFF, 0xFF);			//Initialize PNG loading 			int imgFlags = IMG_INIT_PNG;			if (!(IMG_Init(imgFlags) & imgFlags))			{				printf("SDL_image could not initialize! SDL_image Error: %s/n", IMG_GetError());			}		}	}}

int engine_init(SDL_Window** window, SDL_Renderer** renderer, Resources** resources){	int flags;//{ region init		flags = SDL_INIT_EVERYTHING;	if(SDL_Init(flags) != 0)	{		LOG("SDL init error: %s", SDL_GetError());		return 1;	}	flags = IMG_INIT_PNG;	if(IMG_Init(flags) & flags != flags)	{		LOG("IMG init error: %s", IMG_GetError());		return 1;	}	if(TTF_Init() != 0)	{		LOG("TTF init error %s", TTF_GetError());		return 1;	}//}	random_init();		(*window) = SDL_CreateWindow("Lines",		SDL_WINDOWPOS_UNDEFINED,		SDL_WINDOWPOS_UNDEFINED,		SCREEN_WIDTH,		SCREEN_HEIGHT,		SDL_WINDOW_SHOWN);	if((*window) == NULL)	{		LOG("Window could not be created! SDL_Error: %s/n", SDL_GetError());		return 1;	}		(*renderer) = SDL_CreateRenderer((*window),-1,SDL_RENDERER_ACCELERATED);	if((*renderer) == NULL)	{		LOG("Renderer could not be created! SDL Error: %s/n", SDL_GetError() );		return 1;	}		(*resources) = loadMedia(*renderer);	return 0;}

bool init() {  //Initialization flag  bool success = true;  //Initialize SDL  if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {    printf( "SDL could not initialize! SDL Error: %s/n", SDL_GetError() );    success = false;  } else {    //Set texture filtering to linear    if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) ) {      printf( "Warning: Linear texture filtering not enabled!" );    }    //Create window    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: %s/n", SDL_GetError() );      success = false;    } else {      //Create vsynced renderer for window      gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC );      if( gRenderer == NULL ) {        printf( "Renderer could not be created! SDL Error: %s/n", SDL_GetError() );        success = false;      } else {        //Initialize renderer color        SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );        //Initialize PNG loading        int imgFlags = IMG_INIT_PNG;        if( !( IMG_Init( imgFlags ) & imgFlags ) ) {          printf( "SDL_image could not initialize! SDL_image Error: %s/n", IMG_GetError() );          success = false;        }        //Initialize SDL_ttf        if( TTF_Init() == -1 ) {          printf( "SDL_ttf could not initialize! SDL_ttf Error: %s/n", TTF_GetError() );          success = false;        }      }    }  }  return success;}

bool init(){    bool working = true;    if(SDL_Init(SDL_INIT_VIDEO))    {        cout << "/nSDL Video Subsystem failed. ERROR: " << SDL_GetError();        working = false;    }    else    {        mainWindow = SDL_CreateWindow("Space Invaders v1.2.5", ((1920 - gameWidth) / 2), ((1080 - gameHeight) / 2), gameWidth, gameHeight, SDL_WINDOW_SHOWN);        if(!mainWindow)        {            cout << "/nFailed to create main game window. ERROR: " << SDL_GetError();            working = false;        }        else        {            mainRenderer = SDL_CreateRenderer(mainWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);            if(!mainRenderer)            {                cout << "/nFailed to initialize renderer. ERROR: " << SDL_GetError();                working = false;            }            else            {                SDL_SetRenderDrawColor(mainRenderer, 0xFF, 0xFF, 0xFF, 0xFF);                int imgFlags = IMG_INIT_PNG;                if(!(IMG_Init(imgFlags) & imgFlags))                {                    cout << "/nSDL_image PNG module failed to initialize.Error: " << IMG_GetError();                    working = false;                }                if(TTF_Init() == -1)                {                    cout << "SDL_ttf could not initialize! SDL_ttf Error: " << TTF_GetError();                    working = false;                }            }        }    }    return working;}

//A function that runs when the game starts to initialize thingsbool Initialize(){	//Initiate SDL Video and checks if there is an error	if (SDL_Init(SDL_INIT_EVERYTHING) < 0)	{		printf("SDL could not be initialized! SDL_Error: %s/n", SDL_GetError());		Sleep(1000);		return false;	}	//Create the window	window = SDL_CreateWindow("Leikurinn Minn",		SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,		SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);	//Checks if there is an error when creating the window	if (window == NULL)	{		printf("Window could not be created! SDL_Error: %s/n", SDL_GetError());		Sleep(1000);		return false;	}	//Create the renderer and if there is an error it will display	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);	if (renderer == NULL)	{		printf("We were not able to create the renderer! SDL Error %s/n", SDL_GetError());		return false;	}	if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)	{		cout << "SDL Mixer Error!" << endl;	}	SDL_SetRenderDrawColor(renderer, 144, 195, 212, 255);		int imgFlags = IMG_INIT_PNG;	if (!(IMG_Init(imgFlags) & imgFlags))	{		return false;	}	return true;}

bool WindowManagerSdl::initialiseSDL(){        if (SDL_Init(SDL_INIT_VIDEO) == -1)        {                std::cerr << "Failed to initialise SDL" << std::endl;                return false;        }        int flags = IMG_INIT_PNG;        if ((IMG_Init(flags) & flags) == -1)        {                std::cerr << "Failed to initialise SDL_image" << std::endl;                return false;        }        return true;}