KSG-Framework/Bild.cpp

//---Include---
#include "Bild.h"

#ifdef WIN32
#    include <objidl.h>
#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 <gdiplus.h>
#    pragma comment(lib, "gdiplus.lib")
#endif

#ifndef WIN32
#    include <math.h>
#    include <stdlib.h>
#    include <string.h>
#    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<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,
    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<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,
    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<double> p,
    double len,
    Vec2<double> ta,
    Vec2<double> 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<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,
    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<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() 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*>(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<Bild*>(hintergrundBild->getThis()));
    if (bild) obj->setBild(dynamic_cast<Bild*>(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