|
@@ -98,6 +98,8 @@ 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))
|
|
@@ -105,7 +107,8 @@ inline void Bild::alphaPixelP3D(int& fc, int colorb)
|
|
|
| ((((na * (fc & 0x00FF00)) >> 8)
|
|
|
+ ((alpha * (colorb & 0x00FF00)) >> 8))
|
|
|
& 0x00FF00)
|
|
|
- | ((fc & 0xFF000000)))
|
|
|
+ | ((colorb & 0xFF000000) * newAlpha)
|
|
|
+ | ((fc & 0xFF000000) * !newAlpha))
|
|
|
* (fc != 0)
|
|
|
| (fc == 0) * colorb;
|
|
|
// unsigned char *fc1 = (unsigned char*)&fc;
|
|
@@ -124,13 +127,13 @@ inline void Bild::alphaPixelP(int& fc, int colorb)
|
|
|
// return;
|
|
|
int alpha = ((colorb >> 24) & 0xFF);
|
|
|
int na = (0x100 - alpha);
|
|
|
- fc = (((((na * (fc & 0xFF00FF)) >> 8)
|
|
|
+ fc = ((((na * (fc & 0xFF00FF)) >> 8)
|
|
|
+ ((alpha * (colorb & 0xFF00FF)) >> 8))
|
|
|
& 0xFF00FF)
|
|
|
| ((((na * (fc & 0x00FF00)) >> 8)
|
|
|
+ ((alpha * (colorb & 0x00FF00)) >> 8))
|
|
|
& 0x00FF00)
|
|
|
- | ((fc & 0xFF000000)));
|
|
|
+ | ((fc & 0xFF000000));
|
|
|
// unsigned char *fc1 = (unsigned char*)&fc;
|
|
|
// unsigned char *fc2 = (unsigned char*)&colorb;
|
|
|
// unsigned char na = 255-fc2[ 3 ];
|
|
@@ -556,22 +559,13 @@ void Bild::alphaRegion(int x, int y, int b, int h, int ff)
|
|
|
}
|
|
|
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;
|
|
|
+ alphaPixelP3D(*pixel, ff);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
@@ -581,10 +575,7 @@ void Bild::alphaRegion(int x, int y, int b, int h, int ff)
|
|
|
{
|
|
|
for (; pixel < rowEnd; ++pixel)
|
|
|
{
|
|
|
- *pixel
|
|
|
- = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
|
|
|
- | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
|
|
|
- | ((*pixel & 0xFF000000)));
|
|
|
+ alphaPixelP(*pixel, ff);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
@@ -835,17 +826,19 @@ void Bild::drawLinieHAlpha(
|
|
|
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)
|
|
|
+ if (alpha3D)
|
|
|
+ {
|
|
|
+ for (int i = x + y * br; end < len; ++end, i += pval)
|
|
|
+ {
|
|
|
+ alphaPixelP3D(fc[i], f);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
{
|
|
|
- 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;
|
|
|
+ for (int i = x + y * br; end < len; ++end, i += pval)
|
|
|
+ {
|
|
|
+ alphaPixelP(fc[i], f);
|
|
|
+ }
|
|
|
}
|
|
|
rend = 1;
|
|
|
}
|
|
@@ -882,17 +875,19 @@ void Bild::drawLinieVAlpha(
|
|
|
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)
|
|
|
+ if (alpha3D)
|
|
|
+ {
|
|
|
+ for (int i = x + y * br; end < len; ++end, i += pval)
|
|
|
+ {
|
|
|
+ alphaPixelP3D(fc[i], f);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
{
|
|
|
- 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;
|
|
|
+ for (int i = x + y * br; end < len; ++end, i += pval)
|
|
|
+ {
|
|
|
+ alphaPixelP(fc[i], f);
|
|
|
+ }
|
|
|
}
|
|
|
rend = 1;
|
|
|
}
|
|
@@ -1079,74 +1074,91 @@ void Bild::drawLinieBorderedAlpha(Punkt a, Punkt b, int bc, int fc)
|
|
|
* (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)
|
|
|
+ if (alpha3D)
|
|
|
{
|
|
|
- ++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;
|
|
|
+ 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;
|
|
|
}
|
|
|
- x += xf, y += yf;
|
|
|
}
|
|
|
- count = 0;
|
|
|
- while (
|
|
|
- !((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
|
|
|
+ else
|
|
|
{
|
|
|
- ++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;
|
|
|
+ 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;
|
|
|
}
|
|
@@ -1325,24 +1337,32 @@ void Bild::drawLinieAlpha(Punkt a, Punkt b, int fc)
|
|
|
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)
|
|
|
+ if (alpha3D)
|
|
|
{
|
|
|
- ++count;
|
|
|
+ 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];
|
|
|
- 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;
|
|
|
+ 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);
|
|
|
}
|
|
|
- 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;
|
|
|
}
|
|
|
}
|
|
@@ -1424,93 +1444,116 @@ void Bild::drawKreisAlpha(int xOff, int yOff, int r, int 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)
|
|
|
+ if (alpha3D)
|
|
|
{
|
|
|
- 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)
|
|
|
+ for (int a = 0; a < r; ++a)
|
|
|
{
|
|
|
- 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;
|
|
|
+ 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);
|
|
|
+ }
|
|
|
}
|
|
|
- if (xOff - b < dgx && xOff - b > dpx && yOff - a < dgy
|
|
|
- && yOff - a > dpy)
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ for (int a = 0; a < r; ++a)
|
|
|
{
|
|
|
- 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;
|
|
|
+ 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;
|
|
@@ -1667,7 +1710,7 @@ void Bild::alphaBild(int x, int y, int br, int hi, const Bild& zBild)
|
|
|
unsigned char* cf = (unsigned char*)&fc;
|
|
|
cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl])
|
|
|
* (cf[3] - alpha[alphaAnzahl]));
|
|
|
- alphaPixelP(this->fc[xx + ygr], fc);
|
|
|
+ alphaPixelP3D(this->fc[xx + ygr], fc);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
@@ -1683,7 +1726,7 @@ void Bild::alphaBild(int x, int y, int br, int hi, const Bild& zBild)
|
|
|
unsigned char* cf = (unsigned char*)&fc;
|
|
|
cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl])
|
|
|
* (cf[3] - alpha[alphaAnzahl]));
|
|
|
- alphaPixelP3D(this->fc[xx + ygr], fc);
|
|
|
+ alphaPixelP(this->fc[xx + ygr], fc);
|
|
|
}
|
|
|
}
|
|
|
}
|