void gli_draw_pixel_lcd(int x, int y, unsigned char *alpha, unsigned char *rgb)
{
unsigned char *p = gli_image_rgb + y * gli_image_s + x * gli_bpp;
unsigned char invalf[3];
invalf[0] = 255 - alpha[0];
invalf[1] = 255 - alpha[1];
invalf[2] = 255 - alpha[2];
if (x < 0 || x >= gli_image_w)
return;
if (y < 0 || y >= gli_image_h)
return;
#ifdef WIN32
p[0] = rgb[2] + mul255((short)p[0] - rgb[2], invalf[2]);
p[1] = rgb[1] + mul255((short)p[1] - rgb[1], invalf[1]);
p[2] = rgb[0] + mul255((short)p[2] - rgb[0], invalf[0]);
#elif defined __APPLE__ || defined EFL_4BPP
p[0] = rgb[2] + mul255((short)p[0] - rgb[2], invalf[2]);
p[1] = rgb[1] + mul255((short)p[1] - rgb[1], invalf[1]);
p[2] = rgb[0] + mul255((short)p[2] - rgb[0], invalf[0]);
p[3] = 0xFF;
#elif defined EFL_1BPP
int gray = grayscale( rgb[0], rgb[1], rgb[2] );
int invalfgray = grayscale( invalf[0], invalf[1], invalf[2] );
p[0] = gray + mul255((short)p[0] - gray, invalfgray);
#else
p[0] = rgb[0] + mul255((short)p[0] - rgb[0], invalf[0]);
p[1] = rgb[1] + mul255((short)p[1] - rgb[1], invalf[1]);
p[2] = rgb[2] + mul255((short)p[2] - rgb[2], invalf[2]);
#endif
}
void UpdateBitmapColors(HBITMAP hbmp, COLORREF textColor, COLORREF bgColor)
{
if ((textColor & 0xFFFFFF) == WIN_COL_BLACK &&
(bgColor & 0xFFFFFF) == WIN_COL_WHITE)
return;
// color order in DIB is blue-green-red-alpha
int base[4] = { GetBValueSafe(textColor), GetGValueSafe(textColor), GetRValueSafe(textColor), 0 };
int diff[4] = {
GetBValueSafe(bgColor) - base[0],
GetGValueSafe(bgColor) - base[1],
GetRValueSafe(bgColor) - base[2],
255
};
HDC hDC = GetDC(NULL);
BITMAPINFO bmi = { 0 };
SizeI size = GetBitmapSize(hbmp);
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biWidth = size.dx;
bmi.bmiHeader.biHeight = size.dy;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
int bmpBytes = size.dx * size.dy * 4;
ScopedMem<unsigned char> bmpData((unsigned char *)malloc(bmpBytes));
CrashIf(!bmpData);
if (GetDIBits(hDC, hbmp, 0, size.dy, bmpData, &bmi, DIB_RGB_COLORS)) {
for (int i = 0; i < bmpBytes; i++) {
int k = i % 4;
bmpData[i] = (uint8_t)(base[k] + mul255(bmpData[i], diff[k]));
}
SetDIBits(hDC, hbmp, 0, size.dy, bmpData, &bmi, DIB_RGB_COLORS);
}
ReleaseDC(NULL, hDC);
}
/*
RGB part
*/
static void overmask_rgb(u32 src, char *dst, u32 alpha)
{
s32 srca = (src >> 24) & 0xff;
u32 srcr = (src >> 16) & 0xff;
s32 srcg = (src >> 8) & 0xff;
s32 srcb = (src) & 0xff;
s32 dstr = (*dst) & 0xFF;
s32 dstg = *(dst+1) & 0xFF;
s32 dstb = *(dst+2) & 0xFF;
srca = mul255(srca, alpha);
*dst = mul255(srca, srcr - dstr) + dstr;
*(dst+1) = mul255(srca, srcg - dstg) + dstg;
*(dst+2) = mul255(srca, srcb - dstb) + dstb;
}
static void overmask_rgb_const_run(u32 src, char *dst, s32 dst_pitch_x, u32 count)
{
u8 srca = (src >> 24) & 0xff;
u8 srcr = (src >> 16) & 0xff;
u8 srcg = (src >> 8) & 0xff;
u8 srcb = (src) & 0xff;
while (count) {
u8 dstr = *(dst);
u8 dstg = *(dst+1);
{
return ((a+1) * b) >> 8;
}
/*
32 bit ARGB
*/
static void overmask_bgra(u32 src, u8 *dst, u32 alpha)
{
s32 srca = (src >> 24) & 0xff;
s32 srcr = (src >> 16) & 0xff;
s32 srcg = (src >> 8) & 0xff;
s32 srcb = (src >> 0) & 0xff;
s32 dsta = dst[3];
srca = mul255(srca, alpha);
if (dsta) {
s32 dstr = dst[1];
s32 dstg = dst[1];
s32 dstb = dst[0];
dst[0] = mul255(srca, srcb - dstb) + dstb;
dst[1] = mul255(srca, srcg - dstg) + dstg;
dst[2] = mul255(srca, srcr - dstr) + dstr;
dst[3] = mul255(srca, srca) + mul255(255-srca, dsta);
} else {
dst[0] = srcb;
dst[1] = srcg;
dst[2] = srcr;
dst[3] = srca;
}
}
void gli_draw_picture(picture_t *src, int x0, int y0, int dx0, int dy0, int dx1, int dy1)
{
unsigned char *sp, *dp;
int x1, y1, sx0, sy0, sx1, sy1;
int x, y, w, h;
sx0 = 0;
sy0 = 0;
sx1 = src->w;
sy1 = src->h;
x1 = x0 + src->w;
y1 = y0 + src->h;
if (x1 <= dx0 || x0 >= dx1) return;
if (y1 <= dy0 || y0 >= dy1) return;
if (x0 < dx0)
{
sx0 += dx0 - x0;
x0 = dx0;
}
if (y0 < dy0)
{
sy0 += dy0 - y0;
y0 = dy0;
}
if (x1 > dx1)
{
sx1 += dx1 - x1;
x1 = dx1;
}
if (y1 > dy1)
{
sy1 += dy1 - y1;
y1 = dy1;
}
sp = src->rgba + (sy0 * src->w + sx0) * 4;
dp = gli_image_rgb + y0 * gli_image_s + x0 * gli_bpp;
w = sx1 - sx0;
h = sy1 - sy0;
for (y = 0; y < h; y++)
{
for (x = 0; x < w; x++)
{
unsigned char sa = sp[x*4+3];
unsigned char na = 255 - sa;
unsigned char sr = mul255(sp[x*4+0], sa);
unsigned char sg = mul255(sp[x*4+1], sa);
unsigned char sb = mul255(sp[x*4+2], sa);
#ifdef EFL_1BPP
unsigned char sgray = grayscale(sr, sg, sb);
#endif
#ifdef WIN32
dp[x*3+0] = sb + mul255(dp[x*3+0], na);
dp[x*3+1] = sg + mul255(dp[x*3+1], na);
dp[x*3+2] = sr + mul255(dp[x*3+2], na);
#elif defined __APPLE__ || defined EFL_4BPP
dp[x*4+0] = sb + mul255(dp[x*4+0], na);
dp[x*4+1] = sg + mul255(dp[x*4+1], na);
dp[x*4+2] = sr + mul255(dp[x*4+2], na);
dp[x*4+3] = 0xFF;
#elif defined EFL_1BPP
dp[x] = sgray + mul255(dp[x], na);
#else
dp[x*3+0] = sr + mul255(dp[x*3+0], na);
dp[x*3+1] = sg + mul255(dp[x*3+1], na);
dp[x*3+2] = sb + mul255(dp[x*3+2], na);
#endif
}
sp += src->w * 4;
dp += gli_image_s;
}
}
