Transparente Polygone zu .m2 Dateien hinzugefügt.

Textur Animationen zu einzelnen polygonen sind jetzt möglich

Bild.cpp

@@ -33,224 +33,224 @@ using namespace Framework;
 // Inhalt der Bild Klasse aus Bild.h
 // Konstruktor 
 Bild::Bild( bool options )
-	: fc( 0 ),
-	delFc( 1 ),
-	size( 0, 0 ),
-	ref( 1 ),
-	drawOff( options ? new Punkt[ 2000 ] : new Punkt[ 1 ] ),
-	dPosA( options ? new Punkt[ 2000 ] : new Punkt[ 1 ] ),
-	dSizeA( options ? new Punkt[ 2000 ] : new Punkt[ 1 ] ),
-	doa( 0 ),
-	alpha( options ? new unsigned char[ 1000 ] : new unsigned char[ 1 ] ),
-	alphaAnzahl( 0 ),
-	rend( 0 ),
-	alpha3D( 0 )
-{
-	alpha[ 0 ] = 0;
+    : fc( 0 ),
+    delFc( 1 ),
+    size( 0, 0 ),
+    ref( 1 ),
+    drawOff( options ? new Punkt[ 2000 ] : new Punkt[ 1 ] ),
+    dPosA( options ? new Punkt[ 2000 ] : new Punkt[ 1 ] ),
+    dSizeA( options ? new Punkt[ 2000 ] : new Punkt[ 1 ] ),
+    doa( 0 ),
+    alpha( options ? new unsigned char[ 1000 ] : new unsigned char[ 1 ] ),
+    alphaAnzahl( 0 ),
+    rend( 0 ),
+    alpha3D( 0 )
+{
+    alpha[ 0 ] = 0;
 }
 
 // Destruktor 
 Bild::~Bild()
 {
-	if( delFc )
-	{
-		delete[] fc;
-		fc = 0;
-	}
-	delete[] dPosA;
-	delete[] dSizeA;
-	delete[] alpha;
-	delete[] drawOff;
+    if( delFc )
+    {
+        delete[] fc;
+        fc = 0;
+    }
+    delete[] dPosA;
+    delete[] dSizeA;
+    delete[] alpha;
+    delete[] drawOff;
 }
 
 // privat
 inline void Bild::alphaPixelP( int x, int y, int f )
 {
-	alphaPixelP( fc[ x + y * size.x ], f );
+    alphaPixelP( fc[ x + y * size.x ], f );
 }
 
 inline void Bild::alphaPixelP( int &fc, int colorb )
 {
-	int alpha = ( ( colorb >> 24 ) & 0xFF );
-	int na = ( 0x100 - alpha );
-	fc = ( ( ( ( ( na * ( fc & 0xFF00FF ) ) >> 8 ) + ( ( alpha * ( colorb & 0xFF00FF ) ) >> 8 ) ) & 0xFF00FF ) |
-		( ( ( ( na * ( fc & 0x00FF00 ) ) >> 8 ) + ( ( alpha * ( colorb & 0x00FF00 ) ) >> 8 ) ) & 0x00FF00 ) |
-		   ( ( fc & 0xFF000000 ) ) ) * ( fc != 0 || !alpha3D ) | ( fc == 0 && alpha3D ) * colorb;
-	//unsigned char *fc1 = (unsigned char*)&fc[ i ];
-	//unsigned char *fc2 = (unsigned char*)&colorb;
-	//unsigned char na = ~fc2[ 3 ];
-	//fc1[ 3 ] = fc2[ 3 ];
-	//fc1[ 2 ] = (unsigned char)( ( fc2[ 2 ] * fc2[ 3 ] + fc1[ 2 ] * na ) / 255 );
-	//fc1[ 1 ] = (unsigned char)( ( fc2[ 1 ] * fc2[ 3 ] + fc1[ 1 ] * na ) / 255 );
-	//fc1[ 0 ] = (unsigned char)( ( fc2[ 0 ] * fc2[ 3 ] + fc1[ 0 ] * na ) / 255 );
+    int alpha = ( ( colorb >> 24 ) & 0xFF );
+    int na = ( 0x100 - alpha );
+    fc = ( ( ( ( ( na * ( fc & 0xFF00FF ) ) >> 8 ) + ( ( alpha * ( colorb & 0xFF00FF ) ) >> 8 ) ) & 0xFF00FF ) |
+        ( ( ( ( na * ( fc & 0x00FF00 ) ) >> 8 ) + ( ( alpha * ( colorb & 0x00FF00 ) ) >> 8 ) ) & 0x00FF00 ) |
+           ( ( fc & 0xFF000000 ) ) ) * ( fc != 0 || !alpha3D ) | ( fc == 0 && alpha3D ) * colorb;
+    //unsigned char *fc1 = (unsigned char*)&fc[ i ];
+    //unsigned char *fc2 = (unsigned char*)&colorb;
+    //unsigned char na = ~fc2[ 3 ];
+    //fc1[ 3 ] = fc2[ 3 ];
+    //fc1[ 2 ] = (unsigned char)( ( fc2[ 2 ] * fc2[ 3 ] + fc1[ 2 ] * na ) / 255 );
+    //fc1[ 1 ] = (unsigned char)( ( fc2[ 1 ] * fc2[ 3 ] + fc1[ 1 ] * na ) / 255 );
+    //fc1[ 0 ] = (unsigned char)( ( fc2[ 0 ] * fc2[ 3 ] + fc1[ 0 ] * na ) / 255 );
 }
 
 char Bild::getOutCode( Punkt p ) const
 {
-	char ret = 0;
-	if( p.x < dPosA[ doa ].x )
-		ret = 1;
-	if( p.x >= dSizeA[ doa ].x )
-		ret = 2;
-	if( p.y < dPosA[ doa ].y )
-		ret |= 4;
-	if( p.y >= dSizeA[ doa ].y )
-		ret |= 8;
-	return ret;
+    char ret = 0;
+    if( p.x < dPosA[ doa ].x )
+        ret = 1;
+    if( p.x >= dSizeA[ doa ].x )
+        ret = 2;
+    if( p.y < dPosA[ doa ].y )
+        ret |= 4;
+    if( p.y >= dSizeA[ doa ].y )
+        ret |= 8;
+    return ret;
 }
 
 void Bild::drawFlatDreieck( int y1, int y2, float m1, float b1, float m2, float b2, int farbe )
 {
-	const int yStart = max( y1, dPosA[ doa ].y );
-	const int yEnd = min( y2, dSizeA[ doa ].y );
-	for( int y = yStart; y < yEnd; y++ )
-	{
-		const int xStart = max( (int)( m1 * (float)y + b1 + 0.5f ), dPosA[ doa ].x );
-		const int xEnd = min( (int)( m2 * (float)y + b2 + 0.5f ), dSizeA[ doa ].x );
-		for( int x = xStart; x < xEnd; x++ )
-			fc[ x + y * size.x ] = farbe;
-	}
+    const int yStart = max( y1, dPosA[ doa ].y );
+    const int yEnd = min( y2, dSizeA[ doa ].y );
+    for( int y = yStart; y < yEnd; y++ )
+    {
+        const int xStart = max( (int)( m1 * (float)y + b1 + 0.5f ), dPosA[ doa ].x );
+        const int xEnd = min( (int)( m2 * (float)y + b2 + 0.5f ), dSizeA[ doa ].x );
+        for( int x = xStart; x < xEnd; x++ )
+            fc[ x + y * size.x ] = farbe;
+    }
 }
 
 void Bild::drawFlatDreieckTextur( int y1, int y2, double m1, double b1, double m2, double b2, double tx1, double ty1, double tx2, double ty2,
-								  double tx_1o, double ty_1o, double tx_2o, double ty_2o, double txf, double tyf, Bild &textur )
+                                  double tx_1o, double ty_1o, double tx_2o, double ty_2o, double txf, double tyf, Bild &textur )
 {
-	const double yStart = max( y1, dPosA[ doa ].y );
-	const double yEnd = min( y2, dSizeA[ doa ].y );
-	double tx_1 = tx1 + tx_1o * ( yStart - y1 ), ty_1 = ty1 + ty_1o * ( yStart - y1 ), tx_2 = tx2 + tx_2o * ( yStart - y1 ), ty_2 = ty2 + ty_2o * ( yStart - y1 );
-	for( double y = yStart; y < yEnd; y++, tx_1 += tx_1o, ty_1 += ty_1o, tx_2 += tx_2o, ty_2 += ty_2o )
-	{
-		const double xStart = m1 * y + b1;
-		const double xEnd = m2 * y + b2;
-		drawLinieHTextur( Vec2< double >( xStart, y ), xEnd - xStart, Vec2< double >( tx_1, ty_1 ), Vec2< double >( tx_2, ty_2 ), txf, tyf, textur );
-	}
+    const double yStart = max( y1, dPosA[ doa ].y );
+    const double yEnd = min( y2, dSizeA[ doa ].y );
+    double tx_1 = tx1 + tx_1o * ( yStart - y1 ), ty_1 = ty1 + ty_1o * ( yStart - y1 ), tx_2 = tx2 + tx_2o * ( yStart - y1 ), ty_2 = ty2 + ty_2o * ( yStart - y1 );
+    for( double y = yStart; y < yEnd; y++, tx_1 += tx_1o, ty_1 += ty_1o, tx_2 += tx_2o, ty_2 += ty_2o )
+    {
+        const double xStart = m1 * y + b1;
+        const double xEnd = m2 * y + b2;
+        drawLinieHTextur( Vec2< double >( xStart, y ), xEnd - xStart, Vec2< double >( tx_1, ty_1 ), Vec2< double >( tx_2, ty_2 ), txf, tyf, textur );
+    }
 }
 
 void Bild::drawFlatDreieckAlpha( int y1, int y2, float m1, float b1, float m2, float b2, int farbe )
 {
-	const int yStart = max( (int)( y1 + 0.5 ), dPosA[ doa ].y );
-	const int yEnd = min( (int)( y2 + 0.5 ), dSizeA[ doa ].y );
-	for( int y = yStart; y < yEnd; y++ )
-	{
-		const int xStart = max( (int)( m1 * ( (float)y + 0.5f ) + b1 + 0.5f ), dPosA[ doa ].x );
-		const int xEnd = min( (int)( m2 * ( (float)y + 0.5 ) + b2 + 0.5f ), dSizeA[ doa ].x );
-		for( int x = xStart; x < xEnd; x++ )
-			alphaPixelP( fc[ x + y * size.x ], farbe );
-	}
+    const int yStart = max( (int)( y1 + 0.5 ), dPosA[ doa ].y );
+    const int yEnd = min( (int)( y2 + 0.5 ), dSizeA[ doa ].y );
+    for( int y = yStart; y < yEnd; y++ )
+    {
+        const int xStart = max( (int)( m1 * ( (float)y + 0.5f ) + b1 + 0.5f ), dPosA[ doa ].x );
+        const int xEnd = min( (int)( m2 * ( (float)y + 0.5 ) + b2 + 0.5f ), dSizeA[ doa ].x );
+        for( int x = xStart; x < xEnd; x++ )
+            alphaPixelP( fc[ x + y * size.x ], farbe );
+    }
 }
 
 void Bild::drawFlatDreieckTexturAlpha( int y1, int y2, double m1, double b1, double m2, double b2, double tx1, double ty1, double tx2, double ty2,
-									   double tx_1o, double ty_1o, double tx_2o, double ty_2o, double txf, double tyf, Bild &textur )
+                                       double tx_1o, double ty_1o, double tx_2o, double ty_2o, double txf, double tyf, Bild &textur )
 {
-	const double yStart = max( y1, dPosA[ doa ].y );
-	const double yEnd = min( y2, dSizeA[ doa ].y );
-	double tx_1 = tx1 + tx_1o * ( yStart - y1 ), ty_1 = ty1 + ty_1o * ( yStart - y1 ), tx_2 = tx2 + tx_2o * ( yStart - y1 ), ty_2 = ty2 + ty_2o * ( yStart - y1 );
-	for( double y = yStart; y < yEnd; y++, tx_1 += tx_1o, ty_1 += ty_1o, tx_2 += tx_2o, ty_2 += ty_2o )
-	{
-		const double xStart = m1 * y + b1;
-		const double xEnd = m2 * y + b2;
-		drawLinieHTexturAlpha( Vec2< double >( xStart, y ), xEnd - xStart, Vec2< double >( tx_1, ty_1 ), Vec2< double >( tx_2, ty_2 ), txf, tyf, textur );
-	}
+    const double yStart = max( y1, dPosA[ doa ].y );
+    const double yEnd = min( y2, dSizeA[ doa ].y );
+    double tx_1 = tx1 + tx_1o * ( yStart - y1 ), ty_1 = ty1 + ty_1o * ( yStart - y1 ), tx_2 = tx2 + tx_2o * ( yStart - y1 ), ty_2 = ty2 + ty_2o * ( yStart - y1 );
+    for( double y = yStart; y < yEnd; y++, tx_1 += tx_1o, ty_1 += ty_1o, tx_2 += tx_2o, ty_2 += ty_2o )
+    {
+        const double xStart = m1 * y + b1;
+        const double xEnd = m2 * y + b2;
+        drawLinieHTexturAlpha( Vec2< double >( xStart, y ), xEnd - xStart, Vec2< double >( tx_1, ty_1 ), Vec2< double >( tx_2, ty_2 ), txf, tyf, textur );
+    }
 }
 
 void Bild::drawLinieHTextur( Vec2< double > p, double len, Vec2< double > ta, Vec2< double > tb, double txo, double tyo, Bild &textur ) // zeichnet eine horizontale Linie
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		drawLinieHTexturAlpha( p, len, ta, tb, txo, tyo, textur );
-		return;
-	}
-	if( len < 0 )
-	{
-		p.x += len;
-		len = -len;
-		ta.Swap( tb );
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	if( p.y < dpy || p.y >= dgy )
-		return;
-	double off = 0;
-	if( p.x < dpx )
-	{
-		off = dpx - p.x;
-		len -= dpx - p.x;
-		if( len <= 0 )
-			return;
-		p.x = dpx;
-	}
-	if( p.x + len >= dgx )
-	{
-		len -= p.x - dgx + len;
-		if( len <= 0 )
-			return;
-	}
-	int br = size.x;
-	int *fc = this->fc + (int)( p.x + (int)p.y * br );
-	double x = ta.x + txo * off, y = ta.y + tyo * off;
-	int *buffer = textur.getBuffer();
-	int txtBr = textur.getBreite();
-	for( int i = 0; i < len; ++i, ++fc )
-	{
-		*fc = buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * txtBr ) ];
-		x += txo, y += tyo;
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        drawLinieHTexturAlpha( p, len, ta, tb, txo, tyo, textur );
+        return;
+    }
+    if( len < 0 )
+    {
+        p.x += len;
+        len = -len;
+        ta.Swap( tb );
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    if( p.y < dpy || p.y >= dgy )
+        return;
+    double off = 0;
+    if( p.x < dpx )
+    {
+        off = dpx - p.x;
+        len -= dpx - p.x;
+        if( len <= 0 )
+            return;
+        p.x = dpx;
+    }
+    if( p.x + len >= dgx )
+    {
+        len -= p.x - dgx + len;
+        if( len <= 0 )
+            return;
+    }
+    int br = size.x;
+    int *fc = this->fc + (int)( p.x + (int)p.y * br );
+    double x = ta.x + txo * off, y = ta.y + tyo * off;
+    int *buffer = textur.getBuffer();
+    int txtBr = textur.getBreite();
+    for( int i = 0; i < len; ++i, ++fc )
+    {
+        *fc = buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * txtBr ) ];
+        x += txo, y += tyo;
+    }
+    rend = 1;
 }
 
 void Bild::drawLinieHTexturAlpha( Vec2< double > p, double len, Vec2< double > ta, Vec2< double > tb, double txo, double tyo, Bild &textur ) // zeichnet eine horizontale Linie
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( len < 0 )
-	{
-		p.x += len;
-		len = -len;
-		ta.Swap( tb );
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	if( p.y < dpy || p.y >= dgy )
-		return;
-	double off = 0;
-	if( p.x < dpx )
-	{
-		off = dpx - p.x;
-		len -= dpx - p.x;
-		if( len <= 0 )
-			return;
-		p.x = dpx;
-	}
-	if( p.x + len >= dgx )
-	{
-		len -= p.x - dgx + len;
-		if( len <= 0 )
-			return;
-	}
-	int br = size.x;
-	int *fc = this->fc + (int)( p.x + (int)p.y * br );
-	double x = ta.x + txo * off, y = ta.y + tyo * off;
-	int *buffer = textur.getBuffer();
-	int txtBr = textur.getBreite();
-	int f;
-	for( int i = 0; i < len; ++i, ++fc )
-	{
-		f = buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * txtBr ) ];
-		if( alpha[ alphaAnzahl ] )
-		{
-			unsigned char *cf = (unsigned char*)&f;
-			cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-		}
-		alphaPixelP( *fc, f );
-		x += txo, y += tyo;
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( len < 0 )
+    {
+        p.x += len;
+        len = -len;
+        ta.Swap( tb );
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    if( p.y < dpy || p.y >= dgy )
+        return;
+    double off = 0;
+    if( p.x < dpx )
+    {
+        off = dpx - p.x;
+        len -= dpx - p.x;
+        if( len <= 0 )
+            return;
+        p.x = dpx;
+    }
+    if( p.x + len >= dgx )
+    {
+        len -= p.x - dgx + len;
+        if( len <= 0 )
+            return;
+    }
+    int br = size.x;
+    int *fc = this->fc + (int)( p.x + (int)p.y * br );
+    double x = ta.x + txo * off, y = ta.y + tyo * off;
+    int *buffer = textur.getBuffer();
+    int txtBr = textur.getBreite();
+    int f;
+    for( int i = 0; i < len; ++i, ++fc )
+    {
+        f = buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * txtBr ) ];
+        if( alpha[ alphaAnzahl ] )
+        {
+            unsigned char *cf = (unsigned char*)&f;
+            cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+        }
+        alphaPixelP( *fc, f );
+        x += txo, y += tyo;
+    }
+    rend = 1;
 }
 
 // nicht constant
