Esempio n. 1
0
/**
 * Initialize SDL
 *
 * @param int rows the number of rows that will be displayed
 * @param int cols the number of columns that will be displayed
 * @param int i the time interval in milliseconds after which the next
 * generation is drawn
 * @param ConwaysGameOfLife *cgol pointer to the object that encapsulates the
 * game's actual logic
 * @param positions_t positions the first generation of cells to be displayed
 *
 * @throws SDLException if SDL coudn't be initialized
 *
 * @see{
 *  game::getWindowSize
 * }
 *
 * TODO: allow the user to draw his own pattern using the mouse at the start
 * A nice feature for this would be to highlight the cell under the and only
 * set it if the user clicks on it
 */
Game::Game(int rows, int cols, unsigned int i, SDL_Color acolor,
           SDL_Color dcolor, ConwaysGameOfLife *cgol, positions_t pos)
        : no_rows(rows), no_columns(cols), interval(i), life(cgol){

    if(SDL_Init(SDL_INIT_VIDEO) < 0){
        throw SDLException("Couldn't initialize SDL!");
    }

    const SDL_VideoInfo* vinfo = SDL_GetVideoInfo();

    unsigned int length = std::min(vinfo->current_w, vinfo->current_h) - 50;
    setCellSideLength(length);

    SDL_Rect size = getWindowSize(length);

    screen = SDL_SetVideoMode(size.w, size.h, vinfo->vfmt->BitsPerPixel, flags);

    if(screen == nullptr){
        throw SDLException("Couldn't set SDL video mode!");
    }

    alive_color = SDL_MapRGB(vinfo->vfmt, acolor.r, acolor.g, acolor.b);
    dead_color = SDL_MapRGB(vinfo->vfmt, dcolor.r, dcolor.g, dcolor.b);

    std::vector<SDL_Rect> rects = setCells(pos, alive_color);

    SDL_UpdateRects(screen, rects.size(), rects.data());

    running = true;
}
Esempio n. 2
0
	Image* RenderBackendSDL::createMainScreen(unsigned int width, unsigned int height, unsigned char bitsPerPixel, bool fs, const std::string& title, const std::string& icon) {
		Uint32 flags = 0;
		if (fs) {
			flags |= SDL_FULLSCREEN;
		}

		if(icon != "") {
			SDL_Surface *img = IMG_Load(icon.c_str());
			if(img != NULL) {
				SDL_WM_SetIcon(img, 0);
			}
		}

		SDL_Surface* screen = NULL;

		if( 0 == bitsPerPixel ) {
			/// autodetect best mode
			unsigned char possibleBitsPerPixel[] = {16, 24, 32, 0};
			int i = 0;
			while( true ) {
				bitsPerPixel = possibleBitsPerPixel[i];
				if( !bitsPerPixel ) {
					// Last try, sometimes VideoModeOK seems to lie.
					// Try bpp=0
					screen = SDL_SetVideoMode(width, height, bitsPerPixel, flags);
					if( !screen ) {
						throw SDLException("Videomode not available");
					}
					break;
				}
				bitsPerPixel = SDL_VideoModeOK(width, height, bitsPerPixel, flags);
				if ( bitsPerPixel ) {
					screen = SDL_SetVideoMode(width, height, bitsPerPixel, flags);
					if( screen ) {
						break;
					}
				}
				++i;
			}
		} else {
			if ( !SDL_VideoModeOK(width, height, bitsPerPixel, flags) ) {
				throw SDLException("Videomode not available");
			}
			screen = SDL_SetVideoMode(width, height, bitsPerPixel, flags);
		}
		FL_LOG(_log, LMsg("RenderBackendSDL")
			<< "Videomode " << width << "x" << height
			<< " at " << int(screen->format->BitsPerPixel) << " bpp");

		SDL_WM_SetCaption(title.c_str(), NULL);

		if (!screen) {
			throw SDLException(SDL_GetError());
		}

		m_screen = new SDLImage(screen);
		return m_screen;
	}
Esempio n. 3
0
	void ImageLoader::load(IResource* res) {
		VFS* vfs = VFS::instance();

		Image* img = dynamic_cast<Image*>(res);

		//Have to save the images x and y shift or it gets lost when it's
		//loaded again.
		int32_t xShiftSave = img->getXShift();
		int32_t yShiftSave = img->getYShift();

		if(!img->isSharedImage()) {
			const std::string& filename = img->getName();
			boost::scoped_ptr<RawData> data (vfs->open(filename));
			size_t datalen = data->getDataLength();
			boost::scoped_array<uint8_t> darray(new uint8_t[datalen]);
			data->readInto(darray.get(), datalen);
			SDL_RWops* rwops = SDL_RWFromConstMem(darray.get(), static_cast<int>(datalen));

			SDL_Surface* surface = IMG_Load_RW(rwops, false);

			if (!surface) {
				throw SDLException(std::string("Fatal Error when loading image into a SDL_Surface: ") + SDL_GetError());
			}

			RenderBackend* rb = RenderBackend::instance();
			// in case of SDL we don't need to convert the surface
			if (rb->getName() == "SDL") {
				img->setSurface(surface);
			// in case of OpenGL we need a 32bit surface
			} else {
				SDL_PixelFormat dst_format = rb->getPixelFormat();
				SDL_PixelFormat src_format = *surface->format;
				uint8_t dstbits = dst_format.BitsPerPixel;
				uint8_t srcbits = src_format.BitsPerPixel;

				if (srcbits != 32 || dst_format.Rmask != src_format.Rmask || dst_format.Gmask != src_format.Gmask ||
					dst_format.Bmask != src_format.Bmask || dst_format.Amask != src_format.Amask) {
					dst_format.BitsPerPixel = 32;
					SDL_Surface* conv = SDL_ConvertSurface(surface, &dst_format, 0);
					dst_format.BitsPerPixel = dstbits;

					if (!conv) {
						throw SDLException(std::string("Fatal Error when converting surface to the screen format: ") + SDL_GetError());
					}

					img->setSurface(conv);
					SDL_FreeSurface(surface);
				} else {
					img->setSurface(surface);
				}
			}

			SDL_FreeRW(rwops);
		}
		//restore saved x and y shifts
		img->setXShift(xShiftSave);
		img->setYShift(yShiftSave);
	}
Esempio n. 4
0
void Application::InitializeSDLSystem() {
	if (SDL_Init(SDL_INIT_EVERYTHING) < 0) {
		throw SDLException();
	}

	if (SDL_EnableKeyRepeat(1, SDL_DEFAULT_REPEAT_INTERVAL / 3) == -1) {
		throw SDLException();
	}
}
Esempio n. 5
0
SDL::SDL() {
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
        throw SDLException(SDL_GetError(), HERE);

    LOG4CXX_INFO(m_logger, "SDL initialized.");

    if (TTF_Init() < 0)
        throw SDLException(SDL_GetError(), HERE);

    LOG4CXX_INFO(m_logger, "SDL_ttf initialized.");
}
Esempio n. 6
0
    void Canvas::init()
    {
        Uint32 sdlFlags = SDL_HWSURFACE | SDL_DOUBLEBUF;



        if(isFullscreen) sdlFlags |= SDL_FULLSCREEN;

        if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
            throw SDLException("SDL init failed");

        if((canvas = SDL_SetVideoMode(width, height, 32, sdlFlags)) == NULL)
            throw SDLException("Screen initialization failed");
    }
Esempio n. 7
0
void SoundProcessor::initSoundEngine()
{
	// TODO start a 'watchdog' thread (FMOD waits indefinitely if the sound is currently used!)
	toInfoLog(TextStorage::instance().get(IDS::START_INIT_SOUND_TEXT_ID)->getText());

#ifdef _FMOD_SOUND
	unsigned int version;

	if(!ERRCHECK(FMOD::System_Create(&soundEngine))) { 
		throw SDLException(TextStorage::instance().get(IDS::START_INIT_FMOD_SYSTEM_CREATE_ERROR_TEXT_ID)->getText());
	}

	BOOST_ASSERT(soundEngine);
	if(!ERRCHECK(soundEngine->getVersion(&version))) {
		throw SDLException(TextStorage::instance().get(IDS::START_INIT_FMOD_GET_VERSION_ERROR_TEXT_ID)->getText());
	}

	if (version < FMOD_VERSION)
	{
		std::ostringstream os;
		os << TextStorage::instance().get(IDS::START_INIT_FMOD_VERSION_ERROR_TEXT_ID)->getText() << "[" << version << " < " << FMOD_VERSION << "]";
		throw SDLException(os.str());
	}

	printSoundInformation();

	if(!ERRCHECK(soundEngine->init(32, FMOD_INIT_NORMAL, 0))) {
		throw SDLException(TextStorage::instance().get(IDS::START_INIT_FMOD_SYSTEM_INIT_ERROR_TEXT_ID)->getText());
	}
#elif _SDL_MIXER_SOUND
	if(Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048)==-1) 
	{
		std::ostringstream os;
		os << "ERROR (SoundProcessor::initSoundEngine()): " << Mix_GetError();
		throw SDLException(os.str());
	}		
	Mix_ChannelFinished(::soundChannelDone);
	
	/*
	int flags = MIX_INIT_MP3; // TODO MOD!
	int initted = Mix_Init(flags);
	if(initted&flags != flags) {
		std::ostringstream os;
		os << "ERROR (SoundProcessor::initSoundEngine()): " << Mix_GetError();
		throw SDLException(os.str());
	}*/

#endif
	soundInitialized = true;
}
Esempio n. 8
0
void 
InputImpl::Init( )
{
    if ( m_initialized )
        return;
    m_initialized = true;

    uint32_t ignoreTypes = Input::Instance().IgnoreTypes();

#ifdef SUPPORT_WIIMOTE
    if ( (ignoreTypes & InputDevice::Wiimote) == 0 )
    {
        Wiimote::FindAll( &m_wiimotes );
    }
#endif

    SDL::Instance().Init( );
    Assert( ::SDL_WasInit( SDL_INIT_VIDEO ) != 0 );

    if ( (ignoreTypes & InputDevice::Keyboard) == 0 )
    {
        m_pKeyboard = shared_ptr< Keyboard >( new Keyboard( "Keyboard" ) );
    }
    if ( (ignoreTypes & InputDevice::Mouse) == 0 )
    {
        m_pMouse = shared_ptr< Mouse >( new Mouse( "Mouse" ) );
    }
    if ( (ignoreTypes & InputDevice::Gamepad) == 0 )
    {
        if ( ::SDL_WasInit( SDL_INIT_JOYSTICK ) == 0 )
        {
            int initRslt = ::SDL_InitSubSystem( SDL_INIT_JOYSTICK );

            if ( initRslt != 0 )
                throw SDLException( "SDL_InitSubSystem( SDL_INIT_JOYSTICK )" );
        }
        int joystickEventState = ::SDL_JoystickEventState( SDL_ENABLE );
        if ( joystickEventState != SDL_ENABLE )
            throw SDLException( "SDL_JoystickEventState" );

        for ( int i = 0; i < ::SDL_NumJoysticks( ); ++i )
        {
            
            shared_ptr< Gamepad > pJoy(
                new Gamepad( ::SDL_JoystickName( i ), i ) );
            m_joysticks.push_back( pJoy );
        }
    }
}
Esempio n. 9
0
/**
 * Reinit the sound subsystem.
 */
    void
SDLSoundAgent::reinit()
{
    m_music = NULL;
    m_looper = NULL;
    m_soundVolume = MIX_MAX_VOLUME;
    m_musicVolume = MIX_MAX_VOLUME;
    if(SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
        throw SDLException(ExInfo("SDL_InitSubSystem"));
    }
    SDL_AudioSpec spec, have;
    spec.freq =48000;
    spec.format=AUDIO_S16SYS;
    spec.channels = 2;
    spec.samples=4096;
    spec.callback = 0;
    SDL_OpenAudio(&spec, &have);

    Mix_Init(MIX_INIT_FLAC | MIX_INIT_MOD | MIX_INIT_MP3 | MIX_INIT_OGG);

    int frequency =
       OptionAgent::agent()->getAsInt("sound_frequency", 44100);
    if(Mix_OpenAudio(frequency, MIX_DEFAULT_FORMAT, 2, 1024) < 0) {
        throw MixException(ExInfo("Mix_OpenAudio"));
    }
    Mix_AllocateChannels(16);

    SoundAgent::reinit();
}
Esempio n. 10
0
visualiserWin::visualiserWin(int desiredFrameRate,
                             bool vsync,
                             int width,
                             int height,
                             Uint32 flags)
{
	// Set the local members
	this->desiredFrameRate = desiredFrameRate;
	this->shouldVsync = vsync;
	this->currentVis = NULL;
	this->shouldCloseWindow = false;
	this->width = width;
	this->height = height;

	// Set the OpenGL attributes
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
	if(vsync)
		SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1);
	
	// Create the DSP manmager
	dspman = new DSPManager();
	
	// Create the window
	drawContext = SDL_SetVideoMode(width, height, 0, flags | SDL_OPENGL);
	if(drawContext == NULL)
		throw(SDLException());
	
	// also initialise the standard event handlers.
	initialiseStockEventHandlers();
}
Esempio n. 11
0
RT::Texture::Texture(const std::string &path) : surface(NULL)
{
	surface = IMG_Load(path.c_str());

	if(surface == NULL)
		throw SDLException();
}
Esempio n. 12
0
Surface::Surface(int width, int height)
: width(width)
, height(height)
{
	Uint32 rmask, gmask, bmask, amask;

	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
		rmask = 0xff000000;
		gmask = 0x00ff0000;
		bmask = 0x0000ff00;
		amask = 0x000000ff;
	#else
		rmask = 0x000000ff;
		gmask = 0x0000ff00;
		bmask = 0x00ff0000;
		amask = 0xff000000;
	#endif

	surface = SDL_CreateRGBSurface(0, width, height, 32, rmask, gmask, bmask, amask);

	if (surface == nullptr)
	{
		throw SDLException("SDL_CreateRGBSurface");
	}
}
Esempio n. 13
0
 ApplicationSDL::ApplicationSDL(int resx, int resy, const std::string& name,
                                bool fullscreen)
   : Application(resx, resy, name, fullscreen)
 {
   if( SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE) == -1 )
     throw SDLException("SDL init error: ");
 }
Esempio n. 14
0
bool Application::OnInit() {
	std::string textException = "OnInit() => ";
	
	try {
		SettingsCreator::ConfigureSettingsFile();

		InitializeSDLSystem();
		InitializeVideoSystem();
		InitializeTTFSystem();
		InitializeAudioSystem();
		InitializeResources();

		StateManager::SetActiveState(STATE_MENU);

		return true;
	} catch (const SDLException& sdlException) {
		textException.append(sdlException.WhatHappens());

		throw SDLException(textException);
	} catch (const TTFException& ttfException) {
		textException.append(ttfException.WhatHappens());

		throw TTFException(textException);
	} catch (const MixerException& mixerException) {
		textException.append(mixerException.WhatHappens());

		throw MixerException(textException);
	} catch (const GenericException& exception) {
		textException.append(exception.WhatHappens());

		throw GenericException(textException);
	}

	return false;
}
Esempio n. 15
0
void
Surface::AALine (const Point & begin, const Point & end, const Color & c)
{
    if (aalineColor
	(surface, begin.x, begin.y, end.x, end.y, c.GetRGBAColor ()))
	throw SDLException ();
}
Esempio n. 16
0
void 
Graphics2D::SetupScreen( int width, int height,
                               const char * title, 
                               EPixelType pixelType,
                               bool fullScreen, bool openGL )
{
    const ::SDL_VideoInfo * videoInfo = ::SDL_GetVideoInfo( );
    if ( videoInfo == 0 )
        throw SDLException( "SDL_GetVideoInfo" );
    if ( videoInfo->wm_available )
    {
        ::SDL_WM_SetCaption( title, 0 );
        //!!!SDL_WM_SetIcon(...);
    }

    Uint32 flags = 0;
    if ( fullScreen )
        flags |= SDL_FULLSCREEN;
    ::SDL_PixelFormat pxlFmt = DetermineSDLPixelFormat( pixelType );
    if ( openGL )
    {
        flags |= SDL_OPENGL;

        int glRslt = ::SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
        if ( glRslt != 0 )
            throw SDLException( "SDL_GL_SetAttribute(DOUBLEBUFFER)" );
        glRslt = ::SDL_GL_SetAttribute( SDL_GL_RED_SIZE, (8 - pxlFmt.Rloss) );
        if ( glRslt != 0 )
            throw SDLException( "SDL_GL_SetAttribute(RED_SIZE)" );
        glRslt = ::SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, (8 - pxlFmt.Gloss) );
        if ( glRslt != 0 )
            throw SDLException( "SDL_GL_SetAttribute(GREEN_SIZE)" );
        glRslt = ::SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, (8 - pxlFmt.Bloss) );
        if ( glRslt != 0 )
            throw SDLException( "SDL_GL_SetAttribute(BLUE_SIZE)" );
        glRslt = ::SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, (8 - pxlFmt.Aloss) );
        if ( glRslt != 0 )
            throw SDLException( "SDL_GL_SetAttribute(ALPHA_SIZE)" );
        glRslt = ::SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
        if ( glRslt != 0 )
            throw SDLException( "SDL_GL_SetAttribute(DEPTH_SIZE)" );
        //!!!SDL_GL_STENCIL_SIZE
        //!!!SDL_GL_ACCUM_RED_SIZE, ..., SDL_GL_ACCUM_ALPHA_SIZE
    }
    else
    {
        flags |= (SDL_HWSURFACE | SDL_DOUBLEBUF);
    }

    ::SDL_Surface * sdlScreenSurface
            = ::SDL_SetVideoMode( width, height, pxlFmt.BitsPerPixel, flags );
    if ( sdlScreenSurface == 0 )
        throw SDLException( "SDL_SetVideoMode" );

    m_spScreenSurface.reset( new Surface( sdlScreenSurface, false ) );
    m_spScreenSurface->MakeCurrent( );
}
Esempio n. 17
0
shared_ptr<SDL_Surface> SDL::renderText(const string & text, TTF_Font & font, const SDL_Color & color) {
	shared_ptr<SDL_Surface> renderedText(TTF_RenderText_Solid(&font, text.c_str(), color), &freeSurface);

	if (renderedText == NULL)
			throw SDLException(string("text \"") + text + "\" could not be rendered: " + SDL_GetError());

	return renderedText;
}
Esempio n. 18
0
void Surface::Blit(const Surface &surf, SDL_Rect *src, SDL_Rect *dest)
{
	int ret = SDL_BlitSurface(surf.GetSurface(), src, surface, dest);
	if (ret < 0)
	{
		throw SDLException("SDL_BlitSurface");
	}
}
Esempio n. 19
0
void SDLPP::SDLPP::InitImage() noexcept(false)
{
	int res = IMG_Init(IMG_INIT_PNG);
	if (res <= 0)
	{
		throw SDLException(ErrorCode::FailedInitializingSDLImage);
	}
}
Esempio n. 20
0
SDLInitSubSystem::SDLInitSubSystem(SDLSubSystem subsystem) : m_subsystem(subsystem)
{
    if (SDL_InitSubSystem(static_cast<uint32_t>(m_subsystem)) != 0)
    {
        auto message = "SDL_InitSubsystem(" + ToString(static_cast<uint32_t>(subsystem)) + ") failed with '" + SDLGetError() + "'.";
        throw SDLException(message);
    }
}
Esempio n. 21
0
void SDLPP::SDLPP::InitTTF() noexcept(false)
{
	int res = TTF_Init();
	if (res <= 0)
	{
		throw SDLException(ErrorCode::FailedInitializingSDLTTF);
	}
}
Esempio n. 22
0
TTFInit::TTFInit()
{
    if (TTF_Init() != 0)
    {
        auto message = "TTF_Init() failed with '" + TTFGetError() + "'.";
        throw SDLException(message);
    }
}
Esempio n. 23
0
SDLInit::SDLInit()
{
    if (SDL_Init(0) != 0)
    {
        auto message = "SDL_Init(0) failed with '" + SDLGetError() + "'.";
        throw SDLException(message);
    }
}
Esempio n. 24
0
void SoundProcessor::printSoundInformation() const
{
#ifdef _FMOD_SOUND
	FMOD_RESULT result;
	int driver_num;
	result = soundEngine->getNumDrivers(&driver_num);
	ERRCHECK(result);

	std::ostringstream os; os << "* Available sound drivers: ";
	for(unsigned int i = driver_num; i--;)
	{
		char driver_name[256];
		result = soundEngine->getDriverInfo(i, driver_name, 256, 0);
		ERRCHECK(result);
		os << driver_name << " ";
	}
	toInfoLog(os.str());
	os.str("");
	int current_driver;
	result = soundEngine->getDriver(&current_driver);
	ERRCHECK(result);

	os << "* Driver used: ";
	if(current_driver == -1)
	{
		os << "Primary or main sound device as selected by the operating system settings";
		if(driver_num == 1)
		{
			char driver_name[256];
			result = soundEngine->getDriverInfo(current_driver, driver_name, 256, 0);
			ERRCHECK(result);
			os << "(probably '" << driver_name << "')";
		}
	}
	else
	{
		char driver_name[256];
		result = soundEngine->getDriverInfo(current_driver, driver_name, 256, 0);
		ERRCHECK(result);
		os << driver_name;
	}
	toInfoLog(os.str());
#elif _SDL_MIXER_SOUND
	int audio_rate, audio_channels;
	Uint16 audio_format;
	int success = Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);
	
	if(!success) {
		std::ostringstream os;
		os << "ERROR (SoundProcessor::printSoundInformation()): " << Mix_GetError();
		throw SDLException(os.str());
	}
	int bits = audio_format & 0xFF;
	std::ostringstream os; 
	os << "* Opened audio at " << audio_rate << "Hz " << bits << "bit " << ((audio_channels>1)?"stereo":"mono");// << ", " << audio_buffers << " bytes audio buffer";
	toInfoLog(os.str());
