#ifdef OLD_GRAPHICS

PACKED_INLINE uint8_t _scale_bounded(uint8_t a, uint8_t b)

{

uint32_t u;

u = a * b + 0x80;

return (u + (u >> 8)) >> 8;

}

static void MCBitmapEffectCompositeNormal(uint32_t *dst, uint32_t color, uint8_t *mask, int32_t count)

{

for(int32_t x = 0; x < count; x++)

{

if (mask[x] == 0)

continue;

uint32_t src;

src = packed_scale_bounded(color, mask[x]);

dst[x] = packed_scale_bounded(dst[x], 255 - (src >> 24)) + src;

}

}

static void MCBitmapEffectCompositeMultiply(uint32_t *dst, uint32_t color, uint8_t *mask, int32_t count)

{

for(int32_t x = 0; x < count; x++)

{

if (mask[x] == 0)

continue;

uint32_t src;

src = packed_scale_bounded(color, mask[x]);

dst[x] = packed_multiply_bounded(src, dst[x]) + packed_bilinear_bounded(src, 255 - (dst[x] >> 24), dst[x], 255 - (src >> 24));

}

}

static void MCBitmapEffectCompositeMultiplyOpaque(uint32_t *dst, uint32_t color, uint8_t *mask, int32_t count)

{

for(int32_t x = 0; x < count; x++)

{

if (mask[x] == 0)

continue;

uint32_t src;

src = packed_scale_bounded(color, mask[x]);

dst[x] = packed_multiply_bounded(src, dst[x]) + packed_scale_bounded(dst[x], 255 - (src >> 24));

}

}

static void MCBitmapEffectCompositeColorDodge(uint32_t *dst, uint32_t color, uint8_t *mask, int32_t count)

{

for(int32_t x = 0; x < count; x++)

{

if (mask[x] == 0)

continue;

uint32_t srcv;

// I.M. 2009-08-26 - color dodge works best blending from white -> black

// rather than opaque -> transparent so retain the color alpha value

srcv = (packed_scale_bounded(color, mask[x]) & 0x00FFFFFF) | (color & 0xFF000000);

//srcv = packed_scale_bounded(color, mask[x]);

uint32_t dstv;

dstv = dst[x];

uint8_t sr, sg, sb;

sr = srcv & 0xff;

sg = (srcv >> 8) & 0xff;

sb = (srcv >> 16) & 0xff;

uint8_t dr, dg, db;

dr = dstv & 0xff;

dg = (dstv >> 8) & 0xff;

db = (dstv >> 16) & 0xff;

uint8_t sa, da;

sa = srcv >> 24;

da = dstv >> 24;

uint32_t r, g, b;

uint32_t tr,tg,tb;

r = (sa - sr) * da;

tr = dr * sa;

r = (r > tr) ? 255 * tr / r : (dr == 0 ? 0 : 255);

g = (sa - sg) * da;

tg = dg * sa;

g = (g > tg) ? 255 * tg / g : (dg == 0 ? 0 : 255);

b = (sa - sb) * da;

tb = (db * sa);

b = (b > tb) ? 255 * tb / b : (db == 0 ? 0 : 255);

uint32_t f;

f = 0xff000000 | r | (g << 8) | (b << 16);

dst[x] =

packed_scale_bounded(f, _scale_bounded(sa, da)) +

packed_scale_bounded(srcv, 255 - da) +

packed_scale_bounded(dstv, 255 - sa);

}

}

static void MCBitmapEffectAttenuateInner(uint8_t *mask, uint32_t *src, int32_t count)

{

for(int32_t x = 0; x < count; x++)

mask[x] = _scale_bounded(mask[x], src[x] >> 24);

}

static void MCBitmapEffectAttenuateInvertedInner(uint8_t *mask, uint32_t *src, int32_t count)

{

for(int32_t x = 0; x < count; x++)

mask[x] = _scale_bounded(255 - mask[x], src[x] >> 24);

}

static void MCBitmapEffectAttenuateOuter(uint8_t *mask, uint32_t *src, int32_t count)

{

for(int32_t x = 0; x < count; x++)

mask[x] = _scale_bounded(mask[x], 255 - (src[x] >> 24));

}

typedef void (*MCBitmapEffectAttenuateCallback)(uint8_t *mask, uint32_t *src, int32_t count);

typedef void (*MCBitmapEffectCompositeCallback)(uint32_t *dst, uint32_t src, uint8_t *mask, int32_t count);

struct MCBitmapEffectRenderState

{

// The region we are rendering

MCRectangle region;

// The source color

uint32_t color;

// The blur parameters (if needed)

MCBitmapEffectFilter blur_filter;

uint32_t blur_size;

uint8_t blur_spread;

MCRectangle blur_rect;

// The mask attenuation callback (if needed)

MCBitmapEffectAttenuateCallback attenuate;

MCBitmapEffectCompositeCallback composite;

};

static MCBitmapEffectCompositeCallback MCBitmapEffectChooseCompositer(MCBitmapEffectBlendMode p_mode, bool p_has_dst_alpha)

