class Image : boost::noncopyable{public:    Image( const std::string &filename );    // ...};class ImageCache{public:    typedef boost::shared_ptr<Image> ImagePtr;    typedef std::map<std::string,ImagePtr> Cache;    ImagePtr load( const std::string & filename )    {        Cache::iterator it = cached.find(filename);        if( it == cached.end() )        {            // note: the Image constructor could throw an exception            // to handle "couldn't load image" error.            ImagePtr image( new Image(filename) );            cache.insert(std::make_pair(filename,image);            return image;        }        return it->second;    }private:    Cache cached;};

/*	Universal class. Edits affect multiple projects.*/#ifndef DRAW_ENGINE#define DRAW_ENGINE//test#include <algorithm>#include <map>#include <string>#include <iostream>#include <exception>#include "SDL/SDL.h"#include "SDL/SDL_image.h"#include "SDL/SDL_ttf.h"#include "Point.h"#include "SDL_Tools.h"#include "Uncopyable.h"const Uint8 DEFAULT_FC_R = 0;const Uint8 DEFAULT_FC_G = 0;const Uint8 DEFAULT_FC_B = 0;// When autofit is specific in an Enhanced_Write_Options object,// Enhanced_Write sets the text size to the height of the bounds.// This can result in text exceeding the bounds, so we use this to trim the size.const double AUTOFIT_ADJ = 0.75;enum JUSTIFICATION {JUSTIFY_NONE, JUSTIFY_CENTRED, JUSTIFY_LEFT, JUSTIFY_RIGHT};struct Enhanced_Write_Options{	Enhanced_Write_Options();	Enhanced_Write_Options(		JUSTIFICATION justification,		int left_pad,		int right_pad,		const SDL_Rect& bounds,		const std::string& text,		int font_size,		const std::string& font_name,		SDL_Color colour = SDL_Tools::Colours::BLACK);	friend std::istream& operator>>(std::istream& stream, Enhanced_Write_Options& ewo);	JUSTIFICATION justification;	int left_pad, right_pad, font_size;	SDL_Rect bounds;	std::string text, font_name;	SDL_Color colour;};class Draw_Engine : public Uncopyable{public:	typedef unsigned int uint;	typedef unsigned short ushort;		static void Initialise(		ushort SCREEN_WIDTH,		ushort SCREEN_HEIGHT,		ushort SCREEN_BPP,		const std::string& SCREEN_CAPTION,		const std::string& FONT,		int FONT_SIZE);	static void Clean_Up();	// Blits a surface onto the screen.	static void Blit_Surface(	SDL_Rect position, const std::string& file_name, SDL_Rect* clip);	// Blits a surface onto the screen (Point variation).	static void Blit_Surface(		Point position, const std::string& file_name, SDL_Rect* clip);		static void New_Font(const std::string& file_name, int font_size);	static void Write(int x, int y, const std::string& text);	static void Write_Enhanced(const Enhanced_Write_Options& ewo);	static void Draw_Rect(SDL_Rect position, SDL_Color colour);		// Draws the screen.	static void Draw_Screen();	// Frees a surface.	static void Free_Surface(SDL_Surface*& surface);	// Loads a surface ready for blitting.	static void Load_Surface(const std::string& file_name, SDL_Colour* colour_key = NULL);protected:	class Surface_Manager	{	public:		Surface_Manager();		~Surface_Manager();		void Add_Surface(const std::string& file_name, SDL_Surface* surface);		bool Surface_Exists(const std::string& file_name) const;		SDL_Surface* Get_Surface(const std::string& file_name);	private:		typedef std::map<const std::string, SDL_Surface*>::iterator surface_it;		std::map<const std::string, SDL_Surface*> loaded_surfaces;	};		Draw_Engine() {}	static void Throw_If_Unitialised(); 	static bool initialised;		static Surface_Manager surface_manager;	static SDL_Surface* screen;	static SDL_Surface* text_sfc;	static TTF_Font* font;	static std::string font_name;	static int font_size;	static SDL_Colour font_colour;	static SDL_Rect blit_position;};#endif

/*	Universal class. Edits affect multiple projects.*/#include "stdafx.h"#include "Draw_Engine.h"#include "Directory.h"Enhanced_Write_Options::Enhanced_Write_Options()	:	justification(JUSTIFY_NONE),	left_pad(0),	right_pad(0),	bounds(SDL_Tools::EMPTY),	font_size(0),	colour(SDL_Tools::Colours::WHITE){}Enhanced_Write_Options::Enhanced_Write_Options(	JUSTIFICATION justification,	int left_pad,	int right_pad,	const SDL_Rect& bounds,	const std::string& text,	int font_size,	const std::string& font_name,	SDL_Color colour):	justification(justification),	left_pad(left_pad),	right_pad(right_pad),	bounds(bounds),	text(text),	font_size(font_size),	font_name(font_name),	colour(colour){}std::istream& operator>>(std::istream& stream, Enhanced_Write_Options& ewo){	std::string buffer;	int int_buf = 0;	stream >> buffer; // <	IO::Check_Opening_Tag(buffer);	stream >> int_buf;	ewo.justification = static_cast<JUSTIFICATION>(int_buf);		stream >> ewo.left_pad >> ewo.right_pad;	SDL_Tools::RW_SDL_Rect rwrect;	stream >> rwrect;	ewo.bounds = rwrect;	stream >> ewo.text;	stream >> ewo.font_size;	if(ewo.font_size > 0) stream >> ewo.font_name;	SDL_Tools::RW_SDL_Color rwcol;	stream >> rwcol;	ewo.colour = rwcol;	stream >> buffer; // >	IO::Check_Closing_Tag(buffer);	return stream;}bool Draw_Engine::initialised = false;Draw_Engine::Surface_Manager Draw_Engine::surface_manager;SDL_Surface* Draw_Engine::screen = NULL;SDL_Surface* Draw_Engine::text_sfc = NULL;TTF_Font* Draw_Engine::font = NULL;std::string Draw_Engine::font_name;int Draw_Engine::font_size = 0;SDL_Colour Draw_Engine::font_colour = SDL_Tools::colour(0,0,0);SDL_Rect Draw_Engine::blit_position = SDL_Tools::EMPTY;void Draw_Engine::Initialise(	ushort SCREEN_WIDTH,	ushort SCREEN_HEIGHT,	ushort SCREEN_BPP,	const std::string& SCREEN_CAPTION,	const std::string& FONT,	int FONT_SIZE){	if(initialised)	{ // Already initialised.		return;	}		font_name = FONT;	font_size = FONT_SIZE;	if(SDL_Init(SDL_INIT_EVERYTHING) == -1)	{		throw std::runtime_error(			std::string("SDL_Init failed: ") + std::string(SDL_GetError()));	}	screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE);	if(screen == NULL)	{		throw std::runtime_error(std::string("Error: SDL_SetVideoMode failed: " +		std::string(SDL_GetError())));	}	SDL_WM_SetCaption(SCREEN_CAPTION.c_str(), NULL);	//Initialize SDL_ttf    if(TTF_Init() == -1)	{		throw std::runtime_error(std::string("Error: TTF_Init failed: ") +			std::string(TTF_GetError()));	}	//Open the font    font = TTF_OpenFont(font_name.c_str(), font_size);        //If there was an error in loading the font    if(font == NULL)	{		throw std::runtime_error(		std::string("Error: TTF_OpenFont failed: ") +		std::string(TTF_GetError()));	}	//The color of the font	font_colour.r = DEFAULT_FC_R, font_colour.g = DEFAULT_FC_G, font_colour.b = DEFAULT_FC_B;	// Enable key repeating	if(SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL) == -1)	{		throw std::runtime_error(		std::string("Error: SDL_EnableKeyRepeat failed: ") +		std::string(SDL_GetError()));	}	// Initialisation was successful	initialised = true;	}void Draw_Engine::Clean_Up(){	Throw_If_Unitialised();	//Free the text	SDL_FreeSurface(text_sfc);	//Close used font	TTF_CloseFont(font);	//Quit SDL_ttf	TTF_Quit();}void Draw_Engine::Blit_Surface(SDL_Rect position, const std::string& file_name, SDL_Rect* clip){	Throw_If_Unitialised();	bool successful = (SDL_BlitSurface(		surface_manager.Get_Surface(file_name),	clip, screen, &position) == 0);	if(!successful)	{ // Unsuccessful blit.		throw std::runtime_error("Surface failed to blit.");	}}void Draw_Engine::Blit_Surface(Point position, const std::string& file_name, SDL_Rect* clip){	Throw_If_Unitialised();	SDL_Rect pos = {position.x, position.y, 0, 0};	bool successful = (SDL_BlitSurface(		surface_manager.Get_Surface(file_name), clip, screen, &pos) == 0);	if(!successful)	{ // Unsuccessful blit.		throw std::runtime_error("Surface failed to blit.");	}}void Draw_Engine::New_Font(const std::string& file_name, int font_size){	Throw_If_Unitialised();	TTF_CloseFont(font);	font = TTF_OpenFont(file_name.c_str(), font_size);	if(font == NULL)	{		throw std::runtime_error(		std::string("Error: TTF_OpenFont failed: ") +		std::string(TTF_GetError()));	}}void Draw_Engine::Write(int x, int y, const std::string& text){	Throw_If_Unitialised();	text_sfc = TTF_RenderText_Solid(font, text.c_str(), font_colour);	if(text_sfc == NULL)	{		throw std::runtime_error(		std::string("Error: TTF_RenderText_Solid failed: ") +		std::string(TTF_GetError()));	}	else 	{		blit_position.x = x;		blit_position.y = y;		SDL_BlitSurface(text_sfc, NULL, screen, &blit_position);	}	// Always free the text.	Free_Surface(text_sfc);}void Draw_Engine::Write_Enhanced(const Enhanced_Write_Options& ewo){	Throw_If_Unitialised();	bool font_changed = false;	if(ewo.font_size != font_size)	{		font_changed = true;		New_Font(!ewo.font_name.empty() ? ewo.font_name : font_name,			ewo.font_size < 1 ? (int)(ewo.bounds.h * AUTOFIT_ADJ) : ewo.font_size);	}		text_sfc = TTF_RenderText_Solid(font, ewo.text.c_str(), ewo.colour);	if(text_sfc == NULL)	{		throw std::runtime_error(std::string(			"Error: TTF_RenderText_Solid failed: ") + std::string(TTF_GetError()));	}	else	{		int x = 0, y = 0;		switch(ewo.justification)		{		case JUSTIFY_CENTRED:			x = ewo.bounds.x + (ewo.bounds.w/2) - (text_sfc->w/2);			y = ewo.bounds.y + (ewo.bounds.h/2) - (text_sfc->h/2);			break;		case JUSTIFY_LEFT:			x = ewo.bounds.x + ewo.left_pad;			y = ewo.bounds.y + (ewo.bounds.h/2) - (text_sfc->h/2);			break;		case JUSTIFY_RIGHT:			x = (ewo.bounds.x + ewo.bounds.w) - (text_sfc->w + ewo.right_pad);			y = ewo.bounds.y + (ewo.bounds.h/2) - (text_sfc->h/2);			break;		case JUSTIFY_NONE:			x = ewo.bounds.x;			y = ewo.bounds.y;		}		blit_position.x = x;		blit_position.y = y;		SDL_BlitSurface(text_sfc, NULL, screen, &blit_position);	}	Free_Surface(text_sfc);	if(font_changed)	{ // Change font back to previous.		New_Font(font_name, font_size);	}}void Draw_Engine::Draw_Rect(SDL_Rect position, SDL_Color colour){	Throw_If_Unitialised();	if(SDL_FillRect(screen, &position, SDL_MapRGB(	screen->format, colour.r, colour.g, colour.b)) != 0)	{		throw std::runtime_error(			"Error: SDL_FillRect failed: " + std::string(SDL_GetError()));	}}void Draw_Engine::Draw_Screen(){	Throw_If_Unitialised();	if(SDL_Flip(screen) != 0)	{ // Bad draw.		throw std::runtime_error(			"Couldn't draw screen: " + std::string(SDL_GetError()));	}}void Draw_Engine::Free_Surface(SDL_Surface*& surface){	Throw_If_Unitialised();	SDL_FreeSurface(surface);	surface = NULL;}void Draw_Engine::Load_Surface(const std::string& file_name, SDL_Colour* colour_key){	Throw_If_Unitialised();	if(file_name.empty())	{ // Don't issue errors for empty file names.		return;	}		std::string fn = Directory::abs_path(file_name);	SDL_Surface* loaded = NULL;	SDL_Surface* optimized = NULL;	Uint32 map_colour_key = 0;	loaded = IMG_Load(fn.c_str());	if(loaded == NULL && !fn.empty())	{		throw std::runtime_error("Surface at: " + fn + " failed to load."+			SDL_GetError());		std::cout << SDL_GetError() << std::endl;	}	optimized = SDL_DisplayFormat(loaded);	Free_Surface(loaded);	if(optimized == NULL)	{		throw std::runtime_error("Surface at: " + fn + " failed to optimise.");	}	if(colour_key != NULL)	{ // The surface uses a colour key.		// Create the colour key.		map_colour_key = SDL_MapRGB(optimized->format, colour_key->r, colour_key->g, colour_key->b);		// Sets the colour key to the Surface.		SDL_SetColorKey(optimized, SDL_RLEACCEL | SDL_SRCCOLORKEY, map_colour_key);	}	// Surface optimized and loaded successfully; add to surface manager.	surface_manager.Add_Surface(file_name, optimized);}void Draw_Engine::Throw_If_Unitialised(){	if(!initialised)	{		throw std::runtime_error("Draw_Engine not initialised.");	}}Draw_Engine::Surface_Manager::Surface_Manager(){}Draw_Engine::Surface_Manager::~Surface_Manager(){		for(surface_it it = loaded_surfaces.begin();	it != loaded_surfaces.end(); ++it)	{ // Free each surface.		Free_Surface(it->second);	}}void Draw_Engine::Surface_Manager::Add_Surface(const std::string& file_name, SDL_Surface* surface){	if(!Surface_Exists(file_name))	{ // Surface doesn't exist; add.		loaded_surfaces.insert(std::make_pair(file_name, surface));	}}bool Draw_Engine::Surface_Manager::Surface_Exists(const std::string& file_name) const{	return loaded_surfaces.find(file_name) != loaded_surfaces.end();}SDL_Surface* Draw_Engine::Surface_Manager::Get_Surface(const std::string& file_name){	if(!Surface_Exists(file_name))	{ // Surface doesn't exist.		throw std::runtime_error(std::string("Surface_Manager::Get_Surface: ") +			"\"" + file_name + "\" does not exist.");	}	return loaded_surfaces[file_name];}

void XImage::Load(){	Draw_Engine::Load_Surface(		file_name, is_colour_key ? &colour_key : NULL);}void XImage::Draw(){	Draw_Engine::Blit_Surface(position, file_name, NULL);}

class Renderer : boost::noncopyable{public:    Renderer(unsigned width, unsigned height, unsigned bpp, bool fullscreen)    {        SDL_Init(SDL_INIT_VIDEO);        screen = SDL_SetVideoMode(width,height,bpp,fullscreen ? SDL_FULLSCREEN : SDL_SWSURFACE );        if(!screen)        {            throw std::runtime_error(SDL_GetError());        }    }    ~Renderer()    {        SDL_Quit();    }    void draw(SDL_Surface *surface, int x, int y)    {        SDL_Rect dest = {x,y};        SDL_BlitSurface(surface,0,screen,&dest);    }    void drawRect(const SDL_Rect &rect, Uint32 colour)    {        SDL_Rect copy = rect;        SDL_FillRect(screen,©,colour);    }    void render()    {        SDL_Flip(screen);    }    unsigned width() const    {        return screen->w;    }    unsigned height() const    {        return screen->h;    }private:    SDL_Surface *screen;};class Image{public:    Image(const std::string &filename)    {        surface = IMG_Load(filename.c_str());        if(!surface)        {            throw std::runtime_error(SDL_GetError());        }    }    ~Image()    {        SDL_FreeSurface(surface);    }    void draw(Renderer &renderer, int x, int y)    {        renderer.draw(surface,x,y);    }    unsigned width() const    {        return surface->w;    }    unsigned height() const    {        return surface->h;    }private:    SDL_Surface *surface;};class ImageCache{public:    typedef boost::shared_ptr<Image> ImagePtr;    typedef std::map<std::string,ImagePtr> Cache;    ImagePtr load( const std::string & filename )    {        Cache::iterator it = cached.find(filename);        if( it == cached.end() )        {            // note: the Image constructor could throw an exception            // to handle "couldn't load image" error.            ImagePtr image( new Image(filename) );            cached.insert(std::make_pair(filename,image));            return image;        }        return it->second;    }private:    Cache cached;};// sample program, bounces an image aroundint main( int argc, char* argv[]){    try    {        Renderer renderer(1024,768,32,true);        ImageCache cache;        typedef boost::shared_ptr<Image> ImagePtr;        ImagePtr image = cache.load("image.bmp");        int x = 0, y = 0;        int dx = 1, dy = 1;        SDL_Event event;        const SDL_Rect full = {0,0,renderer.width(), renderer.height()};        bool running = true;        while(running)        {            while(SDL_PollEvent(&event))            {                if(event.type == SDL_QUIT)                {                    running = false;                }                else if(event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)                {                    running = false;                }            }            renderer.drawRect(full,0);            image->draw(renderer,x,y);            x += dx;            y += dy;            if( x + image->width() > renderer.width() || x < 0 )            {                dx = -dx;            }            if( y + image->height() > renderer.height() || y < 0 )            {                dy = -dy;            }            renderer.render();        }    }    catch(const std::exception &e)    {        // handle error    }    return 0;}