#endif
}
Esempio n. 25
0
Graphics::Graphics(int width, int height, const char* title): width(width),
															  height(height){

	//If another instance already exists, we need to bail out
	if(exists)
		throw SDLException("Multiple Graphics objects instantiated");
	else
		exists=true;

	//Initializing SDL and creating the window surface
	SDL_Init(SDL_INIT_EVERYTHING);
	TTF_Init();
	window = SDL_SetVideoMode(width, height, bitsPerPixel, SDL_SWSURFACE);
	if(!window)
		throw SDLException("Error creating window");
	SDL_WM_SetCaption(title, NULL);

}
Esempio n. 26
0
TTFFont::TTFFont(const boost::filesystem::path& fileName, int size)
{
    m_pFont = TTF_OpenFont(fileName.string().c_str(), size);
    if (m_pFont == nullptr)
    {
        auto message = "TTF_OpenFont(" + fileName.string() + ") failed with '" + TTFGetError() + "'.";
        throw SDLException(message);
    }
}
Esempio n. 27
0
shared_ptr<SDL_Surface> SDL::rotate(SDL_Surface & surface, double degrees, bool smoothing) {
    shared_ptr<SDL_Surface> image(
        rotozoomSurface(&surface, degrees, 1, smoothing ? SMOOTHING_ON : SMOOTHING_OFF), &freeSurface);

    if (image == NULL)
        throw SDLException(IMG_GetError(), HERE);

    return image;
}
Esempio n. 28
0
void Application::OnRender() {
	try {
		// Increiblemente importante
		// Limpiar la pantalla de "suciedad"
		if (SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)) == -1) {
			throw SDLException();
		}

		StateManager::OnRender(screen);
		
		if (SDL_Flip(screen) == -1) {
			throw SDLException();
		}
	} catch (const SDLException& sdlException) {
		throw sdlException;
	} catch (const TTFException& ttfException) {
		throw ttfException;
	}
}
Esempio n. 29
0
Bitmap::Bitmap(const std::string& fileName, const boost::shared_ptr<const ObjectSize> objectSize, const bool transparent):
	fileName(fileName),
	objectSize(objectSize),
	transparent(transparent),
	bitmap(IMG_Load((BITMAP_DIRECTORY + fileName).c_str()))
{
	if(!bitmap) {
		throw SDLException("ERROR (Bitmap::Bitmap()): Loading file " + (BITMAP_DIRECTORY + fileName) + " (" + IMG_GetError() + ").");
	}
}
Esempio n. 30
0
SDLSurface::SDLSurface(const boost::filesystem::path& fileName) : m_pSurface(nullptr)
{
    assert(IMGInit::IsInit());
    m_pSurface = IMG_Load(fileName.string().c_str());
    if (m_pSurface == nullptr)
    {
        auto message = "IMG_Load(" + fileName.string() + ") failed with '" + IMGGetError() + "'.";
        throw SDLException(message);
    }
}