//---Include--- #ifdef WIN32 #include #include #pragma comment( lib, "gdiplus.lib" ) #endif #include "Bild.h" #include "DateiSystem.h" #include "Scroll.h" #include "Rahmen.h" #include "MausEreignis.h" #include "Globals.h" #include "ToolTip.h" #include "Text.h" #include "AlphaFeld.h" #ifndef WIN32 #include #include #include #ifndef max #define max( a, b ) ( ( (a) > (b) ) ? (a) : (b) ) #endif #ifndef min #define min( a, b ) ( ( (a) < (b) ) ? (a) : (b) ) #endif #endif 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; } // Destruktor Bild::~Bild() { 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 ); } inline void Bild::alphaPixelP3D( int x, int y, int f ) { alphaPixelP3D( fc[ x + y * size.x ], f ); } inline void Bild::alphaPixelAssozP( int &fc, int f ) { unsigned char *fc1 = (unsigned char *)& fc; unsigned char *fc2 = (unsigned char *)& f; unsigned char na = (unsigned char)~fc2[ 3 ]; unsigned char a = (unsigned char)( fc2[ 3 ] + ( ( na * fc1[ 3 ] ) >> 8 ) ); if( a == 0 ) return; fc1[ 2 ] = (unsigned char)( ( fc2[ 2 ] * fc2[ 3 ] + ( ( fc1[ 2 ] * na * fc1[ 3 ] ) >> 8 ) ) / a ); fc1[ 1 ] = (unsigned char)( ( fc2[ 1 ] * fc2[ 3 ] + ( ( fc1[ 1 ] * na * fc1[ 3 ] ) >> 8 ) ) / a ); fc1[ 0 ] = (unsigned char)( ( fc2[ 0 ] * fc2[ 3 ] + ( ( fc1[ 0 ] * na * fc1[ 3 ] ) >> 8 ) ) / a ); fc1[ 3 ] = a; } inline void Bild::alphaPixelP3D( int &fc, int colorb ) { //alphaPixelAssozP( fc, colorb ); //return; 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 ) | ( fc == 0 ) * colorb; //unsigned char *fc1 = (unsigned char*)&fc; //unsigned char *fc2 = (unsigned char*)&colorb; //unsigned char na = 255-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 ); } inline void Bild::alphaPixelP( int &fc, int colorb ) { //alphaPixelAssozP( fc, colorb ); //return; 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 ) ) ); //unsigned char *fc1 = (unsigned char*)&fc; //unsigned char *fc2 = (unsigned char*)&colorb; //unsigned char na = 255-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; } 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; } } 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 ) { 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 ); if( alpha3D ) { 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++ ) alphaPixelP3D( fc[ x + y * size.x ], farbe ); } } else { 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 ) { 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; } 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; if( alpha3D ) { 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 ] ) ); } alphaPixelP3D( *fc, f ); x += txo, y += tyo; } } else { 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 // Prüft ob ein Rechteck vollständig oder teilweise in der Zeichen Fläche liegt. // return 0, falls das Rechteck nicht in der Zeichenfläche liegt, 1 sonst bool Bild::isAreaDrawable( int x, int y, int b, int h ) { 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 0; return 1; } // Wird dieser Flag gesetzt, so wird beim Alpha Blending wenn die vorheriege Farbe 0 ist nur die neue mit ihrem Alpha Wert kopiert. // 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; } 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 ); } void Bild::releaseAlpha() // Löscht alpha { --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; 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::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; } 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; } 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; } 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; if( alpha3D ) { 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 ) | ( *pixel == 0 ) * ff; } } } else { 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 ) ) ); } } } rend = 1; } void Bild::alphaPixel2D( int i, int f ) { if( !alpha[ alphaAnzahl ] ) alphaPixelP( fc[ i ], f ); else { 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::alphaPixel3D( int i, int f ) { if( !alpha[ alphaAnzahl ] ) alphaPixelP3D( fc[ i ], f ); else { unsigned char *cf = (unsigned char *)& f; cf[ 3 ] = (unsigned char)( ( cf[ 3 ] > alpha[ alphaAnzahl ] ) * ( cf[ 3 ] - alpha[ alphaAnzahl ] ) ); alphaPixelP3D( fc[ i ], f ); rend = 1; } } void Bild::alphaPixel2D( 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; } } void Bild::alphaPixel3D( int x, int y, int f ) { if( !alpha[ alphaAnzahl ] ) alphaPixelP3D( 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 ] ) ); alphaPixelP3D( fc[ x + y * size.x ], f ); rend = 1; } } void Bild::alphaPixelDP2D( 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; } void Bild::alphaPixelDP3D( 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 ] ) ); } alphaPixelP3D( fc[ x + y * size.x ], f ); rend = 1; } void Bild::alphaPixelDP2D( int i, int f ) { int x = i % size.x; int y = i / size.x; alphaPixelDP2D( x, y, f ); rend = 1; } void Bild::alphaPixelDP3D( int i, int f ) { int x = i % size.x; int y = i / size.x; alphaPixelDP3D( x, y, f ); rend = 1; } void Bild::setPixelDP( int x, int y, int f ) { if( alpha[ alphaAnzahl ] == 0xFF ) return; if( alpha[ alphaAnzahl ] ) { if( alpha3D ) alphaPixelDP3D( x, y, f ); else alphaPixelDP2D( 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; } 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; } 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; } 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; } 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; } void Bild::drawLinieBordered( Punkt a, Punkt b, int bc, int fc ) { if( alpha[ alphaAnzahl ] == 0xFF ) return; if( alpha[ alphaAnzahl ] ) { drawLinieBorderedAlpha( a, b, bc, 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( (float)( xlen * xlen + ylen * ylen ) ) + 0.5 ); int count = 0; int maxPixel = size.x * size.y; 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; if( (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * size.x ) < maxPixel && this->fc[ (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * size.x ) ] != fc ) this->fc[ (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * size.x ) ] = bc; if( (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * size.x ) < maxPixel && this->fc[ (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * size.x ) ] != fc ) this->fc[ (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * size.x ) ] = bc; if( (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * size.x ) < maxPixel && this->fc[ (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * size.x ) ] != fc ) this->fc[ (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * size.x ) ] = bc; if( (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * size.x ) < maxPixel && this->fc[ (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * size.x ) ] != fc ) this->fc[ (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * size.x ) ] = bc; x += xf, y += yf; } rend = 1; } } void Bild::drawLinieBorderedAlpha( Punkt a, Punkt b, int bc, 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( (float)( xlen * xlen + ylen * ylen ) ) + 0.5 ); int alpha = ( ( fc >> 24 ) & 0xFF ); int alpha2 = ( ( bc >> 24 ) & 0xFF ); int na = ( 0x100 - alpha ); int na2 = ( 0x100 - alpha2 ); int i1 = ( alpha * ( fc & 0xFF00FF ) ) >> 8; int i2 = ( alpha * ( fc & 0x00FF00 ) ) >> 8; int j1 = ( alpha2 * ( bc & 0xFF00FF ) ) >> 8; int j2 = ( alpha2 * ( bc & 0x00FF00 ) ) >> 8; int count = 0; int maxPixel = size.x * size.y; while( !( (int)( x + 0.5 ) == b.x && (int)( y + 0.5 ) == b.y ) && count < maxP ) { ++count; if( (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * size.x ) < maxPixel ) { int &pixel = this->fc[ (int)( x - 0.5 ) + (int)( y + 0.5 ) * size.x ]; pixel = ( ( ( ( ( na2 * ( pixel & 0xFF00FF ) ) >> 8 ) + j1 ) & 0xFF00FF ) | ( ( ( ( na2 * ( pixel & 0x00FF00 ) ) >> 8 ) + j2 ) & 0x00FF00 ) | ( pixel & 0xFF000000 ) ) * ( pixel != 0 || !alpha3D ) | ( pixel == 0 && alpha3D ) * bc; } if( (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * size.x ) < maxPixel ) { int &pixel = this->fc[ (int)( x + 1.5 ) + (int)( y + 0.5 ) * size.x ]; pixel = ( ( ( ( ( na2 * ( pixel & 0xFF00FF ) ) >> 8 ) + j1 ) & 0xFF00FF ) | ( ( ( ( na2 * ( pixel & 0x00FF00 ) ) >> 8 ) + j2 ) & 0x00FF00 ) | ( pixel & 0xFF000000 ) ) * ( pixel != 0 || !alpha3D ) | ( pixel == 0 && alpha3D ) * bc; } if( (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * size.x ) < maxPixel ) { int &pixel = this->fc[ (int)( x + 0.5 ) + (int)( y - 0.5 ) * size.x ]; pixel = ( ( ( ( ( na2 * ( pixel & 0xFF00FF ) ) >> 8 ) + j1 ) & 0xFF00FF ) | ( ( ( ( na2 * ( pixel & 0x00FF00 ) ) >> 8 ) + j2 ) & 0x00FF00 ) | ( pixel & 0xFF000000 ) ) * ( pixel != 0 || !alpha3D ) | ( pixel == 0 && alpha3D ) * bc; } if( (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * size.x ) < maxPixel ) { int &pixel = this->fc[ (int)( x + 0.5 ) + (int)( y + 1.5 ) * size.x ]; pixel = ( ( ( ( ( na2 * ( pixel & 0xFF00FF ) ) >> 8 ) + j1 ) & 0xFF00FF ) | ( ( ( ( na2 * ( pixel & 0x00FF00 ) ) >> 8 ) + j2 ) & 0x00FF00 ) | ( pixel & 0xFF000000 ) ) * ( pixel != 0 || !alpha3D ) | ( pixel == 0 && alpha3D ) * bc; } x += xf, y += yf; } count = 0; 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::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( (float)( 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( (float)( 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 ); } 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( (float)(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( (float)(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; } void Bild::alphaBildAssoz( 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 ) alphaPixelAssozP( 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 ] ) ); alphaPixelAssozP( this->fc[ xx + ygr ], fc ); } } } 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; if( alpha3D ) { for( int yy = yst2; yy < dgy; ++yy ) { ygr = yy * size.x; ygr2 = ( yy - yst2 + yst ) * bb; int fci = xst2 + ygr; int ffi = xst + ygr2; for( xx = xst2; xx < dgx; ++xx, ++fci, ++ffi ) alphaPixelP3D( fc[ fci ], ff[ ffi ] ); } } else { for( int yy = yst2; yy < dgy; ++yy ) { ygr = yy * size.x; ygr2 = ( yy - yst2 + yst ) * bb; int fci = xst2 + ygr; int ffi = xst + ygr2; for( xx = xst2; xx < dgx; ++xx, ++fci, ++ffi ) alphaPixelP( fc[ fci ], ff[ ffi ] ); } } } else { int xx, ygr, ygr2; if( alpha3D ) { 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 ); } } } else { 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 ] ) ); alphaPixelP3D( 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.getHeight() ); 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 + br, dgx ); dgy = minInt( y + hi, 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.getHeight() ); 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 + br, dgx ); dgy = minInt( y + hi, dgy ); int bb = zBild.getBreite(); int *ff = zBild.getBuffer(); if( !alpha[ alphaAnzahl ] ) { int yy, xbb; if( alpha3D ) { for( int xx = xst2; xx < dgx; ++xx ) { xbb = ( zBild.getHeight() - ( xx - xst2 + xst + 1 ) ) * bb; for( yy = yst2; yy < dgy; ++yy ) alphaPixelP3D( xx, yy, ff[ ( yy - yst2 + yst ) + xbb ] ); } } else { 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; if( alpha3D ) { 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 ] ) ); alphaPixelP3D( xx, yy, fc ); } } } else { 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; } 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.getHeight() ); 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 + br, dgx ); dgy = minInt( y + hi, dgy ); int bb = zBild.getBreite(); int *ff = zBild.getBuffer(); if( !alpha[ alphaAnzahl ] ) { int xx, ygr, ybb; if( alpha3D ) { 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 ) alphaPixelP3D( fc[ xx + ygr ], ff[ ( bb - ( xx - xst2 + xst + 1 ) ) + ybb ] ); } } else { 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; if( alpha3D ) { 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 ] ) ); alphaPixelP3D( this->fc[ xx + ygr ], fc ); } } } else { 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.getHeight() ); 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 + br, dgx ); dgy = minInt( y + hi, 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.getHeight() ); 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 + br, dgx ); dgy = minInt( y + hi, dgy ); int bb = zBild.getBreite(); int *ff = zBild.getBuffer(); if( !alpha[ alphaAnzahl ] ) { int yy, xbb; if( alpha3D ) { for( int xx = xst2; xx < dgx; ++xx ) { xbb = ( xx - xst2 + xst ) * bb; for( yy = yst2; yy < dgy; ++yy ) alphaPixelP3D( xx, yy, ff[ ( bb - ( yy - yst2 + yst + 1 ) ) + xbb ] ); } } else { 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; if( alpha3D ) { 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 ] ) ); alphaPixelP3D( xx, yy, fc ); } } } else { 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; } 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; if( alpha3D ) { 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 ] ) ); alphaPixelP3D( fc[ xx + ygr ], f ); } } } else { 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 < (float)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; } 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 < (float)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; } 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( (float)( ( 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; } 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; } 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; } 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; } void Bild::setDrawOptionsReset() { ++doa; dPosA[ doa ].x = 0; dPosA[ doa ].y = 0; dSizeA[ doa ].x = size.x; dSizeA[ doa ].y = size.y; drawOff[ doa ].x = 0; drawOff[ doa ].y = 0; } void Bild::addScrollOffset( int xOff, int yOff ) // setzt ScrollOffset { drawOff[ doa ].x -= xOff; drawOff[ doa ].y -= yOff; } void Bild::releaseDrawOptions() // setzt die Drawoptionen zurück { --doa; } bool Bild::getRend() { bool ret = rend; rend = 0; return ret; } // constant int *Bild::getBuffer()const // gibt buffer zurück { 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 ]; } const Punkt &Bild::getSize() const // gibt die Größe zurück { return size; } int Bild::getBreite() const // gibt die Breite zurück { return size.x; } int Bild::getHeight() const // gibt die Höhe zurück { return size.y; } unsigned char Bild::getAlpha() const // gibt den Alpha wert zurück { return (unsigned char)( 255 - alpha[ alphaAnzahl ] ); } const Punkt &Bild::getDrawPos() const { return dPosA[ doa ]; } const Punkt &Bild::getDrawGr() const { return dSizeA[ doa ]; } const Punkt &Bild::getDrawOff() const { return drawOff[ doa ]; } bool Bild::hasAlpha3D() { return alpha3D; } // Reference Counting Bild *Bild::getThis() { ++ref; return this; } Bild *Bild::release() { --ref; if( ref < 1 ) delete this; return 0; } // Inhalt der BildZ Klasse aus Bild.h // Konstruktor BildZ::BildZ() : ZeichnungHintergrund(), bild( 0 ) { style = Style::MELockZeichnung; mak = _ret1ME; } // Destruktor BildZ::~BildZ() { if( bild ) bild->release(); } void BildZ::doMausEreignis( MausEreignis &me, bool userRet ) // ruft Mak auf { if( userRet ) { 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 ); } me.verarbeitet = userRet; } // 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(); 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; } bool BildZ::tick( double tickVal ) // tick { return ZeichnungHintergrund::tick( tickVal ); } void BildZ::render( Bild & zRObj ) // zeichnet nach zRObj { if( hatStyle( Style::Sichtbar ) ) { ZeichnungHintergrund::render( zRObj ); lockZeichnung(); if( !zRObj.setDrawOptions( innenPosition, innenSize ) ) { unlockZeichnung(); return; } if( bild ) { int x = 0; int y = 0; int br = innenSize.x; int hi = innenSize.y; if( !( vertikalScrollBar && hatStyle( Style::VScroll ) ) && !( horizontalScrollBar && hatStyle( Style::HScroll ) ) ) { if( hatStyle( Style::Alpha ) ) { if( hatStyle( Style::Skalliert ) ) zRObj.alphaBildSkall( x, y, br, hi, *bild ); else zRObj.alphaBild( x, y, br, hi, *bild ); } else { if( hatStyle( Style::Skalliert ) ) zRObj.drawBildSkall( x, y, br, hi, *bild ); else zRObj.drawBild( x, y, br, hi, *bild ); } } else { if( !zRObj.setDrawOptions( x, y, br, hi ) ) { 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; } Bild *BildZ::zBild() const { 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->setToolTipZ( (ToolTip *)toolTip->dublizieren() ); obj->setStyle( style ); obj->setHintergrundFarbe( hintergrundFarbe ); if( hintergrundFeld ) obj->setAlphaFeldZ( (AlphaFeld *)hintergrundFeld->dublizieren() ); if( rahmen ) obj->setRahmenZ( (Rahmen *)rahmen->dublizieren() ); if( hintergrundBild ) obj->setHintergrundBild( hintergrundBild->getThis() ); if( bild ) obj->setBild( bild->getThis() ); obj->setStyle( style ); return obj; } #ifdef WIN32 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; } #endif