@@ -274,1708 +274,1730 @@ bool Bild::isAreaDrawable( int x, int y, int b, int h )
 // Das ist sinnvoll für die Verwendung im 3DBildschirm, wo das Gezeichnette Bild später mittels Alpha Blending angezeigt wird
 void Bild::setAlpha3D( bool erlaubt )
 {
-	alpha3D = erlaubt;
+    alpha3D = erlaubt;
 }
 
 void Bild::setAlpha( unsigned char alpha ) // setzt die Transparenz der nachfolgenden Zeichnunge
 {
-	int last = this->alpha[ alphaAnzahl ];
-	++alphaAnzahl;
-	assert( alphaAnzahl < 1000 );
-	this->alpha[ alphaAnzahl ] = (unsigned char)( ( 255 - alpha ) > last ? ( 255 - alpha ) : last );
+    int last = this->alpha[ alphaAnzahl ];
+    ++alphaAnzahl;
+    assert( alphaAnzahl < 1000 );
+    this->alpha[ alphaAnzahl ] = (unsigned char)( ( 255 - alpha ) > last ? ( 255 - alpha ) : last );
 }
 
 void Bild::releaseAlpha() // Löscht alpha
 {
-	--alphaAnzahl;
+    --alphaAnzahl;
 }
 
 void Bild::setPixelBuffer( int *buffer, bool deleteBuffer, int breite, int height ) // setzt den Zeiger auf die Pixel des Bildes
 {
-	if( delFc )
-		delete[]fc;
-	fc = buffer;
-	delFc = deleteBuffer;
-	size.x = breite;
-	size.y = height;
-	rend = 1;
+    if( delFc )
+        delete[]fc;
+    fc = buffer;
+    delFc = deleteBuffer;
+    size.x = breite;
+    size.y = height;
+    rend = 1;
 }
 
 void Bild::neuBild( int breite, int height, int fillColor )
 {
-	if( fc && delFc )
-		delete[] fc;
-	size.x = breite;
-	size.y = height;
-	fc = new int[ size.x * size.y ];
-	setFarbe( fillColor );
-	drawOff[ 0 ].x = 0;
-	drawOff[ 0 ].y = 0;
-	dPosA[ 0 ].x = 0;
-	dPosA[ 0 ].y = 0;
-	dSizeA[ 0 ] = size;
-	alphaAnzahl = 0;
-	alpha[ 0 ] = 0;
-	doa = 0;
-	rend = 1;
+    if( fc && delFc )
+        delete[] fc;
+    size.x = breite;
+    size.y = height;
+    fc = new int[ size.x * size.y ];
+    setFarbe( fillColor );
+    drawOff[ 0 ].x = 0;
+    drawOff[ 0 ].y = 0;
+    dPosA[ 0 ].x = 0;
+    dPosA[ 0 ].y = 0;
+    dSizeA[ 0 ] = size;
+    alphaAnzahl = 0;
+    alpha[ 0 ] = 0;
+    doa = 0;
+    rend = 1;
 }
 
 void Bild::setFarbe( int f )
 {
-	if( ( f & 0xFF ) == ( ( f >> 8 ) & 0xFF ) && ( f & 0xFF ) == ( ( f >> 16 ) & 0xFF ) && ( f & 0xFF ) == ( ( f >> 24 ) & 0xFF ) )
-		memset( fc, f, size.x * size.y * 4 );
-	else
-	{
-		for( int *i = fc, *end = i + size.x * size.y; i < end; i++ )
-			*i = f;
-	}
-	rend = 1;
+    if( ( f & 0xFF ) == ( ( f >> 8 ) & 0xFF ) && ( f & 0xFF ) == ( ( f >> 16 ) & 0xFF ) && ( f & 0xFF ) == ( ( f >> 24 ) & 0xFF ) )
+        memset( fc, f, size.x * size.y * 4 );
+    else
+    {
+        for( int *i = fc, *end = i + size.x * size.y; i < end; i++ )
+            *i = f;
+    }
+    rend = 1;
 }
 
 void Bild::fillRegion( int x, int y, int b, int h, int ff )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		alphaRegion( x, y, b, h, ff );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + b < dpx || y + h < dpy || x > dgx || y > dgy )
-		return;
-	if( x < dpx )
-	{
-		b -= dpx - x;
-		x = dpx;
-	}
-	if( y < dpy )
-	{
-		h -= dpy - y;
-		y = dpy;
-	}
-	b = ( x + b ) >= dgx ? ( dgx - x ) : b;
-	h = ( y + h ) >= dgy ? ( dgy - y ) : h;
-	int *pixel = fc + y * size.x + x;
-	int *rowEnd = pixel + b;
-	for( int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x )
-	{
-		for( ; pixel < rowEnd; ++pixel )
-			*pixel = ff;
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        alphaRegion( x, y, b, h, ff );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + b < dpx || y + h < dpy || x > dgx || y > dgy )
+        return;
+    if( x < dpx )
+    {
+        b -= dpx - x;
+        x = dpx;
+    }
+    if( y < dpy )
+    {
+        h -= dpy - y;
+        y = dpy;
+    }
+    b = ( x + b ) >= dgx ? ( dgx - x ) : b;
+    h = ( y + h ) >= dgy ? ( dgy - y ) : h;
+    int *pixel = fc + y * size.x + x;
+    int *rowEnd = pixel + b;
+    for( int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x )
+    {
+        for( ; pixel < rowEnd; ++pixel )
+            *pixel = ff;
+    }
+    rend = 1;
 }
 
 void Bild::alphaRegion( int x, int y, int b, int h, int ff )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + b < dpx || y + h < dpy || x > dgx || y > dgy )
-		return;
-	if( x < dpx )
-	{
-		b -= dpx - x;
-		x = dpx;
-	}
-	if( y < dpy )
-	{
-		h -= dpy - y;
-		y = dpy;
-	}
-	b = ( x + b ) >= dgx ? ( dgx - x ) : b;
-	h = ( y + h ) >= dgy ? ( dgy - y ) : h;
-	if( alpha[ alphaAnzahl ] )
-	{
-		unsigned char *cf = (unsigned char*)&ff;
-		cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-	}
-	int *pixel = fc + y * size.x + x;
-	int *rowEnd = pixel + b;
-	int alpha = ( ( ff >> 24 ) & 0xFF );
-	int na = ( 0x100 - alpha );
-	int i1 = ( alpha * ( ff & 0xFF00FF ) ) >> 8;
-	int i2 = ( alpha * ( ff & 0x00FF00 ) ) >> 8;
-	for( int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x )
-	{
-		for( ; pixel < rowEnd; ++pixel )
-		{
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( ( *pixel & 0xFF000000 ) ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * ff;
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + b < dpx || y + h < dpy || x > dgx || y > dgy )
+        return;
+    if( x < dpx )
+    {
+        b -= dpx - x;
+        x = dpx;
+    }
+    if( y < dpy )
+    {
+        h -= dpy - y;
+        y = dpy;
+    }
+    b = ( x + b ) >= dgx ? ( dgx - x ) : b;
+    h = ( y + h ) >= dgy ? ( dgy - y ) : h;
+    if( alpha[ alphaAnzahl ] )
+    {
+        unsigned char *cf = (unsigned char*)&ff;
+        cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+    }
+    int *pixel = fc + y * size.x + x;
+    int *rowEnd = pixel + b;
+    int alpha = ( ( ff >> 24 ) & 0xFF );
+    int na = ( 0x100 - alpha );
+    int i1 = ( alpha * ( ff & 0xFF00FF ) ) >> 8;
+    int i2 = ( alpha * ( ff & 0x00FF00 ) ) >> 8;
+    for( int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x )
+    {
+        for( ; pixel < rowEnd; ++pixel )
+        {
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( ( *pixel & 0xFF000000 ) ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * ff;
+        }
+    }
+    rend = 1;
 }
 
 void Bild::alphaPixel( int i, int f )
 {
-	if( !alpha[ alphaAnzahl ] )
-		alphaPixelP( fc[ i ], f );
-	if( alpha[ alphaAnzahl ] < 0xFF )
-	{
-		unsigned char *cf = (unsigned char*)&f;
-		cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-		alphaPixelP( fc[ i ], f );
-		rend = 1;
-	}
+    if( !alpha[ alphaAnzahl ] )
+        alphaPixelP( fc[ i ], f );
+    if( alpha[ alphaAnzahl ] < 0xFF )
+    {
+        unsigned char *cf = (unsigned char*)&f;
+        cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+        alphaPixelP( fc[ i ], f );
+        rend = 1;
+    }
 }
 
 void Bild::alphaPixel( int x, int y, int f )
 {
-	if( !alpha[ alphaAnzahl ] )
-		alphaPixelP( fc[ x + y * size.x ], f );
-	if( alpha[ alphaAnzahl ] < 0xFF )
-	{
-		unsigned char *cf = (unsigned char*)&f;
-		cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-		alphaPixelP( fc[ x + y * size.x ], f );
-		rend = 1;
-	}
+    if( !alpha[ alphaAnzahl ] )
+        alphaPixelP( fc[ x + y * size.x ], f );
+    if( alpha[ alphaAnzahl ] < 0xFF )
+    {
+        unsigned char *cf = (unsigned char*)&f;
+        cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+        alphaPixelP( fc[ x + y * size.x ], f );
+        rend = 1;
+    }
 }
 
 void Bild::alphaPixelDP( int x, int y, int f )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	if( x < dpx || y < dpy || x > dgx || y > dgy )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		unsigned char *cf = (unsigned char*)&f;
-		cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-	}
-	alphaPixelP( fc[ x + y * size.x ], f );
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    if( x < dpx || y < dpy || x > dgx || y > dgy )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        unsigned char *cf = (unsigned char*)&f;
+        cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+    }
+    alphaPixelP( fc[ x + y * size.x ], f );
+    rend = 1;
 }
 
 void Bild::alphaPixelDP( int i, int f )
 {
-	int x = i % size.x;
-	int y = i / size.x;
-	alphaPixelDP( x, y, f );
-	rend = 1;
+    int x = i % size.x;
+    int y = i / size.x;
+    alphaPixelDP( x, y, f );
+    rend = 1;
 }
 
 void Bild::setPixelDP( int x, int y, int f )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		alphaPixelDP( x, y, f );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	if( x < dpx || y < dpy || x > dgx || y > dgy )