{

switch(p_mode)

{

case kMCBitmapEffectBlendModeNormal:

return MCBitmapEffectCompositeNormal;

case kMCBitmapEffectBlendModeMultiply:

return p_has_dst_alpha ? MCBitmapEffectCompositeMultiply : MCBitmapEffectCompositeMultiplyOpaque;

case kMCBitmapEffectBlendModeColorDodge:

return MCBitmapEffectCompositeColorDodge;

default:

break;

}

return NULL;

}

static void MCBitmapEffectRender(MCBitmapEffectRenderState& state, MCBitmapEffectLayer& dst, MCBitmapEffectLayer& src)

{

// Compute the dst ptr/stride in pixels.

uint32_t t_dst_stride, *t_dst_pixels;

t_dst_stride = dst . stride / 4;

t_dst_pixels = (uint4 *)dst . bits + t_dst_stride * (state . region . y - dst . bounds . y) + (state . region . x - dst . bounds . x);

// Compute the blur src ptr/stride in pixels.

uint32_t t_blur_src_stride, *t_blur_src_pixels;

t_blur_src_stride = src . stride / 4;

t_blur_src_pixels = (uint4 *)src . bits + t_blur_src_stride * (state . blur_rect . y - src . bounds . y) + (state . blur_rect . x - src . bounds . x);

// Compute the src ptr/stride in pixels.

uint32_t t_src_stride, *t_src_pixels;

t_src_stride = src . stride / 4;

t_src_pixels = (uint4 *)src . bits + t_src_stride * (state . region . y - src . bounds . y) + (state . region . x - src . bounds . x);

// Compute the pre-multiplied color.

uint32_t t_color;

t_color = packed_scale_bounded(state . color | 0xff000000, state . color >> 24);

// Ensure the color format is correct for the target context (Android is 0xAABBGGRR rather than 0xAARRGGBB)

#ifdef _ANDROID_MOBILE

t_color = (t_color & 0xff00ff00) | ((t_color & 0x00ff0000) >> 16) | ((t_color & 0x000000ff) << 16);

#endif

// Allocate a run of mask pixels

uint8_t *t_mask_pixels;

t_mask_pixels = new (nothrow) uint8_t[dst . bounds . width];

// Calculate the attenuation bounds

int32_t t_left, t_top, t_right, t_bottom, t_count;

t_left = MCU_max(state . region . x, src . bounds . x) - state . region . x;

t_top = src . bounds . y - state . region . y;

t_right = MCU_min(state . region . x + state . region . width, src . bounds . x + src . bounds . width) - state . region . x;

t_bottom = src . bounds . y + src . bounds . height - state . region . y;

t_count = MCU_max(t_right - t_left, 0);

// Initialize the blur

MCBitmapEffectBlurRef t_blur;

MCBitmapEffectBlurParameters t_blur_params;

t_blur_params . radius = state . blur_size;

t_blur_params . spread = state . blur_spread;

t_blur_params . filter = state . blur_filter;

if (MCBitmapEffectBlurBegin(t_blur_params, src . bounds, state . blur_rect, t_blur_src_pixels, t_blur_src_stride, t_blur))

{

for(int32_t y = 0; y < state . region . height; y++, t_dst_pixels += t_dst_stride, t_src_pixels += t_src_stride)

{

// Fetch the next line of blur

MCBitmapEffectBlurContinue(t_blur, t_mask_pixels);

// Attenuate the mask pixels appropriately.

if (state . attenuate && y >= t_top && y < t_bottom)

state . attenuate(t_mask_pixels + t_left, t_src_pixels + t_left, t_count);

// Composite the src with dst

state . composite(t_dst_pixels, t_color, t_mask_pixels, state . region . width);

}

MCBitmapEffectBlurEnd(t_blur);

}

delete[] t_mask_pixels;

}

static void MCShadowEffectRender(MCShadowEffect* self, bool p_inner, const MCRectangle& p_shape, MCBitmapEffectLayer& dst, MCBitmapEffectLayer& src)

{

// We fill in this structure and defer to the main rendering routine.

MCBitmapEffectRenderState t_state;

// Compute the displacement of the shadow from the shape

int32_t t_delta_x, t_delta_y;

t_delta_x = (int32_t)floor(0.5 + self -> distance * cos(self -> angle * M_PI / 180.0));

t_delta_y = (int32_t)floor(0.5 + self -> distance * sin(self -> angle * M_PI / 180.0));

if (p_inner)

t_state . region = MCU_intersect_rect(dst . bounds, p_shape);

else

t_state . region = MCU_intersect_rect(dst . bounds, MCU_offset_rect(MCU_reduce_rect(p_shape, -(signed)self -> size), t_delta_x, t_delta_y));

t_state . blur_filter = (MCBitmapEffectFilter)self -> filter;

t_state . blur_size = self -> size;

t_state . blur_spread = self -> spread;

t_state . blur_rect = MCU_offset_rect(t_state . region, -t_delta_x, -t_delta_y);

t_state . color = self -> color;

if (p_inner)

t_state . attenuate = MCBitmapEffectAttenuateInvertedInner;

else if (self -> knockout)

t_state . attenuate = MCBitmapEffectAttenuateOuter;

else

t_state . attenuate = NULL;

t_state . composite = MCBitmapEffectChooseCompositer((MCBitmapEffectBlendMode)self -> blend_mode, dst . has_alpha);

MCBitmapEffectRender(t_state, dst, src);

}

static void MCGlowEffectRender(MCGlowEffect* self, bool p_inner, const MCRectangle& p_shape, MCBitmapEffectLayer& p_dst, MCBitmapEffectLayer& p_src)

{

// We fill in this structure and defer to the main rendering routine.

MCBitmapEffectRenderState t_state;

// There is nothing to do if the glow radius is 0

if (self -> size == 0)

return;

if (p_inner)

t_state . region = MCU_intersect_rect(p_shape, p_dst . bounds);

else

t_state . region = MCU_intersect_rect(MCU_reduce_rect(p_shape, -(signed)self -> size), p_dst . bounds);

t_state . blur_filter = (MCBitmapEffectFilter)self -> filter;

t_state . blur_size = self -> size;

t_state . blur_spread = self -> spread;

t_state . blur_rect = t_state . region;

t_state . color = self -> color;

if (p_inner)

{

if (self -> source == kMCBitmapEffectSourceEdge)

t_state . attenuate = MCBitmapEffectAttenuateInvertedInner;

else

t_state . attenuate = MCBitmapEffectAttenuateInner;

}

else

t_state . attenuate = NULL;//MCBitmapEffectAttenuateOuter;

t_state . composite = MCBitmapEffectChooseCompositer((MCBitmapEffectBlendMode)self -> blend_mode, p_dst . has_alpha);

MCBitmapEffectRender(t_state, p_dst, p_src);

}

static void MCColorOverlayEffectRender(MCLayerEffect *self, const MCRectangle& p_shape, MCBitmapEffectLayer& p_dst, MCBitmapEffectLayer& p_src)

{

MCBitmapEffectRenderState t_state;

t_state . region = MCU_intersect_rect(p_shape, p_dst . bounds);

t_state . blur_filter = kMCBitmapEffectFilterOnePassBox;

t_state . blur_size = 0;

t_state . blur_spread = 0;

t_state . blur_rect = t_state . region;

t_state . color = self -> color;

t_state . attenuate = NULL;

t_state . composite = MCBitmapEffectChooseCompositer((MCBitmapEffectBlendMode)self -> blend_mode, p_dst . has_alpha);

MCBitmapEffectRender(t_state, p_dst, p_src);

}

extern void surface_combine_blendSrcOver(void *p_dst, int32_t p_dst_stride, const void *p_src, uint32_t p_src_stride, uint32_t p_width, uint32_t p_height, uint1 opacity);

void MCFilterEffectRender(MCBitmapEffect* self, const MCRectangle& p_shape, MCBitmapEffectLayer& p_dst, MCBitmapEffectLayer& p_src)

{

// Compute the output region - the output rect is goverened by the shape

// and what bits we have in the src and dst.

MCRectangle t_region;

t_region = MCU_intersect_rect(p_shape, p_dst . bounds);

surface_combine_blendSrcOver(

(char *)p_dst . bits + (t_region . y - p_dst . bounds . y) * p_dst . stride + (t_region . x - p_dst . bounds . x) * 4, p_dst . stride,

(char *)p_src . bits + (t_region . y - p_src . bounds . y) * p_src . stride + (t_region . x - p_src . bounds . x) * 4, p_src . stride,

t_region . width, t_region . height, 255);

}

void MCBitmapEffectsRender(MCBitmapEffectsRef self, const MCRectangle& shape, MCBitmapEffectLayer& dst, MCBitmapEffectLayer& src)

{

// Render the drop shadow

if ((self -> mask & kMCBitmapEffectTypeDropShadowBit) != 0)

MCShadowEffectRender(&self -> effects[kMCBitmapEffectTypeDropShadow] . shadow, false, shape, dst, src);

// Render the outer glow

if ((self -> mask & kMCBitmapEffectTypeOuterGlowBit) != 0)

MCGlowEffectRender(&self -> effects[kMCBitmapEffectTypeOuterGlow] . glow, false, shape, dst, src);

// Render the image

MCFilterEffectRender(NULL, shape, dst, src);

// Render the inner shadow

if ((self -> mask & kMCBitmapEffectTypeInnerShadowBit) != 0)

MCShadowEffectRender(&self -> effects[kMCBitmapEffectTypeInnerShadow] . shadow, true, shape, dst, src);

// Render the inner glow

if ((self -> mask & kMCBitmapEffectTypeInnerGlowBit) != 0)

MCGlowEffectRender(&self -> effects[kMCBitmapEffectTypeInnerGlow] . glow, true, shape, dst, src);

// Render the color overlay

if ((self -> mask & kMCBitmapEffectTypeColorOverlayBit) != 0)

MCColorOverlayEffectRender(&self -> effects[kMCBitmapEffectTypeColorOverlay] . layer, shape, dst, src);

}

#endif