No OneTemporary
Actions

Authored By

Unknown

Size

157 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/file-system.cpp b/util/file-system.cpp
	index 8cacd6a5..8f2e41df 100644
	--- a/util/file-system.cpp
	+++ b/util/file-system.cpp
	@@ -1,1861 +1,1876 @@
	#ifdef USE_ALLEGRO
	#include <allegro.h>

	/* FIXME: replace with <winalleg.h> */
	#ifdef _WIN32
	#define BITMAP dummyBITMAP
	#include <windows.h>
	#undef BITMAP
	#endif

	#endif
	#include <algorithm>
	#include "funcs.h"
	#include "file-system.h"
	#include "thread.h"
	#include "system.h"
	#include "utf.h"
	// #include "globals.h"
	#include <dirent.h>
	#include <sstream>
	#include <exception>
	#include <string>
	#include <fstream>
	#include <ostream>
	#include "token.h"

	#include "zip/unzip.h"
	#include "zip/ioapi.h"

	#include "7z/7zFile.h"
	#include "7z/7z.h"
	#include "7z/7zAlloc.h"
	#include "7z/7zCrc.h"

	#ifndef USE_ALLEGRO
	/* some sfl symbols conflict with allegro */
	#include "sfl/sfl.h"
	#include "sfl/sfldir.h"
	#endif

	#ifdef _WIN32
	#define _WIN32_IE 0x400
	#include <shlobj.h>
	#endif

	using namespace std;

	/* some filesystem access can only be done by one thread at a time. specifically, sfl
	* has its own allocator that is meant to be used in a single-threaded manner.
	* rather than try to add locks to sfl we just wrap all sfl calls with a lock.
	*
	* initialize() must be called to initialize this lock
	*/
	// Util::Thread::Lock lock;



	namespace Path{

	/* remove extra path separators (/) */
	string sanitize(string path){
	size_t double_slash = path.find("//");
	while (double_slash != string::npos){
	path.erase(double_slash, 1);
	double_slash = path.find("//");
	}

	/* Remove /./ from paths because its redundant */
	size_t useless = path.find("/./");
	while (useless != string::npos){
	path.erase(useless, 2);
	useless = path.find("/./");
	}

	return path;
	}

	static string removeEndSlashes(string path){
	size_t last = path.rfind("/");
	while (path.size() > 0 && last == path.size() - 1){
	path.erase(last, 1);
	last = path.rfind("/");
	}
	return path;
	}

	static int invert(int c){
	if (c == '\\'){
	return '/';
	}
	return c;
	}

	std::string invertSlashes(string str){
	transform(str.begin(), str.end(), str.begin(), invert);
	return str;
	}

	const string & Path::path() const {
	return mypath;
	}

	const string Path::getExtension() const {
	size_t dot = mypath.rfind('.');
	if (dot == string::npos){
	return "";
	} else {
	return mypath.substr(dot + 1);
	}
	}

	bool Path::isEmpty() const {
	return mypath.empty();
	}

	Path::~Path(){
	}

	Path::Path(){
	}

	Path::Path(const std::string & path):
	mypath(sanitize(invertSlashes(path))){
	}

	Path::Path(const Path & path):
	mypath(sanitize(invertSlashes(path.path()))){
	}

	RelativePath::RelativePath(){
	}

	RelativePath::RelativePath(const std::string & path):
	Path(path){
	if (! path.empty() && path[0] == '/'){
	ostringstream out;
	out << "Relative path '" << path << "' cannot start with a /. Only absolute paths can start with /";
	throw Storage::IllegalPath(__FILE__, __LINE__, out.str());
	}
	}

	/* a/b/c/d -> b/c/d */
	std::string stripFirstDir(const std::string & str){
	if (str.find("/") != std::string::npos \|\| str.find( "\\") != std::string::npos){
	std::string temp = str;
	size_t rem = temp.find("/");
	if (rem != std::string::npos){
	return str.substr(rem+1,str.size());
	}
	rem = temp.find("\\");
	if( rem != std::string::npos ){
	return str.substr(rem+1,str.size());
	}
	}
	return str;
	}

	static vector<string> splitPath(string path){
	vector<string> all;
	if (path.size() > 0 && path[0] == '/'){
	all.push_back("/");
	}
	size_t found = path.find('/');
	while (found != string::npos){
	if (found > 0){
	all.push_back(path.substr(0, found));
	}
	path.erase(0, found + 1);
	found = path.find('/');
	}
	if (path.size() != 0){
	all.push_back(path);
	}
	return all;
	}

	static string joinPath(const vector<string> & paths){
	ostringstream out;
	bool first = true;
	for (vector<string>::const_iterator it = paths.begin(); it != paths.end(); it++){
	if (!first){
	out << '/';
	}
	out << *it;
	first = false;
	}
	return out.str();
	}

	/* a/b/c/d -> a/b/c
	* a/b/c/d/ -> a/b/c
	*/
	static string dirname(string path){
	vector<string> paths = splitPath(path);
	if (paths.size() > 1){
	paths.pop_back();
	return joinPath(paths);
	} else if (paths.size() == 1){
	if (paths[0] == "/"){
	return "/";
	}
	return ".";
	} else {
	return ".";
	}
	/*
	while (path.size() > 0 && path[path.size() - 1] == '/'){
	path.erase(path.size() - 1);
	}

	if (path.find("/") != string::npos \|\|
	path.find("\\") != string::npos){
	size_t rem = path.find_last_of("/");
	if (rem != string::npos){
	return path.substr(0, rem + 1);
	}

	rem = path.find_last_of("\\");
	if (rem != string::npos){
	return path.substr(0, rem + 1);
	}
	}

	return "";
	*/
	}

	RelativePath::RelativePath(const RelativePath & path):
	Path(path){
	}

	RelativePath RelativePath::removeFirstDirectory() const {
	return RelativePath(stripFirstDir(path()));
	}

	bool RelativePath::isFile() const {
	vector<string> paths = splitPath(path());
	return paths.size() == 1;
	}

	RelativePath RelativePath::firstDirectory() const {
	vector<string> paths = splitPath(path());
	if (paths.size() > 1){
	return RelativePath(paths[0]);
	}
	return RelativePath();
	}

	RelativePath RelativePath::getDirectory() const {
	return RelativePath(dirname(path()));
	}

	RelativePath RelativePath::getFilename() const {
	return RelativePath(stripDir(path()));
	}

	bool RelativePath::operator<(const RelativePath & path) const {
	return this->path() < path.path();
	}

	bool RelativePath::operator==(const RelativePath & path) const {
	return this->path() == path.path();
	}

	bool RelativePath::operator!=(const RelativePath & path) const {
	return !(*this == path);
	}

	RelativePath RelativePath::join(const RelativePath & him) const {
	return RelativePath(path() + "/" + him.path());
	}

	RelativePath & RelativePath::operator=(const RelativePath & copy){
	setPath(copy.path());
	return *this;
	}

	AbsolutePath::AbsolutePath(){
	}

	AbsolutePath::AbsolutePath(const std::string & path):
	Path(path){
	}

	AbsolutePath::AbsolutePath(const AbsolutePath & path):
	Path(path){
	}

	AbsolutePath & AbsolutePath::operator=(const AbsolutePath & copy){
	setPath(copy.path());
	return *this;
	}

	AbsolutePath AbsolutePath::removeFirstDirectory() const {
	return AbsolutePath(stripFirstDir(path()));
	}

	bool AbsolutePath::operator==(const AbsolutePath & path) const {
	return removeEndSlashes(this->path()) == removeEndSlashes(path.path());
	}

	bool AbsolutePath::operator!=(const AbsolutePath & path) const {
	return !(*this == path);
	}

	bool AbsolutePath::operator<(const AbsolutePath & path) const {
	return this->path() < path.path();
	}

	string AbsolutePath::firstDirectory() const {
	vector<string> paths = splitPath(path());
	if (paths.size() > 1){
	return paths[0];
	}
	return removeEndSlashes(path());
	}

	bool AbsolutePath::isFile() const {
	vector<string> paths = splitPath(path());
	return path().find("/") == string::npos;
	// paths.size() == 1;
	}

	RelativePath AbsolutePath::remove(const AbsolutePath & what) const {
	string real = path();
	real.erase(0, what.path().size());
	while (real.find("/") == 0){
	real.erase(0, 1);
	}
	return RelativePath(real);
	}

	AbsolutePath AbsolutePath::getDirectory() const {
	return AbsolutePath(dirname(path()));
	}

	AbsolutePath AbsolutePath::getFilename() const {
	return AbsolutePath(stripDir(path()));
	}

	std::string AbsolutePath::getLastComponent() const {
	if (getFilename().path() == ""){
	return stripDir(removeEndSlashes(path()));
	}
	return getFilename().path();
	}

	AbsolutePath AbsolutePath::join(const RelativePath & path) const {
	return AbsolutePath(this->path() + "/" + path.path());
	}

	InsensitivePath::InsensitivePath(const Path & what):
	Path(what){
	}

	bool InsensitivePath::operator==(const Path & path) const {
	return Util::upperCaseAll(this->path()) == Util::upperCaseAll(path.path());
	}

	std::string removeExtension(const std::string & str){
	if (str.find(".") != std::string::npos){
	return str.substr(0, str.find_last_of("."));
	}
	return str;
	}

	AbsolutePath replaceExtension(const Filesystem::AbsolutePath & input, const std::string & extension){
	return AbsolutePath(removeExtension(input.path()) + "." + extension);
	}

	/* a/b/c/d -> d */
	std::string stripDir(const std::string & str){
	if (str.find("/") != std::string::npos \|\| str.find("\\") != std::string::npos){
	std::string temp = str;
	size_t rem = temp.find_last_of( "/" );
	if (rem != std::string::npos){
	return str.substr(rem+1,str.size());
	}
	rem = temp.find_last_of( "\\" );
	if( rem != std::string::npos ){
	return str.substr(rem+1,str.size());
	}
	}
	return str;
	}

	/* a/b/c/d -> a/b/c/ */
	std::string stripFilename(const std::string & str){
	std::string temp = str;
	if( str.find( "/") != std::string::npos \|\| str.find( "\\") != std::string::npos ){
	size_t rem = temp.find_last_of( "/" );
	if( rem != std::string::npos ){
	return str.substr(0,rem+1);
	}
	rem = temp.find_last_of( "\\" );
	if( rem != std::string::npos ){
	return str.substr(0,rem+1);
	}
	}
	return "";
	}

	}

	namespace Storage{

	Exception::Exception(const std::string & where, int line, const std::string & file):
	Exc::Base(where, line),
	reason(file){
	}

	Exception::Exception(const std::string & where, int line, const Exc::Base & nested, const std::string & file):
	Exc::Base(where, line, nested),
	reason(file){
	}

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

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

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

	NotFound::NotFound(const std::string & where, int line, const std::string & file):
	Exception(where, line, file){
	}

	NotFound::NotFound(const std::string & where, int line, const Exc::Base & nested, const std::string & file):
	Exception(where, line, nested, file){
	}

	NotFound::NotFound(const NotFound & copy):
	Exception(copy){
	}

	NotFound::~NotFound() throw (){
	}

	IllegalPath::IllegalPath(const std::string & where, int line, const std::string & file):
	Exception(where, line, file){
	}

	IllegalPath::IllegalPath(const std::string & where, int line, const Exc::Base & nested, const std::string & file):
	Exception(where, line, nested, file){
	}

	IllegalPath::IllegalPath(const IllegalPath & copy):
	Exception(copy){
	}

	IllegalPath::~IllegalPath() throw(){
	}

	System::System(){
	}

	System::~System(){
	}

	vector<Filesystem::AbsolutePath> System::getFiles(const Filesystem::AbsolutePath & dataPath, const Filesystem::RelativePath & find, bool caseInsensitive){
	if (find.isFile()){
	return getFiles(dataPath, find.path(), caseInsensitive);
	}

	/* split the path into its consituent parts
	* a/b/c -> a/b and c
	* search for a/b, then search for c in the results
	*/
	Filesystem::RelativePath directory = find.getDirectory();
	Filesystem::RelativePath file = find.getFilename();

	vector<Filesystem::AbsolutePath> more = getFiles(dataPath, directory, caseInsensitive);
	vector<Filesystem::AbsolutePath> out;
	for (vector<Filesystem::AbsolutePath>::iterator it = more.begin(); it != more.end(); it++){
	Filesystem::AbsolutePath path = *it;
	/* if its not a directory then we can't keep searching */
	if (::System::isDirectory(path.path())){
	vector<Filesystem::AbsolutePath> findMore = getFiles(path, file, caseInsensitive);
	out.insert(out.end(), findMore.begin(), findMore.end());
	}
	}
	return out;
	}

	Filesystem::AbsolutePath System::findContainer(const RelativePath & dataPath){
	try{
	return find(RelativePath(dataPath.path() + ".zip"));
	} catch (const NotFound & fail){
	}

	try{
	return find(RelativePath(dataPath.path() + ".7z"));
	} catch (const NotFound & fail){
	}

	throw NotFound(dataPath.path(), __LINE__, __FILE__);
	}

	vector<Filesystem::AbsolutePath> System::getContainerFilesRecursive(const Filesystem::AbsolutePath & dataPath){
	vector<Filesystem::AbsolutePath> out;

	vector<Filesystem::AbsolutePath> zips = getFilesRecursive(dataPath, "*.zip");
	out.insert(out.end(), zips.begin(), zips.end());
	zips = getFilesRecursive(dataPath, "*.7z");
	out.insert(out.end(), zips.begin(), zips.end());

	return out;
	}

	vector<Path::AbsolutePath> System::getContainerFiles(const AbsolutePath & dataPath){
	vector<Filesystem::AbsolutePath> out;

	vector<Filesystem::AbsolutePath> zips = getFiles(dataPath, "*.zip");
	out.insert(out.end(), zips.begin(), zips.end());
	zips = getFiles(dataPath, "*.7z");
	out.insert(out.end(), zips.begin(), zips.end());

	return out;
	}

	vector<Filesystem::AbsolutePath> System::getContainerFiles(const RelativePath & path){
	vector<Filesystem::AbsolutePath> out;

	vector<Filesystem::AbsolutePath> zips = getFiles(path, Filesystem::RelativePath("*.zip"), false);
	out.insert(out.end(), zips.begin(), zips.end());
	zips = getFiles(path, Filesystem::RelativePath("*.7z"), false);
	out.insert(out.end(), zips.begin(), zips.end());

	return out;
	}

	static Util::ReferenceCount<System> self;
	System & instance(){
	if (self != NULL){
	return *self;
	}
	self = new Filesystem(Util::getDataPath2());
	return *self;
	}

	File::File(){
	}

	File::~File(){
	}

	class NormalFile: public File {
	public:
	NormalFile(const Path::AbsolutePath & path, Access mode = Read):
	path(path){
	ios_base::openmode iosMode = fstream::in;
	switch (mode){
	case Read: iosMode = fstream::in; break;
	case Write: iosMode = fstream::out; break;
	case ReadWrite: iosMode = fstream::in \| fstream::out; break;
	}

	in.open(path.path().c_str(), iosMode \| fstream::binary);
	in >> noskipws;
	}

	Token * location(){
	Token * head = new Token();
	*head << "file";
	*head << path.path();
	return head;
	}

	long getModificationTime(){
	return ::System::getModificationTime(path.path());
	}

	bool canStream(){
	return true;
	}

	long tell(){
	return in.tellg();
	}

	void reset(){
	in.clear();
	}

	off_t seek(off_t position, int whence){
	switch (whence){
	case SEEK_SET: in.seekg(position, ios::beg); break;
	case SEEK_CUR: in.seekg(position, ios::cur); break;
	case SEEK_END: in.seekg(position, ios::end); break;
	}
	return in.tellg();
	}

	bool eof(){
	return in.eof();
	}

	int getSize(){
	streampos here = in.tellg();
	in.seekg(0, ios::end);
	int length = in.tellg();
	in.seekg(here, ios::beg);
	return length;
	}

	bool good(){
	return in.good();
	}

	File & operator>>(unsigned char & c){
	in >> c;
	return *this;
	}

	int readLine(char * output, int size){
	in.read(output, size);
	return in.gcount();
	}

	~NormalFile(){
	in.close();
	}

	protected:
	const Path::AbsolutePath path;
	std::fstream in;
	};

	StringFile::StringFile(const std::string & start):
	data(start),
	stream(start){
	stream >> noskipws;
	}

	Token * StringFile::location(){
	Token * head = new Token();
	*head << "<string file>";
	return head;
	}

	long StringFile::getModificationTime(){
	/* FIXME: maybe return INT_MAX or something? */
	return 0;
	}

	void StringFile::reset(){
	/* TODO or nothing..? */
	}

	int StringFile::readLine(char * output, int size){
	stream.read(output, size);
	return stream.gcount();
	}

	bool StringFile::canStream(){
	return true;
	}

	int StringFile::getSize(){
	return data.size();
	}

	long StringFile::tell(){
	return stream.tellg();
	}

	off_t StringFile::seek(off_t position, int whence){
	switch (whence){
	case SEEK_SET: stream.seekg(position, ios::beg); break;
	case SEEK_CUR: stream.seekg(position, ios::cur); break;
	case SEEK_END: stream.seekg(position, ios::end); break;
	}
	return stream.tellg();
	}

	bool StringFile::eof(){
	return stream.eof();
	}

	bool StringFile::good(){
	return stream.good();
	}

	File & StringFile::operator>>(unsigned char & c){
	stream >> c;
	return *this;
	}

	StringFile::~StringFile(){
	}

	/* For 7z */
	class LzmaContainer{
	public:
	LzmaContainer(const string & path, const Filesystem::AbsolutePath & start):
	path(path),
	start(start){
	allocator.Alloc = SzAlloc;
	allocator.Free = SzFree;
	allocatorTemporary.Alloc = SzAllocTemp;
	allocatorTemporary.Free = SzFreeTemp;
	if (InFile_Open(&archiveStream.file, path.c_str())){
	/* Error */
	}

	FileInStream_CreateVTable(&archiveStream);
	LookToRead_CreateVTable(&lookStream, False);

	lookStream.realStream = &archiveStream.s;
	LookToRead_Init(&lookStream);

	CrcGenerateTable();

	SzArEx_Init(&database);
	int ok = SzArEx_Open(&database, &lookStream.s, &allocator, &allocatorTemporary);
	if (ok == SZ_OK){
	/* Can read files */
	UInt16 * name = NULL;
	int tempSize = 0;
	for (int index = 0; index < database.db.NumFiles; index++){
	size_t offset = 0;
	size_t outSizeProcessed = 0;
	const CSzFileItem * file = database.db.Files + index;
	size_t length;
	if (file->IsDir){
	continue;
	}
	length = SzArEx_GetFileNameUtf16(&database, index, NULL);
	if (length > tempSize){
	delete[] name;
	name = new UInt16[length];
	memset(name, 0, length);
	}

	SzArEx_GetFileNameUtf16(&database, index, name);
	files[Utf::utf16_to_utf8(name)] = index;
	}

	delete[] name;
	}
	}

	void readFile(const Path::AbsolutePath & path, unsigned char ** buffer, size_t * size){
	Path::RelativePath find(path.remove(start));
	*buffer = 0;
	*size = 0;
	if (files.find(find.path()) != files.end()){
	int index = files[find.path()];
	UInt32 block = 0;
	size_t offset = 0;
	size_t processed = 0;
	int ok = SzArEx_Extract(&database, &lookStream.s, index,
	&block, buffer, size, &offset, &processed,
	&allocator, &allocatorTemporary);
	if (ok != SZ_OK){
	Global::debug(0) << "Could not read file from 7z archive: " << path.path() << endl;
	return;
	}
	if (offset != 0){
	memmove(buffer, buffer + offset, processed);
	}

	/* The original size is the size of the block buffer, but we only care
	* about the size of the actual file.
	*/
	*size = processed;
	}
	}

	vector<string> getFiles(){
	vector<string> names;
	for (map<string, int>::iterator it = files.begin(); it != files.end(); it++){
	names.push_back(it->first);
	}
	return names;
	}

	string getPath() const {
	return path;
	}

	string getMount() const {
	return start.path();
	}

	long getModificationTime(const Path::AbsolutePath & path){
	if (files.find(path.path()) != files.end()){
	int index = files[path.path()];
	const CSzFileItem * file = database.db.Files + index;
	if (file->MTimeDefined){
	CNtfsFileTime time = file->MTime;

	/* Divide by 10 million here? */
	return (time.Low \| ((UInt64)time.High << 32)) / 10000000;

	/*
	unsigned year, mon, day, hour, min, sec;
	UInt64 v64 = (time.Low \| ((UInt64)time.High << 32)) / 10000000;
	Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
	unsigned t;
	UInt32 v;
	sec = (unsigned)(v64 % 60); v64 /= 60;
	min = (unsigned)(v64 % 60); v64 /= 60;
	hour = (unsigned)(v64 % 24); v64 /= 24;

	v = (UInt32)v64;

	const int PERIOD_4 = (4 * 365 + 1);
	const int PERIOD_100 = (PERIOD_4 * 25 - 1);
	const int PERIOD_400 = (PERIOD_100 * 4 + 1);

	year = (unsigned)(1601 + v / PERIOD_400 * 400);
	v %= PERIOD_400;

	t = v / PERIOD_100; if (t == 4) t = 3; year += t * 100; v -= t * PERIOD_100;
	t = v / PERIOD_4; if (t == 25) t = 24; year += t * 4; v -= t * PERIOD_4;
	t = v / 365; if (t == 4) t = 3; year += t; v -= t * 365;

	if (year % 4 == 0 && (year % 100 != 0 \|\| year % 400 == 0)){
	ms[1] = 29;
	}

	for (mon = 1; mon <= 12; mon++){
	unsigned s = ms[mon - 1];
	if (v < s)
	break;
	v -= s;
	}

	day = (unsigned)v + 1;
	struct tm outTime;
	memset(&outTime, 0, sizeof(outTime));
	outTime.tm_sec = sec;
	outTime.tm_min = min;
	outTime.tm_hour = hour;
	outTime.tm_mday = day;
	outTime.tm_mon = mon;
	/ * tm_year The number of years since 1900. * /
	outTime.tm_year = year - 1900;
	outTime.tm_isdst = -1;
	return mktime(&outTime);
	*/
	}
	}

	return 0;
	}

	virtual ~LzmaContainer(){
	SzArEx_Free(&database, &allocator);
	File_Close(&archiveStream.file);
	}

	string path;
	Path::AbsolutePath start;

	CFileInStream archiveStream;
	CLookToRead lookStream;
	CSzArEx database;
	ISzAlloc allocator;
	ISzAlloc allocatorTemporary;

	/* Map the filename to its index in the 7z database */
	map<string, int> files;
	};

	/* overlays:
	* add x/y.zip
	* y.zip contains
	* example.txt
	* try to read x/example.txt, goto y.zip
	* or y.zip could contain y/
	*
	* z.zip contains
	* example.txt
	*
	* how can you prevent two zip files from providing the same files?
	*/
	class ZipContainer{
	public:
	ZipContainer(const string & path, const Filesystem::AbsolutePath & start):
	path(path),
	start(start),
	locked(false){
	zipFile = unzOpen(path.c_str());
	if (zipFile == NULL){
	throw Exception(__FILE__, __LINE__, "Could not open zip file");
	}

	if (unzGoToFirstFile(zipFile) != UNZ_OK){
	throw Exception(__FILE__, __LINE__, "Could not get to first file");
	}

	do{
	char filename[1024];
	unz_file_info fileInfo;
	unzGetCurrentFileInfo(zipFile, &fileInfo, filename, sizeof(filename), NULL, 0, NULL, 0);
	files.push_back(string(filename));

	} while (unzGoToNextFile(zipFile) != UNZ_END_OF_LIST_OF_FILE);

	/*
	zlib_filefunc64_32_def functions;
	functions.open_file_func = __real_open;
	functions.tell_file_func = __real_lseek;
	functions.seek_file_func = __real_lseek;
	*/
	/*
	unzFile zip = unzOpen(path.c_str());
	unz_global_info info;
	if (unzGetGlobalInfo(zip, &info) == UNZ_OK){
	Global::debug(0) << "Entries: " << info.number_entry << std::endl;
	}

	if (unzGoToFirstFile(zip) != UNZ_OK){
	throw Exception(__FILE__, __LINE__, "Could not get to first file");
	}
	do{
	char filename[1024];
	unz_file_info fileInfo;
	unzGetCurrentFileInfo(zip, &fileInfo, filename, sizeof(filename), NULL, 0, NULL, 0);
	Global::debug(0) << "Got file " << filename << std::endl;
	Global::debug(0) << " Compressed " << fileInfo.compressed_size << " uncompressed " << fileInfo.uncompressed_size << std::endl;

	} while (unzGoToNextFile(zip) != UNZ_END_OF_LIST_OF_FILE);
	unzClose(zip);
	*/
	}

	~ZipContainer(){
	if (zipFile != NULL){
	unzClose(zipFile);
	}
	}

	string getPath() const {
	return path;
	}

	string getMount() const {
	return start.path();
	}

	long modificationTime(){
	char filename[1024];
	unz_file_info fileInfo;
	unzGetCurrentFileInfo(zipFile, &fileInfo, filename, sizeof(filename), NULL, 0, NULL, 0);
	struct tm outTime;
	memset(&outTime, 0, sizeof(outTime));
	outTime.tm_sec = fileInfo.tmu_date.tm_sec;
	outTime.tm_min = fileInfo.tmu_date.tm_min;
	outTime.tm_hour = fileInfo.tmu_date.tm_hour;
	outTime.tm_mday = fileInfo.tmu_date.tm_mday;
	outTime.tm_mon = fileInfo.tmu_date.tm_mon;
	/* tm_year The number of years since 1900. */
	outTime.tm_year = fileInfo.tmu_date.tm_year - 1900;
	outTime.tm_isdst = -1;
	return mktime(&outTime);
	}

	void findFile(const Path::AbsolutePath & file){
	Path::RelativePath find(file.remove(start));
	if (unzLocateFile(zipFile, find.path().c_str(), 2) != UNZ_OK){
	Global::debug(0) << "Could not find " << find.path() << std::endl;
	} else {
	Global::debug(1) << "Found " << find.path() << " in zip file " << path << std::endl;
	}
	}

	int currentFileSize(){
	char filename[1024];
	unz_file_info fileInfo;
	unzGetCurrentFileInfo(zipFile, &fileInfo, filename, sizeof(filename), NULL, 0, NULL, 0);
	return fileInfo.uncompressed_size;
	}

	int read(char * buffer, int size){
	// Global::debug(0) << "offset before read " << unzGetOffset(zipFile) << " tell " << unztell(zipFile) << std::endl;
	int got = unzReadCurrentFile(zipFile, buffer, size);
	// Global::debug(0) << "offset after read " << unzGetOffset(zipFile) << " tell " << unztell(zipFile) << std::endl;
	if (got <= 0){
	throw Exception(__FILE__, __LINE__, "Could not read bytes from zip");
	}
	return got;
	}

	long tell(){
	return unztell(zipFile);
	}

	void open(const Path::AbsolutePath & file){
	if (locked){
	std::ostringstream out;
	char filename[1024];
	unz_file_info fileInfo;
	unzGetCurrentFileInfo(zipFile, &fileInfo, filename, sizeof(filename), NULL, 0, NULL, 0);
	out << "Could not open zip file entry " << file.path() << " because a zip file is already open: " << filename;
	throw Exception(__FILE__, __LINE__, out.str());
	}
	findFile(file);
	if (unzOpenCurrentFile(zipFile) != UNZ_OK){
	std::ostringstream out;
	out << "Could not open zip file entry " << file.path();
	throw Exception(__FILE__, __LINE__, out.str());
	}
	locked = true;
	}

	void close(){
	unzCloseCurrentFile(zipFile);
	locked = false;
	}

	vector<string> getFiles() const {
	return files;
	}

	protected:
	/* Path to the zip file itself */
	const string path;
	/* Where overlay starts */
	const Path::AbsolutePath start;

	unzFile zipFile;
	vector<string> files;
	/* Only one file can be opened at a time, so if another file is opened
	* while locked=true then throw an error
	*/
	bool locked;
	};

	class ZipFile: public File {
	public:
	ZipFile(const Path::AbsolutePath & path, const Util::ReferenceCount<ZipContainer> & zip):
	path(path),
	zip(zip),
	atEof(false),
	position(0){
	zip->open(path);
	}

	virtual ~ZipFile(){
	zip->close();
	}

	long getModificationTime(){
	return zip->modificationTime();
	}

	Token * location(){
	Token * head = new Token();
	*head << "container";
	/* container zipfile mount-point file-inside-zip */
	*head << zip->getPath();
	*head << zip->getMount();
	*head << path.path();
	return head;
	}

	off_t seek(off_t where, int whence){
	/* It seems that minizip is not capable of seeking in a specific file in a zip
	* container so we have to re-open the file and read `position' bytes to
	* emulate the seek behavior.
	*/
	switch (whence){
	case SEEK_SET: {
	if (where >= position){
	/* Read bytes until we hit the offset */
	position += skipBytes(where - position);
	} else {
	zip->close();
	zip->open(path);
	/* re-open file and read where bytes */
	position = skipBytes(where);
	}
	break;
	}
	case SEEK_CUR: {
	position += skipBytes(where);
	break;
	}
	case SEEK_END: {
	return seek(getSize() + where, SEEK_SET);
	break;
	}
	}
	if (position > getSize()){
	position = getSize();
	}
	atEof = position == getSize();

	return position;
	}

	bool eof(){
	return atEof;
	}

	long tell(){
	return zip->tell();
	}

	void reset(){
	/* TODO or nothing..? */
	}

	bool canStream(){
	return false;
	}

	bool good(){
	/* FIXME */
	return true;
	}

	File & operator>>(unsigned char & c){
	readLine((char*) &c, 1);
	return *this;
	}

	int getSize(){
	return zip->currentFileSize();
	}

	int readLine(char * output, int size){
	try{
	int read = zip->read(output, size);
	position += read;
	return read;
	} catch (const Exception & nomore){
	atEof = true;
	return 0;
	}
	}

	protected:
	/* skips `bytes'.
	* returns number of bytes skipped (may be less than bytes)
	*/
	int skipBytes(int bytes){
	char dummy[1024];
	int total = 0;
	while (bytes > 0){
	/* Calls the zip file directly here so we don't mess up position */
	int read = zip->read(dummy, bytes > sizeof(dummy) ? sizeof(dummy) : bytes);
	total += read;
	if (read == 0){
	return total;
	}
	bytes -= read;
	}
	return total;
	}

	const Path::AbsolutePath path;
	const Util::ReferenceCount<ZipContainer> zip;
	bool atEof;
	/* keep track of bytes read so we can seek easier */
	int position;
	};

	Descriptor::Descriptor(){
	}

	Descriptor::~Descriptor(){
	}

	class ZipDescriptor: public Descriptor {
	public:
	ZipDescriptor(const Path::AbsolutePath & path, const Util::ReferenceCount<ZipContainer> & container):
	path(path),
	container(container){
	}

	Path::AbsolutePath path;
	Util::ReferenceCount<ZipContainer> container;

	using Descriptor::open;
	virtual Util::ReferenceCount<File> open(File::Access mode){
	return Util::ReferenceCount<File>(new ZipFile(path, container));
	}

	virtual ~ZipDescriptor(){
	}
	};

	/* Extracts an entire file from a 7z archive into memory */
	class LzmaFile: public File {
	public:
	LzmaFile(const Path::AbsolutePath & path, const Util::ReferenceCount<LzmaContainer> & container):
	path(path),
	container(container),
	position(0),
	memory(NULL),
	size(0){
	container->readFile(path, &memory, &size);
	}

	virtual ~LzmaFile(){
	SzFree(NULL, memory);
	}

	bool eof(){
	return position >= size;
	}

	virtual bool good(){
	return memory != NULL;
	}

	virtual int getSize(){
	return size;
	}

	virtual bool canStream(){
	return true;
	}

	virtual void reset(){
	/* nothing */
	}

	virtual long tell(){
	return position;
	}

	virtual Token * location(){
	Token * head = new Token();
	*head << "container";
	/* container zipfile mount-point file-inside-zip */
	*head << container->getPath();
	*head << container->getMount();
	*head << path.path();
	return head;

	}

	virtual long getModificationTime(){
	return container->getModificationTime(path);
	}

	virtual off_t seek(off_t position, int whence){
	switch (whence){
	case SEEK_SET: this->position = position; break;
	case SEEK_CUR: this->position += position; break;
	case SEEK_END: this->position = this->size + position; break;
	}
	if (this->position < 0){
	this->position = 0;
	}
	if (this->position > size){
	this->position = size;
	}
	return this->position;
	}

	virtual File & operator>>(unsigned char & out){
	if (this->position < size){
	out = memory[position];
	position += 1;
	}
	return *this;
	}

	virtual int readLine(char * output, int size){
	if (size > (this->size - this->position)){
	size = this->size - this->position;
	}
	memmove(output, memory + this->position, size);
	this->position += size;
	return size;
	}

	protected:
	const Path::AbsolutePath path;
	const Util::ReferenceCount<LzmaContainer> container;
	/* keep track of bytes read so we can seek easier */
	int position;

	unsigned char * memory;
	size_t size;
	};

	class LzmaDescriptor: public Descriptor {
	public:
	LzmaDescriptor(const Path::AbsolutePath & path, const Util::ReferenceCount<LzmaContainer> & container):
	path(path),
	container(container){
	}

	Path::AbsolutePath path;
	Util::ReferenceCount<LzmaContainer> container;

	using Descriptor::open;
	virtual Util::ReferenceCount<File> open(File::Access mode){
	return Util::ReferenceCount<File>(new LzmaFile(path, container));
	}

	virtual ~LzmaDescriptor(){
	}
	};

	/* Keep this updated with all the supported container types */
	bool isContainer(const Path::AbsolutePath & path){
	return path.getExtension() == "zip" \|\|
	path.getExtension() == "7z";
	}

	bool System::isDirectory(const AbsolutePath & path){
	return virtualDirectory.isDirectory(path) \|\| systemIsDirectory(path);
	}

	bool System::exists(const AbsolutePath & path){
	return virtualDirectory.exists(path) \|\| systemExists(path);
	}

	void System::overlayFile(const AbsolutePath & where, Util::ReferenceCount<LzmaContainer> container){
	virtualDirectory.addFile(where, Util::ReferenceCount<LzmaDescriptor>(new LzmaDescriptor(where, container)).convert<Descriptor>());
	}

	void System::overlayFile(const AbsolutePath & where, Util::ReferenceCount<ZipContainer> zip){
	virtualDirectory.addFile(where, Util::ReferenceCount<ZipDescriptor>(new ZipDescriptor(where, zip)).convert<Descriptor>());
	}

	void System::unoverlayFile(const AbsolutePath & where){
	virtualDirectory.removeFile(where);
	}

	vector<string> System::containerFileList(const AbsolutePath & container){
	Util::ReferenceCount<ZipContainer> zip(new ZipContainer(container.path(), Filesystem::AbsolutePath()));
	return zip->getFiles();
	}

	static bool isZipFile(const Filesystem::AbsolutePath & path){
	return path.path().find(".zip") != string::npos;
	}

	static bool is7zFile(const Filesystem::AbsolutePath & path){
	return path.path().find(".7z") != string::npos;
	}

	template <class Container>
	static void addOverlayFiles(System & system, const Filesystem::AbsolutePath & where, const Util::ReferenceCount<Container> & container){
	vector<string> files = container->getFiles();
	for (vector<string>::const_iterator it = files.begin(); it != files.end(); it++){
	string path = *it;
	Global::debug(1) << "Add overlay to " << where.join(Filesystem::RelativePath(path)).path() << std::endl;
	system.overlayFile(where.join(Filesystem::RelativePath(path)), container);
	}
	}

	void System::addOverlay(const AbsolutePath & container, const AbsolutePath & where){
	if (isZipFile(container)){
	Global::debug(1) << "Opening zip file " << container.path() << std::endl;
	addOverlayFiles(*this, where, Util::ReferenceCount<ZipContainer>(new ZipContainer(container.path(), where)));
	} else if (is7zFile(container)){
	addOverlayFiles(*this, where, Util::ReferenceCount<LzmaContainer>(new LzmaContainer(container.path(), where)));
	}
	}

	void System::removeOverlay(const AbsolutePath & container, const AbsolutePath & where){
	Util::ReferenceCount<ZipContainer> zip(new ZipContainer(container.path(), where));
	vector<string> files = zip->getFiles();
	for (vector<string>::const_iterator it = files.begin(); it != files.end(); it++){
	string path = *it;
	Global::debug(1) << "Remove overlay from " << where.join(Filesystem::RelativePath(path)).path() << std::endl;
	unoverlayFile(where.join(Filesystem::RelativePath(path)));
	}
	}

	Util::ReferenceCount<File> System::open(const AbsolutePath & path, File::Access mode){
	Util::ReferenceCount<Descriptor> descriptor = virtualDirectory.lookup(path);
	if (descriptor != NULL){
	return descriptor->open(mode);
	} else {
	return Util::ReferenceCount<File>(new NormalFile(path, mode));
	}
	}

	+std::string readFile(const Path::AbsolutePath & path){
	+ Util::ReferenceCount<Storage::File> file = Storage::instance().open(path);
	+ if (file != NULL){
	+ char * data = new char[file->getSize() + 1];
	+ file->readLine(data, file->getSize());
	+ data[file->getSize()] = 0;
	+ std::string out(data);
	+ delete[] data;
	+ return out;
	+ }
	+ std::ostringstream out;
	+ out << "Could not open file " << path.path();
	+ throw Exception(__FILE__, __LINE__, out.str());
	+}
	+
	bool hasInstance(){
	// return true;
	return self != NULL;
	}

	System & setInstance(const Util::ReferenceCount<System> & what){
	self = what;
	return *self;
	}

	/* will read upto 'length' bytes unless a null byte is seen first */
	string EndianReader::readStringX(int length){
	ostringstream out;
	uint8_t letter = readByte1();
	while (letter != 0 && length > 0){
	out << letter;
	letter = readByte1();
	length -= 1;
	}
	return out.str();
	}

	/* unconditionally reads 'length' bytes */
	std::string EndianReader::readString2(int length){
	ostringstream out;
	vector<uint8_t> bytes = readBytes(length);
	for (vector<uint8_t>::iterator it = bytes.begin(); it != bytes.end(); it++){
	char byte = *it;
	if (byte == 0){
	break;
	}
	out << *it;
	}
	return out.str();
	}

	void EndianReader::seekEnd(streamoff where){
	internal->seekEnd(where);
	}

	void EndianReader::seek(streampos where){
	internal->seek(where);
	}

	int EndianReader::position(){
	return internal->tell();
	}

	void EndianReader::readBytes(uint8_t * out, int length){
	internal->read((char*) out, length);
	}

	vector<uint8_t> EndianReader::readBytes(int length){
	vector<uint8_t> bytes;
	for (int i = 0; i < length; i++){
	uint8_t byte = 0;
	internal->read((char*) &byte, 1);
	if (internal->eof()){
	throw Eof();
	} else {
	}
	bytes.push_back(byte);
	}
	return bytes;
	}

	EndianReader::Internal::Internal(){
	}

	EndianReader::Internal::~Internal(){
	}

	bool EndianReader::StreamInternal::eof(){
	return stream.eof();
	}

	int EndianReader::StreamInternal::read(char * data, int length){
	stream.read(data, length);
	return stream.gcount();
	}

	void EndianReader::StreamInternal::seekEnd(std::streamoff where){
	stream.seekg(where, ios::end);
	}

	void EndianReader::StreamInternal::seek(std::streamoff where){
	stream.seekg(where);
	}

	int EndianReader::StreamInternal::tell(){
	return stream.tellg();
	}

	EndianReader::StreamInternal::~StreamInternal(){
	}

	bool EndianReader::FileInternal::eof(){
	return file->eof();
	}

	void EndianReader::FileInternal::seekEnd(std::streamoff where){
	file->seek(where, SEEK_END);
	}

	void EndianReader::FileInternal::seek(std::streamoff where){
	file->seek(where, SEEK_SET);
	}

	int EndianReader::FileInternal::read(char * data, int length){
	return file->readLine(data, length);
	}

	int EndianReader::FileInternal::tell(){
	return file->tell();
	}

	EndianReader::FileInternal::~FileInternal(){
	}

	}

	Filesystem::Filesystem(const AbsolutePath & path):
	dataPath(path){
	}

	#ifdef _WIN32
	Filesystem::AbsolutePath Filesystem::userDirectory(){
	ostringstream str;
	char path[MAX_PATH];
	SHGetSpecialFolderPathA(0, path, CSIDL_APPDATA, false);
	str << path << "/paintown/";
	return Filesystem::AbsolutePath(str.str());
	}

	Filesystem::AbsolutePath Filesystem::configFile(){
	ostringstream str;
	char path[MAX_PATH];
	SHGetSpecialFolderPathA(0, path, CSIDL_APPDATA, false);
	str << path << "/paintown_configuration.txt";
	return Filesystem::AbsolutePath(str.str());
	}
	#else
	Filesystem::AbsolutePath Filesystem::configFile(){
	ostringstream str;
	/* what if HOME isn't set? */
	str << getenv("HOME") << "/.paintownrc";
	return Filesystem::AbsolutePath(str.str());
	}

	Filesystem::AbsolutePath Filesystem::userDirectory(){
	ostringstream str;
	char * home = getenv("HOME");
	if (home == NULL){
	str << "/tmp/paintown";
	} else {
	str << home << "/.paintown/";
	}
	return Filesystem::AbsolutePath(str.str());
	}
	#endif

	Filesystem::AbsolutePath Filesystem::lookup(const RelativePath path){
	vector<Filesystem::AbsolutePath> places;

	#define push(x) try{ places.push_back(x); } catch (const Storage::IllegalPath & fail){ }
	push(dataPath.join(path));
	push(userDirectory().join(path));
	push(Filesystem::AbsolutePath(path.path()));
	#undef push

	/* start error stuff early */
	ostringstream out;
	out << "Cannot find " << path.path() << ". I looked in ";
	bool first = true;
	for (vector<Filesystem::AbsolutePath>::iterator it = places.begin(); it != places.end(); it++){
	const Filesystem::AbsolutePath & final = *it;
	if (exists(final)){
	return final;
	}
	if (!first){
	out << ", ";
	} else {
	first = false;
	}
	out << "'" << final.path() << "'";
	}

	// out << "Cannot find " << path.path() << ". I looked in '" << dataPath.join(path).path() << "', '" << userDirectory().join(path).path() << "', and '" << path.path() << "'";

	throw NotFound(__FILE__, __LINE__, out.str());


	#if 0
	/* first try the main data directory */
	Filesystem::AbsolutePath final = dataPath.join(path);
	if (::System::readable(final.path())){
	return final;
	}
	/* then try the user directory, like ~/.paintown */
	final = userDirectory().join(path);
	if (::System::readable(final.path())){
	return final;
	}
	/* then just look in the cwd */
	if (::System::readable(path.path())){
	return Filesystem::AbsolutePath(path.path());
	}

	ostringstream out;
	out << "Cannot find " << path.path() << ". I looked in '" << dataPath.join(path).path() << "', '" << userDirectory().join(path).path() << "', and '" << path.path() << "'";

	throw NotFound(__FILE__, __LINE__, out.str());
	#endif
	}

	Filesystem::AbsolutePath Filesystem::lookupInsensitive(const Filesystem::AbsolutePath & directory, const Filesystem::RelativePath & path){
	if (path.path() == ""){
	throw NotFound(__FILE__, __LINE__, "Given empty path to lookup");
	}
	if (path.path() == "."){
	return directory;
	}
	if (path.path() == ".."){
	return directory.getDirectory();
	}
	if (path.isFile()){
	vector<AbsolutePath> all = getFiles(directory, "*", true);
	for (vector<AbsolutePath>::iterator it = all.begin(); it != all.end(); it++){
	AbsolutePath & check = *it;
	if (InsensitivePath(check.getFilename()) == path){
	return check;
	}
	}

	ostringstream out;
	out << "Cannot find " << path.path() << " in " << directory.path();
	throw NotFound(__FILE__, __LINE__, out.str());
	} else {
	return lookupInsensitive(lookupInsensitive(directory, path.firstDirectory()), path.removeFirstDirectory());
	}
	}

	vector<Filesystem::AbsolutePath> Filesystem::findDirectoriesIn(const Filesystem::AbsolutePath & path){
	vector<Filesystem::AbsolutePath> dirs = virtualDirectory.findDirectories(path, "*", false);

	DIR * dir = opendir(path.path().c_str());
	if (dir == NULL){
	return dirs;
	}

	struct dirent * entry = readdir(dir);
	while (entry != NULL){
	if (string(entry->d_name) != "." && string(entry->d_name) != ".."){
	string total = path.path() + "/" + entry->d_name;
	if (::System::isDirectory(total)){
	dirs.push_back(AbsolutePath(total));
	}
	}
	entry = readdir(dir);
	}

	closedir(dir);

	return dirs;
	}

	vector<Filesystem::AbsolutePath> Filesystem::findDirectories(const RelativePath & path){
	typedef vector<AbsolutePath> Paths;
	Paths dirs;

	Paths main_dirs = findDirectoriesIn(dataPath.join(path));
	Paths user_dirs = findDirectoriesIn(userDirectory().join(path));
	Paths here_dirs = findDirectoriesIn(Filesystem::AbsolutePath(path.path()));

	dirs.insert(dirs.end(), main_dirs.begin(), main_dirs.end());
	dirs.insert(dirs.end(), user_dirs.begin(), user_dirs.end());
	dirs.insert(dirs.end(), here_dirs.begin(), here_dirs.end());

	return dirs;
	}

	/* a/b/c/ -> a/b/c */
	static string removeTrailingSlash(string str){
	while (str.size() > 0 && str[str.size() - 1] == '/'){
	str = str.erase(str.size() - 1);
	}
	return str;
	}

	vector<Filesystem::AbsolutePath> Filesystem::getFiles(const AbsolutePath & dataPath, const string & find, bool caseInsensitive){
	#ifdef USE_ALLEGRO
	struct al_ffblk info;
	vector<AbsolutePath> files;

	if (al_findfirst((dataPath.path() + "/" + find).c_str(), &info, FA_ALL ) != 0){
	return files;
	}
	files.push_back(AbsolutePath(dataPath.path() + "/" + string(info.name)));
	while ( al_findnext( &info ) == 0 ){
	files.push_back(AbsolutePath(dataPath.path() + "/" + string(info.name)));
	}
	al_findclose( &info );
	return files;
	#else
	Util::Thread::ScopedLock scoped(lock);
	vector<AbsolutePath> files;

	vector<AbsolutePath> more = virtualDirectory.findFiles(dataPath, find, caseInsensitive);
	files.insert(files.end(), more.begin(), more.end());

	DIRST sflEntry;
	// bool ok = open_dir(&sflEntry, removeTrailingSlash(dataPath.path()).c_str());
	bool ok = open_dir(&sflEntry, dataPath.path().c_str());
	if (!ok){
	/* sfldir.c claims that you have to call close_dir even if
	* open_dir fails but close_dir will do ASSERT(dir->dir_handle) which is sometimes
	* NULL when open_dir fails so we first check if the dir_handle is non-NULL and
	* then call close_dir.
	*/
	if (sflEntry._dir_handle != NULL){
	close_dir(&sflEntry);
	}

	return files;
	}
	while (ok){
	if (file_matches(sflEntry.file_name, find.c_str())){
	files.push_back(AbsolutePath(dataPath.path() + "/" + string(sflEntry.file_name)));
	}
	ok = read_dir(&sflEntry);
	}
	close_dir(&sflEntry);

	/*
	for (map<AbsolutePath, Util::ReferenceCount<Storage::ZipContainer> >::iterator it = overlays.begin(); it != overlays.end(); it++){
	AbsolutePath path = it->first;
	if (it->second == NULL){
	continue;
	}
	// Global::debug(0) << "Check " << path.path() << " (" << path.getDirectory().path() << ") vs directory " << dataPath.path() << " wildcard " << find << " to " << path.getFilename().path() << std::endl;
	if (path.getDirectory() == dataPath &&
	file_matches(path.getLastComponent().c_str(), find.c_str())){
	// Global::debug(0) << "Found overlay " << path.path() << " in " << dataPath.path() << " for wildcard " << find << std::endl;
	files.push_back(path);
	}
	}
	*/

	// Global::debug(0) << "Warning: Filesystem::getFiles() is not implemented yet for SDL" << endl;
	return files;
	#endif
	}

	std::vector<Filesystem::AbsolutePath> Filesystem::getFiles(const RelativePath & path, const RelativePath & find, bool caseInsensitive){
	vector<AbsolutePath> directories;
	directories.push_back(dataPath.join(path));
	directories.push_back(userDirectory().join(path));
	directories.push_back(Filesystem::AbsolutePath(path.path()));

	vector<AbsolutePath> files;
	for (vector<AbsolutePath>::iterator it = directories.begin(); it != directories.end(); it++){
	Global::debug(0) << "Search for " << find.path() << " in " << it->path() << std::endl;
	vector<AbsolutePath> found = getFiles(*it, find, caseInsensitive);
	files.insert(files.end(), found.begin(), found.end());
	}
	return files;
	}




	template <class X>
	static void append(vector<X> & destination, const vector<X> & source){
	/*
	for (typename vector<X>::const_iterator it = source.begin(); it != source.end(); it++){
	destination.push_back(*it);
	}
	*/
	copy(source.begin(), source.end(), back_insert_iterator<vector<X> >(destination));
	}

	vector<Filesystem::AbsolutePath> Filesystem::getAllDirectories(const AbsolutePath & path){
	vector<AbsolutePath> all = findDirectoriesIn(path);
	vector<AbsolutePath> final;
	append(final, all);
	for (vector<AbsolutePath>::iterator it = all.begin(); it != all.end(); it++){
	vector<AbsolutePath> more = getAllDirectories(*it);
	append(final, more);
	}
	return final;
	}

	vector<Filesystem::AbsolutePath> Filesystem::getFilesRecursive(const AbsolutePath & dataPath, const string & find, bool caseInsensitive){
	if (!exists(dataPath)){
	return vector<AbsolutePath>();
	}
	vector<AbsolutePath> directories = getAllDirectories(dataPath);
	directories.push_back(dataPath);
	vector<AbsolutePath> files;
	for (vector<AbsolutePath>::iterator it = directories.begin(); it != directories.end(); it++){
	vector<AbsolutePath> found = getFiles(*it, find, caseInsensitive);
	append(files, found);
	}
	return files;
	}

	/*
	std::string find(const std::string path){
	if (path.length() == 0){
	throw NotFound("No path given");
	}
	if (path[0] == '/'){
	string str(path);
	str.erase(0, 1);
	string out = lookup(str);
	if (System::isDirectory(out)){
	return sanitize(out + "/");
	}
	return sanitize(out);
	}
	string out = lookup(path);
	if (System::isDirectory(out)){
	return sanitize(out + "/");
	}
	return sanitize(out);
	}
	*/

	Filesystem::AbsolutePath Filesystem::find(const RelativePath & path){
	if (path.isEmpty()){
	throw NotFound(__FILE__, __LINE__, "No path given");
	}

	AbsolutePath out = lookup(path);
	if (::System::isDirectory(out.path())){
	return AbsolutePath(out.path() + "/");
	}
	return AbsolutePath(out.path());
	}

	Filesystem::AbsolutePath Filesystem::findInsensitive(const RelativePath & path){
	try{
	/* try sensitive lookup first */
	return lookup(path);
	} catch (const NotFound & fail){
	}
	/* get the base directory */
	AbsolutePath directory = lookup(path.getDirectory());
	return lookupInsensitive(directory, path.getFilename());
	}

	bool Filesystem::exists(const RelativePath & path){
	try{
	AbsolutePath absolute = find(path);
	return true;
	} catch (const NotFound & found){
	return false;
	}
	}

	bool Filesystem::systemIsDirectory(const AbsolutePath & path){
	return ::System::isDirectory(path.path());
	}

	bool Filesystem::systemExists(const AbsolutePath & path){
	return ::System::readable(path.path());
	}

	Filesystem::RelativePath Filesystem::cleanse(const AbsolutePath & path){
	string str = path.path();
	if (str.find(dataPath.path()) == 0){
	str.erase(0, dataPath.path().length());
	} else if (str.find(userDirectory().path()) == 0){
	str.erase(0, userDirectory().path().length());
	}
	return RelativePath(str);
	}
	diff --git a/util/file-system.h b/util/file-system.h
	index 85780f36..2144467b 100644
	--- a/util/file-system.h
	+++ b/util/file-system.h
	@@ -1,601 +1,603 @@
	#ifndef _paintown_file_system_h
	#define _paintown_file_system_h

	#include "exceptions/exception.h"
	#include "pointer.h"
	#include "thread.h"
	#include <string>
	#include <sstream>
	#include <vector>
	#include <map>
	#include <fstream>
	#include <stdint.h>

	class Token;
	struct stat;
	/* path utilities */
	namespace Path{
	class Path{
	public:
	const std::string & path() const;
	const std::string getExtension() const;
	bool isEmpty() const;

	virtual ~Path();

	protected:
	Path();
	Path(const std::string & path);
	Path(const Path & path);

	virtual inline void setPath(const std::string & s){
	mypath = s;
	}

	std::string mypath;
	};

	class InsensitivePath: public Path {
	public:
	InsensitivePath(const Path & what);
	bool operator==(const Path & path) const;
	};

	/* relative path should not have the leading data directory on it, just
	* the path within the paintown system.
	*/
	class RelativePath: public Path {
	public:
	explicit RelativePath();
	explicit RelativePath(const std::string & path);
	RelativePath(const RelativePath & path);

	bool operator<(const RelativePath & path) const;

	virtual RelativePath getDirectory() const;
	virtual RelativePath getFilename() const;

	RelativePath removeFirstDirectory() const;
	RelativePath firstDirectory() const;

	/* true if there are no directory parts to this path
	* foo is a file
	* bar/foo is not a file
	*/
	bool isFile() const;

	/* a/ + b/ = a/b/ */
	RelativePath join(const RelativePath & path) const;
	RelativePath & operator=(const RelativePath & copy);

	bool operator==(const RelativePath & path) const;
	bool operator!=(const RelativePath & path) const;
	};

	/* absolute paths should have the entire filesystem path on it */
	class AbsolutePath: public Path {
	public:
	explicit AbsolutePath();
	explicit AbsolutePath(const std::string & path);
	AbsolutePath(const AbsolutePath & path);
	AbsolutePath & operator=(const AbsolutePath & copy);

	bool operator<(const AbsolutePath & path) const;
	bool operator==(const AbsolutePath & path) const;
	bool operator!=(const AbsolutePath & path) const;

	/* Remove a given path from the start of this path */
	virtual RelativePath remove(const AbsolutePath & path) const;

	virtual AbsolutePath getDirectory() const;
	virtual AbsolutePath getFilename() const;

	AbsolutePath removeFirstDirectory() const;
	std::string firstDirectory() const;
	bool isFile() const;

	/* If the filename is empty then get the name of the directory.
	* a/b -> b
	* a/b/ -> b
	*
	* Otherwise (a/b/).getFilename() will be ""
	*/
	virtual std::string getLastComponent() const;

	AbsolutePath join(const RelativePath & path) const;
	};

	std::string invertSlashes(std::string str);
	std::string sanitize(std::string path);

	/* remove extension. foo.txt -> foo */
	std::string removeExtension(const std::string & str);

	/* Replace the extension on `input' with `extension'. Don't put the . on the extension,
	* so call it as replaceExtension(path, "foo")
	* instead of replaceExtension(path, ".foo")
	*/
	AbsolutePath replaceExtension(const AbsolutePath & input, const std::string & extension);

	/* basename, just get the filename and remove the directory part */
	std::string stripDir(const std::string & str);

	/* dirname, just get the directory and remove the filename part */
	std::string stripFilename(const std::string & str);
	}

	namespace Storage{
	/* sorry for the crappy abbreviation, but can't collide with the
	* Exception class here
	*/
	namespace Exc = ::Exception;

	class Exception: public Exc::Base {
	public:
	Exception(const std::string & where, int line, const std::string & file);
	Exception(const std::string & where, int line, const Exc::Base & nested, const std::string & file);
	Exception(const Exception & copy);
	virtual ~Exception() throw ();
	virtual void throwSelf() const {
	throw *this;
	}

	protected:
	virtual const std::string getReason() const;

	virtual Exc::Base * copy() const {
	return new Exception(*this);
	}

	private:
	std::string reason;
	};

	class NotFound: public Exception {
	public:
	NotFound(const std::string & where, int line, const std::string & file);
	NotFound(const std::string & where, int line, const Exc::Base & nested, const std::string & file);
	virtual ~NotFound() throw();
	NotFound(const NotFound & copy);
	virtual void throwSelf() const {
	throw *this;
	}
	protected:
	virtual Exc::Base * copy() const {
	return new NotFound(*this);
	}
	};

	class IllegalPath: public Exception {
	public:
	IllegalPath(const std::string & where, int line, const std::string & file);
	IllegalPath(const std::string & where, int line, const Exc::Base & nested, const std::string & file);
	virtual ~IllegalPath() throw();
	IllegalPath(const IllegalPath & copy);
	virtual void throwSelf() const {
	throw *this;
	}
	protected:
	virtual Exc::Base * copy() const {
	return new IllegalPath(*this);
	}
	};

	class Eof: public std::exception {
	public:
	Eof(){
	}

	virtual ~Eof() throw (){
	}
	};

	/* Abstraction for files. Should be used instead of FILE, ifstream, SDL_RWOps, anything else */
	class File{
	public:
	enum Access{
	Read,
	Write,
	ReadWrite
	};

	File();
	virtual ~File();

	/* Returns the number of bytes read */
	virtual int readLine(char * output, int size) = 0;

	/* Mostly for normal files, reset their error flags so
	* we can seek after eof
	*/
	virtual void reset() = 0;

	/* true if the underlying object can be streamed. generally
	* this should be true if the object can be kept around while other files
	* of the same type can be opened.
	* zip files aren't streamable because only one zip entry can be
	* open at a time so it must be closed as soon as possible.
	*/
	virtual bool canStream() = 0;

	virtual long getModificationTime() = 0;

	/* seek to an absolute position */
	virtual off_t seek(off_t position, int whence) = 0;

	virtual int getSize() = 0;

	virtual long tell() = 0;

	/* Returns a token that represents the path. For normal files it will just be
	* a single string containing the path -- "data/x/y/z.txt"
	* For zip files it will be (container "x/y/z.zip" "mount/point" "a.txt")
	*/
	virtual Token * location() = 0;

	/* if the file is at eof and can't read anymore */
	virtual bool eof() = 0;

	/* if the file can still be read */
	virtual bool good() = 0;

	/* read one unsigned byte */
	virtual File & operator>>(unsigned char &) = 0;
	};

	class EndianReader{
	public:
	EndianReader(const Util::ReferenceCount<Storage::File> & file){
	internal = new FileInternal(file);
	}

	EndianReader(std::ifstream & stream){
	internal = new StreamInternal(stream);
	}

	class Internal{
	public:
	Internal();
	virtual bool eof() = 0;
	virtual int read(char * data, int length) = 0;
	virtual void seekEnd(std::streamoff where) = 0;
	virtual void seek(std::streamoff where) = 0;
	virtual int tell() = 0;
	virtual ~Internal();
	};

	class StreamInternal: public Internal {
	public:
	StreamInternal(std::ifstream & stream):
	stream(stream){
	}

	virtual bool eof();
	virtual int read(char * data, int length);
	virtual void seekEnd(std::streamoff where);
	virtual void seek(std::streamoff where);
	virtual int tell();
	virtual ~StreamInternal();

	/* Yes, use a reference here */
	std::ifstream & stream;
	};

	class FileInternal: public Internal {
	public:
	FileInternal(const Util::ReferenceCount<Storage::File> & file):
	file(file){
	}

	virtual bool eof();
	virtual void seekEnd(std::streamoff where);
	virtual void seek(std::streamoff where);
	virtual int read(char * data, int length);
	virtual int tell();
	virtual ~FileInternal();

	Util::ReferenceCount<Storage::File> file;
	};

	virtual ~EndianReader(){
	}

	virtual int8_t readByte1(){
	return convert(readBytes(sizeof(int8_t)));
	}

	virtual int16_t readByte2(){
	return convert(readBytes(sizeof(int16_t)));
	}

	virtual int32_t readByte4(){
	return convert(readBytes(sizeof(int32_t)));
	}

	virtual std::string readStringX(int length);
	virtual std::string readString2(int length);
	virtual void readBytes(uint8_t * out, int length);

	virtual void seekEnd(std::streamoff where);
	virtual void seek(std::streampos where);

	virtual int position();

	protected:
	virtual int32_t convert(const std::vector<uint8_t> & bytes) = 0;

	std::vector<uint8_t> readBytes(int length);

	Util::ReferenceCount<Internal> internal;
	};

	/* combines bytes b0 b1 b2 b3 as b0 + b12^8 + b22^16 + b32^24 /
	class LittleEndianReader: public EndianReader {
	public:
	LittleEndianReader(const Util::ReferenceCount<Storage::File> & file):
	EndianReader(file){
	}

	LittleEndianReader(std::ifstream & stream):
	EndianReader(stream){
	}

	protected:
	virtual int32_t convert(const std::vector<uint8_t> & bytes){
	uint32_t out = 0;
	for (std::vector<uint8_t>::const_reverse_iterator it = bytes.rbegin(); it != bytes.rend(); it++){
	out = (out << 8) + *it;
	}
	return out;
	}
	};

	/* combines bytes b0 b1 b2 b3 as b02^24 + b12^16 + b22^8 + b3 /
	class BigEndianReader: public EndianReader {
	public:
	BigEndianReader(const Util::ReferenceCount<Storage::File> & file):
	EndianReader(file){
	}

	BigEndianReader(std::ifstream & stream):
	EndianReader(stream){
	}

	protected:
	virtual int32_t convert(const std::vector<uint8_t> & bytes){
	uint32_t out = 0;
	for (std::vector<uint8_t>::const_iterator it = bytes.begin(); it != bytes.end(); it++){
	out = (out << 8) + *it;
	}
	return out;
	}
	};

	class LzmaContainer;
	class ZipContainer;

	class StringFile: public File {
	public:
	StringFile(const std::string & start);
	virtual int readLine(char * output, int size);
	virtual bool eof();
	virtual bool good();
	virtual int getSize();
	virtual long getModificationTime();
	virtual bool canStream();
	virtual void reset();
	virtual long tell();
	virtual Token * location();
	virtual off_t seek(off_t position, int whence);
	virtual File & operator>>(unsigned char &);
	virtual ~StringFile();

	protected:
	std::string data;
	std::istringstream stream;
	};

	/* Contains information about an abstract File. */
	class Descriptor{
	public:
	Descriptor();

	virtual Util::ReferenceCount<File> open(File::Access mode) = 0;

	virtual ~Descriptor();
	};

	class Traverser;
	class Directory{
	public:
	Directory();
	virtual ~Directory();

	/* Finds any path in the given directory that matches find, files and directories */
	std::vector<Path::AbsolutePath> findFiles(const Path::AbsolutePath & dataPath, const std::string & find, bool caseInsensitive);
	/* Only finds directories */
	std::vector<Path::AbsolutePath> findDirectories(const Path::AbsolutePath & dataPath, const std::string & find, bool caseInsensitive);

	void addFile(const Path::AbsolutePath & path, const Util::ReferenceCount<Descriptor> & file);
	void removeFile(const Path::AbsolutePath & path);

	/* FIXME: maybe filenames() should just return files? */
	/* Files + directories */
	std::vector<std::string> filenames() const;
	/* Just directories */
	std::vector<std::string> directoryNames() const;

	/* Finds a file with the given path. Will not find directories.
	* Might return NULL if the path can't be found
	*/
	Util::ReferenceCount<Descriptor> lookup(const Path::AbsolutePath & path);

	/* true if the path (either file or directory) exists */
	bool exists(const Path::AbsolutePath & path);

	/* true if path is a directory */
	bool isDirectory(const Path::AbsolutePath & path);

	protected:
	void doTraverse(const Path::AbsolutePath & path, Traverser & traverser);
	void traverse(const Path::AbsolutePath & path, Traverser & traverser);

	// Util::ReferenceCount<File> doLookup(const Path::AbsolutePath & path);

	std::map<std::string, Util::ReferenceCount<Directory> > directories;
	std::map<std::string, Util::ReferenceCount<Descriptor> > files;

	Util::Thread::LockObject lock;
	};

	class System{
	public:
	System();
	virtual ~System();

	typedef Path::AbsolutePath AbsolutePath;
	typedef Path::RelativePath RelativePath;

	virtual AbsolutePath find(const RelativePath & path) = 0;
	virtual RelativePath cleanse(const AbsolutePath & path) = 0;
	virtual bool exists(const RelativePath & path) = 0;
	virtual bool exists(const AbsolutePath & path);
	virtual bool isDirectory(const AbsolutePath & path);
	virtual std::vector<AbsolutePath> getFilesRecursive(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive = false) = 0;

	/* Finds all supported container files. Currently
	* .zip
	*/
	virtual std::vector<AbsolutePath> getContainerFilesRecursive(const AbsolutePath & dataPath);
	/* Gets container files only in the specified directory */
	virtual std::vector<AbsolutePath> getContainerFiles(const AbsolutePath & dataPath);

	/* Gets container files in <user>/path ./path and <data>/path */
	virtual std::vector<AbsolutePath> getContainerFiles(const RelativePath & path);

	/* Given a path with no extension, find a container file that is <name>.zip or
	* <name>.7z or whatever exists.
	* So if dataPath is "mugen/foo" this function will look for
	* mugen/foo.zip
	* mugen/foo.7z
	* mugen/foo.rar
	* ...
	*
	* and return the first one it finds
	*/
	virtual AbsolutePath findContainer(const RelativePath & dataPath);

	/* search for a pattern of a single file within a directory */
	virtual std::vector<AbsolutePath> getFiles(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive = false) = 0;

	/* Container should be a path to a zip file */
	virtual void addOverlay(const AbsolutePath & container, const AbsolutePath & where);
	virtual void removeOverlay(const AbsolutePath & container, const AbsolutePath & where);
	virtual std::vector<std::string> containerFileList(const AbsolutePath & container);

	/* search for some path which may contain wildcards in a directory */
	virtual std::vector<AbsolutePath> getFiles(const AbsolutePath & dataPath, const RelativePath & find, bool caseInsensitive);

	/* Gets all the files in all directories matched by the relative path */
	virtual std::vector<AbsolutePath> getFiles(const RelativePath & dataPath, const RelativePath & find, bool caseInsensitive) = 0;

	virtual AbsolutePath configFile() = 0;
	virtual AbsolutePath userDirectory() = 0;
	virtual std::vector<AbsolutePath> findDirectories(const RelativePath & path) = 0;
	virtual AbsolutePath findInsensitive(const RelativePath & path) = 0;
	virtual AbsolutePath lookupInsensitive(const AbsolutePath & directory, const RelativePath & path) = 0;

	virtual Util::ReferenceCount<File> open(const AbsolutePath & path, File::Access mode = File::Read);

	/* Should be protected but needs to be public so we can use it in template methods
	* in the implementation file.
	*/
	public:
	virtual void overlayFile(const AbsolutePath & where, Util::ReferenceCount<ZipContainer> zip);
	virtual void overlayFile(const AbsolutePath & where, Util::ReferenceCount<LzmaContainer> container);
	protected:
	virtual bool systemExists(const AbsolutePath & path) = 0;
	virtual bool systemIsDirectory(const AbsolutePath & path) = 0;

	virtual void unoverlayFile(const AbsolutePath & where);

	// std::map<AbsolutePath, Util::ReferenceCount<ZipContainer> > overlays;
	Storage::Directory virtualDirectory;
	};

	System & instance();
	bool hasInstance();
	System & setInstance(const Util::ReferenceCount<System> & what);
	bool isContainer(const Path::AbsolutePath & path);
	+
	+ std::string readFile(const Path::AbsolutePath & path);
	}

	/*
	* class Filesystem
	* class NetworkStorage
	* class ZipStorage
	*/
	class Filesystem: public Storage::System {
	public:
	Filesystem(const Path::AbsolutePath & dataPath);

	typedef Path::AbsolutePath AbsolutePath;
	typedef Path::RelativePath RelativePath;
	typedef Path::InsensitivePath InsensitivePath;
	typedef Storage::Exception Exception;
	typedef Storage::NotFound NotFound;

	/* given a relative path like sounds/arrow.png, prepend the proper
	* data path to it to give data/sounds/arrow.png
	*/
	AbsolutePath find(const RelativePath & path);

	/* like `find' but ignores case */
	AbsolutePath findInsensitive(const RelativePath & path);

	/* findInsensitive but starts in the given absolute directory path */
	AbsolutePath lookupInsensitive(const AbsolutePath & directory, const RelativePath & path);

	// void initialize();

	/* whether the file exists at all */
	using System::exists;
	bool exists(const RelativePath & path);

	/* remove the data path from a string
	* data/sounds/arrow.png -> sounds/arrow.png
	*/
	RelativePath cleanse(const AbsolutePath & path);

	/* returns all the directories starting with the given path.
	* will look in the main data directory, the user directory, and
	* the current working directory.
	*/
	std::vector<AbsolutePath> findDirectories(const RelativePath & path);

	/* user specific directory to hold persistent data */
	AbsolutePath userDirectory();

	/* user specific path to store the configuration file */
	AbsolutePath configFile();

	using Storage::System::getFiles;
	/* search a directory for some files matching pattern `find' */
	virtual std::vector<AbsolutePath> getFiles(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive = false);
	virtual std::vector<AbsolutePath> getFiles(const RelativePath & dataPath, const RelativePath & find, bool caseInsensitive);

	/* same as getFiles but search directories recursively */
	std::vector<AbsolutePath> getFilesRecursive(const AbsolutePath & dataPath, const std::string & find, bool caseInsensitive = false);

	protected:
	virtual bool systemExists(const AbsolutePath & path);
	virtual bool systemIsDirectory(const AbsolutePath & path);
	AbsolutePath lookup(const RelativePath path);
	std::vector<AbsolutePath> findDirectoriesIn(const AbsolutePath & path);
	std::vector<AbsolutePath> getAllDirectories(const AbsolutePath & path);

	protected:
	Util::Thread::LockObject lock;
	AbsolutePath dataPath;
	};

	#endif
	diff --git a/util/graphics/allegro5/bitmap.cpp b/util/graphics/allegro5/bitmap.cpp
	index 7870a217..ace861af 100644
	--- a/util/graphics/allegro5/bitmap.cpp
	+++ b/util/graphics/allegro5/bitmap.cpp
	@@ -1,1447 +1,1448 @@
	#include <sstream>
	#include <allegro5/allegro5.h>
	#include <allegro5/allegro_memfile.h>
	#include <allegro5/allegro_primitives.h>
	#include <allegro5/allegro_shader.h>
	#include <allegro5/allegro_shader_glsl.h>
	#include "util/debug.h"
	#include "util/thread.h"
	#include <vector>

	namespace Graphics{

	ALLEGRO_DISPLAY * the_display = NULL;
	static std::vector<ALLEGRO_SHADER*> shaders;
	static ALLEGRO_SHADER * shader_default;
	static ALLEGRO_SHADER * shader_shadow;
	static ALLEGRO_SHADER * shader_lit_sprite;

	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;

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

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

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

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

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

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

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

	class Blender{
	public:
	Blender(){
	}

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

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

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

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

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

	// static Bitmap * Scaler = NULL;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/* FIXME: get gif addon for a5 */

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

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

	ALLEGRO_BITMAP * out = NULL;

	return out;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

	return 0;
	*/
	}

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

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

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

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

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

	return 0;
	*/
	}

	void initializeExtraStuff(){
	// al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_RGB_565);
	}

	-static std::string readFile(const Filesystem::AbsolutePath & path){
	- Util::ReferenceCount<Storage::File> file = Storage::instance().open(path);
	- if (file != NULL){
	- char * data = new char[file->getSize() + 1];
	- file->readLine(data, file->getSize());
	- data[file->getSize()] = 0;
	- std::string out(data);
	- delete[] data;
	- return out;
	- }
	- return "nothing read";
	+std::string defaultVertexShader(){
	+ return std::string(al_get_default_glsl_vertex_shader());
	}

	-static ALLEGRO_SHADER * create_shader(const std::string & vertex, const std::string & pixel){
	+std::string defaultPixelShader(){
	+ return std::string(al_get_default_glsl_pixel_shader());
	+}
	+
	+void setShaderSampler(ALLEGRO_SHADER * shader, const std::string & name, const Bitmap & texture, int unit){
	+ al_set_shader(the_display, shader);
	+ al_set_shader_sampler(shader, name.c_str(), texture.getData()->getBitmap(), unit);
	+ al_set_shader(the_display, shader_default);
	+ al_use_shader(shader_default, true);
	+}
	+
	+ALLEGRO_SHADER * create_shader(const std::string & vertex, const std::string & pixel){
	ALLEGRO_SHADER * shader = al_create_shader(ALLEGRO_SHADER_GLSL);
	if (shader == NULL){
	return NULL;
	}
	if (!al_attach_shader_source(shader, ALLEGRO_VERTEX_SHADER, vertex.c_str())){
	Global::debug(0) << "attach vertex shader source failed: " << al_get_shader_log(shader) << std::endl << vertex << std::endl;
	return NULL;
	}
	if (!al_attach_shader_source(shader, ALLEGRO_PIXEL_SHADER, pixel.c_str())){
	Global::debug(0) << "attach pixel shader source failed: " << al_get_shader_log(shader) << std::endl << pixel << std::endl;
	return NULL;
	}
	if (!al_link_shader(shader)){
	Global::debug(0) << "shader al_link_shader failed: " << al_get_shader_log(shader) << std::endl;
	return NULL;
	}
	return shader;
	}

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

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

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

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

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

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

	shader_default = create_shader(al_get_default_glsl_vertex_shader(), al_get_default_glsl_pixel_shader());

	/* Default shader */
	/*
	shader_default = al_create_shader(ALLEGRO_SHADER_GLSL);
	al_attach_shader_source(shader_default, ALLEGRO_VERTEX_SHADER, al_get_default_glsl_vertex_shader());
	al_attach_shader_source(shader_default, ALLEGRO_PIXEL_SHADER, al_get_default_glsl_pixel_shader());
	if (!al_link_shader(shader_default)){
	Global::debug(0) << "default shader al_link_shader failed: " << al_get_shader_log(shader_default) << std::endl;
	return 1;
	}
	*/
	al_set_shader(the_display, shader_default);
	shaders.push_back(shader_default);
	Global::debug(0) << "Created default shader" << std::endl;

	try{
	- shader_shadow = create_shader(al_get_default_glsl_vertex_shader(), readFile(Storage::instance().find(Filesystem::RelativePath("shaders/shadow.fragment.glsl"))));
	+ shader_shadow = create_shader(al_get_default_glsl_vertex_shader(), Storage::readFile(Storage::instance().find(Filesystem::RelativePath("shaders/shadow.fragment.glsl"))));
	if (shader_shadow == NULL){
	return 1;
	}
	shaders.push_back(shader_shadow);
	Global::debug(0) << "Created shadow shader" << std::endl;
	} catch (const Filesystem::NotFound & fail){
	Global::debug(0) << "Could not load shadow shader: " << fail.getTrace() << std::endl;
	return 1;
	}

	try{
	- shader_lit_sprite = create_shader(al_get_default_glsl_vertex_shader(), readFile(Storage::instance().find(Filesystem::RelativePath("shaders/lit-sprite.fragment.glsl"))));
	+ shader_lit_sprite = create_shader(al_get_default_glsl_vertex_shader(), Storage::readFile(Storage::instance().find(Filesystem::RelativePath("shaders/lit-sprite.fragment.glsl"))));
	if (shader_lit_sprite == NULL){
	return 1;
	}
	shaders.push_back(shader_lit_sprite);
	Global::debug(0) << "Created lit sprite shader" << std::endl;
	} catch (const Filesystem::NotFound & fail){
	Global::debug(0) << "Could not load lit sprite shader: " << fail.getTrace() << std::endl;
	return 1;
	}

	return 0;
	}

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

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

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

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

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

	void Bitmap::putPixelNormal(int x, int y, Color col) const {
	putPixel(x, y, col);
	+ /*
	+ changeTarget(this, this);
	+ al_put_pixel(x, y, col.color);
	+ */
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	void Bitmap::drawHFlip(const int x, const int y, const Bitmap & where) const {
	- changeTarget(this, where);
	- MaskedBlender blender;
	- /* any source pixels with an alpha value of 0 will be masked */
	- al_draw_bitmap(getData()->getBitmap(), x, y, ALLEGRO_FLIP_HORIZONTAL);
	+ draw(x, y, NULL, where, 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);
	+ draw(x, y, filter, where, 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);
	+ draw(x, y, NULL, where, 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);
	+ draw(x, y, filter, where, 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);
	+ draw(x, y, NULL, where, ALLEGRO_FLIP_HORIZONTAL \| ALLEGRO_FLIP_VERTICAL);
	}

	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);
	+ draw(x, y, filter, where, ALLEGRO_FLIP_HORIZONTAL \| ALLEGRO_FLIP_VERTICAL);
	}

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

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

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

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

	-void Bitmap::draw(const int x, const int y, const Bitmap & where) const {
	- // TransBlender blender;
	- changeTarget(this, where);
	- MaskedBlender blender;
	- /* any source pixels with an alpha value of 0 will be masked */
	- al_draw_bitmap(getData()->getBitmap(), x, y, 0);
	-}
	-
	-void Bitmap::draw(const int x, const int y, Filter * filter, const Bitmap & where) const {
	- /* FIXME */
	+void Bitmap::draw(const int x, const int y, Filter * filter, const Bitmap & where, int flags) const {
	changeTarget(this, where);
	MaskedBlender blender;
	Util::ReferenceCount<Shader> shader;
	if (filter != NULL){
	shader = filter->getShader();
	}

	if (shader != NULL && shader->getShader() != NULL){
	ALLEGRO_SHADER * a5shader = shader->getShader();
	al_set_shader(the_display, a5shader);
	al_use_shader(a5shader, true);
	}

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

	if (shader != NULL && shader->getShader() != NULL){
	al_set_shader(the_display, shader_default);
	al_use_shader(shader_default, true);
	}
	}

	+void Bitmap::draw(const int x, const int y, const Bitmap & where) const {
	+ draw(x, y, NULL, where, 0);
	+
	+ /*
	+ // TransBlender blender;
	+ changeTarget(this, where);
	+ MaskedBlender blender;
	+ / * any source pixels with an alpha value of 0 will be masked * /
	+ al_draw_bitmap(getData()->getBitmap(), x, y, 0);
	+ */
	+}
	+
	+void Bitmap::draw(const int x, const int y, Filter * filter, const Bitmap & where) const {
	+ draw(x, y, filter, where, 0);
	+}
	+
	void Bitmap::drawShadow(Bitmap & where, int x, int y, int intensity, Color color, double scale, bool facingRight) const {
	changeTarget(this, where);
	MaskedBlender blender;
	int newHeight = fabs(scale) * getHeight();
	int flags = 0;
	if (!facingRight){
	flags \|= ALLEGRO_FLIP_HORIZONTAL;
	}
	float shadowColor[4];
	al_unmap_rgb_f(color.color, &shadowColor[0], &shadowColor[1], &shadowColor[2]);
	shadowColor[3] = (float) intensity / 255.0;
	al_set_shader(the_display, shader_shadow);
	if (!al_set_shader_float_vector(shader_shadow, "shadow", 4, shadowColor, 1)){
	/* Well.. thats not good. Did the shader source get messed up? */
	}
	al_use_shader(shader_shadow, true);
	al_draw_scaled_bitmap(getData()->getBitmap(), 0, 0, getWidth(), getHeight(), x, y - newHeight, getWidth(), newHeight, flags);
	al_set_shader(the_display, shader_default);
	al_use_shader(shader_default, true);
	}

	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.color, 1);
	}

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

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

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

	if (num_segments < 2)
	return;

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

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

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

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

	void Bitmap::arcFilled(const int x, const int y, const double ang1, const double ang2, const int radius, const Color color ) const {
	changeTarget(this, this);
	al_draw_filled_pieslice(x, y, radius, ang1 - Util::pi/2, ang2 - ang1, color.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.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.color);
	}

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

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

	void Bitmap::rectangle( int x1, int y1, int x2, int y2, Color color ) const {
	changeTarget(this, this);
	al_draw_rectangle(x1, y1, x2, y2, color.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.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.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.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.color);
	}

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

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

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

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

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

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

	void LitBitmap::draw(const int x, const int y, const Bitmap & where) const {
	changeTarget(this, where);

	// LitBlender blender(makeColorAlpha(globalBlend.red, globalBlend.green, globalBlend.blue, globalBlend.alpha));
	// TransBlender blender;
	// al_draw_bitmap(getData()->getBitmap(), x, y, 0);
	// al_draw_tinted_bitmap(getData()->getBitmap(), al_map_rgba_f(1, 0, 0, 1), x, y, 0);

	ALLEGRO_SHADER * shader = shader_lit_sprite;

	float light[4];
	Color color = makeColor(globalBlend.red, globalBlend.green, globalBlend.blue);
	al_unmap_rgb_f(color.color, &light[0], &light[1], &light[2]);
	light[3] = 1;
	float intensity = (float) globalBlend.alpha / 255.0;
	al_set_shader(the_display, shader);
	if (!al_set_shader_float_vector(shader, "light_color", 4, light, 1)){
	/* Well.. thats not good. Did the shader source get messed up? */
	}
	if (!al_set_shader_float(shader, "light_intensity", intensity)){
	}
	al_use_shader(shader, true);
	al_draw_bitmap(getData()->getBitmap(), x, y, 0);
	al_set_shader(the_display, shader_default);
	al_use_shader(shader_default, true);

	}

	static void doDrawLit(const int x, const int y, const Bitmap & who, int flags){
	MaskedBlender blender;

	ALLEGRO_SHADER * shader = shader_lit_sprite;

	float light[4];
	Color color = makeColor(globalBlend.red, globalBlend.green, globalBlend.blue);
	al_unmap_rgb_f(color.color, &light[0], &light[1], &light[2]);
	light[3] = 1;
	float intensity = (float) globalBlend.alpha / 255.0;
	al_set_shader(the_display, shader);
	if (!al_set_shader_float_vector(shader, "light_color", 4, light, 1)){
	/* Well.. thats not good. Did the shader source get messed up? */
	}
	if (!al_set_shader_float(shader, "light_intensity", intensity)){
	}
	al_use_shader(shader, true);
	al_draw_bitmap(who.getData()->getBitmap(), x, y, flags);
	al_set_shader(the_display, shader_default);
	al_use_shader(shader_default, true);
	}

	void LitBitmap::draw( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	changeTarget(this, where);

	/* FIXME: handle filter */
	doDrawLit(x, y, *this, 0);

	// LitBlender blender(makeColorAlpha(globalBlend.red, globalBlend.green, globalBlend.blue, globalBlend.alpha));
	// TransBlender blender;
	// al_draw_bitmap(getData()->getBitmap(), x, y, 0);
	// al_draw_tinted_bitmap(getData()->getBitmap(), al_map_rgba_f(1, 0, 0, 1), x, y, 0);
	}

	void LitBitmap::drawHFlip( const int x, const int y, const Bitmap & where ) const {
	changeTarget(this, where);
	doDrawLit(x, y, *this, ALLEGRO_FLIP_HORIZONTAL);
	}

	void LitBitmap::drawHFlip( const int x, const int y, Filter * filter, const Bitmap & where ) const {
	changeTarget(this, where);
	/* FIXME: handle filter */
	doDrawLit(x, y, *this, ALLEGRO_FLIP_HORIZONTAL);
	}

	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().color, x, y, 0);
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	void Bitmap::shutdown(){
	/* Make sure the display is set */
	al_set_target_bitmap(Screen->getData()->getBitmap());
	for (std::vector<ALLEGRO_SHADER*>::iterator it = shaders.begin(); it != shaders.end(); it++){
	ALLEGRO_SHADER * shader = *it;
	al_use_shader(shader, false);
	al_destroy_shader(shader);
	}

	delete Screen;
	Screen = NULL;

	al_destroy_display(the_display);
	the_display = NULL;
	/*
	delete Scaler;
	Scaler = NULL;
	delete Buffer;
	Buffer = NULL;
	*/
	}

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

	/* TODO: handle filter */
	}

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

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

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

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

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

	Bitmap * getScreenBuffer(){
	return Screen;
	}

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

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

	Shader::Shader():
	shader(NULL){
	}

	Shader::~Shader(){
	+ if (shader != NULL){
	+ al_destroy_shader(shader);
	+ }
	}

	Shader::Shader(ALLEGRO_SHADER * shader):
	shader(shader){
	}

	ALLEGRO_SHADER * Shader::getShader(){
	return shader;
	}

	}

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

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

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

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

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

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

	bool operator==(const ALLEGRO_COLOR & color1, const ALLEGRO_COLOR & color2){
	return sameColor(color1, color2);
	}
	diff --git a/util/graphics/bitmap.h b/util/graphics/bitmap.h
	index a16a3b45..ce6e14e1 100644
	--- a/util/graphics/bitmap.h
	+++ b/util/graphics/bitmap.h
	@@ -1,671 +1,684 @@
	#ifndef _paintown_bitmap_h_
	#define _paintown_bitmap_h_

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

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

	#include "color.h"

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

	namespace Storage{
	class File;
	}

	namespace Graphics{

	+class Bitmap;
	+
	class Color{
	public:
	explicit Color(const INTERNAL_COLOR & color):
	color(color){
	}

	static INTERNAL_COLOR defaultColor();

	Color():
	color(defaultColor()){
	}

	Color & operator=(const Color & him){
	this->color = him.color;
	return *this;
	}

	bool operator==(const Color & him) const {
	return color == him.color;
	}

	bool operator!=(const Color & him) const {
	return !(*this == him);
	}

	bool operator<(const Color & him) const {
	return this->color < him.color;
	}

	INTERNAL_COLOR color;
	};

	enum ImageFormat{
	FormatPNG,
	FormatBMP,
	FormatJPG,
	FormatPCX,
	FormatTGA,
	FormatTIF,
	FormatXPM,
	FormatGIF,
	FormatUnknown
	};

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

	class TranslucentBitmap;
	class LitBitmap;
	class Bitmap;

	extern Util::Parameter<Bitmap*> screenParameter;

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

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

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

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

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

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

	virtual ~BitmapException() throw () {
	}

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

	std::string reason;
	};

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

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

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

	Color MaskColor();

	enum QualityFilter{
	NoFilter,
	HqxFilter,
	XbrFilter
	};

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

	class Shader{
	public:
	Shader();
	virtual ~Shader();

	#ifdef USE_ALLEGRO5
	Shader(ALLEGRO_SHADER * shader);
	ALLEGRO_SHADER * getShader();
	ALLEGRO_SHADER * shader;
	#endif
	};

	+#ifdef USE_ALLEGRO5
	+ALLEGRO_SHADER * create_shader(const std::string & vertex, const std::string & pixel);
	+void setShaderSampler(ALLEGRO_SHADER * shader, const std::string & name, const Bitmap & texture, int unit);
	+std::string defaultVertexShader();
	+std::string defaultPixelShader();
	+#endif
	+
	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 Util::ReferenceCount<Shader> getShader() = 0;
	virtual ~Filter(){
	}
	};

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

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

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

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

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

	virtual Bitmap & operator=( const Bitmap & );

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

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

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

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

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

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

	void detach();

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

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

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

	// static void drawingMode( int type );

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

	void acquire();
	void release();

	void updateOnResize();

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

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

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

	void debugSelf() const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	virtual void fill(Color color) const;

	virtual void clear() const;

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

	bool getError();

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

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

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

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

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

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

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

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

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

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

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

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

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

	static double getScale();


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

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

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

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

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

	#ifdef USE_ALLEGRO5
	void convertToVideo();
	#endif
	protected:
	+#ifdef USE_ALLEGRO5
	+ void draw(const int x, const int y, Filter * filter, const Bitmap & where, int flags) const;
	+#endif
	/* release a reference count, and possibly destroy data */
	// void releaseInternalBitmap();

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

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

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

	void internalLoadFile( const char * load_file );

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

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

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

	protected:
	Color palette[256];
	};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	};

	}

	#endif
	diff --git a/util/graphics/software-renderer/bitmap.cpp b/util/graphics/software-renderer/bitmap.cpp
	index 25dcb6a9..35ec2a0d 100644
	--- a/util/graphics/software-renderer/bitmap.cpp
	+++ b/util/graphics/software-renderer/bitmap.cpp
	@@ -1,183 +1,187 @@
	/* generic software implementation of various bitmap operations */

	namespace Graphics{

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

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

	void Bitmap::startDrawing() const {
	}

	void Bitmap::endDrawing() const {
	}
	+
	+int getAlpha(Color input){
	+ return 255;
	+}

	void Bitmap::drawShadow(Bitmap & where, int x, int y, int intensity, Color color, double scale, bool facingRight) const {
	const double newheight = getHeight() * scale;
	Bitmap shade = temporaryBitmap(getWidth(), (int) fabs(newheight));
	Stretch(shade);

	/* Could be slow, but meh, lets do it for now to make it look like a real shadow */
	for (int h = 0; h < shade.getHeight(); ++h){
	for (int w = 0; w < shade.getWidth(); ++w){
	Color pix = shade.getPixel(w, h);
	if (pix != MaskColor()){
	shade.putPixel(w, h, color);
	}
	}
	}

	transBlender(0, 0, 0, intensity);

	if (scale > 0){
	if (facingRight){
	shade.translucent().drawVFlip(x, y, where);
	} else {
	shade.translucent().drawHVFlip(x, y, where);
	}
	} else if (scale < 0){
	y -= fabs(newheight);
	if (facingRight){
	shade.translucent().draw(x + 3, y, where);
	} else {
	shade.translucent().drawHFlip(x - 3, y, where);
	}
	}
	}

	void TranslucentBitmap::startDrawing() const {
	}

	void TranslucentBitmap::endDrawing() const {
	}

	void Bitmap::lock() const {
	}

	void Bitmap::unlock() const {
	}

	Bitmap Bitmap::scaleTo(const int width, const int height) const {
	if (width == getWidth() && height == getHeight()){
	return *this;
	}
	Bitmap scaled(width, height);
	this->Stretch(scaled);
	return scaled;
	}

	/* Filters only work for multiples of 320x240 up to 4x */
	static bool filterMultiple(int width, int height, int toWidth, int toHeight){
	return (toWidth == width * 2 && toHeight == height * 2) \|\|
	(toWidth == width * 3 && toHeight == height * 3) \|\|
	(toWidth == width * 4 && toHeight == height * 4);
	}

	static void closestMultipleSize(int width, int height, int toWidth, int toHeight, int * outWidth, int * outHeight){
	/* If we are down-scaling then we don't need any filters */
	if (toWidth < width \|\| toHeight < height){
	*outWidth = 1;
	*outHeight = 1;
	} else if (toWidth < width * 2 && toHeight < height * 2){
	*outWidth = 1;
	*outHeight = 1;
	} else if (toWidth < width * 3 && toHeight < height * 3){
	outWidth = width 2;
	outHeight = height 2;
	} else {
	outWidth = width 3;
	outHeight = height 3;
	}
	}

	StretchedBitmap::StretchedBitmap(int width, int height, const Bitmap & parent, QualityFilter filter):
	Bitmap(1, 1),
	width(1),
	height(1),
	where(parent),
	filter(filter),
	scaleToFilter(1, 1){
	if (width == parent.getWidth() && height == parent.getHeight()){
	setData(parent.getData());
	} else {
	updateSize(width, height);
	}

	if (!filterMultiple(width, height, parent.getWidth(), parent.getHeight()) &&
	filter != NoFilter){
	int multipleWidth, multipleHeight;
	closestMultipleSize(width, height, parent.getWidth(), parent.getHeight(), &multipleWidth, &multipleHeight);
	scaleToFilter.updateSize(multipleWidth, multipleHeight);
	}

	this->width = width;
	this->height = height;
	}

	void StretchedBitmap::start(){
	}

	void StretchedBitmap::finish(){
	if (getData() != where.getData()){
	switch (filter){
	case NoFilter: Stretch(where); break;
	case HqxFilter: {
	if (scaleToFilter.getWidth() > 1 &&
	scaleToFilter.getHeight() > 1){
	StretchHqx(scaleToFilter);
	scaleToFilter.Stretch(where);
	} else {
	StretchHqx(where);
	}
	break;
	}
	case XbrFilter: {
	if (scaleToFilter.getWidth() > 1 &&
	scaleToFilter.getHeight() > 1){
	StretchXbr(scaleToFilter);
	scaleToFilter.Stretch(where);
	} else {
	StretchXbr(where);
	}
	break;
	}
	}
	}
	}

	/*
	Bitmap getScreenBuffer(){
	return Bitmap(GFX_X, GFX_Y);
	}
	*/

	RestoreState::RestoreState(){
	}

	RestoreState::~RestoreState(){
	}

	TranslatedBitmap::TranslatedBitmap(int x, int y, const Bitmap & where):
	Bitmap(where),
	x(x),
	y(y){
	}

	void TranslatedBitmap::BlitToScreen() const {
	Bitmap::BlitToScreen(x, y);
	}

	TranslatedBitmap::~TranslatedBitmap(){
	}

	Shader::Shader(){
	}

	Shader::~Shader(){
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 18, 8:26 PM (1 w, 3 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71649
Default Alt Text: (157 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions