No OneTemporary
Actions

Authored By

Unknown

Size

82 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/bitmap.cpp b/util/bitmap.cpp
	index c1aa6a13..0636748e 100644
	--- a/util/bitmap.cpp
	+++ b/util/bitmap.cpp
	@@ -1,226 +1,230 @@
	#ifdef USE_ALLEGRO
	#include <allegro.h>
	#endif

	#include "bitmap.h"
	#include <string>

	/* implementation independant definitions can go here */

	Bitmap * Bitmap::temporary_bitmap = NULL;

	int Bitmap::SCALE_X = 0;
	int Bitmap::SCALE_Y = 0;
	const int Bitmap::MODE_TRANS = 0;
	const int Bitmap::MODE_SOLID = 1;

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

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

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

	static inline int max(int a, int b){
	return a > b ? a : b;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	Bitmap sub(*this, getWidth() - width, getHeight() - height, getWidth() - startWidth, getHeight() - startHeight);
	// sub.drawHFlip(x + startWidth, y + startHeight, where);
	// sub.drawHFlip(x + startWidth, y + startHeight, where);
	sub.drawHFlip(x + startWidth, y + startHeight, where);
	}

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

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

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

	return grey;
	}

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

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

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

	LitBitmap::LitBitmap(const Bitmap & b):
	Bitmap(b){
	}

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

	LitBitmap::~LitBitmap(){
	}

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

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

	TranslucentBitmap::~TranslucentBitmap(){
	}
	diff --git a/util/bitmap.h b/util/bitmap.h
	index 99772c8b..0835bc26 100644
	--- a/util/bitmap.h
	+++ b/util/bitmap.h
	@@ -1,304 +1,308 @@
	/* if you include this file then it must be the first line in file (after any
	* #ifdef's of course. windows will complain loudly if <windows.h> ends up being
	* included before allegro.h and this file fixes things so the order is correct.
	*/
	#ifndef _paintown_bitmap_h_
	#define _paintown_bitmap_h_

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

	#include <string>
	#include <vector>
	#include <iostream>

	+class TranslucentBitmap;
	+
	class Bitmap{
	private:
	static Bitmap * Screen;

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

	static int SCALE_X;
	static int SCALE_Y;

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

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

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

	Bitmap & operator=( const Bitmap & );

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

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

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

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

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

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

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

	void detach();

	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 );
	static int setGraphicsMode( int mode, int width, int height );

	static void drawingMode( int type );

	void acquire();
	void release();

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

	void debugSelf() const;

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

	virtual void triangle( int x1, int y1, int x2, int y2, int x3, int y3, int color ) const;
	virtual void ellipse( int x, int y, int rx, int ry, int color ) const;
	virtual void ellipseFill( int x, int y, int rx, int ry, int color ) const;

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

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

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

	virtual void draw(const int x, const int y, 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 drawCharacter( const int x, const int y, const int color, const int background, const Bitmap & where ) const;
	/* to draw lit use LitBitmap */
	// virtual void drawLit( const int x, const int y, const int level, const Bitmap & where ) const;
	virtual void drawHFlip(const int x, const int y, 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 drawVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawHVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawTrans( const int x, const int y, const Bitmap & where ) const;
	virtual void drawTransHFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawTransVFlip( const int x, const int y, const Bitmap & where ) const;
	virtual void drawTransHVFlip( const int x, const int y, 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 );
	virtual void drawRotate( const int x, const int y, const int angle, const Bitmap & where );
	virtual void drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const Bitmap & where );
	virtual void drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const double scale, const Bitmap & where );

	virtual void Stretch( const Bitmap & where ) const;
	virtual void Stretch( const Bitmap & where, const int sourceX, const int sourceY, const int sourceWidth, const int sourceHeight, const int destX, const int destY, const int destWidth, const int destHeight ) const;
	virtual void StretchBy2( const Bitmap & where );
	virtual void StretchBy4( const Bitmap & where );
	virtual void Blit( const std::string & xpath ) const;
	virtual void Blit( const Bitmap & where ) const;
	virtual void Blit( const int x, const int y, const Bitmap & where ) const;
	virtual void Blit( const int mx, const int my, const int wx, const int wy, const Bitmap & where ) const;
	virtual void Blit( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const;
	virtual void BlitMasked( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const;
	virtual void BlitToScreen() const;
	virtual void BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const;
	virtual void BlitToScreen(const int upper_left_x, const int upper_left_y) const;
	virtual void BlitFromScreen(const int x, const int y) const;

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

	virtual void fill( int color ) const;

	inline void clear() const{
	this->fill( 0 );
	}

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

	bool getError();

	inline const BitmapData & getData() const {
	return data;
	}

	inline BitmapData & getData(){
	return data;
	}

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

	/* uses _putpixel16 underneath which ignores translucent behavior */
	void putPixel( int x, int y, int col ) const;
	/* respects the current trans mode */
	- void putPixelNormal(int x, int y, int col) const;
	+ virtual void putPixelNormal(int x, int y, int 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;

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

	/* 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();
	static int setGfxModeText();
	static int setGfxModeFullscreen( int x, int y );
	static int setGfxModeWindowed( int x, int y );

	static int makeColor( int r, int g, int b );
	static int darken( int color, double factor );
	static void hsvToRGB( float h, float s, float v, int * r, int * g, int * b );

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

	static int getRed( int x );
	static int getBlue( int x );
	static int getGreen( int x );

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

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

	// static const int MaskColor = MASK_COLOR_16;
	static int MaskColor();
	static const int MODE_TRANS;
	static const int MODE_SOLID;

	static const int SPRITE_NO_FLIP;
	static const int SPRITE_V_FLIP;
	static const int SPRITE_H_FLIP;

	static const int SPRITE_NORMAL;
	static const int SPRITE_LIT;
	static const int SPRITE_TRANS;

	protected:

	/* release a reference count, and possibly destroy data */
	void releaseInternalBitmap();

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

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

	void internalLoadFile( const char * load_file );

	/* implementation specific data */
	BitmapData data;
	int * own;
	// bool own;
	bool error;
	std::string path;
	static Bitmap * temporary_bitmap;
	};

	#endif
	diff --git a/util/ftalleg.cpp b/util/ftalleg.cpp
	index 5c0b24aa..c6eeca77 100644
	--- a/util/ftalleg.cpp
	+++ b/util/ftalleg.cpp
	@@ -1,519 +1,526 @@
	/*
	--------------
	About
	--------------
	A Freetype wrapper for use with allegro
	Feel free to do whatever you like with this, by all means enjoy!
	Just add it to your project

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

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

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

	#ifndef FT_FONT_CPP
	#define FT_FONT_CPP

	#include "bitmap.h"

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

	#include "ftalleg.h"
	#include <iostream>
	#include <sstream>
	#include <cassert>
	#include <exception>

	namespace ftalleg{

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

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

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

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

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

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

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

	character::character() {
	}

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

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

	fontSize::~fontSize() {
	}

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

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

	//! Constructor
	freetype::freetype(const Filesystem::AbsolutePath & str, const int x, const int y ){
	//Load library
	if ( !ftLibrary ){
	FT_Init_FreeType(&ftLibrary);
	}
	instances++;
	faceLoaded = kerning = false;
	currentIndex=0;
	currentFilename="";
	faceName="";
	// currentChar = new character;
	systemName="";
	internalFix = false;

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

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

	//if(face!=NULL)FT_Done_Face(face);

	if ( instances > 0 ){
	instances--;
	}

	if ( instances == 0 ){
	FT_Done_FreeType(ftLibrary);
	}

	destroyGlyphIndex();

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

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

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

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

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

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

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

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

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

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

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

	return tempChar;
	}

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

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

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

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

	void drawOneCharacter(const character * tempChar, int & x1, int & y1, FT_UInt sizeHeight, const Bitmap & bitmap, const int & color){
	unsigned char *line = tempChar->line;
	+ int colorRed = Bitmap::getRed(color);
	+ int colorGreen = Bitmap::getGreen(color);
	+ int colorBlue = Bitmap::getBlue(color);
	for (int y = 0; y < tempChar->rows; y++){
	unsigned char *buffer = line;
	for (int x = 0; x < tempChar->width; x++){
	int col = fixColor(buffer++,tempChar->grays);

	- if ((Bitmap::getRed(col) < 50) \|\|
	- (Bitmap::getGreen(col) < 50) \|\|
	- (Bitmap::getBlue(col) < 50)){
	+ int red = Bitmap::getRed(col);
	+ int green = Bitmap::getGreen(col);
	+ int blue = Bitmap::getBlue(col);
	+
	+ if ((red < 50) \|\|
	+ (green < 50) \|\|
	+ (blue < 50)){
	continue;
	}

	- int red = Bitmap::getRed(col) * Bitmap::getRed(color) / 255;
	- int green = Bitmap::getGreen(col) * Bitmap::getGreen(color) / 255;
	- int blue = Bitmap::getBlue(col) * Bitmap::getBlue(color) / 255;
	+ red = red * colorRed / 255;
	+ green = green * colorGreen / 255;
	+ blue = blue * colorBlue / 255;

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

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

	// pixeler putter = getPutPixel();

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

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

	return faceLoaded;
	}

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

	if(FT_HAS_KERNING(face))kerning=true;
	else kerning = false;
	} else {
	faceLoaded=false;
	}

	return faceLoaded;
	}

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

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

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

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

	std::string fixedText(str.str());
	switch(alignment) {
	case ftLeft:
	rend_x=x;
	rend_y=y;
	break;
	case ftCenter:
	rend_x = x - getLength(fixedText)/2;
	rend_y=y;
	break;
	case ftRight:
	rend_x = x - getLength(fixedText);
	rend_y=y;
	break;
	default:
	rend_x=x;
	rend_y=y;
	break;
	}
	int previous = 0;
	int next = 0;
	for(unsigned int i = 0; i<fixedText.length();++i){
	if(kerning && previous && next){
	next = FT_Get_Char_Index( face, fixedText[i] );
	FT_Vector delta;
	FT_Get_Kerning( face, previous, next, FT_KERNING_DEFAULT, &delta );
	rend_x += delta.x >> 6;
	previous = next;
	}
	drawCharacter(fixedText[i],rend_x, rend_y, bmp, color);
	}
	}
	}

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


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

	return 0;
	}

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

	return max;
	}

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

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

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

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

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

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

	#endif /* FONT_BASE_CPP */
	diff --git a/util/sdl/bitmap.cpp b/util/sdl/bitmap.cpp
	index 9e4495ea..1e0ff161 100644
	--- a/util/sdl/bitmap.cpp
	+++ b/util/sdl/bitmap.cpp
	@@ -1,1343 +1,1351 @@
	#include "../bitmap.h"
	#include "../lit_bitmap.h"
	#include "../trans-bitmap.h"
	#include "../funcs.h"
	#include "sprig/sprig.h"
	#include <SDL.h>
	#include "image/SDL_image.h"
	#include <math.h>

	#include <exception>

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

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

	/* taken from allegro 4.2: src/colblend.c, _blender_trans16 */
	static inline unsigned int transBlender(unsigned int x, unsigned int y, unsigned int n){
	unsigned long result;

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

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

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

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

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

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

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

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

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

	return Bitmap::makeColor(r, g, b);
	}

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

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

	int r = iabs(redY - redX);
	int g = iabs(greenY - greenX);
	int b = iabs(blueY - blueX);
	return transBlender(Bitmap::makeColor(r, g, b), y, n);
	}

	static inline unsigned int noBlender(unsigned int a, unsigned int b, unsigned int c){
	return a;
	}

	struct BlendingData{
	BlendingData():
	red(0), green(0), blue(0), alpha(0), currentBlender(noBlender){}

	int red, green, blue, alpha;
	blender currentBlender;
	};

	static BlendingData globalBlend;
	static int drawingMode = Bitmap::MODE_SOLID;

	static int drawingAlpha(){
	switch (::drawingMode){
	case Bitmap::MODE_SOLID : return 255;
	case Bitmap::MODE_TRANS : return globalBlend.alpha;
	default : return 255;
	}
	}

	static void paintown_applyTrans16(SDL_Surface * dst, const int color);
	static void paintown_draw_sprite_ex16(SDL_Surface * dst, SDL_Surface * src, int dx, int dy, int mode, int flip );
	static void paintown_light16(SDL_Surface * dst, const int x, const int y, const int width, const int height, const int start_y, const int focus_alpha, const int edge_alpha, const int focus_color, const int edge_color);

	int Bitmap::MaskColor(){
	static int mask = makeColor(255, 0, 255);
	return mask;
	}

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

	void BitmapData::setSurface(SDL_Surface * surface){
	this->surface = surface;
	clip_left = 0;
	clip_right = surface->w - 1;
	clip_top = 0;
	clip_bottom = surface->h - 1;
	}

	Bitmap::Bitmap():
	own(NULL){
	/* TODO */
	}

	Bitmap::Bitmap(SDL_Surface * who, bool deep_copy):
	own(NULL){
	if (deep_copy){
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, who->w, who->h, SCREEN_DEPTH, 0, 0, 0, 0);
	SDL_Rect source;
	SDL_Rect destination;
	source.w = surface->w;
	source.h = surface->h;
	source.x = 0;
	source.y = 0;

	destination.w = surface->w;
	destination.h = surface->h;
	destination.x = 0;
	destination.y = 0;

	SDL_BlitSurface(who, &source, surface, &destination);
	getData().setSurface(surface);
	own = new int;
	*own = 1;
	} else {
	getData().setSurface(who);
	}
	}

	Bitmap::Bitmap(int w, int h){
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, SCREEN_DEPTH, 0, 0, 0, 0);
	if (surface == NULL){
	/* FIXME */
	throw std::exception();
	}
	getData().setSurface(surface);
	own = new int;
	*own = 1;
	}

	Bitmap::Bitmap( const char * load_file ):
	own(NULL){
	internalLoadFile(load_file);
	}

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

	Bitmap::Bitmap( const char * load_file, int sx, int sy ):
	own(NULL){
	Bitmap temp(load_file);
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, sx, sy, SCREEN_DEPTH, 0, 0, 0, 0);
	getData().setSurface(surface);
	own = new int;
	*own = 1;

	temp.Stretch(*this);
	}

	/* unused */
	Bitmap::Bitmap( const char * load_file, int sx, int sy, double accuracy ):
	own(NULL){
	throw std::exception();
	}

	Bitmap::Bitmap( const Bitmap & copy, bool deep_copy):
	own(NULL){
	if (deep_copy){
	SDL_Surface * who = copy.getData().getSurface();
	SDL_Surface * surface = SDL_CreateRGBSurface(SDL_SWSURFACE, who->w, who->h, SCREEN_DEPTH, 0, 0, 0, 0);
	SDL_Rect source;
	SDL_Rect destination;
	source.w = surface->w;
	source.h = surface->h;
	source.x = 0;
	source.y = 0;

	destination.w = surface->w;
	destination.h = surface->h;
	destination.x = 0;
	destination.y = 0;

	SDL_BlitSurface(who, &source, surface, &destination);
	getData().setSurface(surface);
	own = new int;
	*own = 1;
	} else {
	getData().setSurface(copy.getData().getSurface());
	own = copy.own;
	if (own){
	*own += 1;
	}
	}
	}

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

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

	static Uint8* computeOffset(SDL_Surface * surface, int x, int y){
	int bpp = surface->format->BytesPerPixel;
	return ((Uint8)surface->pixels) + y surface->pitch + x * bpp;
	}

	Bitmap::Bitmap( const Bitmap & copy, int x, int y, int width, int height ):
	own(NULL){
	path = copy.getPath();
	SDL_Surface * his = copy.getData().getSurface();
	if ( x < 0 )
	x = 0;
	if ( y < 0 )
	y = 0;
	if ( width > his->w )
	width = his->w;
	if ( height > his->h )
	height = his->h;

	SDL_Surface * sub = SDL_CreateRGBSurfaceFrom(computeOffset(his, x, y), width, height, SCREEN_DEPTH, his->pitch, 0, 0, 0, 0);
	getData().setSurface(sub);

	own = new int;
	*own = 1;
	}

	void Bitmap::internalLoadFile(const char * path){
	this->path = path;
	SDL_Surface * loaded = IMG_Load(path);
	if (loaded){
	getData().setSurface(SDL_DisplayFormat(loaded));
	SDL_FreeSurface(loaded);
	} else {
	/* FIXME: throw a standard bitmap exception */
	throw std::exception();
	}
	own = new int;
	*own = 1;
	}

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

	return 0;
	}

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

	return 0;
	}

	int Bitmap::getRed(int c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	SDL_GetRGB(c, Screen->getData().getSurface()->format, &red, &green, &blue);
	return red;
	}

	int Bitmap::getBlue(int c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	SDL_GetRGB(c, Screen->getData().getSurface()->format, &red, &green, &blue);
	return blue;
	}

	int Bitmap::getGreen(int c){
	Uint8 red = 0;
	Uint8 green = 0;
	Uint8 blue = 0;
	SDL_GetRGB(c, Screen->getData().getSurface()->format, &red, &green, &blue);
	return green;
	}

	int Bitmap::makeColor(int red, int blue, int green){
	return SDL_MapRGB(Screen->getData().getSurface()->format, red, blue, green);
	}

	int Bitmap::setGraphicsMode(int mode, int width, int height){
	switch (mode){
	default: {
	// case WINDOWED : {
	screen = SDL_SetVideoMode(width, height, SCREEN_DEPTH, SDL_HWSURFACE \| SDL_DOUBLEBUF);
	SDL_ShowCursor(0);
	// screen = SDL_SetVideoMode(width, height, SCREEN_DEPTH, SDL_SWSURFACE \| SDL_DOUBLEBUF);
	if (!screen){
	return 1;
	}
	break;
	}
	}

	if (SCALE_X == 0){
	SCALE_X = width;
	}
	if (SCALE_Y == 0){
	SCALE_Y = height;
	}
	if ( Screen != NULL ){
	delete Screen;
	Screen = NULL;
	}

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

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

	if (width != 0 && height != 0){
	Screen = new Bitmap(screen);
	if ( width != 0 && height != 0 && (width != SCALE_X \|\| height != SCALE_Y) ){
	Scaler = new Bitmap(width, height);
	Buffer = new Bitmap(SCALE_X, SCALE_Y);
	}
	}

	return 0;
	}

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

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

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

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

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

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

	void Bitmap::drawingMode(int type){
	::drawingMode = type;
	}

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

	void Bitmap::setClipRect( int x1, int y1, int x2, int y2 ) const {
	getData().setClip(x1, y1, x2, y2);
	SDL_Rect area;
	area.x = x1;
	area.y = y1;
	area.w = x2 - x1;
	area.h = y2 - y1;
	SDL_SetClipRect(getData().getSurface(), &area);
	}

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

	-void Bitmap::putPixel(int x, int y, int pixel) const {
	- SDL_Surface * surface = getData().getSurface();
	-
	- /* clip it */
	- if (getData().isClipped(x, y)){
	- return;
	- }
	+static void doPutPixel(SDL_Surface * surface, int x, int y, int pixel, bool translucent){

	if (SDL_MUSTLOCK(surface)){
	SDL_LockSurface(surface);
	}

	int bpp = surface->format->BytesPerPixel;
	/* Here p is the address to the pixel we want to set */
	Uint8 *p = computeOffset(surface, x, y);

	switch(bpp) {
	case 1:
	*p = pixel;
	break;

	case 2:
	- switch (::drawingMode){
	- case MODE_SOLID : {
	- (Uint16 )p = pixel;
	- break;
	- }
	- case MODE_TRANS : {
	- (Uint16 )p = globalBlend.currentBlender(pixel, (Uint16)p, globalBlend.alpha);
	- break;
	- }
	+ if (translucent){
	+ (Uint16 )p = globalBlend.currentBlender(pixel, (Uint16)p, globalBlend.alpha);
	+ } else {
	+ (Uint16 )p = pixel;
	}
	break;
	-
	case 3:
	if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
	p[0] = (pixel >> 16) & 0xff;
	p[1] = (pixel >> 8) & 0xff;
	p[2] = pixel & 0xff;
	} else {
	p[0] = pixel & 0xff;
	p[1] = (pixel >> 8) & 0xff;
	p[2] = (pixel >> 16) & 0xff;
	}
	break;
	case 4:
	(Uint32 )p = pixel;
	break;
	}

	if (SDL_MUSTLOCK(surface)){
	SDL_UnlockSurface(surface);
	}
	+
	+}
	+
	+void Bitmap::putPixel(int x, int y, int pixel) const {
	+ /* clip it */
	+ if (getData().isClipped(x, y)){
	+ return;
	+ }
	+
	+ SDL_Surface * surface = getData().getSurface();
	+ doPutPixel(surface, x, y, pixel, false);
	}

	void Bitmap::putPixelNormal(int x, int y, int col) const {
	putPixel(x, y, col);
	}
	+
	+void TranslucentBitmap::putPixelNormal(int x, int y, int color) const {
	+ if (getData().isClipped(x, y)){
	+ return;
	+ }
	+
	+ SDL_Surface * surface = getData().getSurface();
	+ doPutPixel(surface, x, y, color, true);
	+}

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

	void Bitmap::rectangle( int x1, int y1, int x2, int y2, int color ) const {
	switch (::drawingMode){
	case MODE_SOLID : {
	SPG_Rect(getData().getSurface(), x1, y1, x2, y2, color);
	break;
	}
	case MODE_TRANS : {
	int alpha = globalBlend.alpha;
	SPG_RectBlend(getData().getSurface(), x1, y1, x2, y2, color, alpha);
	break;
	}
	}
	}

	void Bitmap::rectangleFill( int x1, int y1, int x2, int y2, int color ) const {
	switch (::drawingMode){
	case MODE_SOLID : {
	SPG_RectFilled(getData().getSurface(), x1, y1, x2, y2, color);
	break;
	}
	case MODE_TRANS : {
	int alpha = globalBlend.alpha;
	SPG_RectFilledBlend(getData().getSurface(), x1, y1, x2, y2, color, alpha);
	break;
	}
	}
	}

	void Bitmap::circleFill(int x, int y, int radius, int color) const {
	switch (::drawingMode){
	case MODE_SOLID : {
	SPG_CircleFilled(getData().getSurface(), x, y, radius, color);
	break;
	}
	case MODE_TRANS : {
	int alpha = globalBlend.alpha;
	SPG_CircleFilledBlend(getData().getSurface(), x, y, radius, color, alpha);
	break;
	}
	}
	}

	void Bitmap::circle(int x, int y, int radius, int color) const {
	// Uint8 red, green, blue;
	// SDL_GetRGB(color, getData().getSurface()->format, &red, &green, &blue);
	// int alpha = 255;
	switch (::drawingMode){
	case MODE_SOLID : {
	SPG_Circle(getData().getSurface(), x, y, radius, color);
	break;
	}
	case MODE_TRANS : {
	int alpha = globalBlend.alpha;
	SPG_CircleBlend(getData().getSurface(), x, y, radius, color, alpha);
	break;
	}
	}

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

	void Bitmap::line( const int x1, const int y1, const int x2, const int y2, const int color ) const {
	switch (::drawingMode){
	case MODE_SOLID : {
	SPG_Line(getData().getSurface(), x1, y1, x2, y2, color);
	break;
	}
	case MODE_TRANS : {
	int alpha = globalBlend.alpha;
	SPG_LineBlend(getData().getSurface(), x1, y1, x2, y2, color, alpha);
	break;
	}
	}
	}

	void Bitmap::draw(const int x, const int y, const Bitmap & where) const {
	if (getData().getSurface() != NULL){
	paintown_draw_sprite_ex16(where.getData().getSurface(), getData().getSurface(), x, y, Bitmap::SPRITE_NORMAL, Bitmap::SPRITE_NO_FLIP);
	/*
	SDL_SetColorKey(getData().getSurface(), SDL_SRCCOLORKEY, makeColor(255, 0, 255));
	Blit(x, y, where);
	*/
	}
	}

	void Bitmap::drawHFlip(const int x, const int y, const Bitmap & where) const {
	paintown_draw_sprite_ex16( where.getData().getSurface(), getData().getSurface(), x, y, Bitmap::SPRITE_NORMAL, Bitmap::SPRITE_H_FLIP );
	}

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

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

	void Bitmap::drawTrans( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData().getSurface(), getData().getSurface(), x, y, Bitmap::SPRITE_TRANS, Bitmap::SPRITE_NO_FLIP);
	}

	void Bitmap::drawTransHFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData().getSurface(), getData().getSurface(), x, y, Bitmap::SPRITE_TRANS, Bitmap::SPRITE_H_FLIP);
	}

	void Bitmap::drawTransVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData().getSurface(), getData().getSurface(), x, y, Bitmap::SPRITE_TRANS, Bitmap::SPRITE_V_FLIP);
	}

	void Bitmap::drawTransHVFlip( const int x, const int y, const Bitmap & where ) const {
	paintown_draw_sprite_ex16(where.getData().getSurface(), getData().getSurface(), x, y, Bitmap::SPRITE_TRANS, SPRITE_V_FLIP \| SPRITE_H_FLIP);
	}

	void Bitmap::drawStretched( const int x, const int y, const int new_width, const int new_height, const Bitmap & who ){

	if (getData().getSurface() != NULL){
	SDL_SetColorKey(getData().getSurface(), SDL_SRCCOLORKEY, makeColor(255, 0, 255));

	SDL_Surface * src = getData().getSurface();
	SDL_Surface * dst = who.getData().getSurface();

	int myWidth = src->w;
	int myHeight = src->h;
	int hisWidth = new_width;
	int hisHeight = new_height;
	int useX = x;
	int useY = y;
	int myX = 0;
	int myY = 0;

	float xscale = (float) hisWidth / (float) myWidth;
	float yscale = (float) hisHeight / (float) myHeight;

	/* sprig wont do the clipping right, if you start drawing from a negative offset
	* sprig will do nothing.
	*/
	if (useX < 0){
	useX = 0;
	myX = -x / xscale;
	}

	if (useY < 0){
	useY = 0;
	myY = -y / yscale;
	}

	SPG_TransformX(src, dst, 0, xscale, yscale, myX, myY, useX, useY, SPG_TCOLORKEY);
	}
	}

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

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

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

	static void doBlit(SDL_Surface * mine, const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ){
	SDL_Rect source;
	SDL_Rect destination;
	source.w = width;
	source.h = height;
	source.x = mx;
	source.y = my;

	destination.w = width;
	destination.h = height;
	destination.x = wx;
	destination.y = wy;

	SDL_BlitSurface(mine, &source, where.getData().getSurface(), &destination);
	}

	void Bitmap::Blit( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const {
	SDL_SetColorKey(getData().getSurface(), 0, MaskColor());
	doBlit(getData().getSurface(),mx, my, width, height, wx, wy, where);

	/* FIXME: this is a hack, maybe put a call here for the other bitmap to update stuff
	* like where->Blitted()
	*/
	if (&where == Screen){
	SDL_Flip(Screen->getData().getSurface());
	}
	}

	void Bitmap::BlitMasked( const int mx, const int my, const int width, const int height, const int wx, const int wy, const Bitmap & where ) const {
	SDL_SetColorKey(getData().getSurface(), SDL_SRCCOLORKEY, MaskColor());

	doBlit(getData().getSurface(),mx, my, width, height, wx, wy, where);

	/* FIXME: this is a hack, maybe put a call here for the other bitmap to update stuff
	* like where->Blitted()
	*/
	if (&where == Screen){
	SDL_Flip(Screen->getData().getSurface());
	}

	}

	void Bitmap::BlitToScreen(const int upper_left_x, const int upper_left_y) const {
	if ( Scaler == NULL ){
	this->Blit( upper_left_x, upper_left_y, *Screen );
	} else {
	this->Blit( upper_left_x, upper_left_y, *Buffer );
	Buffer->Stretch(*Scaler);
	Scaler->Blit(0, 0, 0, 0, *Screen);
	}

	// SDL_Flip(Screen->getData().getSurface());
	// SDL_UpdateRect(Screen->getData().getSurface(), 0, 0, Screen->getWidth(), Screen->getHeight());
	}

	void Bitmap::BlitAreaToScreen(const int upper_left_x, const int upper_left_y) const {
	if ( Scaler != NULL ){
	double mult_x = (double) Scaler->getWidth() / (double) SCALE_X;
	double mult_y = (double) Scaler->getHeight() / (double) SCALE_Y;

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

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

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

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

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

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

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

	SDL_Surface * src = getData().getSurface();
	SDL_Surface * dst = where.getData().getSurface();

	float xscale = (float) destWidth / (float) sourceWidth;
	float yscale = (float) destHeight / (float) sourceHeight;
	SDL_SetColorKey(src, 0, MaskColor());
	SPG_TransformX(src, dst, 0, xscale, yscale, sourceX, sourceY, destX, destY, SPG_NONE);

	/*
	SDL_Rect source;
	SDL_Rect destination;
	source.x = sourceX;
	source.y = sourceY;
	source.w = sourceWidth;
	source.h = sourceHeight;

	destination.x = destX;
	destination.y = destY;
	destination.w = destWidth;
	destination.h = destHeight;

	// SDL_StretchSurfaceRect(getData().getSurface(), &source, where.getData().getSurface(), &destination);

	SDL_Surface * src = getData().getSurface();
	SDL_Surface * dst = where.getData().getSurface();

	if (SDL_MUSTLOCK(src)){
	SDL_LockSurface(src);
	}

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

	SDL_StretchSurfaceRect(src, &source, dst, &destination);

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

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

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

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

	switch (::drawingMode){
	case MODE_SOLID : {
	SPG_TrigonFilled(getData().getSurface(), x1, y1, x2, y2, x3, y3, color);
	break;
	}
	case MODE_TRANS : {
	int alpha = globalBlend.alpha;
	SPG_TrigonFilledBlend(getData().getSurface(), x1, y1, x2, y2, x3, y3, color, alpha);
	break;
	}
	}
	}

	void Bitmap::ellipse( int x, int y, int rx, int ry, int color ) const {
	switch (::drawingMode){
	case MODE_SOLID : {
	SPG_Ellipse(getData().getSurface(), x, y, rx, ry, color);
	break;
	}
	case MODE_TRANS : {
	int alpha = globalBlend.alpha;
	SPG_EllipseBlend(getData().getSurface(), x, y, rx, ry, color, alpha);
	break;
	}
	}
	}

	void Bitmap::ellipseFill( int x, int y, int rx, int ry, int color ) const {
	/* TODO */
	}

	void Bitmap::light(int x, int y, int width, int height, int start_y, int focus_alpha, int edge_alpha, int focus_color, int edge_color) const {
	paintown_light16(getData().getSurface(), x, y, width, height, start_y, focus_alpha, edge_alpha, focus_color, edge_color);
	}

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

	void Bitmap::floodfill( const int x, const int y, const int color ) const {
	SPG_FloodFill(getData().getSurface(), x, y, color);
	}

	void Bitmap::horizontalLine( const int x1, const int y, const int x2, const int color ) const {
	/* TODO */
	}

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

	void Bitmap::vLine( const int y1, const int x, const int y2, const int color ) const {
	/* TODO */
	}

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

	void Bitmap::arc(const int x, const int y, const double ang1, const double ang2, const int radius, const int color ) const {
	/* TODO */
	// arcColor(getData().getSurface(), x, y,
	}

	void Bitmap::fill(int color) const {
	SDL_Rect area;
	area.x = 0;
	area.y = 0;
	area.w = getWidth();
	area.h = getHeight();
	SDL_FillRect(getData().getSurface(), &area, color);
	}

	int Bitmap::darken( int color, double factor ){
	/* TODO */
	return color;
	}

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

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

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const Bitmap & where ){
	SDL_SetColorKey(getData().getSurface(), SDL_SRCCOLORKEY, MaskColor());
	SDL_Surface * src = getData().getSurface();
	SDL_Surface * dst = where.getData().getSurface();
	SPG_TransformX(src, dst, angle, 1, 1, centerX, centerY, x, y, SPG_TCOLORKEY);
	}

	void Bitmap::drawPivot( const int centerX, const int centerY, const int x, const int y, const int angle, const double scale, const Bitmap & where ){
	SDL_SetColorKey(getData().getSurface(), SDL_SRCCOLORKEY, MaskColor());
	SDL_Surface * src = getData().getSurface();
	SDL_Surface * dst = where.getData().getSurface();
	SPG_TransformX(src, dst, angle, scale, scale, centerX, centerY, x, y, SPG_TCOLORKEY);
	}

	Bitmap Bitmap::memoryPCX(unsigned char * const data, const int length, const bool mask){
	SDL_RWops * ops = SDL_RWFromConstMem(data, length);
	SDL_Surface * pcx = IMG_LoadPCX_RW(ops);
	SDL_FreeRW(ops);
	SDL_Surface * display = SDL_DisplayFormat(pcx);
	Bitmap out(display, true);

	if (pcx->format->BitsPerPixel == 8){
	SDL_Color color = pcx->format->palette->colors[pcx->format->colorkey];
	int bad = makeColor(color.r, color.g, color.b);
	for (int x = 0; x < out.getWidth(); x++){
	for (int y = 0; y < out.getHeight(); y++){
	if (out.getPixel(x, y) == bad){
	out.putPixel(x, y, MaskColor());
	}
	}
	}
	}

	SDL_FreeSurface(pcx);
	SDL_FreeSurface(display);
	// out.floodfill(0, 0, makeColor(255, 0, 255));

	return out;
	}

	int Bitmap::getPixel( const int x, const int y ) const {
	return SPG_GetPixel(getData().getSurface(), x, y);
	}

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

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

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

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

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

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

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

	/*
	#define PAINTOWN_DLS_BLENDER BLENDER_FUNC
	#define PAINTOWN_DTS_BLENDER BLENDER_FUNC
	#define PAINTOWN_MAKE_DLS_BLENDER(a) _blender_func16
	#define PAINTOWN_MAKE_DTS_BLENDER() _blender_func16
	#define PAINTOWN_PIXEL_PTR unsigned short*
	#define PAINTOWN_OFFSET_PIXEL_PTR(p,x) ((PAINTOWN_PIXEL_PTR) (p) + (x))
	#define PAINTOWN_INC_PIXEL_PTR(p) ((p)++)
	#define PAINTOWN_INC_PIXEL_PTR_EX(p,d) ((p) += d)
	#define PAINTOWN_GET_MEMORY_PIXEL(p) (*(p))
	#define PAINTOWN_IS_SPRITE_MASK(b,c) ((unsigned long) (c) == (unsigned long) MASK_COLOR)
	#define PAINTOWN_DLSX_BLEND(b,n) ((*(b))(_blender_col_16, (n), globalBlend.alpha))
	#define PAINTOWN_GET_PIXEL(p) ((unsigned short ) (p))
	#define PAINTOWN_DTS_BLEND(b,o,n) ((*(b))((n), (o), globalBlend.alpha))
	#define PAINTOWN_PUT_PIXEL(p,c) (((unsigned short ) p) = (c))
	#define PAINTOWN_PUT_MEMORY_PIXEL(p,c) (*(p) = (c))
	#define PAINTOWN_SET_ALPHA(a) (globalBlend.alpha = (a))
	*/

	static void paintown_applyTrans16(SDL_Surface * dst, const int color){
	int y1 = 0;
	int y2 = dst->h;
	int x1 = 0;
	int x2 = dst->w - 1;

	y1 = dst->clip_rect.y;
	y2 = dst->clip_rect.y + dst->clip_rect.h;
	x1 = dst->clip_rect.x;
	x2 = dst->clip_rect.x + dst->clip_rect.w;

	int bpp = dst->format->BytesPerPixel;
	unsigned int mask = Bitmap::makeColor(255, 0, 255);
	for (int y = y1; y < y2; y++) {
	Uint8 * sourceLine = computeOffset(dst, x1, y1 + y);

	for (int x = x2; x >= x1; sourceLine += bpp, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	sourcePixel = globalBlend.currentBlender(color, sourcePixel, globalBlend.alpha);
	(Uint16 )sourceLine = sourcePixel;
	}
	}
	}
	}

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

	/*
	ASSERT(dst);
	ASSERT(src);
	*/

	if (SDL_MUSTLOCK(src)){
	SDL_LockSurface(src);
	}

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

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

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

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

	tmp = dst->clip_rect.x + dst->clip_rect.w - dx;
	w = ((tmp > src->w) ? src->w : tmp) - sxbeg;
	if (w <= 0)
	return;

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

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

	tmp = dst->clip_rect.y + dst->clip_rect.h - dy;
	h = ((tmp > src->h) ? src->h : tmp) - sybeg;
	if (h <= 0)
	return;

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

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

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

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

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

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

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

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

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

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

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

	bmp_unwrite_line(dst);
	}
	else {
	#endif
	{

	switch (mode){
	case Bitmap::SPRITE_NORMAL : {
	unsigned int mask = Bitmap::makeColor(255, 0, 255);
	int bpp = src->format->BytesPerPixel;
	for (y = 0; y < h; y++) {
	Uint8 * sourceLine = computeOffset(src, sxbeg, sybeg + y);
	Uint8 * destLine = computeOffset(dst, dxbeg, dybeg + y * y_dir);

	for (x = w - 1; x >= 0; sourceLine += bpp, destLine += bpp * x_dir, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	// unsigned int destPixel = (Uint16) destLine;
	// sourcePixel = globalBlend.currentBlender(destPixel, sourcePixel, globalBlend.alpha);
	(Uint16 )destLine = sourcePixel;
	}
	}
	}
	break;
	}
	case Bitmap::SPRITE_LIT : {
	int bpp = src->format->BytesPerPixel;
	int litColor = Bitmap::makeColor(globalBlend.red, globalBlend.green, globalBlend.blue);
	unsigned int mask = Bitmap::makeColor(255, 0, 255);
	for (y = 0; y < h; y++) {
	Uint8 * sourceLine = computeOffset(src, sxbeg, sybeg + y);
	Uint8 * destLine = computeOffset(dst, dxbeg, dybeg + y * y_dir);

	for (x = w - 1; x >= 0; sourceLine += bpp, destLine += bpp * x_dir, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	// unsigned int destPixel = (Uint16) destLine;
	sourcePixel = globalBlend.currentBlender(litColor, sourcePixel, globalBlend.alpha);
	(Uint16 )destLine = sourcePixel;
	}
	}
	}
	break;
	}
	case Bitmap::SPRITE_TRANS : {
	int bpp = src->format->BytesPerPixel;
	unsigned int mask = Bitmap::makeColor(255, 0, 255);
	for (y = 0; y < h; y++) {
	Uint8 * sourceLine = computeOffset(src, sxbeg, sybeg + y);
	Uint8 * destLine = computeOffset(dst, dxbeg, dybeg + y * y_dir);

	for (x = w - 1; x >= 0; sourceLine += bpp, destLine += bpp * x_dir, x--) {
	unsigned long sourcePixel = (Uint16) sourceLine;
	if (!(sourcePixel == mask)){
	unsigned int destPixel = (Uint16) destLine;
	sourcePixel = globalBlend.currentBlender(sourcePixel, destPixel, globalBlend.alpha);
	(Uint16 )destLine = sourcePixel;
	}
	}
	}
	break;
	}
	default : { break; }
	}

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

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

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

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

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

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

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

	int min_y, max_y, min_x, max_x;
	min_y = dst->clip_rect.y;
	max_y = dst->clip_rect.y + dst->clip_rect.h;
	min_x = dst->clip_rect.x;
	max_x = dst->clip_rect.x + dst->clip_rect.w;

	int dybeg = y;

	/* tan(theta) = y / x */
	double xtan = (double) height / (double) width;
	int bpp = dst->format->BytesPerPixel;
	for (int sy = start_y; sy < height; sy++) {
	if (dybeg + sy < min_y \|\| dybeg + sy > max_y){
	continue;
	}
	/* x = y / tan(theta) */
	int top_width = (int)((double) sy / xtan);
	if (top_width == 0){
	continue;
	}

	dxbeg = x - top_width;
	Uint8* line = computeOffset(dst, dxbeg, dybeg + y);

	for (int sx = -top_width; sx <= top_width; line += x_dir * bpp, sx++) {
	if (sx + x < min_x \|\| sx + x > max_x){
	continue;
	}

	unsigned long c = (Uint16) line;

	/* TODO:
	* converting to a double and calling fabs is overkill, just
	* write an integer abs() function.
	*/
	int sx_abs = (int) fabs((double) sx);
	int alphaUse = alphas[sx_abs];
	int color = colors[sx_abs];

	c = globalBlend.currentBlender(color, c, alphaUse);

	(Uint16) line = c;
	}
	}
	delete[] alphas;
	delete[] colors;

	if (SDL_MUSTLOCK(dst)){
	SDL_UnlockSurface(dst);
	}
	}
	diff --git a/util/trans-bitmap.h b/util/trans-bitmap.h
	index 29087296..3e8e40fc 100644
	--- a/util/trans-bitmap.h
	+++ b/util/trans-bitmap.h
	@@ -1,13 +1,15 @@
	#ifndef _paintown_trans_bitmap_h
	#define _paintown_trans_bitmap_h

	#include "bitmap.h"

	class TranslucentBitmap: public Bitmap {
	public:
	TranslucentBitmap(const Bitmap & b);
	TranslucentBitmap();
	virtual ~TranslucentBitmap();
	+
	+ virtual void putPixelNormal(int x, int y, int col) const;
	};

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 12:47 PM (3 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 69102
Default Alt Text: (82 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions