KSG-Framework/Bild.cpp

//---Include---
#ifdef WIN32

#include <Windows.h>
#include <GdiPlus.h>
#pragma comment( lib, "gdiplus.lib" )

#endif
#include "Bild.h"
#include "DateiSystem.h"
#include "Scroll.h"
#include "Rahmen.h"
#include "MausEreignis.h"
#include "Globals.h"
#include "ToolTip.h"
#include "Text.h"
#include "AlphaFeld.h"
#ifndef WIN32
#include <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 na = (0x100 - alpha);
	fc = (((((na * (fc & 0xFF00FF)) >> 8) + ((alpha * (colorb & 0xFF00FF)) >> 8)) & 0xFF00FF) |
		((((na * (fc & 0x00FF00)) >> 8) + ((alpha * (colorb & 0x00FF00)) >> 8)) & 0x00FF00) |
		((fc & 0xFF000000))) * (fc != 0) | (fc == 0) * colorb;
	//unsigned char *fc1 = (unsigned char*)&fc;
	//unsigned char *fc2 = (unsigned char*)&colorb;
	//unsigned char na = 255-fc2[ 3 ];
	//fc1[ 3 ] = fc2[ 3 ];
	//fc1[ 2 ] = (unsigned char)( ( fc2[ 2 ] * fc2[ 3 ] + fc1[ 2 ] * na ) / 255 );
	//fc1[ 1 ] = (unsigned char)( ( fc2[ 1 ] * fc2[ 3 ] + fc1[ 1 ] * na ) / 255 );
	//fc1[ 0 ] = (unsigned char)( ( fc2[ 0 ] * fc2[ 3 ] + fc1[ 0 ] * na ) / 255 );
}

inline void Bild::alphaPixelP(int& fc, int colorb)
{
	//alphaPixelAssozP( fc, colorb );
	//return;
	int alpha = ((colorb >> 24) & 0xFF);
	int na = (0x100 - alpha);
	fc = (((((na * (fc & 0xFF00FF)) >> 8) + ((alpha * (colorb & 0xFF00FF)) >> 8)) & 0xFF00FF) |
		((((na * (fc & 0x00FF00)) >> 8) + ((alpha * (colorb & 0x00FF00)) >> 8)) & 0x00FF00) |
		((fc & 0xFF000000)));
	//unsigned char *fc1 = (unsigned char*)&fc;
	//unsigned char *fc2 = (unsigned char*)&colorb;
	//unsigned char na = 255-fc2[ 3 ];
	//fc1[ 3 ] = fc2[ 3 ];
	//fc1[ 2 ] = (unsigned char)( ( fc2[ 2 ] * fc2[ 3 ] + fc1[ 2 ] * na ) / 255 );
	//fc1[ 1 ] = (unsigned char)( ( fc2[ 1 ] * fc2[ 3 ] + fc1[ 1 ] * na ) / 255 );
	//fc1[ 0 ] = (unsigned char)( ( fc2[ 0 ] * fc2[ 3 ] + fc1[ 0 ] * na ) / 255 );
}

char Bild::getOutCode(Punkt p) const
{
	char ret = 0;
	if (p.x < dPosA[doa].x)
		ret = 1;
	if (p.x >= dSizeA[doa].x)
		ret = 2;
	if (p.y < dPosA[doa].y)
		ret |= 4;
	if (p.y >= dSizeA[doa].y)
		ret |= 8;
	return ret;
}

void Bild::drawFlatDreieck(int y1, int y2, float m1, float b1, float m2, float b2, int farbe)
{
	const int yStart = max(y1, dPosA[doa].y);
	const int yEnd = min(y2, dSizeA[doa].y);
	for (int y = yStart; y < yEnd; y++)
	{
		const int xStart = max((int)(m1 * (float)y + b1 + 0.5f), dPosA[doa].x);
		const int xEnd = min((int)(m2 * (float)y + b2 + 0.5f), dSizeA[doa].x);
		for (int x = xStart; x < xEnd; x++)
			fc[x + y * size.x] = farbe;
	}
}

void Bild::drawFlatDreieckTextur(int y1, int y2, double m1, double b1, double m2, double b2, double tx1, double ty1, double tx2, double ty2,
	double tx_1o, double ty_1o, double tx_2o, double ty_2o, double txf, double tyf, Bild& textur)
{
	const double yStart = max(y1, dPosA[doa].y);
	const double yEnd = min(y2, dSizeA[doa].y);
	double tx_1 = tx1 + tx_1o * (yStart - y1), ty_1 = ty1 + ty_1o * (yStart - y1), tx_2 = tx2 + tx_2o * (yStart - y1), ty_2 = ty2 + ty_2o * (yStart - y1);
	for (double y = yStart; y < yEnd; y++, tx_1 += tx_1o, ty_1 += ty_1o, tx_2 += tx_2o, ty_2 += ty_2o)
	{
		const double xStart = m1 * y + b1;
		const double xEnd = m2 * y + b2;
		drawLinieHTextur(Vec2< double >(xStart, y), xEnd - xStart, Vec2< double >(tx_1, ty_1), Vec2< double >(tx_2, ty_2), txf, tyf, textur);
	}
}

void Bild::drawFlatDreieckAlpha(int y1, int y2, float m1, float b1, float m2, float b2, int farbe)
{
	const int yStart = max((int)(y1 + 0.5), dPosA[doa].y);
	const int yEnd = min((int)(y2 + 0.5), dSizeA[doa].y);
	if (alpha3D)
	{
		for (int y = yStart; y < yEnd; y++)
		{
			const int xStart = max((int)(m1 * ((float)y + 0.5f) + b1 + 0.5f), dPosA[doa].x);
			const int xEnd = min((int)(m2 * ((float)y + 0.5) + b2 + 0.5f), dSizeA[doa].x);
			for (int x = xStart; x < xEnd; x++)
				alphaPixelP3D(fc[x + y * size.x], farbe);
		}
	}
	else
	{
		for (int y = yStart; y < yEnd; y++)
		{
			const int xStart = max((int)(m1 * ((float)y + 0.5f) + b1 + 0.5f), dPosA[doa].x);
			const int xEnd = min((int)(m2 * ((float)y + 0.5) + b2 + 0.5f), dSizeA[doa].x);
			for (int x = xStart; x < xEnd; x++)
				alphaPixelP(fc[x + y * size.x], farbe);
		}
	}
}

void Bild::drawFlatDreieckTexturAlpha(int y1, int y2, double m1, double b1, double m2, double b2, double tx1, double ty1, double tx2, double ty2,
	double tx_1o, double ty_1o, double tx_2o, double ty_2o, double txf, double tyf, Bild& textur)
{
	const double yStart = max(y1, dPosA[doa].y);
	const double yEnd = min(y2, dSizeA[doa].y);
	double tx_1 = tx1 + tx_1o * (yStart - y1), ty_1 = ty1 + ty_1o * (yStart - y1), tx_2 = tx2 + tx_2o * (yStart - y1), ty_2 = ty2 + ty_2o * (yStart - y1);
	for (double y = yStart; y < yEnd; y++, tx_1 += tx_1o, ty_1 += ty_1o, tx_2 += tx_2o, ty_2 += ty_2o)
	{
		const double xStart = m1 * y + b1;
		const double xEnd = m2 * y + b2;
		drawLinieHTexturAlpha(Vec2< double >(xStart, y), xEnd - xStart, Vec2< double >(tx_1, ty_1), Vec2< double >(tx_2, ty_2), txf, tyf, textur);
	}
}

void Bild::drawLinieHTextur(Vec2< double > p, double len, Vec2< double > ta, Vec2< double > tb, double txo, double tyo, Bild& textur) // zeichnet eine horizontale Linie
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		drawLinieHTexturAlpha(p, len, ta, tb, txo, tyo, textur);
		return;
	}
	if (len < 0)
	{
		p.x += len;
		len = -len;
		ta.Swap(tb);
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	if (p.y < dpy || p.y >= dgy)
		return;
	double off = 0;
	if (p.x < dpx)
	{
		off = dpx - p.x;
		len -= dpx - p.x;
		if (len <= 0)
			return;
		p.x = dpx;
	}
	if (p.x + len >= dgx)
	{
		len -= p.x - dgx + len;
		if (len <= 0)
			return;
	}
	int br = size.x;
	int* fc = this->fc + (int)(p.x + (int)p.y * br);
	double x = ta.x + txo * off, y = ta.y + tyo * off;
	int* buffer = textur.getBuffer();
	int txtBr = textur.getBreite();
	for (int i = 0; i < len; ++i, ++fc)
	{
		*fc = buffer[(int)((int)(x + 0.5) + (int)(y + 0.5) * txtBr)];
		x += txo, y += tyo;
	}
	rend = 1;
}

void Bild::drawLinieHTexturAlpha(Vec2< double > p, double len, Vec2< double > ta, Vec2< double > tb, double txo, double tyo, Bild& textur) // zeichnet eine horizontale Linie
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (len < 0)
	{
		p.x += len;
		len = -len;
		ta.Swap(tb);
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	if (p.y < dpy || p.y >= dgy)
		return;
	double off = 0;
	if (p.x < dpx)
	{
		off = dpx - p.x;
		len -= dpx - p.x;
		if (len <= 0)
			return;
		p.x = dpx;
	}
	if (p.x + len >= dgx)
	{
		len -= p.x - dgx + len;
		if (len <= 0)
			return;
	}
	int br = size.x;
	int* fc = this->fc + (int)(p.x + (int)p.y * br);
	double x = ta.x + txo * off, y = ta.y + tyo * off;
	int* buffer = textur.getBuffer();
	int txtBr = textur.getBreite();
	int f;
	if (alpha3D)
	{
		for (int i = 0; i < len; ++i, ++fc)
		{
			f = buffer[(int)((int)(x + 0.5) + (int)(y + 0.5) * txtBr)];
			if (alpha[alphaAnzahl])
			{
				unsigned char* cf = (unsigned char*)&f;
				cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
			}
			alphaPixelP3D(*fc, f);
			x += txo, y += tyo;
		}
	}
	else
	{
		for (int i = 0; i < len; ++i, ++fc)
		{
			f = buffer[(int)((int)(x + 0.5) + (int)(y + 0.5) * txtBr)];
			if (alpha[alphaAnzahl])
			{
				unsigned char* cf = (unsigned char*)&f;
				cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
			}
			alphaPixelP(*fc, f);
			x += txo, y += tyo;
		}
	}
	rend = 1;
}

// nicht constant

// Prüft ob ein Rechteck vollständig oder teilweise in der Zeichen Fläche liegt.
//  return 0, falls das Rechteck nicht in der Zeichenfläche liegt, 1 sonst
bool Bild::isAreaDrawable(int x, int y, int b, int h)
{
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + b < dpx || y + h < dpy || x > dgx || y > dgy)
		return 0;
	return 1;
}

// Wird dieser Flag gesetzt, so wird beim Alpha Blending wenn die vorheriege Farbe 0 ist nur die neue mit ihrem Alpha Wert kopiert.
// Das ist sinnvoll für die Verwendung im 3DBildschirm, wo das Gezeichnette Bild später mittels Alpha Blending angezeigt wird
void Bild::setAlpha3D(bool erlaubt)
{
	alpha3D = erlaubt;
}

void Bild::setAlpha(unsigned char alpha) // setzt die Transparenz der nachfolgenden Zeichnunge
{
	int last = this->alpha[alphaAnzahl];
	++alphaAnzahl;
	assert(alphaAnzahl < 1000);
	this->alpha[alphaAnzahl] = (unsigned char)((255 - alpha) > last ? (255 - alpha) : last);
}

void Bild::releaseAlpha() // Löscht alpha
{
	--alphaAnzahl;
}

void Bild::setPixelBuffer(int* buffer, bool deleteBuffer, int breite, int height) // setzt den Zeiger auf die Pixel des Bildes
{
	if (delFc)
		delete[]fc;
	fc = buffer;
	delFc = deleteBuffer;
	size.x = breite;
	size.y = height;
	drawOff[0].x = 0;
	drawOff[0].y = 0;
	dPosA[0].x = 0;
	dPosA[0].y = 0;
	dSizeA[0] = size;
	alphaAnzahl = 0;
	alpha[0] = 0;
	doa = 0;
	rend = 1;
}

void Bild::neuBild(int breite, int height, int fillColor)
{
	if (fc && delFc)
		delete[] fc;
	size.x = breite;
	size.y = height;
	fc = new int[size.x * size.y];
	setFarbe(fillColor);
	drawOff[0].x = 0;
	drawOff[0].y = 0;
	dPosA[0].x = 0;
	dPosA[0].y = 0;
	dSizeA[0] = size;
	alphaAnzahl = 0;
	alpha[0] = 0;
	doa = 0;
	rend = 1;
}

void Bild::setFarbe(int f)
{
	if ((f & 0xFF) == ((f >> 8) & 0xFF) && (f & 0xFF) == ((f >> 16) & 0xFF) && (f & 0xFF) == ((f >> 24) & 0xFF))
		memset(fc, f, size.x * size.y * 4);
	else
	{
		for (int* i = fc, *end = i + size.x * size.y; i < end; i++)
			*i = f;
	}
	rend = 1;
}

void Bild::fillRegion(int x, int y, int b, int h, int ff)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		alphaRegion(x, y, b, h, ff);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + b < dpx || y + h < dpy || x > dgx || y > dgy)
		return;
	if (x < dpx)
	{
		b -= dpx - x;
		x = dpx;
	}
	if (y < dpy)
	{
		h -= dpy - y;
		y = dpy;
	}
	b = (x + b) >= dgx ? (dgx - x) : b;
	h = (y + h) >= dgy ? (dgy - y) : h;
	int* pixel = fc + y * size.x + x;
	int* rowEnd = pixel + b;
	for (int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x)
	{
		for (; pixel < rowEnd; ++pixel)
			*pixel = ff;
	}
	rend = 1;
}

void Bild::alphaRegion(int x, int y, int b, int h, int ff)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + b < dpx || y + h < dpy || x > dgx || y > dgy)
		return;
	if (x < dpx)
	{
		b -= dpx - x;
		x = dpx;
	}
	if (y < dpy)
	{
		h -= dpy - y;
		y = dpy;
	}
	b = (x + b) >= dgx ? (dgx - x) : b;
	h = (y + h) >= dgy ? (dgy - y) : h;
	if (alpha[alphaAnzahl])
	{
		unsigned char* cf = (unsigned char*)&ff;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
	}
	int* pixel = fc + y * size.x + x;
	int* rowEnd = pixel + b;
	int alpha = ((ff >> 24) & 0xFF);
	int na = (0x100 - alpha);
	int i1 = (alpha * (ff & 0xFF00FF)) >> 8;
	int i2 = (alpha * (ff & 0x00FF00)) >> 8;
	if (alpha3D)
	{
		for (int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x)
		{
			for (; pixel < rowEnd; ++pixel)
			{
				*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
					((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
					((*pixel & 0xFF000000))) * (*pixel != 0) | (*pixel == 0) * ff;
			}
		}
	}
	else
	{
		for (int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x)
		{
			for (; pixel < rowEnd; ++pixel)
			{
				*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
					((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
					((*pixel & 0xFF000000)));
			}
		}
	}
	rend = 1;
}

void Bild::alphaPixel2D(int i, int f)
{
	if (!alpha[alphaAnzahl])
		alphaPixelP(fc[i], f);
	else
	{
		unsigned char* cf = (unsigned char*)&f;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
		alphaPixelP(fc[i], f);
		rend = 1;
	}
}

void Bild::alphaPixel3D(int i, int f)
{
	if (!alpha[alphaAnzahl])
		alphaPixelP3D(fc[i], f);
	else
	{
		unsigned char* cf = (unsigned char*)&f;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
		alphaPixelP3D(fc[i], f);
		rend = 1;
	}
}

void Bild::alphaPixel2D(int x, int y, int f)
{
	if (!alpha[alphaAnzahl])
		alphaPixelP(fc[x + y * size.x], f);
	if (alpha[alphaAnzahl] < 0xFF)
	{
		unsigned char* cf = (unsigned char*)&f;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
		alphaPixelP(fc[x + y * size.x], f);
		rend = 1;
	}
}

void Bild::alphaPixel3D(int x, int y, int f)
{
	if (!alpha[alphaAnzahl])
		alphaPixelP3D(fc[x + y * size.x], f);
	if (alpha[alphaAnzahl] < 0xFF)
	{
		unsigned char* cf = (unsigned char*)&f;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
		alphaPixelP3D(fc[x + y * size.x], f);
		rend = 1;
	}
}

void Bild::alphaPixelDP2D(int x, int y, int f)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	if (x < dpx || y < dpy || x > dgx || y > dgy)
		return;
	if (alpha[alphaAnzahl])
	{
		unsigned char* cf = (unsigned char*)&f;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
	}
	alphaPixelP(fc[x + y * size.x], f);
	rend = 1;
}

void Bild::alphaPixelDP3D(int x, int y, int f)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	if (x < dpx || y < dpy || x > dgx || y > dgy)
		return;
	if (alpha[alphaAnzahl])
	{
		unsigned char* cf = (unsigned char*)&f;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
	}
	alphaPixelP3D(fc[x + y * size.x], f);
	rend = 1;
}

void Bild::alphaPixelDP2D(int i, int f)
{
	int x = i % size.x;
	int y = i / size.x;
	alphaPixelDP2D(x, y, f);
	rend = 1;
}

void Bild::alphaPixelDP3D(int i, int f)
{
	int x = i % size.x;
	int y = i / size.x;
	alphaPixelDP3D(x, y, f);
	rend = 1;
}

void Bild::setPixelDP(int x, int y, int f)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		if (alpha3D)
			alphaPixelDP3D(x, y, f);
		else
			alphaPixelDP2D(x, y, f);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	if (x < dpx || y < dpy || x > dgx || y > dgy)
		return;
	fc[x + y * size.x] = f;
	rend = 1;
}

void Bild::setPixelDP(int i, int f)
{
	int x = i % size.x;
	int y = i / size.x;
	setPixelDP(x, y, f);
	rend = 1;
}

void Bild::drawLinieH(int x, int y, int len, int f) // zeichnet eine horizontale Linie
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		drawLinieHAlpha(x, y, len, f);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (y < dpy || y >= dgy)
		return;
	if (x < dpx)
	{
		len -= dpx - x;
		if (len <= 0)
			return;
		x = dpx;
	}
	if (x + len >= dgx)
	{
		len -= x - dgx + len;
		if (len <= 0)
			return;
	}
	int br = size.x;
	int* fc = this->fc + x + y * br;
	int pval = len < 0 ? -1 : 1;
	len = len > 0 ? len : -len;
	for (int i = 0; i < len; ++i, fc += pval)
		*fc = f;
	rend = 1;
}

void Bild::drawLinieV(int x, int y, int len, int f) // zeichnet eine vertikale Linie
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		drawLinieVAlpha(x, y, len, f);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x < dpx || x >= dgx)
		return;
	if (y < dpy)
	{
		len -= dpy - y;
		if (len <= 0)
			return;
		y = dpy;
	}
	if (y + len >= dgy)
	{
		len -= y - dgy + len;
		if (len < 0)
			return;
	}
	int br = size.x;
	int* fc = this->fc + x + y * br;
	int pval = len < 0 ? -br : br;
	len = len > 0 ? len : -len;
	for (int i = 0; i < len; ++i, fc += pval)
		*fc = f;
	rend = 1;
}

void Bild::drawLinieHAlpha(int x, int y, int len, int f) // zeichnet eine horizontale Linie
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (y < dpy || y >= dgy)
		return;
	if (x < dpx)
	{
		len -= dpx - x;
		if (len <= 0)
			return;
		x = dpx;
	}
	if (x + len >= dgx)
	{
		len -= x - dgx + len;
		if (len <= 0)
			return;
	}
	int br = size.x;
	int pval = len < 0 ? -1 : 1;
	len = len > 0 ? len : -len;
	int end = 0;
	if (alpha[alphaAnzahl])
	{
		unsigned char* cf = (unsigned char*)&f;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
	}
	int alpha = ((f >> 24) & 0xFF);
	int na = (0x100 - alpha);
	int i1 = (alpha * (f & 0xFF00FF)) >> 8;
	int i2 = (alpha * (f & 0x00FF00)) >> 8;
	for (int i = x + y * br; end < len; ++end, i += pval)
	{
		fc[i] = (((((na * (fc[i] & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
			((((na * (fc[i] & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
			((fc[i] & 0xFF000000))) * (fc[i] != 0 || !alpha3D) | (fc[i] == 0 && alpha3D) * f;
	}
	rend = 1;
}

void Bild::drawLinieVAlpha(int x, int y, int len, int f) // zeichnet eine vertikale Linie
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x < dpx || x >= dgx)
		return;
	if (y < dpy)
	{
		len -= dpy - y;
		if (len <= 0)
			return;
		y = dpy;
	}
	if (y + len >= dgy)
	{
		len -= y - dgy + len;
		if (len < 0)
			return;
	}
	int br = size.x;
	int pval = len < 0 ? -br : br;
	len = len > 0 ? len : -len;
	int end = 0;
	if (alpha[alphaAnzahl])
	{
		unsigned char* cf = (unsigned char*)&f;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
	}
	int alpha = ((f >> 24) & 0xFF);
	int na = (0x100 - alpha);
	int i1 = (alpha * (f & 0xFF00FF)) >> 8;
	int i2 = (alpha * (f & 0x00FF00)) >> 8;
	for (int i = x + y * br; end < len; ++end, i += pval)
	{
		fc[i] = (((((na * (fc[i] & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
			((((na * (fc[i] & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
			(fc[i] & 0xFF000000)) * (fc[i] != 0 || !alpha3D) | (fc[i] == 0 && alpha3D) * f;
	}
	rend = 1;
}

void Bild::drawLinieBordered(Punkt a, Punkt b, int bc, int fc)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		drawLinieBorderedAlpha(a, b, bc, fc);
		return;
	}
	a += drawOff[doa];
	b += drawOff[doa];
	char outCode1 = getOutCode(a);
	char outCode2 = getOutCode(b);
	bool ok = 0;
	while (1)
	{
		int xMax = dSizeA[doa].x - 1;
		int yMax = dSizeA[doa].y - 1;
		if (!(outCode1 | outCode2))
		{
			ok = 1;
			break;
		}
		else if (outCode1 & outCode2)
			break;
		else
		{
			int x = 0, y = 0;
			char outCodeOut = outCode1 ? outCode1 : outCode2;
			if (outCodeOut & 8)
			{
				x = (int)(a.x + (b.x - a.x) * (yMax - a.y) / (b.y - a.y) + 0.5);
				y = yMax;
			}
			else if (outCodeOut & 4)
			{
				x = (int)(a.x + (b.x - a.x) * (dPosA[doa].y - a.y) / (b.y - a.y) + 0.5);
				y = dPosA[doa].y;
			}
			else if (outCodeOut & 2)
			{
				y = (int)(a.y + (b.y - a.y) * (xMax - a.x) / (b.x - a.x) + 0.5);
				x = xMax;
			}
			else if (outCodeOut & 1)
			{
				y = (int)(a.y + (b.y - a.y) * (dPosA[doa].x - a.x) / (b.x - a.x) + 0.5);
				x = dPosA[doa].x;
			}
			if (outCodeOut == outCode1)
			{
				a.x = x;
				a.y = y;
				outCode1 = getOutCode(a);
			}
			else
			{
				b.x = x;
				b.y = y;
				outCode2 = getOutCode(b);
			}
		}
	}
	if (ok)
	{
		int xlen = b.x - a.x, axlen = abs(xlen);
		int ylen = b.y - a.y, aylen = abs(ylen);
		double xf = (double)xlen / (aylen ? aylen : 1);
		double yf = (double)ylen / (axlen ? axlen : 1);
		if (axlen > aylen)
			xf = xf < 0 ? -1 : 1;
		else
			yf = yf < 0 ? -1 : 1;
		double x = (double)a.x, y = (double)a.y;
		int maxP = (int)(sqrt((float)(xlen * xlen + ylen * ylen)) + 0.5);
		int count = 0;
		int maxPixel = size.x * size.y;
		while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
		{
			++count;
			this->fc[(int)((int)(x + 0.5) + (int)(y + 0.5) * size.x)] = fc;
			if ((int)((int)(x - 0.5) + (int)(y + 0.5) * size.x) < maxPixel &&
				this->fc[(int)((int)(x - 0.5) + (int)(y + 0.5) * size.x)] != fc)
				this->fc[(int)((int)(x - 0.5) + (int)(y + 0.5) * size.x)] = bc;
			if ((int)((int)(x + 1.5) + (int)(y + 0.5) * size.x) < maxPixel &&
				this->fc[(int)((int)(x + 1.5) + (int)(y + 0.5) * size.x)] != fc)
				this->fc[(int)((int)(x + 1.5) + (int)(y + 0.5) * size.x)] = bc;
			if ((int)((int)(x + 0.5) + (int)(y - 0.5) * size.x) < maxPixel &&
				this->fc[(int)((int)(x + 0.5) + (int)(y - 0.5) * size.x)] != fc)
				this->fc[(int)((int)(x + 0.5) + (int)(y - 0.5) * size.x)] = bc;
			if ((int)((int)(x + 0.5) + (int)(y + 1.5) * size.x) < maxPixel &&
				this->fc[(int)((int)(x + 0.5) + (int)(y + 1.5) * size.x)] != fc)
				this->fc[(int)((int)(x + 0.5) + (int)(y + 1.5) * size.x)] = bc;
			x += xf, y += yf;
		}
		rend = 1;
	}
}

void Bild::drawLinieBorderedAlpha(Punkt a, Punkt b, int bc, int fc)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	a += drawOff[doa];
	b += drawOff[doa];
	char outCode1 = getOutCode(a);
	char outCode2 = getOutCode(b);
	bool ok = 0;
	while (1)
	{
		int xMax = dSizeA[doa].x - 1;
		int yMax = dSizeA[doa].y - 1;
		if (!(outCode1 | outCode2))
		{
			ok = 1;
			break;
		}
		else if (outCode1 & outCode2)
			break;
		else
		{
			int x = 0, y = 0;
			char outCodeOut = outCode1 ? outCode1 : outCode2;
			if (outCodeOut & 8)
			{
				x = (int)(a.x + (b.x - a.x) * (yMax - a.y) / (b.y - a.y) + 0.5);
				y = yMax;
			}
			else if (outCodeOut & 4)
			{
				x = (int)(a.x + (b.x - a.x) * (dPosA[doa].y - a.y) / (b.y - a.y) + 0.5);
				y = dPosA[doa].y;
			}
			else if (outCodeOut & 2)
			{
				y = (int)(a.y + (b.y - a.y) * (xMax - a.x) / (b.x - a.x) + 0.5);
				x = xMax;
			}
			else if (outCodeOut & 1)
			{
				y = (int)(a.y + (b.y - a.y) * (dPosA[doa].x - a.x) / (b.x - a.x) + 0.5);
				x = dPosA[doa].x;
			}
			if (outCodeOut == outCode1)
			{
				a.x = x;
				a.y = y;
				outCode1 = getOutCode(a);
			}
			else
			{
				b.x = x;
				b.y = y;
				outCode2 = getOutCode(b);
			}
		}
	}
	if (ok)
	{
		int xlen = b.x - a.x, axlen = abs(xlen);
		int ylen = b.y - a.y, aylen = abs(ylen);
		double xf = (double)xlen / (aylen ? aylen : 1);
		double yf = (double)ylen / (axlen ? axlen : 1);
		if (axlen > aylen)
			xf = xf < 0 ? -1 : 1;
		else
			yf = yf < 0 ? -1 : 1;
		double x = (double)a.x, y = (double)a.y;
		if (alpha[alphaAnzahl])
		{
			unsigned char* cf = (unsigned char*)&fc;
			cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
		}
		int maxP = (int)(sqrt((float)(xlen * xlen + ylen * ylen)) + 0.5);
		int alpha = ((fc >> 24) & 0xFF);
		int alpha2 = ((bc >> 24) & 0xFF);
		int na = (0x100 - alpha);
		int na2 = (0x100 - alpha2);
		int i1 = (alpha * (fc & 0xFF00FF)) >> 8;
		int i2 = (alpha * (fc & 0x00FF00)) >> 8;
		int j1 = (alpha2 * (bc & 0xFF00FF)) >> 8;
		int j2 = (alpha2 * (bc & 0x00FF00)) >> 8;
		int count = 0;
		int maxPixel = size.x * size.y;
		while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
		{
			++count;
			if ((int)((int)(x - 0.5) + (int)(y + 0.5) * size.x) < maxPixel)
			{
				int& pixel = this->fc[(int)(x - 0.5) + (int)(y + 0.5) * size.x];
				pixel = (((((na2 * (pixel & 0xFF00FF)) >> 8) + j1) & 0xFF00FF) |
					((((na2 * (pixel & 0x00FF00)) >> 8) + j2) & 0x00FF00) |
					(pixel & 0xFF000000)) * (pixel != 0 || !alpha3D) | (pixel == 0 && alpha3D) * bc;
			}
			if ((int)((int)(x + 1.5) + (int)(y + 0.5) * size.x) < maxPixel)
			{
				int& pixel = this->fc[(int)(x + 1.5) + (int)(y + 0.5) * size.x];
				pixel = (((((na2 * (pixel & 0xFF00FF)) >> 8) + j1) & 0xFF00FF) |
					((((na2 * (pixel & 0x00FF00)) >> 8) + j2) & 0x00FF00) |
					(pixel & 0xFF000000)) * (pixel != 0 || !alpha3D) | (pixel == 0 && alpha3D) * bc;
			}
			if ((int)((int)(x + 0.5) + (int)(y - 0.5) * size.x) < maxPixel)
			{
				int& pixel = this->fc[(int)(x + 0.5) + (int)(y - 0.5) * size.x];
				pixel = (((((na2 * (pixel & 0xFF00FF)) >> 8) + j1) & 0xFF00FF) |
					((((na2 * (pixel & 0x00FF00)) >> 8) + j2) & 0x00FF00) |
					(pixel & 0xFF000000)) * (pixel != 0 || !alpha3D) | (pixel == 0 && alpha3D) * bc;
			}
			if ((int)((int)(x + 0.5) + (int)(y + 1.5) * size.x) < maxPixel)
			{
				int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 1.5) * size.x];
				pixel = (((((na2 * (pixel & 0xFF00FF)) >> 8) + j1) & 0xFF00FF) |
					((((na2 * (pixel & 0x00FF00)) >> 8) + j2) & 0x00FF00) |
					(pixel & 0xFF000000)) * (pixel != 0 || !alpha3D) | (pixel == 0 && alpha3D) * bc;
			}
			x += xf, y += yf;
		}
		count = 0;
		while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
		{
			++count;
			int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
			pixel = (((((na * (pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(pixel & 0xFF000000)) * (pixel != 0 || !alpha3D) | (pixel == 0 && alpha3D) * fc;
			x += xf, y += yf;
		}
		rend = 1;
	}
}

void Bild::drawLinie(Punkt a, Punkt b, int fc) // zeichnet eine Linie von Punkt( x1, y1 ) nach Punke( x2, y2 )
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		drawLinieAlpha(a, b, fc);
		return;
	}
	a += drawOff[doa];
	b += drawOff[doa];
	char outCode1 = getOutCode(a);
	char outCode2 = getOutCode(b);
	bool ok = 0;
	while (1)
	{
		int xMax = dSizeA[doa].x - 1;
		int yMax = dSizeA[doa].y - 1;
		if (!(outCode1 | outCode2))
		{
			ok = 1;
			break;
		}
		else if (outCode1 & outCode2)
			break;
		else
		{
			int x = 0, y = 0;
			char outCodeOut = outCode1 ? outCode1 : outCode2;
			if (outCodeOut & 8)
			{
				x = (int)(a.x + (b.x - a.x) * (yMax - a.y) / (b.y - a.y) + 0.5);
				y = yMax;
			}
			else if (outCodeOut & 4)
			{
				x = (int)(a.x + (b.x - a.x) * (dPosA[doa].y - a.y) / (b.y - a.y) + 0.5);
				y = dPosA[doa].y;
			}
			else if (outCodeOut & 2)
			{
				y = (int)(a.y + (b.y - a.y) * (xMax - a.x) / (b.x - a.x) + 0.5);
				x = xMax;
			}
			else if (outCodeOut & 1)
			{
				y = (int)(a.y + (b.y - a.y) * (dPosA[doa].x - a.x) / (b.x - a.x) + 0.5);
				x = dPosA[doa].x;
			}
			if (outCodeOut == outCode1)
			{
				a.x = x;
				a.y = y;
				outCode1 = getOutCode(a);
			}
			else
			{
				b.x = x;
				b.y = y;
				outCode2 = getOutCode(b);
			}
		}
	}
	if (ok)
	{
		int xlen = b.x - a.x, axlen = abs(xlen);
		int ylen = b.y - a.y, aylen = abs(ylen);
		double xf = (double)xlen / (aylen ? aylen : 1);
		double yf = (double)ylen / (axlen ? axlen : 1);
		if (axlen > aylen)
			xf = xf < 0 ? -1 : 1;
		else
			yf = yf < 0 ? -1 : 1;
		double x = (double)a.x, y = (double)a.y;
		int maxP = (int)(sqrt((float)(xlen * xlen + ylen * ylen)) + 0.5);
		int count = 0;
		while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
		{
			++count;
			this->fc[(int)((int)(x + 0.5) + (int)(y + 0.5) * size.x)] = fc;
			x += xf, y += yf;
		}
		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;
		int alpha = ((fc >> 24) & 0xFF);
		int na = (0x100 - alpha);
		int i1 = (alpha * (fc & 0xFF00FF)) >> 8;
		int i2 = (alpha * (fc & 0x00FF00)) >> 8;
		while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
		{
			++count;
			int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
			pixel = (((((na * (pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(pixel & 0xFF000000)) * (pixel != 0 || !alpha3D) | (pixel == 0 && alpha3D) * fc;
			x += xf, y += yf;
		}
		int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
		pixel = (((((na * (pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
			((((na * (pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
			(pixel & 0xFF000000)) * (pixel != 0 || !alpha3D) | (pixel == 0 && alpha3D) * fc;
		rend = 1;
	}
}

void Bild::fillCircle(int xOff, int yOff, int r, int fc) // zeichnet einen Kreis um Punkt( xOff, yOff ) mit radius r
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	for (int i = r; i > 0; i--)
		drawKreis(xOff, yOff, i, fc);
}

void Bild::drawKreis(int xOff, int yOff, int r, int fc) // zeichnet einen Kreis um Punkt( xOff, yOff ) mit radius r
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		drawKreisAlpha(xOff, yOff, r, fc);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	xOff += drawOff[doa].x;
	yOff += drawOff[doa].y;
	if (xOff + r < dpx || xOff - r >= dgx || yOff + r < dpy || yOff - r >= dgy)
		return;
	for (int a = 0; a < r; ++a)
	{
		int b = (int)(sqrt((float)(long)(r * r - a * a)) + 0.5);
		if (xOff + a < dgx && xOff + a > dpx && yOff + b < dgy && yOff + b > dpy)
			this->fc[xOff + a + (yOff + b) * size.x] = fc;
		if (xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy)
			this->fc[xOff - a + (yOff + b) * size.x] = fc;
		if (xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy)
			this->fc[xOff + a + (yOff - b) * size.x] = fc;
		if (xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy)
			this->fc[xOff - a + (yOff - b) * size.x] = fc;
		if (xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy)
			this->fc[xOff + b + (yOff + a) * size.x] = fc;
		if (xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy)
			this->fc[xOff - b + (yOff + a) * size.x] = fc;
		if (xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy)
			this->fc[xOff + b + (yOff - a) * size.x] = fc;
		if (xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy)
			this->fc[xOff - b + (yOff - a) * size.x] = fc;
	}
	rend = 1;
}

void Bild::drawKreisAlpha(int xOff, int yOff, int r, int fc)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	xOff += drawOff[doa].x;
	yOff += drawOff[doa].y;
	if (xOff + r < dpx || xOff - r >= dgx || yOff + r < dpy || yOff - r >= dgy)
		return;
	if (alpha[alphaAnzahl] < 0xFF)
	{
		unsigned char* cf = (unsigned char*)&fc;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
	}
	int alpha = ((fc >> 24) & 0xFF);
	int na = (0x100 - alpha);
	int i1 = (alpha * (fc & 0xFF00FF)) >> 8;
	int i2 = (alpha * (fc & 0x00FF00)) >> 8;
	for (int a = 0; a < r; ++a)
	{
		int b = (int)(sqrt((float)(long)(r * r - a * a)) + 0.5);
		int* pixel = 0;
		if (xOff + a < dgx && xOff + a > dpx && yOff + b < dgy && yOff + b > dpy)
		{
			pixel = &this->fc[xOff + a + (yOff + b) * size.x];
			*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(*pixel & 0xFF000000)) * (*pixel != 0 || !alpha3D) | (*pixel == 0 && alpha3D) * fc;
		}
		if (xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy)
		{
			pixel = &this->fc[xOff - a + (yOff + b) * size.x];
			*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(*pixel & 0xFF000000)) * (*pixel != 0 || !alpha3D) | (*pixel == 0 && alpha3D) * fc;
		}
		if (xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy)
		{
			pixel = &this->fc[xOff + a + (yOff - b) * size.x];
			*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(*pixel & 0xFF000000)) * (*pixel != 0 || !alpha3D) | (*pixel == 0 && alpha3D) * fc;
		}
		if (xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy)
		{
			pixel = &this->fc[xOff - a + (yOff - b) * size.x];
			*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(*pixel & 0xFF000000)) * (*pixel != 0 || !alpha3D) | (*pixel == 0 && alpha3D) * fc;
		}
		if (xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy)
		{
			pixel = &this->fc[xOff + b + (yOff + a) * size.x];
			*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(*pixel & 0xFF000000)) * (*pixel != 0 || !alpha3D) | (*pixel == 0 && alpha3D) * fc;
		}
		if (xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy)
		{
			pixel = &this->fc[xOff - b + (yOff + a) * size.x];
			*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(*pixel & 0xFF000000)) * (*pixel != 0 || !alpha3D) | (*pixel == 0 && alpha3D) * fc;
		}
		if (xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy)
		{
			pixel = &this->fc[xOff + b + (yOff - a) * size.x];
			*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(*pixel & 0xFF000000)) * (*pixel != 0 || !alpha3D) | (*pixel == 0 && alpha3D) * fc;
		}
		if (xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy)
		{
			pixel = &this->fc[xOff - b + (yOff - a) * size.x];
			*pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF) |
				((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00) |
				(*pixel & 0xFF000000)) * (*pixel != 0 || !alpha3D) | (*pixel == 0 && alpha3D) * fc;
		}
	}
	rend = 1;
}

void Bild::drawBild(int x, int y, int br, int hi, Bild& zBild) // zeichet zBild
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		alphaBild(x, y, br, hi, zBild);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + br < dpx || y + hi < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getBreite());
	hi = minInt(hi, zBild.getHeight());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	int xx, ygr, ygr2;
	for (int yy = yst2; yy < dgy; ++yy)
	{
		ygr = yy * size.x;
		ygr2 = (yy - yst2 + yst) * bb;
		for (xx = xst2; xx < dgx; ++xx)
			fc[xx + ygr] = ff[(xx - xst2 + xst) + ygr2];
	}
	rend = 1;
}

void Bild::alphaBildAssoz(int x, int y, int br, int hi, Bild& zBild)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + br < dpx || y + hi < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getBreite());
	hi = minInt(hi, zBild.getHeight());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	if (!alpha[alphaAnzahl])
	{
		int xx, ygr, ygr2;
		for (int yy = yst2; yy < dgy; ++yy)
		{
			ygr = yy * size.x;
			ygr2 = (yy - yst2 + yst) * bb;
			for (xx = xst2; xx < dgx; ++xx)
				alphaPixelAssozP(fc[xx + ygr], ff[(xx - xst2 + xst) + ygr2]);
		}
	}
	else
	{
		int xx, ygr, ygr2;
		for (int yy = yst2; yy < dgy; ++yy)
		{
			ygr = yy * size.x;
			ygr2 = (yy - yst2 + yst) * bb;
			for (xx = xst2; xx < dgx; ++xx)
			{
				int fc = ff[(xx - xst2 + xst) + ygr2];
				unsigned char* cf = (unsigned char*)&fc;
				cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
				alphaPixelAssozP(this->fc[xx + ygr], fc);
			}
		}
	}
	rend = 1;
}

void Bild::alphaBild(int x, int y, int br, int hi, Bild& zBild)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + br < dpx || y + hi < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getBreite());
	hi = minInt(hi, zBild.getHeight());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	if (!alpha[alphaAnzahl])
	{
		int xx, ygr, ygr2;
		if (alpha3D)
		{
			for (int yy = yst2; yy < dgy; ++yy)
			{
				ygr = yy * size.x;
				ygr2 = (yy - yst2 + yst) * bb;
				int fci = xst2 + ygr;
				int ffi = xst + ygr2;
				for (xx = xst2; xx < dgx; ++xx, ++fci, ++ffi)
					alphaPixelP3D(fc[fci], ff[ffi]);
			}
		}
		else
		{
			for (int yy = yst2; yy < dgy; ++yy)
			{
				ygr = yy * size.x;
				ygr2 = (yy - yst2 + yst) * bb;
				int fci = xst2 + ygr;
				int ffi = xst + ygr2;
				for (xx = xst2; xx < dgx; ++xx, ++fci, ++ffi)
					alphaPixelP(fc[fci], ff[ffi]);
			}
		}
	}
	else
	{
		int xx, ygr, ygr2;
		if (alpha3D)
		{
			for (int yy = yst2; yy < dgy; ++yy)
			{
				ygr = yy * size.x;
				ygr2 = (yy - yst2 + yst) * bb;
				for (xx = xst2; xx < dgx; ++xx)
				{
					int fc = ff[(xx - xst2 + xst) + ygr2];
					unsigned char* cf = (unsigned char*)&fc;
					cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
					alphaPixelP(this->fc[xx + ygr], fc);
				}
			}
		}
		else
		{
			for (int yy = yst2; yy < dgy; ++yy)
			{
				ygr = yy * size.x;
				ygr2 = (yy - yst2 + yst) * bb;
				for (xx = xst2; xx < dgx; ++xx)
				{
					int fc = ff[(xx - xst2 + xst) + ygr2];
					unsigned char* cf = (unsigned char*)&fc;
					cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
					alphaPixelP3D(this->fc[xx + ygr], fc);
				}
			}
		}
	}
	rend = 1;
}

void Bild::drawBild90(int x, int y, int br, int hi, Bild& zBild) // Zeichnet ein um 90 Grad nach rchts gedrehtes Bild
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		alphaBild90(x, y, br, hi, zBild);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + hi < dpx || y + br < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getHeight());
	hi = minInt(hi, zBild.getBreite());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	int yy, xbb;
	for (int xx = xst2; xx < dgx; ++xx)
	{
		xbb = (zBild.getHeight() - (xx - xst2 + xst + 1)) * bb;
		for (yy = yst2; yy < dgy; ++yy)
			fc[xx + yy * size.x] = ff[(yy - yst2 + yst) + xbb];
	}
	rend = 1;
}

void Bild::alphaBild90(int x, int y, int br, int hi, Bild& zBild)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + hi < dpx || y + br < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getHeight());
	hi = minInt(hi, zBild.getBreite());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	if (!alpha[alphaAnzahl])
	{
		int yy, xbb;
		if (alpha3D)
		{
			for (int xx = xst2; xx < dgx; ++xx)
			{
				xbb = (zBild.getHeight() - (xx - xst2 + xst + 1)) * bb;
				for (yy = yst2; yy < dgy; ++yy)
					alphaPixelP3D(xx, yy, ff[(yy - yst2 + yst) + xbb]);
			}
		}
		else
		{
			for (int xx = xst2; xx < dgx; ++xx)
			{
				xbb = (zBild.getHeight() - (xx - xst2 + xst + 1)) * bb;
				for (yy = yst2; yy < dgy; ++yy)
					alphaPixelP(xx, yy, ff[(yy - yst2 + yst) + xbb]);
			}
		}
	}
	else
	{
		int yy, xbb;
		if (alpha3D)
		{
			for (int xx = xst2; xx < dgx; ++xx)
			{
				xbb = (zBild.getHeight() - (xx - xst2 + xst + 1)) * bb;
				for (yy = yst2; yy < dgy; ++yy)
				{
					int fc = ff[(yy - yst2 + yst) + xbb];
					unsigned char* cf = (unsigned char*)&fc;
					cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
					alphaPixelP3D(xx, yy, fc);
				}
			}
		}
		else
		{
			for (int xx = xst2; xx < dgx; ++xx)
			{
				xbb = (zBild.getHeight() - (xx - xst2 + xst + 1)) * bb;
				for (yy = yst2; yy < dgy; ++yy)
				{
					int fc = ff[(yy - yst2 + yst) + xbb];
					unsigned char* cf = (unsigned char*)&fc;
					cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
					alphaPixelP(xx, yy, fc);
				}
			}
		}
	}
	rend = 1;
}

void Bild::drawBild180(int x, int y, int br, int hi, Bild& zBild) // Zeichnet ein um 180 Grad nach rchts gedrehtes Bild
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		alphaBild180(x, y, br, hi, zBild);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + br < dpx || y + hi < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getBreite());
	hi = minInt(hi, zBild.getHeight());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	int xx, ygr, ybb;
	for (int yy = yst2; yy < dgy; ++yy)
	{
		ygr = yy * size.x;
		ybb = (zBild.getHeight() - (yy - yst2 + yst + 1)) * bb;
		for (xx = xst2; xx < dgx; ++xx)
			fc[xx + ygr] = ff[(bb - (xx - xst2 + xst + 1)) + ybb];
	}
	rend = 1;
}

void Bild::alphaBild180(int x, int y, int br, int hi, Bild& zBild)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + br < dpx || y + hi < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getHeight());
	hi = minInt(hi, zBild.getBreite());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	if (!alpha[alphaAnzahl])
	{
		int xx, ygr, ybb;
		if (alpha3D)
		{
			for (int yy = yst2; yy < dgy; ++yy)
			{
				ygr = yy * size.x;
				ybb = (zBild.getHeight() - (yy - yst2 + yst + 1)) * bb;
				for (xx = xst2; xx < dgx; ++xx)
					alphaPixelP3D(fc[xx + ygr], ff[(bb - (xx - xst2 + xst + 1)) + ybb]);
			}
		}
		else
		{
			for (int yy = yst2; yy < dgy; ++yy)
			{
				ygr = yy * size.x;
				ybb = (zBild.getHeight() - (yy - yst2 + yst + 1)) * bb;
				for (xx = xst2; xx < dgx; ++xx)
					alphaPixelP(fc[xx + ygr], ff[(bb - (xx - xst2 + xst + 1)) + ybb]);
			}
		}
	}
	else
	{
		int xx, ygr, ybb;
		if (alpha3D)
		{
			for (int yy = yst2; yy < dgy; ++yy)
			{
				ygr = yy * size.x;
				ybb = (zBild.getHeight() - (yy - yst2 + yst + 1)) * bb;
				for (xx = xst2; xx < dgx; ++xx)
				{
					int fc = ff[(bb - (xx - xst2 + xst + 1)) + ybb];
					unsigned char* cf = (unsigned char*)&fc;
					cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
					alphaPixelP3D(this->fc[xx + ygr], fc);
				}
			}
		}
		else
		{
			for (int yy = yst2; yy < dgy; ++yy)
			{
				ygr = yy * size.x;
				ybb = (zBild.getHeight() - (yy - yst2 + yst + 1)) * bb;
				for (xx = xst2; xx < dgx; ++xx)
				{
					int fc = ff[(bb - (xx - xst2 + xst + 1)) + ybb];
					unsigned char* cf = (unsigned char*)&fc;
					cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
					alphaPixelP(this->fc[xx + ygr], fc);
				}
			}
		}
	}
	rend = 1;
}

void Bild::drawBild270(int x, int y, int br, int hi, Bild& zBild) // Zeichnet ein um 270 Grad nach rchts gedrehtes Bild
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		alphaBild270(x, y, br, hi, zBild);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + hi < dpx || y + br < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getHeight());
	hi = minInt(hi, zBild.getBreite());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	int yy, xbb;
	for (int xx = xst2; xx < dgx; ++xx)
	{
		xbb = (xx - xst2 + xst) * bb;
		for (yy = yst2; yy < dgy; ++yy)
			fc[xx + yy * size.x] = ff[(bb - (yy - yst2 + yst + 1)) + xbb];
	}
	rend = 1;
}

void Bild::alphaBild270(int x, int y, int br, int hi, Bild& zBild)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + hi < dpx || y + br < dpy || x > dgx || y > dgy)
		return;
	br = minInt(br, zBild.getHeight());
	hi = minInt(hi, zBild.getBreite());
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	if (!alpha[alphaAnzahl])
	{
		int yy, xbb;
		if (alpha3D)
		{
			for (int xx = xst2; xx < dgx; ++xx)
			{
				xbb = (xx - xst2 + xst) * bb;
				for (yy = yst2; yy < dgy; ++yy)
					alphaPixelP3D(xx, yy, ff[(bb - (yy - yst2 + yst + 1)) + xbb]);
			}
		}
		else
		{
			for (int xx = xst2; xx < dgx; ++xx)
			{
				xbb = (xx - xst2 + xst) * bb;
				for (yy = yst2; yy < dgy; ++yy)
					alphaPixelP(xx, yy, ff[(bb - (yy - yst2 + yst + 1)) + xbb]);
			}
		}
	}
	else
	{
		int yy, xbb;
		if (alpha3D)
		{
			for (int xx = xst2; xx < dgx; ++xx)
			{
				xbb = (xx - xst2 + xst) * bb;
				for (yy = yst2; yy < dgy; ++yy)
				{
					int fc = ff[(bb - (yy - yst2 + yst + 1)) + xbb];
					unsigned char* cf = (unsigned char*)&fc;
					cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
					alphaPixelP3D(xx, yy, fc);
				}
			}
		}
		else
		{
			for (int xx = xst2; xx < dgx; ++xx)
			{
				xbb = (xx - xst2 + xst) * bb;
				for (yy = yst2; yy < dgy; ++yy)
				{
					int fc = ff[(bb - (yy - yst2 + yst + 1)) + xbb];
					unsigned char* cf = (unsigned char*)&fc;
					cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
					alphaPixelP(xx, yy, fc);
				}
			}
		}
	}
	rend = 1;
}

void Bild::drawBildSkall(int x, int y, int br, int hi, Bild& zBild) // zeichet zBild Skalliert
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		alphaBildSkall(x, y, br, hi, zBild);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + br < dpx || y + hi < dpy || x > dgx || y > dgy)
		return;
	double xo = zBild.getBreite() / (double)br;
	double yo = zBild.getHeight() / (double)hi;
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	int xx, ygr, ygr2;
	double xb = 0, yb = yst * yo;
	for (int yy = yst2; yy < dgy; ++yy, yb += yo)
	{
		ygr = yy * size.x;
		ygr2 = (int)((yy - yst2 + yst) * yo) * bb;
		for (xx = xst2, xb = xst * xo; xx < dgx; ++xx, xb += xo)
			fc[xx + ygr] = ff[(int)xb + ygr2];
	}
	rend = 1;
}

void Bild::alphaBildSkall(int x, int y, int br, int hi, Bild& zBild)
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	x += drawOff[doa].x;
	y += drawOff[doa].y;
	if (x + br < dpx || y + hi < dpy || x > dgx || y > dgy)
		return;
	double xo = zBild.getBreite() / (double)br;
	double yo = zBild.getHeight() / (double)hi;
	int xst = maxInt(dpx - x, 0);
	int yst = maxInt(dpy - y, 0);
	int xst2 = maxInt(x, dpx);
	int yst2 = maxInt(y, dpy);
	dgx = minInt(x + br, dgx);
	dgy = minInt(y + hi, dgy);
	int bb = zBild.getBreite();
	int* ff = zBild.getBuffer();
	int xx, ygr, ygr2;
	double xb = 0;
	if (alpha3D)
	{
		for (int yy = yst2; yy < dgy; ++yy)
		{
			ygr = yy * size.x;
			ygr2 = (int)((yy - yst2 + yst) * yo) * bb;
			for (xx = xst2, xb = xst * xo; xx < dgx; ++xx, xb += xo)
			{
				int f = ff[(int)xb + ygr2];
				unsigned char* cf = (unsigned char*)&f;
				cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
				alphaPixelP3D(fc[xx + ygr], f);
			}
		}
	}
	else
	{
		for (int yy = yst2; yy < dgy; ++yy)
		{
			ygr = yy * size.x;
			ygr2 = (int)((yy - yst2 + yst) * yo) * bb;
			for (xx = xst2, xb = xst * xo; xx < dgx; ++xx, xb += xo)
			{
				int f = ff[(int)xb + ygr2];
				unsigned char* cf = (unsigned char*)&f;
				cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
				alphaPixelP(fc[xx + ygr], f);
			}
		}
	}
	rend = 1;
}

void Bild::drawDreieck(Punkt a, Punkt b, Punkt c, int farbe) // füllt eine Dreieck aus
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		drawDreieckAlpha(a, b, c, farbe);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	a += drawOff[doa];
	b += drawOff[doa];
	c += drawOff[doa];
	if ((a.x < dpx && b.x < dpx && c.x < dpx) || (a.y < dpy && b.y < dpy && c.y < dpy) ||
		(a.x > dgx && b.x > dgx && c.x > dgx) || (a.y > dgy && b.y > dgy && c.y > dgy))
		return;
	if (b.y < a.y)
		a.Swap(b);
	if (c.y < b.y)
		b.Swap(c);
	if (b.y < a.y)
		a.Swap(b);
	if (a.y == b.y)
	{
		if (b.x < a.x)
			a.Swap(b);
		const float m2 = (float)(a.x - c.x) / (float)(a.y - c.y);
		const float m3 = (float)(b.x - c.x) / (float)(b.y - c.y);
		float b2 = (float)a.x - m2 * (float)a.y;
		float b3 = (float)b.x - m3 * (float)b.y;
		drawFlatDreieck(b.y, c.y, m2, b2, m3, b3, farbe);
	}
	else if (b.y == c.y)
	{
		if (c.x < b.x)
			b.Swap(c);
		const float m1 = (float)(a.x - b.x) / (float)(a.y - b.y);
		const float m2 = (float)(a.x - c.x) / (float)(a.y - c.y);
		float b1 = (float)a.x - m1 * (float)a.y;
		float b2 = (float)a.x - m2 * (float)a.y;
		drawFlatDreieck(a.y, b.y, m1, b1, m2, b2, farbe);
	}
	else
	{
		const float m1 = (float)(a.x - b.x) / (float)(a.y - b.y);
		const float m2 = (float)(a.x - c.x) / (float)(a.y - c.y);
		const float m3 = (float)(b.x - c.x) / (float)(b.y - c.y);
		float b1 = (float)a.x - m1 * (float)a.y;
		float b2 = (float)a.x - m2 * (float)a.y;
		float b3 = (float)b.x - m3 * (float)b.y;
		const float qx = m2 * (float)b.y + b2;
		if (qx < (float)b.x)
		{
			drawFlatDreieck(a.y, b.y, m2, b2, m1, b1, farbe);
			drawFlatDreieck(b.y, c.y, m2, b2, m3, b3, farbe);
		}
		else
		{
			drawFlatDreieck(a.y, b.y, m1, b1, m2, b2, farbe);
			drawFlatDreieck(b.y, c.y, m3, b3, m2, b2, farbe);
		}
	}
	rend = 1;
}

void Bild::drawDreieckTextur(Punkt a, Punkt b, Punkt c, Punkt ta, Punkt tb, Punkt tc, Bild& textur) // füllt eine Dreieck aus
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	if (alpha[alphaAnzahl])
	{
		drawDreieckTexturAlpha(a, b, c, ta, tb, tc, textur);
		return;
	}
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	a += drawOff[doa];
	b += drawOff[doa];
	c += drawOff[doa];
	if ((a.x < dpx && b.x < dpx && c.x < dpx) || (a.y < dpy && b.y < dpy && c.y < dpy) ||
		(a.x > dgx && b.x > dgx && c.x > dgx) || (a.y > dgy && b.y > dgy && c.y > dgy))
		return;
	if (b.y < a.y)
	{
		a.Swap(b);
		ta.Swap(tb);
	}
	if (c.y < b.y)
	{
		b.Swap(c);
		tb.Swap(tc);
	}
	if (b.y < a.y)
	{
		a.Swap(b);
		ta.Swap(tb);
	}
	const double m1 = (double)(a.x - b.x) / (a.y - b.y);
	const double m2 = (double)(a.x - c.x) / (a.y - c.y);
	const double m3 = (double)(b.x - c.x) / (b.y - c.y);
	double b1 = a.x - m1 * a.y;
	double b2 = a.x - m2 * a.y;
	double b3 = b.x - m3 * b.y;
	const double qx = m2 * b.y + b2;
	if (qx < b.x)
	{
		double tx1o, ty1o, tx2o, ty2o;
		if (c.y - a.y)
		{
			tx1o = (double)(tc.x - ta.x) / (c.y - a.y);
			ty1o = (double)(tc.y - ta.y) / (c.y - a.y);
		}
		else
		{
			tx1o = 0;
			ty1o = 0;
		}
		if (b.y - a.y)
		{
			tx2o = (double)(tb.x - ta.x) / (b.y - a.y);
			ty2o = (double)(tb.y - ta.y) / (b.y - a.y);
		}
		else
		{
			tx2o = 0;
			ty2o = 0;
		}
		Vec2< double > q(ta.x + tx1o * (b.y - a.y), ta.y + ty1o * (b.y - a.y));
		double txf, tyf;
		if (b.x - qx)
		{
			txf = (tb.x - q.x) / (b.x - qx);
			tyf = (tb.y - q.y) / (b.x - qx);
		}
		else
		{
			txf = 0;
			tyf = 0;
		}
		drawFlatDreieckTextur(a.y, b.y, m2, b2, m1, b1, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur);
		if (c.y - b.y)
		{
			tx2o = (double)(tc.x - tb.x) / (c.y - b.y);
			ty2o = (double)(tc.y - tb.y) / (c.y - b.y);
		}
		else
		{
			tx2o = 0;
			ty2o = 0;
		}
		drawFlatDreieckTextur(b.y, c.y, m2, b2, m3, b3, q.x, q.y, tb.x, tb.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur);
	}
	else
	{
		double tx1o, ty1o, tx2o, ty2o;
		if (b.y - a.y)
		{
			tx1o = (double)(tb.x - ta.x) / (b.y - a.y);
			ty1o = (double)(tb.y - ta.y) / (b.y - a.y);
		}
		else
		{
			tx1o = 0;
			ty1o = 0;
		}
		if (c.y - a.y)
		{
			tx2o = (double)(tc.x - ta.x) / (c.y - a.y);
			ty2o = (double)(tc.y - ta.y) / (c.y - a.y);
		}
		else
		{
			tx2o = 0;
			ty2o = 0;
		}
		Vec2< double > q(ta.x + tx2o * (b.y - a.y), ta.y + ty2o * (b.y - a.y));
		double txf, tyf;
		if (qx - b.x)
		{
			txf = (q.x - tb.x) / (qx - b.x);
			tyf = (q.y - tb.y) / (qx - b.x);
		}
		else
		{
			txf = 0;
			tyf = 0;
		}
		drawFlatDreieckTextur(a.y, b.y, m1, b1, m2, b2, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur);
		if (c.y - b.y)
		{
			tx1o = (double)(tc.x - tb.x) / (c.y - b.y);
			ty1o = (double)(tc.y - tb.y) / (c.y - b.y);
		}
		else
		{
			tx1o = 0;
			ty1o = 0;
		}
		drawFlatDreieckTextur(b.y, c.y, m3, b3, m2, b2, tb.x, tb.y, q.x, q.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur);
	}
	rend = 1;
}

void Bild::drawDreieckAlpha(Punkt a, Punkt b, Punkt c, int farbe) // füllt eine Dreieck aus
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	a += drawOff[doa];
	b += drawOff[doa];
	c += drawOff[doa];
	if ((a.x < dpx && b.x < dpx && c.x < dpx) || (a.y < dpy && b.y < dpy && c.y < dpy) ||
		(a.x > dgx && b.x > dgx && c.x > dgx) || (a.y > dgy && b.y > dgy && c.y > dgy))
		return;
	if (alpha[alphaAnzahl])
	{
		unsigned char* cf = (unsigned char*)&farbe;
		cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl]) * (cf[3] - alpha[alphaAnzahl]));
	}
	if (b.y < a.y)
		a.Swap(b);
	if (c.y < b.y)
		b.Swap(c);
	if (b.y < a.y)
		a.Swap(b);
	if (a.y == b.y)
	{
		if (b.x < a.x)
			a.Swap(b);
		const float m2 = (float)(a.x - c.x) / (float)(a.y - c.y);
		const float m3 = (float)(b.x - c.x) / (float)(b.y - c.y);
		float b2 = (float)a.x - m2 * (float)a.y;
		float b3 = (float)b.x - m3 * (float)b.y;
		drawFlatDreieckAlpha(b.y, c.y, m2, b2, m3, b3, farbe);
	}
	else if (b.y == c.y)
	{
		if (c.x < b.x)
			b.Swap(c);
		const float m1 = (float)(a.x - b.x) / (float)(a.y - b.y);
		const float m2 = (float)(a.x - c.x) / (float)(a.y - c.y);
		float b1 = (float)a.x - m1 * (float)a.y;
		float b2 = (float)a.x - m2 * (float)a.y;
		drawFlatDreieckAlpha(a.y, b.y, m1, b1, m2, b2, farbe);
	}
	else
	{
		const float m1 = (float)(a.x - b.x) / (float)(a.y - b.y);
		const float m2 = (float)(a.x - c.x) / (float)(a.y - c.y);
		const float m3 = (float)(b.x - c.x) / (float)(b.y - c.y);
		float b1 = (float)a.x - m1 * (float)a.y;
		float b2 = (float)a.x - m2 * (float)a.y;
		float b3 = (float)b.x - m3 * (float)b.y;
		const float qx = m2 * (float)b.y + b2;
		if (qx < (float)b.x)
		{
			drawFlatDreieckAlpha(a.y, b.y, m2, b2, m1, b1, farbe);
			drawFlatDreieckAlpha(b.y, c.y, m2, b2, m3, b3, farbe);
		}
		else
		{
			drawFlatDreieckAlpha(a.y, b.y, m1, b1, m2, b2, farbe);
			drawFlatDreieckAlpha(b.y, c.y, m3, b3, m2, b2, farbe);
		}
	}
	rend = 1;
}

void Bild::drawDreieckTexturAlpha(Punkt a, Punkt b, Punkt c, Punkt ta, Punkt tb, Punkt tc, Bild& textur) // füllt eine Dreieck aus
{
	if (alpha[alphaAnzahl] == 0xFF)
		return;
	int dpx = dPosA[doa].x;
	int dpy = dPosA[doa].y;
	int dgx = dSizeA[doa].x;
	int dgy = dSizeA[doa].y;
	a += drawOff[doa];
	b += drawOff[doa];
	c += drawOff[doa];
	if ((a.x < dpx && b.x < dpx && c.x < dpx) || (a.y < dpy && b.y < dpy && c.y < dpy) ||
		(a.x > dgx && b.x > dgx && c.x > dgx) || (a.y > dgy && b.y > dgy && c.y > dgy))
		return;
	if (b.y < a.y)
	{
		a.Swap(b);
		ta.Swap(tb);
	}
	if (c.y < b.y)
	{
		b.Swap(c);
		tb.Swap(tc);
	}
	if (b.y < a.y)
	{
		a.Swap(b);
		ta.Swap(tb);
	}
	const double m1 = (double)(a.x - b.x) / (a.y - b.y);
	const double m2 = (double)(a.x - c.x) / (a.y - c.y);
	const double m3 = (double)(b.x - c.x) / (b.y - c.y);
	double b1 = a.x - m1 * a.y;
	double b2 = a.x - m2 * a.y;
	double b3 = b.x - m3 * b.y;
	const double qx = m2 * b.y + b2;
	if (qx < b.x)
	{
		double tx1o, ty1o, tx2o, ty2o;
		if (c.y - a.y)
		{
			tx1o = (double)(tc.x - ta.x) / (c.y - a.y);
			ty1o = (double)(tc.y - ta.y) / (c.y - a.y);
		}
		else
		{
			tx1o = 0;
			ty1o = 0;
		}
		if (b.y - a.y)
		{
			tx2o = (double)(tb.x - ta.x) / (b.y - a.y);
			ty2o = (double)(tb.y - ta.y) / (b.y - a.y);
		}
		else
		{
			tx2o = 0;
			ty2o = 0;
		}
		Vec2< double > q(ta.x + tx1o * (b.y - a.y), ta.y + ty1o * (b.y - a.y));
		double txf, tyf;
		if (b.x - qx)
		{
			txf = (tb.x - q.x) / (b.x - qx);
			tyf = (tb.y - q.y) / (b.x - qx);
		}
		else
		{
			txf = 0;
			tyf = 0;
		}
		drawFlatDreieckTexturAlpha(a.y, b.y, m2, b2, m1, b1, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur);
		if (c.y - b.y)
		{
			tx2o = (double)(tc.x - tb.x) / (c.y - b.y);
			ty2o = (double)(tc.y - tb.y) / (c.y - b.y);
		}
		else
		{
			tx2o = 0;
			ty2o = 0;
		}
		drawFlatDreieckTexturAlpha(b.y, c.y, m2, b2, m3, b3, q.x, q.y, tb.x, tb.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur);
	}
	else
	{
		double tx1o, ty1o, tx2o, ty2o;
		if (b.y - a.y)
		{
			tx1o = (double)(tb.x - ta.x) / (b.y - a.y);
			ty1o = (double)(tb.y - ta.y) / (b.y - a.y);
		}
		else
		{
			tx1o = 0;
			ty1o = 0;
		}
		if (c.y - a.y)
		{
			tx2o = (double)(tc.x - ta.x) / (c.y - a.y);
			ty2o = (double)(tc.y - ta.y) / (c.y - a.y);
		}
		else
		{
			tx2o = 0;
			ty2o = 0;
		}
		Vec2< double > q(ta.x + tx2o * (b.y - a.y), ta.y + ty2o * (b.y - a.y));
		double txf, tyf;
		if (qx - b.x)
		{
			txf = (q.x - tb.x) / (qx - b.x);
			tyf = (q.y - tb.y) / (qx - b.x);
		}
		else
		{
			txf = 0;
			tyf = 0;
		}
		drawFlatDreieckTexturAlpha(a.y, b.y, m1, b1, m2, b2, ta.x, ta.y, ta.x, ta.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur);
		if (c.y - b.y)
		{
			tx1o = (double)(tc.x - tb.x) / (c.y - b.y);
			ty1o = (double)(tc.y - tb.y) / (c.y - b.y);
		}
		else
		{
			tx1o = 0;
			ty1o = 0;
		}
		drawFlatDreieckTexturAlpha(b.y, c.y, m3, b3, m2, b2, tb.x, tb.y, q.x, q.y, tx1o, ty1o, tx2o, ty2o, txf, tyf, textur);
	}
	rend = 1;
}

void Bild::replaceColorWithAlpha(int color)
{
	int r = (color & 0xFF0000) >> 16;
	int g = (color & 0xFF00) >> 8;
	int b = color & 0xFF;
	int dx = drawOff[doa].x, dy = drawOff[doa].y;
	int xx = dPosA[doa].x, yy = dPosA[doa].y;
	int bb = dSizeA[doa].x, hh = dSizeA[doa].y;
	for (int y = dy + yy; y < hh; y++)
	{
		int ygr = y * size.x;
		for (int x = dx + xx; x < bb; x++)
		{
			unsigned char* cf = (unsigned char*)&(fc[x + ygr]);
			int abstand = (int)sqrt((float)((r - cf[2]) * (r - cf[2]) + (g - cf[1]) * (g - cf[1]) + (b - cf[0]) * (b - cf[0])));
			if (abstand > 255)
				abstand = 255;
			cf[3] = (unsigned char)(abstand);
		}
	}
}

bool Bild::setDrawOptions(const Punkt& pos, const Punkt& gr) // setzt die Drawoptionen
{
	int dx = drawOff[doa].x, dy = drawOff[doa].y;
	int xx = dPosA[doa].x, yy = dPosA[doa].y;
	int bb = dSizeA[doa].x, hh = dSizeA[doa].y;
	if (dx + pos.x + gr.x < 0 || dy + pos.y + gr.y < 0 || dx + pos.x >= size.x || dy + pos.y >= size.y)
		return 0;
	if (pos.x + gr.x + dx < xx || pos.y + gr.y + dy < yy || dx + pos.x >= bb || dy + pos.y >= hh)
		return 0;
	++doa;
	assert(doa < 2000);
	dPosA[doa].x = maxInt(pos.x + dx, xx);
	dPosA[doa].y = maxInt(pos.y + dy, yy);
	dSizeA[doa].x = minInt(pos.x + gr.x + dx, bb);
	dSizeA[doa].y = minInt(pos.y + gr.y + dy, hh);
	drawOff[doa].x = dx + pos.x;
	drawOff[doa].y = dy + pos.y;
	return 1;
}

bool Bild::setDrawOptions(int x, int y, int br, int hi)
{
	int dx = drawOff[doa].x, dy = drawOff[doa].y;
	int xx = dPosA[doa].x, yy = dPosA[doa].y;
	int bb = dSizeA[doa].x, hh = dSizeA[doa].y;
	if (dx + x + br < 0 || dy + y + hi < 0 || dx + x >= size.x || dy + y >= size.y)
		return 0;
	if (x + br + dx < xx || y + hi + dy < yy || dx + x >= bb || dy + y >= hh)
		return 0;
	++doa;
	assert(doa < 2000);
	dPosA[doa].x = maxInt(x + dx, xx);
	dPosA[doa].y = maxInt(y + dy, yy);
	dSizeA[doa].x = minInt(x + br + dx, bb);
	dSizeA[doa].y = minInt(y + hi + dy, hh);
	drawOff[doa].x = dx + x;
	drawOff[doa].y = dy + y;
	return 1;
}

bool Bild::setDrawOptionsErzwingen(const Punkt& pos, const Punkt& gr) // setzt die Drawoptionen
{
	int dx = drawOff[doa].x, dy = drawOff[doa].y;
	if (dx + pos.x + gr.x < 0 || dy + pos.y + gr.y < 0 || dx + pos.x >= size.x || dy + pos.y >= size.y)
		return 0;
	++doa;
	assert(doa < 2000);
	dPosA[doa].x = maxInt(pos.x + dx, 0);
	dPosA[doa].y = maxInt(pos.y + dy, 0);
	dSizeA[doa].x = minInt(pos.x + gr.x + dx, size.x);
	dSizeA[doa].y = minInt(pos.y + gr.y + dy, size.y);
	drawOff[doa].x = dx + pos.x;
	drawOff[doa].y = dy + pos.y;
	return 1;
}

bool Bild::setDrawOptionsErzwingen(int x, int y, int br, int hi) // setzt die Drawoptionen
{
	int dx = drawOff[doa].x, dy = drawOff[doa].y;
	if (dx + x + br < 0 || dy + y + hi < 0 || dx + x >= size.x || dy + y >= size.y)
		return 0;
	++doa;
	assert(doa < 2000);
	dPosA[doa].x = maxInt(x + dx, 0);
	dPosA[doa].y = maxInt(y + dy, 0);
	dSizeA[doa].x = minInt(x + br + dx, size.x);
	dSizeA[doa].y = minInt(y + hi + dy, size.y);
	drawOff[doa].x = dx + x;
	drawOff[doa].y = dy + y;
	return 1;
}

void Bild::setDrawOptionsReset()
{
	++doa;
	dPosA[doa].x = 0;
	dPosA[doa].y = 0;
	dSizeA[doa].x = size.x;
	dSizeA[doa].y = size.y;
	drawOff[doa].x = 0;
	drawOff[doa].y = 0;
}

void Bild::addScrollOffset(int xOff, int yOff) // setzt ScrollOffset
{
	drawOff[doa].x -= xOff;
	drawOff[doa].y -= yOff;
}

void Bild::releaseDrawOptions() // setzt die Drawoptionen zurück
{
	--doa;
}

bool Bild::getRend()
{
	bool ret = rend;
	rend = 0;
	return ret;
}

// constant 
int* Bild::getBuffer()const // gibt buffer zurück
{
	return fc;
}

int Bild::getPixel(int x, int y) const
{
	if (x < 0 || y < 0 || x >= size.x || y >= size.y)
		return 0;
	return fc[x + y * size.x];
}

const Punkt& Bild::getSize() const // gibt die Größe zurück
{
	return size;
}

int Bild::getBreite() const // gibt die Breite zurück
{
	return size.x;
}

int Bild::getHeight() const // gibt die Höhe zurück
{
	return size.y;
}

unsigned char Bild::getAlpha() const // gibt den Alpha wert zurück
{
	return (unsigned char)(255 - alpha[alphaAnzahl]);
}

const Punkt& Bild::getDrawPos() const
{
	return dPosA[doa];
}

const Punkt& Bild::getDrawGr() const
{
	return dSizeA[doa];
}

const Punkt& Bild::getDrawOff() const
{
	return drawOff[doa];
}

bool Bild::hasAlpha3D()
{
	return alpha3D;
}


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