-		return;
-	fc[ x + y * size.x ] = f;
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        alphaPixelDP( x, y, f );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    if( x < dpx || y < dpy || x > dgx || y > dgy )
+        return;
+    fc[ x + y * size.x ] = f;
+    rend = 1;
 }
 
 void Bild::setPixelDP( int i, int f )
 {
-	int x = i % size.x;
-	int y = i / size.x;
-	setPixelDP( x, y, f );
-	rend = 1;
+    int x = i % size.x;
+    int y = i / size.x;
+    setPixelDP( x, y, f );
+    rend = 1;
 }
 
 void Bild::drawLinieH( int x, int y, int len, int f ) // zeichnet eine horizontale Linie
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		drawLinieHAlpha( x, y, len, f );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( y < dpy || y >= dgy )
-		return;
-	if( x < dpx )
-	{
-		len -= dpx - x;
-		if( len <= 0 )
-			return;
-		x = dpx;
-	}
-	if( x + len >= dgx )
-	{
-		len -= x - dgx + len;
-		if( len <= 0 )
-			return;
-	}
-	int br = size.x;
-	int *fc = this->fc + x + y * br;
-	int pval = len < 0 ? -1 : 1;
-	len = len > 0 ? len : -len;
-	for( int i = 0; i < len; ++i, fc += pval )
-		*fc = f;
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        drawLinieHAlpha( x, y, len, f );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( y < dpy || y >= dgy )
+        return;
+    if( x < dpx )
+    {
+        len -= dpx - x;
+        if( len <= 0 )
+            return;
+        x = dpx;
+    }
+    if( x + len >= dgx )
+    {
+        len -= x - dgx + len;
+        if( len <= 0 )
+            return;
+    }
+    int br = size.x;
+    int *fc = this->fc + x + y * br;
+    int pval = len < 0 ? -1 : 1;
+    len = len > 0 ? len : -len;
+    for( int i = 0; i < len; ++i, fc += pval )
+        *fc = f;
+    rend = 1;
 }
 
 void Bild::drawLinieV( int x, int y, int len, int f ) // zeichnet eine vertikale Linie
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		drawLinieVAlpha( x, y, len, f );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x < dpx || x >= dgx )
-		return;
-	if( y < dpy )
-	{
-		len -= dpy - y;
-		if( len <= 0 )
-			return;
-		y = dpy;
-	}
-	if( y + len >= dgy )
-	{
-		len -= y - dgy + len;
-		if( len < 0 )
-			return;
-	}
-	int br = size.x;
-	int *fc = this->fc + x + y * br;
-	int pval = len < 0 ? -br : br;
-	len = len > 0 ? len : -len;
-	for( int i = 0; i < len; ++i, fc += pval )
-		*fc = f;
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        drawLinieVAlpha( x, y, len, f );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x < dpx || x >= dgx )
+        return;
+    if( y < dpy )
+    {
+        len -= dpy - y;
+        if( len <= 0 )
+            return;
+        y = dpy;
+    }
+    if( y + len >= dgy )
+    {
+        len -= y - dgy + len;
+        if( len < 0 )
+            return;
+    }
+    int br = size.x;
+    int *fc = this->fc + x + y * br;
+    int pval = len < 0 ? -br : br;
+    len = len > 0 ? len : -len;
+    for( int i = 0; i < len; ++i, fc += pval )
+        *fc = f;
+    rend = 1;
 }
 
 void Bild::drawLinieHAlpha( int x, int y, int len, int f ) // zeichnet eine horizontale Linie
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( y < dpy || y >= dgy )
-		return;
-	if( x < dpx )
-	{
-		len -= dpx - x;
-		if( len <= 0 )
-			return;
-		x = dpx;
-	}
-	if( x + len >= dgx )
-	{
-		len -= x - dgx + len;
-		if( len <= 0 )
-			return;
-	}
-	int br = size.x;
-	int pval = len < 0 ? -1 : 1;
-	len = len > 0 ? len : -len;
-	int end = 0;
-	if( alpha[ alphaAnzahl ] )
-	{
-		unsigned char *cf = (unsigned char*)&f;
-		cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-	}
-	int alpha = ( ( f >> 24 ) & 0xFF );
-	int na = ( 0x100 - alpha );
-	int i1 = ( alpha * ( f & 0xFF00FF ) ) >> 8;
-	int i2 = ( alpha * ( f & 0x00FF00 ) ) >> 8;
-	for( int i = x + y * br; end < len; ++end, i += pval )
-	{
-		fc[ i ] = ( ( ( ( ( na * ( fc[ i ] & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-			( ( ( ( na * ( fc[ i ] & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					( ( fc[ i ] & 0xFF000000 ) ) ) * ( fc[ i ] != 0 || !alpha3D ) | ( fc[ i ] == 0 && alpha3D ) * f;
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( y < dpy || y >= dgy )
+        return;
+    if( x < dpx )
+    {
+        len -= dpx - x;
+        if( len <= 0 )
+            return;
+        x = dpx;
+    }
+    if( x + len >= dgx )
+    {
+        len -= x - dgx + len;
+        if( len <= 0 )
+            return;
+    }
+    int br = size.x;
+    int pval = len < 0 ? -1 : 1;
+    len = len > 0 ? len : -len;
+    int end = 0;
+    if( alpha[ alphaAnzahl ] )
+    {
+        unsigned char *cf = (unsigned char*)&f;
+        cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+    }
+    int alpha = ( ( f >> 24 ) & 0xFF );
+    int na = ( 0x100 - alpha );
+    int i1 = ( alpha * ( f & 0xFF00FF ) ) >> 8;
+    int i2 = ( alpha * ( f & 0x00FF00 ) ) >> 8;
+    for( int i = x + y * br; end < len; ++end, i += pval )
+    {
+        fc[ i ] = ( ( ( ( ( na * ( fc[ i ] & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+            ( ( ( ( na * ( fc[ i ] & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                    ( ( fc[ i ] & 0xFF000000 ) ) ) * ( fc[ i ] != 0 || !alpha3D ) | ( fc[ i ] == 0 && alpha3D ) * f;
+    }
+    rend = 1;
 }
 
 void Bild::drawLinieVAlpha( int x, int y, int len, int f ) // zeichnet eine vertikale Linie
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x < dpx || x >= dgx )
-		return;
-	if( y < dpy )
-	{
-		len -= dpy - y;
-		if( len <= 0 )
-			return;
-		y = dpy;
-	}
-	if( y + len >= dgy )
-	{
-		len -= y - dgy + len;
-		if( len < 0 )
-			return;
-	}
-	int br = size.x;
-	int pval = len < 0 ? -br : br;
-	len = len > 0 ? len : -len;
-	int end = 0;
-	if( alpha[ alphaAnzahl ] )
-	{
-		unsigned char *cf = (unsigned char*)&f;
-		cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-	}
-	int alpha = ( ( f >> 24 ) & 0xFF );
-	int na = ( 0x100 - alpha );
-	int i1 = ( alpha * ( f & 0xFF00FF ) ) >> 8;
-	int i2 = ( alpha * ( f & 0x00FF00 ) ) >> 8;
-	for( int i = x + y * br; end < len; ++end, i += pval )
-	{
-		fc[ i ] = ( ( ( ( ( na * ( fc[ i ] & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-			( ( ( ( na * ( fc[ i ] & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					( fc[ i ] & 0xFF000000 ) ) * ( fc[ i ] != 0 || !alpha3D ) | ( fc[ i ] == 0 && alpha3D ) * f;
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x < dpx || x >= dgx )
+        return;
+    if( y < dpy )
+    {
+        len -= dpy - y;
+        if( len <= 0 )
+            return;
+        y = dpy;
+    }
+    if( y + len >= dgy )
+    {
+        len -= y - dgy + len;
+        if( len < 0 )
+            return;
+    }
+    int br = size.x;
+    int pval = len < 0 ? -br : br;
+    len = len > 0 ? len : -len;
+    int end = 0;
+    if( alpha[ alphaAnzahl ] )
+    {
+        unsigned char *cf = (unsigned char*)&f;
+        cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+    }
+    int alpha = ( ( f >> 24 ) & 0xFF );
+    int na = ( 0x100 - alpha );
+    int i1 = ( alpha * ( f & 0xFF00FF ) ) >> 8;
+    int i2 = ( alpha * ( f & 0x00FF00 ) ) >> 8;
+    for( int i = x + y * br; end < len; ++end, i += pval )
+    {
+        fc[ i ] = ( ( ( ( ( na * ( fc[ i ] & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+            ( ( ( ( na * ( fc[ i ] & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                    ( fc[ i ] & 0xFF000000 ) ) * ( fc[ i ] != 0 || !alpha3D ) | ( fc[ i ] == 0 && alpha3D ) * f;
+    }
+    rend = 1;
 }
 
 void Bild::drawLinie( Punkt a, Punkt b, int fc ) // zeichnet eine Linie von Punkt( x1, y1 ) nach Punke( x2, y2 )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		drawLinieAlpha( a, b, fc );
-		return;
-	}
-	a += drawOff[ doa ];
-	b += drawOff[ doa ];
-	char outCode1 = getOutCode( a );
-	char outCode2 = getOutCode( b );
-	bool ok = 0;
-	while( 1 )
-	{
-		int xMax = dSizeA[ doa ].x - 1;
-		int yMax = dSizeA[ doa ].y - 1;
-		if( !( outCode1 | outCode2 ) )
-		{
-			ok = 1;
-			break;
-		}
-		else if( outCode1 & outCode2 )
-			break;
-		else
-		{
-			int x = 0, y = 0;
-			char outCodeOut = outCode1 ? outCode1 : outCode2;
-			if( outCodeOut & 8 )
-			{
-				x = (int)( a.x + ( b.x - a.x ) * ( yMax - a.y ) / ( b.y - a.y ) + 0.5 );
-				y = yMax;
-			}
-			else if( outCodeOut & 4 )
-			{
-				x = (int)( a.x + ( b.x - a.x ) * ( dPosA[ doa ].y - a.y ) / ( b.y - a.y ) + 0.5 );
-				y = dPosA[ doa ].y;
-			}
-			else if( outCodeOut & 2 )
-			{
-				y = (int)( a.y + ( b.y - a.y ) * ( xMax - a.x ) / ( b.x - a.x ) + 0.5 );
-				x = xMax;
-			}
-			else if( outCodeOut & 1 )
-			{
-				y = (int)( a.y + ( b.y - a.y ) * ( dPosA[ doa ].x - a.x ) / ( b.x - a.x ) + 0.5 );
-				x = dPosA[ doa ].x;
-			}
-			if( outCodeOut == outCode1 )
-			{
-				a.x = x;
-				a.y = y;
-				outCode1 = getOutCode( a );
-			}
-			else
-			{
-				b.x = x;
-				b.y = y;
-				outCode2 = getOutCode( b );
-			}
-		}
-	}
-	if( ok )
-	{
-		int xlen = b.x - a.x, axlen = abs( xlen );
-		int ylen = b.y - a.y, aylen = abs( ylen );
-		double xf = (double)xlen / ( aylen ? aylen : 1 );
-		double yf = (double)ylen / ( axlen ? axlen : 1 );
-		if( axlen > aylen )
-			xf = xf < 0 ? -1 : 1;
-		else
-			yf = yf < 0 ? -1 : 1;
-		double x = (double)a.x, y = (double)a.y;
-		int maxP = (int)( sqrt( xlen * xlen + ylen * ylen ) + 0.5 );
-		int count = 0;
-		while( !( (int)( x + 0.5 ) == b.x && (int)( y + 0.5 ) == b.y ) && count < maxP )
-		{
-			++count;
-			this->fc[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * size.x ) ] = fc;
-			x += xf, y += yf;
-		}
-		rend = 1;
-	}
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        drawLinieAlpha( a, b, fc );
+        return;
+    }
+    a += drawOff[ doa ];
+    b += drawOff[ doa ];
+    char outCode1 = getOutCode( a );
+    char outCode2 = getOutCode( b );
+    bool ok = 0;
+    while( 1 )
+    {
+        int xMax = dSizeA[ doa ].x - 1;
+        int yMax = dSizeA[ doa ].y - 1;
+        if( !( outCode1 | outCode2 ) )
+        {
+            ok = 1;
+            break;
+        }
+        else if( outCode1 & outCode2 )
+            break;
+        else
+        {
+            int x = 0, y = 0;
+            char outCodeOut = outCode1 ? outCode1 : outCode2;
+            if( outCodeOut & 8 )
+            {
+                x = (int)( a.x + ( b.x - a.x ) * ( yMax - a.y ) / ( b.y - a.y ) + 0.5 );
+                y = yMax;
+            }
+            else if( outCodeOut & 4 )
+            {
+                x = (int)( a.x + ( b.x - a.x ) * ( dPosA[ doa ].y - a.y ) / ( b.y - a.y ) + 0.5 );
+                y = dPosA[ doa ].y;
+            }
+            else if( outCodeOut & 2 )
+            {
+                y = (int)( a.y + ( b.y - a.y ) * ( xMax - a.x ) / ( b.x - a.x ) + 0.5 );
+                x = xMax;
+            }
+            else if( outCodeOut & 1 )
+            {
+                y = (int)( a.y + ( b.y - a.y ) * ( dPosA[ doa ].x - a.x ) / ( b.x - a.x ) + 0.5 );
+                x = dPosA[ doa ].x;
+            }
+            if( outCodeOut == outCode1 )
+            {
+                a.x = x;
+                a.y = y;
+                outCode1 = getOutCode( a );
+            }
+            else
+            {
+                b.x = x;
+                b.y = y;
+                outCode2 = getOutCode( b );
+            }
+        }
+    }
+    if( ok )
+    {
+        int xlen = b.x - a.x, axlen = abs( xlen );
+        int ylen = b.y - a.y, aylen = abs( ylen );
+        double xf = (double)xlen / ( aylen ? aylen : 1 );
+        double yf = (double)ylen / ( axlen ? axlen : 1 );
+        if( axlen > aylen )
+            xf = xf < 0 ? -1 : 1;
+        else
+            yf = yf < 0 ? -1 : 1;
+        double x = (double)a.x, y = (double)a.y;
+        int maxP = (int)( sqrt( xlen * xlen + ylen * ylen ) + 0.5 );
+        int count = 0;
+        while( !( (int)( x + 0.5 ) == b.x && (int)( y + 0.5 ) == b.y ) && count < maxP )
+        {
+            ++count;
+            this->fc[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * size.x ) ] = fc;
+            x += xf, y += yf;
+        }
+        rend = 1;
+    }
 }
 
 void Bild::drawLinieAlpha( Punkt a, Punkt b, int fc )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	a += drawOff[ doa ];
-	b += drawOff[ doa ];
-	char outCode1 = getOutCode( a );
-	char outCode2 = getOutCode( b );
-	bool ok = 0;
-	while( 1 )
-	{
-		int xMax = dSizeA[ doa ].x - 1;
-		int yMax = dSizeA[ doa ].y - 1;
-		if( !( outCode1 | outCode2 ) )
-		{
-			ok = 1;
-			break;
-		}
-		else if( outCode1 & outCode2 )
-			break;
-		else
-		{
-			int x = 0, y = 0;
-			char outCodeOut = outCode1 ? outCode1 : outCode2;
-			if( outCodeOut & 8 )
-			{
-				x = (int)( a.x + ( b.x - a.x ) * ( yMax - a.y ) / ( b.y - a.y ) + 0.5 );
-				y = yMax;
-			}
-			else if( outCodeOut & 4 )
-			{
-				x = (int)( a.x + ( b.x - a.x ) * ( dPosA[ doa ].y - a.y ) / ( b.y - a.y ) + 0.5 );
-				y = dPosA[ doa ].y;
-			}
-			else if( outCodeOut & 2 )
-			{
-				y = (int)( a.y + ( b.y - a.y ) * ( xMax - a.x ) / ( b.x - a.x ) + 0.5 );
-				x = xMax;
-			}
-			else if( outCodeOut & 1 )
-			{
-				y = (int)( a.y + ( b.y - a.y ) * ( dPosA[ doa ].x - a.x ) / ( b.x - a.x ) + 0.5 );
-				x = dPosA[ doa ].x;
-			}
-			if( outCodeOut == outCode1 )
-			{
-				a.x = x;
-				a.y = y;
-				outCode1 = getOutCode( a );
-			}
-			else
-			{
-				b.x = x;
-				b.y = y;
-				outCode2 = getOutCode( b );
-			}
-		}
-	}
-	if( ok )
-	{
-		int xlen = b.x - a.x, axlen = abs( xlen );
-		int ylen = b.y - a.y, aylen = abs( ylen );
-		double xf = (double)xlen / ( aylen ? aylen : 1 );
-		double yf = (double)ylen / ( axlen ? axlen : 1 );
-		if( axlen > aylen )
-			xf = xf < 0 ? -1 : 1;
-		else
-			yf = yf < 0 ? -1 : 1;
-		double x = (double)a.x, y = (double)a.y;
-		if( alpha[ alphaAnzahl ] )
-		{
-			unsigned char *cf = (unsigned char*)&fc;
-			cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-		}
-		int maxP = (int)( sqrt( xlen * xlen + ylen * ylen ) + 0.5 );
-		int count = 0;
-		int alpha = ( ( fc >> 24 ) & 0xFF );
-		int na = ( 0x100 - alpha );
-		int i1 = ( alpha * ( fc & 0xFF00FF ) ) >> 8;
-		int i2 = ( alpha * ( fc & 0x00FF00 ) ) >> 8;
-		while( !( (int)( x + 0.5 ) == b.x && (int)( y + 0.5 ) == b.y ) && count < maxP )
-		{
-			++count;
-			int &pixel = this->fc[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * size.x ];
-			pixel = ( ( ( ( ( na * ( pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					  ( pixel & 0xFF000000 ) ) * ( pixel != 0 || !alpha3D ) | ( pixel == 0 && alpha3D ) * fc;
-			x += xf, y += yf;
-		}
-		rend = 1;
-	}
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    a += drawOff[ doa ];
+    b += drawOff[ doa ];
+    char outCode1 = getOutCode( a );
+    char outCode2 = getOutCode( b );
+    bool ok = 0;
+    while( 1 )
+    {
+        int xMax = dSizeA[ doa ].x - 1;
+        int yMax = dSizeA[ doa ].y - 1;
+        if( !( outCode1 | outCode2 ) )
+        {
+            ok = 1;
+            break;
+        }
+        else if( outCode1 & outCode2 )
+            break;
+        else
+        {
+            int x = 0, y = 0;
+            char outCodeOut = outCode1 ? outCode1 : outCode2;
+            if( outCodeOut & 8 )
+            {
+                x = (int)( a.x + ( b.x - a.x ) * ( yMax - a.y ) / ( b.y - a.y ) + 0.5 );
+                y = yMax;
+            }
+            else if( outCodeOut & 4 )
+            {
+                x = (int)( a.x + ( b.x - a.x ) * ( dPosA[ doa ].y - a.y ) / ( b.y - a.y ) + 0.5 );
+                y = dPosA[ doa ].y;
+            }
+            else if( outCodeOut & 2 )
+            {
+                y = (int)( a.y + ( b.y - a.y ) * ( xMax - a.x ) / ( b.x - a.x ) + 0.5 );
+                x = xMax;
+            }
+            else if( outCodeOut & 1 )
+            {
+                y = (int)( a.y + ( b.y - a.y ) * ( dPosA[ doa ].x - a.x ) / ( b.x - a.x ) + 0.5 );
+                x = dPosA[ doa ].x;
+            }
+            if( outCodeOut == outCode1 )
+            {
+                a.x = x;
+                a.y = y;
+                outCode1 = getOutCode( a );
+            }
+            else
+            {
+                b.x = x;
+                b.y = y;
+                outCode2 = getOutCode( b );
+            }
+        }
+    }
+    if( ok )
+    {
+        int xlen = b.x - a.x, axlen = abs( xlen );
+        int ylen = b.y - a.y, aylen = abs( ylen );
+        double xf = (double)xlen / ( aylen ? aylen : 1 );
+        double yf = (double)ylen / ( axlen ? axlen : 1 );
+        if( axlen > aylen )
+            xf = xf < 0 ? -1 : 1;
+        else
+            yf = yf < 0 ? -1 : 1;
+        double x = (double)a.x, y = (double)a.y;
+        if( alpha[ alphaAnzahl ] )
+        {
+            unsigned char *cf = (unsigned char*)&fc;
+            cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+        }
+        int maxP = (int)( sqrt( xlen * xlen + ylen * ylen ) + 0.5 );
+        int count = 0;
+        int alpha = ( ( fc >> 24 ) & 0xFF );
+        int na = ( 0x100 - alpha );
+        int i1 = ( alpha * ( fc & 0xFF00FF ) ) >> 8;
+        int i2 = ( alpha * ( fc & 0x00FF00 ) ) >> 8;
+        while( !( (int)( x + 0.5 ) == b.x && (int)( y + 0.5 ) == b.y ) && count < maxP )
+        {
+            ++count;
+            int &pixel = this->fc[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * size.x ];
+            pixel = ( ( ( ( ( na * ( pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                      ( pixel & 0xFF000000 ) ) * ( pixel != 0 || !alpha3D ) | ( pixel == 0 && alpha3D ) * fc;
+            x += xf, y += yf;
+        }
+        rend = 1;
+    }
 }
 
 void Bild::fillCircle( int xOff, int yOff, int r, int fc ) // zeichnet einen Kreis um Punkt( xOff, yOff ) mit radius r
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	for( int i = r; i > 0; i-- )
-		drawKreis( xOff, yOff, i, fc );
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    for( int i = r; i > 0; i-- )
+        drawKreis( xOff, yOff, i, fc );
 }
 
 void Bild::drawKreis( int xOff, int yOff, int r, int fc ) // zeichnet einen Kreis um Punkt( xOff, yOff ) mit radius r
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		drawKreisAlpha( xOff, yOff, r, fc );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	xOff += drawOff[ doa ].x;
-	yOff += drawOff[ doa ].y;
-	if( xOff + r < dpx || xOff - r >= dgx || yOff + r < dpy || yOff - r >= dgy )
-		return;
-	for( int a = 0; a < r; ++a )
-	{
-		int b = (int)( sqrt( (long)( r * r - a * a ) ) + 0.5 );
-		if( xOff + a < dgx && xOff + a > dpx && yOff + b < dgy && yOff + b > dpy )
-			this->fc[ xOff + a + ( yOff + b ) * size.x ] = fc;
-		if( xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy )
-			this->fc[ xOff - a + ( yOff + b ) * size.x ] = fc;
-		if( xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy )
-			this->fc[ xOff + a + ( yOff - b ) * size.x ] = fc;
-		if( xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy )
-			this->fc[ xOff - a + ( yOff - b ) * size.x ] = fc;
-		if( xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy )
-			this->fc[ xOff + b + ( yOff + a ) * size.x ] = fc;
-		if( xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy )
-			this->fc[ xOff - b + ( yOff + a ) * size.x ] = fc;
-		if( xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy )
-			this->fc[ xOff + b + ( yOff - a ) * size.x ] = fc;
-		if( xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy )
-			this->fc[ xOff - b + ( yOff - a ) * size.x ] = fc;
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        drawKreisAlpha( xOff, yOff, r, fc );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    xOff += drawOff[ doa ].x;
+    yOff += drawOff[ doa ].y;
+    if( xOff + r < dpx || xOff - r >= dgx || yOff + r < dpy || yOff - r >= dgy )
+        return;
+    for( int a = 0; a < r; ++a )
+    {
+        int b = (int)( sqrt( (long)( r * r - a * a ) ) + 0.5 );
+        if( xOff + a < dgx && xOff + a > dpx && yOff + b < dgy && yOff + b > dpy )
+            this->fc[ xOff + a + ( yOff + b ) * size.x ] = fc;
+        if( xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy )
+            this->fc[ xOff - a + ( yOff + b ) * size.x ] = fc;
+        if( xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy )
+            this->fc[ xOff + a + ( yOff - b ) * size.x ] = fc;
+        if( xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy )
+            this->fc[ xOff - a + ( yOff - b ) * size.x ] = fc;
+        if( xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy )
+            this->fc[ xOff + b + ( yOff + a ) * size.x ] = fc;
+        if( xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy )
+            this->fc[ xOff - b + ( yOff + a ) * size.x ] = fc;
+        if( xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy )
+            this->fc[ xOff + b + ( yOff - a ) * size.x ] = fc;
+        if( xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy )
+            this->fc[ xOff - b + ( yOff - a ) * size.x ] = fc;
+    }
+    rend = 1;
 }
 
 void Bild::drawKreisAlpha( int xOff, int yOff, int r, int fc )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	xOff += drawOff[ doa ].x;
-	yOff += drawOff[ doa ].y;
-	if( xOff + r < dpx || xOff - r >= dgx || yOff + r < dpy || yOff - r >= dgy )
-		return;
-	if( alpha[ alphaAnzahl ] < 0xFF )
-	{
-		unsigned char *cf = (unsigned char*)&fc;
-		cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-	}
-	int alpha = ( ( fc >> 24 ) & 0xFF );
-	int na = ( 0x100 - alpha );
-	int i1 = ( alpha * ( fc & 0xFF00FF ) ) >> 8;
-	int i2 = ( alpha * ( fc & 0x00FF00 ) ) >> 8;
-	for( int a = 0; a < r; ++a )
-	{
-		int b = (int)( sqrt( (long)( r * r - a * a ) ) + 0.5 );
-		int *pixel = 0;
-		if( xOff + a < dgx && xOff + a > dpx && yOff + b < dgy && yOff + b > dpy )
-		{
-			pixel = &this->fc[ xOff + a + ( yOff + b ) * size.x ];
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
-		}
-		if( xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy )
-		{
-			pixel = &this->fc[ xOff - a + ( yOff + b ) * size.x ];
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
-		}
-		if( xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy )
-		{
-			pixel = &this->fc[ xOff + a + ( yOff - b ) * size.x ];
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
-		}
-		if( xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy )
-		{
-			pixel = &this->fc[ xOff - a + ( yOff - b ) * size.x ];
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
-		}
-		if( xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy )
-		{
-			pixel = &this->fc[ xOff + b + ( yOff + a ) * size.x ];
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
-		}
-		if( xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy )
-		{
-			pixel = &this->fc[ xOff - b + ( yOff + a ) * size.x ];
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
-		}
-		if( xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy )
-		{
-			pixel = &this->fc[ xOff + b + ( yOff - a ) * size.x ];
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
-		}
-		if( xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy )
-		{
-			pixel = &this->fc[ xOff - b + ( yOff - a ) * size.x ];
-			*pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-				( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
-					   ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    xOff += drawOff[ doa ].x;
+    yOff += drawOff[ doa ].y;
+    if( xOff + r < dpx || xOff - r >= dgx || yOff + r < dpy || yOff - r >= dgy )
+        return;
+    if( alpha[ alphaAnzahl ] < 0xFF )
+    {
+        unsigned char *cf = (unsigned char*)&fc;
+        cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+    }
+    int alpha = ( ( fc >> 24 ) & 0xFF );
+    int na = ( 0x100 - alpha );
+    int i1 = ( alpha * ( fc & 0xFF00FF ) ) >> 8;
+    int i2 = ( alpha * ( fc & 0x00FF00 ) ) >> 8;
+    for( int a = 0; a < r; ++a )
+    {
+        int b = (int)( sqrt( (long)( r * r - a * a ) ) + 0.5 );
+        int *pixel = 0;
+        if( xOff + a < dgx && xOff + a > dpx && yOff + b < dgy && yOff + b > dpy )
+        {
+            pixel = &this->fc[ xOff + a + ( yOff + b ) * size.x ];
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
+        }
+        if( xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy )
+        {
+            pixel = &this->fc[ xOff - a + ( yOff + b ) * size.x ];
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
+        }
+        if( xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy )
+        {
+            pixel = &this->fc[ xOff + a + ( yOff - b ) * size.x ];
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
+        }
+        if( xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy )
+        {
+            pixel = &this->fc[ xOff - a + ( yOff - b ) * size.x ];
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
+        }
+        if( xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy )
+        {
+            pixel = &this->fc[ xOff + b + ( yOff + a ) * size.x ];
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
+        }
+        if( xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy )
+        {
+            pixel = &this->fc[ xOff - b + ( yOff + a ) * size.x ];
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
+        }
+        if( xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy )
+        {
+            pixel = &this->fc[ xOff + b + ( yOff - a ) * size.x ];
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
+        }
+        if( xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy )
+        {
+            pixel = &this->fc[ xOff - b + ( yOff - a ) * size.x ];
+            *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                       ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
+        }
+    }
+    rend = 1;
 }
 
 void Bild::drawBild( int x, int y, int br, int hi, Bild &zBild ) // zeichet zBild
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		alphaBild( x, y, br, hi, zBild );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
-		return;
-	br = minInt( br, zBild.getBreite() );
-	hi = minInt( hi, zBild.getHeight() );
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + br, dgx );
-	dgy = minInt( y + hi, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	int xx, ygr, ygr2;
-	for( int yy = yst2; yy < dgy; ++yy )
-	{
-		ygr = yy * size.x;
-		ygr2 = ( yy - yst2 + yst ) * bb;
-		for( xx = xst2; xx < dgx; ++xx )
-			fc[ xx + ygr ] = ff[ ( xx - xst2 + xst ) + ygr2 ];
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        alphaBild( x, y, br, hi, zBild );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
+        return;
+    br = minInt( br, zBild.getBreite() );
+    hi = minInt( hi, zBild.getHeight() );
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + br, dgx );
+    dgy = minInt( y + hi, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    int xx, ygr, ygr2;
+    for( int yy = yst2; yy < dgy; ++yy )
+    {
+        ygr = yy * size.x;
+        ygr2 = ( yy - yst2 + yst ) * bb;
+        for( xx = xst2; xx < dgx; ++xx )
+            fc[ xx + ygr ] = ff[ ( xx - xst2 + xst ) + ygr2 ];
+    }
+    rend = 1;
 }
 
 void Bild::alphaBild( int x, int y, int br, int hi, Bild &zBild )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
-		return;
-	br = minInt( br, zBild.getBreite() );
-	hi = minInt( hi, zBild.getHeight() );
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + br, dgx );
-	dgy = minInt( y + hi, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	if( !alpha[ alphaAnzahl ] )
-	{
-		int xx, ygr, ygr2;
-		for( int yy = yst2; yy < dgy; ++yy )
-		{
-			ygr = yy * size.x;
-			ygr2 = ( yy - yst2 + yst ) * bb;
-			for( xx = xst2; xx < dgx; ++xx )
-				alphaPixelP( fc[ xx + ygr ], ff[ ( xx - xst2 + xst ) + ygr2 ] );
-		}
-	}
-	else
-	{
-		int xx, ygr, ygr2;
-		for( int yy = yst2; yy < dgy; ++yy )
-		{
-			ygr = yy * size.x;
-			ygr2 = ( yy - yst2 + yst ) * bb;
-			for( xx = xst2; xx < dgx; ++xx )
-			{
-				int fc = ff[ ( xx - xst2 + xst ) + ygr2 ];
-				unsigned char *cf = (unsigned char*)&fc;
-				cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-				alphaPixelP( this->fc[ xx + ygr ], fc );
-			}
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
+        return;
+    br = minInt( br, zBild.getBreite() );
+    hi = minInt( hi, zBild.getHeight() );
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + br, dgx );
+    dgy = minInt( y + hi, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    if( !alpha[ alphaAnzahl ] )
+    {
+        int xx, ygr, ygr2;
+        for( int yy = yst2; yy < dgy; ++yy )
+        {
+            ygr = yy * size.x;
+            ygr2 = ( yy - yst2 + yst ) * bb;
+            for( xx = xst2; xx < dgx; ++xx )
+                alphaPixelP( fc[ xx + ygr ], ff[ ( xx - xst2 + xst ) + ygr2 ] );
+        }
+    }
+    else
+    {
+        int xx, ygr, ygr2;
+        for( int yy = yst2; yy < dgy; ++yy )
+        {
+            ygr = yy * size.x;
+            ygr2 = ( yy - yst2 + yst ) * bb;
+            for( xx = xst2; xx < dgx; ++xx )
+            {
+                int fc = ff[ ( xx - xst2 + xst ) + ygr2 ];
+                unsigned char *cf = (unsigned char*)&fc;
+                cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+                alphaPixelP( this->fc[ xx + ygr ], fc );
+            }
+        }
+    }
+    rend = 1;
 }
 
 void Bild::drawBild90( int x, int y, int br, int hi, Bild &zBild ) // Zeichnet ein um 90 Grad nach rchts gedrehtes Bild
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		alphaBild90( x, y, br, hi, zBild );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + hi < dpx || y + br < dpy || x > dgx || y > dgy )
-		return;
-	br = minInt( br, zBild.getBreite() );
-	hi = minInt( hi, zBild.getHeight() );
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + hi, dgx );
-	dgy = minInt( y + br, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	int yy, xbb;
-	for( int xx = xst2; xx < dgx; ++xx )
-	{
-		xbb = ( zBild.getHeight() - ( xx - xst2 + xst + 1 ) ) * bb;
-		for( yy = yst2; yy < dgy; ++yy )
-			fc[ xx + yy * size.x ] = ff[ ( yy - yst2 + yst ) + xbb ];
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        alphaBild90( x, y, br, hi, zBild );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + hi < dpx || y + br < dpy || x > dgx || y > dgy )
+        return;
+    br = minInt( br, zBild.getBreite() );
+    hi = minInt( hi, zBild.getHeight() );
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + hi, dgx );
+    dgy = minInt( y + br, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    int yy, xbb;
+    for( int xx = xst2; xx < dgx; ++xx )
+    {
+        xbb = ( zBild.getHeight() - ( xx - xst2 + xst + 1 ) ) * bb;
+        for( yy = yst2; yy < dgy; ++yy )
+            fc[ xx + yy * size.x ] = ff[ ( yy - yst2 + yst ) + xbb ];
+    }
+    rend = 1;
 }
 
 void Bild::alphaBild90( int x, int y, int br, int hi, Bild &zBild )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + hi < dpx || y + br < dpy || x > dgx || y > dgy )
-		return;
-	br = minInt( br, zBild.getBreite() );
-	hi = minInt( hi, zBild.getHeight() );
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + hi, dgx );
-	dgy = minInt( y + br, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	if( !alpha[ alphaAnzahl ] )
-	{
-		int yy, xbb;
-		for( int xx = xst2; xx < dgx; ++xx )
-		{
-			xbb = ( zBild.getHeight() - ( xx - xst2 + xst + 1 ) ) * bb;
-			for( yy = yst2; yy < dgy; ++yy )
-				alphaPixelP( xx, yy, ff[ ( yy - yst2 + yst ) + xbb ] );
-		}
-	}
-	else
-	{
-		int yy, xbb;
-		for( int xx = xst2; xx < dgx; ++xx )
-		{
-			xbb = ( zBild.getHeight() - ( xx - xst2 + xst + 1 ) ) * bb;
-			for( yy = yst2; yy < dgy; ++yy )
-			{
-				int fc = ff[ ( yy - yst2 + yst ) + xbb ];
-				unsigned char *cf = (unsigned char*)&fc;
-				cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-				alphaPixelP( xx, yy, fc );
-			}
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + hi < dpx || y + br < dpy || x > dgx || y > dgy )
+        return;
+    br = minInt( br, zBild.getBreite() );
+    hi = minInt( hi, zBild.getHeight() );
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + hi, dgx );
+    dgy = minInt( y + br, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    if( !alpha[ alphaAnzahl ] )
+    {
+        int yy, xbb;
+        for( int xx = xst2; xx < dgx; ++xx )
+        {
+            xbb = ( zBild.getHeight() - ( xx - xst2 + xst + 1 ) ) * bb;
+            for( yy = yst2; yy < dgy; ++yy )
+                alphaPixelP( xx, yy, ff[ ( yy - yst2 + yst ) + xbb ] );
+        }
+    }
+    else
+    {
+        int yy, xbb;
+        for( int xx = xst2; xx < dgx; ++xx )
+        {
+            xbb = ( zBild.getHeight() - ( xx - xst2 + xst + 1 ) ) * bb;
+            for( yy = yst2; yy < dgy; ++yy )
+            {
+                int fc = ff[ ( yy - yst2 + yst ) + xbb ];
+                unsigned char *cf = (unsigned char*)&fc;
+                cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+                alphaPixelP( xx, yy, fc );
+            }
+        }
+    }
+    rend = 1;
 }
 
 void Bild::drawBild180( int x, int y, int br, int hi, Bild &zBild ) // Zeichnet ein um 180 Grad nach rchts gedrehtes Bild
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		alphaBild180( x, y, br, hi, zBild );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
-		return;
-	br = minInt( br, zBild.getBreite() );
-	hi = minInt( hi, zBild.getHeight() );
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + br, dgx );
-	dgy = minInt( y + hi, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	int xx, ygr, ybb;
-	for( int yy = yst2; yy < dgy; ++yy )
-	{
-		ygr = yy * size.x;
-		ybb = ( zBild.getHeight() - ( yy - yst2 + yst + 1 ) ) * bb;
-		for( xx = xst2; xx < dgx; ++xx )
-			fc[ xx + ygr ] = ff[ ( bb - ( xx - xst2 + xst + 1 ) ) + ybb ];
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        alphaBild180( x, y, br, hi, zBild );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
+        return;
+    br = minInt( br, zBild.getBreite() );
+    hi = minInt( hi, zBild.getHeight() );
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + br, dgx );
+    dgy = minInt( y + hi, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    int xx, ygr, ybb;
+    for( int yy = yst2; yy < dgy; ++yy )
+    {
+        ygr = yy * size.x;
+        ybb = ( zBild.getHeight() - ( yy - yst2 + yst + 1 ) ) * bb;
+        for( xx = xst2; xx < dgx; ++xx )
+            fc[ xx + ygr ] = ff[ ( bb - ( xx - xst2 + xst + 1 ) ) + ybb ];
+    }
+    rend = 1;
 }
 
 void Bild::alphaBild180( int x, int y, int br, int hi, Bild &zBild )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
-		return;
-	br = minInt( br, zBild.getBreite() );
-	hi = minInt( hi, zBild.getHeight() );
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + br, dgx );
-	dgy = minInt( y + hi, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	if( !alpha[ alphaAnzahl ] )
-	{
-		int xx, ygr, ybb;
-		for( int yy = yst2; yy < dgy; ++yy )
-		{
-			ygr = yy * size.x;
-			ybb = ( zBild.getHeight() - ( yy - yst2 + yst + 1 ) ) * bb;
-			for( xx = xst2; xx < dgx; ++xx )
-				alphaPixelP( fc[ xx + ygr ], ff[ ( bb - ( xx - xst2 + xst + 1 ) ) + ybb ] );
-		}
-	}
-	else
-	{
-		int xx, ygr, ybb;
-		for( int yy = yst2; yy < dgy; ++yy )
-		{
-			ygr = yy * size.x;
-			ybb = ( zBild.getHeight() - ( yy - yst2 + yst + 1 ) ) * bb;
-			for( xx = xst2; xx < dgx; ++xx )
-			{
-				int fc = ff[ ( bb - ( xx - xst2 + xst + 1 ) ) + ybb ];
-				unsigned char *cf = (unsigned char*)&fc;
-				cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-				alphaPixelP( this->fc[ xx + ygr ], fc );
-			}
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
+        return;
+    br = minInt( br, zBild.getBreite() );
+    hi = minInt( hi, zBild.getHeight() );
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + br, dgx );
+    dgy = minInt( y + hi, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    if( !alpha[ alphaAnzahl ] )
+    {
+        int xx, ygr, ybb;
+        for( int yy = yst2; yy < dgy; ++yy )
+        {
+            ygr = yy * size.x;
+            ybb = ( zBild.getHeight() - ( yy - yst2 + yst + 1 ) ) * bb;
+            for( xx = xst2; xx < dgx; ++xx )
+                alphaPixelP( fc[ xx + ygr ], ff[ ( bb - ( xx - xst2 + xst + 1 ) ) + ybb ] );
+        }
+    }
+    else
+    {
+        int xx, ygr, ybb;
+        for( int yy = yst2; yy < dgy; ++yy )
+        {
+            ygr = yy * size.x;
+            ybb = ( zBild.getHeight() - ( yy - yst2 + yst + 1 ) ) * bb;
+            for( xx = xst2; xx < dgx; ++xx )
+            {
+                int fc = ff[ ( bb - ( xx - xst2 + xst + 1 ) ) + ybb ];
+                unsigned char *cf = (unsigned char*)&fc;
+                cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+                alphaPixelP( this->fc[ xx + ygr ], fc );
+            }
+        }
+    }
+    rend = 1;
 }
 
 void Bild::drawBild270( int x, int y, int br, int hi, Bild &zBild ) // Zeichnet ein um 270 Grad nach rchts gedrehtes Bild
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		alphaBild270( x, y, br, hi, zBild );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + hi < dpx || y + br < dpy || x > dgx || y > dgy )
-		return;
-	br = minInt( br, zBild.getBreite() );
-	hi = minInt( hi, zBild.getHeight() );
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + hi, dgx );
-	dgy = minInt( y + br, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	int yy, xbb;
-	for( int xx = xst2; xx < dgx; ++xx )
-	{
-		xbb = ( xx - xst2 + xst ) * bb;
-		for( yy = yst2; yy < dgy; ++yy )
-			fc[ xx + yy * size.x ] = ff[ ( bb - ( yy - yst2 + yst + 1 ) ) + xbb ];
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        alphaBild270( x, y, br, hi, zBild );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + hi < dpx || y + br < dpy || x > dgx || y > dgy )
+        return;
+    br = minInt( br, zBild.getBreite() );
+    hi = minInt( hi, zBild.getHeight() );
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + hi, dgx );
+    dgy = minInt( y + br, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    int yy, xbb;
+    for( int xx = xst2; xx < dgx; ++xx )
+    {
+        xbb = ( xx - xst2 + xst ) * bb;
+        for( yy = yst2; yy < dgy; ++yy )
+            fc[ xx + yy * size.x ] = ff[ ( bb - ( yy - yst2 + yst + 1 ) ) + xbb ];
+    }
+    rend = 1;
 }
 
 void Bild::alphaBild270( int x, int y, int br, int hi, Bild &zBild )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + hi < dpx || y + br < dpy || x > dgx || y > dgy )
-		return;
-	br = minInt( br, zBild.getBreite() );
-	hi = minInt( hi, zBild.getBreite() );
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + hi, dgx );
-	dgy = minInt( y + br, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	if( !alpha[ alphaAnzahl ] )
-	{
-		int yy, xbb;
-		for( int xx = xst2; xx < dgx; ++xx )
-		{
-			xbb = ( xx - xst2 + xst ) * bb;
-			for( yy = yst2; yy < dgy; ++yy )
-				alphaPixelP( xx, yy, ff[ ( bb - ( yy - yst2 + yst + 1 ) ) + xbb ] );
-		}
-	}
-	else
-	{
-		int yy, xbb;
-		for( int xx = xst2; xx < dgx; ++xx )
-		{
-			xbb = ( xx - xst2 + xst ) * bb;
-			for( yy = yst2; yy < dgy; ++yy )
-			{
-				int fc = ff[ ( bb - ( yy - yst2 + yst + 1 ) ) + xbb ];
-				unsigned char *cf = (unsigned char*)&fc;
-				cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-				alphaPixelP( xx, yy, fc );
-			}
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + hi < dpx || y + br < dpy || x > dgx || y > dgy )
+        return;
+    br = minInt( br, zBild.getBreite() );
+    hi = minInt( hi, zBild.getBreite() );
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + hi, dgx );
+    dgy = minInt( y + br, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    if( !alpha[ alphaAnzahl ] )
+    {
+        int yy, xbb;
+        for( int xx = xst2; xx < dgx; ++xx )
+        {
+            xbb = ( xx - xst2 + xst ) * bb;
+            for( yy = yst2; yy < dgy; ++yy )
+                alphaPixelP( xx, yy, ff[ ( bb - ( yy - yst2 + yst + 1 ) ) + xbb ] );
+        }
+    }
+    else
+    {
+        int yy, xbb;
+        for( int xx = xst2; xx < dgx; ++xx )
+        {
+            xbb = ( xx - xst2 + xst ) * bb;
+            for( yy = yst2; yy < dgy; ++yy )
+            {
+                int fc = ff[ ( bb - ( yy - yst2 + yst + 1 ) ) + xbb ];
+                unsigned char *cf = (unsigned char*)&fc;
+                cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+                alphaPixelP( xx, yy, fc );
+            }
+        }
+    }
+    rend = 1;
 }
 
 void Bild::drawBildSkall( int x, int y, int br, int hi, Bild &zBild ) // zeichet zBild Skalliert
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		alphaBildSkall( x, y, br, hi, zBild );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
-		return;
-	double xo = zBild.getBreite() / (double)br;
-	double yo = zBild.getHeight() / (double)hi;
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + br, dgx );
-	dgy = minInt( y + hi, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	int xx, ygr, ygr2;
-	double xb = 0, yb = yst * yo;
-	for( int yy = yst2; yy < dgy; ++yy, yb += yo )
-	{
-		ygr = yy * size.x;
-		ygr2 = (int)( ( yy - yst2 + yst ) * yo ) * bb;
-		for( xx = xst2, xb = xst * xo; xx < dgx; ++xx, xb += xo )
-			fc[ xx + ygr ] = ff[ (int)xb + ygr2 ];
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        alphaBildSkall( x, y, br, hi, zBild );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
+        return;
+    double xo = zBild.getBreite() / (double)br;
+    double yo = zBild.getHeight() / (double)hi;
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + br, dgx );
+    dgy = minInt( y + hi, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    int xx, ygr, ygr2;
+    double xb = 0, yb = yst * yo;
+    for( int yy = yst2; yy < dgy; ++yy, yb += yo )
+    {
+        ygr = yy * size.x;
+        ygr2 = (int)( ( yy - yst2 + yst ) * yo ) * bb;
+        for( xx = xst2, xb = xst * xo; xx < dgx; ++xx, xb += xo )
+            fc[ xx + ygr ] = ff[ (int)xb + ygr2 ];
+    }
+    rend = 1;
 }
 
 void Bild::alphaBildSkall( int x, int y, int br, int hi, Bild &zBild )
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	x += drawOff[ doa ].x;
-	y += drawOff[ doa ].y;
-	if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
-		return;
-	double xo = zBild.getBreite() / (double)br;
-	double yo = zBild.getHeight() / (double)hi;
-	int xst = maxInt( dpx - x, 0 );
-	int yst = maxInt( dpy - y, 0 );
-	int xst2 = maxInt( x, dpx );
-	int yst2 = maxInt( y, dpy );
-	dgx = minInt( x + br, dgx );
-	dgy = minInt( y + hi, dgy );
-	int bb = zBild.getBreite();
-	int *ff = zBild.getBuffer();
-	int xx, ygr, ygr2;
-	double xb = 0;
-	for( int yy = yst2; yy < dgy; ++yy )
-	{
-		ygr = yy * size.x;
-		ygr2 = (int)( ( yy - yst2 + yst ) * yo ) * bb;
-		for( xx = xst2, xb = xst * xo; xx < dgx; ++xx, xb += xo )
-		{
-			int f = ff[ (int)xb + ygr2 ];
-			unsigned char *cf = (unsigned char*)&f;
-			cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-			alphaPixelP( fc[ xx + ygr ], f );
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    x += drawOff[ doa ].x;
+    y += drawOff[ doa ].y;
+    if( x + br < dpx || y + hi < dpy || x > dgx || y > dgy )
+        return;
+    double xo = zBild.getBreite() / (double)br;
+    double yo = zBild.getHeight() / (double)hi;
+    int xst = maxInt( dpx - x, 0 );
+    int yst = maxInt( dpy - y, 0 );
+    int xst2 = maxInt( x, dpx );
+    int yst2 = maxInt( y, dpy );
+    dgx = minInt( x + br, dgx );
+    dgy = minInt( y + hi, dgy );
+    int bb = zBild.getBreite();
+    int *ff = zBild.getBuffer();
+    int xx, ygr, ygr2;
+    double xb = 0;
+    for( int yy = yst2; yy < dgy; ++yy )
+    {
+        ygr = yy * size.x;
+        ygr2 = (int)( ( yy - yst2 + yst ) * yo ) * bb;
+        for( xx = xst2, xb = xst * xo; xx < dgx; ++xx, xb += xo )
+        {
+            int f = ff[ (int)xb + ygr2 ];
+            unsigned char *cf = (unsigned char*)&f;
+            cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+            alphaPixelP( fc[ xx + ygr ], f );
+        }
+    }
+    rend = 1;
 }
 
 void Bild::drawDreieck( Punkt a, Punkt b, Punkt c, int farbe ) // füllt eine Dreieck aus
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		drawDreieckAlpha( a, b, c, farbe );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	a += drawOff[ doa ];
-	b += drawOff[ doa ];
-	c += drawOff[ doa ];
-	if( ( a.x < dpx && b.x < dpx && c.x < dpx ) || ( a.y < dpy && b.y < dpy && c.y < dpy ) ||
-		( a.x > dgx && b.x > dgx && c.x > dgx ) || ( a.y > dgy && b.y > dgy && c.y > dgy ) )
-		return;
-	if( b.y < a.y )
-		a.Swap( b );
-	if( c.y < b.y )
-		b.Swap( c );
-	if( b.y < a.y )
-		a.Swap( b );
-	if( a.y == b.y )
-	{
-		if( b.x < a.x )
-			a.Swap( b );
-		const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
-		const float m3 = (float)( b.x - c.x ) / (float)( b.y - c.y );
-		float b2 = (float)a.x - m2 * (float)a.y;
-		float b3 = (float)b.x - m3 * (float)b.y;
-		drawFlatDreieck( b.y, c.y, m2, b2, m3, b3, farbe );
-	}
-	else if( b.y == c.y )
-	{
-		if( c.x < b.x )
-			b.Swap( c );
-		const float m1 = (float)( a.x - b.x ) / (float)( a.y - b.y );
-		const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
-		float b1 = (float)a.x - m1 * (float)a.y;
-		float b2 = (float)a.x - m2 * (float)a.y;
-		drawFlatDreieck( a.y, b.y, m1, b1, m2, b2, farbe );
-	}
-	else
-	{
-		const float m1 = (float)( a.x - b.x ) / (float)( a.y - b.y );
-		const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
-		const float m3 = (float)( b.x - c.x ) / (float)( b.y - c.y );
-		float b1 = (float)a.x - m1 * (float)a.y;
-		float b2 = (float)a.x - m2 * (float)a.y;
-		float b3 = (float)b.x - m3 * (float)b.y;
-		const float qx = m2 * (float)b.y + b2;
-		if( qx < b.x )
-		{
-			drawFlatDreieck( a.y, b.y, m2, b2, m1, b1, farbe );
-			drawFlatDreieck( b.y, c.y, m2, b2, m3, b3, farbe );
-		}
-		else
-		{
-			drawFlatDreieck( a.y, b.y, m1, b1, m2, b2, farbe );
-			drawFlatDreieck( b.y, c.y, m3, b3, m2, b2, farbe );
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        drawDreieckAlpha( a, b, c, farbe );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    a += drawOff[ doa ];
+    b += drawOff[ doa ];
+    c += drawOff[ doa ];
+    if( ( a.x < dpx && b.x < dpx && c.x < dpx ) || ( a.y < dpy && b.y < dpy && c.y < dpy ) ||
+        ( a.x > dgx && b.x > dgx && c.x > dgx ) || ( a.y > dgy && b.y > dgy && c.y > dgy ) )
+        return;
+    if( b.y < a.y )
+        a.Swap( b );
+    if( c.y < b.y )
+        b.Swap( c );
+    if( b.y < a.y )
+        a.Swap( b );
+    if( a.y == b.y )
+    {
+        if( b.x < a.x )
+            a.Swap( b );
+        const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
+        const float m3 = (float)( b.x - c.x ) / (float)( b.y - c.y );
+        float b2 = (float)a.x - m2 * (float)a.y;
+        float b3 = (float)b.x - m3 * (float)b.y;
+        drawFlatDreieck( b.y, c.y, m2, b2, m3, b3, farbe );
+    }
+    else if( b.y == c.y )
+    {
+        if( c.x < b.x )
+            b.Swap( c );
+        const float m1 = (float)( a.x - b.x ) / (float)( a.y - b.y );
+        const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
+        float b1 = (float)a.x - m1 * (float)a.y;
+        float b2 = (float)a.x - m2 * (float)a.y;
+        drawFlatDreieck( a.y, b.y, m1, b1, m2, b2, farbe );
+    }
+    else
+    {
+        const float m1 = (float)( a.x - b.x ) / (float)( a.y - b.y );
+        const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
+        const float m3 = (float)( b.x - c.x ) / (float)( b.y - c.y );
+        float b1 = (float)a.x - m1 * (float)a.y;
+        float b2 = (float)a.x - m2 * (float)a.y;
+        float b3 = (float)b.x - m3 * (float)b.y;
+        const float qx = m2 * (float)b.y + b2;
+        if( qx < b.x )
+        {
+            drawFlatDreieck( a.y, b.y, m2, b2, m1, b1, farbe );
+            drawFlatDreieck( b.y, c.y, m2, b2, m3, b3, farbe );
+        }
+        else
+        {
+            drawFlatDreieck( a.y, b.y, m1, b1, m2, b2, farbe );
+            drawFlatDreieck( b.y, c.y, m3, b3, m2, b2, farbe );
+        }
+    }
+    rend = 1;
 }
 
 void Bild::drawDreieckTextur( Punkt a, Punkt b, Punkt c, Punkt ta, Punkt tb, Punkt tc, Bild &textur ) // füllt eine Dreieck aus
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		drawDreieckTexturAlpha( a, b, c, ta, tb, tc, textur );
-		return;
-	}
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	a += drawOff[ doa ];
-	b += drawOff[ doa ];
-	c += drawOff[ doa ];
-	if( ( a.x < dpx && b.x < dpx && c.x < dpx ) || ( a.y < dpy && b.y < dpy && c.y < dpy ) ||
-		( a.x > dgx && b.x > dgx && c.x > dgx ) || ( a.y > dgy && b.y > dgy && c.y > dgy ) )
-		return;
-	if( b.y < a.y )
-	{
-		a.Swap( b );
-		ta.Swap( tb );
-	}
-	if( c.y < b.y )
-	{
-		b.Swap( c );
-		tb.Swap( tc );
-	}
-	if( b.y < a.y )
-	{
-		a.Swap( b );
-		ta.Swap( tb );
-	}
-	const double m1 = (double)( a.x - b.x ) / ( a.y - b.y );
-	const double m2 = (double)( a.x - c.x ) / ( a.y - c.y );
-	const double m3 = (double)( b.x - c.x ) / ( b.y - c.y );
-	double b1 = a.x - m1 * a.y;
-	double b2 = a.x - m2 * a.y;
-	double b3 = b.x - m3 * b.y;
-	const double qx = m2 * b.y + b2;
-	if( qx < b.x )
-	{
-		double tx1o, ty1o, tx2o, ty2o;
-		if( c.y - a.y )
-		{
-			tx1o = (double)( tc.x - ta.x ) / ( c.y - a.y );
-			ty1o = (double)( tc.y - ta.y ) / ( c.y - a.y );
-		}
-		else
-		{
-			tx1o = 0;
-			ty1o = 0;
-		}
-		if( b.y - a.y )
-		{
-			tx2o = (double)( tb.x - ta.x ) / ( b.y - a.y );
-			ty2o = (double)( tb.y - ta.y ) / ( b.y - a.y );
-		}
-		else
-		{
-			tx2o = 0;
-			ty2o = 0;
-		}
-		Vec2< double > q( ta.x + tx1o * ( b.y - a.y ), ta.y + ty1o * ( b.y - a.y ) );
-		double txf, tyf;
-		if( b.x - qx )
-		{
-			txf = ( tb.x - q.x ) / ( b.x - qx );
-			tyf = ( tb.y - q.y ) / ( b.x - qx );
-		}
-		else
-		{
-			txf = 0;
-			tyf = 0;
-		}
-		drawFlatDreieckTextur( a.y, b.y, m2, b2, m1, b1, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
-		if( c.y - b.y )
-		{
-			tx2o = (double)( tc.x - tb.x ) / ( c.y - b.y );
-			ty2o = (double)( tc.y - tb.y ) / ( c.y - b.y );
-		}
-		else
-		{
-			tx2o = 0;
-			ty2o = 0;
-		}
-		drawFlatDreieckTextur( b.y, c.y, m2, b2, m3, b3, q.x, q.y, tb.x, tb.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
-	}
-	else
-	{
-		double tx1o, ty1o, tx2o, ty2o;
-		if( b.y - a.y )
-		{
-			tx1o = (double)( tb.x - ta.x ) / ( b.y - a.y );
-			ty1o = (double)( tb.y - ta.y ) / ( b.y - a.y );
-		}
-		else
-		{
-			tx1o = 0;
-			ty1o = 0;
-		}
-		if( c.y - a.y )
-		{
-			tx2o = (double)( tc.x - ta.x ) / ( c.y - a.y );
-			ty2o = (double)( tc.y - ta.y ) / ( c.y - a.y );
-		}
-		else
-		{
-			tx2o = 0;
-			ty2o = 0;
-		}
-		Vec2< double > q( ta.x + tx2o * ( b.y - a.y ), ta.y + ty2o * ( b.y - a.y ) );
-		double txf, tyf;
-		if( qx - b.x )
-		{
-			txf = ( q.x - tb.x ) / ( qx - b.x );
-			tyf = ( q.y - tb.y ) / ( qx - b.x );
-		}
-		else
-		{
-			txf = 0;
-			tyf = 0;
-		}
-		drawFlatDreieckTextur( a.y, b.y, m1, b1, m2, b2, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
-		if( c.y - b.y )
-		{
-			tx1o = (double)( tc.x - tb.x ) / ( c.y - b.y );
-			ty1o = (double)( tc.y - tb.y ) / ( c.y - b.y );
-		}
-		else
-		{
-			tx1o = 0;
-			ty1o = 0;
-		}
-		drawFlatDreieckTextur( b.y, c.y, m3, b3, m2, b2, tb.x, tb.y, q.x, q.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        drawDreieckTexturAlpha( a, b, c, ta, tb, tc, textur );
+        return;
+    }
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    a += drawOff[ doa ];
+    b += drawOff[ doa ];
+    c += drawOff[ doa ];
+    if( ( a.x < dpx && b.x < dpx && c.x < dpx ) || ( a.y < dpy && b.y < dpy && c.y < dpy ) ||
+        ( a.x > dgx && b.x > dgx && c.x > dgx ) || ( a.y > dgy && b.y > dgy && c.y > dgy ) )
+        return;
+    if( b.y < a.y )
+    {
+        a.Swap( b );
+        ta.Swap( tb );
+    }
+    if( c.y < b.y )
+    {
+        b.Swap( c );
+        tb.Swap( tc );
+    }
+    if( b.y < a.y )
+    {
+        a.Swap( b );
+        ta.Swap( tb );
+    }
+    const double m1 = (double)( a.x - b.x ) / ( a.y - b.y );
+    const double m2 = (double)( a.x - c.x ) / ( a.y - c.y );
+    const double m3 = (double)( b.x - c.x ) / ( b.y - c.y );
+    double b1 = a.x - m1 * a.y;
+    double b2 = a.x - m2 * a.y;
+    double b3 = b.x - m3 * b.y;
+    const double qx = m2 * b.y + b2;
+    if( qx < b.x )
+    {
+        double tx1o, ty1o, tx2o, ty2o;
+        if( c.y - a.y )
+        {
+            tx1o = (double)( tc.x - ta.x ) / ( c.y - a.y );
+            ty1o = (double)( tc.y - ta.y ) / ( c.y - a.y );
+        }
+        else
+        {
+            tx1o = 0;
+            ty1o = 0;
+        }
+        if( b.y - a.y )
+        {
+            tx2o = (double)( tb.x - ta.x ) / ( b.y - a.y );
+            ty2o = (double)( tb.y - ta.y ) / ( b.y - a.y );
+        }
+        else
+        {
+            tx2o = 0;
+            ty2o = 0;
+        }
+        Vec2< double > q( ta.x + tx1o * ( b.y - a.y ), ta.y + ty1o * ( b.y - a.y ) );
+        double txf, tyf;
+        if( b.x - qx )
+        {
+            txf = ( tb.x - q.x ) / ( b.x - qx );
+            tyf = ( tb.y - q.y ) / ( b.x - qx );
+        }
+        else
+        {
+            txf = 0;
+            tyf = 0;
+        }
+        drawFlatDreieckTextur( a.y, b.y, m2, b2, m1, b1, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
+        if( c.y - b.y )
+        {
+            tx2o = (double)( tc.x - tb.x ) / ( c.y - b.y );
+            ty2o = (double)( tc.y - tb.y ) / ( c.y - b.y );
+        }
+        else
+        {
+            tx2o = 0;
+            ty2o = 0;
+        }
+        drawFlatDreieckTextur( b.y, c.y, m2, b2, m3, b3, q.x, q.y, tb.x, tb.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
+    }
+    else
+    {
+        double tx1o, ty1o, tx2o, ty2o;
+        if( b.y - a.y )
+        {
+            tx1o = (double)( tb.x - ta.x ) / ( b.y - a.y );
+            ty1o = (double)( tb.y - ta.y ) / ( b.y - a.y );
+        }
+        else
+        {
+            tx1o = 0;
+            ty1o = 0;
+        }
+        if( c.y - a.y )
+        {
+            tx2o = (double)( tc.x - ta.x ) / ( c.y - a.y );
+            ty2o = (double)( tc.y - ta.y ) / ( c.y - a.y );
+        }
+        else
+        {
+            tx2o = 0;
+            ty2o = 0;
+        }
+        Vec2< double > q( ta.x + tx2o * ( b.y - a.y ), ta.y + ty2o * ( b.y - a.y ) );
+        double txf, tyf;
+        if( qx - b.x )
+        {
+            txf = ( q.x - tb.x ) / ( qx - b.x );
+            tyf = ( q.y - tb.y ) / ( qx - b.x );
+        }
+        else
+        {
+            txf = 0;
+            tyf = 0;
+        }
+        drawFlatDreieckTextur( a.y, b.y, m1, b1, m2, b2, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
+        if( c.y - b.y )
+        {
+            tx1o = (double)( tc.x - tb.x ) / ( c.y - b.y );
+            ty1o = (double)( tc.y - tb.y ) / ( c.y - b.y );
+        }
+        else
+        {
+            tx1o = 0;
+            ty1o = 0;
+        }
+        drawFlatDreieckTextur( b.y, c.y, m3, b3, m2, b2, tb.x, tb.y, q.x, q.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
+    }
+    rend = 1;
 }
 
 void Bild::drawDreieckAlpha( Punkt a, Punkt b, Punkt c, int farbe ) // füllt eine Dreieck aus
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	a += drawOff[ doa ];
-	b += drawOff[ doa ];
-	c += drawOff[ doa ];
-	if( ( a.x < dpx && b.x < dpx && c.x < dpx ) || ( a.y < dpy && b.y < dpy && c.y < dpy ) ||
-		( a.x > dgx && b.x > dgx && c.x > dgx ) || ( a.y > dgy && b.y > dgy && c.y > dgy ) )
-		return;
-	if( alpha[ alphaAnzahl ] )
-	{
-		unsigned char *cf = (unsigned char*)&farbe;
-		cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
-	}
-	if( b.y < a.y )
-		a.Swap( b );
-	if( c.y < b.y )
-		b.Swap( c );
-	if( b.y < a.y )
-		a.Swap( b );
-	if( a.y == b.y )
-	{
-		if( b.x < a.x )
-			a.Swap( b );
-		const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
-		const float m3 = (float)( b.x - c.x ) / (float)( b.y - c.y );
-		float b2 = (float)a.x - m2 * (float)a.y;
-		float b3 = (float)b.x - m3 * (float)b.y;
-		drawFlatDreieckAlpha( b.y, c.y, m2, b2, m3, b3, farbe );
-	}
-	else if( b.y == c.y )
-	{
-		if( c.x < b.x )
-			b.Swap( c );
-		const float m1 = (float)( a.x - b.x ) / (float)( a.y - b.y );
-		const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
-		float b1 = (float)a.x - m1 * (float)a.y;
-		float b2 = (float)a.x - m2 * (float)a.y;
-		drawFlatDreieckAlpha( a.y, b.y, m1, b1, m2, b2, farbe );
-	}
-	else
-	{
-		const float m1 = (float)( a.x - b.x ) / (float)( a.y - b.y );
-		const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
-		const float m3 = (float)( b.x - c.x ) / (float)( b.y - c.y );
-		float b1 = (float)a.x - m1 * (float)a.y;
-		float b2 = (float)a.x - m2 * (float)a.y;
-		float b3 = (float)b.x - m3 * (float)b.y;
-		const float qx = m2 * (float)b.y + b2;
-		if( qx < b.x )
-		{
-			drawFlatDreieckAlpha( a.y, b.y, m2, b2, m1, b1, farbe );
-			drawFlatDreieckAlpha( b.y, c.y, m2, b2, m3, b3, farbe );
-		}
-		else
-		{
-			drawFlatDreieckAlpha( a.y, b.y, m1, b1, m2, b2, farbe );
-			drawFlatDreieckAlpha( b.y, c.y, m3, b3, m2, b2, farbe );
-		}
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    a += drawOff[ doa ];
+    b += drawOff[ doa ];
+    c += drawOff[ doa ];
+    if( ( a.x < dpx && b.x < dpx && c.x < dpx ) || ( a.y < dpy && b.y < dpy && c.y < dpy ) ||
+        ( a.x > dgx && b.x > dgx && c.x > dgx ) || ( a.y > dgy && b.y > dgy && c.y > dgy ) )
+        return;
+    if( alpha[ alphaAnzahl ] )
+    {
+        unsigned char *cf = (unsigned char*)&farbe;
+        cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) );
+    }
+    if( b.y < a.y )
+        a.Swap( b );
+    if( c.y < b.y )
+        b.Swap( c );
+    if( b.y < a.y )
+        a.Swap( b );
+    if( a.y == b.y )
+    {
+        if( b.x < a.x )
+            a.Swap( b );
+        const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
+        const float m3 = (float)( b.x - c.x ) / (float)( b.y - c.y );
+        float b2 = (float)a.x - m2 * (float)a.y;
+        float b3 = (float)b.x - m3 * (float)b.y;
+        drawFlatDreieckAlpha( b.y, c.y, m2, b2, m3, b3, farbe );
+    }
+    else if( b.y == c.y )
+    {
+        if( c.x < b.x )
+            b.Swap( c );
+        const float m1 = (float)( a.x - b.x ) / (float)( a.y - b.y );
+        const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
+        float b1 = (float)a.x - m1 * (float)a.y;
+        float b2 = (float)a.x - m2 * (float)a.y;
+        drawFlatDreieckAlpha( a.y, b.y, m1, b1, m2, b2, farbe );
+    }
+    else
+    {
+        const float m1 = (float)( a.x - b.x ) / (float)( a.y - b.y );
+        const float m2 = (float)( a.x - c.x ) / (float)( a.y - c.y );
+        const float m3 = (float)( b.x - c.x ) / (float)( b.y - c.y );
+        float b1 = (float)a.x - m1 * (float)a.y;
+        float b2 = (float)a.x - m2 * (float)a.y;
+        float b3 = (float)b.x - m3 * (float)b.y;
+        const float qx = m2 * (float)b.y + b2;
+        if( qx < b.x )
+        {
+            drawFlatDreieckAlpha( a.y, b.y, m2, b2, m1, b1, farbe );
+            drawFlatDreieckAlpha( b.y, c.y, m2, b2, m3, b3, farbe );
+        }
+        else
+        {
+            drawFlatDreieckAlpha( a.y, b.y, m1, b1, m2, b2, farbe );
+            drawFlatDreieckAlpha( b.y, c.y, m3, b3, m2, b2, farbe );
+        }
+    }
+    rend = 1;
 }
 
 void Bild::drawDreieckTexturAlpha( Punkt a, Punkt b, Punkt c, Punkt ta, Punkt tb, Punkt tc, Bild &textur ) // füllt eine Dreieck aus
 {
-	if( alpha[ alphaAnzahl ] == 0xFF )
-		return;
-	int dpx = dPosA[ doa ].x;
-	int dpy = dPosA[ doa ].y;
-	int dgx = dSizeA[ doa ].x;
-	int dgy = dSizeA[ doa ].y;
-	a += drawOff[ doa ];
-	b += drawOff[ doa ];
-	c += drawOff[ doa ];
-	if( ( a.x < dpx && b.x < dpx && c.x < dpx ) || ( a.y < dpy && b.y < dpy && c.y < dpy ) ||
-		( a.x > dgx && b.x > dgx && c.x > dgx ) || ( a.y > dgy && b.y > dgy && c.y > dgy ) )
-		return;
-	if( b.y < a.y )
-	{
-		a.Swap( b );
-		ta.Swap( tb );
-	}
-	if( c.y < b.y )
-	{
-		b.Swap( c );
-		tb.Swap( tc );
-	}
-	if( b.y < a.y )
-	{
-		a.Swap( b );
-		ta.Swap( tb );
-	}
-	const double m1 = (double)( a.x - b.x ) / ( a.y - b.y );
-	const double m2 = (double)( a.x - c.x ) / ( a.y - c.y );
-	const double m3 = (double)( b.x - c.x ) / ( b.y - c.y );
-	double b1 = a.x - m1 * a.y;
-	double b2 = a.x - m2 * a.y;
-	double b3 = b.x - m3 * b.y;
-	const double qx = m2 * b.y + b2;
-	if( qx < b.x )
-	{
-		double tx1o, ty1o, tx2o, ty2o;
-		if( c.y - a.y )
-		{
-			tx1o = (double)( tc.x - ta.x ) / ( c.y - a.y );
-			ty1o = (double)( tc.y - ta.y ) / ( c.y - a.y );
-		}
-		else
-		{
-			tx1o = 0;
-			ty1o = 0;
-		}
-		if( b.y - a.y )
-		{
-			tx2o = (double)( tb.x - ta.x ) / ( b.y - a.y );
-			ty2o = (double)( tb.y - ta.y ) / ( b.y - a.y );
-		}
-		else
-		{
-			tx2o = 0;
-			ty2o = 0;
-		}
-		Vec2< double > q( ta.x + tx1o * ( b.y - a.y ), ta.y + ty1o * ( b.y - a.y ) );
-		double txf, tyf;
-		if( b.x - qx )
-		{
-			txf = ( tb.x - q.x ) / ( b.x - qx );
-			tyf = ( tb.y - q.y ) / ( b.x - qx );
-		}
-		else
-		{
-			txf = 0;
-			tyf = 0;
-		}
-		drawFlatDreieckTexturAlpha( a.y, b.y, m2, b2, m1, b1, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
-		if( c.y - b.y )
-		{
-			tx2o = (double)( tc.x - tb.x ) / ( c.y - b.y );
-			ty2o = (double)( tc.y - tb.y ) / ( c.y - b.y );
-		}
-		else
-		{
-			tx2o = 0;
-			ty2o = 0;
-		}
-		drawFlatDreieckTexturAlpha( b.y, c.y, m2, b2, m3, b3, q.x, q.y, tb.x, tb.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
-	}
-	else
-	{
-		double tx1o, ty1o, tx2o, ty2o;
-		if( b.y - a.y )
-		{
-			tx1o = (double)( tb.x - ta.x ) / ( b.y - a.y );
-			ty1o = (double)( tb.y - ta.y ) / ( b.y - a.y );
-		}
-		else
-		{
-			tx1o = 0;
-			ty1o = 0;
-		}
-		if( c.y - a.y )
-		{
-			tx2o = (double)( tc.x - ta.x ) / ( c.y - a.y );
-			ty2o = (double)( tc.y - ta.y ) / ( c.y - a.y );
-		}
-		else
-		{
-			tx2o = 0;
-			ty2o = 0;
-		}
-		Vec2< double > q( ta.x + tx2o * ( b.y - a.y ), ta.y + ty2o * ( b.y - a.y ) );
-		double txf, tyf;
-		if( qx - b.x )
-		{
-			txf = ( q.x - tb.x ) / ( qx - b.x );
-			tyf = ( q.y - tb.y ) / ( qx - b.x );
-		}
-		else
-		{
-			txf = 0;
-			tyf = 0;
-		}
-		drawFlatDreieckTexturAlpha( a.y, b.y, m1, b1, m2, b2, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
-		if( c.y - b.y )
-		{
-			tx1o = (double)( tc.x - tb.x ) / ( c.y - b.y );
-			ty1o = (double)( tc.y - tb.y ) / ( c.y - b.y );
-		}
-		else
-		{
-			tx1o = 0;
-			ty1o = 0;
-		}
-		drawFlatDreieckTexturAlpha( b.y, c.y, m3, b3, m2, b2, tb.x, tb.y, q.x, q.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
-	}
-	rend = 1;
+    if( alpha[ alphaAnzahl ] == 0xFF )
+        return;
+    int dpx = dPosA[ doa ].x;
+    int dpy = dPosA[ doa ].y;
+    int dgx = dSizeA[ doa ].x;
+    int dgy = dSizeA[ doa ].y;
+    a += drawOff[ doa ];
+    b += drawOff[ doa ];
+    c += drawOff[ doa ];
+    if( ( a.x < dpx && b.x < dpx && c.x < dpx ) || ( a.y < dpy && b.y < dpy && c.y < dpy ) ||
+        ( a.x > dgx && b.x > dgx && c.x > dgx ) || ( a.y > dgy && b.y > dgy && c.y > dgy ) )
+        return;
+    if( b.y < a.y )
+    {
+        a.Swap( b );
+        ta.Swap( tb );
+    }
+    if( c.y < b.y )
+    {
+        b.Swap( c );
+        tb.Swap( tc );
+    }
+    if( b.y < a.y )
+    {
+        a.Swap( b );
+        ta.Swap( tb );
+    }
+    const double m1 = (double)( a.x - b.x ) / ( a.y - b.y );
+    const double m2 = (double)( a.x - c.x ) / ( a.y - c.y );
+    const double m3 = (double)( b.x - c.x ) / ( b.y - c.y );
+    double b1 = a.x - m1 * a.y;
+    double b2 = a.x - m2 * a.y;
+    double b3 = b.x - m3 * b.y;
+    const double qx = m2 * b.y + b2;
+    if( qx < b.x )
+    {
+        double tx1o, ty1o, tx2o, ty2o;
+        if( c.y - a.y )
+        {
+            tx1o = (double)( tc.x - ta.x ) / ( c.y - a.y );
+            ty1o = (double)( tc.y - ta.y ) / ( c.y - a.y );
+        }
+        else
+        {
+            tx1o = 0;
+            ty1o = 0;
+        }
+        if( b.y - a.y )
+        {
+            tx2o = (double)( tb.x - ta.x ) / ( b.y - a.y );
+            ty2o = (double)( tb.y - ta.y ) / ( b.y - a.y );
+        }
+        else
+        {
+            tx2o = 0;
+            ty2o = 0;
+        }
+        Vec2< double > q( ta.x + tx1o * ( b.y - a.y ), ta.y + ty1o * ( b.y - a.y ) );
+        double txf, tyf;
+        if( b.x - qx )
+        {
+            txf = ( tb.x - q.x ) / ( b.x - qx );
+            tyf = ( tb.y - q.y ) / ( b.x - qx );
+        }
+        else
+        {
+            txf = 0;
+            tyf = 0;
+        }
+        drawFlatDreieckTexturAlpha( a.y, b.y, m2, b2, m1, b1, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
+        if( c.y - b.y )
+        {
+            tx2o = (double)( tc.x - tb.x ) / ( c.y - b.y );
+            ty2o = (double)( tc.y - tb.y ) / ( c.y - b.y );
+        }
+        else
+        {
+            tx2o = 0;
+            ty2o = 0;
+        }
+        drawFlatDreieckTexturAlpha( b.y, c.y, m2, b2, m3, b3, q.x, q.y, tb.x, tb.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
+    }
+    else
+    {
+        double tx1o, ty1o, tx2o, ty2o;
+        if( b.y - a.y )
+        {
+            tx1o = (double)( tb.x - ta.x ) / ( b.y - a.y );
+            ty1o = (double)( tb.y - ta.y ) / ( b.y - a.y );
+        }
+        else
+        {
+            tx1o = 0;
+            ty1o = 0;
+        }
+        if( c.y - a.y )
+        {
+            tx2o = (double)( tc.x - ta.x ) / ( c.y - a.y );
+            ty2o = (double)( tc.y - ta.y ) / ( c.y - a.y );
+        }
+        else
+        {
+            tx2o = 0;
+            ty2o = 0;
+        }
+        Vec2< double > q( ta.x + tx2o * ( b.y - a.y ), ta.y + ty2o * ( b.y - a.y ) );
+        double txf, tyf;
+        if( qx - b.x )
+        {
+            txf = ( q.x - tb.x ) / ( qx - b.x );
+            tyf = ( q.y - tb.y ) / ( qx - b.x );
+        }
+        else
+        {
+            txf = 0;
+            tyf = 0;
+        }
+        drawFlatDreieckTexturAlpha( a.y, b.y, m1, b1, m2, b2, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
+        if( c.y - b.y )
+        {
+            tx1o = (double)( tc.x - tb.x ) / ( c.y - b.y );
+            ty1o = (double)( tc.y - tb.y ) / ( c.y - b.y );
+        }
+        else
+        {
+            tx1o = 0;
+            ty1o = 0;
+        }
+        drawFlatDreieckTexturAlpha( b.y, c.y, m3, b3, m2, b2, tb.x, tb.y, q.x, q.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur );
+    }
+    rend = 1;
+}
+
+void Bild::replaceColorWithAlpha( int color )
+{
+    int r = ( color & 0xFF0000 ) >> 16;
+    int g = ( color & 0xFF00 ) >> 8;
+    int b = color & 0xFF;
+    int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
+    int xx = dPosA[ doa ].x, yy = dPosA[ doa ].y;
+    int bb = dSizeA[ doa ].x, hh = dSizeA[ doa ].y;
+    for( int y = dy + yy; y < hh; y++ )
+    {
+        int ygr = y * size.x;
+        for( int x = dx + xx; x < bb; x++ )
+        {
+            unsigned char *cf = (unsigned char*)&(fc[ x + ygr ]);
+            int abstand = (int)sqrt( ( r - cf[ 2 ] ) * ( r - cf[ 2 ] ) + ( g - cf[ 1 ] ) * ( g - cf[ 1 ] ) + ( b - cf[ 0 ] ) * ( b - cf[ 0 ] ) );
+            if( abstand > 255 )
+                abstand = 255;
+            cf[ 3 ] = (unsigned char)( abstand );
+        }
+    }
 }
 
 bool Bild::setDrawOptions( const Punkt &pos, const Punkt &gr ) // setzt die Drawoptionen
 {
-	int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
-	int xx = dPosA[ doa ].x, yy = dPosA[ doa ].y;
-	int bb = dSizeA[ doa ].x, hh = dSizeA[ doa ].y;
-	if( dx + pos.x + gr.x < 0 || dy + pos.y + gr.y < 0 || dx + pos.x >= size.x || dy + pos.y >= size.y )
-		return 0;
-	if( pos.x + gr.x + dx < xx || pos.y + gr.y + dy < yy || dx + pos.x >= bb || dy + pos.y >= hh )
-		return 0;
-	++doa;
-	assert( doa < 2000 );
-	dPosA[ doa ].x = maxInt( pos.x + dx, xx );
-	dPosA[ doa ].y = maxInt( pos.y + dy, yy );
-	dSizeA[ doa ].x = minInt( pos.x + gr.x + dx, bb );
-	dSizeA[ doa ].y = minInt( pos.y + gr.y + dy, hh );
-	drawOff[ doa ].x = dx + pos.x;
-	drawOff[ doa ].y = dy + pos.y;
-	return 1;
+    int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
+    int xx = dPosA[ doa ].x, yy = dPosA[ doa ].y;
+    int bb = dSizeA[ doa ].x, hh = dSizeA[ doa ].y;
+    if( dx + pos.x + gr.x < 0 || dy + pos.y + gr.y < 0 || dx + pos.x >= size.x || dy + pos.y >= size.y )
+        return 0;
+    if( pos.x + gr.x + dx < xx || pos.y + gr.y + dy < yy || dx + pos.x >= bb || dy + pos.y >= hh )
+        return 0;
+    ++doa;
+    assert( doa < 2000 );
+    dPosA[ doa ].x = maxInt( pos.x + dx, xx );
+    dPosA[ doa ].y = maxInt( pos.y + dy, yy );
+    dSizeA[ doa ].x = minInt( pos.x + gr.x + dx, bb );
+    dSizeA[ doa ].y = minInt( pos.y + gr.y + dy, hh );
+    drawOff[ doa ].x = dx + pos.x;
+    drawOff[ doa ].y = dy + pos.y;
+    return 1;
 }
 
 bool Bild::setDrawOptions( int x, int y, int br, int hi )
 {
-	int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
-	int xx = dPosA[ doa ].x, yy = dPosA[ doa ].y;
-	int bb = dSizeA[ doa ].x, hh = dSizeA[ doa ].y;
-	if( dx + x + br < 0 || dy + y + hi < 0 || dx + x >= size.x || dy + y >= size.y )
-		return 0;
-	if( x + br + dx < xx || y + hi + dy < yy || dx + x >= bb || dy + y >= hh )
-		return 0;
-	++doa;
-	assert( doa < 2000 );
-	dPosA[ doa ].x = maxInt( x + dx, xx );
-	dPosA[ doa ].y = maxInt( y + dy, yy );
-	dSizeA[ doa ].x = minInt( x + br + dx, bb );
-	dSizeA[ doa ].y = minInt( y + hi + dy, hh );
-	drawOff[ doa ].x = dx + x;
-	drawOff[ doa ].y = dy + y;
-	return 1;
+    int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
+    int xx = dPosA[ doa ].x, yy = dPosA[ doa ].y;
+    int bb = dSizeA[ doa ].x, hh = dSizeA[ doa ].y;
+    if( dx + x + br < 0 || dy + y + hi < 0 || dx + x >= size.x || dy + y >= size.y )
+        return 0;
+    if( x + br + dx < xx || y + hi + dy < yy || dx + x >= bb || dy + y >= hh )
+        return 0;
+    ++doa;
+    assert( doa < 2000 );
+    dPosA[ doa ].x = maxInt( x + dx, xx );
+    dPosA[ doa ].y = maxInt( y + dy, yy );
+    dSizeA[ doa ].x = minInt( x + br + dx, bb );
+    dSizeA[ doa ].y = minInt( y + hi + dy, hh );
+    drawOff[ doa ].x = dx + x;
+    drawOff[ doa ].y = dy + y;
+    return 1;
 }
 
 bool Bild::setDrawOptionsErzwingen( const Punkt &pos, const Punkt &gr ) // setzt die Drawoptionen
 {
-	int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
-	if( dx + pos.x + gr.x < 0 || dy + pos.y + gr.y < 0 || dx + pos.x >= size.x || dy + pos.y >= size.y )
-		return 0;
-	++doa;
-	assert( doa < 2000 );
-	dPosA[ doa ].x = maxInt( pos.x + dx, 0 );
-	dPosA[ doa ].y = maxInt( pos.y + dy, 0 );
-	dSizeA[ doa ].x = minInt( pos.x + gr.x + dx, size.x );
-	dSizeA[ doa ].y = minInt( pos.y + gr.y + dy, size.y );
-	drawOff[ doa ].x = dx + pos.x;
-	drawOff[ doa ].y = dy + pos.y;
-	return 1;
+    int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
+    if( dx + pos.x + gr.x < 0 || dy + pos.y + gr.y < 0 || dx + pos.x >= size.x || dy + pos.y >= size.y )
+        return 0;
+    ++doa;
+    assert( doa < 2000 );
+    dPosA[ doa ].x = maxInt( pos.x + dx, 0 );
+    dPosA[ doa ].y = maxInt( pos.y + dy, 0 );
+    dSizeA[ doa ].x = minInt( pos.x + gr.x + dx, size.x );
+    dSizeA[ doa ].y = minInt( pos.y + gr.y + dy, size.y );
+    drawOff[ doa ].x = dx + pos.x;
+    drawOff[ doa ].y = dy + pos.y;
+    return 1;
 }
 
 bool Bild::setDrawOptionsErzwingen( int x, int y, int br, int hi ) // setzt die Drawoptionen
 {
-	int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
-	if( dx + x + br < 0 || dy + y + hi < 0 || dx + x >= size.x || dy + y >= size.y )
-		return 0;
-	++doa;
-	assert( doa < 2000 );
-	dPosA[ doa ].x = maxInt( x + dx, 0 );
-	dPosA[ doa ].y = maxInt( y + dy, 0 );
-	dSizeA[ doa ].x = minInt( x + br + dx, size.x );
-	dSizeA[ doa ].y = minInt( y + hi + dy, size.y );
-	drawOff[ doa ].x = dx + x;
-	drawOff[ doa ].y = dy + y;
-	return 1;
+    int dx = drawOff[ doa ].x, dy = drawOff[ doa ].y;
+    if( dx + x + br < 0 || dy + y + hi < 0 || dx + x >= size.x || dy + y >= size.y )
+        return 0;
+    ++doa;
+    assert( doa < 2000 );
+    dPosA[ doa ].x = maxInt( x + dx, 0 );
+    dPosA[ doa ].y = maxInt( y + dy, 0 );
+    dSizeA[ doa ].x = minInt( x + br + dx, size.x );
+    dSizeA[ doa ].y = minInt( y + hi + dy, size.y );
+    drawOff[ doa ].x = dx + x;
+    drawOff[ doa ].y = dy + y;
+    return 1;
 }
 
 void Bild::addScrollOffset( int xOff, int yOff ) // setzt ScrollOffset
 {
-	drawOff[ doa ].x -= xOff;
-	drawOff[ doa ].y -= yOff;
+    drawOff[ doa ].x -= xOff;
+    drawOff[ doa ].y -= yOff;
 }
 
 void Bild::releaseDrawOptions() // setzt die Drawoptionen zurück
 {
-	--doa;
+    --doa;
 }
 
 bool Bild::getRend()
 {
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 // constant 
 int *Bild::getBuffer()const // gibt buffer zurück
 {
-	return fc;
+    return fc;
 }
 
 int Bild::getPixel( int x, int y ) const
 {
-	if( x < 0 || y < 0 || x >= size.x || y >= size.y )
-		return 0;
-	return fc[ x + y * size.x ];
+    if( x < 0 || y < 0 || x >= size.x || y >= size.y )
+        return 0;
+    return fc[ x + y * size.x ];
 }
 
 const Punkt &Bild::getSize() const // gibt die Größe zurück
 {
-	return size;
+    return size;
 }
 
 int Bild::getBreite() const // gibt die Breite zurück
 {
-	return size.x;
+    return size.x;
 }
 
 int Bild::getHeight() const // gibt die Höhe zurück
 {
-	return size.y;
+    return size.y;
 }
 
 unsigned char Bild::getAlpha() const // gibt den Alpha wert zurück
 {
-	return (unsigned char)( 255 - alpha[ alphaAnzahl ] );
+    return (unsigned char)( 255 - alpha[ alphaAnzahl ] );
 }
 
 const Punkt &Bild::getDrawPos() const
 {
-	return dPosA[ doa ];
+    return dPosA[ doa ];
 }
 
 const Punkt &Bild::getDrawGr() const
 {
-	return dSizeA[ doa ];
+    return dSizeA[ doa ];
 }
 
 const Punkt &Bild::getDrawOff() const
 {
-	return drawOff[ doa ];
+    return drawOff[ doa ];
 }
 
 // Reference Counting 
 Bild *Bild::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Bild *Bild::release()
 {
-	--ref;
-	if( ref < 1 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref < 1 )
+        delete this;
+    return 0;
 }
 
 
@@ -1983,246 +2005,249 @@ Bild *Bild::release()
 // Inhalt der BildZ Klasse aus Bild.h
 // Konstruktor 
 BildZ::BildZ()
-	: ZeichnungHintergrund(),
-	bild( 0 ),
-	ref( 1 )
+    : ZeichnungHintergrund(),
+    bild( 0 ),
+    ref( 1 )
 {
-	style = 0;
-	mak = _ret1ME;
+    style = 0;
+    mak = _ret1ME;
 }
 
 // Destruktor 
 BildZ::~BildZ()
 {
-	if( bild )
-		bild->release();
+    if( bild )
+        bild->release();
 }
 
 // nicht constant 
 void BildZ::setBildZ( Bild *b ) // setzt das Bild
 {
-	if( bild )
-		bild->release();
-	bild = b;
-	if( !vertikalScrollBar )
-		vertikalScrollBar = new VScrollBar();
-	if( !horizontalScrollBar )
-		horizontalScrollBar = new HScrollBar();
-	horizontalScrollBar->getScrollData()->max = b->getBreite();
-	vertikalScrollBar->getScrollData()->max = b->getHeight();
-	rend = 1;
+    if( bild )
+        bild->release();
+    bild = b;
+    if( !vertikalScrollBar )
+        vertikalScrollBar = new VScrollBar();
+    if( !horizontalScrollBar )
+        horizontalScrollBar = new HScrollBar();
+    if( b )
+    {
+        horizontalScrollBar->getScrollData()->max = b->getBreite();
+        vertikalScrollBar->getScrollData()->max = b->getHeight();
+    }
+    rend = 1;
 }
 
 void BildZ::setBild( Bild *b )
 {
-	if( !bild )
-		bild = new Bild();
-	bild->neuBild( b->getBreite(), b->getHeight(), 0 );
-	bild->drawBild( 0, 0, b->getBreite(), b->getHeight(), *b );
-	if( !vertikalScrollBar )
-		vertikalScrollBar = new VScrollBar();
-	if( !horizontalScrollBar )
-		horizontalScrollBar = new HScrollBar();
-	horizontalScrollBar->getScrollData()->max = b->getBreite();
-	vertikalScrollBar->getScrollData()->max = b->getHeight();
-	b->release();
-	rend = 1;
+    if( !bild )
+        bild = new Bild();
+    bild->neuBild( b->getBreite(), b->getHeight(), 0 );
+    bild->drawBild( 0, 0, b->getBreite(), b->getHeight(), *b );
+    if( !vertikalScrollBar )
+        vertikalScrollBar = new VScrollBar();
+    if( !horizontalScrollBar )
+        horizontalScrollBar = new HScrollBar();
+    horizontalScrollBar->getScrollData()->max = b->getBreite();
+    vertikalScrollBar->getScrollData()->max = b->getHeight();
+    b->release();
+    rend = 1;
 }
 
 bool BildZ::tick( double tickVal ) // tick
 {
-	return __super::tick( tickVal );
+    return __super::tick( tickVal );
 }
 
 void BildZ::doMausEreignis( MausEreignis &me ) // ruft Mak auf
 {
-	if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) )
-	{
-		if( mausIn )
-		{
-			mausIn = 0;
-			MausEreignis me2;
-			me2.id = ME_Leaves;
-			me2.mx = me.mx;
-			me2.my = me.my;
-			me2.verarbeitet = 0;
-			doMausEreignis( me2 );
-			return;
-		}
-	}
-	if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Leaves )
-	{
-		return;
-	}
-	if( !mausIn && me.id != ME_Leaves )
-	{
-		mausIn = 1;
-		MausEreignis me2;
-		me2.id = ME_Betritt;
-		me2.mx = me.mx;
-		me2.my = me.my;
-		me2.verarbeitet = 0;
-		doMausEreignis( me2 );
-	}
-	me.mx -= pos.x;
-	me.my -= pos.y;
-	if( hatStyle( Style::Sichtbar ) )
-	{
-		if( mak && ( me.verarbeitet || mak( makParam, this, me ) ) )
-		{
-			if( me.id != ME_Betritt && me.id != ME_Leaves )
-			{
-				lockZeichnung();
-				int rbr = 0;
-				if( hatStyle( Style::Rahmen ) && rahmen )
-					rbr = rahmen->getRBreite();
-				bool vs = hatStyle( Style::VScroll ) && vertikalScrollBar;
-				bool hs = hatStyle( Style::HScroll ) && horizontalScrollBar;
-				if( vs )
-				{
-					if( hs )
-						horizontalScrollBar->doMausMessage( rbr, gr.y - rbr - 15, gr.x - rbr * 2 - 15, 15, me );
-					vertikalScrollBar->doMausMessage( gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me );
-				}
-				else if( hs )
-					horizontalScrollBar->doMausMessage( rbr, gr.y - rbr - 15, gr.x - rbr * 2, 15, me );
-				unlockZeichnung();
-				if( vs || hs )
-					me.verarbeitet = 1;
-			}
-		}
-	}
-	me.mx += pos.x;
-	me.my += pos.y;
+    if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) )
+    {
+        if( mausIn )
+        {
+            mausIn = 0;
+            MausEreignis me2;
+            me2.id = ME_Leaves;
+            me2.mx = me.mx;
+            me2.my = me.my;
+            me2.verarbeitet = 0;
+            doMausEreignis( me2 );
+            return;
+        }
+    }
+    if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Leaves )
+    {
+        return;
+    }
+    if( !mausIn && me.id != ME_Leaves )
+    {
+        mausIn = 1;
+        MausEreignis me2;
+        me2.id = ME_Betritt;
+        me2.mx = me.mx;
+        me2.my = me.my;
+        me2.verarbeitet = 0;
+        doMausEreignis( me2 );
+    }
+    me.mx -= pos.x;
+    me.my -= pos.y;
+    if( hatStyle( Style::Sichtbar ) )
+    {
+        if( mak && ( me.verarbeitet || mak( makParam, this, me ) ) )
+        {
+            if( me.id != ME_Betritt && me.id != ME_Leaves )
+            {
+                lockZeichnung();
+                int rbr = 0;
+                if( hatStyle( Style::Rahmen ) && rahmen )
+                    rbr = rahmen->getRBreite();
+                bool vs = hatStyle( Style::VScroll ) && vertikalScrollBar;
+                bool hs = hatStyle( Style::HScroll ) && horizontalScrollBar;
+                if( vs )
+                {
+                    if( hs )
+                        horizontalScrollBar->doMausMessage( rbr, gr.y - rbr - 15, gr.x - rbr * 2 - 15, 15, me );
+                    vertikalScrollBar->doMausMessage( gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me );
+                }
+                else if( hs )
+                    horizontalScrollBar->doMausMessage( rbr, gr.y - rbr - 15, gr.x - rbr * 2, 15, me );
+                unlockZeichnung();
+                if( vs || hs )
+                    me.verarbeitet = 1;
+            }
+        }
+    }
+    me.mx += pos.x;
+    me.my += pos.y;
 }
 
 void BildZ::render( Bild &zRObj ) // zeichnet nach zRObj
 {
-	if( hatStyle( Style::Sichtbar ) )
-	{
-		__super::render( zRObj );
-		lockZeichnung();
-		if( !zRObj.setDrawOptions( innenPosition, innenSize ) )
-		{
-			unlockZeichnung();
-			return;
-		}
-		if( bild )
-		{
-			int x = 0;
-			int y = 0;
-			int br = innenSize.x;
-			int hö = innenSize.y;
-			if( !( vertikalScrollBar && hatStyle( Style::VScroll ) ) && !( horizontalScrollBar && hatStyle( Style::HScroll ) ) )
-			{
-				if( hatStyle( Style::Alpha ) )
-					zRObj.alphaBild( x, y, br, hö, *bild );
-				else
-					zRObj.drawBild( x, y, br, hö, *bild );
-			}
-			else
-			{
-				if( !zRObj.setDrawOptions( x, y, br, hö ) )
-				{
-					zRObj.releaseDrawOptions();
-					unlockZeichnung();
-					return;
-				}
-				if( hatStyle( Style::Alpha ) )
-					zRObj.alphaBild( -horizontalScrollBar->getScroll(), -vertikalScrollBar->getScroll(), bild->getBreite(), bild->getHeight(), *bild );
-				else
-					zRObj.drawBild( -horizontalScrollBar->getScroll(), -vertikalScrollBar->getScroll(), bild->getBreite(), bild->getHeight(), *bild );
-				zRObj.releaseDrawOptions();
-			}
-		}
-		zRObj.releaseDrawOptions();
-		unlockZeichnung();
-	}
+    if( hatStyle( Style::Sichtbar ) )
+    {
+        __super::render( zRObj );
+        lockZeichnung();
+        if( !zRObj.setDrawOptions( innenPosition, innenSize ) )
+        {
+            unlockZeichnung();
+            return;
+        }
+        if( bild )
+        {
+            int x = 0;
+            int y = 0;
+            int br = innenSize.x;
+            int hö = innenSize.y;
+            if( !( vertikalScrollBar && hatStyle( Style::VScroll ) ) && !( horizontalScrollBar && hatStyle( Style::HScroll ) ) )
+            {
+                if( hatStyle( Style::Alpha ) )
+                    zRObj.alphaBild( x, y, br, hö, *bild );
+                else
+                    zRObj.drawBild( x, y, br, hö, *bild );
+            }
+            else
+            {
+                if( !zRObj.setDrawOptions( x, y, br, hö ) )
+                {
+                    zRObj.releaseDrawOptions();
+                    unlockZeichnung();
+                    return;
+                }
+                if( hatStyle( Style::Alpha ) )
+                    zRObj.alphaBild( -horizontalScrollBar->getScroll(), -vertikalScrollBar->getScroll(), bild->getBreite(), bild->getHeight(), *bild );
+                else
+                    zRObj.drawBild( -horizontalScrollBar->getScroll(), -vertikalScrollBar->getScroll(), bild->getBreite(), bild->getHeight(), *bild );
+                zRObj.releaseDrawOptions();
+            }
+        }
+        zRObj.releaseDrawOptions();
+        unlockZeichnung();
+    }
 }
 
 // constant 
 Bild *BildZ::getBild() const // gibt das Bild zurück
 {
-	if( bild )
-		return bild->getThis();
-	return 0;
+    if( bild )
+        return bild->getThis();
+    return 0;
 }
 
 Bild *BildZ::zBild() const
 {
-	return bild;
+    return bild;
 }
 
 Zeichnung *BildZ::dublizieren() const // erstellt eine Kopie des Zeichnungs
 {
-	BildZ *obj = new BildZ();
-	obj->setPosition( pos );
-	obj->setSize( gr );
-	obj->setMausEreignisParameter( makParam );
-	obj->setTastaturEreignisParameter( takParam );
-	obj->setMausEreignis( mak );
-	obj->setTastaturEreignis( tak );
-	if( toolTip )
-		obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
-	obj->setStyle( style );
-	obj->setHintergrundFarbe( hintergrundFarbe );
-	if( hintergrundFeld )
-		obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
-	if( rahmen )
-		obj->setLinienRahmenZ( (LRahmen*)rahmen->dublizieren() );
-	if( hintergrundBild )
-		obj->setHintergrundBild( hintergrundBild->getThis() );
-	if( bild )
-		obj->setBild( bild->getThis() );
-	obj->setStyle( style );
-	return obj;
+    BildZ *obj = new BildZ();
+    obj->setPosition( pos );
+    obj->setSize( gr );
+    obj->setMausEreignisParameter( makParam );
+    obj->setTastaturEreignisParameter( takParam );
+    obj->setMausEreignis( mak );
+    obj->setTastaturEreignis( tak );
+    if( toolTip )
+        obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
+    obj->setStyle( style );
+    obj->setHintergrundFarbe( hintergrundFarbe );
+    if( hintergrundFeld )
+        obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
+    if( rahmen )
+        obj->setLinienRahmenZ( (LRahmen*)rahmen->dublizieren() );
+    if( hintergrundBild )
+        obj->setHintergrundBild( hintergrundBild->getThis() );
+    if( bild )
+        obj->setBild( bild->getThis() );
+    obj->setStyle( style );
+    return obj;
 }
 
 // Reference Counting 
 BildZ *BildZ::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 BildZ *BildZ::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
 Bild *Framework::ladeBild( char *pfad, Text *zError )
 {
-	Text p = pfad;
-	Text *txt = p.getTeilText( p.positionVon( '.', p.anzahlVon( '.' ) - 1 ) );
-	if( !( txt->istGleich( ".bmp" ) || txt->istGleich( ".jpg" ) || txt->istGleich( ".gif" ) || txt->istGleich( ".png" ) ) )
-	{
-		zError->setText( "Die Angegebene Datei ist keine gueltige Bilddatei!" );
-		txt->release();
-		return 0;
-	}
-	txt->release();
-	wchar_t *name = new wchar_t[ p.getLength() + 1 ];
-	for( int i = 0; i < p.getLength(); i++ )
-		name[ i ] = (wchar_t)p.getText()[ i ];
-	name[ p.getLength() ] = '\0';
-
-	Gdiplus::Bitmap bitmap( name );
-	Gdiplus::Color pix;
-	delete[]name;
-
-	Bild *ret = new Bild();
-	ret->neuBild( bitmap.GetWidth(), bitmap.GetHeight(), 0 );
-	int *buff = ret->getBuffer();
-	for( unsigned int i = 0; i < bitmap.GetWidth() * bitmap.GetHeight(); i++ )
-	{
-		bitmap.GetPixel( i % bitmap.GetWidth(), i / bitmap.GetWidth(), &pix );
-		buff[ i ] = pix.GetValue();
-	}
-	return ret;
+    Text p = pfad;
+    Text *txt = p.getTeilText( p.positionVon( '.', p.anzahlVon( '.' ) - 1 ) );
+    if( !( txt->istGleich( ".bmp" ) || txt->istGleich( ".jpg" ) || txt->istGleich( ".gif" ) || txt->istGleich( ".png" ) ) )
+    {
+        zError->setText( "Die Angegebene Datei ist keine gueltige Bilddatei!" );
+        txt->release();
+        return 0;
+    }
+    txt->release();
+    wchar_t *name = new wchar_t[ p.getLength() + 1 ];
+    for( int i = 0; i < p.getLength(); i++ )
+        name[ i ] = (wchar_t)p.getText()[ i ];
+    name[ p.getLength() ] = '\0';
+
+    Gdiplus::Bitmap bitmap( name );
+    Gdiplus::Color pix;
+    delete[]name;
+
+    Bild *ret = new Bild();
+    ret->neuBild( bitmap.GetWidth(), bitmap.GetHeight(), 0 );
+    int *buff = ret->getBuffer();
+    for( unsigned int i = 0; i < bitmap.GetWidth() * bitmap.GetHeight(); i++ )
+    {
+        bitmap.GetPixel( i % bitmap.GetWidth(), i / bitmap.GetWidth(), &pix );
+        buff[ i ] = pix.GetValue();
+    }
+    return ret;
 }
 
 #endif

Bild.h

@@ -278,6 +278,8 @@ namespace Framework
         //  tc: Die Koordinaten von c in der Textur
         //  textur: Das Bild, was als Textur verwendet werden soll
         __declspec( dllexport ) void drawDreieckTexturAlpha( Punkt a, Punkt b, Punkt c, Punkt ta, Punkt tb, Punkt tc, Bild &textur );
+        // Ersetzt eine bestimmte Farbe durch Transparenz
+        __declspec( dllexport ) void replaceColorWithAlpha( int color );
         // Begrenzt die Zeichenfläche in die bis zum nächsten aufruf von releaseDrawOptions() gezeichnet werden kann. Alles außerhalb der Fläche wird automatisch ignoriert.
         // Wenn die Zeichenfläche über den Rand einer bestehenden Zeichenfläche hinausragt, wird sie automatisch auf die bestehende Zeichnenfläche beschnitten.
         //  pos: Die Koordinaten der linken oberen Ecke der Zeichenfläche

DreieckListe.h

@@ -11,11 +11,11 @@ namespace Framework
     struct DreieckPunkt
     {
         T *punkt;
-        Punkt *textur;
+        Vec2<float> *textur;
         // Konstruktor
         //  punkt: Die Koordinate der Ecke
         //  textur: Die Koordinate in der Textur
-        DreieckPunkt( T *punkt, Punkt *textur )
+        DreieckPunkt( T *punkt, Vec2<float> *textur )
         {
             this->punkt = punkt;
             this->textur = textur;
@@ -56,7 +56,7 @@ namespace Framework
         // Fügt der Liste einen Punkt hinzu
         //  p: Die Koordinaten des Punktes
         //  textur: Die Koordinaten in der Textur
-        void addPunkt( T *p, Punkt *textur )
+        void addPunkt( T *p, Vec2<float> *textur )
         {
             punkte->add( new DreieckPunkt< T >( p, textur ) );
         }

Framework Linux.vcxproj

@@ -141,6 +141,7 @@
     <ClCompile Include="Text.cpp" />
     <ClCompile Include="TextFeld.cpp" />
     <ClCompile Include="Textur.cpp" />
+    <ClCompile Include="Textur2D.cpp" />
     <ClCompile Include="TexturList.cpp" />
     <ClCompile Include="TexturModel.cpp" />
     <ClCompile Include="Thread.cpp" />
@@ -199,6 +200,7 @@
     <ClInclude Include="Text.h" />
     <ClInclude Include="TextFeld.h" />
     <ClInclude Include="Textur.h" />
+    <ClInclude Include="Textur2D.h" />
     <ClInclude Include="TexturList.h" />
     <ClInclude Include="TexturModel.h" />
     <ClInclude Include="Thread.h" />

Framework Linux.vcxproj.filters

@@ -246,6 +246,9 @@
     <ClInclude Include="AsynchronCall.h">
       <Filter>Headerdateien\Framework\OS</Filter>
     </ClInclude>
+    <ClInclude Include="Textur2D.h">
+      <Filter>Headerdateien\Framework\Grafik\2D</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Prozess.cpp">
@@ -389,5 +392,8 @@
     <ClCompile Include="AsynchronCall.cpp">
       <Filter>Quelldateien\Framework\OS</Filter>
     </ClCompile>
+    <ClCompile Include="Textur2D.cpp">
+      <Filter>Quelldateien\Framework\Grafik\2D</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Framework.vcxproj

@@ -240,6 +240,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClInclude Include="Render3D.h" />
     <ClInclude Include="Shader.h" />
     <ClInclude Include="Textur.h" />
+    <ClInclude Include="Textur2D.h" />
     <ClInclude Include="TexturList.h" />
     <ClInclude Include="TexturModel.h" />
     <ClInclude Include="Ebene3D.h" />
@@ -299,6 +300,7 @@ copy "x64\Release\Framework.dll" "..\..\Spiele Platform\SMP\Fertig\x64\framework
     <ClCompile Include="Render3D.cpp" />
     <ClCompile Include="Shader.cpp" />
     <ClCompile Include="Textur.cpp" />
+    <ClCompile Include="Textur2D.cpp" />
     <ClCompile Include="TexturList.cpp" />
     <ClCompile Include="TexturModel.cpp" />
     <ClCompile Include="Welt3D.cpp" />

Framework.vcxproj.filters

@@ -270,6 +270,9 @@
     <ClInclude Include="Random.h">
       <Filter>Headerdateien\Framework</Filter>
     </ClInclude>
+    <ClInclude Include="Textur2D.h">
+      <Filter>Headerdateien\Framework\Grafik\2D</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Maus.cpp">
@@ -431,5 +434,8 @@
     <ClCompile Include="AsynchronCall.cpp">
       <Filter>Quelldateien\Framework\OS</Filter>
     </ClCompile>
+    <ClCompile Include="Textur2D.cpp">
+      <Filter>Quelldateien\Framework\Grafik\2D</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

M2Datei.cpp

@@ -155,6 +155,8 @@ bool M2Datei::saveModel( Model2DData *zMdr, const char *name )
             options = (char)( options & (char)zMdr->polygons->get( p ).tKordinaten->hat( i ) );
         if( pNameL != 0 )
             options |= 2;
+        if( zMdr->polygons->get( p ).transparent )
+            options |= 4;
         neu.schreibe( &options, 1 );
         if( ( options | 2 ) == options ) // name
         {
@@ -170,7 +172,7 @@ bool M2Datei::saveModel( Model2DData *zMdr, const char *name )
             neu.schreibe( (char*)&v, 4 );
             if( ( options | 1 ) == options ) // textur
             {
-                int t = zMdr->polygons->get( p ).tKordinaten->get( i ).x;
+                float t = zMdr->polygons->get( p ).tKordinaten->get( i ).x;
                 neu.schreibe( (char*)&t, 4 );
                 t = zMdr->polygons->get( p ).tKordinaten->get( i ).y;
                 neu.schreibe( (char*)&t, 4 );
@@ -317,13 +319,14 @@ Model2DData *M2Datei::ladeModel( const char *name ) const
         char options = 0;
         d.lese( &options, 1 );
         Polygon2D polygon;
+        polygon.transparent = ( options | 4 ) == options;
         polygon.name = new Text();
         if( ( options | 2 ) == options )
         {
             char nameL = 0;
             d.lese( &nameL, 1 );
             char *name = new char[ nameL + 1 ];
-            name[ nameL ] = 0;
+            name[ (int)nameL ] = 0;
             d.lese( name, nameL );
             polygon.name->setText( name );
             delete[] name;
@@ -339,7 +342,7 @@ Model2DData *M2Datei::ladeModel( const char *name ) const
         }
         polygon.vertex = new Array< Vertex >();
         if( ( options | 1 ) == options ) // wenn textur
-            polygon.tKordinaten = new Array< Punkt >();
+            polygon.tKordinaten = new Array< Vertex >();
         else
             polygon.tKordinaten = 0;
         for( int v = 0; v < vAnz; v++ )
@@ -350,7 +353,7 @@ Model2DData *M2Datei::ladeModel( const char *name ) const
             polygon.vertex->add( p );
             if( ( options | 1 ) == options ) // wenn textur
             {
-                Punkt tp;
+                Vertex tp;
                 d.lese( (char*)&tp.x, 4 );
                 d.lese( (char*)&tp.y, 4 );
                 polygon.tKordinaten->add( tp );

Model2D.cpp

@@ -1,8 +1,9 @@
 #include "Model2D.h"
-#include "Bild.h"
+#include "Textur2D.h"
 #include "FrameworkMath.h"
 #include "Mat3.h"
 #include "MausEreignis.h"
+#include "Bild.h"
 
 using namespace Framework;
 
@@ -242,8 +243,8 @@ bool Model2DData::erstelleModell( Array< Polygon2D > *polygons )
                 {
                     DreieckListe< Vertex > *lowL = new DreieckListe< Vertex >();
                     DreieckListe< Vertex > *heightL = new DreieckListe< Vertex >();
-                    lowL->addPunkt( new Vertex( pg.vertex->get( i ) ), textur ? new Punkt( pg.tKordinaten->get( i ) ) : 0 );
-                    heightL->addPunkt( new Vertex( pg.vertex->get( i ) ), textur ? new Punkt( pg.tKordinaten->get( i ) ) : 0 );
+                    lowL->addPunkt( new Vertex( pg.vertex->get( i ) ), textur ? new Vertex( pg.tKordinaten->get( i ) ) : 0 );
+                    heightL->addPunkt( new Vertex( pg.vertex->get( i ) ), textur ? new Vertex( pg.tKordinaten->get( i ) ) : 0 );
                     int height = i + 1;
                     int low = i - 1;
                     Punkt outL( 0, 0 );
@@ -282,9 +283,9 @@ bool Model2DData::erstelleModell( Array< Polygon2D > *polygons )
                                 fertig = 1;
                                 outList.z( p )->set( Punkt( 0, 0 ), lauf );
                                 if( !k )
-                                    lowL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
+                                    lowL->addPunkt( new Vertex( b ), textur ? new Vertex( pg.tKordinaten->get( low ) ) : 0 );
                                 else
-                                    heightL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
+                                    heightL->addPunkt( new Vertex( b ), textur ? new Vertex( pg.tKordinaten->get( low ) ) : 0 );
                                 break;
                             }
                             bool inside = istLinieInnen( a, b, p );
@@ -299,17 +300,17 @@ bool Model2DData::erstelleModell( Array< Polygon2D > *polygons )
                             if( lowp )
                             {
                                 if( !k )
-                                    lowL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
+                                    lowL->addPunkt( new Vertex( b ), textur ? new Vertex( pg.tKordinaten->get( low ) ) : 0 );
                                 else
-                                    heightL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
+                                    heightL->addPunkt( new Vertex( b ), textur ? new Vertex( pg.tKordinaten->get( low ) ) : 0 );
                                 low--;
                             }
                             else
                             {
                                 if( !k )
-                                    lowL->addPunkt( new Vertex( a ), textur ? new Punkt( pg.tKordinaten->get( height ) ) : 0 );
+                                    lowL->addPunkt( new Vertex( a ), textur ? new Vertex( pg.tKordinaten->get( height ) ) : 0 );
                                 else
-                                    heightL->addPunkt( new Vertex( a ), textur ? new Punkt( pg.tKordinaten->get( height ) ) : 0 );
+                                    heightL->addPunkt( new Vertex( a ), textur ? new Vertex( pg.tKordinaten->get( height ) ) : 0 );
                                 height++;
                             }
                             lowp = !lowp;
@@ -407,14 +408,14 @@ Model2DData *Model2DData::release()
 // Inhalt der Model2D Klasse aus Model2D.h
 // Konstruktor
 Model2D::Model2D()
-    : Zeichnung(),
-    textur( 0 )
+    : Zeichnung()
 {
     farbe = 0;
     style = 0;
     rData = 0;
     drehung = 0;
     size = 1;
+    textur = new RCArray< Textur2D >;
     ref = 1;
 }
 
@@ -423,8 +424,7 @@ Model2D::~Model2D()
 {
     if( rData )
         rData->release();
-	if( textur )
-		textur->release();
+	textur->release();
 }
 
 // nicht constant
@@ -467,11 +467,26 @@ void Model2D::addSize( float size )
     rend = 1;
 }
 
-void Model2D::setTextur( Bild *t )
+void Model2D::setTextur( Textur2D *t )
 {
-    if( textur )
-        textur->release();
-    textur = t;
+    int index = 0;
+    if( rData )
+    {
+        for( auto i = rData->polygons->getArray(); i.set; i++ )
+            textur->set( t->getThis(), index++ );
+    }
+    t->release();
+}
+
+void Model2D::setTextur( Textur2D *t, const char *polygonName )
+{
+    int index = 0;
+    for( auto i = rData->polygons->getArray(); i.set; i++, index++ )
+    {
+        if( i.var.name->istGleich( polygonName ) )
+            textur->set( t->getThis(), index );
+    }
+    t->release();
 }
 
 void Model2D::setFarbe( int f )
@@ -510,7 +525,7 @@ void Model2D::render( Bild &zRObj )
         Mat3< float > mat = Mat3< float >::translation( pos ) * Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( size );
         if( hatStyle( Model2D::Style::Textur ) )
         {
-            if( !textur || !rData->polygons->get( num ).tKordinaten )
+            if( !textur || !textur->z( num ) || !textur->z( num )->zTextur() || !rData->polygons->get( num ).tKordinaten )
             {
                 for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
                 {
@@ -528,6 +543,7 @@ void Model2D::render( Bild &zRObj )
             }
             else
             {
+                Bild *txt = textur->z( num )->zTextur();
                 for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
                 {
                     for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
@@ -535,10 +551,13 @@ void Model2D::render( Bild &zRObj )
                         Vertex a = mat * *j->var->punkt;
                         Vertex b = mat * *j->next->var->punkt;
                         Vertex c = mat * *j->next->next->var->punkt;
+                        Punkt ta = (Punkt)Vertex( j->var->textur->x * (float)txt->getBreite(), j->var->textur->y * (float)txt->getHeight() );
+                        Punkt tb = (Punkt)Vertex( j->next->var->textur->x * (float)txt->getBreite(), j->next->var->textur->y * (float)txt->getHeight() );
+                        Punkt tc = (Punkt)Vertex( j->next->next->var->textur->x * (float)txt->getBreite(), j->next->next->var->textur->y * (float)txt->getHeight() );
                         if( hatStyle( Model2D::Style::Alpha ) )
-                            zRObj.drawDreieckTexturAlpha( a, b, c, *j->var->textur, *j->next->var->textur, *j->next->next->var->textur, *textur );
+                            zRObj.drawDreieckTexturAlpha( a, b, c, ta, tb, tc, *txt );
                         else
-                            zRObj.drawDreieckTextur( a, b, c, *j->var->textur, *j->next->var->textur, *j->next->next->var->textur, *textur );
+                            zRObj.drawDreieckTextur( a, b, c, ta, tb, tc, *txt );
                     }
                 }
             }
@@ -614,6 +633,8 @@ bool Model2D::istPunktInnen( Vertex p ) const
     int num = 0;
     for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
     {
+        if( polygon->var.transparent )
+            continue;
         Mat3< float > mat = Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( size );
         int anz = polygon->var.vertex->getEintragAnzahl();
         bool c = 0;
@@ -639,6 +660,8 @@ bool Model2D::istLinieInnen( Vertex a, Vertex b ) const
     int pAnz = rData->polygons->getEintragAnzahl();
     for( int p = 0; p < pAnz; p++ )
     {
+        if( rData->polygons->get( p ).transparent )
+            continue;
         Mat3< float > mat = Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( size );
         int anz = rData->polygons->get( p ).vertex->getEintragAnzahl();
         int j = anz - 1;
@@ -689,6 +712,8 @@ bool Model2D::istModelInnen( const Model2D *zMdl, bool end ) const
     Mat3< float > mat = Mat3< float >::translation( pos ) * Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( size );
     for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next )
     {
+        if( polygon->var.transparent )
+            continue;
         int anz = polygon->var.vertex->getEintragAnzahl();
         for( int i = 0; i < anz; i++ )
         {

Model2D.h

@@ -10,15 +10,16 @@
 namespace Framework
 {
     typedef Vec2< float > Vertex;
-    class Bild;
+    class Textur2D;
 
     // Eine Polygon Struktur, die von Model2D verwendet wird
     // Model2D Klasse löscht die Zeiger
     struct Polygon2D
     {
+        bool transparent;
         Text *name;
         Array< Vertex > *vertex;
-        Array< Punkt > *tKordinaten;
+        Array< Vertex > *tKordinaten;
     };
 
     // Die Daten für ein 2D Model
@@ -78,7 +79,7 @@ namespace Framework
         float size;
         int ref;
         int farbe;
-        Bild *textur;
+        RCArray< Textur2D > *textur;
 
     public:
         // Konstruktor
@@ -102,7 +103,11 @@ namespace Framework
         __declspec( dllexport ) void addSize( float size );
         // Setzt die Textur
         //  t: Das Bild, das als Textur verwendet werden soll
-        __declspec( dllexport ) void setTextur( Bild *t );
+        __declspec( dllexport ) void setTextur( Textur2D *t );
+        // Setzt die Textur
+        //  t: Das Bild, das als Textur verwendet werden soll
+        //  polygonName: Der name des Polygons, was die Textur bekommen soll
+        __declspec( dllexport ) void setTextur( Textur2D *t, const char *polygonName );
         // Setzt die Farbe
         //  f: Die Farbe im A8R8G8B8 Format
         __declspec( dllexport ) void setFarbe( int f );

Textur2D.cpp

@@ -0,0 +1,120 @@
+#include "Textur2D.h"
+#include "Bild.h"
+#include "Animation.h"
+
+using namespace Framework;
+// inhalt der Textur2D Klasse aus Textur2D.h
+
+// Konstructor
+Textur2D::Textur2D()
+{
+    circularAnimation = 0;
+    animationIndex = -1;
+    txt = 0;
+    animData = new Array< Animation* >();
+    ref = 1;
+}
+
+// Destructor
+Textur2D::~Textur2D()
+{
+    if( txt )
+        txt->release();
+    for( auto i = animData->getArray(); i.set; i++ )
+    {
+        i.var->data->release();
+        delete i.var;
+    }
+    animData->release();
+}
+
+// Legt fest, ob die animation sich automatisch wiederhohlen soll
+//  ca: 1, falls sich die animation automatisch wiederhohlen soll
+void Textur2D::setCircularAnimation( bool ca )
+{
+    circularAnimation = ca;
+}
+
+// setzt einen Zeiger auf die Textur (fals nicht animiert)
+//  textur: Der Zeiger auf das Bild
+void Textur2D::setTexturZ( Bild *textur )
+{
+    if( txt )
+        txt->release();
+    txt = textur;
+}
+
+// fügt eine Animation hinzu
+//  textur: Der Zeiger auf die Animationsdaten
+void Textur2D::addAnimationZ( Animation2DData *textur )
+{
+    animData->add( new Animation{ textur, 0, 0 } );
+}
+
+// aktiviert die nachfolgende animation
+void Textur2D::nextAnimation()
+{
+    if( animationIndex != -1 )
+    {
+        animData->get( animationIndex )->jetzt = 0;
+        animData->get( animationIndex )->ausgleich = 0;
+    }
+    animationIndex++;
+    int anz = animData->getEintragAnzahl();
+    if( animationIndex >= anz && ( !circularAnimation || anz == 0 ) )
+        animationIndex = -1;
+    else if( animationIndex >= anz )
+        animationIndex = 0;
+}
+
+// setzt die vergangene Zeit seit dem letzten Aufruf
+//  t: die vergangene Zeit in sekunden
+bool Textur2D::tick( double t )
+{
+    if( animationIndex != -1 )
+    {
+        Animation *a = animData->get( animationIndex );
+        a->ausgleich += t;
+        int tmp = a->jetzt;
+        int tmp2 = animationIndex;
+        a->data->lock();
+        if( a->ausgleich >= 1.0 / a->data->getFPS() )
+        {
+            a->ausgleich -= 1.0 / a->data->getFPS();
+            if( ++(a->jetzt) >= a->data->getBildAnzahl() )
+            {
+                a->jetzt = 0;
+                if( !a->data->istWiederhohlend() )
+                    nextAnimation();
+            }
+        }
+        a->data->unlock();
+        if( tmp != a->jetzt || tmp2 != animationIndex )
+            return 1;
+    }
+    return 0;
+}
+
+// gibt die aktuelle Textur zurück
+Bild *Textur2D::zTextur() const
+{
+    if( animationIndex != -1 )
+        return animData->get( animationIndex )->data->zBild( animData->get( animationIndex )->jetzt );
+    return txt;
+}
+
+// erhöht den Reference Counter um 1 und gibt this zurück
+Textur2D *Textur2D::getThis()
+{
+    ref++;
+    return this;
+}
+
+// verringert den reference counter um 1 und löscht sich selbst, falls er 0 erreicht
+//  gibt 0 zurück
+Textur2D *Textur2D::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

Textur2D.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "Array.h"
+
+namespace Framework
+{
+    class Bild;
+    class Animation2DData;
+
+    class Textur2D
+    {
+    private:
+        struct Animation
+        {
+            Animation2DData *data;
+            int jetzt;
+            double ausgleich;
+        };
+        bool circularAnimation;
+        int animationIndex;
+        Bild *txt;
+        Array< Animation* > *animData;
+        int ref;
+
+    public:
+        // Konstructor
+        Textur2D();
+        // Destructor
+        ~Textur2D();
+        // Legt fest, ob die animation sich automatisch wiederhohlen soll
+        //  ca: 1, falls sich die animation automatisch wiederhohlen soll
+        void setCircularAnimation( bool ca );
+        // setzt einen Zeiger auf die Textur (fals nicht animiert)
+        //  textur: Der Zeiger auf das Bild
+        void setTexturZ( Bild *textur );
+        // fügt eine Animation hinzu
+        //  textur: Der Zeiger auf die Animationsdaten
+        void addAnimationZ( Animation2DData *textur );
+        // aktiviert die nachfolgende animation
+        void nextAnimation();
+        // setzt die vergangene Zeit seit dem letzten Aufruf
+        //  t: die vergangene Zeit in sekunden
+        bool tick( double t );
+        // gibt die aktuelle Textur zurück
+        Bild *zTextur() const;
+        // erhöht den Reference Counter um 1 und gibt this zurück
+        Textur2D *getThis();
+        // verringert den reference counter um 1 und löscht sich selbst, falls er 0 erreicht
+        //  gibt 0 zurück
+        Textur2D *release();
+    };
+}