//---Include--- #include "Bild.h" #ifdef WIN32 # include #endif #include "AlphaFeld.h" #include "DateiSystem.h" #include "Globals.h" #include "MausEreignis.h" #include "Rahmen.h" #include "Scroll.h" #include "Text.h" #include "ToolTip.h" #ifdef WIN32 # include # pragma comment(lib, "gdiplus.lib") #endif #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) : ReferenceCounter(), fc(0), delFc(1), size(0, 0), 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 oldAlpha = ((fc >> 24) & 0xFF); bool newAlpha = alpha > oldAlpha; int na = (0x100 - alpha); fc = (((((na * (fc & 0xFF00FF)) >> 8) + ((alpha * (colorb & 0xFF00FF)) >> 8)) & 0xFF00FF) | ((((na * (fc & 0x00FF00)) >> 8) + ((alpha * (colorb & 0x00FF00)) >> 8)) & 0x00FF00) | ((colorb & 0xFF000000) * newAlpha) | ((fc & 0xFF000000) * !newAlpha)) * (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, const 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(xStart, y), xEnd - xStart, Vec2(tx_1, ty_1), Vec2(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, const 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(xStart, y), xEnd - xStart, Vec2(tx_1, ty_1), Vec2(tx_2, ty_2), txf, tyf, textur); } } void Bild::drawLinieHTextur(Vec2 p, double len, Vec2 ta, Vec2 tb, double txo, double tyo, const 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 p, double len, Vec2 ta, Vec2 tb, double txo, double tyo, const 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; if (alpha3D) { for (int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x) { for (; pixel < rowEnd; ++pixel) { alphaPixelP3D(*pixel, ff); } } } else { for (int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x) { for (; pixel < rowEnd; ++pixel) { alphaPixelP(*pixel, ff); } } } 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; x += drawOff[doa].x; y += drawOff[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; x += drawOff[doa].x; y += drawOff[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; x += drawOff[doa].x; y += drawOff[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])); } if (alpha3D) { for (int i = x + y * br; end < len; ++end, i += pval) { alphaPixelP3D(fc[i], f); } } else { for (int i = x + y * br; end < len; ++end, i += pval) { alphaPixelP(fc[i], 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])); } if (alpha3D) { for (int i = x + y * br; end < len; ++end, i += pval) { alphaPixelP3D(fc[i], f); } } else { for (int i = x + y * br; end < len; ++end, i += pval) { alphaPixelP(fc[i], 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 count = 0; int maxPixel = size.x * size.y; if (alpha3D) { 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]; alphaPixelP3D(pixel, 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]; alphaPixelP3D(pixel, 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]; alphaPixelP3D(pixel, 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]; alphaPixelP3D(pixel, 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]; alphaPixelP3D(pixel, fc); x += xf, y += yf; } } else { 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]; alphaPixelP(pixel, 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]; alphaPixelP(pixel, 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]; alphaPixelP(pixel, 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]; alphaPixelP(pixel, 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]; alphaPixelP(pixel, 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; } this->fc[(int)((int)(x + 0.5) + (int)(y + 0.5) * size.x)] = fc; 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; if (alpha3D) { 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]; alphaPixelP3D(pixel, fc); x += xf, y += yf; } int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x]; alphaPixelP3D(pixel, fc); } else { 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]; alphaPixelP(pixel, fc); x += xf, y += yf; } int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x]; alphaPixelP(pixel, fc); } 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])); } if (alpha3D) { 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]; alphaPixelP3D(*pixel, fc); } if (xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy) { pixel = &this->fc[xOff - a + (yOff + b) * size.x]; alphaPixelP3D(*pixel, fc); } if (xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy) { pixel = &this->fc[xOff + a + (yOff - b) * size.x]; alphaPixelP3D(*pixel, fc); } if (xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy) { pixel = &this->fc[xOff - a + (yOff - b) * size.x]; alphaPixelP3D(*pixel, fc); } if (xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy) { pixel = &this->fc[xOff + b + (yOff + a) * size.x]; alphaPixelP3D(*pixel, fc); } if (xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy) { pixel = &this->fc[xOff - b + (yOff + a) * size.x]; alphaPixelP3D(*pixel, fc); } if (xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy) { pixel = &this->fc[xOff + b + (yOff - a) * size.x]; alphaPixelP3D(*pixel, fc); } if (xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy) { pixel = &this->fc[xOff - b + (yOff - a) * size.x]; alphaPixelP3D(*pixel, fc); } } } else { 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]; alphaPixelP(*pixel, fc); } if (xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy) { pixel = &this->fc[xOff - a + (yOff + b) * size.x]; alphaPixelP(*pixel, fc); } if (xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy) { pixel = &this->fc[xOff + a + (yOff - b) * size.x]; alphaPixelP(*pixel, fc); } if (xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy) { pixel = &this->fc[xOff - a + (yOff - b) * size.x]; alphaPixelP(*pixel, fc); } if (xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy) { pixel = &this->fc[xOff + b + (yOff + a) * size.x]; alphaPixelP(*pixel, fc); } if (xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy) { pixel = &this->fc[xOff - b + (yOff + a) * size.x]; alphaPixelP(*pixel, fc); } if (xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy) { pixel = &this->fc[xOff + b + (yOff - a) * size.x]; alphaPixelP(*pixel, fc); } if (xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy) { pixel = &this->fc[xOff - b + (yOff - a) * size.x]; alphaPixelP(*pixel, fc); } } } rend = 1; } void Bild::drawBild( int x, int y, int br, int hi, const 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, const 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, const 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])); alphaPixelP3D(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])); alphaPixelP(this->fc[xx + ygr], fc); } } } } rend = 1; } void Bild::drawBild90(int x, int y, int br, int hi, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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 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 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, const 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 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 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() const { return alpha3D; } int Bild::getAverageColor() const { double a = 0; double r = 0; double g = 0; double b = 0; for (int i = 0; i < size.x * size.y; i++) { float currentA = (float)(fc[i] >> 24) / 255.f; a = a + currentA; r = r + (double)((float)((fc[i] >> 16) & 0xFF) * currentA); g = g + (double)((float)((fc[i] >> 8) & 0xFF) * currentA); b = b + (double)((float)(fc[i] & 0xFF) * currentA); } a = a / (size.x * size.y); r = (r / (size.x * size.y)) / a; g = (g / (size.x * size.y)) / a; b = (b / (size.x * size.y)) / a; a = a * 255; return ((((int)a) & 0xFF) << 24) | ((((int)r) & 0xFF) << 16) | ((((int)g) & 0xFF) << 8) | (((int)b) & 0xFF); } // 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 dynamic_cast(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( dynamic_cast(hintergrundBild->getThis())); if (bild) obj->setBild(dynamic_cast(bild->getThis())); obj->setStyle(style); return obj; } #ifdef WIN32 Bild* Framework::ladeBild(const 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