No OneTemporary
Actions

Authored By

Unknown

Size

286 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/util/font.cpp b/util/font.cpp
	index d54815d3..cd1010b9 100644
	--- a/util/font.cpp
	+++ b/util/font.cpp
	@@ -1,318 +1,318 @@
	#ifdef USE_ALLEGRO
	/* for textout_* and whatnot */
	#include <allegro.h>
	#endif
	#include "graphics/bitmap.h"
	#include "font.h"
	#include "funcs.h"
	#include "init.h"
	#include "ftalleg.h"
	#include "font_factory.h"
	#include "exceptions/exception.h"
	#include <string.h>

	using namespace std;

	Util::Parameter<Util::ReferenceCount<Filesystem::RelativePath> > Font::defaultFont;

	Font::Font(){
	}

	/* copy/pasted from network/message.cpp */
	static vector<string> wrapStrings(const string & left, const string & right, const Font & font, int max, vector< string > accum){
	if (left == ""){
	return accum;
	}

	int length = font.textLength(left.c_str());

	if (length >= max){
	return wrapStrings(left.substr(0, left.length() / 2), left.substr(left.length() / 2) + right, font, max, accum);
	} else if (right == "" \|\| font.textLength((left + right.substr(0, 1)).c_str()) >= max){
	accum.push_back(left);
	return wrapStrings(right, "", font, max, accum);
	} else {
	return wrapStrings(left + right.substr(0, 1), right.substr(1), font, max, accum);
	}
	}

	void Font::printfWrapLine(int x, int & y, Graphics::Color color, const Graphics::Bitmap & work, int maxWidth, const char * line) const {
	vector< string > all;
	all = wrapStrings(string(line), "", *this, maxWidth, all );
	for ( vector< string >::iterator str = all.begin(); str != all.end(); str++ ){
	printf(x, y, color, work, *str, 0);
	y += getHeight();
	}
	y += getHeight() / 2;
	}

	#if 0
	void Font::printfWrapLine2(int x, int & y, int color, const Bitmap & work, int maxWidth, const char * line) const {
	int height = getHeight();
	while (*line != '\0'){
	char tmp2[1024];
	int left = strlen(line);
	int min = 0;
	int max = left;
	int current = (min + max) / 2;
	strncpy(tmp2, line, current);
	tmp2[current] = '\0';
	bool done = false;
	while (!done){
	int length = textLength(tmp2);
	if (length >= maxWidth){
	max = current;
	current = (min + max) / 2;
	strncpy(tmp2, line, current);
	tmp2[current] = '\0';
	} else if (length < maxWidth && current < max){
	min = current;
	current = (min + max) / 2;
	if (current == max - 1){
	current = max;
	done = true;
	}
	strncpy(tmp2, line, current);
	tmp2[current] = '\0';
	} else {
	done = true;
	}
	}
	printf(x, y, color, work, string(tmp2), 0);
	y += height;

	line += current;
	}

	y += height / 2;
	}
	#endif

	void Font::printfWrap(int x, int y, Graphics::Color color, const Graphics::Bitmap & work, int maxWidth, const std::string & str, int marker, ... ) const {
	char buf[4096];
	va_list ap;

	va_start(ap, marker);
	Util::limitPrintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	char * start = buf;
	char * end = strchr(start, '\n');
	while (end != NULL){
	char tmp[1024];
	unsigned int ender = end - start;
	if (ender >= sizeof(tmp) - 1){
	ender = sizeof(tmp) - 1;
	}

	strncpy(tmp, start, ender);
	tmp[ender] = '\0';
	printfWrapLine(x, y, color, work, maxWidth, tmp);

	start = end + 1;
	end = strchr(start, '\n');
	}
	printfWrapLine(x, y, color, work, maxWidth, start);
	}

	Font::~Font(){
	}

	#ifdef USE_ALLEGRO
	AllegroFont::AllegroFont( const FONT * const font ):
	font(font){
	}

	AllegroFont::AllegroFont( const AllegroFont & copy ):
	font( copy.getInternalFont() ){
	}

	AllegroFont::~AllegroFont(){
	}

	int AllegroFont::textLength( const char * text ) const{
	return text_length( getInternalFont(), text );
	}

	int AllegroFont::getHeight( const string & str ) const {
	return getHeight();
	}

	int AllegroFont::getHeight() const {
	return text_height( getInternalFont() );
	}

	void AllegroFont::setSize( const int x, const int y ){
	}

	int AllegroFont::getSizeX() const {
	return 0;
	}

	int AllegroFont::getSizeY() const {
	return 0;
	}

	-void AllegroFont::printf( int x, int y, int xSize, int ySize, int color, const Graphics::Bitmap & work, const string & str, int marker, ... ) const {
	+void AllegroFont::printf( int x, int y, int xSize, int ySize, Graphics::Color color, const Graphics::Bitmap & work, const string & str, int marker, ... ) const {
	char buf[512];
	va_list ap;

	va_start(ap, marker);
	Util::limitPrintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	- textout_ex(work.getData()->getBitmap(), getInternalFont(), buf, x, y, color, -1);
	+ textout_ex(work.getData()->getBitmap(), getInternalFont(), buf, x, y, color.color, -1);
	}

	-void AllegroFont::printf( int x, int y, int color, const Graphics::Bitmap & work, const string & str, int marker, ... ) const {
	+void AllegroFont::printf( int x, int y, Graphics::Color color, const Graphics::Bitmap & work, const string & str, int marker, ... ) const {
	char buf[512];
	va_list ap;

	va_start(ap, marker);
	uvszprintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	- textout_ex(work.getData()->getBitmap(), getInternalFont(), buf, x, y, color, -1);
	+ textout_ex(work.getData()->getBitmap(), getInternalFont(), buf, x, y, color.color, -1);
	}
	#endif

	const Font & Font::getDefaultFont(){
	return getDefaultFont(16, 16);
	}

	const Path::RelativePath & Font::getDefaultFontPath(){
	if (defaultFont.current() == NULL){
	throw Exception::FontException(__FILE__, __LINE__, "No default font set");
	}
	return *defaultFont.current();
	}

	const Font & Font::getDefaultFont(int width, int height){
	Font * font = FontFactory::getFont(getDefaultFontPath(), width, height);
	if (font == NULL){
	throw Exception::FontException(__FILE__, __LINE__, "No default font set");
	}
	return *font;
	}

	/* name should be the path of a .ttf file in the fonts/ directory.
	* something like 'arial.ttf'
	*/
	const Font & Font::getFont(const Filesystem::RelativePath & name, const int x, const int y){
	Font * check = FontFactory::getFont(name, x, y);
	if (check == NULL){
	throw Exception::FontException(__FILE__, __LINE__, "Could not get font");
	}
	Font & font = *check;
	/* sanity check */
	if (font.getHeight("A") == 0){
	return getDefaultFont();
	}
	return font;
	}

	const Font & Font::getFont( const Filesystem::AbsolutePath & name, const int x, const int y){
	return *FontFactory::getFont(name, x, y);
	}

	FreeTypeFont::FreeTypeFont(const Filesystem::AbsolutePath & str ):
	sizeX(16),
	sizeY(16),
	own(true){
	this->font = new ftalleg::freetype(str, getSizeX(), getSizeY() );
	}

	int FreeTypeFont::getHeight( const string & str ) const {
	return this->font->getHeight(str);
	}

	int FreeTypeFont::getHeight() const {
	return getHeight("A");
	}

	int FreeTypeFont::textLength( const char * text ) const {
	return this->font->getLength(string(text));
	}

	void FreeTypeFont::printf( int x, int y, int xSize, int ySize, Graphics::Color color, const Graphics::Bitmap & work, const string & str, int marker, ... ) const {
	char buf[512];
	va_list ap;

	va_start(ap, marker);
	vsnprintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	int old_x = 0;
	int old_y = 0;
	this->font->getSize(&old_x, &old_y);
	this->font->setSize(xSize, ySize);
	this->font->render(x, y, color, work, ftalleg::freetype::ftLeft, string(buf), 0);
	this->font->setSize(old_x, old_y);
	}

	void FreeTypeFont::printf( int x, int y, Graphics::Color color, const Graphics::Bitmap & work, const string & str, int marker, ... ) const {
	char buf[512];
	va_list ap;

	va_start(ap, marker);
	vsnprintf(buf, sizeof(buf), str.c_str(), ap);
	va_end(ap);

	this->font->render(x, y, color, work, ftalleg::freetype::ftLeft, string(buf), 0);
	}

	void FreeTypeFont::setSize( const int x, const int y ){
	this->sizeX = x;
	this->sizeY = y;
	this->font->setSize( this->sizeX, this->sizeY );
	}

	int FreeTypeFont::getSizeX() const {
	return this->sizeX;
	}

	int FreeTypeFont::getSizeY() const {
	return this->sizeY;
	}

	FreeTypeFont::~FreeTypeFont(){
	// cout << "Delete font " << this->font << endl;
	if (own){
	delete this->font;
	}
	}

	NullFont::NullFont(){
	}

	NullFont::~NullFont(){
	}

	void NullFont::setSize( const int x, const int y ){
	}

	int NullFont::getSizeX() const {
	return 0;
	}

	int NullFont::getSizeY() const {
	return 0;
	}

	int NullFont::textLength( const char * text ) const {
	return 0;
	}

	int NullFont::getHeight( const std::string & str ) const {
	return 0;
	}

	int NullFont::getHeight() const {
	return 0;
	}

	void NullFont::printf( int x, int y, int xSize, int ySize, Graphics::Color color, const Graphics::Bitmap & work, const std::string & str, int marker, ... ) const {
	}

	void NullFont::printf( int x, int y, Graphics::Color color, const Graphics::Bitmap & work, const std::string & str, int marker, ... ) const {
	}
	diff --git a/util/ftalleg.cpp b/util/ftalleg.cpp
	index 4607ff5b..96a963cc 100644
	--- a/util/ftalleg.cpp
	+++ b/util/ftalleg.cpp
	@@ -1,705 +1,705 @@
	/*
	--------------
	About
	--------------
	A Freetype wrapper for use with allegro
	Feel free to do whatever you like with this, by all means enjoy!
	Just add it to your project

	--------------
	Linking
	--------------
	on linux:
	g++ `freetype-config --cflags` ftalleg.cpp myfiles.cpp `freetype-config --libs` `allegro-config --libs`

	on windows (you may need to include the freetype dir location, ie -Ic:/mingw/include):
	g++ ftalleg.cpp myfiles.cpp -lfreetype -lalleg

	--------------
	Disclaimer
	--------------
	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
	TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE
	SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
	ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*/

	#ifndef FT_FONT_CPP
	#define FT_FONT_CPP

	#include "graphics/bitmap.h"

	/*
	#include <allegro.h>
	#ifdef _WIN32
	#include <winalleg.h>
	#endif
	*/

	#include "ftalleg.h"
	#include "utf.h"
	#include <iostream>
	#include <sstream>
	#include <cassert>
	#include <exception>
	#ifdef USE_ALLEGRO5
	#include <allegro5/allegro_font.h>
	#include <allegro5/allegro_ttf.h>
	#endif

	namespace ftalleg{

	Exception::Exception():
	std::exception(){
	}

	Exception::Exception(const std::string reason):
	std::exception(),
	reason(reason){
	}

	Exception::~Exception() throw(){
	}

	// typedef void (pixeler)( BITMAP bitmap, int x, int y, int color );

	static Graphics::Color fixColor(const unsigned char c, short grays){
	// Safety checks
	// assert(c != 0);
	assert(grays != 1);

	// invariant: c can be dereferenced safely
	// invariant: (grays - 1) != 0, thus it can be used as divisor.

	int red = c * 255 / (grays - 1);
	int green = c * 255 / (grays - 1);
	int blue = c * 255 / (grays - 1);
	//alpha = c 255 / (grays - 1);
	return Graphics::makeColor(red,green,blue);
	}
	// Static count of instances of fonts to track library
	static int instances = 0;
	static FT_Library ftLibrary = 0;

	character::character() {
	}

	character::~character() {
	if (line){
	delete [] line;
	}
	}

	fontSize::fontSize() {
	width = height = italics = angle = 0;
	}

	fontSize::fontSize(int width, int height):
	width(width),
	height(height),
	italics(0),
	angle(0){
	}

	fontSize::~fontSize() {
	}

	bool fontSize::operator<(const fontSize &fs) const {
	return (width<fs.width \|\| height<fs.height \|\| italics<fs.italics);
	}

	/* im not sure this is a very unique key.. */
	int fontSize::createKey() const {
	return ((width+10) * (height+20) * (italics+250));
	}

	#ifdef USE_ALLEGRO5
	freetype::freetype(const Filesystem::AbsolutePath & path, const int x, const int y):
	alive(5, 5),
	path(path),
	width(x),
	height(y),
	original_size(x){
	if (instances == 0){
	al_init_font_addon();
	al_init_ttf_addon();
	}
	instances += 1;

	int flags = al_get_new_bitmap_flags();
	/* memory fonts must live in memory */
	al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
	fonts[width].memory = al_load_font(path.path().c_str(), width, 0);
	al_set_new_bitmap_flags(flags);
	fonts[width].video = al_load_font(path.path().c_str(), width, 0);
	}

	freetype::~freetype(){
	for (std::map<int, FontUse>::iterator it = fonts.begin(); it != fonts.end(); it++){
	FontUse & font = it->second;
	al_destroy_font(font.memory);
	al_destroy_font(font.video);
	}

	instances -= 1;
	if (instances == 0){
	al_shutdown_font_addon();
	}
	}

	ALLEGRO_FONT * freetype::currentMemoryFont() const {
	std::map<int, FontUse>::const_iterator find = fonts.find(width);
	if (find == fonts.end()){
	throw Exception("inconsistency error");
	}
	return find->second.memory;
	}

	ALLEGRO_FONT * freetype::currentVideoFont() const {
	std::map<int, FontUse>::const_iterator find = fonts.find(width);
	if (find == fonts.end()){
	throw Exception("inconsistency error");
	}
	return find->second.video;
	}

	int freetype::getHeight(const std::string & str) const {
	Util::Thread::ScopedLock locked(lock);
	/* sort of a hack but we need to set the display to the screen. with
	* allegro5 the screen buffer will be the actual screen so no allocation
	* will occur.
	*/
	// al_set_target_bitmap(alive.getData().getBitmap());
	// ALLEGRO_BITMAP * target = al_get_target_bitmap();
	// al_set_target_bitmap(NULL);
	int height = al_get_font_line_height(currentMemoryFont());
	// al_set_target_bitmap(target);
	return height;
	}

	int freetype::getLength(const std::string & text) const {
	Util::Thread::ScopedLock locked(lock);
	// al_set_target_bitmap(alive.getData().getBitmap());
	// ALLEGRO_BITMAP * target = al_get_target_bitmap();
	// al_set_target_bitmap(NULL);
	int width = al_get_text_width(currentMemoryFont(), text.c_str());
	// al_set_target_bitmap(target);
	return width;
	}

	void freetype::setSize(unsigned int w, unsigned int h){
	Util::Thread::ScopedLock locked(lock);
	width = w;
	height = h;
	if (fonts.find(width) == fonts.end()){
	fonts[width].memory = al_load_font(path.path().c_str(), width, 0);
	fonts[width].video = al_load_font(path.path().c_str(), width, 0);
	}
	}

	void freetype::getSize(int * w, int * h) const {
	Util::Thread::ScopedLock locked(lock);
	*w = width;
	*h = height;
	}

	void freetype::render(int x, int y, const Graphics::Color & color, const Graphics::Bitmap & bmp, ftAlign alignment, const std::string & text, int marker, ...){
	Util::Thread::ScopedLock locked(lock);
	std::ostringstream str;

	/* use vsnprintf/Util::limitPrintf here? */

	// Get extra arguments
	va_list ap;
	va_start(ap, marker);
	for(unsigned int i = 0; i<text.length();++i) {
	if (text[i] == '%') {
	if(text[i+1]=='s') {
	str << va_arg(ap, char *);
	++i;
	} else if(text[i+1]=='d'\|\|text[i+1]=='i') {
	str << va_arg(ap, signed int);
	++i;
	} else if(text[i+1]=='c') {
	str << (char)va_arg(ap, int);
	++i;
	} else str << text[i];
	} else {
	str << text[i];
	}
	}
	va_end(ap);

	std::string fixedText(str.str());
	if (al_get_target_bitmap() != bmp.getData()->getBitmap()){
	al_set_target_bitmap(bmp.getData()->getBitmap());
	}
	al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA);

	/* for setting the blend state and whatnot */
	bmp.startDrawing();
	- al_draw_text(currentVideoFont(), bmp.blendColor(color), x, y, 0, fixedText.c_str());
	+ al_draw_text(currentVideoFont(), bmp.blendColor(color).color, x, y, 0, fixedText.c_str());
	bmp.endDrawing();
	}
	#else
	//! Constructor
	freetype::freetype(const Filesystem::AbsolutePath & str, const int x, const int y ):
	face(NULL){
	//Load library
	if (!ftLibrary){
	if (FT_Init_FreeType(&ftLibrary) != 0){
	throw Exception("Could not initialize freetype");
	}
	}
	instances += 1;
	faceLoaded = kerning = false;
	currentIndex = 0;
	currentFilename = "";
	faceName = "";
	// currentChar = new character;
	systemName = "";
	internalFix = false;

	this->load(str, 0, x, y );
	}

	//! Destructor
	freetype::~freetype(){

	//if(face!=NULL)FT_Done_Face(face);
	if (faceLoaded && face != NULL){
	FT_Done_Face(face);
	face = NULL;
	}

	instances -= 1;
	if (instances == 0){
	FT_Done_FreeType(ftLibrary);
	ftLibrary = NULL;
	}

	destroyGlyphIndex();

	/*
	if ( currentChar ){
	delete currentChar;
	}
	*/
	}

	void freetype::destroyGlyphIndex(){
	for (std::map<int, std::map<signed long, character*> >::iterator i1 = fontTable.begin(); i1 != fontTable.end(); i1++){
	std::map<signed long, character> & characters = (i1).second;
	for (std::map<signed long, character*>::iterator i2 = characters.begin(); i2 != characters.end(); i2++){
	character * character = (*i2).second;
	delete character;
	}
	}
	}

	// Extract glyph
	character * freetype::extractGlyph(signed long unicode){
	int w, h, ew;
	character * tempChar = new character();

	// Translate it according to the given italics
	double italics = (double)(size.italics)*GLYPH_PI/180;

	FT_Matrix matrix;
	matrix.xx = 0x10000L;
	matrix.xy = (FT_Fixed)( sin( italics ) * (GLYPH_SQRT2*0x10000L) );
	matrix.yx = 0;
	matrix.yy = 0x10000L;
	FT_Set_Transform( face, &matrix, 0 );

	if (FT_Load_Char(face, unicode, FT_LOAD_TARGET_NORMAL \| FT_LOAD_RENDER \| FT_LOAD_FORCE_AUTOHINT) != 0){
	throw Exception("Could not load freetype glyph");
	}

	w = face->glyph->bitmap.width;
	h = face->glyph->bitmap.rows;
	ew = 0;
	if (!w)ew = 1;
	if (!h)h = 1;

	tempChar->width = (w + ew);
	tempChar->height = h;

	tempChar->rows = face->glyph->bitmap.rows;
	tempChar->grays = face->glyph->bitmap.num_grays;
	tempChar->pitch = face->glyph->bitmap.pitch;
	tempChar->line = new unsigned char[tempChar->rows * tempChar->pitch];
	memcpy(tempChar->line, face->glyph->bitmap.buffer, tempChar->rows * tempChar->pitch);

	tempChar->left = face->glyph->bitmap_left;
	tempChar->top = face->glyph->bitmap_top;
	tempChar->right = face->glyph->advance.x >> 6;
	tempChar->unicode = unicode;

	tempChar->length = ((w + ew)+face->glyph->advance.x) >> 6;

	return tempChar;
	}

	// Create single index
	void freetype::createIndex(){
	std::map<int, std::map<signed long, character*> >::iterator p;
	p = fontTable.find(size.createKey());
	if (p == fontTable.end()){
	if (FT_Set_Pixel_Sizes(face, size.width, size.height) != 0){
	throw Exception("Could not set freetype size");
	}
	FT_UInt glyphIndex;
	FT_ULong unicode = FT_Get_First_Char(face, &glyphIndex);
	std::map<signed long, character*> tempMap;
	while (glyphIndex != 0){
	tempMap.insert(std::make_pair(unicode, extractGlyph(unicode)));
	unicode = FT_Get_Next_Char(face, unicode, &glyphIndex);
	}

	fontTable.insert(std::make_pair(size.createKey(), tempMap));
	}

	if (fontTable.find(size.createKey()) == fontTable.end()){
	printf("ftalleg: inconsistency error\n");
	throw Exception("inconsistency error");
	}
	}

	/*
	pixeler getPutPixel(){
	switch( get_color_depth() ){
	case 8 : return _putpixel;
	case 15 : return _putpixel15;
	case 16 : return _putpixel16;
	case 24 : return _putpixel24;
	case 32 : return _putpixel32;
	default : return putpixel;
	}
	}
	*/

	void drawOneCharacter(const character * tempChar, int & x1, int & y1, FT_UInt sizeHeight, const Graphics::Bitmap & bitmap, const Graphics::Color & color){
	unsigned char * line = tempChar->line;
	int colorRed = Graphics::getRed(color);
	int colorGreen = Graphics::getGreen(color);
	int colorBlue = Graphics::getBlue(color);

	/* cache the last color, there is a good chance it will be reused */
	unsigned char lastData = -1;
	short lastGrays = -1;
	Graphics::Color black = Graphics::makeColor(0, 0, 0);
	Graphics::Color lastColor = black;

	for (int y = 0; y < tempChar->rows; y++){
	unsigned char * buffer = line;
	for (int x = 0; x < tempChar->width; x++){
	Graphics::Color finalColor = black;
	unsigned char current = *buffer;
	buffer++;
	if (current == lastData && lastGrays == tempChar->grays){
	finalColor = lastColor;
	} else {
	Graphics::Color col = fixColor(current, tempChar->grays);

	int red = Graphics::getRed(col);
	int green = Graphics::getGreen(col);
	int blue = Graphics::getBlue(col);

	if ((red < 50) \|\|
	(green < 50) \|\|
	(blue < 50)){
	continue;
	}

	red = red * colorRed / 255;
	green = green * colorGreen / 255;
	blue = blue * colorBlue / 255;

	finalColor = Graphics::makeColor(red, green, blue);
	lastData = current;
	lastColor = finalColor;
	lastGrays = tempChar->grays;
	}

	//col.alpha= col.alpha * color.alpha / 255;
	// putpixel(bitmap,x1+tempChar.left+x,y1 - tempChar.top+y + size.height,makecol(red,blue,green));
	/* dangerous! putter is probably one of the _putpixel* routines so if x or y are off the bitmap
	* you will get a segfault
	*/
	// putter(bitmap,x1+tempChar.left+x,y1 - tempChar.top+y + size.height,makecol(red,blue,green));
	// putter = 0;
	int finalX = x1+tempChar->left+x;
	int finalY = y1 - tempChar->top + y + sizeHeight;
	bitmap.putPixelNormal(finalX, finalY, finalColor);
	}
	line += tempChar->pitch;
	}
	x1 += tempChar->right;
	}

	// Render a character from the lookup table
	void freetype::drawCharacter(signed long unicode, int &x1, int &y1, const Graphics::Bitmap & bitmap, const Graphics::Color &color){

	// pixeler putter = getPutPixel();

	std::map<int, std::map<signed long, character*> >::iterator ft;
	ft = fontTable.find(size.createKey());
	if (ft != fontTable.end()){
	std::map<signed long, character*>::iterator p;
	p = (ft->second).find(unicode);
	if (p != ft->second.end()){
	const character * tempChar = p->second;
	drawOneCharacter(tempChar, x1, y1, size.height, bitmap, color);
	}
	}
	}

	//! Load font from memory
	bool freetype::load(const unsigned char *memoryFont, unsigned int length, int index, unsigned int width, unsigned int height) {
	if(!FT_New_Memory_Face(ftLibrary,memoryFont, length,index,&face)) {
	currentFilename = "memoryFont";
	currentIndex = index;
	faceLoaded = true;
	size.italics = 0;
	setSize(width, height);
	if (FT_HAS_GLYPH_NAMES(face)){
	char buff[1024];
	if(!FT_Get_Glyph_Name(face, currentIndex,buff, sizeof(buff))){
	faceName = currentFilename;
	}
	else faceName = std::string(buff);
	} else {
	faceName = currentFilename;
	}
	if(FT_HAS_KERNING(face))kerning=true;
	else kerning = false;
	} else {
	faceLoaded=false;
	std::cout << "Load system font failed\n";
	}

	return faceLoaded;
	}

	//! Load font from file
	bool freetype::load(const Filesystem::AbsolutePath & filename, int index, unsigned int width, unsigned int height){
	FT_Error error = FT_New_Face(ftLibrary, filename.path().c_str(), index, &face);
	if (error == 0){
	currentFilename = filename.path();
	currentIndex = index;
	faceLoaded = true;
	size.italics = 0;
	setSize(width, height);
	if (FT_HAS_GLYPH_NAMES(face)){
	char buff[1024];
	if (!FT_Get_Glyph_Name(face, currentIndex, buff, sizeof(buff))) {
	faceName = currentFilename;
	} else {
	faceName = std::string(buff);
	}
	} else {
	faceName = currentFilename;
	}

	kerning = FT_HAS_KERNING(face);
	} else {
	faceLoaded = false;
	std::ostringstream fail;
	fail << "Could not load freetype font " << filename.path() << " error code " << error;
	throw Exception(fail.str());
	}

	return faceLoaded;
	}

	//! Get text length
	int freetype::getLength(const std::string & text) {
	Util::Thread::ScopedLock locked(lock);
	int length=0;
	std::map<int, std::map<signed long, character*> >::iterator ft;
	ft = fontTable.find(size.createKey());
	if (ft != fontTable.end()){
	for (unsigned int i = 0; i < text.length(); i++) {
	std::map<signed long, character*>::iterator p;
	signed long unicode = Utf::readUtf8CodePoint(text, &i);
	p = (ft->second).find(unicode);
	if (p != (ft->second).end()){
	if (p != fontTable[size.createKey()].end()){
	length += (p->second)->length;
	}
	}
	}
	}
	return length;
	}

	//! Render font to a bitmap
	void freetype::render(int x, int y, const Graphics::Color & color, const Graphics::Bitmap & bmp, ftAlign alignment, const std::string & text, int marker ...) {
	if (faceLoaded){
	int rend_x = 0;
	int rend_y = 0;
	std::ostringstream str;

	/* use vsnprintf/Util::limitPrintf here? */

	// Get extra arguments
	va_list ap;
	va_start(ap, marker);
	for(unsigned int i = 0; i<text.length();++i) {
	if (text[i] == '%') {
	if(text[i+1]=='s') {
	str << va_arg(ap, char *);
	++i;
	} else if(text[i+1]=='d'\|\|text[i+1]=='i') {
	str << va_arg(ap, signed int);
	++i;
	} else if(text[i+1]=='c') {
	str << (char)va_arg(ap, int);
	++i;
	} else str << text[i];
	} else {
	str << text[i];
	}
	}
	va_end(ap);

	std::string fixedText(str.str());
	switch (alignment) {
	case ftLeft:
	rend_x = x;
	rend_y = y;
	break;
	case ftCenter:
	rend_x = x - getLength(fixedText)/2;
	rend_y = y;
	break;
	case ftRight:
	rend_x = x - getLength(fixedText);
	rend_y = y;
	break;
	default:
	rend_x = x;
	rend_y = y;
	break;
	}

	int previous = 0;
	int next = 0;
	for (unsigned int i = 0; i<fixedText.length(); i++){
	long unicode = Utf::readUtf8CodePoint(fixedText, &i);
	if (kerning && previous && next){
	next = FT_Get_Char_Index(face, unicode);
	FT_Vector delta;
	FT_Get_Kerning(face, previous, next, FT_KERNING_DEFAULT, &delta);
	rend_x += delta.x >> 6;
	previous = next;
	}
	drawCharacter(unicode, rend_x, rend_y, bmp, color);
	}
	}
	}

	int freetype::calculateMaximumHeight(){
	Util::Thread::ScopedLock locked(lock);
	/* uhh, comment out the printf's ?? */
	std::map<int, std::map<signed long, character*> >::iterator ft;
	ft = fontTable.find(size.createKey());
	int top = 0;
	long code = 0;
	if ( ft != fontTable.end() ){
	std::map<signed long, character*>::iterator p;
	std::map< signed long, character* > & map = ft->second;
	for ( p = map.begin(); p != map.end(); p++ ){
	const character * ch = p->second;
	printf( "%c( %ld ). top = %d. rows = %d. total = %d\n", (char) ch->unicode, ch->unicode, ch->top, ch->rows, ch->top + ch->rows );
	if ( ch->top + ch->rows > top ){
	code = ch->unicode;
	top = ch->top + ch->rows;
	}
	}
	}
	printf( "Largest letter = %ld\n", code );
	return top;
	}

	int freetype::height(long code) const {
	Util::Thread::ScopedLock locked(lock);
	std::map<int, std::map<signed long, character*> >::const_iterator ft;
	ft = fontTable.find(size.createKey());
	if (ft != fontTable.end()){
	std::map<signed long, character*>::const_iterator p;
	p = (ft->second).find( code );
	if ( p != (ft->second).end() ){
	const character * temp = p->second;
	// printf( "%c top = %d rows = %d\n", (char) code, temp.top, temp.rows );
	return temp->top + temp->rows;
	}
	} else {
	throw Exception("Internal inconsistency");
	}

	return 0;
	}

	int freetype::calculateHeight(const std::string & str) const {
	int max = 0;
	for ( unsigned int i = 0; i < str.length(); i++ ){
	int q = height(str[i]);
	// printf( "Height of %c is %d\n", str[ i ], q );
	if (q > max){
	max = q;
	}
	}

	return max;
	}

	//! Set size
	void freetype::setSize( unsigned int w, unsigned int h){
	Util::Thread::ScopedLock locked(lock);
	if ( w != size.width \|\| h != size.height ){
	if (internalFix)return;
	if (w<=0 \|\| h<=0)return;
	size.width = w;
	size.height = h;
	createIndex();
	// maximumHeight = calculateMaximumHeight();
	}
	}

	//! Set italics
	void freetype::setItalics(int i){
	Util::Thread::ScopedLock locked(lock);
	if(internalFix)return;
	if(i<-45)i=(-45);
	else if(i>45)i=45;
	size.italics = i;
	createIndex();
	}

	void freetype::getSize(int * w, int * h) const {
	*w = size.width;
	*h = size.height;
	}

	//! Get Width
	int freetype::getWidth() const {
	return size.width;
	}

	//! Get Height
	int freetype::getHeight( const std::string & str ) const {
	// return size.height;
	return calculateHeight(str);
	}

	//! Get Italics
	int freetype::getItalics(){
	return size.italics;
	}
	#endif
	}

	#endif /* FONT_BASE_CPP */
	diff --git a/util/graphics/allegro/bitmap.cpp b/util/graphics/allegro/bitmap.cpp
	index dde818ec..990f6240 100644
	--- a/util/graphics/allegro/bitmap.cpp
	+++ b/util/graphics/allegro/bitmap.cpp
	@@ -1,1881 +1,1881 @@
	/* allegro.h must be on top, don't move it!!!! */
	#include <allegro.h>

	#ifdef _WIN32
	#include <winalleg.h>
	#endif

	#include "gif/algif.h"
	#include "util/init.h"
	#include "loadpng/loadpng.h"
	#include <stdarg.h>
	#include <vector>
	#include <string>
	#include <iostream>
	#include <math.h>
	#include "util/funcs.h"
	#include <stdio.h>
	#include "util/exceptions/load_exception.h"
	#include "util/memory.h"
	#include <sstream>
	// #include <fblend.h>

	#ifdef _WIN32
	#include <winalleg.h>
	#define EXTERNAL_VARIABLE __declspec(dllimport)
	#else
	#define EXTERNAL_VARIABLE
	#endif

	using namespace std;

	#ifndef debug
	#define debug cout<<"File: "<<__FILE__<<" Line: "<<__LINE__<<endl;
	#endif

	/* These have to go outside the Graphics namespace for some reason */
	/* defined at allegro/include/internal/aintern.h:457 */
	extern EXTERNAL_VARIABLE BLENDER_FUNC _blender_func16;
	/* defined at allegro/include/internal/aintern.h:466 */
	extern EXTERNAL_VARIABLE int _blender_col_16;
	/* defined at allegro/include/internal/aintern.h:470 */
	extern EXTERNAL_VARIABLE int _blender_alpha;

	namespace Graphics{

	enum DrawingModes{
	MODE_TRANS,
	MODE_SOLID
	};

	/* FIXME: try to get rid of these variables */
	static int SCALE_X;
	static int SCALE_Y;

	static void paintown_draw_sprite_ex16( BITMAP * dst, BITMAP * src, int dx, int dy, int mode, int flip, Bitmap::Filter * filter);
	static void paintown_draw_sprite_filter_ex16(BITMAP * dst, BITMAP * src, int x, int y, const Bitmap::Filter & filter);
	-static void paintown_light16(BITMAP * dst, const int x, const int y, const int width, const int height, const int start_y, const int focus_alpha, const int edge_alpha, const int focus_color, const int edge_color);
	-static void paintown_applyTrans16(BITMAP * dst, const int color);
	+static void paintown_light16(BITMAP * dst, const int x, const int y, const int width, const int height, const int start_y, const int focus_alpha, const int edge_alpha, const Color focus_color, const Color edge_color);
	+static void paintown_applyTrans16(BITMAP * dst, const Color color);

	-int MaskColor(){
	- return MASK_COLOR_16;
	+Color MaskColor(){
	+ return Color(MASK_COLOR_16);
	}

	static Bitmap * Scaler = NULL;
	static Bitmap * Buffer = NULL;

	static void drawingMode(int mode){
	// drawing_mode( DRAW_MODE_TRANS, NULL, 0, 0 );
	switch( mode ){
	case MODE_TRANS : {
	drawing_mode( DRAW_MODE_TRANS, NULL, 0, 0 );
	break;
	}
	case MODE_SOLID : {
	drawing_mode( DRAW_MODE_SOLID, NULL, 0, 0 );
	break;
	}
	}
	}


	Bitmap::Bitmap():
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap( 10, 10 ))));
	if (! getData()->getBitmap()){
	error = true;
	cerr << "Could not create bitmap!" << endl;
	} else {
	clear();
	}
	}

	Bitmap::Bitmap( int x, int y ):
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	if ( x < 1 ){
	x = 1;
	}
	if ( y < 1 ){
	y = 1;
	}
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(x, y))));
	if ( ! getData()->getBitmap() ){
	error = true;
	cerr << "Could not create bitmap!" << endl;
	} else {
	clear();
	}
	}

	static BITMAP * memoryPNG(const char * data, int length){
	return load_memory_png(data, length, NULL);
	}

	static BITMAP * memoryGIF(const char * data, int length){
	PACKFILE_VTABLE table = Memory::makeTable();
	Memory::memory memory((unsigned char *) data, length);

	PACKFILE * pack = pack_fopen_vtable(&table, &memory);
	/* need to supply a proper palette at some point */
	RGB * palette = NULL;
	/* algif will close the packfile for us in both error and success cases */
	BITMAP * gif = load_gif_packfile(pack, palette);
	if (!gif){
	// pack_fclose(pack);
	ostringstream out;
	out <<"Could not load gif from memory: " << (void*) data << " length " << length;
	throw LoadException(__FILE__, __LINE__, out.str());
	}

	#if 0
	/* converts 8-bit pcx mask to allegro's mask */
	if (mask){
	/* warning! 8-bit assumptions */
	int colors = 256;
	int maskR = (int)data[length - colors*3 + 0];
	int maskG = (int)data[length - colors*3 + 1];
	int maskB = (int)data[length - colors*3 + 2];
	int mask = makeColor(maskR, maskG, maskB);

	// printf("mask r %d g %d b %d = %d\n", maskR, maskG, maskB, mask);

	if (mask != MaskColor()){
	for( int i = 0; i < pcx->h; ++i ){
	for( int j = 0; j < pcx->w; ++j ){
	/* use getPixel/putPixel? */
	int pix = getpixel(pcx,j,i);
	if (pix == mask){
	putpixel(pcx,j,i, MaskColor());
	}
	}
	}
	}
	}
	#endif

	BITMAP * out = create_bitmap(gif->w, gif->h);
	blit(gif, out, 0, 0, 0, 0, gif->w, gif->h);
	destroy_bitmap(gif);
	// pack_fclose(pack);

	return out;
	}

	static BITMAP * load_bitmap_from_memory(const char * data, int length, ImageFormat type){
	switch (type){
	case FormatPNG: {
	return memoryPNG(data, length);
	}
	case FormatBMP: throw BitmapException(__FILE__, __LINE__, "Could not load .bmp file from memory");
	case FormatJPG: throw BitmapException(__FILE__, __LINE__, "Could not load .jpg file from memory");
	case FormatPCX: {
	Bitmap pcx(memoryPCX((unsigned char * const) data, length, false));
	BITMAP * out = create_bitmap(pcx.getWidth(), pcx.getHeight());
	blit(pcx.getData()->getBitmap(), out, 0, 0, 0, 0, out->w, out->h);
	return out;
	}
	case FormatTGA: throw BitmapException(__FILE__, __LINE__, "Could not load .tga file from memory");
	case FormatTIF: throw BitmapException(__FILE__, __LINE__, "Could not load .tif file from memory");
	case FormatXPM: throw BitmapException(__FILE__, __LINE__, "Could not load .xpm file from memory");
	case FormatGIF: {
	return memoryGIF(data, length);
	}
	case FormatUnknown: throw BitmapException(__FILE__, __LINE__, "Could not load unknown formatted image file");
	}
	throw BitmapException(__FILE__, __LINE__, "Internal error");
	}

	Bitmap::Bitmap(const char * data, int length):
	mustResize(false),
	error(false),
	bit8MaskColor(0){
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(load_bitmap_from_memory(data, length, identifyImage((unsigned char *) data, length)))));
	}

	void Bitmap::loadFromMemory(const char * data, int length){
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(load_bitmap_from_memory(data, length, identifyImage((unsigned char *) data, length)))));
	}

	/* If a BITMAP is given to us, we didn't make it so we don't own it */
	Bitmap::Bitmap( BITMAP * who, bool deep_copy ):
	mustResize(false),
	error( false ),
	bit8MaskColor(0){

	if ( deep_copy ){
	BITMAP * his = who;
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(his->w, his->h))));
	if ( ! getData()->getBitmap() ){
	cout << "Could not create bitmap" << endl;
	error = true;
	}
	::blit( his, getData()->getBitmap(), 0, 0, 0, 0, his->w, his->h );
	} else {
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(who)));
	}
	}

	Bitmap::Bitmap( const char * load_file ):
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	internalLoadFile( load_file );
	/*
	my_bitmap = load_bitmap( load_file, NULL );
	if ( !my_bitmap ){
	my_bitmap = create_bitmap( 100, 100 );
	clear( my_bitmap );
	cout<<"Could not load "<<load_file<<endl;
	error = true;
	}
	own = true;
	*/
	}

	Bitmap::Bitmap( const string & load_file ):
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	internalLoadFile( load_file.c_str() );
	}

	Bitmap::Bitmap( const char * load_file, int sx, int sy ):
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	path = load_file;
	BITMAP * temp = load_bitmap( load_file, NULL );
	// my_bitmap = load_bitmap( load_file, NULL );
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(sx, sy))));
	// clear( my_bitmap );
	if ( !temp \|\| ! getData()->getBitmap() ){
	cout<<"Could not load "<<load_file<<endl;
	error = true;
	} else {
	clear();
	stretch_blit( temp, getData()->getBitmap(), 0, 0, temp->w, temp->h, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );
	destroy_bitmap( temp );
	}
	}

	Bitmap::Bitmap( const char * load_file, int sx, int sy, double accuracy ):
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	path = load_file;
	BITMAP * temp = load_bitmap( load_file, NULL );
	if ( !temp ){
	cout<<"Could not load "<<load_file<<endl;
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap( sx, sy ))));
	// clear( my_bitmap );
	clear();
	error = true;
	} else {
	if ( temp->w > sx \|\| temp->h > sy ){
	double bx = temp->w / sx;
	double by = temp->h / sy;
	double use;
	use = bx > by ? bx : by;
	int fx = (int)(sx / use);
	int fy = (int)(sy / use);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap( fx, fy ))));

	stretch_blit( temp, getData()->getBitmap(), 0, 0, temp->w, temp->h, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );

	destroy_bitmap( temp );
	} else {
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(temp)));
	}
	}
	// own = true;
	}

	Bitmap::Bitmap( const Bitmap & copy, int sx, int sy ):
	mustResize(false),
	error( false ),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	BITMAP * temp = copy.getData()->getBitmap();
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(sx, sy))));
	if ( ! getData()->getBitmap() ){
	error = true;
	cout << "Could not copy bitmap" << endl;
	}
	// clear( my_bitmap );
	clear();
	stretch_blit( temp, getData()->getBitmap(), 0, 0, temp->w, temp->h, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );
	}

	Bitmap::Bitmap( const Bitmap & copy, int sx, int sy, double accuracy ):
	mustResize(false),
	error( false ),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	BITMAP * temp = copy.getData()->getBitmap();
	if ( temp->w > sx \|\| temp->h > sy ){
	double bx = (double)temp->w / (double)sx;
	double by = (double)temp->h / (double)sy;
	double use;
	use = bx > by ? bx : by;
	int fx = (int)(temp->w / use);
	int fy = (int)(temp->h / use);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(fx, fy))));
	if ( ! getData()->getBitmap() ){
	allegro_message("Could not create bitmap\n");
	// own = false;
	// own = copy.own;
	// *own++;
	error = true;
	return;
	}

	stretch_blit( temp, getData()->getBitmap(), 0, 0, temp->w, temp->h, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );
	// destroy_bitmap( temp );
	} else {
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(temp->w, temp->h))));
	blit( temp, getData()->getBitmap(), 0, 0, 0, 0, temp->w, temp->h );
	// own = new int
	// own = true;
	}
	}

	Bitmap::Bitmap( const Bitmap & copy, bool deep_copy ):
	mustResize(false),
	error( false ),
	bit8MaskColor(copy.bit8MaskColor){

	path = copy.getPath();
	if ( deep_copy ){
	BITMAP * his = copy.getData()->getBitmap();
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(his->w, his->h))));
	if ( ! getData()->getBitmap() ){
	cout << "Could not create bitmap" << endl;
	error = true;
	}
	::blit( his, getData()->getBitmap(), 0, 0, 0, 0, his->w, his->h );
	} else {
	setData(copy.getData());
	}
	/*
	BITMAP * his = copy.getBitmap();
	my_bitmap = create_bitmap( his->w, his->h );
	::blit( his, my_bitmap, 0, 0, 0, 0, his->w, his->h );
	own = true;
	*/
	}

	Bitmap::Bitmap( const Bitmap & copy, int x, int y, int width, int height ):
	mustResize(false),
	error( false ),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	BITMAP * his = copy.getData()->getBitmap();
	if ( x < 0 )
	x = 0;
	if ( y < 0 )
	y = 0;
	if ( width + x > his->w )
	width = his->w - x;
	if ( height + y > his->h )
	height = his->h - y;
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_sub_bitmap(his, x, y, width, height))));

	if ( ! getData()->getBitmap() ){
	cout<<"Could not create sub-bitmap"<<endl;
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(10, 10))));
	// clear( my_bitmap );
	clear();
	}
	}

	void Bitmap::internalLoadFile( const char * load_file ){
	path = load_file;
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(load_bitmap(load_file, NULL))));
	if ( ! getData()->getBitmap() ){
	cout<<"Could not load "<<load_file<<". Using default"<<endl;
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(create_bitmap(10, 10))));
	if ( ! getData()->getBitmap() ){
	cout<<"Out of memory or Allegro not initialized"<<endl;
	error = true;
	return;
	}
	// clear( my_bitmap );
	clear();
	// cout<<"Could not load "<<load_file<<endl;
	error = true;
	}
	}

	void Bitmap::save( const string & str ) const {
	save_bitmap( str.c_str(), getData()->getBitmap(), NULL );
	}

	Bitmap memoryPCX(unsigned char * const data, const int length, const bool mask){
	PACKFILE_VTABLE table = Memory::makeTable();
	Memory::memory memory(data, length);

	PACKFILE * pack = pack_fopen_vtable(&table, &memory);
	/* need to supply a proper palette at some point */
	RGB * palette = NULL;
	BITMAP * pcx = load_pcx_pf(pack, palette);
	if (!pcx){
	pack_fclose(pack);
	ostringstream out;
	out <<"Could not load pcx from memory: " << (void*) data << " length " << length;
	throw LoadException(__FILE__, __LINE__, out.str());
	}

	int colors = 256;
	int maskR = (int)data[length - colors*3 + 0];
	int maskG = (int)data[length - colors*3 + 1];
	int maskB = (int)data[length - colors*3 + 2];
	- int maskColor = makeColor(maskR, maskG, maskB);
	+ Color maskColor = makeColor(maskR, maskG, maskB);


	#if 0
	/* converts 8-bit pcx mask to allegro's mask */
	if (mask){
	/* warning! 8-bit assumptions */
	int colors = 256;
	int maskR = (int)data[length - colors*3 + 0];
	int maskG = (int)data[length - colors*3 + 1];
	int maskB = (int)data[length - colors*3 + 2];
	int mask = makeColor(maskR, maskG, maskB);

	// printf("mask r %d g %d b %d = %d\n", maskR, maskG, maskB, mask);

	if (mask != MaskColor()){
	for( int i = 0; i < pcx->h; ++i ){
	for( int j = 0; j < pcx->w; ++j ){
	/* use getPixel/putPixel? */
	int pix = getpixel(pcx,j,i);
	if (pix == mask){
	putpixel(pcx,j,i, MaskColor());
	}
	}
	}
	}
	}
	#endif

	Bitmap bitmap(pcx, true);
	bitmap.set8BitMaskColor(maskColor);
	destroy_bitmap(pcx);
	pack_fclose(pack);

	return bitmap;
	}

	Bitmap * getScreenBuffer(){
	return Scaler;
	}

	void initializeExtraStuff(){
	/* nothing yet */
	}

	int Bitmap::getWidth() const{
	return getData()->getBitmap()->w;
	}

	int Bitmap::getHeight() const{
	return getData()->getBitmap()->h;
	}

	-int getRed( int x ){
	- return ::getr( x );
	+int getRed( Color x ){
	+ return ::getr( x.color );
	}

	-int getBlue( int x ){
	- return ::getb( x );
	+int getBlue( Color x ){
	+ return ::getb( x.color );
	}

	-int getGreen( int x ){
	- return ::getg( x );
	+int getGreen( Color x ){
	+ return ::getg( x.color );
	}

	void Bitmap::setClipRect( int x1, int y1, int x2, int y2 ) const {
	::set_clip_rect( getData()->getBitmap(), x1, y1, x2, y2 );
	}

	void Bitmap::getClipRect(int & x1, int & y1, int & x2, int & y2) const {
	::get_clip_rect(getData()->getBitmap(), &x1, &y1, &x2, &y2);
	}

	/*
	const string & Bitmap::getPath() const{
	return path;
	}
	*/

	void Bitmap::debugSelf() const{
	cout<<"Bitmap: "<<endl;
	cout<<"Self = "<< getData()->getBitmap() <<endl;
	cout<<"Path = "<<path<<endl;
	}

	/*
	Bitmap::~Bitmap(){
	releaseInternalBitmap();
	}
	*/

	void Bitmap::detach(){

	/*
	if ( own ){
	(*own)--;

	if ( *own == 0 ){
	destroy_bitmap( getBitmap() );
	delete own;
	}
	}
	*/
	}

	/*
	BITMAP * Bitmap::getBitmap() const{
	return my_bitmap;
	}
	*/

	bool Bitmap::getError(){
	return error;
	}

	/*
	int Bitmap::getWidth(){
	return my_bitmap->w;
	}

	int Bitmap::getHeight(){
	return my_bitmap->h;
	}
	*/

	void Bitmap::acquire(){
	acquire_bitmap( getData()->getBitmap() );
	}

	void Bitmap::release(){
	release_bitmap( getData()->getBitmap() );
	}

	-void Bitmap::circleFill( int x, int y, int radius, int color ) const {
	- ::circlefill( getData()->getBitmap(), x, y, radius, color );
	+void Bitmap::circleFill( int x, int y, int radius, Color color ) const {
	+ ::circlefill( getData()->getBitmap(), x, y, radius, color.color );
	}

	-void TranslucentBitmap::circleFill(int x, int y, int radius, int color) const {
	+void TranslucentBitmap::circleFill(int x, int y, int radius, Color color) const {
	drawingMode(MODE_TRANS);
	Bitmap::circleFill(x, y, radius, color);
	drawingMode(MODE_SOLID);
	}

	-void Bitmap::circle( int x, int y, int radius, int color ) const{
	- ::circle( getData()->getBitmap(), x, y, radius, color );
	+void Bitmap::circle( int x, int y, int radius, Color color ) const{
	+ ::circle( getData()->getBitmap(), x, y, radius, color.color );
	}

	/* FIXME */
	-void Bitmap::circle( int x, int y, int radius, int thickness, int color ) const{
	- ::circle( getData()->getBitmap(), x, y, radius, color );
	+void Bitmap::circle( int x, int y, int radius, int thickness, Color color ) const{
	+ ::circle( getData()->getBitmap(), x, y, radius, color.color );
	}

	-void Bitmap::line( const int x1, const int y1, const int x2, const int y2, const int color ) const{
	- ::fastline( getData()->getBitmap(), x1, y1, x2, y2, color );
	+void Bitmap::line( const int x1, const int y1, const int x2, const int y2, const Color color ) const{
	+ ::fastline( getData()->getBitmap(), x1, y1, x2, y2, color.color );
	}

	-void TranslucentBitmap::line(const int x1, const int y1, const int x2, const int y2, const int color) const{
	+void TranslucentBitmap::line(const int x1, const int y1, const int x2, const int y2, const Color color) const{
	drawingMode(MODE_TRANS);
	Bitmap::line(x1, y1, x2, y2, color);
	drawingMode(MODE_SOLID);
	}

	-void Bitmap::floodfill( const int x, const int y, const int color ) const {
	- ::floodfill( getData()->getBitmap(), x, y, color );
	+void Bitmap::floodfill( const int x, const int y, const Color color ) const {
	+ ::floodfill( getData()->getBitmap(), x, y, color.color );
	}

	-void Bitmap::drawCharacter( const int x, const int y, const int color, const int background, const Bitmap & where ) const {
	- ::draw_character_ex( where.getData()->getBitmap(), getData()->getBitmap(), x, y, color, background );
	+void Bitmap::drawCharacter( const int x, const int y, const Color color, const int background, const Bitmap & where ) const {
	+ ::draw_character_ex( where.getData()->getBitmap(), getData()->getBitmap(), x, y, color.color, background );
	}

	void Bitmap::alphaBlender(int source, int dest){
	/* TODO */
	}

	void Bitmap::transBlender( int r, int g, int b, int a ){
	set_trans_blender( r, g, b, a );
	}

	void Bitmap::multiplyBlender( int r, int g, int b, int a ){
	set_multiply_blender( r, g, b, a );
	}

	void Bitmap::dissolveBlender( int r, int g, int b, int a ){
	set_dissolve_blender( r, g, b, a );
	}

	void Bitmap::addBlender( int r, int g, int b, int a ){
	set_add_blender( r, g, b, a );
	}

	void Bitmap::burnBlender( int r, int g, int b, int a ){
	set_burn_blender( r, g, b, a );
	}

	void Bitmap::colorBlender( int r, int g, int b, int a ){
	set_color_blender( r, g, b, a );
	}

	void Bitmap::differenceBlender( int r, int g, int b, int a ){
	set_difference_blender( r, g, b, a );
	}

	void Bitmap::dodgeBlender( int r, int g, int b, int a ){
	set_dodge_blender( r, g, b, a );
	}

	void Bitmap::hueBlender( int r, int g, int b, int a ){
	set_hue_blender( r, g, b, a );
	}

	void Bitmap::luminanceBlender( int r, int g, int b, int a ){
	set_luminance_blender( r, g, b, a );
	}

	void Bitmap::invertBlender( int r, int g, int b, int a ){
	set_invert_blender( r, g, b, a );
	}

	void Bitmap::screenBlender( int r, int g, int b, int a ){
	set_screen_blender( r, g, b, a );
	}

	void Bitmap::replaceColor(const Color & original, const Color & replaced){
	int height = getHeight();
	int width = getWidth();
	BITMAP * bitmap = getData()->getBitmap();
	for (int i = 0; i < height; ++i ){
	for( int j = 0; j < width; ++j ){
	/* use getPixel/putPixel? */
	- int pix = getpixel(bitmap, j,i);
	- if (pix == original){
	- putpixel(bitmap, j, i, replaced);
	+ int pix = getpixel(bitmap, j, i);
	+ if (pix == original.color){
	+ putpixel(bitmap, j, i, replaced.color);
	}
	}
	}
	}

	int setGraphicsMode( int mode, int width, int height ){
	int ok = ::set_gfx_mode(mode, width, height, 0, 0);
	if ( ok == 0 ){
	if (SCALE_X == 0){
	SCALE_X = width;
	}
	if (SCALE_Y == 0){
	SCALE_Y = height;
	}
	if ( Screen != NULL ){
	delete Screen;
	Screen = NULL;
	}
	/*
	if ( Scaler != NULL ){
	delete Scaler;
	Scaler = NULL;
	}
	*/
	if ( Buffer != NULL ){
	delete Buffer;
	Buffer = NULL;
	}
	if (width != 0 && height != 0){
	Screen = new Bitmap( ::screen );
	Screen->getData()->setDestroy(false);
	if (Scaler == NULL){
	Scaler = new Bitmap(width, height);
	} else {
	Scaler->updateSize(width, height);
	}
	/*
	if ( width != 0 && height != 0 && (width != SCALE_X \|\| height != SCALE_Y) ){
	Scaler = new Bitmap(width, height);
	// Buffer = new Bitmap(SCALE_X, SCALE_Y);
	}
	*/
	}
	}
	return ok;
	}

	void Bitmap::shutdown(){
	delete Screen;
	Screen = NULL;
	delete Scaler;
	Scaler = NULL;
	delete Buffer;
	Buffer = NULL;
	}


	/*
	const int Bitmap::getWidth() const{
	return getBitmap()->w;
	}

	const int Bitmap::getHeight() const{
	return getBitmap()->h;
	}
	*/

	-int Bitmap::getPixel( const int x, const int y ) const{
	- if ( x >= 0 && x < getData()->getBitmap()->w && y >= 0 && y < getData()->getBitmap()->h )
	- return _getpixel16( getData()->getBitmap(), x, y );
	- return -1;
	+Color Bitmap::getPixel( const int x, const int y ) const{
	+ if ( x >= 0 && x < getData()->getBitmap()->w && y >= 0 && y < getData()->getBitmap()->h )
	+ return Color(_getpixel16( getData()->getBitmap(), x, y ));
	+ return Color(-1);
	}

	-void Bitmap::readLine( vector< int > & vec, int y ){
	- if ( y >= 0 && y < getData()->getBitmap()->h ){
	- for ( int q = 0; q < getData()->getBitmap()->w; q++ ){
	- // int col = my_bitmap->line[ y ][ q ];
	- int col = _getpixel16( getData()->getBitmap(), q, y );
	- vec.push_back( col );
	- }
	- }
	+void Bitmap::readLine( vector< Color > & vec, int y ){
	+ if ( y >= 0 && y < getData()->getBitmap()->h ){
	+ for ( int q = 0; q < getData()->getBitmap()->w; q++ ){
	+ // int col = my_bitmap->line[ y ][ q ];
	+ int col = _getpixel16( getData()->getBitmap(), q, y );
	+ vec.push_back(Color(col) );
	+ }
	+ }
	}

	int setGfxModeText(){
	- return setGraphicsMode(GFX_TEXT, 0, 0);
	+ return setGraphicsMode(GFX_TEXT, 0, 0);
	}

	int setGfxModeFullscreen(int x, int y){
	- return setGraphicsMode(GFX_AUTODETECT_FULLSCREEN, x, y);
	+ return setGraphicsMode(GFX_AUTODETECT_FULLSCREEN, x, y);
	}

	int setGfxModeWindowed(int x, int y){
	- return setGraphicsMode(GFX_AUTODETECT_WINDOWED, x, y);
	+ return setGraphicsMode(GFX_AUTODETECT_WINDOWED, x, y);
	}

	-int makeColor( int r, int g, int b ){
	- return ::makecol16( r, g, b );
	+Color makeColor( int r, int g, int b ){
	+ return Color(::makecol16( r, g, b ));
	}

	void hsvToRGB( float h, float s, float v, int * r, int * g, int * b ){
	::hsv_to_rgb( h, s, v, r, g, b );
	}

	void Bitmap::rgbToHSV(int r, int g, int b, float * h, float * s, float * v){
	::rgb_to_hsv(r, g, b, h, s, v);
	}


	-int Bitmap::addColor( int color1, int color2 ){
	- return makeColor( getr( color1 ) + getr( color2 ),
	- getg( color1 ) + getg( color2 ),
	- getb( color1 ) + getb( color2 ) );
	+Color Bitmap::addColor( Color color1, Color color2 ){
	+ return makeColor( getr( color1.color ) + getr( color2.color ),
	+ getg( color1.color ) + getg( color2.color ),
	+ getb( color1.color ) + getb( color2.color ) );
	}

	-void Bitmap::putPixelNormal(int x, int y, int col) const {
	+void Bitmap::putPixelNormal(int x, int y, Color col) const {
	BITMAP * dst = getData()->getBitmap();
	- ::putpixel(dst, x, y, col);
	+ ::putpixel(dst, x, y, col.color);
	}

	/* FIXME: its pretty slow to keep setting the drawing mode. Either
	* 1) dont use translucent putpixel that much or
	* 2) somehow cache the drawing mode so that its not reset every time
	*/
	-void TranslucentBitmap::putPixelNormal(int x, int y, int color) const {
	+void TranslucentBitmap::putPixelNormal(int x, int y, Color color) const {
	drawingMode(MODE_TRANS);
	Bitmap::putPixelNormal(x, y, color);
	drawingMode(MODE_SOLID);
	}

	-void Bitmap::putPixel( int x, int y, int col ) const{
	+void Bitmap::putPixel( int x, int y, Color col ) const{
	BITMAP * dst = getData()->getBitmap();
	if (dst->clip && ((x < dst->cl) \|\| (x >= dst->cr) \|\| (y < dst->ct) \|\| (y >= dst->cb))){
	return;
	}
	if ( x >= 0 && x < getData()->getBitmap()->w && y >= 0 && y < getData()->getBitmap()->h )
	- _putpixel16( getData()->getBitmap(), x, y, col );
	+ _putpixel16( getData()->getBitmap(), x, y, col.color );
	}

	/*
	void Bitmap::printf( int x, int y, int color, FONT * f, const char * str, ... ) const{

	char buf[512];
	va_list ap;

	va_start(ap, str);
	uvszprintf(buf, sizeof(buf), str, ap);
	va_end(ap);

	textout_ex( getBitmap(), f, buf, x, y, color, -1);
	}

	void Bitmap::printf( int x, int y, int color, const Font * const f, const char * str, ... ) const{

	char buf[512];
	va_list ap;

	va_start(ap, str);
	uvszprintf(buf, sizeof(buf), str, ap);
	va_end(ap);

	textout_ex( getBitmap(), f->getInternalFont(), buf, x, y, color, -1);
	}

	void Bitmap::printf( int x, int y, int color, const Font * const f, const string & str ) const{
	printf( x, y, color, f, str.c_str() );
	}

	void Bitmap::printf( int x, int y, int color, const Font & f, const string & str ) const{
	printf( x, y, color, &f, str );
	}

	void Bitmap::printfNormal( int x, int y, int color, const char * str, ... ) const{

	char buf[512];
	va_list ap;

	va_start(ap, str);
	uvszprintf(buf, sizeof(buf), str, ap);
	va_end(ap);

	textout_ex( getBitmap(), font, buf, x, y, color, -1);

	}

	void Bitmap::printfNormal( int x, int y, int color, const string & str ) const{
	printfNormal( x, y, color, "%s", str.c_str() );
	}
	*/

	-void Bitmap::triangle( int x1, int y1, int x2, int y2, int x3, int y3, int color ) const{
	- ::triangle( getData()->getBitmap(), x1, y1, x2, y2, x3, y3, color );
	+void Bitmap::triangle( int x1, int y1, int x2, int y2, int x3, int y3, Color color ) const{
	+ ::triangle( getData()->getBitmap(), x1, y1, x2, y2, x3, y3, color.color );
	}

	-void Bitmap::ellipse( int x, int y, int rx, int ry, int color ) const {
	- ::ellipse( getData()->getBitmap(), x, y, rx, ry, color );
	+void Bitmap::ellipse( int x, int y, int rx, int ry, Color color ) const {
	+ ::ellipse( getData()->getBitmap(), x, y, rx, ry, color.color );
	}

	-void TranslucentBitmap::ellipse(int x, int y, int rx, int ry, int color) const {
	+void TranslucentBitmap::ellipse(int x, int y, int rx, int ry, Color color) const {
	drawingMode(MODE_TRANS);
	Bitmap::ellipse(x, y, rx, ry, color);
	drawingMode(MODE_SOLID);
	}

	-void TranslucentBitmap::ellipseFill(int x, int y, int rx, int ry, int color) const {
	+void TranslucentBitmap::ellipseFill(int x, int y, int rx, int ry, Color color) const {
	drawingMode(MODE_TRANS);
	Bitmap::ellipseFill(x, y, rx, ry, color);
	drawingMode(MODE_SOLID);
	}

	-void Bitmap::ellipseFill( int x, int y, int rx, int ry, int color ) const {
	- ::ellipsefill( getData()->getBitmap(), x, y, rx, ry, color );
	+void Bitmap::ellipseFill( int x, int y, int rx, int ry, Color color ) const {
	+ ::ellipsefill( getData()->getBitmap(), x, y, rx, ry, color.color );
	}

	-void Bitmap::rectangle( int x1, int y1, int x2, int y2, int color ) const{
	- ::rect( getData()->getBitmap(), x1, y1, x2, y2, color );
	+void Bitmap::rectangle( int x1, int y1, int x2, int y2, Color color ) const{
	+ ::rect( getData()->getBitmap(), x1, y1, x2, y2, color.color );
	}

	-void TranslucentBitmap::rectangle( int x1, int y1, int x2, int y2, int color ) const {
	+void TranslucentBitmap::rectangle( int x1, int y1, int x2, int y2, Color color ) const {
	drawingMode(MODE_TRANS);
	Bitmap::rectangle(x1, y1, x2, y2, color);
	drawingMode(MODE_SOLID);
	}

	-void Bitmap::rectangleFill( int x1, int y1, int x2, int y2, int color ) const{
	- ::rectfill( getData()->getBitmap(), x1, y1, x2, y2, color );
	+void Bitmap::rectangleFill( int x1, int y1, int x2, int y2, Color color ) const{
	+ ::rectfill( getData()->getBitmap(), x1, y1, x2, y2, color.color );
	}

	-void TranslucentBitmap::rectangleFill( int x1, int y1, int x2, int y2, int color ) const{
	+void TranslucentBitmap::rectangleFill( int x1, int y1, int x2, int y2, Color color ) const{
	drawingMode(MODE_TRANS);
	Bitmap::rectangleFill(x1, y1, x2, y2, color);
	drawingMode(MODE_SOLID);
	}

	/*
	int Bitmap::getPixel( int x, int y ){
	if ( x >= 0 && x < my_bitmap->w && y >= 0 && y <= my_bitmap->h )
	return _getpixel16( my_bitmap, x, y );
	return -1;
	}
	*/

	/*
	int Bitmap::makeColor( int r, int g, int b ){
	return makecol16( r, g, b );
	}
	*/

	-void Bitmap::hLine( const int x1, const int y, const int x2, const int color ) const{
	- ::hline( getData()->getBitmap(), x1, y, x2, color );
	+void Bitmap::hLine( const int x1, const int y, const int x2, const Color color ) const{
	+ ::hline( getData()->getBitmap(), x1, y, x2, color.color );
	}

	-void TranslucentBitmap::hLine( const int x1, const int y, const int x2, const int color ) const{
	+void TranslucentBitmap::hLine( const int x1, const int y, const int x2, const Color color ) const{
	drawingMode(MODE_TRANS);
	- ::hline(getData()->getBitmap(), x1, y, x2, color);
	+ ::hline(getData()->getBitmap(), x1, y, x2, color.color);
	drawingMode(MODE_SOLID);
	}

	-void Bitmap::vLine( const int y1, const int x, const int y2, const int color ) const{
	- ::vline( getData()->getBitmap(), x, y1, y2, color );
	+void Bitmap::vLine( const int y1, const int x, const int y2, const Color color ) const{
	+ ::vline( getData()->getBitmap(), x, y1, y2, color.color );
	}

	-void Bitmap::polygon( const int * verts, const int nverts, const int color ) const{
	- ::polygon( getData()->getBitmap(), nverts, verts, color );
	+void Bitmap::polygon( const int * verts, const int nverts, const Color color ) const{
	+ ::polygon( getData()->getBitmap(), nverts, verts, color.color );
	}

	/* These values are specified in 16.16 fixed point format, with 256 equal to
	* a full circle, 64 a right angle, etc. Zero is to the right of the centre
	* point, and larger values rotate anticlockwise from there.
	*/
	static const double RAD_TO_DEG = 180.0/Util::pi;
	static const double DEG_TO_RAD = Util::pi/180.0;

	static double toDegrees(double radians){
	return RAD_TO_DEG * radians;
	}

	double toAllegroDegrees(double radians){
	return toDegrees(radians) * 256.0 / 365;
	}

	-void Bitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	+void Bitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	::fixed angle1 = ::ftofix(toAllegroDegrees(-(ang1 - Util::pi/2)));
	::fixed angle2 = ::ftofix(toAllegroDegrees(-(ang2 - Util::pi/2)));
	if (angle1 > angle2){
	::fixed swap = angle1;
	angle1 = angle2;
	angle2 = swap;
	}
	- ::arc(getData()->getBitmap(), x, y, angle1, angle2, radius, color);
	+ ::arc(getData()->getBitmap(), x, y, angle1, angle2, radius, color.color);
	}

	-void TranslucentBitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	+void TranslucentBitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	drawingMode(MODE_TRANS);
	Bitmap::arc(x, y, ang1, ang2, radius, color);
	drawingMode(MODE_SOLID);
	}

	struct ArcPoint{
	int x;
	int y;
	};

	struct ArcPoints{
	ArcPoints(int radius):
	next(0),
	size(0){
	/* 1/4th of the circumference = 2 * pi * r / 4 */
	size = (Util::pi * radius / 2);
	if (size < 2){
	size = 2;
	}
	points = new ArcPoint[size];
	}

	void save(int x, int y){
	if (next < size){
	points[next].x = x;
	points[next].y = y;
	next += 1;
	}
	}

	~ArcPoints(){
	delete[] points;
	}

	ArcPoint * points;
	int next;
	int size;
	};

	void store_arc_points(BITMAP * _store, int x, int y, int color){
	ArcPoints * store = (ArcPoints*) _store;
	store->save(x, y);
	}

	void drawFilledArc(const int x, const int y, ::fixed angle1, ::fixed angle2, int radius, Color color, BITMAP * paint){
	// num_segments = fabs(delta_theta / (2 * ALLEGRO_PI) * ALLEGRO_PRIM_QUALITY * sqrtf(r));
	ArcPoints store(radius);
	- do_arc((BITMAP*) &store, x, y, angle1, angle2, radius, color, store_arc_points);
	+ do_arc((BITMAP*) &store, x, y, angle1, angle2, radius, color.color, store_arc_points);
	/* for each point on the arc draw a vertical line */
	for (int index = 0; index < store.next; index += 1){
	int x1 = x;
	int y1 = y;
	int x2 = store.points[index].x;
	int y2 = store.points[index].y;
	- ::vline(paint, x2, y1, y2, color);
	+ ::vline(paint, x2, y1, y2, color.color);
	}
	}

	-void Bitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const{
	+void Bitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const{
	::fixed angle1 = ::ftofix(toAllegroDegrees(-(ang1 - Util::pi/2)));
	::fixed angle2 = ::ftofix(toAllegroDegrees(-(ang2 - Util::pi/2)));
	if (angle1 > angle2){
	::fixed swap = angle1;
	angle1 = angle2;
	angle2 = swap;
	}
	drawFilledArc(x, y, angle1, angle2, radius, color, getData()->getBitmap());
	}

	-void TranslucentBitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	+void TranslucentBitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	drawingMode(MODE_TRANS);
	Bitmap::arcFilled(x, y, ang1, ang2, radius, color);
	drawingMode(MODE_SOLID);
	}

	/*
	void Bitmap::clear(){
	this->fill( 0 );
	}
	*/

	-void Bitmap::fill( int color ) const{
	- ::clear_to_color( getData()->getBitmap(), color );
	+void Bitmap::fill( Color color ) const{
	+ ::clear_to_color( getData()->getBitmap(), color.color );
	}

	/*
	void TranslucentBitmap::fill(int color) const {
	rectangleFill(0, 0, getWidth(), getHeight(), color);
	}
	*/

	void Bitmap::draw( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_NORMAL, SPRITE_NO_FLIP, NULL);
	// ::draw_sprite( where.getData().getBitmap(), getBitmap(), x, y );
	}

	void Bitmap::draw(const int x, const int y, Filter * filter, const Bitmap & where) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_NORMAL, SPRITE_NO_FLIP, filter);
	}

	void Bitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_NORMAL, SPRITE_H_FLIP, NULL);
	// ::draw_sprite_h_flip( where.getBitmap(), getBitmap(), x, y );
	}

	void Bitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_NORMAL, SPRITE_H_FLIP, filter);
	// ::draw_sprite_h_flip( where.getBitmap(), getBitmap(), x, y );
	}

	void Bitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_NORMAL, SPRITE_V_FLIP, NULL);
	}

	void Bitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_NORMAL, SPRITE_V_FLIP, filter);
	}

	void Bitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_NORMAL, SPRITE_V_FLIP \| SPRITE_H_FLIP, NULL);
	}

	void Bitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_NORMAL, SPRITE_V_FLIP \| SPRITE_H_FLIP, filter);
	}

	/*
	void Bitmap::drawLit( const int x, const int y, const int level, const Bitmap & where ) const{
	::draw_lit_sprite( where.getBitmap(), getBitmap(), x, y, level );
	}
	*/

	void TranslucentBitmap::draw( const int x, const int y, const Bitmap & where ) const{
	// ::draw_trans_sprite( where.getBitmap(), getBitmap(), x, y );
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_TRANS, SPRITE_NO_FLIP, NULL);
	}

	void TranslucentBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const{
	// ::draw_trans_sprite( where.getBitmap(), getBitmap(), x, y );
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_TRANS, SPRITE_NO_FLIP, filter);
	}

	void TranslucentBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_TRANS, SPRITE_H_FLIP, NULL);
	}

	void TranslucentBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_TRANS, SPRITE_H_FLIP, filter);
	}

	void TranslucentBitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_TRANS, SPRITE_V_FLIP, NULL);
	}

	void TranslucentBitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_TRANS, SPRITE_V_FLIP, filter);
	}

	void TranslucentBitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_TRANS, SPRITE_V_FLIP \| SPRITE_H_FLIP, NULL);
	}

	void TranslucentBitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_TRANS, SPRITE_V_FLIP \| SPRITE_H_FLIP, filter);
	}

	void Bitmap::drawRotate( const int x, const int y, const int angle, const Bitmap & where ){
	::fixed fang = itofix( (360 - angle) % 360 * 256 / 360 );
	::rotate_sprite( where.getData()->getBitmap(), getData()->getBitmap(), x, y, fang );
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const Bitmap & where ){
	::fixed fang = ftofix( (double)((360 - angle) % 360) * 256.0 / 360.0 );
	::pivot_sprite( where.getData()->getBitmap(), getData()->getBitmap(), x, y, centerX, centerY, fang );
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const double scale, const Bitmap & where ){
	::fixed fscale = ftofix(scale);
	::fixed fang = ftofix( (double)((360 - angle) % 360) * 256.0 / 360.0 );
	::pivot_scaled_sprite( where.getData()->getBitmap(), getData()->getBitmap(), x, y, centerX, centerY, fang, fscale );
	}

	void Bitmap::drawStretched( const int x, const int y, const int new_width, const int new_height, const Bitmap & who ) const {
	BITMAP * bmp = who.getData()->getBitmap();
	::masked_stretch_blit( getData()->getBitmap(), bmp, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h, x,y, new_width, new_height );
	}

	-void Bitmap::light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, int focus_color, int edge_color) const {
	+void Bitmap::light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, Color focus_color, Color edge_color) const {
	paintown_light16(getData()->getBitmap(), x, y, width, height, start_y, focus_alpha, edge_alpha, focus_color, edge_color);
	}

	-void Bitmap::applyTrans(const int color) const {
	+void Bitmap::applyTrans(const Color color) const {
	paintown_applyTrans16(getData()->getBitmap(), color);
	}

	void Bitmap::StretchBy2( const Bitmap & where ){
	- BITMAP * bmp = where.getData()->getBitmap();
	+ BITMAP * bmp = where.getData()->getBitmap();

	- if ( where.getWidth() == getWidth() && where.getHeight() == getHeight() ){
	- ::blit( getData()->getBitmap(), bmp, 0, 0, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );
	- return;
	- }
	+ if ( where.getWidth() == getWidth() && where.getHeight() == getHeight() ){
	+ ::blit( getData()->getBitmap(), bmp, 0, 0, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );
	+ return;
	+ }

	- if ( where.getWidth() != getWidth()*2 \|\|
	- where.getHeight() != getHeight()*2 ){
	- cout<<"Wrong dimensions"<<endl;
	- cout<<"My: "<< getWidth() << " " << getHeight() << endl;
	- cout<<"Him: "<<where.getWidth()<< " " << where.getHeight()<<endl;
	- return;
	- }
	- // debug
	- ::stretch_blit( getData()->getBitmap(), bmp, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h, 0, 0, bmp->w, bmp->h );
	- // fblend_2x_stretch( my_bitmap, bmp, 0, 0, 0, 0, my_bitmap->w, my_bitmap->h);
	- // scale2x_allegro( my_bitmap, bmp, 2 );
	- // debug
	+ if ( where.getWidth() != getWidth()*2 \|\|
	+ where.getHeight() != getHeight()*2 ){
	+ cout<<"Wrong dimensions"<<endl;
	+ cout<<"My: "<< getWidth() << " " << getHeight() << endl;
	+ cout<<"Him: "<<where.getWidth()<< " " << where.getHeight()<<endl;
	+ return;
	+ }
	+ // debug
	+ ::stretch_blit( getData()->getBitmap(), bmp, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h, 0, 0, bmp->w, bmp->h );
	+ // fblend_2x_stretch( my_bitmap, bmp, 0, 0, 0, 0, my_bitmap->w, my_bitmap->h);
	+ // scale2x_allegro( my_bitmap, bmp, 2 );
	+ // debug

	}

	void Bitmap::StretchBy4( const Bitmap & where ){

	- BITMAP * bmp = where.getData()->getBitmap();
	- if ( where.getWidth() != getWidth()*4 \|\|
	- where.getHeight() != getHeight()*4 ){
	- cout<<"Wrong dimensions"<<endl;
	- cout<<"My: "<< getWidth() << " " << getHeight() << endl;
	- cout<<"Him: "<<where.getWidth()<< " " << where.getHeight()<<endl;
	- cout<<"Scaled: "<<getWidth()4<<" "<< getHeight()4<<endl;
	- return;
	- }
	- // fblend_2x_stretch( my_bitmap, bmp, 0, 0, 0, 0, my_bitmap->w, my_bitmap->h);
	- // scale4x_allegro( my_bitmap, bmp, 2 );
	- ::stretch_blit( getData()->getBitmap(), bmp, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h, 0, 0, bmp->w, bmp->h );
	+ BITMAP * bmp = where.getData()->getBitmap();
	+ if ( where.getWidth() != getWidth()*4 \|\|
	+ where.getHeight() != getHeight()*4 ){
	+ cout<<"Wrong dimensions"<<endl;
	+ cout<<"My: "<< getWidth() << " " << getHeight() << endl;
	+ cout<<"Him: "<<where.getWidth()<< " " << where.getHeight()<<endl;
	+ cout<<"Scaled: "<<getWidth()4<<" "<< getHeight()4<<endl;
	+ return;
	+ }
	+ // fblend_2x_stretch( my_bitmap, bmp, 0, 0, 0, 0, my_bitmap->w, my_bitmap->h);
	+ // scale4x_allegro( my_bitmap, bmp, 2 );
	+ ::stretch_blit( getData()->getBitmap(), bmp, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h, 0, 0, bmp->w, bmp->h );

	}

	#if 0
	void Bitmap::Stretch( const Bitmap & where ) const {
	Stretch( where, 0, 0, getData().getBitmap()->w, getData().getBitmap()->h, 0, 0, where.getData().getBitmap()->w, where.getData().getBitmap()->h );
	/*
	BITMAP * bmp = where.getBitmap();
	::stretch_blit( getBitmap(), bmp, 0, 0, getBitmap()->w, getBitmap()->h, 0, 0, bmp->w, bmp->h );
	*/
	}
	#endif

	void Bitmap::StretchHqx(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight) const {
	/* TODO */
	}

	void Bitmap::StretchXbr(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight) const {
	/* TODO */
	}

	void Bitmap::Stretch( const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight ) const {
	BITMAP * bmp = where.getData()->getBitmap();
	::stretch_blit( getData()->getBitmap(), bmp, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight );
	}

	#if 0
	void Bitmap::Blit( const int x, const int y, const Bitmap & where ) const {
	BITMAP * bmp = where.getData().getBitmap();
	/*
	acquire_bitmap( bmp );
	acquire_bitmap( my_bitmap );
	*/
	::blit( getData().getBitmap(), bmp, 0, 0, x, y, getData().getBitmap()->w, getData().getBitmap()->h );
	/*
	release_bitmap( my_bitmap );
	release_bitmap( bmp );
	*/
	}
	#endif

	/*
	void Bitmap::Blit( const int mx, const int my, const int wx, const int wy, const Bitmap & where ) const {
	BITMAP * bmp = where.getData().getBitmap();
	::blit( getData().getBitmap(), bmp, mx, my, wx, wy, getData().getBitmap()->w, getData().getBitmap()->h );
	}
	*/

	void Bitmap::Blit( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const {
	BITMAP * bmp = where.getData()->getBitmap();
	::blit( getData()->getBitmap(), bmp, mx, my, wx, wy, width, height );
	}

	void Bitmap::BlitMasked( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const {
	BITMAP * bmp = where.getData()->getBitmap();
	::masked_blit( getData()->getBitmap(), bmp, mx, my, wx, wy, width, height );
	}

	void Bitmap::BlitToScreen(const int upper_left_x, const int upper_left_y) const {
	if ( Scaler == NULL ){
	this->Blit( upper_left_x, upper_left_y, *Screen );
	} else {
	if (upper_left_x != 0 \|\| upper_left_y != 0){
	Bitmap buffer = temporaryBitmap(getWidth(), getHeight());
	buffer.clear();
	this->Blit(upper_left_x, upper_left_y, buffer);
	buffer.Stretch(*Scaler);
	} else {
	this->Stretch(*Scaler);
	}
	Scaler->Blit( 0, 0, 0, 0, *Screen );
	}
	}

	void Bitmap::BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const {

	if ( Scaler != NULL ){
	double mult_x = (double) Scaler->getWidth() / (double) SCALE_X;
	double mult_y = (double) Scaler->getHeight() / (double) SCALE_Y;

	int x = (int)(upper_left_x * mult_x);
	int y = (int)(upper_left_y * mult_y);
	int w = (int)(this->getWidth() * mult_x);
	int h = (int)(this->getHeight() * mult_y);

	// printf("ux %d uy %d uw %d uh %d. x %d y %d w %d h %d\n", upper_left_x, upper_left_y, getWidth(), getHeight(), x, y, w, h );

	this->Stretch( *Scaler, 0, 0, this->getWidth(), this->getHeight(), x, y, w, h );

	Bitmap tmp(*Scaler, x, y, w, h );
	tmp.Blit( x, y, *Screen );

	// Scaler->Blit( x, y, w, h, *Screen );
	} else {
	this->Blit( upper_left_x, upper_left_y, *Screen );
	}
	}

	void LitBitmap::draw( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_LIT, SPRITE_NO_FLIP, NULL);
	}

	void LitBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_LIT, SPRITE_NO_FLIP, filter);
	}

	void LitBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_LIT, SPRITE_H_FLIP, NULL);
	}

	void LitBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_LIT, SPRITE_H_FLIP, filter);
	}

	void LitBitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_LIT, SPRITE_V_FLIP, NULL);
	}

	void LitBitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_LIT, SPRITE_V_FLIP, filter);
	}

	void LitBitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_LIT, SPRITE_V_FLIP \| SPRITE_H_FLIP, NULL);
	}

	void LitBitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getBitmap(), getData()->getBitmap(), x, y, SPRITE_LIT, SPRITE_V_FLIP \| SPRITE_H_FLIP, filter);
	}

	/* this function should be in allegro but its not yet so just store it
	* here for now
	*/
	#define PAINTOWN_DLS_BLENDER BLENDER_FUNC
	#define PAINTOWN_DTS_BLENDER BLENDER_FUNC
	#define PAINTOWN_MAKE_DLS_BLENDER(a) _blender_func16
	#define PAINTOWN_MAKE_DTS_BLENDER() _blender_func16
	#define PAINTOWN_PIXEL_PTR unsigned short*
	#define PAINTOWN_OFFSET_PIXEL_PTR(p,x) ((PAINTOWN_PIXEL_PTR) (p) + (x))
	#define PAINTOWN_INC_PIXEL_PTR(p) ((p)++)
	#define PAINTOWN_INC_PIXEL_PTR_EX(p,d) ((p) += d)
	#define PAINTOWN_GET_MEMORY_PIXEL(p) (*(p))
	#define PAINTOWN_IS_SPRITE_MASK(b,c) ((unsigned long) (c) == (unsigned long) (b)->vtable->mask_color)
	#define PAINTOWN_DLSX_BLEND(b,n) ((*(b))(_blender_col_16, (n), _blender_alpha))
	#define PAINTOWN_GET_PIXEL(p) bmp_read16((uintptr_t) (p))
	#define PAINTOWN_DTS_BLEND(b,o,n) ((*(b))((n), (o), ::_blender_alpha))
	#define PAINTOWN_PUT_PIXEL(p,c) bmp_write16((uintptr_t) (p), (c))
	#define PAINTOWN_PUT_MEMORY_PIXEL(p,c) (*(p) = (c))
	#define PAINTOWN_SET_ALPHA(a) (_blender_alpha = (a))

	static void paintown_draw_sprite_ex16( BITMAP * dst, BITMAP * src, int dx, int dy, int mode, int flip, Bitmap::Filter * filter ){
	int x, y, w, h;
	int x_dir = 1, y_dir = 1;
	int dxbeg, dybeg;
	int sxbeg, sybeg;
	PAINTOWN_DLS_BLENDER lit_blender;
	PAINTOWN_DTS_BLENDER trans_blender;

	ASSERT(dst);
	ASSERT(src);

	if ( flip & SPRITE_V_FLIP ){
	y_dir = -1;
	}
	if ( flip & SPRITE_H_FLIP ){
	x_dir = -1;
	}

	if (dst->clip) {
	int tmp;

	tmp = dst->cl - dx;
	sxbeg = ((tmp < 0) ? 0 : tmp);
	dxbeg = sxbeg + dx;

	tmp = dst->cr - dx;
	w = ((tmp > src->w) ? src->w : tmp) - sxbeg;
	if (w <= 0)
	return;

	if ( flip & SPRITE_H_FLIP ){
	/* use backward drawing onto dst */
	sxbeg = src->w - (sxbeg + w);
	dxbeg += w - 1;
	}

	tmp = dst->ct - dy;
	sybeg = ((tmp < 0) ? 0 : tmp);
	dybeg = sybeg + dy;

	tmp = dst->cb - dy;
	h = ((tmp > src->h) ? src->h : tmp) - sybeg;
	if (h <= 0)
	return;

	if ( flip & SPRITE_V_FLIP ){
	/* use backward drawing onto dst */
	sybeg = src->h - (sybeg + h);
	dybeg += h - 1;
	}
	} else {
	w = src->w;
	h = src->h;
	sxbeg = 0;
	sybeg = 0;
	dxbeg = dx;
	if ( flip & SPRITE_H_FLIP ){
	dxbeg = dx + w - 1;
	}
	dybeg = dy;
	if ( flip & SPRITE_V_FLIP ){
	dybeg = dy + h - 1;
	}
	}

	lit_blender = PAINTOWN_MAKE_DLS_BLENDER(0);
	trans_blender = PAINTOWN_MAKE_DTS_BLENDER();

	if (dst->id & (BMP_ID_VIDEO \| BMP_ID_SYSTEM)) {
	bmp_select(dst);

	#if 0
	switch (mode){
	case Bitmap::SPRITE_NORMAL : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {

	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}

	break;
	}
	case Bitmap::SPRITE_LIT : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {

	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}
	break;
	}
	case Bitmap::SPRITE_TRANS : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {

	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}
	break;
	}
	}
	#endif

	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);

	/* flipped if y_dir is -1 */
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	/* d is incremented by x_dir, -1 if flipped */
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	switch (mode){
	case SPRITE_NORMAL: {
	if (filter){
	- c = filter->filter(c);
	+ c = filter->filter(Color(c)).color;
	}
	break;
	}
	case SPRITE_LIT : {
	if (filter){
	- c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(c));
	+ c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(Color(c)).color);
	} else {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	}
	break;
	}
	case SPRITE_TRANS : {
	if (filter){
	- c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), filter->filter(c));
	+ c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), filter->filter(Color(c)).color);
	} else {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	}
	break;
	}
	}
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}

	bmp_unwrite_line(dst);
	} else {
	switch (mode){
	case SPRITE_NORMAL : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	if (filter){
	- PAINTOWN_PUT_MEMORY_PIXEL(d, filter->filter(c));
	+ PAINTOWN_PUT_MEMORY_PIXEL(d, filter->filter(Color(c)).color);
	} else {
	PAINTOWN_PUT_MEMORY_PIXEL(d, c);
	}
	}
	}
	}

	break;
	}
	case SPRITE_LIT : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	if (filter){
	- c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(c));
	+ c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(Color(c)).color);
	} else {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	}
	PAINTOWN_PUT_MEMORY_PIXEL(d, c);
	}
	}
	}
	break;
	}
	case SPRITE_TRANS : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	if (filter){
	- c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), filter->filter(c));
	+ c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), filter->filter(Color(c)).color);
	} else {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	}
	PAINTOWN_PUT_MEMORY_PIXEL(d, c);
	}
	}
	}
	break;
	}
	}

	#if 0
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	switch( mode ){
	case Bitmap::SPRITE_NORMAL : break;
	case Bitmap::SPRITE_LIT : {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	break;
	}
	case Bitmap::SPRITE_TRANS : {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	break;
	}
	}
	PAINTOWN_PUT_MEMORY_PIXEL(d, c);
	}
	}
	}
	#endif
	}
	}

	/* mix pixels with the given color in with each non-masking pixel in dst */
	-static void paintown_applyTrans16(BITMAP * dst, const int color){
	+static void paintown_applyTrans16(BITMAP * dst, const Color color){
	int y1 = 0;
	int y2 = dst->h;
	int x1 = 0;
	int x2 = dst->w - 1;

	if (dst->clip){
	y1 = dst->ct;
	y2 = dst->cb - 1;
	x1 = dst->cl;
	x2 = dst->cr - 1;
	}

	PAINTOWN_DTS_BLENDER trans_blender;
	trans_blender = PAINTOWN_MAKE_DTS_BLENDER();
	if (dst->id & (BMP_ID_VIDEO \| BMP_ID_SYSTEM)) {
	} else {
	for (int y = y1; y < y2; y++) {
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, y), x1);
	for (int x = x2; x >= x1; PAINTOWN_INC_PIXEL_PTR_EX(d,1), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(d);
	if (!PAINTOWN_IS_SPRITE_MASK(dst, c)) {
	- c = PAINTOWN_DTS_BLEND(trans_blender, c, color);
	+ c = PAINTOWN_DTS_BLEND(trans_blender, c, color.color);
	PAINTOWN_PUT_MEMORY_PIXEL(d, c);
	}
	}
	}
	}
	}

	/* ultra special-case for drawing a light (like from a lamp).
	* center of light is x,y and shines in a perfect isosolese triangle.
	*/
	-static void paintown_light16(BITMAP * dst, const int x, const int y, const int width, const int height, const int start_y, const int focus_alpha, const int edge_alpha, const int focus_color, const int edge_color){
	+static void paintown_light16(BITMAP * dst, const int x, const int y, const int width, const int height, const int start_y, const int focus_alpha, const int edge_alpha, const Color focus_color, const Color edge_color){

	int dxbeg = x - width;
	int x_dir = 1;
	unsigned char * alphas = new unsigned char[width];
	- int * colors = new int[width];
	+ Color * colors = new Color[width];
	for (int i = 0; i < width; i++){
	alphas[i] = (unsigned char)((double)(edge_alpha - focus_alpha) * (double)i / (double)width + focus_alpha);
	}
	blend_palette(colors, width, focus_color, edge_color);

	int min_y, max_y, min_x, max_x;
	if (dst->clip){
	min_y = dst->ct;
	max_y = dst->cb - 1;
	min_x = dst->cl;
	max_x = dst->cr - 1;
	} else {
	min_y = y < 0 ? 0 : y;
	max_y = dst->h - 1;
	min_x = (x-width) < 0 ? 0 : x-width;
	max_x = (x+width) > dst->w-1 ? dst->w-1 : x+width;
	}

	int dybeg = y;

	/* tan(theta) = y / x */
	double xtan = (double) height / (double) width;
	PAINTOWN_DTS_BLENDER trans_blender;
	trans_blender = PAINTOWN_MAKE_DTS_BLENDER();
	if (dst->id & (BMP_ID_VIDEO \| BMP_ID_SYSTEM)) {
	} else {
	for (int sy = start_y; sy < height; sy++) {
	if (dybeg + sy < min_y \|\| dybeg + sy > max_y){
	continue;
	}
	/* x = y / tan(theta) */
	int top_width = (int)((double) sy / xtan);
	if (top_width == 0){
	continue;
	}
	dxbeg = x - top_width;
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + sy), dxbeg);

	for (int sx = -top_width; sx <= top_width; PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), sx++) {
	if (sx + x < min_x \|\| sx + x > max_x){
	continue;
	}
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(d);
	/* TODO:
	* converting to a double and calling fabs is overkill, just
	* write an integer abs() function.
	*/
	int sx_abs = (int) fabs((double) sx);
	PAINTOWN_SET_ALPHA(alphas[sx_abs]);
	- int color = colors[sx_abs];
	+ int color = colors[sx_abs].color;
	c = PAINTOWN_DTS_BLEND(trans_blender, c, color);
	PAINTOWN_PUT_MEMORY_PIXEL(d, c);
	}
	}
	}
	delete[] alphas;
	delete[] colors;
	}

	/* there is a bug in this function that causes memory corruption. if that bug
	* is ever found then use this method, otherwise don't use it.
	*/
	static void paintown_draw_sprite_ex16_old( BITMAP * dst, BITMAP * src, int dx, int dy, int mode, int flip, Bitmap::Filter * filter){
	int x, y, w, h;
	int x_dir = 1, y_dir = 1;
	int dxbeg, dybeg;
	int sxbeg, sybeg;
	PAINTOWN_DLS_BLENDER lit_blender;
	PAINTOWN_DTS_BLENDER trans_blender;

	ASSERT(dst);
	ASSERT(src);

	if ( flip & SPRITE_V_FLIP ){
	y_dir = -1;
	}
	if ( flip & SPRITE_H_FLIP ){
	x_dir = -1;
	}

	if (dst->clip) {
	int tmp;

	tmp = dst->cl - dx;
	sxbeg = ((tmp < 0) ? 0 : tmp);
	dxbeg = sxbeg + dx;

	tmp = dst->cr - dx;
	w = ((tmp > src->w) ? src->w : tmp) - sxbeg;
	if (w <= 0)
	return;

	if ( flip & SPRITE_H_FLIP ){
	/* use backward drawing onto dst */
	sxbeg = src->w - (sxbeg + w);
	dxbeg += w - 1;
	}

	tmp = dst->ct - dy;
	sybeg = ((tmp < 0) ? 0 : tmp);
	dybeg = sybeg + dy;

	tmp = dst->cb - dy;
	h = ((tmp > src->h) ? src->h : tmp) - sybeg;
	if (h <= 0)
	return;

	if ( flip & SPRITE_V_FLIP ){
	/* use backward drawing onto dst */
	sybeg = src->h - (sybeg + h);
	dybeg += h - 1;
	}
	} else {
	w = src->w;
	h = src->h;
	sxbeg = 0;
	sybeg = 0;
	dxbeg = dx;
	if ( flip & SPRITE_H_FLIP ){
	dxbeg = dx + w - 1;
	}
	dybeg = dy;
	if ( flip & SPRITE_V_FLIP ){
	dybeg = dy + h - 1;
	}
	}

	lit_blender = PAINTOWN_MAKE_DLS_BLENDER(0);
	trans_blender = PAINTOWN_MAKE_DTS_BLENDER();

	if (dst->id & (BMP_ID_VIDEO \| BMP_ID_SYSTEM)) {
	bmp_select(dst);

	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);

	/* flipped if y_dir is -1 */
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	/* d is incremented by x_dir, -1 if flipped */
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	switch( mode ){
	case SPRITE_NORMAL : break;
	case SPRITE_LIT : {
	if (filter){
	- c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(c));
	+ c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(Color(c)).color);
	} else {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	}
	break;
	}
	case SPRITE_TRANS : {
	if (filter){
	- c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), filter->filter(c));
	+ c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), filter->filter(Color(c)).color);
	} else {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	}
	break;
	}
	}
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}

	bmp_unwrite_line(dst);
	}
	else {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	switch( mode ){
	case SPRITE_NORMAL : break;
	case SPRITE_LIT : {
	if (filter){
	- c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(c));
	+ c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(Color(c)).color);
	} else {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	}
	break;
	}
	case SPRITE_TRANS : {
	if (filter){
	- c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), filter->filter(c));
	+ c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), filter->filter(Color(c)).color);
	} else {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	}
	break;
	}
	}
	PAINTOWN_PUT_MEMORY_PIXEL(d, c);
	}
	}
	}
	}
	}

	static void paintown_draw_sprite_filter_ex16(BITMAP * dst, BITMAP * src, int dx, int dy, const Bitmap::Filter & filter){
	int x, y, w, h;
	int x_dir = 1, y_dir = 1;
	int dxbeg, dybeg;
	int sxbeg, sybeg;

	if (true /* dst->clip*/ ) {
	int tmp;

	tmp = dst->cl - dx;
	sxbeg = ((tmp < 0) ? 0 : tmp);
	dxbeg = sxbeg + dx;

	tmp = dst->cr - dx;
	w = ((tmp > src->w) ? src->w : tmp) - sxbeg;
	if (w <= 0)
	return;

	tmp = dst->ct - dy;
	sybeg = ((tmp < 0) ? 0 : tmp);
	dybeg = sybeg + dy;

	tmp = dst->cb - dy;
	h = ((tmp > src->h) ? src->h : tmp) - sybeg;
	if (h <= 0)
	return;
	}

	- unsigned int mask = makeColor(255, 0, 255);
	+ unsigned int mask = MaskColor().color;
	// int bpp = src->format->BytesPerPixel;
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	- PAINTOWN_PUT_MEMORY_PIXEL(d, filter.filter(c));
	+ PAINTOWN_PUT_MEMORY_PIXEL(d, filter.filter(Color(c)).color);
	} else {
	PAINTOWN_PUT_MEMORY_PIXEL(d, mask);
	}
	}
	}
	}

	}

	#include "../software-renderer/bitmap.cpp"
	diff --git a/util/graphics/allegro/bitmap.h b/util/graphics/allegro/bitmap.h
	index 8eca223d..87a0f9f2 100644
	--- a/util/graphics/allegro/bitmap.h
	+++ b/util/graphics/allegro/bitmap.h
	@@ -1,52 +1,52 @@
	#include <allegro.h>
	#ifdef _WIN32
	#include <winalleg.h>
	#endif

	/*
	#ifdef _WIN32
	#define BITMAP dummyBITMAP
	#include <windows.h>
	#undef BITMAP
	#endif
	*/

	struct BITMAP;

	struct BitmapData{
	BitmapData():
	bitmap(0),
	destroy(true){}

	BitmapData(BITMAP * bitmap):
	bitmap(bitmap),
	destroy(true){
	}

	~BitmapData(){
	if (bitmap != NULL && destroy){
	destroy_bitmap(bitmap);
	}
	}

	void setDestroy(bool b){
	destroy = b;
	}

	inline BITMAP * getBitmap() const {
	return bitmap;
	}

	inline void setBitmap(BITMAP * b) {
	bitmap = b;
	}

	BITMAP * bitmap;
	bool destroy;
	};

	namespace Graphics{
	- typedef int Color;
	+ typedef int INTERNAL_COLOR;
	}

	#include "../software-renderer/bitmap.h"
	diff --git a/util/graphics/allegro5/bitmap.cpp b/util/graphics/allegro5/bitmap.cpp
	index 11644ffc..ee4a2ab7 100644
	--- a/util/graphics/allegro5/bitmap.cpp
	+++ b/util/graphics/allegro5/bitmap.cpp
	@@ -1,1258 +1,1258 @@
	#include <sstream>
	#include <allegro5/allegro5.h>
	#include <allegro5/allegro_memfile.h>
	#include <allegro5/allegro_primitives.h>
	#include "util/debug.h"
	#include "util/thread.h"

	namespace Graphics{

	ALLEGRO_DISPLAY * the_display = NULL;

	enum BlendingType{
	Translucent,
	Add,
	Difference,
	Multiply
	};

	struct BlendingData{
	BlendingData():
	red(0), green(0), blue(0), alpha(0), type(Translucent){
	}

	int red, green, blue, alpha;
	BlendingType type;
	};

	static BlendingData globalBlend;

	/* must be a pointer so it can be created dynamically after allegro init */
	// Util::Thread::LockObject * allegroLock;

	Color makeColorAlpha(unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha){
	- return al_map_rgba(red, green, blue, alpha);
	+ return Color(al_map_rgba(red, green, blue, alpha));
	}

	Color MaskColor(){
	static Color mask = makeColorAlpha(0, 0, 0, 0);
	return mask;
	}
	-
	+
	Color getBlendColor(){
	/* sort of a hack */
	if (globalBlend.type == Multiply){
	return makeColorAlpha(255, 255, 255, 255);
	}
	return makeColorAlpha(255, 255, 255, globalBlend.alpha);
	}

	Color doTransBlend(const Color & color, int alpha){
	unsigned char red, green, blue;
	- al_unmap_rgb(color, &red, &green, &blue);
	+ al_unmap_rgb(color.color, &red, &green, &blue);
	return makeColorAlpha(red, green, blue, alpha);
	/*
	red *= alpha_f;
	green *= alpha_f;
	blue *= alpha_f;
	return al_map_rgb_f(red, green, blue);
	*/
	}

	Color transBlendColor(const Color & color){
	return doTransBlend(color, globalBlend.alpha);
	}

	int getRealWidth(const Bitmap & what){
	return al_get_bitmap_width(what.getData()->getBitmap());
	}

	int getRealHeight(const Bitmap & what){
	return al_get_bitmap_height(what.getData()->getBitmap());
	}

	class Blender{
	public:
	Blender(){
	}

	virtual ~Blender(){
	/* default is to draw the source and ignore the destination */
	al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	}
	};

	class MaskedBlender: public Blender {
	public:
	MaskedBlender(){
	al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA);
	}
	};

	class LitBlender: public Blender {
	public:
	LitBlender(ALLEGRO_COLOR lit){
	// al_set_blend_color(lit);
	// al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE_MINUS_DST_COLOR, ALLEGRO_ZERO);
	}
	};

	class TransBlender: public Blender {
	public:
	TransBlender(){
	switch (globalBlend.type){
	case Translucent: al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA); break;
	case Add: al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE); break;
	case Multiply: al_set_blender(ALLEGRO_ADD, ALLEGRO_DST_COLOR, ALLEGRO_INVERSE_ALPHA); break;
	case Difference: al_set_blender(ALLEGRO_DEST_MINUS_SRC, ALLEGRO_ONE, ALLEGRO_ONE); break;
	}
	}
	};

	static const int WINDOWED = 0;
	static const int FULLSCREEN = 1;

	// static Bitmap * Scaler = NULL;

	Bitmap::Bitmap():
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)),
	width(0),
	height(0){
	/* TODO */
	}

	Bitmap::Bitmap( const char * load_file ):
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	internalLoadFile(load_file);
	width = al_get_bitmap_width(getData()->getBitmap());
	height = al_get_bitmap_height(getData()->getBitmap());
	}

	Bitmap::Bitmap( const std::string & load_file ):
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	internalLoadFile(load_file.c_str());
	width = al_get_bitmap_width(getData()->getBitmap());
	height = al_get_bitmap_height(getData()->getBitmap());
	}

	Bitmap::Bitmap(ALLEGRO_BITMAP * who, bool deep_copy):
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	if (deep_copy){
	ALLEGRO_BITMAP * clone = al_clone_bitmap(who);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(clone)));
	} else {
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(who)));
	}
	this->width = al_get_bitmap_width(getData()->getBitmap());
	this->height = al_get_bitmap_height(getData()->getBitmap());
	}

	Bitmap::Bitmap(int width, int height):
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	ALLEGRO_BITMAP * bitmap = al_create_bitmap(width, height);
	if (bitmap == NULL){
	std::ostringstream out;
	out << "Could not create bitmap with dimensions " << width << ", " << height;
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(bitmap)));
	this->width = al_get_bitmap_width(getData()->getBitmap());
	this->height = al_get_bitmap_height(getData()->getBitmap());
	}

	Bitmap::Bitmap( const Bitmap & copy, bool deep_copy):
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor),
	width(copy.width),
	height(copy.height){
	if (deep_copy){
	ALLEGRO_BITMAP * clone = al_clone_bitmap(copy.getData()->getBitmap());
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(clone)));
	} else {
	setData(copy.getData());
	}
	}

	void Bitmap::convertToVideo(){
	ALLEGRO_BITMAP * original = getData()->getBitmap();
	ALLEGRO_BITMAP * copy = al_clone_bitmap(original);
	if (copy == NULL){
	throw BitmapException(__FILE__, __LINE__, "Could not create video bitmap");
	}
	al_destroy_bitmap(getData()->getBitmap());
	getData()->setBitmap(copy);
	}

	void changeTarget(const Bitmap & from, const Bitmap & who){
	/* pray that if drawing is held then who is already the current target */
	if (!al_is_bitmap_drawing_held()){
	if (al_get_target_bitmap() != who.getData()->getBitmap()){
	al_set_target_bitmap(who.getData()->getBitmap());
	}
	if ((al_get_bitmap_flags(who.getData()->getBitmap()) & ALLEGRO_VIDEO_BITMAP) &&
	(al_get_bitmap_flags(from.getData()->getBitmap()) & ALLEGRO_MEMORY_BITMAP)){

	((Bitmap&) from).convertToVideo();
	/* How can from == who? If they were the same then the bitmap flags above
	* would not have been different.
	*/
	if (&from == &who){
	al_set_target_bitmap(who.getData()->getBitmap());
	}
	}
	}
	}

	void changeTarget(const Bitmap * from, const Bitmap & who){
	changeTarget(*from, who);
	}

	void changeTarget(const Bitmap & from, const Bitmap * who){
	changeTarget(from, *who);
	}

	void changeTarget(const Bitmap * from, const Bitmap * who){
	changeTarget(from, who);
	}

	void dumpColor(const Color & color){
	unsigned char red, green, blue, alpha;
	- al_unmap_rgba(color, &red, &green, &blue, &alpha);
	+ al_unmap_rgba(color.color, &red, &green, &blue, &alpha);
	Global::debug(0) << "red " << (int) red << " green " << (int) green << " blue " << (int) blue << " alpha " << (int) alpha << std::endl;
	}

	Color pcxMaskColor(unsigned char * data, const int length){
	if (length >= 769){
	if (data[length - 768 - 1] == 12){
	unsigned char * palette = &data[length - 768];
	unsigned char red = palette[0];
	unsigned char green = palette[1];
	unsigned char blue = palette[2];
	return makeColorAlpha(red, green, blue, 255);
	}
	}
	return makeColorAlpha(255, 255, 255, 255);
	}

	Bitmap memoryPCX(unsigned char * const data, const int length, const bool mask){
	ALLEGRO_FILE * memory = al_open_memfile((void *) data, length, "r");
	ALLEGRO_BITMAP * pcx = al_load_bitmap_f(memory, ".pcx");
	al_fclose(memory);
	if (pcx == NULL){
	throw BitmapException(__FILE__, __LINE__, "Could not load pcx");
	}
	// dumpColor(al_get_pixel(pcx, 0, 0));
	Bitmap out(pcx);
	out.set8BitMaskColor(pcxMaskColor(data, length));
	return out;
	}

	static bool isVideoBitmap(ALLEGRO_BITMAP * bitmap){
	return (al_get_bitmap_flags(bitmap) & ALLEGRO_VIDEO_BITMAP) &&
	!(al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP);
	}

	void Bitmap::replaceColor(const Color & original, const Color & replaced){
	changeTarget(this, this);

	if (isVideoBitmap(getData()->getBitmap())){
	al_lock_bitmap(getData()->getBitmap(), ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE);
	}

	int width = getRealWidth(*this);
	int height = getRealHeight(*this);
	for (int x = 0; x < width; x++){
	for (int y = 0; y < height; y++){
	Color pixel = getPixel(x, y);
	if (pixel == original){
	- al_put_pixel(x, y, replaced);
	+ al_put_pixel(x, y, replaced.color);
	}
	}
	}

	if (isVideoBitmap(getData()->getBitmap())){
	al_unlock_bitmap(getData()->getBitmap());
	}
	}

	static ALLEGRO_BITMAP * memoryGIF(const char * data, int length){
	ALLEGRO_FILE * memory = al_open_memfile((void *) data, length, "r");
	al_fclose(memory);

	/* FIXME: get gif addon for a5 */

	#if 0
	RGB * palette = NULL;
	/* algif will close the packfile for us in both error and success cases */
	BITMAP * gif = load_gif_packfile(pack, palette);
	if (!gif){
	al_fclose(memory);
	// pack_fclose(pack);
	ostringstream out;
	out <<"Could not load gif from memory: " << (void*) data << " length " << length;
	throw LoadException(__FILE__, __LINE__, out.str());
	}

	BITMAP * out = create_bitmap(gif->w, gif->h);
	blit(gif, out, 0, 0, 0, 0, gif->w, gif->h);
	destroy_bitmap(gif);
	// pack_fclose(pack);
	#endif

	ALLEGRO_BITMAP * out = NULL;

	return out;
	}

	void Bitmap::internalLoadFile(const char * path){
	this->path = path;
	ALLEGRO_BITMAP * loaded = al_load_bitmap(path);
	if (loaded == NULL){
	std::ostringstream out;
	out << "Could not load file '" << path << "'";
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	al_convert_mask_to_alpha(loaded, al_map_rgb(255, 0, 255));
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(loaded)));
	}

	static ALLEGRO_BITMAP * do_load_from_memory(const char * data, int length, const char * type){
	ALLEGRO_FILE * memory = al_open_memfile((void*) data, length, "r");
	ALLEGRO_BITMAP * bitmap = al_load_bitmap_f(memory, type);
	al_fclose(memory);
	al_convert_mask_to_alpha(bitmap, al_map_rgb(255, 0, 255));
	return bitmap;
	}

	static ALLEGRO_BITMAP * load_bitmap_from_memory(const char * data, int length, ImageFormat type){
	switch (type){
	case FormatBMP: return do_load_from_memory(data, length, ".bmp");
	case FormatPNG: return do_load_from_memory(data, length, ".png");
	case FormatJPG: return do_load_from_memory(data, length, ".jpg");
	case FormatPCX: return do_load_from_memory(data, length, ".pcx");
	case FormatTGA: return do_load_from_memory(data, length, ".tga");
	case FormatTIF: return do_load_from_memory(data, length, ".tif");
	case FormatXPM: return do_load_from_memory(data, length, ".xpm");
	case FormatGIF : {
	return memoryGIF(data, length);
	break;
	}
	}
	std::ostringstream out;
	out << "Could not load the bitmap because its format was not known";
	throw BitmapException(__FILE__, __LINE__, out.str());
	}

	Bitmap::Bitmap(const char * data, int length):
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	loadFromMemory(data, length);
	}

	void Bitmap::loadFromMemory(const char * data, int length){
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(load_bitmap_from_memory(data, length, identifyImage((const unsigned char *) data, length)))));
	if (getData()->getBitmap() == NULL){
	std::ostringstream out;
	out << "Could not create bitmap from memory";
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	width = al_get_bitmap_width(getData()->getBitmap());
	height = al_get_bitmap_height(getData()->getBitmap());
	}

	Bitmap::Bitmap( const Bitmap & copy, int x, int y, int width, int height ):
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor),
	width(width),
	height(height){
	path = copy.getPath();
	ALLEGRO_BITMAP * his = copy.getData()->getBitmap();
	if (x < 0)
	x = 0;
	if (y < 0)
	y = 0;
	/*
	if (width + x > al_get_bitmap_width(his)){
	width = al_get_bitmap_width(his) - x;
	}
	if (height + y > al_get_bitmap_height(his)){
	height = al_get_bitmap_height(his) - y;
	}
	*/

	ALLEGRO_BITMAP * old_target = al_get_target_bitmap();
	ALLEGRO_TRANSFORM transform;
	al_identity_transform(&transform);
	if (al_get_target_bitmap() != copy.getData()->getBitmap()){
	al_set_target_bitmap(copy.getData()->getBitmap());
	}
	if (al_get_current_transform() != NULL){
	if (old_target != copy.getData()->getBitmap()){
	al_set_target_bitmap(copy.getData()->getBitmap());
	}
	al_copy_transform(&transform, al_get_current_transform());
	}

	float x_scaled = x;
	float y_scaled = y;
	float width_scaled = width;
	float height_scaled = height;

	al_transform_coordinates(&transform, &x_scaled, &y_scaled);
	al_transform_coordinates(&transform, &width_scaled, &height_scaled);

	// ALLEGRO_BITMAP * sub = al_create_sub_bitmap(his, x, y, width, height);
	ALLEGRO_BITMAP * sub = al_create_sub_bitmap(his, (int) x_scaled, (int) y_scaled, (int) width_scaled, (int) height_scaled);
	// ALLEGRO_BITMAP * sub = al_create_sub_bitmap(his, (int) x_scaled, (int) y_scaled, width, height);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(sub)));

	al_set_target_bitmap(sub);
	al_use_transform(&transform);
	al_set_target_bitmap(old_target);
	}

	static bool isBackBuffer(ALLEGRO_BITMAP * bitmap){
	return bitmap == al_get_backbuffer(the_display);
	}

	int Bitmap::getWidth() const {
	/* Always return the true dimensions of the backbuffer */
	if (getData() != NULL && isBackBuffer(getData()->getBitmap())){
	return al_get_bitmap_width(getData()->getBitmap());
	}
	return width;
	/*
	if (getData()->getBitmap() != NULL){
	return al_get_bitmap_width(getData()->getBitmap());
	}

	return 0;
	*/
	}

	int getRed(Color color){
	unsigned char red, green, blue;
	- al_unmap_rgb(color, &red, &green, &blue);
	+ al_unmap_rgb(color.color, &red, &green, &blue);
	return red;
	}

	int getGreen(Color color){
	unsigned char red, green, blue;
	- al_unmap_rgb(color, &red, &green, &blue);
	+ al_unmap_rgb(color.color, &red, &green, &blue);
	return green;
	}

	int getBlue(Color color){
	unsigned char red, green, blue;
	- al_unmap_rgb(color, &red, &green, &blue);
	+ al_unmap_rgb(color.color, &red, &green, &blue);
	return blue;
	}

	Color makeColor(int red, int blue, int green){
	- return al_map_rgb(red, blue, green);
	+ return Color(al_map_rgb(red, blue, green));
	}

	int Bitmap::getHeight() const {
	if (getData() != NULL && isBackBuffer(getData()->getBitmap())){
	return al_get_bitmap_height(getData()->getBitmap());
	}
	return height;
	/*
	if (getData()->getBitmap() != NULL){
	return al_get_bitmap_height(getData()->getBitmap());
	}

	return 0;
	*/
	}

	void initializeExtraStuff(){
	// al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_RGB_565);
	// allegroLock = new Util::Thread::LockObject();
	}

	int setGraphicsMode(int mode, int width, int height){
	initializeExtraStuff();

	/* FIXME: the configuration should pass in fullscreen mode here */
	#ifdef IPHONE
	mode = FULLSCREEN;
	#endif
	switch (mode){
	case FULLSCREEN: {
	#ifdef IPHONE
	al_set_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS, ALLEGRO_DISPLAY_ORIENTATION_LANDSCAPE, ALLEGRO_SUGGEST);
	al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
	#else
	al_set_new_display_flags(ALLEGRO_FULLSCREEN);
	#endif
	break;
	}
	case WINDOWED: {
	al_set_new_display_flags(ALLEGRO_WINDOWED \| ALLEGRO_RESIZABLE);
	break;
	}
	default: break;
	}
	the_display = al_create_display(width, height);
	if (the_display == NULL){
	std::ostringstream out;
	out << "Could not create display with dimensions " << width << ", " << height;
	throw BitmapException(__FILE__, __LINE__, out.str());
	}

	// Global::debug(0) << "Set width " << al_get_display_width(the_display) << " height " << al_get_display_height(the_display) << std::endl;
	// Global::debug(0) << "Backbuffer width " << al_get_bitmap_width(al_get_backbuffer(the_display)) << " height " << al_get_bitmap_height(al_get_backbuffer(the_display)) << std::endl;

	try{
	/* TODO: maybe find a more general way to get the icon */
	ALLEGRO_BITMAP * icon = al_load_bitmap(Storage::instance().find(Filesystem::RelativePath("menu/icon.bmp")).path().c_str());
	if (icon != NULL){
	al_set_display_icon(the_display, icon);
	}
	} catch (const Filesystem::NotFound & fail){
	Global::debug(0) << "Could not set window icon: " << fail.getTrace() << std::endl;
	}
	Screen = new Bitmap(al_get_backbuffer(the_display));
	/* dont destroy the backbuffer */
	Screen->getData()->setDestroy(false);

	ALLEGRO_TRANSFORM transformation;
	al_identity_transform(&transformation);
	al_scale_transform(&transformation, (double) Screen->getWidth() / (double) width, (double) Screen->getHeight() / (double) height);
	al_set_target_bitmap(Screen->getData()->getBitmap());
	al_use_transform(&transformation);

	// Scaler = new Bitmap(width, height);
	/* default drawing mode */
	al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	return 0;
	}

	void Bitmap::lock() const {
	al_lock_bitmap(getData()->getBitmap(), ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE);
	}

	void Bitmap::lock(int x, int y, int width, int height) const {
	al_lock_bitmap_region(getData()->getBitmap(), x, y, width, height, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE);
	}

	void Bitmap::unlock() const {
	al_unlock_bitmap(getData()->getBitmap());
	}

	Color Bitmap::getPixel(const int x, const int y) const {
	// changeTarget(this, this);
	- return al_get_pixel(getData()->getBitmap(), x, y);
	+ return Color(al_get_pixel(getData()->getBitmap(), x, y));
	}

	void Bitmap::putPixel(int x, int y, Color pixel) const {
	changeTarget(this, this);
	// al_put_pixel(x, y, pixel);
	- al_draw_pixel(x, y, pixel);
	+ al_draw_pixel(x, y, pixel.color);
	}

	void Bitmap::putPixelNormal(int x, int y, Color col) const {
	putPixel(x, y, col);
	}

	void Bitmap::fill(Color color) const {
	changeTarget(this, this);
	- al_clear_to_color(color);
	+ al_clear_to_color(color.color);
	}

	void Bitmap::startDrawing() const {
	/* we are about to draw on this bitmap so make sure we are the target */
	changeTarget(this, this);
	al_hold_bitmap_drawing(true);
	}

	void Bitmap::endDrawing() const {
	al_hold_bitmap_drawing(false);
	}

	void TranslucentBitmap::startDrawing() const {
	al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA);
	}

	void TranslucentBitmap::endDrawing() const {
	al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	}

	Color Bitmap::blendColor(const Color & input) const {
	return input;
	}

	Color TranslucentBitmap::blendColor(const Color & color) const {
	unsigned char red, green, blue;
	unsigned char alpha = globalBlend.alpha;
	- al_unmap_rgb(color, &red, &green, &blue);
	+ al_unmap_rgb(color.color, &red, &green, &blue);
	return makeColorAlpha(red, green, blue, alpha);
	}

	void Bitmap::StretchHqx(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight) const {
	/* TODO */
	}

	void Bitmap::StretchXbr(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight) const {
	/* TODO */
	}

	void Bitmap::Stretch( const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight ) const {
	/* TODO */
	}

	void Bitmap::StretchBy2( const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::StretchBy4( const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::drawRotate(const int x, const int y, const int angle, const Bitmap & where ){
	changeTarget(this, where);
	MaskedBlender blender;
	al_draw_rotated_bitmap(getData()->getBitmap(), getWidth() / 2, getHeight() / 2, x, y, Util::radians(angle), ALLEGRO_FLIP_HORIZONTAL);
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const Bitmap & where ){
	changeTarget(this, where);
	MaskedBlender blender;
	al_draw_rotated_bitmap(getData()->getBitmap(), getWidth() / 2, getHeight() / 2, x, y, Util::radians(-angle), 0);
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const double scale, const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::drawStretched( const int x, const int y, const int new_width, const int new_height, const Bitmap & who ) const {
	/* FIXME */
	changeTarget(this, who);
	MaskedBlender blender;
	al_draw_scaled_bitmap(getData()->getBitmap(), 0, 0, al_get_bitmap_width(getData()->getBitmap()), al_get_bitmap_height(getData()->getBitmap()), x, y, new_width, new_height, 0);
	#if 0
	ALLEGRO_TRANSFORM save;
	al_copy_transform(&save, al_get_current_transform());
	ALLEGRO_TRANSFORM stretch;
	al_identity_transform(&stretch);
	// al_translate_transform(&stretch, x / ((double) new_width / getWidth()), y / ((double) new_height / getHeight()));
	al_scale_transform(&stretch, (double) new_width / getWidth(), (double) new_height / getHeight());
	al_translate_transform(&stretch, x, y);
	// al_translate_transform(&stretch, -x / ((double) new_width / getWidth()), -y / ((double) (new_height / getHeight())));
	al_use_transform(&stretch);
	/* any source pixels with an alpha value of 0 will be masked */
	// al_draw_bitmap(getData().getBitmap(), x, y, 0);
	al_draw_bitmap(getData().getBitmap(), 0, 0, 0);
	al_use_transform(&save);
	#endif
	}

	Bitmap Bitmap::scaleTo(const int width, const int height) const {
	if (width == getRealWidth(this) && height == getRealHeight(this)){
	return *this;
	}
	Bitmap scaled(width, height);
	changeTarget(*this, scaled);
	al_draw_scaled_bitmap(getData()->getBitmap(), 0, 0, getRealWidth(this), getRealHeight(this),
	0, 0, width, height, 0);
	return scaled;
	}

	void Bitmap::Blit(const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where) const {
	// double start = al_get_time();
	// changeTarget(this, where);
	// al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	/*
	if (&where != Screen){
	al_draw_bitmap(getData().getBitmap(), wx, wy, 0);
	}
	*/

	changeTarget(this, where);
	Bitmap part(*this, mx, my, width, height);
	// al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
	al_draw_bitmap(part.getData()->getBitmap(), wx, wy, 0);
	/*
	double end = al_get_time();
	Global::debug(0) << "Draw in " << (end - start) << " seconds" << std::endl;
	*/
	}

	void Bitmap::drawHFlip(const int x, const int y, const Bitmap & where) const {
	changeTarget(this, where);
	MaskedBlender blender;
	/* any source pixels with an alpha value of 0 will be masked */
	al_draw_bitmap(getData()->getBitmap(), x, y, ALLEGRO_FLIP_HORIZONTAL);
	}

	void Bitmap::drawHFlip(const int x, const int y, Filter * filter, const Bitmap & where) const {
	/* FIXME: deal with filter */
	changeTarget(this, where);
	MaskedBlender blender;
	/* any source pixels with an alpha value of 0 will be masked */
	al_draw_bitmap(getData()->getBitmap(), x, y, ALLEGRO_FLIP_HORIZONTAL);
	}

	void Bitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	changeTarget(this, where);
	MaskedBlender blender;
	/* any source pixels with an alpha value of 0 will be masked */
	al_draw_bitmap(getData()->getBitmap(), x, y, ALLEGRO_FLIP_VERTICAL);
	}

	void Bitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* FIXME: deal with filter */
	changeTarget(this, where);
	MaskedBlender blender;
	/* any source pixels with an alpha value of 0 will be masked */
	al_draw_bitmap(getData()->getBitmap(), x, y, ALLEGRO_FLIP_VERTICAL);
	}

	void Bitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	changeTarget(this, where);
	MaskedBlender blender;
	/* any source pixels with an alpha value of 0 will be masked */
	al_draw_bitmap(getData()->getBitmap(), x, y, ALLEGRO_FLIP_VERTICAL \| ALLEGRO_FLIP_HORIZONTAL);
	}

	void Bitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* FIXME: deal with filter */
	changeTarget(this, where);
	MaskedBlender blender;
	/* any source pixels with an alpha value of 0 will be masked */
	al_draw_bitmap(getData()->getBitmap(), x, y, ALLEGRO_FLIP_VERTICAL \| ALLEGRO_FLIP_HORIZONTAL);
	}

	void Bitmap::BlitMasked(const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where) const {
	/* TODO */
	}

	void Bitmap::BlitToScreen(const int upper_left_x, const int upper_left_y) const {
	#if 0
	if (getWidth() != Screen->getWidth() \|\| getHeight() != Screen->getHeight()){
	/*
	this->Blit( upper_left_x, upper_left_y, *Buffer );
	Buffer->Stretch(*Scaler);
	Scaler->Blit(0, 0, 0, 0, *Screen);
	*/

	this->Stretch(*Scaler, 0, 0, getWidth(), getHeight(), upper_left_x, upper_left_y, Scaler->getWidth(), Scaler->getHeight());
	Scaler->Blit(0, 0, 0, 0, *Screen);
	} else {
	this->Blit(upper_left_x, upper_left_y, *Screen);
	}
	#endif
	/*
	if (&where == Screen){
	al_flip_display();
	}
	*/
	changeTarget(this, Screen);
	if (getData()->getBitmap() != Screen->getData()->getBitmap()){
	Blit(*Screen);
	}
	al_flip_display();
	}

	void Bitmap::BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const {
	changeTarget(this, Screen);
	/*
	if (getData()->getBitmap() != Screen->getData()->getBitmap()){
	Blit(upper_left_y, upper_left_y, *Screen);
	}
	*/
	al_flip_display();
	}

	void Bitmap::draw(const int x, const int y, const Bitmap & where) const {
	// TransBlender blender;
	changeTarget(this, where);
	MaskedBlender blender;
	/* any source pixels with an alpha value of 0 will be masked */
	al_draw_bitmap(getData()->getBitmap(), x, y, 0);
	}

	void Bitmap::draw(const int x, const int y, Filter * filter, const Bitmap & where) const {
	/* FIXME */
	changeTarget(this, where);
	MaskedBlender blender;
	/* any source pixels with an alpha value of 0 will be masked */
	al_draw_bitmap(getData()->getBitmap(), x, y, 0);
	}

	void Bitmap::drawShadow(Bitmap & where, int x, int y, int intensity, Color color, double scale, bool facingRight) const {
	/* TODO: implement */
	}

	void Bitmap::hLine(const int x1, const int y, const int x2, const Color color) const {
	line(x1, y, x2, y, color);
	}

	void Bitmap::vLine(const int y1, const int x, const int y2, const Color color) const {
	line(x, y1, x, y2, color);
	}

	void Bitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	changeTarget(this, this);
	- al_draw_arc(x, y, radius, ang1 - Util::pi/2, ang2 - ang1, color, 1);
	+ al_draw_arc(x, y, radius, ang1 - Util::pi/2, ang2 - ang1, color.color, 1);
	}

	void TranslucentBitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	TransBlender blender;
	Bitmap::arc(x, y, ang1, ang2, radius, transBlendColor(color));
	/*
	changeTarget(this);
	al_draw_arc(x, y, radius, ang1 + S_PI/2, ang2 - ang1, doTransBlend(color, globalBlend.alpha), 0);
	*/
	}

	/* from http://www.allegro.cc/forums/thread/605684/892721#target */
	#if 0
	void al_draw_filled_pieslice(float cx, float cy, float r, float start_theta,
	float delta_theta, ALLEGRO_COLOR color){
	ALLEGRO_VERTEX vertex_cache[ALLEGRO_VERTEX_CACHE_SIZE];
	int num_segments, ii;

	num_segments = fabs(delta_theta / (2 * ALLEGRO_PI) * ALLEGRO_PRIM_QUALITY * sqrtf(r));

	if (num_segments < 2)
	return;

	if (num_segments >= ALLEGRO_VERTEX_CACHE_SIZE) {
	num_segments = ALLEGRO_VERTEX_CACHE_SIZE - 1;
	}

	al_calculate_arc(&(vertex_cache[1].x), sizeof(ALLEGRO_VERTEX), cx, cy, r, r, start_theta, delta_theta, 0, num_segments);
	vertex_cache[0].x = cx; vertex_cache[0].y = cy;

	for (ii = 0; ii < num_segments + 1; ii++) {
	vertex_cache[ii].color = color;
	vertex_cache[ii].z = 0;
	}

	al_draw_prim(vertex_cache, NULL, NULL, 0, num_segments + 1, ALLEGRO_PRIM_TRIANGLE_FAN);
	// al_draw_prim(vertex_cache, NULL, NULL, 0, 3, ALLEGRO_PRIM_TRIANGLE_FAN);
	}
	#endif

	void Bitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	changeTarget(this, this);
	- al_draw_filled_pieslice(x, y, radius, ang1 - Util::pi/2, ang2 - ang1, color);
	+ al_draw_filled_pieslice(x, y, radius, ang1 - Util::pi/2, ang2 - ang1, color.color);
	}

	void TranslucentBitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	TransBlender blender;
	Bitmap::arcFilled(x, y, ang1, ang2, radius, transBlendColor(color));
	}

	void Bitmap::floodfill( const int x, const int y, const Color color ) const {
	/* TODO */
	}

	void Bitmap::line(const int x1, const int y1, const int x2, const int y2, const Color color) const {
	- al_draw_line(x1, y1, x2, y2, color, 1.5);
	+ al_draw_line(x1, y1, x2, y2, color.color, 1.5);
	}

	void TranslucentBitmap::line(const int x1, const int y1, const int x2, const int y2, const Color color) const {
	TransBlender blender;
	Bitmap::line(x1, y1, x2, y2, transBlendColor(color));
	}

	void Bitmap::circleFill(int x, int y, int radius, Color color) const {
	changeTarget(this, this);
	- al_draw_filled_circle(x, y, radius, color);
	+ al_draw_filled_circle(x, y, radius, color.color);
	}

	void Bitmap::circle(int x, int y, int radius, Color color) const {
	changeTarget(this, this);
	- al_draw_circle(x, y, radius, color, 0);
	+ al_draw_circle(x, y, radius, color.color, 0);
	}

	void Bitmap::circle(int x, int y, int radius, int thickness, Color color) const {
	changeTarget(this, this);
	- al_draw_circle(x, y, radius, color, thickness);
	+ al_draw_circle(x, y, radius, color.color, thickness);
	}

	void Bitmap::rectangle( int x1, int y1, int x2, int y2, Color color ) const {
	changeTarget(this, this);
	- al_draw_rectangle(x1, y1, x2, y2, color, 0);
	+ al_draw_rectangle(x1, y1, x2, y2, color.color, 0);
	}

	void Bitmap::rectangleFill( int x1, int y1, int x2, int y2, Color color ) const {
	changeTarget(this, this);
	- al_draw_filled_rectangle(x1 - 0.5, y1 - 0.5, x2 + 0.5, y2 + 0.5, color);
	+ al_draw_filled_rectangle(x1 - 0.5, y1 - 0.5, x2 + 0.5, y2 + 0.5, color.color);
	}

	void Bitmap::triangle( int x1, int y1, int x2, int y2, int x3, int y3, Color color ) const {
	changeTarget(this, this);
	- al_draw_filled_triangle(x1, y1, x2, y2, x3, y3, color);
	+ al_draw_filled_triangle(x1, y1, x2, y2, x3, y3, color.color);
	}

	void Bitmap::polygon( const int * verts, const int nverts, const Color color ) const {
	/* TODO */
	}

	void Bitmap::ellipse( int x, int y, int rx, int ry, Color color ) const {
	changeTarget(this, this);
	- al_draw_ellipse(x, y, rx, ry, color, 0);
	+ al_draw_ellipse(x, y, rx, ry, color.color, 0);
	}

	void Bitmap::ellipseFill( int x, int y, int rx, int ry, Color color ) const {
	changeTarget(this, this);
	- al_draw_filled_ellipse(x, y, rx, ry, color);
	+ al_draw_filled_ellipse(x, y, rx, ry, color.color);
	}

	void Bitmap::applyTrans(const Color color) const {
	TransBlender blender;
	changeTarget(this, this);
	- al_draw_filled_rectangle(0, 0, getWidth(), getHeight(), transBlendColor(color));
	+ al_draw_filled_rectangle(0, 0, getWidth(), getHeight(), transBlendColor(color).color);
	}

	-void Bitmap::light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, int focus_color, Color edge_color) const {
	+void Bitmap::light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, Color focus_color, Color edge_color) const {
	/* TODO */
	}

	-void Bitmap::drawCharacter( const int x, const int y, const int color, const int background, const Bitmap & where ) const {
	+void Bitmap::drawCharacter( const int x, const int y, const Color color, const int background, const Bitmap & where ) const {
	/* TODO */
	}

	void Bitmap::save( const std::string & str ) const {
	/* TODO */
	}

	void Bitmap::readLine(std::vector<Color> & line, int y){
	/* TODO */
	}

	void TranslucentBitmap::draw(const int x, const int y, const Bitmap & where) const {
	changeTarget(this, where);
	TransBlender blender;
	- al_draw_tinted_bitmap(getData()->getBitmap(), getBlendColor(), x, y, 0);
	+ al_draw_tinted_bitmap(getData()->getBitmap(), getBlendColor().color, x, y, 0);
	}

	void LitBitmap::draw(const int x, const int y, const Bitmap & where) const {
	// changeTarget(this, where);
	// LitBlender blender(makeColorAlpha(globalBlend.red, globalBlend.green, globalBlend.blue, globalBlend.alpha));
	// TransBlender blender;
	// al_draw_bitmap(getData()->getBitmap(), x, y, 0);
	// al_draw_tinted_bitmap(getData()->getBitmap(), al_map_rgba_f(1, 0, 0, 1), x, y, 0);
	}

	void LitBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void LitBitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	changeTarget(this, where);
	TransBlender blender;
	- al_draw_tinted_bitmap(getData()->getBitmap(), getBlendColor(), x, y, 0);
	+ al_draw_tinted_bitmap(getData()->getBitmap(), getBlendColor().color, x, y, 0);
	}

	void TranslucentBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::drawHVFlip( const int x, const int y, Filter * filter,const Bitmap & where ) const {
	/* TODO */
	}

	void TranslucentBitmap::hLine( const int x1, const int y, const int x2, const Color color ) const {
	/* TODO */
	}

	void TranslucentBitmap::circleFill(int x, int y, int radius, Color color) const {
	TransBlender blender;
	Bitmap::circleFill(x, y, radius, doTransBlend(color, globalBlend.alpha));
	}

	void TranslucentBitmap::putPixelNormal(int x, int y, Color color) const {
	TransBlender blender;
	Bitmap::putPixelNormal(x, y, doTransBlend(color, globalBlend.alpha));
	}

	void TranslucentBitmap::rectangle( int x1, int y1, int x2, int y2, Color color ) const {
	TransBlender blender;
	Bitmap::rectangle(x1, y1, x2, y2, doTransBlend(color, globalBlend.alpha));
	}

	void TranslucentBitmap::rectangleFill(int x1, int y1, int x2, int y2, Color color) const {
	TransBlender blender;
	Bitmap::rectangleFill(x1, y1, x2, y2, doTransBlend(color, globalBlend.alpha));
	}

	void TranslucentBitmap::ellipse( int x, int y, int rx, int ry, Color color ) const {
	TransBlender blender;
	Bitmap::ellipse(x, y, rx, ry, doTransBlend(color, globalBlend.alpha));
	}

	void TranslucentBitmap::ellipseFill( int x, int y, int rx, int ry, Color color ) const {
	TransBlender blender;
	Bitmap::ellipseFill(x, y, rx, ry, doTransBlend(color, globalBlend.alpha));
	}

	void Bitmap::setClipRect( int x1, int y1, int x2, int y2 ) const {
	/* TODO */
	}

	void Bitmap::getClipRect(int & x1, int & y1, int & x2, int & y2) const {
	/* TODO */
	}

	int setGfxModeFullscreen(int x, int y){
	return setGraphicsMode(FULLSCREEN, x, y);
	}

	int setGfxModeWindowed( int x, int y ){
	return setGraphicsMode(WINDOWED, x, y);
	}

	int setGfxModeText(){
	/* TODO */
	return 0;
	}

	bool Bitmap::getError(){
	/* TODO */
	return false;
	}

	void Bitmap::alphaBlender(int source, int dest){
	/* TODO */
	}

	void Bitmap::transBlender(int r, int g, int b, int a){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.type = Translucent;
	}

	void Bitmap::addBlender(int r, int g, int b, int a){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.type = Add;
	}

	void Bitmap::differenceBlender( int r, int g, int b, int a ){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.type = Difference;
	}

	void Bitmap::multiplyBlender( int r, int g, int b, int a ){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.type = Multiply;
	}

	/*
	void Bitmap::drawingMode(int type){
	}
	*/

	void Bitmap::shutdown(){
	delete Screen;
	Screen = NULL;
	// delete allegroLock;
	// allegroLock = NULL;
	/*
	delete Scaler;
	Scaler = NULL;
	delete Buffer;
	Buffer = NULL;
	*/
	}

	StretchedBitmap::StretchedBitmap(int width, int height, const Bitmap & parent, QualityFilter filter):
	Bitmap(parent, 0, 0, parent.getWidth(), parent.getHeight()),
	width(width),
	height(height),
	where(parent),
	filter(filter){
	scale_x = (double) parent.getWidth() / width;
	scale_y = (double) parent.getHeight() / height;
	ALLEGRO_BITMAP * old_target = al_get_target_bitmap();
	if (al_get_target_bitmap() != parent.getData()->getBitmap()){
	al_set_target_bitmap(parent.getData()->getBitmap());
	}
	ALLEGRO_TRANSFORM transform;
	al_identity_transform(&transform);
	if (al_get_current_transform() != NULL){
	al_copy_transform(&transform, al_get_current_transform());
	}
	al_scale_transform(&transform, scale_x, scale_y);
	if (al_get_target_bitmap() != getData()->getBitmap()){
	al_set_target_bitmap(getData()->getBitmap());
	}
	al_use_transform(&transform);
	if (old_target != al_get_target_bitmap()){
	al_set_target_bitmap(old_target);
	}

	/* TODO: handle filter */
	}

	void StretchedBitmap::start(){
	#if 0
	ALLEGRO_TRANSFORM transform;
	changeTarget(this, this);
	al_copy_transform(&transform, al_get_current_transform());
	// al_identity_transform(&transform);
	// al_scale_transform(&transform, Bitmap::getWidth() / width, Bitmap::getHeight() / height);
	al_scale_transform(&transform, scale_x, scale_y);
	al_use_transform(&transform);
	#endif
	}

	void StretchedBitmap::finish(){
	#if 0
	ALLEGRO_TRANSFORM transform;
	changeTarget(this, this);
	al_copy_transform(&transform, al_get_current_transform());
	/* apply the inverse transform */
	al_scale_transform(&transform, 1.0/scale_x, 1.0/scale_y);
	// al_identity_transform(&transform);
	al_use_transform(&transform);
	#endif
	}

	TranslatedBitmap::TranslatedBitmap(int x, int y, const Bitmap & where):
	Bitmap(where),
	x(x),
	y(y){
	ALLEGRO_TRANSFORM transform;
	changeTarget(this, where);
	al_identity_transform(&transform);
	if (al_get_current_transform() != NULL){
	al_copy_transform(&transform, al_get_current_transform());
	}
	al_translate_transform(&transform, x, y);
	al_use_transform(&transform);
	}

	void TranslatedBitmap::BlitToScreen() const {
	Bitmap::BlitToScreen();
	}

	TranslatedBitmap::~TranslatedBitmap(){
	ALLEGRO_TRANSFORM transform;
	al_copy_transform(&transform, al_get_current_transform());
	al_translate_transform(&transform, -x, -y);
	al_use_transform(&transform);
	}

	Bitmap * getScreenBuffer(){
	return Screen;
	}

	RestoreState::RestoreState(){
	al_store_state(&state, ALLEGRO_STATE_ALL);
	}

	RestoreState::~RestoreState(){
	al_restore_state(&state);
	}

	}

	static inline bool close(float x, float y){
	static float epsilon = 0.001;
	return fabs(x - y) < epsilon;
	}

	-static inline bool sameColor(Graphics::Color color1, Graphics::Color color2){
	+static inline bool sameColor(const ALLEGRO_COLOR & color1, const ALLEGRO_COLOR & color2){
	// return memcmp(&color1, &color2, sizeof(Graphics::Color)) == 0;
	float r1, g1, b1, a1;
	float r2, g2, b2, a2;
	al_unmap_rgba_f(color1, &r1, &g1, &b1, &a1);
	al_unmap_rgba_f(color2, &r2, &g2, &b2, &a2);
	return close(r1, r2) &&
	close(g1, g2) &&
	close(b1, b2) &&
	close(a1, a2);

	/*
	unsigned char r1, g1, b1, a1;
	unsigned char r2, g2, b2, a2;
	al_unmap_rgba(color1, &r1, &g1, &b1, &a1);
	al_unmap_rgba(color2, &r2, &g2, &b2, &a2);
	return r1 == r2 &&
	g1 == g2 &&
	b1 == b2 &&
	a1 == a2;
	*/
	}

	static uint32_t quantify(const ALLEGRO_COLOR & color){
	unsigned char red, green, blue, alpha;
	al_unmap_rgba(color, &red, &green, &blue, &alpha);
	return (red << 24) \|
	(green << 16) \|
	(blue << 8) \|
	alpha;
	}

	bool operator<(const ALLEGRO_COLOR & color1, const ALLEGRO_COLOR & color2){
	return quantify(color1) < quantify(color2);
	}

	bool operator!=(const ALLEGRO_COLOR & color1, const ALLEGRO_COLOR & color2){
	return !(color1 == color2);
	}

	bool operator==(const ALLEGRO_COLOR & color1, const ALLEGRO_COLOR & color2){
	return sameColor(color1, color2);
	}
	diff --git a/util/graphics/allegro5/bitmap.h b/util/graphics/allegro5/bitmap.h
	index 330f76ce..cbf6a63f 100644
	--- a/util/graphics/allegro5/bitmap.h
	+++ b/util/graphics/allegro5/bitmap.h
	@@ -1,57 +1,57 @@
	#include <allegro5/allegro5.h>

	struct BitmapData{
	BitmapData():
	bitmap(NULL),
	destroy(true){
	}

	BitmapData(ALLEGRO_BITMAP * bitmap):
	bitmap(bitmap),
	destroy(true){
	}

	virtual ~BitmapData(){
	if (bitmap != NULL){
	if (al_get_target_bitmap() == bitmap){
	al_set_target_bitmap(NULL);
	}
	if (destroy){
	al_destroy_bitmap(bitmap);
	}
	}
	}

	void setDestroy(bool ok){
	destroy = ok;
	}

	inline ALLEGRO_BITMAP * getBitmap() const {
	return bitmap;
	}

	inline void setBitmap(ALLEGRO_BITMAP * b){
	bitmap = b;
	}

	ALLEGRO_BITMAP * bitmap;
	bool destroy;
	};

	namespace Graphics{
	- typedef ALLEGRO_COLOR Color;
	+ typedef ALLEGRO_COLOR INTERNAL_COLOR;
	/* events.cpp needs this */
	extern ALLEGRO_DISPLAY * the_display;

	class RestoreState{
	public:
	RestoreState();
	~RestoreState();
	protected:
	ALLEGRO_STATE state;
	};
	}

	bool operator<(const ALLEGRO_COLOR & color1, const ALLEGRO_COLOR & color2);
	bool operator!=(const ALLEGRO_COLOR & color1, const ALLEGRO_COLOR & color2);
	bool operator==(const ALLEGRO_COLOR & color1, const ALLEGRO_COLOR & color2);
	diff --git a/util/graphics/bitmap.cpp b/util/graphics/bitmap.cpp
	index 70099b24..74dbdd71 100644
	--- a/util/graphics/bitmap.cpp
	+++ b/util/graphics/bitmap.cpp
	@@ -1,572 +1,576 @@
	#include "../funcs.h"
	#include "bitmap.h"
	#include "../file-system.h"
	#include <string>
	#include <stdio.h>
	#include <math.h>

	namespace Graphics{

	static Bitmap * Screen = NULL;
	/* bitmaps that should always be resized to the dimensions of the screen */
	static std::vector<Bitmap*> needResize;

	Util::Parameter<Bitmap*> screenParameter;

	/* implementation independant definitions can go here */

	Bitmap * Bitmap::temporary_bitmap = NULL;
	Bitmap * Bitmap::temporary_bitmap2 = NULL;

	/*
	int SCALE_X = 0;
	int SCALE_Y = 0;
	*/

	/*
	const int Bitmap::MODE_TRANS = 0;
	const int Bitmap::MODE_SOLID = 1;
	*/

	const int SPRITE_NO_FLIP = 0;
	const int SPRITE_V_FLIP = 1;
	const int SPRITE_H_FLIP = 2;

	const int SPRITE_NORMAL = 1;
	const int SPRITE_LIT = 2;
	const int SPRITE_TRANS = 3;

	static inline int max(int a, int b){
	return a > b ? a : b;
	}
	+
	+INTERNAL_COLOR Color::defaultColor(){
	+ return makeColor(0, 0, 0).color;
	+}

	void initializeExtraStuff();

	Bitmap::Bitmap(Storage::File & file):
	mustResize(false),
	error(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	int length = file.getSize();
	if (length == -1){
	throw BitmapException(__FILE__, __LINE__, std::string("Could not read from file"));
	}
	char * data = new char[length];
	try{
	file.readLine(data, length);
	loadFromMemory(data, length);
	delete[] data;
	} catch (const BitmapException & fail){
	delete[] data;
	throw;
	} catch (...){
	delete[] data;
	throw;
	}
	}

	QualityFilter qualityFilterName(const std::string & type){
	if (type == "xbr"){
	return XbrFilter;
	}
	if (type == "hqx"){
	return HqxFilter;
	}
	return NoFilter;
	}

	Bitmap::~Bitmap(){
	if (mustResize){
	for (std::vector<Bitmap*>::iterator it = needResize.begin(); it != needResize.end(); it++){
	Bitmap * who = *it;
	if (who == this){
	needResize.erase(it);
	break;
	}
	}
	}
	}

	static Bitmap makeTemporaryBitmap(Bitmap *& temporary, int w, int h){
	if (temporary == NULL){
	temporary = new Bitmap(w, h);
	} else if (temporary->getWidth() < w \|\| temporary->getHeight() < h){
	int mw = max(temporary->getWidth(), w);
	int mh = max(temporary->getHeight(), h);
	// printf("Create temporary bitmap %d %d\n", mw, mh);
	delete temporary;
	temporary = new Bitmap(mw, mh);
	}
	if (temporary == NULL){
	printf("bug temporary bitmap is null\n");
	}
	return Bitmap(*temporary, 0, 0, w, h);
	}

	Bitmap Bitmap::temporaryBitmap(int w, int h){
	return makeTemporaryBitmap(temporary_bitmap, w, h);
	}

	Bitmap Bitmap::temporaryBitmap2(int w, int h){
	return makeTemporaryBitmap(temporary_bitmap2, w, h);
	}

	void Bitmap::cleanupTemporaryBitmaps(){
	if (temporary_bitmap != NULL){
	delete temporary_bitmap;
	temporary_bitmap = NULL;
	}

	if (temporary_bitmap2 != NULL){
	delete temporary_bitmap2;
	temporary_bitmap2 = NULL;
	}
	}

	Bitmap & Bitmap::operator=(const Bitmap & copy){
	path = copy.getPath();
	this->width = copy.getWidth();
	this->height = copy.getHeight();
	setData(copy.getData());
	return *this;
	}

	double Bitmap::getScale(){
	/* the game is pretty much hard coded to run at 320 scaled upto 640
	* and then scaled to whatever the user wants, but as long as
	* 320 and 640 remain this number will be 2.
	* maybe calculate this at some point
	*/
	return 2;
	/*
	if (Scaler != NULL && Buffer != NULL){
	double x1 = Scaler->getWidth();
	double x2 = Buffer->getWidth();
	return x2 / x1;
	}
	return 1;
	*/
	}

	/* taken from the color addon from allegro 4.9 */
	static void al_color_cmyk_to_rgb(float cyan, float magenta, float yellow, float key, float red, float green, float *blue){
	float max = 1 - key;
	red = max - cyan max;
	green = max - magenta max;
	blue = max - yellow max;
	}

	void Bitmap::cymkToRGB(int c, int y, int m, int k, int * r, int * g, int * b){
	float fc = (float)c / 255.0;
	float fy = (float)y / 255.0;
	float fm = (float)m / 255.0;
	float fk = (float)k / 255.0;

	float fr, fg, fb;
	al_color_cmyk_to_rgb(fc, fm, fy, fk, &fr, &fg, &fb);
	r = (int)(fr 255.0);
	g = (int)(fg 255.0);
	b = (int)(fb 255.0);
	}

	void Bitmap::updateOnResize(){
	if (!mustResize){
	mustResize = true;
	needResize.push_back(this);
	}
	}

	void Bitmap::updateSize(const int width, const int height){
	if (getWidth() == width && getHeight() == height){
	return;
	}

	Bitmap created(width, height);
	*this = created;
	}

	/* resize the internal bitmap. not guaranteed to destroy the internal bitmap */
	void Bitmap::resize(const int width, const int height){

	/* if internal bitmap is already the proper size, do nothing */
	if (getWidth() == width && getHeight() == height){
	return;
	}

	Bitmap created(width, height);
	Stretch(created);
	*this = created;
	}


	/* decrement bitmap reference counter and free memory if counter hits 0 */
	#if 0
	void Bitmap::releaseInternalBitmap(){
	const int MAGIC_DEBUG = 0xa5a5a5;
	if (own != NULL){
	if (*own == MAGIC_DEBUG){
	printf("[bitmap] Trying to delete an already deleted reference counter %p\n", own);
	}

	(*own) -= 1;
	if ( *own == 0 ){
	*own = MAGIC_DEBUG;
	delete own;
	destroyPrivateData();
	own = NULL;
	}
	}
	}
	#endif

	void Bitmap::BlitToScreen() const {
	// this->Blit( *Bitmap::Screen );
	this->BlitToScreen(0, 0);
	}

	void Bitmap::load( const std::string & str ){
	// releaseInternalBitmap();
	internalLoadFile( str.c_str() );
	}

	Bitmap Bitmap::scaleBy(const double widthRatio, const double heightRatio) const {
	return scaleTo(getWidth() * widthRatio, getHeight() * heightRatio);
	}

	void Bitmap::border( int min, int max, Color color ) const {
	int w = getWidth();
	int h = getHeight();
	for (int i = min; i < max; i++){
	rectangle(i, i, w - 1 - i, h - 1 - i, color);
	}
	}

	void Bitmap::drawHFlip(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, const Bitmap & where) const {
	drawHFlip(x, y, startWidth, startHeight, width, height, NULL, where);
	}

	void Bitmap::drawHFlip(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, Filter * filter, const Bitmap & where) const {
	Bitmap sub(*this, getWidth() - width, getHeight() - height, getWidth() - startWidth, getHeight() - startHeight);
	sub.drawHFlip(x + startWidth, y + startHeight, filter, where);
	}

	void Bitmap::drawRotateCenter(const int x, const int y, const int angle, const Bitmap & where){
	drawRotate(x - getWidth() / 2, y - getHeight() / 2, angle, where);
	}

	void Bitmap::drawCenter(const int x, const int y, const Bitmap & where) const {
	draw(x - getWidth() / 2, y - getHeight() / 2, where);
	}

	void Bitmap::drawStretched(const Bitmap & who) const {
	drawStretched(0, 0, who.getWidth(), who.getHeight(), who);
	}

	void Bitmap::draw(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, const Bitmap & where) const {
	draw(x, y, startWidth, startHeight, width, height, NULL, where);
	/*
	Bitmap sub(*this, startWidth, startHeight, width, height);
	sub.draw(x + startWidth, y + startHeight, where);
	*/
	}

	void Bitmap::draw(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, Filter * filter, const Bitmap & where) const {
	Bitmap sub(*this, startWidth, startHeight, width, height);
	sub.draw(x + startWidth, y + startHeight, filter, where);
	}

	void Bitmap::horizontalLine( const int x1, const int y, const int x2, const Graphics::Color color ) const{
	this->hLine(x1, y, x2, color);
	}

	void Bitmap::equilateralTriangle(int x, int y, int angle, int size, Color color) const {
	double radians = Util::radians(angle);
	int x1 = x + size / 2 * cos(radians + 2 * Util::pi / 3);
	int y1 = y + size / 2 * sin(radians + 2 * Util::pi / 3);
	int x2 = x + size / 2 * cos(radians - 2 * Util::pi / 3);
	int y2 = y + size / 2 * sin(radians - 2 * Util::pi / 3);
	int x3 = x + size / 2 * cos(radians);
	int y3 = y + size / 2 * sin(radians);
	triangle(x1, y1, x2, y2, x3, y3, color);
	}

	Bitmap Bitmap::greyScale(){
	Bitmap grey(getWidth(), getHeight());

	for (int x = 0; x < getWidth(); x++){
	for (int y = 0; y < getHeight(); y++){
	Color pixel = getPixel(x, y);
	int val = (int)((0.299getRed(pixel) + 0.587getGreen(pixel) + 0.114*getBlue(pixel) + 0.5) + 16);
	if (val > 255){
	val = 255;
	}
	grey.putPixel(x, y, makeColor(val, val, val));
	}
	}

	return grey;
	}

	bool Bitmap::inRange(int x, int y) const {
	int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
	getClipRect(x1, y1, x2, y2);
	return (x >= x1 && x <= x2 &&
	y >= y1 && y <= y2);
	}

	void Bitmap::drawMask( const int _x, const int _y, const Bitmap & where ){
	Color mask = MaskColor();
	for (int x = 0; x < getWidth(); x++){
	for (int y = 0; y < getHeight(); y++){
	if (getPixel(x,y) == mask){
	where.putPixel(x+_x, y+_y, mask);
	}
	}
	}
	}

	void Bitmap::set8BitMaskColor(const Color & color){
	bit8MaskColor = color;
	}

	Color Bitmap::get8BitMaskColor(){
	return bit8MaskColor;
	}

	void Bitmap::setFakeGraphicsMode(int width, int height){
	initializeExtraStuff();
	Screen = new Bitmap(width, height);
	}

	void Bitmap::Blit( const std::string & xpath ) const {
	Bitmap duh(xpath);
	duh.Blit(*this);
	}

	void Bitmap::Blit(const Bitmap & where) const {
	this->Blit(0, 0, where);
	}

	void Bitmap::Blit(const int x, const int y, const Bitmap & where) const {
	Blit(0, 0, x, y, where);
	}

	void Bitmap::Blit(const int mx, const int my, const int wx, const int wy, const Bitmap & where) const {
	Blit(mx, my, getWidth(), getHeight(), wx, wy, where);
	}

	void Bitmap::BlitFromScreen(const int x, const int y) const {
	Screen->Blit(x, y, getWidth(), getHeight(), 0, 0, *this);
	}

	//! min (borrowed from allegro)
	static inline int Min(int x, int y){ return (((x) < (y)) ? (x) : (y)); }

	//! max (borrowed from allegro)
	static inline int Max(int x, int y){ return (((x) > (y)) ? (x) : (y)); }

	//! mid (borrowed from allegro)
	static inline int Mid(int x,int y,int z){ return (Max((x), Min((y), (z)))); }

	void Bitmap::roundRect(int radius, int x1, int y1, int x2, int y2, Color color) const {
	const int width = x2 - x1;
	const int height = y2 - y1;
	radius = Mid(0, radius, Min((x1+width - x1)/2, (y1+height - y1)/2));
	line(x1+radius, y1, x1+width-radius, y1, color);
	line(x1+radius, y1+height, x1+width-radius,y1+height, color);
	line(x1, y1+radius,x1, y1+height-radius, color);
	line(x1+width, y1+radius,x1+width, y1+height-radius, color);

	double quarterTurn = Util::pi / 2;
	double quadrant1 = 0;
	/* signs are flipped because the coordinate system is reflected over the y-axis */
	double quadrant2 = -Util::pi / 2;
	double quadrant3 = Util::pi;
	double quadrant4 = -3 * Util::pi / 2;

	/* upper right. draw from 90 to 0 */
	arc(x1+radius + (width - radius *2), y1 + radius, quadrant1, quadrant1 + quarterTurn, radius, color);
	/* upper left. draw from 180 to 270 */
	arc(x1 + radius, y1 + radius, quadrant2, quadrant2 + quarterTurn, radius, color);
	/* lower left. draw from 180 to 270 */
	arc(x1 + radius, y1 + height - radius, quadrant3, quadrant3 + quarterTurn, radius, color);
	/* lower right. draw from 0 to 270 */
	arc(x1+width-radius, y1+height-radius, quadrant4, quadrant4 + quarterTurn, radius, color);
	}

	void Bitmap::roundRectFill(int radius, int x1, int y1, int x2, int y2, Graphics::Color color) const {
	const int width = x2 - x1;
	const int height = y2 - y1;
	radius = Mid(0, radius, Min((x1+width - x1)/2, (y1+height - y1)/2));

	double quarterTurn = Util::pi / 2;
	double quadrant1 = 0;
	/* signs are flipped because the coordinate system is reflected over the y-axis */
	double quadrant2 = -Util::pi / 2;
	double quadrant3 = Util::pi;
	double quadrant4 = -3 * Util::pi / 2;

	/* upper right. draw from 90 to 0 */
	arcFilled(x1+radius + (width - radius *2), y1 + radius, quadrant1, quadrant1 + quarterTurn, radius, color);
	/* upper left. draw from 180 to 270 */
	arcFilled(x1 + radius, y1 + radius, quadrant2, quadrant2 + quarterTurn, radius, color);
	/* lower left. draw from 180 to 270 */
	arcFilled(x1 + radius, y1 + height - radius, quadrant3, quadrant3 + quarterTurn, radius, color);
	/* lower right. draw from 0 to 270 */
	arcFilled(x1+width-radius, y1+height-radius, quadrant4, quadrant4 + quarterTurn, radius, color);

	rectangleFill(x1+radius + 1, y1, x2-radius - 1, y1+radius - 1, color);
	rectangleFill(x1, y1+radius, x2, y2-radius, color);
	rectangleFill(x1+radius + 1, y2-radius + 1, x2-radius - 1, y2, color);
	}

	int Bitmap::getScreenWidth(){
	if (Screen != 0){
	return Screen->getWidth();
	}
	return 0;
	}

	int Bitmap::getScreenHeight(){
	if (Screen != 0){
	return Screen->getHeight();
	}
	return 0;
	}

	void Bitmap::clear() const {
	fill(makeColor(0, 0, 0));
	}

	void Bitmap::copy(const Bitmap & him){
	resize(him.getWidth(), him.getHeight());
	him.Blit(*this);
	}

	void Bitmap::Stretch( const Bitmap & where ) const {
	if (getWidth() == where.getWidth() && getHeight() == where.getHeight()){
	Blit(where);
	} else {
	Stretch(where, 0, 0, getWidth(), getHeight(), 0, 0, where.getWidth(), where.getHeight());
	}
	}

	void Bitmap::StretchHqx(const Bitmap & where) const {
	if (getWidth() == where.getWidth() && getHeight() == where.getHeight()){
	Blit(where);
	} else {
	StretchHqx(where, 0, 0, getWidth(), getHeight(), 0, 0, where.getWidth(), where.getHeight());
	}
	}

	void Bitmap::StretchXbr(const Bitmap & where) const {
	if (getWidth() == where.getWidth() && getHeight() == where.getHeight()){
	Blit(where);
	} else {
	StretchXbr(where, 0, 0, getWidth(), getHeight(), 0, 0, where.getWidth(), where.getHeight());
	}
	}

	Color darken(Color color, double factor ){
	int r = (int)((double)getRed(color) / factor);
	int g = (int)((double)getGreen(color) / factor);
	int b = (int)((double)getBlue(color) / factor);

	return makeColor(r, g, b);
	}

	LitBitmap::LitBitmap(const Bitmap & b):
	Bitmap(b){
	int x1, y1, x2, y2;
	b.getClipRect(x1, y1, x2, y2);
	setClipRect(x1, y1, x2, y2);
	}

	LitBitmap::LitBitmap():
	Bitmap(){
	}

	LitBitmap::~LitBitmap(){
	}

	LitBitmap Bitmap::lit() const {
	return LitBitmap(*this);
	}

	TranslucentBitmap Bitmap::translucent() const {
	return TranslucentBitmap(*this);
	}

	TranslucentBitmap Bitmap::translucent(int red, int green, int blue, int alpha) const {
	transBlender(red, green, blue, alpha);
	return TranslucentBitmap(*this);
	}

	TranslucentBitmap::TranslucentBitmap(const Bitmap & b):
	Bitmap(b){
	int x1, y1, x2, y2;
	b.getClipRect(x1, y1, x2, y2);
	setClipRect(x1, y1, x2, y2);
	}

	TranslucentBitmap::TranslucentBitmap():
	Bitmap(){
	}

	TranslucentBitmap::~TranslucentBitmap(){
	}

	void TranslucentBitmap::fill(Color color) const {
	Bitmap::applyTrans(color);
	}

	int StretchedBitmap::getWidth() const {
	return width;
	}

	int StretchedBitmap::getHeight() const {
	return height;
	}

	double StretchedBitmap::getScaleWidth() const {
	return (double) where.getWidth() / (double) getWidth();
	}

	double StretchedBitmap::getScaleHeight() const {
	return (double) where.getHeight() / (double) getHeight();
	}

	void blend_palette(Color * pal, int mp, Color startColor, Color endColor){
	/*
	ASSERT(pal);
	ASSERT(mp != 0);
	*/

	int sc_r = Graphics::getRed(startColor);
	int sc_g = Graphics::getGreen(startColor);
	int sc_b = Graphics::getBlue(startColor);

	int ec_r = Graphics::getRed(endColor);
	int ec_g = Graphics::getGreen(endColor);
	int ec_b = Graphics::getBlue(endColor);

	for ( int q = 0; q < mp; q++ ) {
	float j = (float)( q + 1 ) / (float)( mp );
	int f_r = (int)( 0.5 + (float)( sc_r ) + (float)( ec_r-sc_r ) * j );
	int f_g = (int)( 0.5 + (float)( sc_g ) + (float)( ec_g-sc_g ) * j );
	int f_b = (int)( 0.5 + (float)( sc_b ) + (float)( ec_b-sc_b ) * j );
	pal[q] = Graphics::makeColor( f_r, f_g, f_b );
	}
	}

	}

	#ifdef USE_ALLEGRO
	#include "allegro/bitmap.cpp"
	#endif
	#ifdef USE_SDL
	#include "sdl/bitmap.cpp"
	#endif
	#ifdef USE_ALLEGRO5
	#include "allegro5/bitmap.cpp"
	#endif

	diff --git a/util/graphics/bitmap.h b/util/graphics/bitmap.h
	index 24560961..8a308619 100644
	--- a/util/graphics/bitmap.h
	+++ b/util/graphics/bitmap.h
	@@ -1,623 +1,657 @@
	#ifndef _paintown_bitmap_h_
	#define _paintown_bitmap_h_

	#include "../exceptions/exception.h"
	#include "../pointer.h"
	#include "../parameter.h"
	#include <string>
	#include <vector>
	#include <iostream>

	#ifdef USE_ALLEGRO
	#include "allegro/bitmap.h"
	#endif
	#ifdef USE_SDL
	#include "sdl/bitmap.h"
	#endif
	#ifdef USE_ALLEGRO5
	#include "allegro5/bitmap.h"
	#endif

	+#include "color.h"
	+
	#if !defined(USE_ALLEGRO) && !defined(USE_SDL) && !defined(USE_ALLEGRO5)
	#error No backend specified. Define one of USE_ALLEGRO, USE_SDL, or USE_ALLEGRO5
	#endif

	namespace Storage{
	class File;
	}

	namespace Graphics{

	+class Color{
	+public:
	+ explicit Color(const INTERNAL_COLOR & color):
	+ color(color){
	+ }
	+
	+ static INTERNAL_COLOR defaultColor();
	+
	+ Color():
	+ color(defaultColor()){
	+ }
	+
	+ Color & operator=(const Color & him){
	+ this->color = him.color;
	+ return *this;
	+ }
	+
	+ bool operator==(const Color & him) const {
	+ return color == him.color;
	+ }
	+
	+ bool operator!=(const Color & him) const {
	+ return !(*this == him);
	+ }
	+
	+ bool operator<(const Color & him) const {
	+ return this->color < him.color;
	+ }
	+
	+ INTERNAL_COLOR color;
	+};
	+
	enum ImageFormat{
	FormatPNG,
	FormatBMP,
	FormatJPG,
	FormatPCX,
	FormatTGA,
	FormatTIF,
	FormatXPM,
	FormatGIF,
	FormatUnknown
	};

	ImageFormat identifyImage(const unsigned char * data, int length);

	class TranslucentBitmap;
	class LitBitmap;
	class Bitmap;

	extern Util::Parameter<Bitmap*> screenParameter;

	extern const int SPRITE_NORMAL;
	extern const int SPRITE_LIT;
	extern const int SPRITE_TRANS;

	extern const int SPRITE_NO_FLIP;
	extern const int SPRITE_V_FLIP;
	extern const int SPRITE_H_FLIP;

	/*
	extern int SCALE_X;
	extern int SCALE_Y;
	*/

	class BitmapException: public Exception::Base {
	public:
	BitmapException(const std::string & file, int line, const std::string & reason):
	Base(file, line),
	reason(reason){
	}

	BitmapException(const BitmapException & copy):
	Base(copy),
	reason(copy.reason){
	}

	virtual void throwSelf() const {
	throw *this;
	}

	virtual ~BitmapException() throw () {
	}

	protected:
	virtual const std::string getReason() const {
	return reason;
	}

	std::string reason;
	};

	/* create a color from components */
	Color makeColor(int r, int g, int b);
	Color darken(Color color, double factor);
	void hsvToRGB( float h, float s, float v, int * r, int * g, int * b );

	int setGfxModeText();
	int setGfxModeFullscreen( int x, int y );
	int setGfxModeWindowed( int x, int y );
	int setGraphicsMode(int mode, int width, int height);

	/* get color components */
	int getRed(Color x);
	int getBlue(Color x);
	int getGreen(Color x);

	Color MaskColor();

	enum QualityFilter{
	NoFilter,
	HqxFilter,
	XbrFilter
	};

	QualityFilter qualityFilterName(const std::string & type);

	class Bitmap{
	private:

	/* these constructors don't really matter, get rid of them at some point */
	Bitmap( const Bitmap & copy, int sx, int sy, double accuracy );
	Bitmap( const char * load_file, int sx, int sy, double accuracy );
	public:

	/* equivalent to a GPU shader */
	class Filter{
	public:
	virtual Color filter(Color pixel) const = 0;
	virtual ~Filter(){
	}
	};

	/* default constructor makes 10x10 bitmap */
	Bitmap();
	Bitmap( int x, int y );
	Bitmap( const char * load_file );
	Bitmap(const char * data, int length);
	Bitmap( const std::string & load_file );
	Bitmap( const char * load_file, int sx, int sy );

	/* Load a bitmap from an abstract file */
	Bitmap(Storage::File & file);

	/* 4/24/2010: remove this at some point */
	#ifdef USE_ALLEGRO
	explicit Bitmap( BITMAP * who, bool deep_copy = false );
	#endif
	#ifdef USE_SDL
	explicit Bitmap(SDL_Surface * who, bool deep_copy = false );
	#endif
	#ifdef USE_ALLEGRO5
	explicit Bitmap(ALLEGRO_BITMAP * who, bool deep_copy = false );
	#endif
	Bitmap( const Bitmap & copy, bool deep_copy = false );
	Bitmap( const Bitmap & copy, int sx, int sy );
	Bitmap( const Bitmap & copy, int x, int y, int width, int height );
	virtual ~Bitmap();

	virtual TranslucentBitmap translucent() const;
	/* will call transBlender() with the supplied values for you */
	virtual TranslucentBitmap translucent(int red, int green, int blue, int alpha) const;
	virtual LitBitmap lit() const;

	virtual void save( const std::string & str ) const;

	virtual Bitmap & operator=( const Bitmap & );

	virtual void load( const std::string & str );

	virtual int getWidth() const;
	virtual int getHeight() const;

	/*
	inline const int getWidth() const{
	return getBitmap()->w;
	}

	inline const int getHeight() const{
	return getBitmap()->h;
	}
	*/

	/*
	inline const int getWidth() const{
	return my_bitmap->w;
	}

	inline const int getHeight() const{
	return my_bitmap->h;
	}
	*/

	void detach();

	/* replace all pixels that have value `original' with `replaced' */
	void replaceColor(const Color & original, const Color & replaced);
	void set8BitMaskColor(const Color & color);
	Color get8BitMaskColor();

	/* Blend between source pixel and destination pixel.
	* Source and dest should be 0-255.
	* source = 64, dest = 128
	* pixel = source_pixel * source / 255 + dest_pixel * dest / 255
	*/
	static void alphaBlender(int source, int dest);
	static void transBlender( int r, int g, int b, int a );
	static void multiplyBlender( int r, int g, int b, int a );
	static void dissolveBlender( int r, int g, int b, int a );
	static void addBlender( int r, int g, int b, int a );
	static void burnBlender( int r, int g, int b, int a );
	static void colorBlender( int r, int g, int b, int a );
	static void differenceBlender( int r, int g, int b, int a );
	static void dodgeBlender( int r, int g, int b, int a );
	static void hueBlender( int r, int g, int b, int a );
	static void luminanceBlender( int r, int g, int b, int a );
	static void invertBlender( int r, int g, int b, int a );
	static void screenBlender( int r, int g, int b, int a );
	/* for testing */
	static void setFakeGraphicsMode(int width, int height);

	/* clean up any remaining state */
	static void shutdown();

	// static void drawingMode( int type );

	virtual Color blendColor(const Color & input) const;
	/* sets the blend state. try not to use these function unless
	* absolutely necessary.
	*/
	virtual void startDrawing() const;
	virtual void endDrawing() const;

	void acquire();
	void release();

	void updateOnResize();

	/* Resizes the bitmap and stretches the old pixels to the new bitmap */
	void resize(const int width, const int height);

	/* Just resizes the bitmap without copying pixels */
	void updateSize(const int width, const int height);

	/* Makes this bitmap the same as the parameter.
	* Width/height is copied and then a Blit is called.
	*/
	void copy(const Bitmap & him);

	void debugSelf() const;

	/* convert to a grey scale version */
	virtual Bitmap greyScale();

	virtual void triangle( int x1, int y1, int x2, int y2, int x3, int y3, Color color ) const;

	/* draws an equilateral triangle centered at (x,y) pointing at `angle'
	* where each side has `size' pixels using the color.
	*/
	virtual void equilateralTriangle(int x, int y, int angle, int size, Color color) const;
	virtual void ellipse( int x, int y, int rx, int ry, Color color ) const;
	virtual void ellipseFill( int x, int y, int rx, int ry, Color color ) const;

	- virtual void light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, int focus_color, Color edge_color) const;
	+ virtual void light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, Color focus_color, Color edge_color) const;
	virtual void applyTrans(const Color color) const;

	virtual void border( int min, int max, Color color ) const;
	virtual void rectangle( int x1, int y1, int x2, int y2, Color color ) const;
	virtual void rectangleFill( int x1, int y1, int x2, int y2, Color color ) const;
	virtual void circleFill( int x, int y, int radius, Color color ) const;
	virtual void circle( int x, int y, int radius, Color color ) const;
	virtual void circle(int x, int y, int radius, int thickness, Color color) const;
	virtual void line( const int x1, const int y1, const int x2, const int y2, const Color color ) const;

	virtual void floodfill( const int x, const int y, const Color color ) const;
	virtual void horizontalLine( const int x1, const int y, const int x2, const Color color ) const;
	virtual void hLine( const int x1, const int y, const int x2, const Color color ) const;
	virtual void vLine( const int y1, const int x, const int y2, const Color color ) const;
	virtual void polygon( const int * verts, const int nverts, const Color color ) const;
	virtual void arc(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const;
	virtual void arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const;

	/* x/y is in the center of the bitmap */
	virtual void drawCenter(const int x, const int y, const Bitmap & where) const;

	virtual void draw(const int x, const int y, const Bitmap & where) const;
	virtual void draw(const int x, const int y, Filter * filter, const Bitmap & where) const;
	virtual void draw(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, const Bitmap & where) const;
	virtual void draw(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, Filter * filter, const Bitmap & where) const;
	- virtual void drawCharacter( const int x, const int y, const int color, const int background, const Bitmap & where ) const;
	+ virtual void drawCharacter( const int x, const int y, const Color color, const int background, const Bitmap & where ) const;

	/* flip horizontally */
	virtual void drawHFlip(const int x, const int y, const Bitmap & where) const;
	virtual void drawHFlip(const int x, const int y, Filter * filter, const Bitmap & where) const;
	virtual void drawHFlip(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, const Bitmap & where) const;
	virtual void drawHFlip(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, Filter * filter, const Bitmap & where) const;
	/* flip vertically */
	virtual void drawVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;

	/* flip horizontal and vertical */
	virtual void drawHVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	// virtual void drawTrans( const int x, const int y, const Bitmap & where ) const;
	// virtual void drawTrans( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	// virtual void drawTransHFlip( const int x, const int y, const Bitmap & where ) const;
	// virtual void drawTransHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	// virtual void drawTransVFlip( const int x, const int y, const Bitmap & where ) const;
	// virtual void drawTransVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	// virtual void drawTransHVFlip( const int x, const int y, const Bitmap & where ) const;
	// virtual void drawTransHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	virtual void drawMask( const int x, const int y, const Bitmap & where );
	virtual void drawStretched( const int x, const int y, const int new_width, const int new_height, const Bitmap & who ) const;
	virtual void drawStretched(const Bitmap & who) const;

	/* middle of the bitmap is at x, y */
	virtual void drawRotateCenter(const int x, const int y, const int angle, const Bitmap & where);
	/* upper left hand corner is at x, y*/
	virtual void drawRotate(const int x, const int y, const int angle, const Bitmap & where);
	virtual void drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const Bitmap & where );
	virtual void drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const double scale, const Bitmap & where );

	/* Stretch using the hqx algorithm */
	virtual void StretchHqx(const Bitmap & where) const;
	virtual void StretchHqx(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight) const;

	/* Xbr is defined here:
	* http://board.byuu.org/viewtopic.php?f=10&t=2248
	*/
	virtual void StretchXbr(const Bitmap & where) const;
	virtual void StretchXbr(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight) const;

	/* Just copies pixels (fast) */
	virtual void Stretch(const Bitmap & where) const;
	virtual void Stretch(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight ) const;
	virtual void StretchBy2( const Bitmap & where );
	virtual void StretchBy4( const Bitmap & where );

	virtual void Blit( const std::string & xpath ) const;
	virtual void Blit( const Bitmap & where ) const;
	virtual void Blit( const int x, const int y, const Bitmap & where ) const;
	virtual void Blit( const int mx, const int my, const int wx, const int wy, const Bitmap & where ) const;
	virtual void Blit( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const;
	virtual void BlitMasked( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const;
	virtual void BlitToScreen() const;
	virtual void BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const;
	virtual void BlitToScreen(const int upper_left_x, const int upper_left_y) const;
	virtual void BlitFromScreen(const int x, const int y) const;

	void roundRect(int radius, int x1, int y1, int x2, int y2, Color color) const;
	void roundRectFill(int radius, int x1, int y1, int x2, int y2, Graphics::Color color) const;

	virtual void drawShadow(Bitmap & where, int x, int y, int intensity, Color color, double scale, bool facingRight) const;

	/* returned a scaled version of this bitmap of the given dimensions */
	virtual Bitmap scaleTo(const int width, const int height) const;

	/* scale the image by the given ratios, i.e: a ratio of 1 means do nothing.
	* less than 1 will make it smaller and larger than 1 will make it larger.
	*/
	virtual Bitmap scaleBy(const double widthRatio, const double heightRatio) const;

	/* try to call Global::getScreenWidth/Height() instead of these directly */
	static int getScreenWidth();
	static int getScreenHeight();

	virtual void fill(Color color) const;

	virtual void clear() const;

	inline void clearToMask() const{
	this->fill(MaskColor());
	}

	bool getError();

	inline const Util::ReferenceCount<BitmapData> & getData() const {
	return data;
	}

	inline Util::ReferenceCount<BitmapData> getData(){
	return data;
	}

	void setData(Util::ReferenceCount<BitmapData> data){
	this->data = data;
	}

	virtual void readLine( std::vector<Color> & vec, int y );
	Color getPixel( const int x, const int y ) const;

	/* lock video bitmap to memory */
	void lock() const;
	void lock(int x, int y, int width, int height) const;
	void unlock() const;

	/* true if the point is within the bounds of the bitmap */
	bool inRange(int x, int y) const;

	/* uses _putpixel16 underneath which ignores translucent behavior */
	void putPixel( int x, int y, Color col ) const;
	/* respects the current trans mode */
	virtual void putPixelNormal(int x, int y, Color col) const;

	/*
	inline int getPixel( int x, int y ) const{
	if ( x >= 0 && x < my_bitmap->w && y >= 0 && y <= my_bitmap->h )
	return _getpixel16( my_bitmap, x, y );
	return -1;
	}

	inline void putPixel( int x, int y, int col ) const{
	if ( x >= 0 && x < my_bitmap->w && y >= 0 && y <= my_bitmap->h )
	_putpixel16( my_bitmap, x, y, col );
	}
	*/

	void setClipRect( int x1, int y1, int x2, int y2 ) const;
	void getClipRect( int & x1, int & y1, int & x2, int & y2 ) const;

	inline const std::string & getPath() const{
	return path;
	}

	/* produce a temporary bitmap that is not guaranteed to be preserved
	* after your function returns. do not hold references to this bitmap
	* and if you make a temporary bitmap, do not call functions that
	* might also make temporary bitmaps.
	*/
	static Bitmap temporaryBitmap(int w, int h);
	static Bitmap temporaryBitmap2(int w, int h);

	/* call this method to delete all temporary bitmaps.
	* don't call this unless you know what you are doing
	*/
	static void cleanupTemporaryBitmaps();

	static double getScale();


	/*
	* Convert color values between the HSV and RGB color spaces. The RGB values
	* range from 0 to 255, hue is from 0 to 360, and saturation and value are
	* from 0 to 1.
	*/
	static void rgbToHSV(int r, int g, int b, float * h, float * s, float * v);

	/* convert cymk to rgb. values should be in the range 0-255 */
	static void cymkToRGB(int c, int y, int m, int k, int * r, int * g, int * b);

	/* Add two RGB16 colors together
	* r = c1.r + c2.r
	* g = c1.g + c2.g
	* b = c1.b + c2.b
	*/
	- static int addColor( int color1, int color2 );
	+ static Color addColor( Color color1, Color color2 );

	/*
	inline static int makeColor( int r, int g, int b ){
	return makecol16( r, g, b );
	}
	*/

	// static const int MaskColor = MASK_COLOR_16;
	/*
	static const int MODE_TRANS;
	static const int MODE_SOLID;
	*/

	#ifdef USE_ALLEGRO5
	void convertToVideo();
	#endif
	protected:
	/* release a reference count, and possibly destroy data */
	// void releaseInternalBitmap();

	/* really destroy private data */
	// void destroyPrivateData();

	/*
	inline void setBitmap( BITMAP * bitmap ){
	if ( bitmap == NULL ){
	std::cout << "FATAL Setting null bitmap" << std::endl;
	}
	_my_bitmap = bitmap;
	}
	*/

	void loadFromMemory(const char * data, int length);

	void internalLoadFile( const char * load_file );

	/* implementation specific data */
	Util::ReferenceCount<BitmapData> data;
	// int * own;
	bool mustResize;
	// bool own;
	bool error;
	std::string path;
	static Bitmap * temporary_bitmap;
	static Bitmap * temporary_bitmap2;
	Color bit8MaskColor;

	/* only used by allegro5 for now */
	int width, height;
	};

	/* 8-bit bitmap that supports a palette */
	class PaletteBitmap: public Bitmap {
	public:
	PaletteBitmap();
	virtual ~PaletteBitmap();
	using Bitmap::operator=;

	protected:
	Color palette[256];
	};

	Bitmap memoryPCX(unsigned char * const data, const int length, const bool mask = true);

	/* creates a bitmap that can be used as a buffer for the screen.
	* on opengl/allegro5 systems this will return the current backbuffer
	*/
	Bitmap * getScreenBuffer();

	void blend_palette(Color * pal, int mp, Color sc, Color ec);
	// bool sameColors(Color color1, Color color2);

	class LitBitmap: public Bitmap {
	public:
	LitBitmap( const Bitmap & b );
	LitBitmap();
	virtual ~LitBitmap();

	using Bitmap::draw;
	virtual void draw(const int x, const int y, const Bitmap & where) const;
	virtual void draw(const int x, const int y, Filter * filter, const Bitmap & where ) const;
	using Bitmap::drawHFlip;
	virtual void drawHFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	using Bitmap::drawVFlip;
	virtual void drawVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	using Bitmap::drawHVFlip;
	virtual void drawHVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	using Bitmap::operator=;
	};

	class StretchedBitmap: public Bitmap {
	public:
	StretchedBitmap(int width, int height, const Bitmap & where, QualityFilter filter = NoFilter);
	void finish();
	void start();
	virtual int getWidth() const;
	virtual int getHeight() const;
	using Bitmap::operator=;

	virtual double getScaleWidth() const;
	virtual double getScaleHeight() const;

	protected:
	double width;
	double height;
	double scale_x, scale_y;
	const Bitmap & where;
	const QualityFilter filter;
	Bitmap scaleToFilter;
	};

	class TranslatedBitmap: public Bitmap {
	public:
	TranslatedBitmap(int x, int y, const Bitmap & where);
	using Bitmap::operator=;
	using Bitmap::BlitToScreen;
	virtual void BlitToScreen() const;
	virtual ~TranslatedBitmap();
	public:
	int x, y;
	};

	class TranslucentBitmap: public Bitmap {
	public:
	TranslucentBitmap(const Bitmap & b);
	TranslucentBitmap();
	virtual ~TranslucentBitmap();

	using Bitmap::operator=;
	virtual Color blendColor(const Color & color) const;
	virtual void startDrawing() const;
	virtual void endDrawing() const;

	virtual void putPixelNormal(int x, int y, Color col) const;
	virtual void rectangleFill(int x1, int y1, int x2, int y2, Color color) const;
	virtual void rectangle(int x1, int y1, int x2, int y2, Color color) const;
	virtual void fill(Color color) const;
	virtual void line( const int x1, const int y1, const int x2, const int y2, const Color color ) const;
	virtual void hLine( const int x1, const int y, const int x2, const Color color ) const;
	virtual void arc(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color) const;
	virtual void arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const;
	virtual void circleFill( int x, int y, int radius, Color color ) const;
	virtual void ellipse( int x, int y, int rx, int ry, Color color ) const;
	virtual void ellipseFill( int x, int y, int rx, int ry, Color color ) const;

	using Bitmap::draw;
	virtual void draw(const int x, const int y, const Bitmap & where) const;
	virtual void draw(const int x, const int y, Filter * filter, const Bitmap & where) const;
	// virtual void draw(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, const Bitmap & where) const;
	// virtual void draw(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, Filter * filter, const Bitmap & where) const;

	using Bitmap::drawHFlip;
	virtual void drawHFlip(const int x, const int y, const Bitmap & where) const;
	virtual void drawHFlip(const int x, const int y, Filter * filter, const Bitmap & where) const;
	// virtual void drawHFlip(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, const Bitmap & where) const;
	// virtual void drawHFlip(const int x, const int y, const int startWidth, const int startHeight, const int width, const int height, Filter * filter, const Bitmap & where) const;
	virtual void drawVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;
	virtual void drawHVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const;

	};

	}

	#endif
	diff --git a/util/graphics/sdl/bitmap.cpp b/util/graphics/sdl/bitmap.cpp
	index 2bf15286..8ce12941 100644
	--- a/util/graphics/sdl/bitmap.cpp
	+++ b/util/graphics/sdl/bitmap.cpp
	@@ -1,2366 +1,2366 @@
	#include "util/funcs.h"
	#include "util/debug.h"
	#include "util/system.h"
	#include "util/init.h"
	#include "hqx.h"
	#include "xbr.h"
	#include "sprig/sprig.h"
	#include "stretch/SDL_stretch.h"
	#include <SDL.h>
	#include "image/SDL_image.h"
	#include "image/IMG_savepng.h"
	#include <math.h>
	#include "util/exceptions/exception.h"
	#include <string>
	#include <sstream>

	namespace Graphics{

	static const int WINDOWED = 0;
	static const int FULLSCREEN = 1;
	/* bits per pixel */
	static int SCREEN_DEPTH = 16;
	static SDL_Surface * screen;

	static SDL_PixelFormat format565;

	/* FIXME: try to get rid of these two variables */
	/*
	static int SCALE_X;
	static int SCALE_Y;
	*/

	typedef unsigned int (*blender)(unsigned int color1, unsigned int color2, unsigned int alpha);

	/* taken from allegro 4.2: src/colblend.c, _blender_trans16 */
	/* this function performs a psuedo-SIMD operation on the pixel
	* components in RGB 5-6-5 format. To get this to work for some
	* other format probably all that needs to happen is to change
	* the 0x7E0F81F constant to something else. 5-5-5:
	* binary: 0011 1110 000 0111 1100 0001 1111
	* hex: 0x174076037
	*/
	static inline unsigned int transBlender(unsigned int x, unsigned int y, unsigned int n){
	unsigned long result;

	if (n)
	n = (n + 1) / 8;

	/* hex: 0x7E0F81F
	* binary: 0111 1110 0000 1111 1000 0001 1111
	*/
	x = ((x & 0xFFFF) \| (x << 16)) & 0x7E0F81F;
	y = ((y & 0xFFFF) \| (y << 16)) & 0x7E0F81F;

	result = ((x - y) * n / 32 + y) & 0x7E0F81F;

	return ((result & 0xFFFF) \| (result >> 16));
	}

	static inline unsigned int multiplyBlender(unsigned int x, unsigned int y, unsigned int n){
	Uint8 redX = 0;
	Uint8 greenX = 0;
	Uint8 blueX = 0;
	SDL_GetRGB(x, &format565, &redX, &greenX, &blueX);
	Uint8 redY = 0;
	Uint8 greenY = 0;
	Uint8 blueY = 0;
	SDL_GetRGB(y, &format565, &redY, &greenY, &blueY);

	int r = redX * redY / 256;
	int g = greenX * greenY / 256;
	int b = blueX * blueY / 256;
	- return transBlender(makeColor(r, g, b), y, n);
	+ return transBlender(makeColor(r, g, b).color, y, n);
	}

	static inline unsigned int alphaBlender(unsigned int x, unsigned int y, unsigned int n){
	Uint8 source = n >> 8;
	Uint8 dest = n & 0xff;

	/*
	unsigned long result;

	x = ((x & 0xFFFF) \| (x << 16)) & 0x7E0F81F;
	y = ((y & 0xFFFF) \| (y << 16)) & 0x7E0F81F;

	result = ((x * source / 255) + (y * dest / 255)) & 0x7E0F81F;

	return ((result & 0xFFFF) \| (result >> 16));
	*/

	Uint8 redX = 0;
	Uint8 greenX = 0;
	Uint8 blueX = 0;
	SDL_GetRGB(x, &format565, &redX, &greenX, &blueX);
	Uint8 redY = 0;
	Uint8 greenY = 0;
	Uint8 blueY = 0;
	SDL_GetRGB(y, &format565, &redY, &greenY, &blueY);

	int r = (redY * dest + redX * source) / 256;
	int g = (greenY * dest + greenX * source) / 256;
	int b = (blueY * dest + blueX * source) / 256;

	r = Util::min(r, 255);
	g = Util::min(g, 255);
	b = Util::min(b, 255);

	// return transBlender(makeColor(r, g, b), y, dest);

	- return makeColor(r, g, b);
	+ return makeColor(r, g, b).color;
	// return y;
	}

	static inline unsigned int addBlender(unsigned int x, unsigned int y, unsigned int n){
	Uint8 redX = 0;
	Uint8 greenX = 0;
	Uint8 blueX = 0;
	SDL_GetRGB(x, &format565, &redX, &greenX, &blueX);
	Uint8 redY = 0;
	Uint8 greenY = 0;
	Uint8 blueY = 0;
	SDL_GetRGB(y, &format565, &redY, &greenY, &blueY);

	int r = redY + redX * n / 256;
	int g = greenY + greenX * n / 256;
	int b = blueY + blueX * n / 256;

	r = Util::min(r, 255);
	g = Util::min(g, 255);
	b = Util::min(b, 255);

	- return makeColor(r, g, b);
	+ return makeColor(r, g, b).color;
	}

	static inline int iabs(int x){
	return x < 0 ? -x : x;
	}

	static inline unsigned int differenceBlender(unsigned int x, unsigned int y, unsigned int n){
	Uint8 redX = 0;
	Uint8 greenX = 0;
	Uint8 blueX = 0;
	SDL_GetRGB(x, &format565, &redX, &greenX, &blueX);
	Uint8 redY = 0;
	Uint8 greenY = 0;
	Uint8 blueY = 0;
	SDL_GetRGB(y, &format565, &redY, &greenY, &blueY);

	// int r = iabs(redY - redX);
	// int g = iabs(greenY - greenX);
	// int b = iabs(blueY - blueX);
	int r = redY - redX;
	int g = greenY - greenX;
	int b = blueY - blueX;
	if (r < 0){
	r = 0;
	}
	if (g < 0){
	g = 0;
	}
	if (b < 0){
	b = 0;
	}
	- return transBlender(makeColor(r, g, b), y, n);
	+ return transBlender(makeColor(r, g, b).color, y, n);
	}

	static inline unsigned int burnBlender(unsigned int x, unsigned int y, unsigned int n){
	Uint8 redX = 0;
	Uint8 greenX = 0;
	Uint8 blueX = 0;
	SDL_GetRGB(x, &format565, &redX, &greenX, &blueX);
	Uint8 redY = 0;
	Uint8 greenY = 0;
	Uint8 blueY = 0;
	SDL_GetRGB(y, &format565, &redY, &greenY, &blueY);

	int r = redX - redY;
	int g = greenX - greenY;
	int b = blueX - blueY;
	if (r < 0){
	r = 0;
	}
	if (g < 0){
	g = 0;
	}
	if (b < 0){
	g = 0;
	}
	- return transBlender(makeColor(r, g, b), y, n);
	+ return transBlender(makeColor(r, g, b).color, y, n);
	}

	static inline unsigned int noBlender(unsigned int a, unsigned int b, unsigned int c){
	return a;
	}

	struct BlendingData{
	BlendingData():
	red(0), green(0), blue(0), alpha(0), currentBlender(noBlender){}

	int red, green, blue, alpha;
	blender currentBlender;
	};

	BitmapData::~BitmapData(){
	if (surface != NULL && destroy){
	SDL_FreeSurface(surface);
	}
	}

	static BlendingData globalBlend;
	// static int drawingMode = Bitmap::MODE_SOLID;

	/*
	static int drawingAlpha(){
	if (drawingMode == Bitmap::MODE_SOLID){
	return 255;
	}
	if (drawingMode == Bitmap::MODE_TRANS){
	return globalBlend.alpha;
	}
	return 255;
	}
	*/

	static void paintown_applyTrans16(SDL_Surface * dst, const int color);
	static void paintown_replace16(SDL_Surface * dst, const int original, const int replace);
	static void paintown_draw_sprite_ex16(SDL_Surface * dst, SDL_Surface * src, long long dx, long long dy, int mode, int flip, Bitmap::Filter * filter);
	static void paintown_draw_sprite_filter_ex16(SDL_Surface * dst, SDL_Surface * src, long long x, long long y, Bitmap::Filter * filter);
	static void paintown_light16(SDL_Surface * dst, const int x, const int y, int width, int height, const int start_y, const int focus_alpha, const int edge_alpha, const int focus_color, const int edge_color);

	-int MaskColor(){
	- static int mask = makeColor(255, 0, 255);
	+Color MaskColor(){
	+ static Color mask = makeColor(255, 0, 255);
	return mask;
	}

	static SDL_Surface * optimizedSurface(SDL_Surface * in){
	/* SDL_DisplayFormat will return 0 if a graphics context is not set,
	* like if a test is running instead of the real game.
	*/
	// SDL_Surface * out = SDL_DisplayFormat(in);
	SDL_Surface * out = SDL_ConvertSurface(in, &format565, SDL_SWSURFACE);
	if (out == NULL){
	// out = SDL_CreateRGBSurface(SDL_SWSURFACE, in->w, in->h, in->format->BitsPerPixel, 0, 0, 0, 0);
	out = SDL_CreateRGBSurface(SDL_SWSURFACE, in->w, in->h, SCREEN_DEPTH, format565.Rmask, format565.Gmask, format565.Bmask, format565.Amask);
	if (out == NULL){
	std::ostringstream out;
	out << "Could not create RGB surface of size " << in->w << ", " << in->h << ". Memory usage: " << System::memoryUsage();
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	SDL_Rect source;
	SDL_Rect destination;
	source.w = in->w;
	source.h = in->h;
	source.x = 0;
	source.y = 0;

	destination.w = in->w;
	destination.h = in->h;
	destination.x = 0;
	destination.y = 0;

	SDL_BlitSurface(in, &source, out, &destination);
	}
	return out;
	}

	static Bitmap * Scaler = NULL;

	BitmapData::BitmapData(SDL_Surface * surface):
	surface(surface),
	destroy(true){
	setSurface(surface);
	}

	void BitmapData::setSurface(SDL_Surface * surface){
	this->surface = surface;
	clip_left = 0;
	clip_top = 0;
	if (surface){
	clip_right = surface->w;
	clip_bottom = surface->h;
	} else {
	clip_right = 0;
	clip_bottom = 0;
	}
	}

	Bitmap::Bitmap():
	mustResize(false),
	bit8MaskColor(0){
	int width = 1;
	int height = 1;
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, SCREEN_DEPTH, format565.Rmask, format565.Gmask, format565.Bmask, format565.Amask);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(surface)));
	}

	Bitmap::Bitmap(const char * data, int length):
	mustResize(false),
	bit8MaskColor(0){
	loadFromMemory(data, length);
	}

	Bitmap::Bitmap(SDL_Surface * who, bool deep_copy):
	mustResize(false),
	bit8MaskColor(0){
	if (deep_copy){
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, who->w, who->h, SCREEN_DEPTH, format565.Rmask, format565.Gmask, format565.Bmask, format565.Amask);
	SDL_Rect source;
	SDL_Rect destination;
	source.w = surface->w;
	source.h = surface->h;
	source.x = 0;
	source.y = 0;

	destination.w = surface->w;
	destination.h = surface->h;
	destination.x = 0;
	destination.y = 0;

	SDL_BlitSurface(who, &source, surface, &destination);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(surface)));
	} else {
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(who)));
	}
	}

	Bitmap::Bitmap(int w, int h):
	mustResize(false),
	bit8MaskColor(0){
	if (w < 1){
	w = 1;
	}
	if (h < 1){
	h = 1;
	}
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, SCREEN_DEPTH, format565.Rmask, format565.Gmask, format565.Bmask, format565.Amask);
	if (surface == NULL){
	std::ostringstream out;
	out << "Could not create surface with dimensions " << w << ", " << h;
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(surface)));
	}

	Bitmap::Bitmap( const char * load_file ):
	mustResize(false),
	bit8MaskColor(0){
	internalLoadFile(load_file);
	}

	Bitmap::Bitmap( const std::string & load_file ):
	mustResize(false){
	internalLoadFile(load_file.c_str());
	}

	Bitmap::Bitmap( const char * load_file, int sx, int sy ):
	mustResize(false),
	bit8MaskColor(0){
	Bitmap temp(load_file);
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, sx, sy, SCREEN_DEPTH, format565.Rmask, format565.Gmask, format565.Bmask, format565.Amask);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(surface)));

	temp.Stretch(*this);
	}

	/* unused */
	Bitmap::Bitmap( const char * load_file, int sx, int sy, double accuracy ):
	mustResize(false),
	bit8MaskColor(0){
	throw BitmapException(__FILE__, __LINE__, "Unimplemented constructor");
	}

	Bitmap::Bitmap( const Bitmap & copy, bool deep_copy):
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	if (deep_copy){
	SDL_Surface * who = copy.getData()->getSurface();
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, who->w, who->h, SCREEN_DEPTH, format565.Rmask, format565.Gmask, format565.Bmask, format565.Amask);
	SDL_Rect source;
	SDL_Rect destination;
	source.w = surface->w;
	source.h = surface->h;
	source.x = 0;
	source.y = 0;

	destination.w = surface->w;
	destination.h = surface->h;
	destination.x = 0;
	destination.y = 0;

	SDL_BlitSurface(who, &source, surface, &destination);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(surface)));
	} else {
	setData(copy.getData());
	}
	}

	Bitmap::Bitmap( const Bitmap & copy, int sx, int sy ):
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	/* TODO */
	}

	Bitmap::Bitmap( const Bitmap & copy, int sx, int sy, double accuracy ):
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	/* TODO */
	}

	void Bitmap::loadFromMemory(const char * data, int length){
	SDL_RWops * ops = SDL_RWFromConstMem(data, length);
	SDL_Surface * loaded = IMG_Load_RW(ops, 1);
	if (loaded){
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(optimizedSurface(loaded))));
	SDL_FreeSurface(loaded);
	} else {
	std::ostringstream out;
	out << "Could not load surface from memory " << (void*) data << " length " << length;
	throw BitmapException(__FILE__, __LINE__, out.str());
	}

	}

	static inline Uint8* computeOffset(SDL_Surface * surface, int x, int y){
	int bpp = surface->format->BytesPerPixel;
	return ((Uint8)surface->pixels) + y surface->pitch + x * bpp;
	}

	Bitmap::Bitmap( const Bitmap & copy, int x, int y, int width, int height ):
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	SDL_Surface * his = copy.getData()->getSurface();
	if (x < 0)
	x = 0;
	if (y < 0)
	y = 0;
	if (width + x > his->w )
	width = his->w - x;
	if (height + y > his->h)
	height = his->h - y;

	SDL_Surface * sub = SDL_CreateRGBSurfaceFrom(computeOffset(his, x, y), width, height, SCREEN_DEPTH, his->pitch, format565.Rmask, format565.Gmask, format565.Bmask, format565.Amask);
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(sub)));
	}

	void Bitmap::internalLoadFile(const char * path){
	this->path = path;
	SDL_Surface * loaded = IMG_Load(path);
	if (loaded){
	setData(Util::ReferenceCount<BitmapData>(new BitmapData(optimizedSurface(loaded))));
	SDL_FreeSurface(loaded);
	} else {
	std::ostringstream out;
	out << "Could not load file '" << path << "'";
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	}

	int Bitmap::getWidth() const {
	if (getData()->getSurface() != NULL){
	return getData()->getSurface()->w;
	}

	return 0;
	}

	int Bitmap::getHeight() const {
	if (getData()->getSurface() != NULL){
	return getData()->getSurface()->h;
	}

	return 0;
	}

	-int getRed(int c){
	+int getRed(Color c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	- SDL_GetRGB(c, &format565, &red, &green, &blue);
	+ SDL_GetRGB(c.color, &format565, &red, &green, &blue);
	return red;
	}

	-int getBlue(int c){
	+int getBlue(Color c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	- SDL_GetRGB(c, &format565, &red, &green, &blue);
	+ SDL_GetRGB(c.color, &format565, &red, &green, &blue);
	return blue;
	}

	-int getGreen(int c){
	+int getGreen(Color c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	- SDL_GetRGB(c, &format565, &red, &green, &blue);
	+ SDL_GetRGB(c.color, &format565, &red, &green, &blue);
	return green;
	}

	-int makeColor(int red, int blue, int green){
	- return SDL_MapRGB(&format565, red, blue, green);
	+Color makeColor(int red, int blue, int green){
	+ return Color(SDL_MapRGB(&format565, red, blue, green));
	}

	void initializeExtraStuff(){
	/* this is as good a place as any to initialize our format */
	format565.palette = 0;
	format565.BitsPerPixel = 16;
	format565.BytesPerPixel = 2;
	format565.Rloss = 3;
	format565.Gloss = 2;
	format565.Bloss = 3;
	format565.Aloss = 0;
	format565.Rshift = 11;
	format565.Gshift = 5;
	format565.Bshift = 0;
	format565.Ashift = 0;
	format565.Rmask = 63488;
	format565.Gmask = 2016;
	format565.Bmask = 31;
	format565.Amask = 0;
	#if !SDL_VERSION_ATLEAST(1, 3, 0)
	format565.colorkey = 0;
	format565.alpha = 255;
	#endif
	}

	/* This code isn't used but leave it here for reference */
	#ifdef PS3
	#include <rsx/rsx.h>
	#include <sysutil/video.h>
	void getNativePs3Resolution(int * width, int * height){
	videoState state;
	videoGetState(0,0,&state);
	videoResolution resolution;
	videoGetResolution(state.displayMode.resolution, &resolution);
	*height = resolution.height;
	/* preserve 640x480 aspect ratio */
	width = (int)((height) * 1.33333);
	}
	#endif

	int setGraphicsMode(int mode, int width, int height){
	initializeExtraStuff();

	switch (mode){
	case WINDOWED : {
	// screen = SDL_SetVideoMode(width, height, SCREEN_DEPTH, SDL_HWSURFACE \| SDL_DOUBLEBUF \| SDL_RESIZABLE);
	screen = SDL_SetVideoMode(width, height, SCREEN_DEPTH, SDL_SWSURFACE \| SDL_RESIZABLE);
	SDL_ShowCursor(0);
	// screen = SDL_SetVideoMode(width, height, SCREEN_DEPTH, SDL_SWSURFACE \| SDL_DOUBLEBUF);
	if (!screen){
	return 1;
	}
	break;
	}
	case FULLSCREEN : {
	screen = SDL_SetVideoMode(width, height, SCREEN_DEPTH, SDL_HWSURFACE \| SDL_DOUBLEBUF \| SDL_FULLSCREEN);
	SDL_ShowCursor(0);
	// screen = SDL_SetVideoMode(width, height, SCREEN_DEPTH, SDL_SWSURFACE \| SDL_DOUBLEBUF);
	if (!screen){
	return 1;
	}
	break;
	}
	}

	Global::debug(1) << "SDL Screen format palette: " << screen->format->palette <<
	" bits per pixel: " << (int) screen->format->BitsPerPixel <<
	" bytes per pixel: " << (int) screen->format->BytesPerPixel <<
	" rloss: " << (int) screen->format->Rloss <<
	" gloss: " << (int) screen->format->Gloss <<
	" bloss: " << (int) screen->format->Bloss <<
	" aloss: " << (int) screen->format->Aloss <<
	" rshift: " << (int) screen->format->Rshift <<
	" gshift: " << (int) screen->format->Gshift <<
	" bshift: " << (int) screen->format->Bshift <<
	" ashift: " << (int) screen->format->Ashift <<
	" rmask: " << (int) screen->format->Rmask <<
	" gmask: " << (int) screen->format->Gmask <<
	" bmask: " << (int) screen->format->Bmask <<
	" amask: " << (int) screen->format->Amask <<
	#if !SDL_VERSION_ATLEAST(1, 3, 0)
	" colorkey: " << (int) screen->format->colorkey <<
	" alpha: " << (int) screen->format->alpha << std::endl;
	#else
	std::endl;
	#endif


	/*
	SCALE_X = width;
	SCALE_Y = height;
	*/

	/* does this need to be here? I think configuration will set SCALE_ */
	/*
	SCALE_X = 640;
	SCALE_Y = 480;
	*/

	if ( Screen != NULL ){
	delete Screen;
	Screen = NULL;
	}

	/*
	if ( Scaler != NULL ){
	delete Scaler;
	Scaler = NULL;
	}
	*/

	if (width != 0 && height != 0){
	Screen = new Bitmap(screen);
	/* don't destroy the screen */
	Screen->getData()->destroy = false;

	/* Scaler is re-used as the screen buffer so don't destroy it */
	if (Scaler == NULL){
	Scaler = new Bitmap(width, height);
	} else {
	Scaler->updateSize(width, height);
	}

	/*
	if ( width != 0 && height != 0 && (width != SCALE_X \|\| height != SCALE_Y) ){
	Scaler = new Bitmap(width, height);
	Buffer = new Bitmap(SCALE_X, SCALE_Y);
	}
	*/
	}

	for (std::vector<Bitmap*>::iterator it = needResize.begin(); it != needResize.end(); it++){
	Bitmap * who = *it;
	who->resize(width, height);
	}

	return 0;
	}

	Bitmap * getScreenBuffer(){
	return Scaler;
	}

	void Bitmap::shutdown(){
	delete Screen;
	Screen = NULL;
	delete Scaler;
	Scaler = NULL;
	}

	void Bitmap::addBlender( int r, int g, int b, int a ){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.currentBlender = Graphics::addBlender;
	}

	void Bitmap::multiplyBlender( int r, int g, int b, int a ){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.currentBlender = Graphics::multiplyBlender;
	}

	void Bitmap::differenceBlender( int r, int g, int b, int a ){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.currentBlender = Graphics::differenceBlender;
	}

	void Bitmap::burnBlender(int r, int g, int b, int a){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.currentBlender = Graphics::burnBlender;
	}

	int setGfxModeText(){
	/* TODO */
	return 0;
	}

	int setGfxModeFullscreen(int x, int y){
	return setGraphicsMode(FULLSCREEN, x, y);
	}

	int setGfxModeWindowed( int x, int y ){
	return setGraphicsMode(WINDOWED, x, y);
	}

	/*
	void Bitmap::drawingMode(int type){
	Graphics::drawingMode = type;
	}
	*/

	void Bitmap::alphaBlender(int source, int dest){
	globalBlend.red = 0;
	globalBlend.green = 0;
	globalBlend.blue = 0;
	/* Shove values into alpha */
	if (source > 255){
	source = 255;
	}
	if (dest > 255){
	dest = 255;
	}
	globalBlend.alpha = ((source & 0xff) << 8) + (dest & 0xff);
	globalBlend.currentBlender = Graphics::alphaBlender;
	}

	void Bitmap::transBlender( int r, int g, int b, int a ){
	globalBlend.red = r;
	globalBlend.green = g;
	globalBlend.blue = b;
	globalBlend.alpha = a;
	globalBlend.currentBlender = Graphics::transBlender;
	}

	void Bitmap::setClipRect( int x1, int y1, int x2, int y2 ) const {
	SDL_Rect area;
	area.x = x1;
	area.y = y1;
	area.w = x2 - x1;
	area.h = y2 - y1;
	SDL_SetClipRect(getData()->getSurface(), &area);
	SDL_GetClipRect(getData()->getSurface(), &area);
	getData()->setClip(area.x, area.y, area.x + area.w, area.y + area.h);
	}

	void Bitmap::getClipRect(int & x1, int & y1, int & x2, int & y2) const {
	const Util::ReferenceCount<BitmapData> & data = getData();
	x1 = data->clip_left;
	y1 = data->clip_top;
	x2 = data->clip_right;
	y2 = data->clip_bottom;
	}

	static void doPutPixel(SDL_Surface * surface, int x, int y, int pixel, bool translucent){

	if (SDL_MUSTLOCK(surface)){
	SDL_LockSurface(surface);
	}

	int bpp = surface->format->BytesPerPixel;
	/* Here p is the address to the pixel we want to set */
	Uint8 *p = computeOffset(surface, x, y);

	switch(bpp) {
	case 1:
	*p = pixel;
	break;

	case 2:
	if (translucent){
	(Uint16 )p = globalBlend.currentBlender(pixel, (Uint16)p, globalBlend.alpha);
	} else {
	(Uint16 )p = pixel;
	}
	break;
	case 3:
	if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
	p[0] = (pixel >> 16) & 0xff;
	p[1] = (pixel >> 8) & 0xff;
	p[2] = pixel & 0xff;
	} else {
	p[0] = pixel & 0xff;
	p[1] = (pixel >> 8) & 0xff;
	p[2] = (pixel >> 16) & 0xff;
	}
	break;
	case 4:
	(Uint32 )p = pixel;
	break;
	}

	if (SDL_MUSTLOCK(surface)){
	SDL_UnlockSurface(surface);
	}

	}

	-void Bitmap::putPixel(int x, int y, int pixel) const {
	+void Bitmap::putPixel(int x, int y, Color pixel) const {
	/* clip it */
	if (getData()->isClipped(x, y)){
	return;
	}

	SDL_Surface * surface = getData()->getSurface();
	- doPutPixel(surface, x, y, pixel, false);
	+ doPutPixel(surface, x, y, pixel.color, false);
	}

	-void Bitmap::putPixelNormal(int x, int y, int col) const {
	+void Bitmap::putPixelNormal(int x, int y, Color col) const {
	putPixel(x, y, col);
	}

	-void TranslucentBitmap::putPixelNormal(int x, int y, int color) const {
	+void TranslucentBitmap::putPixelNormal(int x, int y, Color color) const {
	if (getData()->isClipped(x, y)){
	return;
	}

	SDL_Surface * surface = getData()->getSurface();
	- doPutPixel(surface, x, y, color, true);
	+ doPutPixel(surface, x, y, color.color, true);
	}

	bool Bitmap::getError(){
	/* TODO */
	return false;
	}

	-void Bitmap::rectangle( int x1, int y1, int x2, int y2, int color ) const {
	- SPG_Rect(getData()->getSurface(), x1, y1, x2, y2, color);
	+void Bitmap::rectangle( int x1, int y1, int x2, int y2, Color color) const {
	+ SPG_Rect(getData()->getSurface(), x1, y1, x2, y2, color.color);
	}

	-void TranslucentBitmap::rectangle( int x1, int y1, int x2, int y2, int color ) const {
	+void TranslucentBitmap::rectangle( int x1, int y1, int x2, int y2, Color color) const {
	int alpha = globalBlend.alpha;
	- SPG_RectBlend(getData()->getSurface(), x1, y1, x2, y2, color, alpha);
	+ SPG_RectBlend(getData()->getSurface(), x1, y1, x2, y2, color.color, alpha);
	}

	-void Bitmap::rectangleFill( int x1, int y1, int x2, int y2, int color ) const {
	- SPG_RectFilled(getData()->getSurface(), x1, y1, x2, y2, color);
	+void Bitmap::rectangleFill( int x1, int y1, int x2, int y2, Color color) const {
	+ SPG_RectFilled(getData()->getSurface(), x1, y1, x2, y2, color.color);
	}

	-void TranslucentBitmap::rectangleFill(int x1, int y1, int x2, int y2, int color) const {
	+void TranslucentBitmap::rectangleFill(int x1, int y1, int x2, int y2, Color color) const {
	int alpha = globalBlend.alpha;
	- SPG_RectFilledBlend(getData()->getSurface(), x1, y1, x2, y2, color, alpha);
	+ SPG_RectFilledBlend(getData()->getSurface(), x1, y1, x2, y2, color.color, alpha);
	}

	-void TranslucentBitmap::ellipseFill( int x, int y, int rx, int ry, Color color ) const {
	+void TranslucentBitmap::ellipseFill( int x, int y, int rx, int ry, Color color) const {
	int alpha = globalBlend.alpha;
	- SPG_EllipseFilledBlend(getData()->getSurface(), x, y, rx, ry, color, alpha);
	+ SPG_EllipseFilledBlend(getData()->getSurface(), x, y, rx, ry, color.color, alpha);
	}

	-void Bitmap::circleFill(int x, int y, int radius, int color) const {
	- SPG_CircleFilled(getData()->getSurface(), x, y, radius, color);
	+void Bitmap::circleFill(int x, int y, int radius, Color color) const {
	+ SPG_CircleFilled(getData()->getSurface(), x, y, radius, color.color);

	/*
	if (Graphics::drawingMode == MODE_SOLID){
	SPG_CircleFilled(getData().getSurface(), x, y, radius, color);
	} else if (Graphics::drawingMode == MODE_TRANS){
	int alpha = globalBlend.alpha;
	SPG_CircleFilledBlend(getData().getSurface(), x, y, radius, color, alpha);
	}
	*/
	}

	-void TranslucentBitmap::circleFill(int x, int y, int radius, int color) const {
	+void TranslucentBitmap::circleFill(int x, int y, int radius, Color color) const {
	int alpha = globalBlend.alpha;
	- SPG_CircleFilledBlend(getData()->getSurface(), x, y, radius, color, alpha);
	+ SPG_CircleFilledBlend(getData()->getSurface(), x, y, radius, color.color, alpha);
	}

	-void Bitmap::circle(int x, int y, int radius, int color) const {
	+void Bitmap::circle(int x, int y, int radius, Color color) const {
	// Uint8 red, green, blue;
	// SDL_GetRGB(color, getData().getSurface()->format, &red, &green, &blue);
	// int alpha = 255;

	- SPG_Circle(getData()->getSurface(), x, y, radius, color);
	+ SPG_Circle(getData()->getSurface(), x, y, radius, color.color);
	/*
	if (Graphics::drawingMode == MODE_SOLID){
	SPG_Circle(getData()->getSurface(), x, y, radius, color);
	} else if (Graphics::drawingMode == MODE_TRANS){
	int alpha = globalBlend.alpha;
	SPG_CircleBlend(getData()->getSurface(), x, y, radius, color, alpha);
	}
	*/

	// circleRGBA(getData().getSurface(), x, y, radius, red, green, blue, alpha);
	}

	extern "C" unsigned short spg_thickness;
	-void Bitmap::circle(int x, int y, int radius, int thickness, int color) const {
	+void Bitmap::circle(int x, int y, int radius, int thickness, Color color) const {
	int old = spg_thickness;
	spg_thickness = thickness;
	- SPG_Circle(getData()->getSurface(), x, y, radius, color);
	+ SPG_Circle(getData()->getSurface(), x, y, radius, color.color);
	spg_thickness = old;
	}

	-void Bitmap::line( const int x1, const int y1, const int x2, const int y2, const int color ) const {
	- SPG_Line(getData()->getSurface(), x1, y1, x2, y2, color);
	+void Bitmap::line( const int x1, const int y1, const int x2, const int y2, const Color color) const {
	+ SPG_Line(getData()->getSurface(), x1, y1, x2, y2, color.color);
	/*
	if (Graphics::drawingMode == MODE_SOLID){
	SPG_Line(getData().getSurface(), x1, y1, x2, y2, color);
	} else if (Graphics::drawingMode == MODE_TRANS){
	int alpha = globalBlend.alpha;
	SPG_LineBlend(getData().getSurface(), x1, y1, x2, y2, color, alpha);
	}
	*/
	}

	-void TranslucentBitmap::line(const int x1, const int y1, const int x2, const int y2, const int color ) const {
	+void TranslucentBitmap::line(const int x1, const int y1, const int x2, const int y2, const Color color ) const {
	int alpha = globalBlend.alpha;
	- SPG_LineBlend(getData()->getSurface(), x1, y1, x2, y2, color, alpha);
	+ SPG_LineBlend(getData()->getSurface(), x1, y1, x2, y2, color.color, alpha);
	}

	void Bitmap::draw(const int x, const int y, const Bitmap & where) const {
	if (getData()->getSurface() != NULL){
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_NORMAL, SPRITE_NO_FLIP, NULL);
	/*
	SDL_SetColorKey(getData().getSurface(), SDL_SRCCOLORKEY, makeColor(255, 0, 255));
	Blit(x, y, where);
	*/
	}
	}

	void Bitmap::drawHFlip(const int x, const int y, const Bitmap & where) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_NORMAL, SPRITE_H_FLIP, NULL);
	}

	void Bitmap::drawHFlip(const int x, const int y, Filter * filter, const Bitmap & where) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_NORMAL, SPRITE_H_FLIP, filter);
	}

	void Bitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_NORMAL, SPRITE_V_FLIP, NULL);
	}

	void Bitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_NORMAL, SPRITE_V_FLIP, filter);
	}

	void Bitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_NORMAL, SPRITE_V_FLIP \| SPRITE_H_FLIP, NULL);
	}

	void Bitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_NORMAL, SPRITE_V_FLIP \| SPRITE_H_FLIP, filter);
	}

	void TranslucentBitmap::draw(const int x, const int y, const Bitmap & where) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_TRANS, SPRITE_NO_FLIP, NULL);
	}

	void TranslucentBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_TRANS, SPRITE_NO_FLIP, filter);
	}

	void TranslucentBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_TRANS, SPRITE_H_FLIP, NULL);
	}

	void TranslucentBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_TRANS, SPRITE_H_FLIP, filter);
	}

	void TranslucentBitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_TRANS, SPRITE_V_FLIP, NULL);
	}

	void TranslucentBitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_TRANS, SPRITE_V_FLIP, filter);
	}

	void TranslucentBitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_TRANS, SPRITE_V_FLIP \| SPRITE_H_FLIP, NULL);
	}

	void TranslucentBitmap::drawHVFlip( const int x, const int y, Filter * filter,const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_TRANS, SPRITE_V_FLIP \| SPRITE_H_FLIP, filter);
	}

	void Bitmap::drawStretched( const int x, const int y, const int new_width, const int new_height, const Bitmap & who ) const {

	if (getData()->getSurface() != NULL){
	- SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, makeColor(255, 0, 255));
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor().color);

	SDL_Surface * src = getData()->getSurface();
	SDL_Surface * dst = who.getData()->getSurface();

	int myWidth = src->w;
	int myHeight = src->h;
	int hisWidth = new_width;
	int hisHeight = new_height;
	int useX = x;
	int useY = y;
	int myX = 0;
	int myY = 0;

	float xscale = (float) hisWidth / (float) myWidth;
	float yscale = (float) hisHeight / (float) myHeight;

	/* sprig wont do the clipping right, if you start drawing from a negative offset
	* sprig will do nothing.
	*/
	if (useX < 0){
	useX = 0;
	myX = -x / xscale;
	}

	if (useY < 0){
	useY = 0;
	myY = -y / yscale;
	}

	SPG_TransformX(src, dst, 0, xscale, yscale, myX, myY, useX, useY, SPG_TCOLORKEY);
	}
	}

	static void doBlit(SDL_Surface * mine, const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ){
	SDL_Rect source;
	SDL_Rect destination;
	source.w = width;
	source.h = height;
	source.x = mx;
	source.y = my;

	destination.w = width;
	destination.h = height;
	destination.x = wx;
	destination.y = wy;

	SDL_BlitSurface(mine, &source, where.getData()->getSurface(), &destination);
	}

	void Bitmap::Blit( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const {
	- SDL_SetColorKey(getData()->getSurface(), 0, MaskColor());
	+ SDL_SetColorKey(getData()->getSurface(), 0, MaskColor().color);
	doBlit(getData()->getSurface(), mx, my, width, height, wx, wy, where);

	/* FIXME: this is a hack, maybe put a call here for the other bitmap to update stuff
	* like where->Blitted()
	*/
	if (&where == Screen){
	SDL_Flip(Screen->getData()->getSurface());
	}
	}

	void Bitmap::BlitMasked( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const {
	- SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor());
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor().color);

	doBlit(getData()->getSurface(),mx, my, width, height, wx, wy, where);

	/* FIXME: this is a hack, maybe put a call here for the other bitmap to update stuff
	* like where->Blitted()
	*/
	if (&where == Screen){
	SDL_Flip(Screen->getData()->getSurface());
	}
	}

	void Bitmap::BlitToScreen(const int upper_left_x, const int upper_left_y) const {
	#if 0
	if (getWidth() != Screen->getWidth() \|\| getHeight() != Screen->getHeight()){
	/*
	this->Blit( upper_left_x, upper_left_y, *Buffer );
	Buffer->Stretch(*Scaler);
	Scaler->Blit(0, 0, 0, 0, *Screen);
	*/

	this->Stretch(*Scaler, 0, 0, getWidth(), getHeight(), upper_left_x, upper_left_y, Scaler->getWidth(), Scaler->getHeight());
	Scaler->Blit(0, 0, 0, 0, *Screen);
	} else {
	this->Blit( upper_left_x, upper_left_y, *Screen );
	}
	#endif
	this->Blit(upper_left_x, upper_left_y, *Screen);

	/*
	if ( Scaler == NULL ){
	this->Blit( upper_left_x, upper_left_y, *Screen );
	} else {
	this->Blit( upper_left_x, upper_left_y, *Buffer );
	Buffer->Stretch(*Scaler);
	Scaler->Blit(0, 0, 0, 0, *Screen);
	}
	*/

	// SDL_Flip(Screen->getData().getSurface());
	// SDL_UpdateRect(Screen->getData().getSurface(), 0, 0, Screen->getWidth(), Screen->getHeight());
	}

	void Bitmap::BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const {
	this->Blit(upper_left_x, upper_left_y, *Screen);
	#if 0
	if (Scaler != NULL && false){
	/*
	double mult_x = (double) Scaler->getWidth() / (double) SCALE_X;
	double mult_y = (double) Scaler->getHeight() / (double) SCALE_Y;
	*/

	double mult_x = 1;
	double mult_y = 1;

	int x = (int)(upper_left_x * mult_x);
	int y = (int)(upper_left_y * mult_y);
	int w = (int)(this->getWidth() * mult_x);
	int h = (int)(this->getHeight() * mult_y);

	// printf("ux %d uy %d uw %d uh %d. x %d y %d w %d h %d\n", upper_left_x, upper_left_y, getWidth(), getHeight(), x, y, w, h );

	this->Stretch( *Scaler, 0, 0, this->getWidth(), this->getHeight(), x, y, w, h );

	Bitmap tmp(*Scaler, x, y, w, h );
	tmp.Blit( x, y, *Screen );

	// Scaler->Blit( x, y, w, h, *Screen );
	} else {
	this->Blit(upper_left_x, upper_left_y, *Screen);
	}
	#endif
	}

	/*
	void Bitmap::Stretch( const Bitmap & where ) const {
	if (getWidth() == where.getWidth() && getHeight() == where.getHeight()){
	Blit(where);
	} else {
	Stretch(where, 0, 0, getWidth(), getHeight(), 0, 0, where.getWidth(), where.getHeight());
	}
	}
	*/

	void Bitmap::StretchXbr(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight) const {
	Bitmap subSource(*this, sourceX, sourceY, sourceWidth, sourceHeight);
	Bitmap subDestination(where, destX, destY, destWidth, destHeight);

	SDL_Surface * source = subSource.getData()->getSurface();
	SDL_Surface * destination = subDestination.getData()->getSurface();

	if (SDL_MUSTLOCK(source)){
	SDL_LockSurface(source);
	}

	if (SDL_MUSTLOCK(destination)){
	SDL_LockSurface(destination);
	}

	if (sourceWidth * 4 == destWidth && sourceHeight * 4 == destHeight){
	xbr::xbr4x(source, destination);
	} else if (sourceWidth * 3 == destWidth && sourceHeight * 3 == destHeight){
	xbr::xbr3x(source, destination);
	} else if (sourceWidth * 2 == destWidth && sourceHeight * 2 == destHeight){
	xbr::xbr2x(source, destination);
	} else {
	if (SDL_MUSTLOCK(source)){
	SDL_UnlockSurface(source);
	}

	if (SDL_MUSTLOCK(destination)){
	SDL_UnlockSurface(destination);
	}
	subSource.Stretch(subDestination);
	return;
	}

	if (SDL_MUSTLOCK(source)){
	SDL_UnlockSurface(source);
	}

	if (SDL_MUSTLOCK(destination)){
	SDL_UnlockSurface(destination);
	}
	}

	void Bitmap::StretchHqx(const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight) const {
	Bitmap subSource(*this, sourceX, sourceY, sourceWidth, sourceHeight);
	Bitmap subDestination(where, destX, destY, destWidth, destHeight);

	SDL_Surface * source = subSource.getData()->getSurface();
	SDL_Surface * destination = subDestination.getData()->getSurface();

	if (SDL_MUSTLOCK(source)){
	SDL_LockSurface(source);
	}

	if (SDL_MUSTLOCK(destination)){
	SDL_LockSurface(destination);
	}

	if (sourceWidth * 4 == destWidth && sourceHeight * 4 == destHeight){
	hqx::hq4x(source, destination);
	} else if (sourceWidth * 3 == destWidth && sourceHeight * 3 == destHeight){
	hqx::hq3x(source, destination);
	} else if (sourceWidth * 2 == destWidth && sourceHeight * 2 == destHeight){
	hq2x::hq2x(source, destination);
	} else {
	if (SDL_MUSTLOCK(source)){
	SDL_UnlockSurface(source);
	}

	if (SDL_MUSTLOCK(destination)){
	SDL_UnlockSurface(destination);
	}
	subSource.Stretch(subDestination);
	return;
	}

	if (SDL_MUSTLOCK(source)){
	SDL_UnlockSurface(source);
	}

	if (SDL_MUSTLOCK(destination)){
	SDL_UnlockSurface(destination);
	}
	}

	void Bitmap::Stretch( const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight ) const {

	/* TODO: if souceWidth == destWidth && souceHeight == destHeight then
	* just do a normal blit. check if sdl already does this optimization
	*/

	if (destWidth <= 0 \|\| destHeight <= 0 \|\|
	sourceWidth <= 0 \|\| sourceHeight <= 0){
	return;
	}

	Bitmap subSource(*this, sourceX, sourceY, sourceWidth, sourceHeight);
	Bitmap subDestination(where, destX, destY, destWidth, destHeight);

	SDL_Surface * src = subSource.getData()->getSurface();
	SDL_Surface * dst = subDestination.getData()->getSurface();

	if (SDL_MUSTLOCK(src)){
	SDL_LockSurface(src);
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_LockSurface(dst);
	}

	SDL_StretchSurfaceRect(src, NULL, dst, NULL);

	if (SDL_MUSTLOCK(src)){
	SDL_UnlockSurface(src);
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_UnlockSurface(dst);
	}

	/*
	SDL_Surface * src = getData().getSurface();
	SDL_Surface * dst = where.getData().getSurface();
	*/

	/*
	float xscale = (float) destWidth / (float) sourceWidth;
	float yscale = (float) destHeight / (float) sourceHeight;
	SDL_SetColorKey(src, 0, MaskColor());
	SPG_TransformX(src, dst, 0, xscale, yscale, sourceX, sourceY, destX, destY, SPG_NONE);
	*/

	/*
	SDL_Rect source;
	SDL_Rect destination;
	source.x = sourceX;
	source.y = sourceY;
	source.w = sourceWidth;
	source.h = sourceHeight;

	destination.x = destX;
	destination.y = destY;
	destination.w = destWidth;
	destination.h = destHeight;

	// SDL_StretchSurfaceRect(getData().getSurface(), &source, where.getData().getSurface(), &destination);

	SDL_Surface * src = getData().getSurface();
	SDL_Surface * dst = where.getData().getSurface();

	if (SDL_MUSTLOCK(src)){
	SDL_LockSurface(src);
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_LockSurface(dst);
	}

	SDL_StretchSurfaceRect(src, &source, dst, &destination);

	if (SDL_MUSTLOCK(src)){
	SDL_UnlockSurface(src);
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_UnlockSurface(dst);
	}
	*/
	}

	void Bitmap::save(const std::string & str) const {
	/* always saves as a png for now */
	IMG_SavePNG(str.c_str(), getData()->getSurface(), IMG_COMPRESS_DEFAULT);
	}

	-void Bitmap::triangle( int x1, int y1, int x2, int y2, int x3, int y3, int color ) const {
	+void Bitmap::triangle( int x1, int y1, int x2, int y2, int x3, int y3, Color color ) const {

	- SPG_TrigonFilled(getData()->getSurface(), x1, y1, x2, y2, x3, y3, color);
	+ SPG_TrigonFilled(getData()->getSurface(), x1, y1, x2, y2, x3, y3, color.color);
	/*
	if (Graphics::drawingMode == MODE_SOLID){
	SPG_TrigonFilled(getData()->getSurface(), x1, y1, x2, y2, x3, y3, color);
	} else if (Graphics::drawingMode == MODE_TRANS){
	int alpha = globalBlend.alpha;
	SPG_TrigonFilledBlend(getData()->getSurface(), x1, y1, x2, y2, x3, y3, color, alpha);
	}
	*/
	}

	-void Bitmap::ellipse( int x, int y, int rx, int ry, int color ) const {
	- SPG_Ellipse(getData()->getSurface(), x, y, rx, ry, color);
	+void Bitmap::ellipse( int x, int y, int rx, int ry, Color color ) const {
	+ SPG_Ellipse(getData()->getSurface(), x, y, rx, ry, color.color);
	/*
	if (Graphics::drawingMode == MODE_SOLID){
	SPG_Ellipse(getData()->getSurface(), x, y, rx, ry, color);
	} else if (Graphics::drawingMode == MODE_TRANS){
	int alpha = globalBlend.alpha;
	SPG_EllipseBlend(getData()->getSurface(), x, y, rx, ry, color, alpha);
	}
	*/
	}

	-void TranslucentBitmap::ellipse( int x, int y, int rx, int ry, int color ) const {
	+void TranslucentBitmap::ellipse( int x, int y, int rx, int ry, Color color ) const {
	int alpha = globalBlend.alpha;
	- SPG_EllipseBlend(getData()->getSurface(), x, y, rx, ry, color, alpha);
	+ SPG_EllipseBlend(getData()->getSurface(), x, y, rx, ry, color.color, alpha);
	}

	-void Bitmap::ellipseFill( int x, int y, int rx, int ry, int color ) const {
	- SPG_EllipseFilled(getData()->getSurface(), x, y, rx, ry, color);
	+void Bitmap::ellipseFill( int x, int y, int rx, int ry, Color color ) const {
	+ SPG_EllipseFilled(getData()->getSurface(), x, y, rx, ry, color.color);
	}

	-void Bitmap::light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, int focus_color, int edge_color) const {
	- paintown_light16(getData()->getSurface(), x, y, width, height, start_y, focus_alpha, edge_alpha, focus_color, edge_color);
	+void Bitmap::light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, Color focus_color, Color edge_color) const {
	+ paintown_light16(getData()->getSurface(), x, y, width, height, start_y, focus_alpha, edge_alpha, focus_color.color, edge_color.color);
	}

	-void Bitmap::applyTrans(const int color) const {
	- paintown_applyTrans16(getData()->getSurface(), color);
	+void Bitmap::applyTrans(const Color color) const {
	+ paintown_applyTrans16(getData()->getSurface(), color.color);
	}

	-void Bitmap::floodfill( const int x, const int y, const int color ) const {
	- SPG_FloodFill(getData()->getSurface(), x, y, color);
	+void Bitmap::floodfill( const int x, const int y, const Color color ) const {
	+ SPG_FloodFill(getData()->getSurface(), x, y, color.color);
	}

	/*
	void Bitmap::horizontalLine( const int x1, const int y, const int x2, const int color ) const {
	SPG_LineH(getData().getSurface(), x1, y, x2, color);
	}
	*/

	-void Bitmap::hLine( const int x1, const int y, const int x2, const int color ) const {
	- SPG_LineH(getData()->getSurface(), x1, y, x2, color);
	+void Bitmap::hLine( const int x1, const int y, const int x2, const Color color ) const {
	+ SPG_LineH(getData()->getSurface(), x1, y, x2, color.color);
	}

	-void TranslucentBitmap::hLine( const int x1, const int y, const int x2, const int color ) const {
	+void TranslucentBitmap::hLine( const int x1, const int y, const int x2, const Color color ) const {
	int alpha = globalBlend.alpha;
	- SPG_LineHBlend(getData()->getSurface(), x1, y, x2, color, alpha);
	+ SPG_LineHBlend(getData()->getSurface(), x1, y, x2, color.color, alpha);
	}

	-void Bitmap::vLine( const int y1, const int x, const int y2, const int color ) const {
	- SPG_LineV(getData()->getSurface(), x, y1, y2, color);
	+void Bitmap::vLine( const int y1, const int x, const int y2, const Color color ) const {
	+ SPG_LineV(getData()->getSurface(), x, y1, y2, color.color);
	}

	-void Bitmap::polygon( const int * verts, const int nverts, const int color ) const {
	+void Bitmap::polygon( const int * verts, const int nverts, const Color color ) const {
	SPG_Point * points = new SPG_Point[nverts];
	for (int i = 0; i < nverts; i++){
	points[i].x = verts[i*2];
	points[i].y = verts[i*2+1];
	}
	- SPG_PolygonFilled(getData()->getSurface(), nverts, points, color);
	+ SPG_PolygonFilled(getData()->getSurface(), nverts, points, color.color);
	delete[] points;
	}

	static const double RAD_TO_DEG = 180.0/Util::pi;
	static const double DEG_TO_RAD = Util::pi/180.0;

	static double toDegrees(double radians){
	return RAD_TO_DEG * radians;
	}

	static const double arcPhase = -Util::pi / 2;

	/* 0 = right. pi/2 = up. pi = left. 3pi/2 = down */
	-void Bitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	- SPG_Arc(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color);
	+void Bitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	+ SPG_Arc(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color.color);
	}

	-void Bitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	- SPG_ArcFilled(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color);
	+void Bitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	+ SPG_ArcFilled(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color.color);
	}

	-void TranslucentBitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	+void TranslucentBitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	int alpha = globalBlend.alpha;
	- SPG_ArcBlend(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color, alpha);
	+ SPG_ArcBlend(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color.color, alpha);
	}

	-void TranslucentBitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	+void TranslucentBitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	int alpha = globalBlend.alpha;
	- SPG_ArcFilledBlend(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color, alpha);
	+ SPG_ArcFilledBlend(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color.color, alpha);
	}

	-void Bitmap::fill(int color) const {
	+void Bitmap::fill(Color color) const {
	SDL_Rect area;
	area.x = 0;
	area.y = 0;
	area.w = getWidth();
	area.h = getHeight();
	- SDL_FillRect(getData()->getSurface(), &area, color);
	+ SDL_FillRect(getData()->getSurface(), &area, color.color);
	}

	/*
	void TranslucentBitmap::fill(int color) const {
	rectangleFill(0, 0, getWidth(), getHeight(), color);
	}
	*/



	-void Bitmap::drawCharacter( const int x, const int y, const int color, const int background, const Bitmap & where ) const {
	+void Bitmap::drawCharacter( const int x, const int y, const Color color, const int background, const Bitmap & where ) const {
	/* TODO */
	}

	void Bitmap::drawRotate( const int x, const int y, const int angle, const Bitmap & where ){
	- SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor());
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor().color);
	SDL_Surface * src = getData()->getSurface();
	SDL_Surface * dst = where.getData()->getSurface();
	SPG_TransformX(src, dst, angle, 1, 1, 0, 0, x, y, SPG_TCOLORKEY);
	}

	/* I'm not really sure whats going on here but we need to negate the angle */
	static int fixAngle(int angle){
	return -angle;
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const Bitmap & where ){
	- SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor());
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor().color);
	SDL_Surface * src = getData()->getSurface();
	SDL_Surface * dst = where.getData()->getSurface();
	SPG_TransformX(src, dst, fixAngle(angle), 1, 1, centerX, centerY, x, y, SPG_TCOLORKEY);
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const double scale, const Bitmap & where ){
	- SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor());
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor().color);
	SDL_Surface * src = getData()->getSurface();
	SDL_Surface * dst = where.getData()->getSurface();
	SPG_TransformX(src, dst, angle, scale, scale, centerX, centerY, x, y, SPG_TCOLORKEY);
	}

	void Bitmap::replaceColor(const Color & original, const Color & replaced){
	- paintown_replace16(getData()->getSurface(), original, replaced);
	+ paintown_replace16(getData()->getSurface(), original.color, replaced.color);
	}

	static SDL_Color pcxMaskColor(unsigned char * data, const int length){
	if (length >= 769){
	if (data[length - 768 - 1] == 12){
	unsigned char * palette = &data[length - 768];
	unsigned char red = palette[0];
	unsigned char green = palette[1];
	unsigned char blue = palette[2];
	SDL_Color color;
	color.r = red;
	color.g = green;
	color.b = blue;
	return color;
	}
	}
	SDL_Color color;
	color.r = 255;
	color.g = 255;
	color.b = 255;
	return color;
	}

	struct PCXheader {
	Uint8 Manufacturer;
	Uint8 Version;
	Uint8 Encoding;
	Uint8 BitsPerPixel;
	Sint16 Xmin, Ymin, Xmax, Ymax;
	Sint16 HDpi, VDpi;
	Uint8 Colormap[48];
	Uint8 Reserved;
	Uint8 NPlanes;
	Sint16 BytesPerLine;
	Sint16 PaletteInfo;
	Sint16 HscreenSize;
	Sint16 VscreenSize;
	Uint8 Filler[54];
	};

	static SDL_Surface * fast_load_pcx(unsigned char * const memory, const unsigned int length){
	int start;
	struct PCXheader pcxh;
	Uint32 Rmask;
	Uint32 Gmask;
	Uint32 Bmask;
	Uint32 Amask;
	SDL_Surface *surface = NULL;
	int width, height;
	int y, bpl;
	Uint8 row, buf = NULL;
	const char *error = NULL;
	int bits, src_bits;
	Uint8 * data = memory;

	if (length < sizeof(pcxh)){
	goto done;
	}

	memcpy(&pcxh, data, sizeof(pcxh));
	data += sizeof(pcxh);

	pcxh.Xmin = SDL_SwapLE16(pcxh.Xmin);
	pcxh.Ymin = SDL_SwapLE16(pcxh.Ymin);
	pcxh.Xmax = SDL_SwapLE16(pcxh.Xmax);
	pcxh.Ymax = SDL_SwapLE16(pcxh.Ymax);
	pcxh.BytesPerLine = SDL_SwapLE16(pcxh.BytesPerLine);

	/* Create the surface of the appropriate type */
	width = (pcxh.Xmax - pcxh.Xmin) + 1;
	height = (pcxh.Ymax - pcxh.Ymin) + 1;
	Rmask = Gmask = Bmask = Amask = 0;
	src_bits = pcxh.BitsPerPixel * pcxh.NPlanes;
	if((pcxh.BitsPerPixel == 1 && pcxh.NPlanes >= 1 && pcxh.NPlanes <= 4)
	\|\| (pcxh.BitsPerPixel == 8 && pcxh.NPlanes == 1)) {
	bits = 8;
	} else if(pcxh.BitsPerPixel == 8 && pcxh.NPlanes == 3) {
	bits = 24;
	if (SDL_BYTEORDER == SDL_LIL_ENDIAN){
	Rmask = 0x000000FF;
	Gmask = 0x0000FF00;
	Bmask = 0x00FF0000;
	} else {
	Rmask = 0xFF0000;
	Gmask = 0x00FF00;
	Bmask = 0x0000FF;
	}
	} else {
	error = "unsupported PCX format";
	goto done;
	}
	surface = SDL_AllocSurface(SDL_SWSURFACE, width, height,
	bits, Rmask, Gmask, Bmask, Amask);
	if ( surface == NULL )
	goto done;

	bpl = pcxh.NPlanes * pcxh.BytesPerLine;
	if (bpl > surface->pitch) {
	error = "bytes per line is too large (corrupt?)";
	}
	buf = (Uint8*) malloc(bpl);
	row = (Uint8*) surface->pixels;
	for ( y=0; y<surface->h; ++y ) {
	/* decode a scan line to a temporary buffer first */
	int i, count = 0;
	Uint8 *dst = (src_bits == 8) ? row : buf;
	if (pcxh.Encoding == 0){
	if (bpl + data - memory < length){
	memcpy(dst, data, bpl);
	data += bpl;
	} else {
	error = "file truncated";
	goto done;
	}
	} else {
	Uint8 ch = 0;
	for (i = 0; i < bpl; i++) {
	if (!count) {
	if (data - memory >= length){
	error = "file truncated";
	goto done;
	} else {
	ch = *data;
	data += 1;
	}

	if ((ch & 0xc0) == 0xc0){
	count = ch & 0x3f;
	if (data - memory >= length){
	error = "file truncated";
	goto done;
	} else {
	ch = *data;
	data += 1;
	}
	} else
	count = 1;
	}
	dst[i] = ch;
	count--;
	}
	}

	if (src_bits <= 4){
	/* expand planes to 1 byte/pixel */
	Uint8 *src = buf;
	int plane;
	for(plane = 0; plane < pcxh.NPlanes; plane++) {
	int i, j, x = 0;
	for(i = 0; i < pcxh.BytesPerLine; i++) {
	Uint8 byte = *src++;
	for(j = 7; j >= 0; j--) {
	unsigned bit = (byte >> j) & 1;
	/* skip padding bits */
	if (i * 8 + j >= width)
	continue;
	row[x++] \|= bit << plane;
	}
	}
	}
	} else if(src_bits == 24) {
	/* de-interlace planes */
	Uint8 *src = buf;
	int plane;
	for(plane = 0; plane < pcxh.NPlanes; plane++) {
	int x;
	dst = row + plane;
	for(x = 0; x < width; x++) {
	dst = src++;
	dst += pcxh.NPlanes;
	}
	}
	}

	row += surface->pitch;
	}

	if(bits == 8) {
	SDL_Color *colors = surface->format->palette->colors;
	int nc = 1 << src_bits;
	int i;

	surface->format->palette->ncolors = nc;
	if(src_bits == 8) {
	/* look for a 256-colour palette */
	while (data - memory < length && *data != 12){
	data += 1;
	}
	data += 1;

	if (data - memory >= length){
	goto done;
	}

	for (i = 0; i < 256; i++) {
	colors[i].r = *data; data += 1;
	colors[i].g = *data; data += 1;
	colors[i].b = *data; data += 1;
	}
	} else {
	for(i = 0; i < nc; i++) {
	colors[i].r = pcxh.Colormap[i * 3];
	colors[i].g = pcxh.Colormap[i * 3 + 1];
	colors[i].b = pcxh.Colormap[i * 3 + 2];
	}
	}
	}

	done:
	free(buf);
	if (error){
	if (surface){
	SDL_FreeSurface(surface);
	surface = NULL;
	}
	}

	return surface;
	}

	Bitmap memoryPCX(unsigned char * const data, const int length, const bool mask){
	/*
	SDL_RWops * ops = SDL_RWFromConstMem(data, length);
	SDL_Surface * pcx = IMG_LoadPCX_RW(ops);
	SDL_FreeRW(ops);
	if (!pcx){
	std::ostringstream out;
	out << "Could not load PCX file at " << (void*) data << " length " << length;
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	*/
	SDL_Surface * pcx = fast_load_pcx(data, length);
	if (pcx == NULL){
	std::ostringstream out;
	out << "Could not load PCX file from " << (void*) data << " length " << length;
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	SDL_Surface * display = optimizedSurface(pcx);
	Bitmap out(display, false);

	if (pcx->format->BitsPerPixel == 8){
	#if SDL_VERSION_ATLEAST(1, 3, 0)
	SDL_Color color = pcxMaskColor(data, length);
	#else
	SDL_Color color = pcx->format->palette->colors[pcx->format->colorkey];
	#endif

	- int bad = makeColor(color.r, color.g, color.b);
	+ Color bad = makeColor(color.r, color.g, color.b);
	out.set8BitMaskColor(bad);
	// int mask = MaskColor();
	// out.replaceColor(bad, mask);
	}

	SDL_FreeSurface(pcx);
	// SDL_FreeSurface(display);
	// out.floodfill(0, 0, makeColor(255, 0, 255));

	return out;
	}

	-int Bitmap::getPixel( const int x, const int y ) const {
	- return SPG_GetPixel(getData()->getSurface(), x, y);
	+Color Bitmap::getPixel( const int x, const int y ) const {
	+ return Color(SPG_GetPixel(getData()->getSurface(), x, y));
	}

	-void Bitmap::readLine( std::vector< int > & line, int y ){
	+void Bitmap::readLine( std::vector<Color> & line, int y ){
	for (int x = 0; x < getWidth(); x++){
	line.push_back(getPixel(x, y));
	}
	}

	void Bitmap::StretchBy2( const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::StretchBy4( const Bitmap & where ){
	/* TODO */
	}

	void Bitmap::draw(const int x, const int y, Filter * filter, const Bitmap & where) const {
	// paintown_draw_sprite_filter_ex16(where.getData().getSurface(), getData().getSurface(), x, y, filter);
	paintown_draw_sprite_ex16(where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_NORMAL, SPRITE_NO_FLIP, filter);
	}

	void LitBitmap::draw( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_LIT, SPRITE_NO_FLIP, NULL);
	}

	void LitBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_LIT, SPRITE_NO_FLIP, filter);
	}

	void LitBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_LIT, SPRITE_H_FLIP, NULL);
	}

	void LitBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_LIT, SPRITE_H_FLIP, filter);
	}

	void LitBitmap::drawVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_LIT, SPRITE_V_FLIP, NULL);
	}

	void LitBitmap::drawVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_LIT, SPRITE_V_FLIP, filter);
	}

	void LitBitmap::drawHVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_LIT, SPRITE_V_FLIP \| SPRITE_H_FLIP, NULL);
	}

	void LitBitmap::drawHVFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	paintown_draw_sprite_ex16( where.getData()->getSurface(), getData()->getSurface(), x, y, SPRITE_LIT, SPRITE_V_FLIP \| SPRITE_H_FLIP, filter);
	}

	/*
	#define PAINTOWN_DLS_BLENDER BLENDER_FUNC
	#define PAINTOWN_DTS_BLENDER BLENDER_FUNC
	#define PAINTOWN_MAKE_DLS_BLENDER(a) _blender_func16
	#define PAINTOWN_MAKE_DTS_BLENDER() _blender_func16
	#define PAINTOWN_PIXEL_PTR unsigned short*
	#define PAINTOWN_OFFSET_PIXEL_PTR(p,x) ((PAINTOWN_PIXEL_PTR) (p) + (x))
	#define PAINTOWN_INC_PIXEL_PTR(p) ((p)++)
	#define PAINTOWN_INC_PIXEL_PTR_EX(p,d) ((p) += d)
	#define PAINTOWN_GET_MEMORY_PIXEL(p) (*(p))
	#define PAINTOWN_IS_SPRITE_MASK(b,c) ((unsigned long) (c) == (unsigned long) MASK_COLOR)
	#define PAINTOWN_DLSX_BLEND(b,n) ((*(b))(_blender_col_16, (n), globalBlend.alpha))
	#define PAINTOWN_GET_PIXEL(p) ((unsigned short ) (p))
	#define PAINTOWN_DTS_BLEND(b,o,n) ((*(b))((n), (o), globalBlend.alpha))
	#define PAINTOWN_PUT_PIXEL(p,c) (((unsigned short ) p) = (c))
	#define PAINTOWN_PUT_MEMORY_PIXEL(p,c) (*(p) = (c))
	#define PAINTOWN_SET_ALPHA(a) (globalBlend.alpha = (a))
	*/

	static void paintown_applyTrans16(SDL_Surface * dst, const int color){
	int y1 = 0;
	int y2 = dst->h;
	int x1 = 0;
	int x2 = dst->w - 1;

	y1 = dst->clip_rect.y;
	y2 = dst->clip_rect.y + dst->clip_rect.h;
	x1 = dst->clip_rect.x;
	x2 = dst->clip_rect.x + dst->clip_rect.w;

	int bpp = dst->format->BytesPerPixel;
	- unsigned int mask = makeColor(255, 0, 255);
	+ unsigned int mask = MaskColor().color;
	for (int y = y1; y < y2; y++) {
	Uint8 * sourceLine = computeOffset(dst, x1, y);

	for (int x = x2 - 1; x >= x1; sourceLine += bpp, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	sourcePixel = globalBlend.currentBlender(color, sourcePixel, globalBlend.alpha);
	(Uint16 )sourceLine = sourcePixel;
	}
	}
	}
	}

	static void paintown_replace16(SDL_Surface * dst, const int original, const int replace){
	int y1 = 0;
	int y2 = dst->h;
	int x1 = 0;
	int x2 = dst->w - 1;

	y1 = dst->clip_rect.y;
	y2 = dst->clip_rect.y + dst->clip_rect.h;
	x1 = dst->clip_rect.x;
	x2 = dst->clip_rect.x + dst->clip_rect.w;

	int bpp = dst->format->BytesPerPixel;

	/* Attempted manual unrolling. Gcc can optimize the naive loop below better
	* than this unrolling attempt.
	*/
	/*
	for (int y = y1; y < y2; y += 4){
	switch (y2 - y1){
	case 1 : {
	Uint8 * source1 = computeOffset(dst, x1, y);
	for (int x = x2 - 1; x >= x1; source1 += bpp, x--) {
	unsigned long sourcePixel = (Uint16) source1;
	if ((int) sourcePixel == original){
	(Uint16 )source1 = replace;
	}
	}
	break;
	}
	case 2 : {
	Uint8 * source1 = computeOffset(dst, x1, y);
	Uint8 * source2 = computeOffset(dst, x1, y + 1);
	for (int x = x2 - 1; x >= x1; source1 += bpp, source2 += bpp, x--) {
	unsigned long sourcePixel = (Uint16) source1;
	unsigned long sourcePixel2 = (Uint16) source2;
	if ((int) sourcePixel == original){
	(Uint16 )source1 = replace;
	}
	if ((int) sourcePixel2 == original){
	(Uint16 )source2 = replace;
	}
	}
	break;
	}
	case 3 : {
	Uint8 * source1 = computeOffset(dst, x1, y);
	Uint8 * source2 = computeOffset(dst, x1, y + 1);
	Uint8 * source3 = computeOffset(dst, x1, y + 2);
	for (int x = x2 - 1; x >= x1; source1 += bpp, source2 += bpp, source3 += bpp, x--) {
	unsigned long sourcePixel = (Uint16) source1;
	unsigned long sourcePixel2 = (Uint16) source2;
	unsigned long sourcePixel3 = (Uint16) source3;
	if ((int) sourcePixel == original){
	(Uint16 )source1 = replace;
	}
	if ((int) sourcePixel2 == original){
	(Uint16 )source2 = replace;
	}
	if ((int) sourcePixel3 == original){
	(Uint16 )source3 = replace;
	}
	}
	break;
	}
	default:
	case 4 : {
	Uint8 * source1 = computeOffset(dst, x1, y);
	Uint8 * source2 = computeOffset(dst, x1, y + 1);
	Uint8 * source3 = computeOffset(dst, x1, y + 2);
	Uint8 * source4 = computeOffset(dst, x1, y + 3);
	for (int x = x2 - 1; x >= x1; source1 += bpp, source2 += bpp, source3 += bpp, source4 += bpp, x--) {
	unsigned long sourcePixel = (Uint16) source1;
	unsigned long sourcePixel2 = (Uint16) source2;
	unsigned long sourcePixel3 = (Uint16) source3;
	unsigned long sourcePixel4 = (Uint16) source4;
	if ((int) sourcePixel == original){
	(Uint16 )source1 = replace;
	}
	if ((int) sourcePixel2 == original){
	(Uint16 )source2 = replace;
	}
	if ((int) sourcePixel3 == original){
	(Uint16 )source3 = replace;
	}
	if ((int) sourcePixel4 == original){
	(Uint16 )source4 = replace;
	}
	}
	break;
	}
	}
	}
	*/
	if (SDL_MUSTLOCK(dst)){
	SDL_LockSurface(dst);
	}

	/* Another failed attempt at loop unrolling. */
	/*
	int y2_4 = y2 & (~3);

	for (int y = y1; y < y2_4; y += 4) {
	Uint8 * source1 = computeOffset(dst, x1, y);
	Uint8 * source2 = computeOffset(dst, x1, y + 1);
	Uint8 * source3 = computeOffset(dst, x1, y + 2);
	Uint8 * source4 = computeOffset(dst, x1, y + 3);
	for (int x = x2 - 1; x >= x1; source1 += bpp, source2 += bpp, source3 += bpp, source4 += bpp, x--) {
	Uint16 sourcePixel = (Uint16) source1;
	Uint16 sourcePixel2 = (Uint16) source2;
	Uint16 sourcePixel3 = (Uint16) source3;
	Uint16 sourcePixel4 = (Uint16) source4;
	if (sourcePixel == original){
	(Uint16 )source1 = replace;
	}
	if (sourcePixel2 == original){
	(Uint16 )source2 = replace;
	}
	if (sourcePixel3 == original){
	(Uint16 )source3 = replace;
	}
	if (sourcePixel4 == original){
	(Uint16 )source4 = replace;
	}
	}
	}

	for (int y = y2_4; y < y2; y++) {
	Uint8 * sourceLine = computeOffset(dst, x1, y);

	for (int x = x2 - 1; x >= x1; sourceLine += bpp, x--) {
	Uint16 sourcePixel = (Uint16) sourceLine;
	if (sourcePixel == original){
	(Uint16 )sourceLine = replace;
	}
	}
	}
	*/

	/* Original */
	for (int y = y1; y < y2; y++){
	Uint8 * sourceLine = computeOffset(dst, x1, y);

	for (int x = x2 - 1; x >= x1; sourceLine += bpp, x--) {
	Uint16 sourcePixel = (Uint16) sourceLine;
	if (sourcePixel == original){
	(Uint16 )sourceLine = replace;
	}
	}
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_UnlockSurface(dst);
	}
	}

	static void paintown_draw_sprite_filter_ex16(SDL_Surface * dst, SDL_Surface * src, long long dx, long long dy, Bitmap::Filter * filter){
	int x, y, w, h;
	int x_dir = 1, y_dir = 1;
	int dxbeg, dybeg;
	int sxbeg, sybeg;

	if (SDL_MUSTLOCK(dst)){
	SDL_LockSurface(dst);
	}

	if (true /* dst->clip*/ ) {
	long long tmp;

	tmp = dst->clip_rect.x - dx;
	sxbeg = ((tmp < 0) ? 0 : tmp);
	dxbeg = sxbeg + dx;

	tmp = dst->clip_rect.x + dst->clip_rect.w - dx;
	w = ((tmp > src->w) ? src->w : tmp) - sxbeg;
	if (w <= 0)
	return;

	tmp = dst->clip_rect.y - dy;
	sybeg = ((tmp < 0) ? 0 : tmp);
	dybeg = sybeg + dy;

	tmp = dst->clip_rect.y + dst->clip_rect.h - dy;
	h = ((tmp > src->h) ? src->h : tmp) - sybeg;
	if (h <= 0)
	return;
	}

	- unsigned int mask = makeColor(255, 0, 255);
	+ unsigned int mask = MaskColor().color;
	int bpp = src->format->BytesPerPixel;
	for (y = 0; y < h; y++) {
	Uint8 * sourceLine = computeOffset(src, sxbeg, sybeg + y);
	Uint8 * destLine = computeOffset(dst, dxbeg, dybeg + y * y_dir);

	for (x = w - 1; x >= 0; sourceLine += bpp, destLine += bpp * x_dir, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	- (Uint16 )destLine = filter->filter(sourcePixel);
	+ (Uint16 )destLine = filter->filter(Color(sourcePixel)).color;
	} else {
	(Uint16 )destLine = mask;
	}
	}
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_UnlockSurface(dst);
	}
	}

	static void paintown_draw_sprite_ex16(SDL_Surface * dst, SDL_Surface * src, long long dx, long long dy, int mode, int flip, Bitmap::Filter * filter){
	int x, y, w, h;
	int x_dir = 1, y_dir = 1;
	int dxbeg, dybeg;
	int sxbeg, sybeg;
	/*
	PAINTOWN_DLS_BLENDER lit_blender;
	PAINTOWN_DTS_BLENDER trans_blender;
	*/

	/*
	ASSERT(dst);
	ASSERT(src);
	*/

	if (SDL_MUSTLOCK(src)){
	SDL_LockSurface(src);
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_LockSurface(dst);
	}

	if ( flip & SPRITE_V_FLIP ){
	y_dir = -1;
	}
	if ( flip & SPRITE_H_FLIP ){
	x_dir = -1;
	}

	if (true /* dst->clip*/ ) {
	long long tmp;

	tmp = dst->clip_rect.x - dx;
	sxbeg = ((tmp < 0) ? 0 : tmp);
	dxbeg = sxbeg + dx;

	tmp = dst->clip_rect.x + dst->clip_rect.w - dx;
	w = ((tmp > src->w) ? src->w : tmp) - sxbeg;
	if (w <= 0)
	return;

	if ( flip & SPRITE_H_FLIP ){
	/* use backward drawing onto dst */
	sxbeg = src->w - (sxbeg + w);
	dxbeg += w - 1;
	}

	tmp = dst->clip_rect.y - dy;
	sybeg = ((tmp < 0) ? 0 : tmp);
	dybeg = sybeg + dy;

	tmp = dst->clip_rect.y + dst->clip_rect.h - dy;
	h = ((tmp > src->h) ? src->h : tmp) - sybeg;
	if (h <= 0)
	return;

	if ( flip & SPRITE_V_FLIP ){
	/* use backward drawing onto dst */
	sybeg = src->h - (sybeg + h);
	dybeg += h - 1;
	}
	} else {
	w = src->w;
	h = src->h;
	sxbeg = 0;
	sybeg = 0;
	dxbeg = dx;
	if ( flip & SPRITE_H_FLIP ){
	dxbeg = dx + w - 1;
	}
	dybeg = dy;
	if ( flip & SPRITE_V_FLIP ){
	dybeg = dy + h - 1;
	}
	}

	/*
	lit_blender = PAINTOWN_MAKE_DLS_BLENDER(0);
	trans_blender = PAINTOWN_MAKE_DTS_BLENDER();
	*/

	#if 0
	if (dst->id & (BMP_ID_VIDEO \| BMP_ID_SYSTEM)) {
	bmp_select(dst);

	switch (mode){
	case Bitmap::SPRITE_NORMAL : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {

	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}

	break;
	}
	case Bitmap::SPRITE_LIT : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {

	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}
	break;
	}
	case Bitmap::SPRITE_TRANS : {
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {

	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}
	break;
	}
	}
	#xendif

	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);

	/* flipped if y_dir is -1 */
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	/* d is incremented by x_dir, -1 if flipped */
	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	switch( mode ){
	case Bitmap::SPRITE_NORMAL : break;
	case Bitmap::SPRITE_LIT : {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	break;
	}
	case Bitmap::SPRITE_TRANS : {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	break;
	}
	}
	PAINTOWN_PUT_PIXEL(d, c);
	}
	}
	}

	bmp_unwrite_line(dst);
	}
	else {
	#endif
	{

	switch (mode){
	case SPRITE_NORMAL : {
	- unsigned int mask = makeColor(255, 0, 255);
	+ unsigned int mask = MaskColor().color;
	int bpp = src->format->BytesPerPixel;
	for (y = 0; y < h; y++) {
	Uint8 * sourceLine = computeOffset(src, sxbeg, sybeg + y);
	Uint8 * destLine = computeOffset(dst, dxbeg, dybeg + y * y_dir);

	for (x = w - 1; x >= 0; sourceLine += bpp, destLine += bpp * x_dir, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	// unsigned int destPixel = (Uint16) destLine;
	// sourcePixel = globalBlend.currentBlender(destPixel, sourcePixel, globalBlend.alpha);
	if (filter != NULL){
	- (Uint16 )destLine = filter->filter(sourcePixel);
	+ (Uint16 )destLine = filter->filter(Color(sourcePixel)).color;
	} else {
	(Uint16 )destLine = sourcePixel;
	}
	}
	}
	}
	break;
	}
	case SPRITE_LIT : {
	int bpp = src->format->BytesPerPixel;
	- int litColor = makeColor(globalBlend.red, globalBlend.green, globalBlend.blue);
	- unsigned int mask = makeColor(255, 0, 255);
	+ int litColor = makeColor(globalBlend.red, globalBlend.green, globalBlend.blue).color;
	+ unsigned int mask = MaskColor().color;
	for (y = 0; y < h; y++) {
	Uint8 * sourceLine = computeOffset(src, sxbeg, sybeg + y);
	Uint8 * destLine = computeOffset(dst, dxbeg, dybeg + y * y_dir);

	for (x = w - 1; x >= 0; sourceLine += bpp, destLine += bpp * x_dir, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	// unsigned int destPixel = (Uint16) destLine;
	if (filter != NULL){
	- sourcePixel = globalBlend.currentBlender(litColor, filter->filter(sourcePixel), globalBlend.alpha);
	+ sourcePixel = globalBlend.currentBlender(litColor, filter->filter(Color(sourcePixel)).color, globalBlend.alpha);
	(Uint16 )destLine = sourcePixel;
	} else {
	sourcePixel = globalBlend.currentBlender(litColor, sourcePixel, globalBlend.alpha);
	(Uint16 )destLine = sourcePixel;
	}
	}
	}
	}
	break;
	}
	case SPRITE_TRANS : {
	int bpp = src->format->BytesPerPixel;
	- unsigned int mask = makeColor(255, 0, 255);
	+ unsigned int mask = MaskColor().color;
	for (y = 0; y < h; y++) {
	Uint8 * sourceLine = computeOffset(src, sxbeg, sybeg + y);
	Uint8 * destLine = computeOffset(dst, dxbeg, dybeg + y * y_dir);

	for (x = w - 1; x >= 0; sourceLine += bpp, destLine += bpp * x_dir, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	unsigned int destPixel = (Uint16) destLine;
	if (filter != NULL){
	- sourcePixel = globalBlend.currentBlender(filter->filter(sourcePixel), destPixel, globalBlend.alpha);
	+ sourcePixel = globalBlend.currentBlender(filter->filter(Color(sourcePixel)).color, destPixel, globalBlend.alpha);
	(Uint16 )destLine = sourcePixel;
	} else {
	sourcePixel = globalBlend.currentBlender(sourcePixel, destPixel, globalBlend.alpha);
	(Uint16 )destLine = sourcePixel;
	}
	}
	}
	}
	break;
	}
	default : { break; }
	}

	#if 0
	for (y = 0; y < h; y++) {
	PAINTOWN_PIXEL_PTR s = PAINTOWN_OFFSET_PIXEL_PTR(src->line[sybeg + y], sxbeg);
	PAINTOWN_PIXEL_PTR d = PAINTOWN_OFFSET_PIXEL_PTR(bmp_write_line(dst, dybeg + y * y_dir), dxbeg);

	for (x = w - 1; x >= 0; PAINTOWN_INC_PIXEL_PTR(s), PAINTOWN_INC_PIXEL_PTR_EX(d,x_dir), x--) {
	unsigned long c = PAINTOWN_GET_MEMORY_PIXEL(s);
	if (!PAINTOWN_IS_SPRITE_MASK(src, c)) {
	switch( mode ){
	case Bitmap::SPRITE_NORMAL : break;
	case Bitmap::SPRITE_LIT : {
	c = PAINTOWN_DLSX_BLEND(lit_blender, c);
	break;
	}
	case Bitmap::SPRITE_TRANS : {
	c = PAINTOWN_DTS_BLEND(trans_blender, PAINTOWN_GET_PIXEL(d), c);
	break;
	}
	}
	PAINTOWN_PUT_MEMORY_PIXEL(d, c);
	}
	}
	}
	#endif
	}

	if (SDL_MUSTLOCK(src)){
	SDL_UnlockSurface(src);
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_UnlockSurface(dst);
	}
	}

	/* ultra special-case for drawing a light (like from a lamp).
	* center of light is x,y and shines in a perfect isosolese triangle.
	*/
	static void paintown_light16(SDL_Surface * dst, const int x, const int y, int width, int height, const int start_y, const int focus_alpha, const int edge_alpha, const int focus_color, const int edge_color){

	if (width > dst->w){
	width = dst->w;
	}

	if (height > dst->h){
	height = dst->h;
	}

	int dxbeg = x - width;
	int x_dir = 1;
	unsigned char * alphas = new unsigned char[width];
	- int * colors = new int[width];
	+ Color * colors = new Color[width];
	for (int i = 0; i < width; i++){
	alphas[i] = (unsigned char)((double)(edge_alpha - focus_alpha) * (double)i / (double)width + focus_alpha);
	}
	- blend_palette(colors, width, focus_color, edge_color);
	+ blend_palette(colors, width, Color(focus_color), Color(edge_color));

	if (SDL_MUSTLOCK(dst)){
	SDL_LockSurface(dst);
	}

	int min_y, max_y, min_x, max_x;
	min_y = dst->clip_rect.y;
	max_y = dst->clip_rect.y + dst->clip_rect.h - 1;
	min_x = dst->clip_rect.x;
	max_x = dst->clip_rect.x + dst->clip_rect.w - 1;

	int dybeg = y;

	/* tan(theta) = y / x */
	double xtan = (double) height / (double) width;
	int bpp = dst->format->BytesPerPixel;
	for (int sy = start_y; sy < height; sy++) {
	if (dybeg + sy < min_y \|\| dybeg + sy > max_y){
	continue;
	}
	/* x = y / tan(theta) */
	int top_width = (int)((double) sy / xtan);
	if (top_width == 0){
	continue;
	}

	dxbeg = x - top_width;
	Uint8* line = computeOffset(dst, dxbeg, dybeg + y);

	for (int sx = -top_width; sx <= top_width; line += x_dir * bpp, sx++) {
	if (sx + x < min_x \|\| sx + x > max_x){
	continue;
	}

	unsigned long c = (Uint16) line;

	/* TODO:
	* converting to a double and calling fabs is overkill, just
	* write an integer abs() function.
	*/
	int sx_abs = (int) fabs((double) sx);
	int alphaUse = alphas[sx_abs];
	- int color = colors[sx_abs];
	+ int color = colors[sx_abs].color;

	c = globalBlend.currentBlender(color, c, alphaUse);

	(Uint16) line = c;
	}
	}
	delete[] alphas;
	delete[] colors;

	if (SDL_MUSTLOCK(dst)){
	SDL_UnlockSurface(dst);
	}
	}

	}

	#include "../software-renderer/bitmap.cpp"
	diff --git a/util/graphics/sdl/bitmap.h b/util/graphics/sdl/bitmap.h
	index bb3f953d..26a8d555 100644
	--- a/util/graphics/sdl/bitmap.h
	+++ b/util/graphics/sdl/bitmap.h
	@@ -1,46 +1,46 @@
	struct SDL_Surface;

	namespace Graphics{
	struct BitmapData{
	BitmapData():
	surface(0),
	clip_left(0),
	clip_right(0),
	clip_top(0),
	clip_bottom(0),
	destroy(true){}

	BitmapData(SDL_Surface * surface);

	inline SDL_Surface * getSurface() const {
	return surface;
	}

	virtual ~BitmapData();

	inline void setClip(int left, int top, int right, int bottom) const {
	clip_left = left;
	clip_right = right;
	clip_top = top;
	clip_bottom = bottom;
	}

	bool isClipped(int x, int y) const {
	return (x < clip_left \|\|
	y < clip_top \|\|
	x >= clip_right \|\|
	y >= clip_bottom);
	}

	void setSurface(SDL_Surface * surface);

	SDL_Surface * surface;
	mutable int clip_left, clip_right;
	mutable int clip_top, clip_bottom;
	bool destroy;
	};

	-typedef int Color;
	+typedef int INTERNAL_COLOR;
	}

	#include "../software-renderer/bitmap.h"

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 18, 8:21 PM (1 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71820
Default Alt Text: (286 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions