Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-08 03:28:20 +02:00
Code Activity
Beef/BeefySysLib/img/ImageUtils.cpp
Brian Fiete 078564ac9e Initial checkin
2019-08-23 11:56:54 -07:00

1118 lines
35 KiB
C++
Raw Permalink Blame History

#include "ImageUtils.h"
#include "ImageData.h"
#include "Common.h"
#include "util/PerfTimer.h"
USING_NS_BF;
const int DISSOLVE_SIZE = 6679;
static uint8 gDissolveTable[DISSOLVE_SIZE];
static bool gDissolveInitialized = false;
static int gDissolveIdx = 0;
static int gSqrtTable[256];
struct WideColor
{
int r;
int g;
int b;
int a;
};
static inline float clamp(float val, float min, float max)
{
return (val <= min) ? min : (val >= max) ? max : val;
}
static inline int clamp(int val, int min, int max)
{
return (val <= min) ? min : (val >= max) ? max : val;
}
#define Blend_Apply(Blend_Channel) \
aBlendedColor.r = Blend_Channel((int) aDestColor->r, (int) aSrcColor->r); \
aBlendedColor.g = Blend_Channel((int) aDestColor->g, (int) aSrcColor->g); \
aBlendedColor.b = Blend_Channel((int) aDestColor->b, (int) aSrcColor->b);
inline PackedColor SetSat(PackedColor color, int satVal)
{
#define SetSatComponents(minComp, midComp, maxComp) \
{ \
midComp -= minComp; \
maxComp -= minComp; \
minComp = 0; \
if (maxComp > 0) \
{ \
midComp = midComp*satVal/maxComp; \
maxComp = satVal; \
} \
}
if (color.r <= color.g)
{
if (color.g <= color.b)
SetSatComponents(color.r, color.g, color.b)
else if (color.r < color.b)
SetSatComponents(color.r, color.b, color.g)
else
SetSatComponents(color.b, color.r, color.g);
}
else
{
if (color.r <= color.b)
SetSatComponents(color.g, color.r, color.b)
else if (color.g < color.b)
SetSatComponents(color.g, color.b, color.r)
else
SetSatComponents(color.b, color.g, color.r);
}
return color;
}
#define max3( x, y, z ) ( std::max((x), std::max((y), (z))) )
#define min3( x, y, z ) ( std::min((x), std::min((y), (z))) )
#define Sat(C) ( (max3(((C).r), ((C).g), ((C).b)) - min3(((C).r), ((C).g), ((C).b))) )
#define Lum(C) ( ((((C).r) * 300) + (((C).g) * 586) + (((C).b) * 113)) / 1000 )
inline PackedColor SetLum(PackedColor color, int lum)
{
//int lum_cl = luminance(color);
int d = lum - Lum(color);
WideColor color_cl = {color.r + d, color.g + d, color.b + d, color.a};
int aLum = Lum(color_cl);
int mini = min3(color_cl.r, color_cl.g, color_cl.b);
int maxi = max3(color_cl.r, color_cl.g, color_cl.b);
if (mini < 0)
{
color.r = (int) aLum + (color_cl.r - aLum)*aLum/std::max(aLum - mini, 1);
color.g = (int) aLum + (color_cl.g - aLum)*aLum/std::max(aLum - mini, 1);
color.b = (int) aLum + (color_cl.b - aLum)*aLum/std::max(aLum - mini, 1);
}
else if (maxi > 255)
{
color.r = aLum + (color_cl.r - aLum)*(255 - aLum)/std::max(maxi - aLum, 1);
color.g = aLum + (color_cl.g - aLum)*(255 - aLum)/std::max(maxi - aLum, 1);
color.b = aLum + (color_cl.b - aLum)*(255 - aLum)/std::max(maxi - aLum, 1);
}
else
{
color.r = color_cl.r;
color.g = color_cl.g;
color.b = color_cl.b;
}
return color;
}
inline int ClampedOffset(int cur, int to, int maxDelta)
{
int delta = abs(to - cur);
if (abs(delta) < maxDelta)
return to;
if (cur < to)
return cur + maxDelta;
return cur - maxDelta;
}
ImageData* Beefy::CreateResizedImageUnion(ImageData* src, int x, int y, int width, int height)
{
int minX = std::min(src->mX, x);
int minY = std::min(src->mY, y);
int maxX = std::max(src->mX + src->mWidth, x + width);
int maxY = std::max(src->mY + src->mHeight, y + height);
/*if ((src->mX == minX) && (src->mY == minY) && (src->mWidth == maxX - minX) && (src->mHeight == maxY - minY))
return src;*/
ImageData* imageData = new ImageData();
imageData->CreateNew(maxX - minX, maxY - minY);
imageData->mX = minX;
imageData->mY = minY;
for (int y = src->mY; y < src->mY + src->mHeight; y++)
{
for (int x = src->mX; x < src->mX + src->mWidth; x++)
{
PackedColor* aDest = (PackedColor*) &imageData->mBits[(x - imageData->mX) + (y - imageData->mY)*imageData->mWidth];
PackedColor* aSrc = (PackedColor*) &src->mBits[(x - src->mX) + (y - src->mY)*src->mWidth];
*aDest = *aSrc;
}
}
return imageData;
}
ImageData* Beefy::CreateEmptyResizedImageUnion(ImageData* src, int x, int y, int width, int height)
{
ImageData* imageData = new ImageData();
if (src == NULL)
{
imageData->CreateNew(x, y, width, height);
return imageData;
}
int minX = std::min(src->mX, x);
int minY = std::min(src->mY, y);
int maxX = std::max(src->mX + src->mWidth, x + width);
int maxY = std::max(src->mY + src->mHeight, y + height);
imageData->CreateNew(maxX - minX, maxY - minY);
imageData->mX = minX;
imageData->mY = minY;
return imageData;
}
void Beefy::CrossfadeImage(ImageData* origImage, ImageData* newImage, float opacity)
{
AutoPerf gPerf("Beefy::CrossfadeImage");
int a = (int) (opacity * 255 + 0.5f);
int oma = 255 - a;
if (a == 255) // No crossfade needed
return;
if (origImage == NULL)
{
for (int y = newImage->mY; y < newImage->mY + newImage->mHeight; y++)
{
for (int x = newImage->mX; x < newImage->mX + newImage->mWidth; x++)
{
PackedColor* aDest = (PackedColor*) &newImage->mBits[(x - newImage->mX) + (y - newImage->mY)*newImage->mWidth];
aDest->a = (aDest->a * a) / 255;
aDest++;
}
}
}
else
{
for (int x = newImage->mX; x < newImage->mX + newImage->mWidth; x++)
{
// Top
for (int y = newImage->mY; y < origImage->mY; y++)
{
PackedColor* aDest = (PackedColor*) &newImage->mBits[(x - newImage->mX) + (y - newImage->mY)*newImage->mWidth];
aDest->a = (aDest->a * a) / 255;
aDest++;
}
// Bottom
for (int y = origImage->mY + origImage->mHeight; y < newImage->mY + newImage->mHeight; y++)
{
PackedColor* aDest = (PackedColor*) &newImage->mBits[(x - newImage->mX) + (y - newImage->mY)*newImage->mWidth];
aDest->a = (aDest->a * a) / 255;
aDest++;
}
}
// Crash seems to be here:
for (int y = origImage->mY; y < origImage->mY + origImage->mHeight; y++)
{
// Left
for (int x = newImage->mX; x < origImage->mX; x++)
{
PackedColor* aDest = (PackedColor*) &newImage->mBits[(x - newImage->mX) + (y - newImage->mY)*newImage->mWidth];
aDest->a = (aDest->a * a) / 255;
aDest++;
}
// Right
for (int x = origImage->mX + origImage->mWidth; x < newImage->mX + newImage->mWidth; x++)
{
PackedColor* aDest = (PackedColor*) &newImage->mBits[(x - newImage->mX) + (y - newImage->mY)*newImage->mWidth];
aDest->a = (aDest->a * a) / 255;
aDest++;
}
}
for (int y = origImage->mY; y < origImage->mY + origImage->mHeight; y++)
{
for (int x = origImage->mX; x < origImage->mX + origImage->mWidth; x++)
{
PackedColor* aDest = (PackedColor*) &newImage->mBits[(x - newImage->mX) + (y - newImage->mY)*newImage->mWidth];
PackedColor* aSrc = (PackedColor*) &origImage->mBits[(x - origImage->mX) + (y - origImage->mY)*origImage->mWidth];
int newDestAlpha = ((aDest->a * a) + (aSrc->a * oma)) / 255;
if (newDestAlpha != 0)
{
int ca = (255 * a * aDest->a) / (aDest->a * a + aSrc->a * oma);
int coma = 255 - ca;
aDest->a = newDestAlpha;
aDest->r = ((aDest->r * ca) + (aSrc->r * coma)) / 255;
aDest->g = ((aDest->g * ca) + (aSrc->g * coma)) / 255;
aDest->b = ((aDest->b * ca) + (aSrc->b * coma)) / 255;
}
aSrc++;
aDest++;
}
}
}
}
// aSrcColor, aDestColor, aBlendAlpha
// doReverseBlend, doFullBlend, doAltBlend, normal blend
class BlendGetColor_Normal
{
public:
PackedColor operator()(PackedColor* srcColor, PackedColor* destColor, int srcAlpha, int blendAlpha)
{
PackedColor aBlendedColor = *srcColor;
aBlendedColor.a = srcAlpha;
return aBlendedColor;
}
};
class BlendMix_Normal
{
public:
void operator()(PackedColor* srcColor, PackedColor* destColor, PackedColor blendedColor, int srcAlpha, int blendAlpha)
{
int newDestAlpha = 255;
int a = blendedColor.a;
if (destColor->a != 255)
newDestAlpha = destColor->a + ((255 - destColor->a) * blendedColor.a) / 255;
if (newDestAlpha != 0)
{
a = 255 * blendedColor.a / newDestAlpha;
int ba = destColor->a;
int boma = 255 - destColor->a;
blendedColor.r = ((blendedColor.r * ba) + (srcColor->r * boma)) / 255;
blendedColor.g = ((blendedColor.g * ba) + (srcColor->g * boma)) / 255;
blendedColor.b = ((blendedColor.b * ba) + (srcColor->b * boma)) / 255;
}
int oma = 255 - a;
destColor->a = newDestAlpha;
destColor->r = ((blendedColor.r * a) + (destColor->r * oma)) / 255;
destColor->g = ((blendedColor.g * a) + (destColor->g * oma)) / 255;
destColor->b = ((blendedColor.b * a) + (destColor->b * oma)) / 255;
}
};
template <class GetColorFunctor, class MixFunctor>
static void BlendImage_Fast_T(ImageData* dest, ImageData* src, int destX, int destY, float alpha, int mixType, bool fullAlpha)
{
AutoPerf gPerf("Beefy::BlendImage");
BF_ASSERT(destX >= 0);
BF_ASSERT(destY >= 0);
BF_ASSERT(destX + src->mWidth <= dest->mWidth);
BF_ASSERT(destY + src->mHeight <= dest->mHeight);
if (!gDissolveInitialized)
{
for (int i = 0; i < DISSOLVE_SIZE; i++)
gDissolveTable[i] = rand() % 1023;
gDissolveInitialized = true;
for (int i = 0; i < 256; i++)
gSqrtTable[i] = (int) (sqrt(i / 255.0f) * 255.0f + 0.5f);
}
int aBlendAlpha = (int) (255 * alpha);
for (int y = 0; y < src->mHeight; y++)
{
PackedColor* aSrcColor = (PackedColor*) (src->mBits + (y * src->mWidth));
PackedColor* aDestColor = (PackedColor*) (dest->mBits + destX + (y + destY) * dest->mWidth);
for (int x = 0; x < src->mWidth; x++)
{
int aSrcAlpha = (int) (aSrcColor->a * alpha + 0.5f);
if (fullAlpha)
aSrcAlpha = (int) (alpha * 255 + 0.5f);
PackedColor aBlendedColor = GetColorFunctor()(aSrcColor, aDestColor, aSrcAlpha, aBlendAlpha);
MixFunctor()(aSrcColor, aDestColor, aBlendedColor, aSrcAlpha, aBlendAlpha);
aDestColor++;
aSrcColor++;
}
}
}
static void BlendImage_Fast(ImageData* dest, ImageData* src, int destX, int destY, float alpha, int mixType, bool fullAlpha)
{
BlendImage_Fast_T<BlendGetColor_Normal, BlendMix_Normal>(dest, src, destX, destY, alpha, mixType, fullAlpha);
}
void Beefy::BlendImage(ImageData* dest, ImageData* src, int destX, int destY, float alpha, int mixType, bool fullAlpha)
{
/*BlendImage_Fast(dest, src, destX, destY, alpha, mixType, fullAlpha);
return;*/
AutoPerf gPerf("Beefy::BlendImage");
BF_ASSERT(destX >= 0);
BF_ASSERT(destY >= 0);
BF_ASSERT(destX + src->mWidth <= dest->mWidth);
BF_ASSERT(destY + src->mHeight <= dest->mHeight);
if (!gDissolveInitialized)
{
for (int i = 0; i < DISSOLVE_SIZE; i++)
gDissolveTable[i] = rand() % 1023;
gDissolveInitialized = true;
for (int i = 0; i < 256; i++)
gSqrtTable[i] = (int) (sqrt(i / 255.0f) * 255.0f + 0.5f);
}
int aBlendAlpha = (int) (255 * alpha);
for (int y = 0; y < src->mHeight; y++)
{
PackedColor* aSrcColor = (PackedColor*) (src->mBits + (y * src->mWidth));
PackedColor* aDestColor = (PackedColor*) (dest->mBits + destX + (y + destY) * dest->mWidth);
for (int x = 0; x < src->mWidth; x++)
{
int aSrcAlpha = (int) (aSrcColor->a * alpha + 0.5f);
if (fullAlpha)
aSrcAlpha = (int) (alpha * 255 + 0.5f);
PackedColor aBlendedColor = *aSrcColor;
aBlendedColor.a = aSrcAlpha;
bool doReverseBlend = false;
bool doAltBlend = false;
bool doFullBlend = false;
if ((mixType == 'Nrml') || (mixType == 'norm')) // Normal
{
}
else if ((mixType == 'Lghn') || (mixType == 'lite')) // Lighten
{
aBlendedColor.r = std::max((int) aSrcColor->r, (int) aDestColor->r);
aBlendedColor.g = std::max((int) aSrcColor->g, (int) aDestColor->g);
aBlendedColor.b = std::max((int) aSrcColor->b, (int) aDestColor->b);
}
else if ((mixType == 'Drkn') || (mixType == 'dark')) // Darken
{
aBlendedColor.r = std::min((int) aSrcColor->r, (int) aDestColor->r);
aBlendedColor.g = std::min((int) aSrcColor->g, (int) aDestColor->g);
aBlendedColor.b = std::min((int) aSrcColor->b, (int) aDestColor->b);
}
else if (mixType == 'blen')
{
aBlendedColor.r = std::max(0, (int) aDestColor->r - (int) aSrcColor->r);
aBlendedColor.g = std::max(0, (int) aDestColor->g - (int) aSrcColor->g);
aBlendedColor.b = std::max(0, (int) aDestColor->b - (int) aSrcColor->b);
}
else if ((mixType == 'Dslv') || (mixType == 'diss')) // Disolve
{
if ((dest->mX + x == 132) && (dest->mY + y == 19))
{
/*aBlendedColor.a = 255;
aBlendedColor.r = 0;
aBlendedColor.g = 255;
aBlendedColor.b = 0; */
}
int dissolveIdx = ((dest->mX + x) * 179 + (dest->mY + y) * 997) % DISSOLVE_SIZE;
if ((int) (aSrcColor->a * alpha + 0.5f) < gDissolveTable[dissolveIdx])
aBlendedColor.a = 0;
else
aBlendedColor.a = 255;
}
else if ((mixType == 'Mltp') || (mixType == 'mul ')) // Multiply
{
aBlendedColor.r = (int) aDestColor->r * (int) aSrcColor->r / 255;
aBlendedColor.g = (int) aDestColor->g * (int) aSrcColor->g / 255;
aBlendedColor.b = (int) aDestColor->b * (int) aSrcColor->b / 255;
}
else if ((mixType == 'CBrn') || (mixType == 'idiv')) // Color Burn
{
if (mixType == 'CBrn') // Effect
{
int blendVal = (aBlendAlpha * aSrcColor->a / 255);
#define Blend_ColorBurn_Effect(A,B) \
std::max(0, 255 - (((255 - (int) A) << 8 ) / std::max((((B * blendVal) + (255 * (255 - blendVal))) / 255), 1)))
Blend_Apply(Blend_ColorBurn_Effect);
//doFullBlend = true;
}
else // Layer
{
#define Blend_ColorBurn(A,B) \
std::max(0, 255 - (((255 - (int) A) << 8 ) / std::max((((B * aBlendAlpha) + (255 * (255 - aBlendAlpha))) / 255), 1)))
Blend_Apply(Blend_ColorBurn);
doFullBlend = true;
}
}
else if ((mixType == 'lnDg') || (mixType == 'lddg')) // Linear Dodge
{
// Uses alternate blend methdod
}
else if (mixType == 'lbrn') // Linear Burn (Layer)
{
/*int newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * aBlendedColor.a) / 255;
#define Blend_LinearDodge_Layer(A,B) \
255 - std::min(255, (255 - A) + (255 - B))
Blend_Apply(Blend_LinearDodge_Layer); */
}
else if (mixType == 'lnBn')
{
// Uses alternate blend methdod
}
else if (mixType == 'dkCl') // Darker Color
{
// 299, 587, 144 is "correct"
int intensityDest = (aDestColor->r * 300) + (aDestColor->g * 586) + (aDestColor->b * 113);
int intensitySrc = (aSrcColor->r * 300) + (aSrcColor->g * 586) + (aSrcColor->b * 113);
if (intensityDest <= intensitySrc)
doReverseBlend = true;
}
else if ((mixType == 'ltCl') || (mixType == 'lgCl')) // Lighter Color
{
if ((dest->mX + x == 125) && (dest->mY + y == 299))
{
/*aDestColor->a = 255;
aDestColor->r = 0;
aDestColor->g = 255;
aDestColor->b = 0; */
}
// 299, 587, 144 is "correct"
int intensityDest = (aDestColor->r * 300) + (aDestColor->g * 586) + (aDestColor->b * 113);
int intensitySrc = (aSrcColor->r * 300) + (aSrcColor->g * 586) + (aSrcColor->b * 113);
if (intensityDest >= intensitySrc)
doReverseBlend = true;
}
else if ((mixType == 'Scrn') || (mixType == 'scrn')) // Screen
{
aBlendedColor.r = 255 - ((255 - aDestColor->r) * (255 - aSrcColor->r) / 255);
aBlendedColor.g = 255 - ((255 - aDestColor->g) * (255 - aSrcColor->g) / 255);
aBlendedColor.b = 255 - ((255 - aDestColor->b) * (255 - aSrcColor->b) / 255);
}
else if ((mixType == 'CDdg') || (mixType == 'div ')) // Color Dodge
{
if (mixType == 'CDdg') // Effect
{
int blendVal = (aBlendAlpha * aSrcColor->a / 255);
#define Blend_ColorDodge_Effect(A,B) \
std::min(255, ((((int) A) << 8 ) / std::max((((255 - B) * blendVal) + (255 * (255 - blendVal))) / 255, 1)))
Blend_Apply(Blend_ColorDodge_Effect);
doFullBlend = true;
}
else
{
#define Blend_ColorDodge_Layer(A,B) \
std::min(255, ((((int) A) << 8 ) / std::max((((255 - B) * aBlendAlpha) + (255 * (255 - aBlendAlpha))) / 255, 1)))
Blend_Apply(Blend_ColorDodge_Layer);
doFullBlend = true;
}
}
else if ((mixType == 'Ovrl') || (mixType == 'over')) // Overlay
{
#define ChannelBlend_Overlay(A,B) \
(A < 128) ? \
(2 * A * B / 255) : \
(255 - (2 * (255 - A) * (255 - B) / 255))
Blend_Apply(ChannelBlend_Overlay);
}
else if ((mixType == 'SftL') || (mixType == 'sLit')) // Soft Light
{
#define ChannelBlend_SoftLight(A,B) \
(B < 128) ? (A - (255 - clamp(2 * B, 0, 255))*A*(255 - A)/255/255) : \
(A < 64) ? A + ((2*B - 255) * ((((16*A - 12*255)*A/255 + 4*255) * A / 255) - A) / 255) : \
A + ((2*B - 255) * (gSqrtTable[A] - A) / 255)
Blend_Apply(ChannelBlend_SoftLight);
}
else if ((mixType == 'HrdL') || (mixType == 'hLit')) // Hard Light
{
#define Blend_HardLight(A,B) \
(B < 128) ? \
(2 * B * A / 255) : \
(255 - (2 * (255 - B) * (255 - A) / 255))
Blend_Apply(Blend_HardLight);
}
else if ((mixType == 'vivL') || (mixType == 'vLit')) // Vivid Light
{
if ((dest->mX + x == 149) && (dest->mY + y == 218))
{
/*aDestColor->a = 255;
aDestColor->r = 0;
aDestColor->g = 255;
aDestColor->b = 0;*/
}
if (mixType == 'vivL') // Effect
{
int blendVal = (aBlendAlpha * aSrcColor->a / 255);
#define Blend_VividLight_Effect(A,B) \
(B < 128) ? \
std::max(0, 255 - (((255 - (int) A) << 8 ) / \
std::max((((2 * B * blendVal) + (255 * (255 - blendVal))) / 255), 1))) : \
std::min(255, ((((int) A) << 8 ) / \
std::max((((255 - B) * 2 * blendVal) + (255 * (255 - blendVal))) / 255, 1)))
Blend_Apply(Blend_VividLight_Effect);
doFullBlend = true;
}
else // Layer
{
#define Blend_VividLight_Layer(A,B) \
(B < 128) ? \
std::max(0, 255 - (((255 - (int) A) << 8 ) / \
std::max(((2 * B * aBlendAlpha) + (255 * (255 - aBlendAlpha))) / 255, 1))) : \
std::min(255, ((((int) A) << 8 ) / \
std::max((((255 - B) * 2 * aBlendAlpha) + (255 * (255 - aBlendAlpha))) / 255, 1)))
Blend_Apply(Blend_VividLight_Layer);
//doAltBlend = (mixType == 'vivL');
//doFullBlend = !doAltBlend;
doFullBlend = true;
}
}
else if (mixType == 'lLit') // Linear Light (Layer)
{
// Alternate blend mode
/*#define Blend_LinearLight_Layer(A,B) \
(B < 128) ? \
(255 - std::min(255, (255 - A) + (255 - B*2))) : \
std::min(255, A + (B - 128) * 2)
Blend_Apply(Blend_LinearLight_Layer); */
}
else if (mixType == 'linL') // Linear Light (Effect)
{
int newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * aBlendedColor.a) / 255;
if (newDestAlpha > 0)
{
#define Blend_LinearLight(A,B) \
(B < 128) ? \
(255 - std::min(255, \
(((255 - B*2) * aSrcAlpha) + ((255 - A) * aDestColor->a)) / newDestAlpha)) : \
std::min(255, (((B - 128)*2 * aSrcAlpha) + (A * aDestColor->a)) / newDestAlpha)
Blend_Apply(Blend_LinearLight);
}
doFullBlend = true;
}
else if ((mixType == 'pinL') || (mixType == 'pLit')) // Pin Light
{
#define ChannelBlend_PinLight(A,B) \
(B < 128) ? \
std::min((int) A, (int) B * 2) : \
std::max((int) A, (int) (B - 128) * 2)
aBlendedColor.r = ChannelBlend_PinLight((int) aDestColor->r, (int) aSrcColor->r);
aBlendedColor.g = ChannelBlend_PinLight((int) aDestColor->g, (int) aSrcColor->g);
aBlendedColor.b = ChannelBlend_PinLight((int) aDestColor->b, (int) aSrcColor->b);
}
else if ((mixType == 'hdMx') || (mixType == 'hMix')) // Hard Mix
{
if (mixType == 'hdMx') // Effect
{
int scale = 255 * 255 / std::max(255 - (aBlendAlpha * aSrcColor->a)/255, 1);
#define Blend_Scale(A,S) \
(((A) - 128)*S/255+128)
#define Blend_HardMix(A,B) \
clamp(Blend_Scale(A,scale) - Blend_Scale(255 - B,scale) + (255 - B), 0, 255)
Blend_Apply(Blend_HardMix);
doFullBlend = true;
}
else // Layer
{
int scale = 255 * 255 / std::max(255 - aBlendAlpha, 1);
#define Blend_Scale(A,S) \
(((A) - 128)*S/255+128)
#define Blend_HardMix_Layer(A,B) \
clamp(Blend_Scale(A,scale) - Blend_Scale(255 - B,scale) + (255 - B), 0, 255)
Blend_Apply(Blend_HardMix_Layer);
doFullBlend = true;
}
}
else if ((mixType == 'Dfrn') || (mixType == 'diff')) // Difference
{
/*#define ChannelBlend_Difference(A,B) \
abs(A - B*aBlendAlpha/255)
Blend_Apply(ChannelBlend_Difference);
doAltBlend = (mixType == 'Dfrn');
doFullBlend = !doAltBlend;*/
#define ChannelBlend_Difference(A,B) \
abs(A - B*aSrcAlpha/255)
Blend_Apply(ChannelBlend_Difference);
//doAltBlend = (mixType == 'Dfrn');
//doFullBlend = !doAltBlend;
//doAltBlend = true;
doFullBlend = true;
}
else if ((mixType == 'Xclu') || (mixType == 'smud')) // Exclusion
{
#define ChannelBlend_Exclusion(A,B) \
(A + B*aBlendAlpha/255 - 2*A*B*aBlendAlpha/255/255)
Blend_Apply(ChannelBlend_Exclusion);
doAltBlend = (mixType == 'Xclu');
doFullBlend = !doAltBlend;
}
else if ((mixType == 'subt') || (mixType == 'fsub')) // Subtract
{
if (mixType == 'fsub')
{
#define ChannelBlend_Subtract(A,B) \
std::max(0, A - B)
Blend_Apply(ChannelBlend_Subtract);
}
else //TODO: Double check the Effect version here...
{
#define ChannelBlend_Subtract_Effect(A,B) \
std::max(0, A - B*aBlendAlpha/255)
Blend_Apply(ChannelBlend_Subtract_Effect);
doAltBlend = (mixType == 'subt');
}
}
else if ((mixType == 'divi') || (mixType == 'fdiv')) // Divide
{
#define ChannelBlend_Divide(A,B) \
std::min(255, A*255 / std::max(B, 1))
Blend_Apply(ChannelBlend_Divide);
}
else if ((mixType == 'H ') || (mixType == 'hue ')) // Hue
{
aBlendedColor = SetLum(SetSat(*aSrcColor, Sat(*aDestColor)), Lum(*aDestColor));
aBlendedColor.a = aSrcAlpha;
}
else if ((mixType == 'Strt') || (mixType == 'sat ')) // Saturation
{
aBlendedColor = SetLum(SetSat(*aDestColor, Sat(*aSrcColor)), Lum(*aDestColor));
aBlendedColor.a = aSrcAlpha;
}
else if ((mixType == 'Clr ') || (mixType == 'colr')) // Color
{
aBlendedColor = SetLum(*aSrcColor, Lum(*aDestColor));
aBlendedColor.a = aSrcAlpha;
}
else if ((mixType == 'Lmns') || (mixType == 'lum ')) // Luminosity
{
aBlendedColor = SetLum(*aDestColor, Lum(*aSrcColor));
aBlendedColor.a = aSrcAlpha;
}
else
{
BF_FATAL("Unknown blend type");
}
//if (aDestColor->a != 0)
{
if ((mixType == 'lddg') || (mixType == 'lnDg')) // Linear Dodge
{
int newDestAlpha = 255;
int a = aSrcAlpha;
if (aDestColor->a != 255)
newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * aSrcAlpha) / 255;
int blendThing = 255 - ((255 - aBlendAlpha) * aDestColor->a / 255);
#define LinearDodge_Layer(A,B) \
std::min(255, A + B * blendThing / 255) + ((255 - blendThing) * B) / 255
WideColor blendWColor =
{LinearDodge_Layer((int) aDestColor->r, (int) aSrcColor->r),
LinearDodge_Layer((int) aDestColor->g, (int) aSrcColor->g),
LinearDodge_Layer((int) aDestColor->b, (int) aSrcColor->b),
aSrcAlpha};
if (newDestAlpha != 0)
{
a = 255 * blendWColor.a / newDestAlpha;
int ba = aDestColor->a;
int boma = 255 - ba;
blendWColor.r = ((blendWColor.r * ba) + (aSrcColor->r * boma)) / 255;
blendWColor.g = ((blendWColor.g * ba) + (aSrcColor->g * boma)) / 255;
blendWColor.b = ((blendWColor.b * ba) + (aSrcColor->b * boma)) / 255;
}
int oma = 255 - a;
aDestColor->a = newDestAlpha;
aDestColor->r = std::min(255, ((blendWColor.r * a) + (aDestColor->r * oma)) / 255);
aDestColor->g = std::min(255, ((blendWColor.g * a) + (aDestColor->g * oma)) / 255);
aDestColor->b = std::min(255, ((blendWColor.b * a) + (aDestColor->b * oma)) / 255);
}
else if ((mixType == 'lbrn') || (mixType == 'lnBn')) // Linear Burn
{
int blendThing = 255 - ((255 - aBlendAlpha) * aDestColor->a / 255);
#define Blend_LinearDodge_Layer(A,B) \
255 - (std::min(255, ((255 - A) + (255 - B) * blendThing / 255)) + ((255 - blendThing) * (255 - B)) / 255)
//255 - ((255 - A) + (255 - B))
WideColor blendWColor =
{Blend_LinearDodge_Layer((int) aDestColor->r, (int) aSrcColor->r),
Blend_LinearDodge_Layer((int) aDestColor->g, (int) aSrcColor->g),
Blend_LinearDodge_Layer((int) aDestColor->b, (int) aSrcColor->b),
aSrcAlpha};
int newDestAlpha = 255;
int a = blendWColor.a;
if (aDestColor->a != 255)
newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * blendWColor.a) / 255;
if (newDestAlpha != 0)
{
a = 255 * blendWColor.a / newDestAlpha;
int ba = aDestColor->a;
int boma = 255 - aDestColor->a;
blendWColor.r = ((blendWColor.r * ba) + (aSrcColor->r * boma)) / 255;
blendWColor.g = ((blendWColor.g * ba) + (aSrcColor->g * boma)) / 255;
blendWColor.b = ((blendWColor.b * ba) + (aSrcColor->b * boma)) / 255;
}
int oma = 255 - a;
aDestColor->a = newDestAlpha;
aDestColor->r = std::max(0, ((blendWColor.r * a) + (aDestColor->r * oma)) / 255);
aDestColor->g = std::max(0, ((blendWColor.g * a) + (aDestColor->g * oma)) / 255);
aDestColor->b = std::max(0, ((blendWColor.b * a) + (aDestColor->b * oma)) / 255);
}
else if ((mixType == 'lLit') || (mixType == 'linL')) // Linear Light
{
int blendThing = 255 - ((255 - aBlendAlpha) * aDestColor->a / 255);
#define LinearLight_Contrib(A,B) \
(B < 128) ? \
(255 - (std::min(255, ((255 - A) + (255 - B*2) * blendThing / 255)) + ((255 - blendThing) * (255 - B*2)) / 255)) : \
(std::min(255, A + (B - 128)*2 * blendThing / 255) + ((255 - blendThing) * (B - 128)*2) / 255)
//((B - 128)*2 + A)
WideColor blendWColor =
{LinearLight_Contrib((int) aDestColor->r, (int) aSrcColor->r),
LinearLight_Contrib((int) aDestColor->g, (int) aSrcColor->g),
LinearLight_Contrib((int) aDestColor->b, (int) aSrcColor->b),
aSrcAlpha};
int newDestAlpha = 255;
int a = blendWColor.a;
if (aDestColor->a != 255)
newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * blendWColor.a) / 255;
if (newDestAlpha != 0)
{
a = 255 * blendWColor.a / newDestAlpha;
int ba = aDestColor->a;
int boma = 255 - aDestColor->a;
blendWColor.r = ((blendWColor.r * ba) + (aSrcColor->r * boma)) / 255;
blendWColor.g = ((blendWColor.g * ba) + (aSrcColor->g * boma)) / 255;
blendWColor.b = ((blendWColor.b * ba) + (aSrcColor->b * boma)) / 255;
}
int oma = 255 - a;
aDestColor->a = newDestAlpha;
aDestColor->r = clamp((((blendWColor.r * a) + (aDestColor->r * oma)) / 255), 0, 255);
aDestColor->g = clamp((((blendWColor.g * a) + (aDestColor->g * oma)) / 255), 0, 255);
aDestColor->b = clamp((((blendWColor.b * a) + (aDestColor->b * oma)) / 255), 0, 255);
}
else if (doReverseBlend)
{
int newDestAlpha = 255;
int a = aDestColor->a;
if (aDestColor->a != 255)
newDestAlpha = aBlendedColor.a + ((255 - aBlendedColor.a) * aDestColor->a) / 255;
if (newDestAlpha != 0)
a = 255 * aDestColor->a / newDestAlpha;
int oma = 255 - a;
aDestColor->a = newDestAlpha;
aDestColor->r = ((aDestColor->r * a) + (aBlendedColor.r * oma)) / 255;
aDestColor->g = ((aDestColor->g * a) + (aBlendedColor.g * oma)) / 255;
aDestColor->b = ((aDestColor->b * a) + (aBlendedColor.b * oma)) / 255;
}
else if (doFullBlend)
{
if ((dest->mX + x == 231) && (dest->mY + y == 183))
{
/*aBlendedColor.a = 255;
aBlendedColor.r = 0;
aBlendedColor.g = 255;
aBlendedColor.b = 0;*/
}
int newDestAlpha = 255;
int a = aBlendedColor.a;
if (aDestColor->a != 255)
newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * aBlendedColor.a) / 255;
/*if (newDestAlpha != 0)
{
//a = 255 * aSrcColor->a / newDestAlpha;
int ba = aDestColor->a;
int boma = 255 - ba;
aBlendedColor.r = ((aBlendedColor.r * ba) + (aSrcColor->r * boma)) / 255;
aBlendedColor.g = ((aBlendedColor.g * ba) + (aSrcColor->g * boma)) / 255;
aBlendedColor.b = ((aBlendedColor.b * ba) + (aSrcColor->b * boma)) / 255;
}*/
if (newDestAlpha != 0)
{
//a = 255 * aSrcColor->a / newDestAlpha;
int ba = 255 * aDestColor->a / newDestAlpha;
int boma = 255 - ba;
aBlendedColor.r = ((aBlendedColor.r * ba) + (aSrcColor->r * boma)) / 255;
aBlendedColor.g = ((aBlendedColor.g * ba) + (aSrcColor->g * boma)) / 255;
aBlendedColor.b = ((aBlendedColor.b * ba) + (aSrcColor->b * boma)) / 255;
//}
//if (aBlendedColor.a
/*int coma = (255 * 255 * a) / (255 * a + aDestColor->a * (255 - a));
//int ca = 255 - aBlendedColor.a;
//coma = gSqrtTable[coma];
//coma = std::min(255, coma * 255);
if (coma != 255)
{
}
coma = 255;
int ca = 255 - coma;
aDestColor->a = newDestAlpha;
aDestColor->r = ((aDestColor->r * ca) + (aBlendedColor.r * coma)) / 255;
aDestColor->g = ((aDestColor->g * ca) + (aBlendedColor.g * coma)) / 255;
aDestColor->b = ((aDestColor->b * ca) + (aBlendedColor.b * coma)) / 255;*/
aDestColor->a = newDestAlpha;
aDestColor->r = aBlendedColor.r;
aDestColor->g = aBlendedColor.g;
aDestColor->b = aBlendedColor.b;
}
else
{
aDestColor->a = 0;
}
/*int oma = 255 - a;
aDestColor->a = newDestAlpha;
aDestColor->r = aBlendedColor.r;
aDestColor->g = aBlendedColor.g;
aDestColor->b = aBlendedColor.b;*/
/*int newDestAlpha = 255;
int a = aBlendedColor.a;
if (aDestColor->a != 255)
newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * aBlendedColor.a) / 255;
int oma = 255 - a;
aDestColor->a = newDestAlpha;
aDestColor->r = aBlendedColor.r;
aDestColor->g = aBlendedColor.g;
aDestColor->b = aBlendedColor.b;
if (newDestAlpha != 0)
{
a = 255 * aBlendedColor.a / newDestAlpha;
int ba = aDestColor->a;
int boma = 255 - ba;
aBlendedColor.r = ((aDestColor->r * ba) + (aSrcColor->r * boma)) / 255;
aBlendedColor.g = ((aDestColor->g * ba) + (aSrcColor->g * boma)) / 255;
aBlendedColor.b = ((aDestColor->b * ba) + (aSrcColor->b * boma)) / 255;
}*/
}
else if (doAltBlend)
{
if ((dest->mX + x == 134) && (dest->mY + y == 153))
{
/*aDestColor->a = 255;
aDestColor->r = 0;
aDestColor->g = 255;
aDestColor->b = 0;*/
}
int newDestAlpha = 255;
if (aDestColor->a != 255)
newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * aSrcAlpha) / 255;
int destContrib = (255 - aSrcColor->a)*aDestColor->a;
int srcContrib = (255 - aDestColor->a)*aSrcColor->a;
int blendContrib = aSrcColor->a * aDestColor->a;
int divTot = destContrib + srcContrib + blendContrib;
if (divTot > 0)
{
aDestColor->r = ((destContrib * aDestColor->r) + (srcContrib * aSrcColor->r) + (blendContrib * aBlendedColor.r)) / divTot;
aDestColor->g = ((destContrib * aDestColor->g) + (srcContrib * aSrcColor->g) + (blendContrib * aBlendedColor.g)) / divTot;
aDestColor->b = ((destContrib * aDestColor->b) + (srcContrib * aSrcColor->b) + (blendContrib * aBlendedColor.b)) / divTot;
aDestColor->a = newDestAlpha;
}
}
else
{
if ((x == 140) && (y == 83))
{
}
int newDestAlpha = 255;
int a = aBlendedColor.a;
if (aDestColor->a != 255)
newDestAlpha = aDestColor->a + ((255 - aDestColor->a) * aBlendedColor.a) / 255;
if (newDestAlpha != 0)
{
a = 255 * aBlendedColor.a / newDestAlpha;
int ba = aDestColor->a;
int boma = 255 - aDestColor->a;
aBlendedColor.r = ((aBlendedColor.r * ba) + (aSrcColor->r * boma)) / 255;
aBlendedColor.g = ((aBlendedColor.g * ba) + (aSrcColor->g * boma)) / 255;
aBlendedColor.b = ((aBlendedColor.b * ba) + (aSrcColor->b * boma)) / 255;
}
int oma = 255 - a;
aDestColor->a = newDestAlpha;
aDestColor->r = ((aBlendedColor.r * a) + (aDestColor->r * oma)) / 255;
aDestColor->g = ((aBlendedColor.g * a) + (aDestColor->g * oma)) / 255;
aDestColor->b = ((aBlendedColor.b * a) + (aDestColor->b * oma)) / 255;
}
}
aDestColor++;
aSrcColor++;
}
}
}
void Beefy::BlendImagesTogether(ImageData* bottomImage, ImageData* topImage, ImageData* alphaImage)
{
for (int y = alphaImage->mY; y < alphaImage->mY + alphaImage->mHeight; y++)
{
PackedColor* topColor = (PackedColor*) (topImage->mBits + (alphaImage->mX - topImage->mX) + ((y - topImage->mY) * topImage->mWidth));
PackedColor* botColor = (PackedColor*) (bottomImage->mBits + (alphaImage->mX - bottomImage->mX) + ((y - bottomImage->mY) * bottomImage->mWidth));
PackedColor* alphaColor = (PackedColor*) (alphaImage->mBits + (alphaImage->mX - alphaImage->mX) + ((y - alphaImage->mY) * alphaImage->mWidth));
for (int x = 0; x < alphaImage->mWidth; x++)
{
int a = alphaColor->a;
int oma = 255 - a;
int newDestAlpha = ((topColor->a * a) + (botColor->a * oma)) / 255;
if (newDestAlpha != 0)
{
int ca = (255 * topColor->a * a) / ((topColor->a * a) + (botColor->a * oma));
int coma = 255 - ca;
botColor->a = newDestAlpha;
botColor->r = ((topColor->r * ca) + (botColor->r * coma)) / 255;
botColor->g = ((topColor->g * ca) + (botColor->g * coma)) / 255;
botColor->b = ((topColor->b * ca) + (botColor->b * coma)) / 255;
}
topColor++;
botColor++;
alphaColor++;
}
}
}
void Beefy::SetImageAlpha(ImageData* image, ImageData* alphaImage)
{
for (int i = 0; i < image->mWidth * image->mHeight; i++)
image->mBits[i] = image->mBits[i] & 0x00FFFFFF;
for (int y = alphaImage->mY; y < alphaImage->mY + alphaImage->mHeight; y++)
{
PackedColor* aColor = (PackedColor*) (image->mBits + (alphaImage->mX - image->mX) + ((y - image->mY) * image->mWidth));
PackedColor* alphaColor = (PackedColor*) (alphaImage->mBits + (alphaImage->mX - alphaImage->mX) + ((y - alphaImage->mY) * alphaImage->mWidth));
for (int x = 0; x < alphaImage->mWidth; x++)
{
aColor->a = alphaColor->a;
aColor++;
alphaColor++;
}
}
}
void Beefy::MultiplyImageAlpha(ImageData* image, ImageData* alphaImage)
{
for (int y = alphaImage->mY; y < alphaImage->mY + alphaImage->mHeight; y++)
{
PackedColor* aColor = (PackedColor*) (image->mBits + (alphaImage->mX - image->mX) + ((y - image->mY) * image->mWidth));
PackedColor* alphaColor = (PackedColor*) (alphaImage->mBits + (alphaImage->mX - alphaImage->mX) + ((y - alphaImage->mY) * alphaImage->mWidth));
for (int x = 0; x < alphaImage->mWidth; x++)
{
aColor->a = aColor->a * alphaColor->a / 255;
aColor++;
alphaColor++;
}
}
}
void Beefy::SetImageAlpha(ImageData* image, int alpha)
{
int size = image->mWidth * image->mHeight;
for (int i = 0; i < size; i++)
image->mBits[i] |= 0xFF000000;
}
void Beefy::CopyImageBits(ImageData* dest, ImageData* src)
{
for (int y = src->mY; y < src->mY + src->mHeight; y++)
{
PackedColor* aDestColor = (PackedColor*) (dest->mBits + (src->mX - dest->mX) + ((y - dest->mY) * dest->mWidth));
PackedColor* aSrcColor = (PackedColor*) (src->mBits + (src->mX - src->mX) + ((y - src->mY) * src->mWidth));
for (int x = 0; x < src->mWidth; x++)
{
*aDestColor = *aSrcColor;
aDestColor++;
aSrcColor++;
}
}
}
View git blame Copy permalink