No OneTemporary
Actions

Authored By

Unknown

Size

265 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/util/allegro/bitmap.cpp b/util/allegro/bitmap.cpp
	index 259664d0..6fadade6 100644
	--- a/util/allegro/bitmap.cpp
	+++ b/util/allegro/bitmap.cpp
	@@ -1,1900 +1,1902 @@
	/* allegro.h must be on top, don't move it!!!! */
	#include <allegro.h>

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

	#include "../gif/algif.h"
	#include "../bitmap.h"
	#include "../lit_bitmap.h"
	#include "../trans-bitmap.h"
	#include "../init.h"
	#include <stdarg.h>
	#include <vector>
	#include <string>
	#include <iostream>
	#include <math.h>
	#include "../funcs.h"
	#include <stdio.h>
	#include "../load_exception.h"
	#include "../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{

	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);

	int MaskColor(){
	return MASK_COLOR_16;
	}

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

	Bitmap::Bitmap():
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	- getData().setBitmap( create_bitmap( 10, 10 ) );
	- if (! getData().getBitmap()){
	+ setData(new BitmapData(create_bitmap( 10, 10 )));
	+ if (! getData()->getBitmap()){
	error = true;
	cerr << "Could not create bitmap!" << endl;
	} else {
	clear();
	own = new int;
	*own = 1;
	}
	}

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

	enum Format{
	PNG,
	GIF,
	};

	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, Format type){
	switch (type){
	case PNG : {
	break;
	}
	case GIF : {
	return memoryGIF(data, length);
	break;
	}
	}
	throw Exception::Base(__FILE__, __LINE__);
	}

	Bitmap::Bitmap(const char * data, int length):
	own(NULL),
	mustResize(false),
	error(false),
	bit8MaskColor(0){
	/* FIXME: pass the type in */
	Format type = GIF;
	- getData().setBitmap(load_bitmap_from_memory(data, length, type));
	+ setData(new BitmapData(load_bitmap_from_memory(data, length, type)));
	own = new int;
	*own = 1;
	}

	/* 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 ):
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(0){

	if ( deep_copy ){
	BITMAP * his = who;
	- getData().setBitmap( create_bitmap( his->w, his->h ) );
	- if ( ! getData().getBitmap() ){
	+ setData(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 );
	+ ::blit( his, getData()->getBitmap(), 0, 0, 0, 0, his->w, his->h );
	own = new int;
	*own = 1;
	} else {
	- getData().setBitmap( who );
	+ setData(new BitmapData(who));
	own = NULL;
	}
	}

	Bitmap::Bitmap( const char * load_file ):
	own( NULL ),
	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 ):
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	internalLoadFile( load_file.c_str() );
	}

	Bitmap::Bitmap( const char * load_file, int sx, int sy ):
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	path = load_file;
	BITMAP * temp = load_bitmap( load_file, NULL );
	// my_bitmap = load_bitmap( load_file, NULL );
	- getData().setBitmap( create_bitmap( sx, sy ) );
	+ setData(new BitmapData(create_bitmap(sx, sy)));
	// clear( my_bitmap );
	- if ( !temp \|\| ! getData().getBitmap() ){
	+ 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 );
	+ stretch_blit( temp, getData()->getBitmap(), 0, 0, temp->w, temp->h, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );
	destroy_bitmap( temp );
	}
	// own = true;
	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap( const char * load_file, int sx, int sy, double accuracy ):
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(0){
	path = load_file;
	BITMAP * temp = load_bitmap( load_file, NULL );
	own = new int;
	*own = 1;
	if ( !temp ){
	cout<<"Could not load "<<load_file<<endl;
	- getData().setBitmap( create_bitmap( sx, sy ) );
	+ setData(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);
	- getData().setBitmap( create_bitmap( fx, fy ) );
	+ setData(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 );
	+ stretch_blit( temp, getData()->getBitmap(), 0, 0, temp->w, temp->h, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );

	destroy_bitmap( temp );
	- } else getData().setBitmap( temp );
	+ } else {
	+ setData(new BitmapData(temp));
	+ }
	}
	// own = true;
	}

	Bitmap::Bitmap( const Bitmap & copy, int sx, int sy ):
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	- BITMAP * temp = copy.getData().getBitmap();
	- getData().setBitmap( create_bitmap( sx, sy ) );
	- if ( ! getData().getBitmap() ){
	+ BITMAP * temp = copy.getData()->getBitmap();
	+ setData(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 );
	+ stretch_blit( temp, getData()->getBitmap(), 0, 0, temp->w, temp->h, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );
	// own = true;
	// own = copy.own;
	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap( const Bitmap & copy, int sx, int sy, double accuracy ):
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	- BITMAP * temp = copy.getData().getBitmap();
	+ BITMAP * temp = copy.getData()->getBitmap();
	own = new int;
	*own = 1;
	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);
	- getData().setBitmap( create_bitmap( fx, fy ) );
	- if ( ! getData().getBitmap() ){
	+ setData(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 );
	+ stretch_blit( temp, getData()->getBitmap(), 0, 0, temp->w, temp->h, 0, 0, getData()->getBitmap()->w, getData()->getBitmap()->h );
	// destroy_bitmap( temp );
	} else {
	- getData().setBitmap( create_bitmap( temp->w, temp->h ) );
	- blit( temp, getData().getBitmap(), 0, 0, 0, 0, temp->w, temp->h );
	+ setData(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 ):
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(copy.bit8MaskColor){

	path = copy.getPath();
	if ( deep_copy ){
	- BITMAP * his = copy.getData().getBitmap();
	- getData().setBitmap( create_bitmap( his->w, his->h ) );
	- if ( ! getData().getBitmap() ){
	+ BITMAP * his = copy.getData()->getBitmap();
	+ setData(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 );
	+ ::blit( his, getData()->getBitmap(), 0, 0, 0, 0, his->w, his->h );
	own = new int;
	*own = 1;
	} else {
	- getData().setBitmap( copy.getData().getBitmap() );
	+ setData(copy.getData());
	// own = false;
	own = copy.own;
	if ( own ){
	own = own + 1;
	}
	}
	/*
	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 ):
	own( NULL ),
	mustResize(false),
	error( false ),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	- BITMAP * his = copy.getData().getBitmap();
	+ 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;
	- getData().setBitmap( create_sub_bitmap( his, x, y, width, height ) );
	+ setData(new BitmapData(create_sub_bitmap(his, x, y, width, height)));

	- if ( ! getData().getBitmap() ){
	+ if ( ! getData()->getBitmap() ){
	cout<<"Could not create sub-bitmap"<<endl;
	- getData().setBitmap( create_bitmap( 10, 10 ) );
	+ setData(new BitmapData(create_bitmap(10, 10)));
	// clear( my_bitmap );
	clear();
	}
	// own = true;
	own = new int;
	*own = 1;
	}

	void Bitmap::internalLoadFile( const char * load_file ){
	path = load_file;
	- getData().setBitmap( load_bitmap( load_file, NULL ) );
	- if ( ! getData().getBitmap() ){
	+ setData(new BitmapData(load_bitmap(load_file, NULL)));
	+ if ( ! getData()->getBitmap() ){
	cout<<"Could not load "<<load_file<<". Using default"<<endl;
	- getData().setBitmap( create_bitmap( 10, 10 ) );
	- if ( ! getData().getBitmap() ){
	+ setData(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;
	}
	// own = true;
	own = new int;
	*own = 1;
	}

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

	Bitmap 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);


	#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;
	}

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

	void Bitmap::destroyPrivateData(){
	- destroy_bitmap(getData().getBitmap());
	}

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

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

	int getRed( int x ){
	return ::getr( x );
	}

	int getBlue( int x ){
	return ::getb( x );
	}

	int getGreen( int x ){
	return ::getg( x );
	}

	void Bitmap::setClipRect( int x1, int y1, int x2, int y2 ) const {
	- ::set_clip_rect( getData().getBitmap(), x1, y1, x2, y2 );
	+ ::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);
	+ ::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<<"Self = "<< getData()->getBitmap() <<endl;
	cout<<"Own = "<< own <<" : "<< *own <<endl;
	cout<<"Path = "<<path<<endl;
	}

	Bitmap & Bitmap::operator=( const Bitmap & copy ){

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

	releaseInternalBitmap();

	path = copy.getPath();
	- getData().setBitmap( copy.getData().getBitmap() );
	+ setData(copy.getData());
	// own = false;
	own = copy.own;
	if ( own )
	*own += 1;

	return *this;
	}

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

	void Bitmap::detach(){

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

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

	/*
	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() );
	+ acquire_bitmap( getData()->getBitmap() );
	}

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

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

	void TranslucentBitmap::circleFill(int x, int y, int radius, int 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 );
	+ ::circle( getData()->getBitmap(), x, y, radius, 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 );
	+ ::fastline( getData()->getBitmap(), x1, y1, x2, y2, color );
	}

	void TranslucentBitmap::line(const int x1, const int y1, const int x2, const int y2, const int 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 );
	+ ::floodfill( getData()->getBitmap(), x, y, 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 );
	+ ::draw_character_ex( where.getData()->getBitmap(), getData()->getBitmap(), x, y, color, background );
	}

	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(int original, int replaced){
	int height = getHeight();
	int width = getWidth();
	- BITMAP * bitmap = getData().getBitmap();
	+ 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);
	}
	}
	}
	}

	void Bitmap::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;
	}
	}
	}

	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);
	Scaler = new Bitmap(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 );
	+ if ( x >= 0 && x < getData()->getBitmap()->w && y >= 0 && y < getData()->getBitmap()->h )
	+ return _getpixel16( getData()->getBitmap(), x, y );
	return -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++ ){
	+ 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 );
	+ int col = _getpixel16( getData()->getBitmap(), q, y );
	vec.push_back( col );
	}
	}
	}

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

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

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

	int makeColor( int r, int g, int b ){
	return ::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 ) );
	}

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

	/* 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 {
	drawingMode(MODE_TRANS);
	Bitmap::putPixelNormal(x, y, color);
	drawingMode(MODE_SOLID);
	}

	void Bitmap::putPixel( int x, int y, int col ) const{
	- BITMAP * dst = getData().getBitmap();
	+ 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 );
	+ if ( x >= 0 && x < getData()->getBitmap()->w && y >= 0 && y < getData()->getBitmap()->h )
	+ _putpixel16( getData()->getBitmap(), x, y, col );
	}

	/*
	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 );
	+ ::triangle( getData()->getBitmap(), x1, y1, x2, y2, x3, y3, color );
	}

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

	void TranslucentBitmap::ellipse(int x, int y, int rx, int ry, int color) const {
	drawingMode(MODE_TRANS);
	Bitmap::ellipse(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 );
	+ ::ellipsefill( getData()->getBitmap(), x, y, rx, ry, color );
	}

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

	void TranslucentBitmap::rectangle( int x1, int y1, int x2, int y2, int 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 );
	+ ::rectfill( getData()->getBitmap(), x1, y1, x2, y2, color );
	}

	void TranslucentBitmap::rectangleFill( int x1, int y1, int x2, int y2, int 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 );
	+ ::hline( getData()->getBitmap(), x1, y, x2, color );
	}

	void TranslucentBitmap::hLine( const int x1, const int y, const int x2, const int color ) const{
	drawingMode(MODE_TRANS);
	- ::hline(getData().getBitmap(), x1, y, x2, color);
	+ ::hline(getData()->getBitmap(), x1, y, x2, 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 );
	+ ::vline( getData()->getBitmap(), x, y1, y2, color );
	}

	void Bitmap::polygon( const int * verts, const int nverts, const int color ) const{
	- ::polygon( getData().getBitmap(), nverts, verts, color );
	+ ::polygon( getData()->getBitmap(), nverts, verts, 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 {
	::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);
	}

	void TranslucentBitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int 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);
	/* 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);
	}
	}

	void Bitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const int 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());
	+ 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 {
	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 );
	+ ::clear_to_color( getData()->getBitmap(), 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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 );
	+ ::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 );
	+ ::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 );
	+ ::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 );
	+ 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 {
	- paintown_light16(getData().getBitmap(), x, y, width, height, start_y, focus_alpha, edge_alpha, focus_color, edge_color);
	+ 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 {
	- paintown_applyTrans16(getData().getBitmap(), color);
	+ 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 );
	+ ::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 );
	+ ::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();
	+ 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 );
	+ ::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::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 );
	+ 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 );
	+ 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 );
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	}
	break;
	}
	case SPRITE_LIT : {
	if (filter){
	c = PAINTOWN_DLSX_BLEND(lit_blender, filter->filter(c));
	} 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));
	} 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));
	} 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));
	} 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));
	} 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){
	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);
	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){

	int dxbeg = x - width;
	int x_dir = 1;
	unsigned char * alphas = new unsigned char[width];
	int * colors = new int[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];
	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));
	} 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));
	} 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));
	} 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));
	} 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);
	// 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));
	} else {
	PAINTOWN_PUT_MEMORY_PIXEL(d, mask);
	}
	}
	}
	}

	}

	#include "../software-renderer/bitmap.cpp"
	diff --git a/util/allegro/bitmap.h b/util/allegro/bitmap.h
	index 1343af9f..8eca223d 100644
	--- a/util/allegro/bitmap.h
	+++ b/util/allegro/bitmap.h
	@@ -1,35 +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){}
	+ 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;
	}

	#include "../software-renderer/bitmap.h"
	diff --git a/util/allegro5/bitmap.cpp b/util/allegro5/bitmap.cpp
	index 2b87754e..7673ceee 100644
	--- a/util/allegro5/bitmap.cpp
	+++ b/util/allegro5/bitmap.cpp
	@@ -1,1103 +1,1112 @@
	#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{

	/* it doesnt look like we need to pack colors into 16-bit values */
	#if 0
	static const int rgb_r_shift_16 = 0;
	static const int rgb_g_shift_16 = 5;
	static const int rgb_b_shift_16 = 11;

	static inline int pack565(unsigned char red, unsigned char green, unsigned char blue){
	return (((red >> 3) << rgb_r_shift_16) \|
	((green >> 2) << rgb_g_shift_16) \|
	((blue >> 3) << rgb_b_shift_16));
	}

	/* from allegro4 */
	static inline void unpack565(int color, unsigned char * red, unsigned char * green, unsigned char * blue){
	static int _rgb_scale_5[32] = {
	0, 8, 16, 24, 33, 41, 49, 57,
	66, 74, 82, 90, 99, 107, 115, 123,
	132, 140, 148, 156, 165, 173, 181, 189,
	198, 206, 214, 222, 231, 239, 247, 255
	};

	static int _rgb_scale_6[64] = {
	0, 4, 8, 12, 16, 20, 24, 28,
	32, 36, 40, 44, 48, 52, 56, 60,
	65, 69, 73, 77, 81, 85, 89, 93,
	97, 101, 105, 109, 113, 117, 121, 125,
	130, 134, 138, 142, 146, 150, 154, 158,
	162, 166, 170, 174, 178, 182, 186, 190,
	195, 199, 203, 207, 211, 215, 219, 223,
	227, 231, 235, 239, 243, 247, 251, 255
	};

	*red = _rgb_scale_5[(color >> rgb_r_shift_16) & 0x1F];
	*green = _rgb_scale_6[(color >> rgb_g_shift_16) & 0x3F];
	*blue = _rgb_scale_5[(color >> rgb_b_shift_16) & 0x1F];
	}
	#endif

	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, blue, green, alpha);
	}

	Color MaskColor(){
	static Color mask = makeColorAlpha(0, 0, 0, 0);
	return mask;
	}

	Color getBlendColor(){
	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);
	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);
	}

	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 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_DEST_MINUS_SRC, ALLEGRO_ONE, ALLEGRO_ONE); 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():
	own(NULL),
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	/* TODO */
	}

	Bitmap::Bitmap( const char * load_file ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	internalLoadFile(load_file);
	}

	Bitmap::Bitmap( const std::string & load_file ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	internalLoadFile(load_file.c_str());
	}

	Bitmap::Bitmap(ALLEGRO_BITMAP * who, bool deep_copy):
	own(NULL),
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	if (deep_copy){
	ALLEGRO_BITMAP * clone = al_clone_bitmap(who);
	- getData().setBitmap(clone);
	+ setData(new BitmapData(clone));
	own = new int;
	*own = 1;
	} else {
	- getData().setBitmap(who);
	+ setData(new BitmapData(who));
	}
	}

	Bitmap::Bitmap(int width, int height):
	own(NULL),
	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());
	}
	- getData().setBitmap(bitmap);
	+ setData(new BitmapData(bitmap));
	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap( const Bitmap & copy, bool deep_copy):
	own(NULL),
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	if (deep_copy){
	- ALLEGRO_BITMAP * clone = al_clone_bitmap(copy.getData().getBitmap());
	- getData().setBitmap(clone);
	+ ALLEGRO_BITMAP * clone = al_clone_bitmap(copy.getData()->getBitmap());
	+ setData(new BitmapData(clone));
	own = new int;
	*own = 1;
	} else {
	- getData().setBitmap(copy.getData().getBitmap());
	+ setData(copy.getData());
	own = copy.own;
	if (own){
	*own += 1;
	}
	}
	}

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

	void changeTarget(const Bitmap & from, const Bitmap & who){
	- 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)){
	+ 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();
	if (&from == &who){
	- al_set_target_bitmap(who.getData().getBitmap());
	+ 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);
	}

	enum Format{
	PNG,
	GIF,
	};

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

	Bitmap 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);
	// dumpColor(al_get_pixel(pcx, 0, 0));
	Bitmap out(pcx);
	out.set8BitMaskColor(makeColorAlpha(255, 255, 255, 255));
	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(Color original, Color replaced){
	changeTarget(this, this);

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

	for (int x = 0; x < getWidth(); x++){
	for (int y = 0; y < getHeight(); y++){
	Color pixel = getPixel(x, y);
	if (pixel == original){
	al_put_pixel(x, y, replaced);
	}
	}
	}

	- if (isVideoBitmap(getData().getBitmap())){
	- al_unlock_bitmap(getData().getBitmap());
	+ 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));
	- getData().setBitmap(loaded);
	+ setData(new BitmapData(loaded));
	own = new int;
	*own = 1;
	}

	static ALLEGRO_BITMAP * load_bitmap_from_memory(const char * data, int length, Format type){
	switch (type){
	case PNG : {
	break;
	}
	case GIF : {
	return memoryGIF(data, length);
	break;
	}
	}
	throw Exception::Base(__FILE__, __LINE__);
	}

	Bitmap::Bitmap(const char * data, int length):
	own(NULL),
	mustResize(false),
	bit8MaskColor(makeColor(0, 0, 0)){
	Format type = GIF;
	- getData().setBitmap(load_bitmap_from_memory(data, length, type));
	- if (getData().getBitmap() == NULL){
	+ setData(new BitmapData(load_bitmap_from_memory(data, length, type)));
	+ if (getData()->getBitmap() == NULL){
	std::ostringstream out;
	out << "Could not create bitmap from memory";
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap( const Bitmap & copy, int x, int y, int width, int height ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	- ALLEGRO_BITMAP * his = copy.getData().getBitmap();
	+ 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 * sub = al_create_sub_bitmap(his, x, y, width, height);
	- getData().setBitmap(sub);
	+ setData(new BitmapData(sub));

	own = new int;
	*own = 1;
	}

	int Bitmap::getWidth() const {
	- if (getData().getBitmap() != NULL){
	- return al_get_bitmap_width(getData().getBitmap());
	+ 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);
	return red;
	}

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

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

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

	int Bitmap::getHeight() const {
	- if (getData().getBitmap() != NULL){
	- return al_get_bitmap_height(getData().getBitmap());
	+ 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();
	switch (mode){
	case FULLSCREEN: {
	al_set_new_display_flags(ALLEGRO_FULLSCREEN);
	break;
	}
	case WINDOWED: {
	al_set_new_display_flags(ALLEGRO_WINDOWED \| ALLEGRO_RESIZABLE);
	break;
	}
	default: break;
	}
	ALLEGRO_DISPLAY * display = al_create_display(width, height);
	if (display == NULL){
	std::ostringstream out;
	out << "Could not create display with dimensions " << width << ", " << height;
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	Screen = new Bitmap(al_get_backbuffer(display));
	+ /* dont destroy the backbuffer */
	+ Screen->getData()->setDestroy(false);
	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_READONLY);
	+ 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());
	+ al_unlock_bitmap(getData()->getBitmap());
	}

	Color Bitmap::getPixel(const int x, const int y) const {
	- return al_get_pixel(getData().getBitmap(), x, y);
	+ changeTarget(this, this);
	+ return 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);
	}

	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);
	}

	void Bitmap::startDrawing() const {
	}

	void Bitmap::endDrawing() const {
	}

	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);
	return makeColorAlpha(red, green, blue, alpha);
	}

	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);
	+ 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 ){
	/* TODO */
	}

	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, getWidth(), getHeight(), x, y, new_width, new_height, 0);
	+ al_draw_scaled_bitmap(getData()->getBitmap(), 0, 0, getWidth(), getHeight(), 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
	}

	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);
	}
	*/

	/* FIXME: deal with mx, my, width, height */

	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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	al_flip_display();
	}

	void Bitmap::BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const {
	changeTarget(this, 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);
	+ 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);
	+ al_draw_bitmap(getData()->getBitmap(), x, y, 0);

	}

	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);
	}

	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 */
	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);
	}

	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);
	}

	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);
	}

	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);
	}

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

	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);
	}

	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);
	}

	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);
	}

	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);
	}

	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);
	}

	void Bitmap::applyTrans(const Color color) const {
	TransBlender blender;
	changeTarget(this, this);
	al_draw_filled_rectangle(0, 0, getWidth(), getHeight(), transBlendColor(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 {
	/* TODO */
	}

	void Bitmap::drawCharacter( const int x, const int y, const int 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(), x, y, 0);
	}

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

	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(), 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));
	}


	Bitmap & Bitmap::operator=(const Bitmap & copy){
	releaseInternalBitmap();
	path = copy.getPath();
	- getData().setBitmap(copy.getData().getBitmap());
	+ setData(copy.getData());
	// own = false;
	own = copy.own;
	if (own)
	*own += 1;
	return *this;
	}

	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 */
	}

	void Bitmap::destroyPrivateData(){
	- if (al_get_target_bitmap() == getData().getBitmap()){
	+ /*
	+ if (al_get_target_bitmap() == getData()->getBitmap()){
	al_set_target_bitmap(NULL);
	}
	- al_destroy_bitmap(getData().getBitmap());
	+ al_destroy_bitmap(getData()->getBitmap());
	+ */
	}

	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::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){
	/* TODO */
	}

	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):
	Bitmap(parent, 0, 0, parent.getWidth(), parent.getHeight()),
	width(width),
	height(height),
	where(parent){
	scale_x = (double) parent.getWidth() / width;
	scale_y = (double) parent.getHeight() / height;
	- al_set_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);
	- al_set_target_bitmap(getData().getBitmap());
	+ al_set_target_bitmap(getData()->getBitmap());
	al_use_transform(&transform);
	}

	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;
	}

	void resetDisplay(){
	// al_set_target_bitmap(Screen->getData().getBitmap());
	// changeTarget(Screen);
	}

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

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

	}

	static bool sameColor(Graphics::Color color1, Graphics::Color color2){
	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/allegro5/bitmap.h b/util/allegro5/bitmap.h
	index 6c7819ca..7d81c1de 100644
	--- a/util/allegro5/bitmap.h
	+++ b/util/allegro5/bitmap.h
	@@ -1,33 +1,55 @@
	-#include <allegro5/allegro.h>
	+#include <allegro5/allegro5.h>

	struct BitmapData{
	BitmapData():
	- bitmap(NULL){
	+ 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;

	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/bitmap.cpp b/util/bitmap.cpp
	index 4ba2a43c..fc509b7b 100644
	--- a/util/bitmap.cpp
	+++ b/util/bitmap.cpp
	@@ -1,420 +1,414 @@
	-/*
	-#ifdef USE_ALLEGRO
	-#include <allegro.h>
	-#endif
	-*/
	-
	#include "funcs.h"
	#include "bitmap.h"
	#include "trans-bitmap.h"
	#include "stretch-bitmap.h"
	#include "lit_bitmap.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;

	/* 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;
	}

	void initializeExtraStuff();

	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;
	}
	}
	}

	releaseInternalBitmap();
	}

	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;
	}
	}

	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);
	}
	}

	/* 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;

	/*
	BITMAP * b = create_bitmap( width, height );
	::stretch_blit( getData().getBitmap(), b, 0, 0, getData().getBitmap()->w, getData().getBitmap()->h, 0, 0, b->w, b->h );

	releaseInternalBitmap();

	own = new int;
	getData().setBitmap( b );
	*own = 1;
	*/
	}


	/* decrement bitmap reference counter and free memory if counter hits 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;
	}
	}
	}

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

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

	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::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(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);
	}

	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::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());
	}
	}

	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(){
	}

	TranslucentBitmap Bitmap::translucent() const {
	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;
	}

	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/bitmap.h b/util/bitmap.h
	index 8ba966a7..fb8c3cae 100644
	--- a/util/bitmap.h
	+++ b/util/bitmap.h
	@@ -1,418 +1,424 @@
	#ifndef _paintown_bitmap_h_
	#define _paintown_bitmap_h_

	#include "exceptions/exception.h"
	+#include "pointer.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

	namespace Graphics{

	class TranslucentBitmap;

	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();

	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 );

	/* 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;

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

	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;
	}
	*/

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

	void detach();

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

	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();

	void resize(const int width, const int height);

	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 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 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;

	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;

	/* 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 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 );

	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;

	/* 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 BitmapData & getData() const {
	+ inline const Util::ReferenceCount<BitmapData> & getData() const {
	return data;
	}

	- inline BitmapData & getData(){
	+ 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 );

	/*
	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 internalLoadFile( const char * load_file );

	/* implementation specific data */
	- BitmapData 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;

	};

	/* 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();

	/* sets the current target bitmap to the screen (on allegro5) */
	void resetDisplay();

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

	}

	#endif
	diff --git a/util/font.cpp b/util/font.cpp
	index 4e5725de..065419b5 100644
	--- a/util/font.cpp
	+++ b/util/font.cpp
	@@ -1,302 +1,302 @@
	#ifdef USE_ALLEGRO
	/* for textout_* and whatnot */
	#include <allegro.h>
	#endif
	#include "bitmap.h"
	#include "font.h"
	#include "funcs.h"
	#include "init.h"
	#include "ftalleg.h"
	#include "factory/font_factory.h"
	#include <string.h>

	using namespace std;

	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 ( length >= max - font.textLength( "E" ) \|\| right == "" ){
	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 {
	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, -1);
	}

	void AllegroFont::printf( int x, int y, int 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, -1);
	}
	#endif

	const Font & Font::getDefaultFont(){
	// return getFont( "tmp/comic.ttf" );
	// return *FontFactory::getFont(Filesystem::RelativePath("bios"), 16, 16);
	return *FontFactory::getFont(Filesystem::RelativePath("fonts/arial.ttf"), 16, 16);
	}

	const Font & Font::getDefaultFont(int width, int height){
	return *FontFactory::getFont(Filesystem::RelativePath("fonts/arial.ttf"), width, height);
	}

	/* 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 & font = *FontFactory::getFont(name, x, y);
	/* 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 5c5234c5..b0112d31 100644
	--- a/util/ftalleg.cpp
	+++ b/util/ftalleg.cpp
	@@ -1,732 +1,732 @@
	/*
	--------------
	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 "bitmap.h"

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

	#include "ftalleg.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;

	fonts[width].memory = al_load_font(path.path().c_str(), width, 0);
	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());
	- al_set_target_bitmap(bmp.getData().getBitmap());
	+ al_set_target_bitmap(bmp.getData()->getBitmap());

	/* for setting the blend state and whatnot */
	bmp.startDrawing();
	al_draw_text(currentVideoFont(), bmp.blendColor(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){
	FT_Init_FreeType(&ftLibrary);
	}
	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 );

	FT_Load_Char(face, unicode, FT_LOAD_TARGET_NORMAL \| FT_LOAD_RENDER \| FT_LOAD_FORCE_AUTOHINT);

	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()){
	FT_Set_Pixel_Sizes(face, size.width, size.height);
	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 std::exception();
	}
	}

	/*
	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;
	}

	return faceLoaded;
	}

	/* utf8 decoding */
	static long decodeUnicode(const std::string & input, unsigned int * position){
	unsigned char byte1 = (unsigned char) input[*position];
	/* one byte - ascii */
	if (byte1 >> 7 == 0){
	return byte1;
	}

	if (byte1 >> 5 == 6){
	*position += 1;
	unsigned char byte2 = (unsigned char) input[*position];
	int top = byte1 & 31;
	int bottom = byte2 & 63;
	return (top << 6) + bottom;
	}

	if (byte1 >> 4 == 14){
	*position += 1;
	unsigned char byte2 = (unsigned char) input[*position];
	*position += 1;
	unsigned char byte3 = (unsigned char) input[*position];
	int top4 = byte1 & 15;
	int middle6 = byte2 & 63;
	int bottom6 = byte3 & 63;
	return (top4 << (6+6)) + (middle6 << 6) + bottom6;
	}

	if (byte1 >> 3 == 30){
	*position += 1;
	unsigned char byte2 = (unsigned char) input[*position];
	*position += 1;
	unsigned char byte3 = (unsigned char) input[*position];
	*position += 1;
	unsigned char byte4 = (unsigned char) input[*position];
	int unit1 = byte1 & 7;
	int unit2 = byte2 & 63;
	int unit3 = byte3 & 63;
	int unit4 = byte4 & 63;
	return (unit1 << 18) + (unit2 << 12) + (unit3 << 6) + unit4;
	}

	return 0;
	}

	//! 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 = decodeUnicode(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 = decodeUnicode(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/loading.cpp b/util/loading.cpp
	index a2b25184..fed11156 100644
	--- a/util/loading.cpp
	+++ b/util/loading.cpp
	@@ -1,497 +1,504 @@
	#include "bitmap.h"
	#include "trans-bitmap.h"
	#include <math.h>
	#include <iostream>

	/* FIXME: get rid of this dependancy */
	#include "paintown-engine/level/utils.h"

	#include "messages.h"
	#include "loading.h"
	#include "file-system.h"
	#include "font.h"
	#include "funcs.h"
	#include "gradient.h"
	#include "parameter.h"
	#include "thread.h"
	#include "globals.h"
	#include <vector>
	#include "thread.h"
	#include "message-queue.h"
	#include "init.h"
	#include "events.h"

	using namespace std;

	namespace Loader{

	volatile bool done_loading = true;

	typedef struct pair{
	int x, y;
	} ppair;

	class Info{
	public:
	Info(){
	Global::registerInfo(&messages);
	}

	bool transferMessages(Messages & box){
	bool did = false;
	while (messages.hasAny()){
	const string & str = messages.get();
	box.addMessage(str);
	did = true;
	}
	return did;
	}

	~Info(){
	Global::unregisterInfo(&messages);
	}

	private:
	MessageQueue messages;
	};

	void * loadingScreenSimple1(void * arg);

	static void setupBackground(const Graphics::Bitmap & background, int load_x, int load_y, int load_width, int load_height, int infobox_x, int infobox_y, int infoWidth, int infoHeight, const Graphics::Bitmap & infoBackground){
	Font::getDefaultFont().printf( 400, 480 - Font::getDefaultFont().getHeight() * 5 / 2 - Font::getDefaultFont().getHeight(), Graphics::makeColor( 192, 192, 192 ), background, "Paintown version %s", 0, Global::getVersionString().c_str());
	Font::getDefaultFont().printf( 400, 480 - Font::getDefaultFont().getHeight() * 5 / 2, Graphics::makeColor( 192, 192, 192 ), background, "Made by Jon Rafkind", 0 );
	background.BlitToScreen();
	background.Blit(infobox_x, infobox_y, infoWidth, infoHeight, 0, 0, infoBackground);
	}

	/* converts a bitmap with some text on it into a sequence of points */
	static vector<ppair> generateFontPixels(const Font & myFont, const string & message, int width, int height){
	Graphics::Bitmap letters(width, height);
	letters.fill(Graphics::MaskColor());
	myFont.printf(0, 0, Graphics::makeColor(255, 255, 255), letters, message.c_str(), 0);

	- vector< ppair > pairs;
	+ vector<ppair> pairs;
	/* store every pixel we need to draw */
	+ letters.lock();
	for (int x = 0; x < letters.getWidth(); x++){
	for (int y = 0; y < letters.getHeight(); y++){
	Graphics::Color pixel = letters.getPixel(x, y);
	if (pixel != Graphics::MaskColor()){
	ppair p;
	p.x = x;
	p.y = y;
	pairs.push_back(p);
	}
	}
	}
	+ letters.unlock();

	- Graphics::resetDisplay();
	+ // Graphics::resetDisplay();

	return pairs;
	}

	/* shows time elapsed */
	class TimeCounter{
	public:
	TimeCounter():
	work(200, 40){
	start = Global::second_counter;
	last = 0;
	}

	void draw(int x, int y){
	const Font & font = Font::getDefaultFont(24, 24);
	if (Global::second_counter != last){
	work.clear();
	last = Global::second_counter;
	font.printf(0, 0, Graphics::makeColor(192, 192, 192), work, "Waiting.. %d", 0, last - start);
	work.BlitAreaToScreen(x, y);
	}
	}

	Graphics::Bitmap work;
	unsigned int start;
	unsigned int last;
	};

	static void loadingScreen1(LoadingContext & context, const Level::LevelInfo & levelInfo){
	int load_x = 80;
	int load_y = 220;
	const int infobox_width = 300;
	const int infobox_height = 150;
	Graphics::resetDisplay();
	const Font & myFont = Font::getFont(Global::DEFAULT_FONT, 24, 24);

	if (levelInfo.getPositionX() != -1){
	load_x = levelInfo.getPositionX();
	}

	if (levelInfo.getPositionY() != -1){
	load_y = levelInfo.getPositionY();
	}

	// const char * the_string = (arg != NULL) ? (const char *) arg : "Loading...";
	int load_width = myFont.textLength(levelInfo.loadingMessage().c_str());
	int load_height = myFont.getHeight(levelInfo.loadingMessage().c_str());

	Global::debug(2) << "loading screen" << endl;

	Messages infobox(infobox_width, infobox_height);

	const int MAX_COLOR = 200;

	/* blend from dark grey to light red */
	Effects::Gradient gradient(MAX_COLOR, Graphics::makeColor(16, 16, 16), Graphics::makeColor(192, 8, 8));

	TimeCounter counter;

	struct State{
	bool drawInfo;
	};

	class Logic: public Util::Logic {
	public:
	Logic(LoadingContext & context, State & state, Effects::Gradient & gradient, Messages & infoBox):
	context(context),
	state(state),
	gradient(gradient),
	infobox(infoBox){
	}

	LoadingContext & context;
	State & state;
	Effects::Gradient & gradient;
	Info info;
	Messages & infobox;

	void run(){
	gradient.backward();
	state.drawInfo = info.transferMessages(infobox) \|\| state.drawInfo;
	}

	double ticks(double system){
	return system;
	}

	bool done(){
	return context.done();
	}
	};

	class Draw: public Util::Draw {
	public:
	Draw(const Level::LevelInfo & levelInfo, State & state, Messages & infobox, Effects::Gradient & gradient, int load_width, int load_height, int infobox_width, int infobox_height, int load_x, int load_y):
	gradient(gradient),
	state(state),
	infobox(infobox),
	infoWork(Util::Parameter<Graphics::Bitmap>::current(), load_x, load_y + load_height * 2, infobox_width, infobox_height),
	infoBackground(infobox_width, infobox_height),
	infobox_x(load_x),
	infobox_y(load_y + load_height * 2),
	load_x(load_x),
	load_y(load_y),
	load_width(load_width),
	load_height(load_height){

	const Font & myFont = Font::getFont(Global::DEFAULT_FONT, 24, 24);
	pairs = generateFontPixels(myFont, levelInfo.loadingMessage(), load_width, load_height);

	/*
	if (levelInfo.getBackground() != 0){
	setupBackground(*levelInfo.getBackground(), load_x, load_y, load_width, load_height, infobox_x, infobox_y, infoBackground.getWidth(), infoBackground.getHeight(), infoBackground);
	} else {
	setupBackground(Graphics::Bitmap(levelInfo.loadingBackground().path()), load_x, load_y, load_width, load_height, infobox_x, infobox_y, infoBackground.getWidth(), infoBackground.getHeight(), infoBackground);
	}
	*/
	}

	Effects::Gradient & gradient;
	State & state;
	Messages & infobox;
	Graphics::Bitmap work;
	Graphics::Bitmap infoWork;
	Graphics::Bitmap infoBackground;
	vector<ppair> pairs;
	const int infobox_x;
	const int infobox_y;
	const int load_x;
	const int load_y;
	const int load_width;
	const int load_height;

	void draw(const Graphics::Bitmap & screen){
	Graphics::Bitmap work(screen, load_x, load_y, load_width, load_height);
	+ // screen.lock(load_x, load_y, load_width, load_height);
	+ /* bug in allegro5.1: locking sub-bitmaps in opengl */
	+ work.lock();
	for (vector< ppair >::iterator it = pairs.begin(); it != pairs.end(); it++){
	Graphics::Color color = gradient.current(it->x);
	work.putPixel(it->x, it->y, color);
	}
	+ // screen.unlock();
	+ work.unlock();

	if (state.drawInfo){
	infoBackground.Blit(infoWork);

	const Font & infoFont = Font::getFont(Global::DEFAULT_FONT, 24, 24);
	/* cheesy hack to change the font size. the font
	* should store the size and change it on its own
	*/
	Font::getFont(Global::DEFAULT_FONT, 13, 13);
	infobox.draw(0, 0, infoWork, infoFont);
	Font::getFont(Global::DEFAULT_FONT, 24, 24);
	infoWork.BlitAreaToScreen(infobox_x, infobox_y);
	// infoWork.BlitToScreen();
	state.drawInfo = false;
	}
	/* work already contains the correct background */
	// work.Blit( load_x, load_y, *Bitmap::Screen );
	// work.BlitToScreen();
	work.BlitAreaToScreen(load_x, load_y);
	}
	};

	State state;
	state.drawInfo = true;
	Logic logic(context, state, gradient, infobox);
	Draw draw(levelInfo, state, infobox, gradient, load_width, load_height, infobox_width, infobox_height, load_x, load_y);

	Util::standardLoop(logic, draw);
	Graphics::resetDisplay();

	#if 0
	while (! context.done()){

	/* true if a logic loop has passed */
	bool draw = firstDraw;

	/* will be true if any new info messages appeared */
	bool drawInfo = firstDraw;
	firstDraw = false;
	if ( Global::speed_counter > 0 ){
	double think = Global::speed_counter;
	Global::speed_counter = 0;
	draw = true;

	while ( think > 0 ){
	gradient.backward();
	think -= 1;
	}

	/* if no new messages appeared this will be false */
	drawInfo = info.transferMessages(infobox);
	} else {
	Util::rest( 1 );
	}

	if (draw){
	for ( vector< ppair >::iterator it = pairs.begin(); it != pairs.end(); it++ ){
	int color = gradient.current(it->x);
	work.putPixel(it->x, it->y, color);
	}

	// counter.draw(200, 100);

	/* we might not have to draw the whole info box again if no new
	* messages appeared.
	*/
	if (drawInfo){
	infoBackground.Blit(infoWork);

	/* cheesy hack to change the font size. the font
	* should store the size and change it on its own
	*/
	Font::getFont(Global::DEFAULT_FONT, 13, 13);
	infobox.draw(0, 0, infoWork, infoFont);
	Font::getFont(Global::DEFAULT_FONT, 24, 24);
	infoWork.BlitAreaToScreen(infobox_x, infobox_y);
	}
	/* work already contains the correct background */
	// work.Blit( load_x, load_y, *Bitmap::Screen );
	work.BlitAreaToScreen(load_x, load_y);
	}
	}
	#endif
	}

	static void loadingScreenSimpleX1(LoadingContext & context, const Level::LevelInfo & levelInfo){
	class Logic: public Util::Logic {
	public:
	Logic(LoadingContext & context, int & angle, int speed):
	context(context),
	speed(speed),
	angle(angle){
	}

	LoadingContext & context;
	/* speed of rotation */
	const int speed;
	int & angle;

	double ticks(double system){
	return system / 2;
	}

	bool done(){
	return context.done();
	}

	void run(){
	angle += speed * 2;
	}
	};

	class Draw: public Util::Draw {
	public:
	Draw(int & angle, const int speed):
	original(40, 40),
	angle(angle),
	speed(speed){
	original.BlitFromScreen(0, 0);

	color1 = Graphics::makeColor(0, 0, 0);
	color2 = Graphics::makeColor(0x00, 0x99, 0xff);
	color3 = Graphics::makeColor(0xff, 0x22, 0x33);
	color4 = Graphics::makeColor(0x44, 0x77, 0x33);
	colors[0] = color1;
	colors[1] = color2;
	colors[2] = color3;
	colors[3] = color4;
	Graphics::Bitmap::transBlender(0, 0, 0, 64);
	}

	Graphics::Bitmap original;
	int & angle;
	const int speed;

	Graphics::Color color1;
	Graphics::Color color2;
	Graphics::Color color3;
	Graphics::Color color4;
	/* the length of this array is the number of circles to show */
	Graphics::Color colors[4];

	~Draw(){
	}

	void draw(const Graphics::Bitmap & screen){
	Graphics::Bitmap work(screen, 0, 0, 40, 40);
	int max = sizeof(colors) / sizeof(int);
	double middleX = work.getWidth() / 2;
	double middleY = work.getHeight() / 2;
	original.Blit(work);
	for (int i = 0; i < max; i++){
	double x = cos(Util::radians(angle + 360 / max * i)) * 15;
	double y = sin(Util::radians(angle + 360 / max * i)) * 15;
	/* ghost circle */
	work.translucent().circleFill(middleX + x, middleY + y, 2, colors[i]);
	x = cos(Util::radians(angle + speed + 360 / max * i)) * 15;
	y = sin(Util::radians(angle + speed + 360 / max * i)) * 15;
	/* real circle */
	work.circleFill(middleX + x, middleY + y, 2, colors[i]);
	}
	work.BlitAreaToScreen(0, 0);
	}
	};

	int angle = 0;
	int speed = 7;
	Logic logic(context, angle, speed);
	Draw draw(angle, speed);
	Util::standardLoop(logic, draw);

	#if 0
	while (! context.done()){
	bool draw = false;

	if (Global::speed_counter > 0){
	double think = Global::speed_counter;
	Global::speed_counter = 0;
	draw = true;

	while (think > 0){
	angle += speed;
	think -= 1;
	}
	} else {
	Util::rest(1);
	}

	if (draw){
	int max = sizeof(colors) / sizeof(int);
	double middleX = work.getWidth() / 2;
	double middleY = work.getHeight() / 2;
	original.Blit(work);
	for (int i = 0; i < max; i++){
	double x = cos(Util::radians(angle + 360 / max * i)) * 15;
	double y = sin(Util::radians(angle + 360 / max * i)) * 15;
	/* ghost circle */
	work.translucent().circleFill(middleX + x, middleY + y, 2, colors[i]);
	x = cos(Util::radians(angle + speed + 360 / max * i)) * 15;
	y = sin(Util::radians(angle + speed + 360 / max * i)) * 15;
	/* real circle */
	work.circleFill(middleX + x, middleY + y, 2, colors[i]);
	}
	work.BlitAreaToScreen(0, 0);
	}
	}
	#endif
	}

	LoadingContext::LoadingContext():
	finished(false){
	Util::Thread::initializeLock(&lock);
	}

	LoadingContext::~LoadingContext(){
	}

	void LoadingContext::doLoad(){
	this->load();
	Util::Thread::acquireLock(&lock);
	finished = true;
	Util::Thread::releaseLock(&lock);
	}

	bool LoadingContext::done(){
	bool ok = false;
	Util::Thread::acquireLock(&lock);
	ok = this->finished;
	Util::Thread::releaseLock(&lock);
	return ok;
	}

	void * LoadingContext::load_it(void * arg){
	LoadingContext * context = (LoadingContext*) arg;
	context->doLoad();
	return NULL;
	}

	static void showLoadMessage(){
	int screenX = 80;
	int screenY = 50;
	Graphics::Bitmap work(110, 50);
	work.BlitFromScreen(screenX, screenY);
	Graphics::Bitmap top(110, 50);
	top.fill(Graphics::makeColor(0, 0, 0));
	Font::getDefaultFont(25, 25).printf(10, 5, Graphics::makeColor(192, 192, 192), top, "Loading", 0);
	Graphics::Bitmap::transBlender(0, 0, 0, 200);
	top.translucent().draw(0, 0, work);
	work.BlitAreaToScreen(screenX, screenY);
	}

	void loadScreen(LoadingContext & context, const Level::LevelInfo & info, Kind kind){
	Util::Thread::Id loadingThread;
	bool created = Util::Thread::createThread(&loadingThread, NULL, (Util::Thread::ThreadFunction) LoadingContext::load_it, &context);
	if (!created){
	Global::debug(0) << "Could not create loading thread. Loading will occur in the main thread" << endl;
	showLoadMessage();
	LoadingContext::load_it(&context);
	// throw LoadException(__FILE__, __LINE__, "Could not create loader thread");
	} else {
	switch (kind){
	case Default: loadingScreen1(context, info); break;
	case SimpleCircle: loadingScreenSimpleX1(context, info); break;
	default: loadingScreen1(context, info); break;
	}

	Util::Thread::joinThread(loadingThread);
	}
	}

	}
	diff --git a/util/sdl/bitmap.cpp b/util/sdl/bitmap.cpp
	index b7d60631..1623e268 100644
	--- a/util/sdl/bitmap.cpp
	+++ b/util/sdl/bitmap.cpp
	@@ -1,1906 +1,1916 @@
	#include "../bitmap.h"
	#include "../lit_bitmap.h"
	#include "../trans-bitmap.h"
	#include "../funcs.h"
	#include "../../util/debug.h"
	#include "../system.h"
	#include "../init.h"
	#include "sprig/sprig.h"
	#include "stretch/SDL_stretch.h"
	#include <SDL.h>
	#include "image/SDL_image.h"
	#include <math.h>
	#include "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;

	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);
	}

	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);
	}

	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);
	}

	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);
	}

	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){
	+ 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, int dx, int dy, int mode, int flip, Bitmap::Filter * filter);
	static void paintown_draw_sprite_filter_ex16(SDL_Surface * dst, SDL_Surface * src, int x, int 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);
	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;
	static Bitmap * Buffer = NULL;
	+
	+BitmapData::BitmapData(SDL_Surface * surface):
	+surface(surface){
	+ 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():
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	/* TODO */
	}

	Bitmap::Bitmap(const char * data, int length):
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	SDL_RWops * ops = SDL_RWFromConstMem(data, length);
	SDL_Surface * loaded = IMG_Load_RW(ops, 1);
	if (loaded){
	- getData().setSurface(optimizedSurface(loaded));
	+ setData(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());
	}

	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap(SDL_Surface * who, bool deep_copy):
	own(NULL),
	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);
	- getData().setSurface(surface);
	+ setData(new BitmapData(surface));
	own = new int;
	*own = 1;
	} else {
	- getData().setSurface(who);
	+ setData(new BitmapData(who));
	}
	}

	Bitmap::Bitmap(int w, int h):
	mustResize(false),
	bit8MaskColor(0){
	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());
	}
	- getData().setSurface(surface);
	+ setData(new BitmapData(surface));
	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap( const char * load_file ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	internalLoadFile(load_file);
	}

	Bitmap::Bitmap( const std::string & load_file ):
	own(NULL),
	mustResize(false){
	internalLoadFile(load_file.c_str());
	}

	Bitmap::Bitmap( const char * load_file, int sx, int sy ):
	own(NULL),
	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);
	- getData().setSurface(surface);
	+ setData(new BitmapData(surface));
	own = new int;
	*own = 1;

	temp.Stretch(*this);
	}

	/* unused */
	Bitmap::Bitmap( const char * load_file, int sx, int sy, double accuracy ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(0){
	throw BitmapException(__FILE__, __LINE__, "Unimplemented constructor");
	}

	Bitmap::Bitmap( const Bitmap & copy, bool deep_copy):
	own(NULL),
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	if (deep_copy){
	- SDL_Surface * who = copy.getData().getSurface();
	+ 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);
	- getData().setSurface(surface);
	+ setData(new BitmapData(surface));
	own = new int;
	*own = 1;
	} else {
	- getData().setSurface(copy.getData().getSurface());
	+ setData(copy.getData());
	own = copy.own;
	if (own){
	*own += 1;
	}
	}
	}

	Bitmap::Bitmap( const Bitmap & copy, int sx, int sy ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	/* TODO */
	}

	Bitmap::Bitmap( const Bitmap & copy, int sx, int sy, double accuracy ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	/* TODO */
	}

	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 ):
	own(NULL),
	mustResize(false),
	bit8MaskColor(copy.bit8MaskColor){
	path = copy.getPath();
	- SDL_Surface * his = copy.getData().getSurface();
	+ 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);
	- getData().setSurface(sub);
	+ setData(new BitmapData(sub));

	own = new int;
	*own = 1;
	}

	void Bitmap::internalLoadFile(const char * path){
	this->path = path;
	SDL_Surface * loaded = IMG_Load(path);
	if (loaded){
	- getData().setSurface(optimizedSurface(loaded));
	+ setData(new BitmapData(optimizedSurface(loaded)));
	SDL_FreeSurface(loaded);
	} else {
	std::ostringstream out;
	out << "Could not load file '" << path << "'";
	throw BitmapException(__FILE__, __LINE__, out.str());
	}
	own = new int;
	*own = 1;
	}

	int Bitmap::getWidth() const {
	- if (getData().getSurface() != NULL){
	- return getData().getSurface()->w;
	+ if (getData()->getSurface() != NULL){
	+ return getData()->getSurface()->w;
	}

	return 0;
	}

	int Bitmap::getHeight() const {
	- if (getData().getSurface() != NULL){
	- return getData().getSurface()->h;
	+ if (getData()->getSurface() != NULL){
	+ return getData()->getSurface()->h;
	}

	return 0;
	}

	int getRed(int c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	SDL_GetRGB(c, &format565, &red, &green, &blue);
	return red;
	}

	int getBlue(int c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	SDL_GetRGB(c, &format565, &red, &green, &blue);
	return blue;
	}

	int getGreen(int c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	SDL_GetRGB(c, &format565, &red, &green, &blue);
	return green;
	}

	int makeColor(int red, int blue, int green){
	return 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;
	#ifndef PS3
	format565.colorkey = 0;
	format565.alpha = 255;
	#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 <<
	#ifndef PS3
	" colorkey: " << (int) screen->format->colorkey <<
	" alpha: " << (int) screen->format->alpha << std::endl;
	#else
	std::endl;
	#endif


	if (SCALE_X == 0){
	SCALE_X = width;
	}

	SCALE_X = width;

	if (SCALE_Y == 0){
	SCALE_Y = height;
	}

	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 ( Buffer != NULL ){
	delete Buffer;
	Buffer = NULL;
	}

	if (width != 0 && height != 0){
	Screen = new Bitmap(screen);
	Scaler = new Bitmap(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;
	}

	void Bitmap::shutdown(){
	delete Screen;
	Screen = NULL;
	delete Scaler;
	Scaler = NULL;
	delete Buffer;
	Buffer = 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;
	}

	Bitmap & Bitmap::operator=(const Bitmap & copy){
	releaseInternalBitmap();
	path = copy.getPath();
	- getData().setSurface(copy.getData().getSurface());
	+ setData(copy.getData());
	// own = false;
	own = copy.own;
	if (own)
	*own += 1;
	return *this;
	}

	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::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);
	+ 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 {
	- x1 = getData().clip_left;
	- y1 = getData().clip_top;
	- x2 = getData().clip_right;
	- y2 = getData().clip_bottom;
	+ x1 = getData()->clip_left;
	+ y1 = getData()->clip_top;
	+ x2 = getData()->clip_right;
	+ y2 = getData()->clip_bottom;
	}

	void Bitmap::destroyPrivateData(){
	- SDL_FreeSurface(getData().getSurface());
	}

	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 {
	/* clip it */
	- if (getData().isClipped(x, y)){
	+ if (getData()->isClipped(x, y)){
	return;
	}

	- SDL_Surface * surface = getData().getSurface();
	+ SDL_Surface * surface = getData()->getSurface();
	doPutPixel(surface, x, y, pixel, false);
	}

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

	void TranslucentBitmap::putPixelNormal(int x, int y, int color) const {
	- if (getData().isClipped(x, y)){
	+ if (getData()->isClipped(x, y)){
	return;
	}

	- SDL_Surface * surface = getData().getSurface();
	+ SDL_Surface * surface = getData()->getSurface();
	doPutPixel(surface, x, y, 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);
	+ SPG_Rect(getData()->getSurface(), x1, y1, x2, y2, color);
	}

	void TranslucentBitmap::rectangle( int x1, int y1, int x2, int y2, int 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, alpha);
	}

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

	void TranslucentBitmap::rectangleFill(int x1, int y1, int x2, int y2, int 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, alpha);
	}

	void Bitmap::circleFill(int x, int y, int radius, int color) const {
	- SPG_CircleFilled(getData().getSurface(), x, y, radius, color);
	+ SPG_CircleFilled(getData()->getSurface(), x, y, radius, 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 {
	int alpha = globalBlend.alpha;
	- SPG_CircleFilledBlend(getData().getSurface(), x, y, radius, color, alpha);
	+ SPG_CircleFilledBlend(getData()->getSurface(), x, y, radius, color, alpha);
	}

	void Bitmap::circle(int x, int y, int radius, int color) const {
	// Uint8 red, green, blue;
	// SDL_GetRGB(color, getData().getSurface()->format, &red, &green, &blue);
	// int alpha = 255;
	if (Graphics::drawingMode == MODE_SOLID){
	- SPG_Circle(getData().getSurface(), x, y, radius, color);
	+ 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);
	+ SPG_CircleBlend(getData()->getSurface(), x, y, radius, color, alpha);
	}

	// circleRGBA(getData().getSurface(), x, y, radius, red, green, blue, alpha);
	}

	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);
	+ SPG_Line(getData()->getSurface(), x1, y1, x2, y2, 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 {
	int alpha = globalBlend.alpha;
	- SPG_LineBlend(getData().getSurface(), x1, y1, x2, y2, color, alpha);
	+ SPG_LineBlend(getData()->getSurface(), x1, y1, x2, y2, 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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));
	+ if (getData()->getSurface() != NULL){
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, makeColor(255, 0, 255));

	- SDL_Surface * src = getData().getSurface();
	- SDL_Surface * dst = who.getData().getSurface();
	+ 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);
	+ 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());
	- doBlit(getData().getSurface(), mx, my, width, height, wx, wy, where);
	+ SDL_SetColorKey(getData()->getSurface(), 0, MaskColor());
	+ 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());
	+ 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());

	- doBlit(getData().getSurface(),mx, my, width, height, wx, wy, where);
	+ 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());
	+ SDL_Flip(Screen->getData()->getSurface());
	}
	}

	void Bitmap::BlitToScreen(const int upper_left_x, const int upper_left_y) const {
	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 );
	}

	/*
	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 {
	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 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::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 {

	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();
	+ 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 {
	/* TODO */
	}

	void Bitmap::triangle( int x1, int y1, int x2, int y2, int x3, int y3, int color ) const {

	if (Graphics::drawingMode == MODE_SOLID){
	- SPG_TrigonFilled(getData().getSurface(), x1, y1, x2, y2, x3, y3, color);
	+ 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);
	+ 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 {
	if (Graphics::drawingMode == MODE_SOLID){
	- SPG_Ellipse(getData().getSurface(), x, y, rx, ry, color);
	+ 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);
	+ SPG_EllipseBlend(getData()->getSurface(), x, y, rx, ry, color, alpha);
	}
	}

	void TranslucentBitmap::ellipse( int x, int y, int rx, int ry, int 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, alpha);
	}

	void Bitmap::ellipseFill( int x, int y, int rx, int ry, int color ) const {
	- SPG_EllipseFilled(getData().getSurface(), x, y, rx, ry, color);
	+ SPG_EllipseFilled(getData()->getSurface(), x, y, rx, ry, 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);
	+ paintown_light16(getData()->getSurface(), x, y, width, height, start_y, focus_alpha, edge_alpha, focus_color, edge_color);
	}

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

	void Bitmap::floodfill( const int x, const int y, const int color ) const {
	- SPG_FloodFill(getData().getSurface(), x, y, color);
	+ SPG_FloodFill(getData()->getSurface(), x, y, 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);
	+ SPG_LineH(getData()->getSurface(), x1, y, x2, color);
	}

	void TranslucentBitmap::hLine( const int x1, const int y, const int x2, const int color ) const {
	int alpha = globalBlend.alpha;
	- SPG_LineHBlend(getData().getSurface(), x1, y, x2, color, alpha);
	+ SPG_LineHBlend(getData()->getSurface(), x1, y, x2, 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);
	+ SPG_LineV(getData()->getSurface(), x, y1, y2, color);
	}

	void Bitmap::polygon( const int * verts, const int nverts, const int 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);
	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);
	+ SPG_Arc(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 int color ) const {
	- SPG_ArcFilled(getData().getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color);
	+ SPG_ArcFilled(getData()->getSurface(), x, y, radius, toDegrees(ang1 + arcPhase), toDegrees(ang2 + arcPhase), color);
	}

	void TranslucentBitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int 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, alpha);
	}

	void TranslucentBitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const int 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, alpha);
	}

	void Bitmap::fill(int 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);
	}

	/*
	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 {
	/* TODO */
	}

	void Bitmap::drawRotate( const int x, const int y, const int angle, const Bitmap & where ){
	- SDL_SetColorKey(getData().getSurface(), SDL_SRCCOLORKEY, MaskColor());
	- SDL_Surface * src = getData().getSurface();
	- SDL_Surface * dst = where.getData().getSurface();
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor());
	+ SDL_Surface * src = getData()->getSurface();
	+ SDL_Surface * dst = where.getData()->getSurface();
	SPG_TransformX(src, dst, angle, 1, 1, 0, 0, x, y, SPG_TCOLORKEY);
	}

	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_Surface * src = getData().getSurface();
	- SDL_Surface * dst = where.getData().getSurface();
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor());
	+ SDL_Surface * src = getData()->getSurface();
	+ SDL_Surface * dst = where.getData()->getSurface();
	SPG_TransformX(src, dst, 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_Surface * src = getData().getSurface();
	- SDL_Surface * dst = where.getData().getSurface();
	+ SDL_SetColorKey(getData()->getSurface(), SDL_SRCCOLORKEY, MaskColor());
	+ 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(int original, int replaced){
	- paintown_replace16(getData().getSurface(), original, replaced);
	+ paintown_replace16(getData()->getSurface(), original, replaced);
	}

	Bitmap 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 * display = optimizedSurface(pcx);
	Bitmap out(display, true);

	#ifndef PS3
	if (pcx->format->BitsPerPixel == 8){
	SDL_Color color = pcx->format->palette->colors[pcx->format->colorkey];
	int bad = makeColor(color.r, color.g, color.b);
	out.set8BitMaskColor(bad);
	// int mask = MaskColor();
	// out.replaceColor(bad, mask);
	}
	#endif

	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);
	+ return SPG_GetPixel(getData()->getSurface(), x, y);
	}

	void Bitmap::readLine( std::vector< int > & 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	+ 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);
	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);
	}

	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 ((int) 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, int dx, int 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*/ ) {
	int 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);
	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);
	} else {
	(Uint16 )destLine = mask;
	}
	}
	}

	if (SDL_MUSTLOCK(dst)){
	SDL_UnlockSurface(dst);
	}
	}

	static void paintown_draw_sprite_ex16(SDL_Surface * dst, SDL_Surface * 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 (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*/ ) {
	int 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);
	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);
	} 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);
	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);
	(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);
	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);
	(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];
	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);

	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];

	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/sdl/bitmap.h b/util/sdl/bitmap.h
	index 37a02b03..278cea9c 100644
	--- a/util/sdl/bitmap.h
	+++ b/util/sdl/bitmap.h
	@@ -1,40 +1,44 @@
	struct SDL_Surface;

	namespace Graphics{
	struct BitmapData{
	BitmapData():
	surface(0),
	clip_left(0),
	clip_right(0),
	clip_top(0),
	clip_bottom(0){}

	+ 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;
	};

	typedef int Color;
	}

	#include "../software-renderer/bitmap.h"
	diff --git a/util/stretch-bitmap.h b/util/stretch-bitmap.h
	index 7780cd96..8d7dcb87 100644
	--- a/util/stretch-bitmap.h
	+++ b/util/stretch-bitmap.h
	@@ -1,33 +1,34 @@
	#ifndef _paintown_stretch_bitmap_h
	#define _paintown_stretch_bitmap_h

	#include "bitmap.h"

	namespace Graphics{

	class StretchedBitmap: public Bitmap {
	public:
	StretchedBitmap(int width, int height, const Bitmap & where);
	void finish();
	void start();
	virtual int getWidth() const;
	virtual int getHeight() const;
	protected:
	double width;
	double height;
	double scale_x, scale_y;
	const Bitmap & where;
	};

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

	}

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 10:50 AM (3 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 68539
Default Alt Text: (265 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions