void DynamicSprite_CopyTransparencyMask(ScriptDynamicSprite *sds, int sourceSprite) {
if (sds->slot == 0)
quit("!DynamicSprite.CopyTransparencyMask: sprite has been deleted");
if ((spritewidth[sds->slot] != spritewidth[sourceSprite]) ||
(spriteheight[sds->slot] != spriteheight[sourceSprite]))
{
quit("!DynamicSprite.CopyTransparencyMask: sprites are not the same size");
}
Bitmap *target = spriteset[sds->slot];
Bitmap *source = spriteset[sourceSprite];
if (target->GetColorDepth() != source->GetColorDepth())
{
quit("!DynamicSprite.CopyTransparencyMask: sprites are not the same colour depth");
}
// set the target's alpha channel depending on the source
bool dst_has_alpha = (game.spriteflags[sds->slot] & SPF_ALPHACHANNEL) != 0;
bool src_has_alpha = (game.spriteflags[sourceSprite] & SPF_ALPHACHANNEL) != 0;
game.spriteflags[sds->slot] &= ~SPF_ALPHACHANNEL;
if (src_has_alpha)
{
game.spriteflags[sds->slot] |= SPF_ALPHACHANNEL;
}
BitmapHelper::CopyTransparency(target, source, dst_has_alpha, src_has_alpha);
}
void DrawingSurface_DrawImage(ScriptDrawingSurface* sds, int xx, int yy, int slot, int trans, int width, int height)
{
if ((slot < 0) || (slot >= MAX_SPRITES) || (spriteset[slot] == NULL))
quit("!DrawingSurface.DrawImage: invalid sprite slot number specified");
if ((trans < 0) || (trans > 100))
quit("!DrawingSurface.DrawImage: invalid transparency setting");
// 100% transparency, don't draw anything
if (trans == 100)
return;
Bitmap *sourcePic = spriteset[slot];
bool needToFreeBitmap = false;
if (width != SCR_NO_VALUE)
{
// Resize specified
if ((width < 1) || (height < 1))
return;
sds->MultiplyCoordinates(&width, &height);
// resize the sprite to the requested size
Bitmap *newPic = BitmapHelper::CreateBitmap(width, height, sourcePic->GetColorDepth());
newPic->StretchBlt(sourcePic,
RectWH(0, 0, spritewidth[slot], spriteheight[slot]),
RectWH(0, 0, width, height));
sourcePic = newPic;
needToFreeBitmap = true;
update_polled_stuff_if_runtime();
}
sds->StartDrawing();
sds->MultiplyCoordinates(&xx, &yy);
if (sourcePic->GetColorDepth() != abuf->GetColorDepth()) {
debug_log("RawDrawImage: Sprite %d colour depth %d-bit not same as background depth %d-bit", slot, spriteset[slot]->GetColorDepth(), abuf->GetColorDepth());
}
if (trans > 0)
{
trans_mode = ((100 - trans) * 255) / 100;
}
draw_sprite_support_alpha(xx, yy, sourcePic, slot);
sds->FinishedDrawing();
if (needToFreeBitmap)
delete sourcePic;
}
void DrawingSurface_DrawImage(ScriptDrawingSurface* sds, int xx, int yy, int slot, int trans, int width, int height)
{
if ((slot < 0) || (slot >= MAX_SPRITES) || (spriteset[slot] == NULL))
quit("!DrawingSurface.DrawImage: invalid sprite slot number specified");
if ((trans < 0) || (trans > 100))
quit("!DrawingSurface.DrawImage: invalid transparency setting");
// 100% transparency, don't draw anything
if (trans == 100)
return;
Bitmap *sourcePic = spriteset[slot];
bool needToFreeBitmap = false;
if (width != SCR_NO_VALUE)
{
// Resize specified
if ((width < 1) || (height < 1))
return;
sds->MultiplyCoordinates(&width, &height);
// resize the sprite to the requested size
Bitmap *newPic = BitmapHelper::CreateBitmap(width, height, sourcePic->GetColorDepth());
newPic->StretchBlt(sourcePic,
RectWH(0, 0, spritewidth[slot], spriteheight[slot]),
RectWH(0, 0, width, height));
sourcePic = newPic;
needToFreeBitmap = true;
update_polled_stuff_if_runtime();
}
Bitmap *ds = sds->StartDrawing();
sds->MultiplyCoordinates(&xx, &yy);
if (sourcePic->GetColorDepth() != ds->GetColorDepth()) {
debug_script_warn("RawDrawImage: Sprite %d colour depth %d-bit not same as background depth %d-bit", slot, spriteset[slot]->GetColorDepth(), ds->GetColorDepth());
}
draw_sprite_support_alpha(ds, sds->hasAlphaChannel != 0, xx, yy, sourcePic, (game.spriteflags[slot] & SPF_ALPHACHANNEL) != 0,
kBlendMode_Alpha, GfxDef::Trans100ToAlpha255(trans));
sds->FinishedDrawing();
if (needToFreeBitmap)
delete sourcePic;
}
void show_preload () {
// ** Do the preload graphic if available
color temppal[256];
Bitmap *splashsc = BitmapHelper::CreateRawObjectOwner( load_pcx("preload.pcx",temppal) );
if (splashsc != NULL) {
if (splashsc->GetColorDepth() == 8)
wsetpalette(0,255,temppal);
Bitmap *screen_bmp = BitmapHelper::GetScreenBitmap();
Bitmap *tsc = BitmapHelper::CreateBitmap(splashsc->GetWidth(),splashsc->GetHeight(),screen_bmp->GetColorDepth());
tsc->Blit(splashsc,0,0,0,0,tsc->GetWidth(),tsc->GetHeight());
screen_bmp->Clear();
screen_bmp->StretchBlt(tsc, RectWH(0, 0, scrnwid,scrnhit), Common::kBitmap_Transparency);
gfxDriver->ClearDrawList();
if (!gfxDriver->UsesMemoryBackBuffer())
{
IDriverDependantBitmap *ddb = gfxDriver->CreateDDBFromBitmap(screen_bmp, false, true);
gfxDriver->DrawSprite(0, 0, ddb);
render_to_screen(screen_bmp, 0, 0);
gfxDriver->DestroyDDB(ddb);
}
else
render_to_screen(screen_bmp, 0, 0);
delete splashsc;
delete tsc;
platform->Delay(500);
}
}
void RawDrawImageResized(int xx, int yy, int gotSlot, int width, int height) {
if ((gotSlot < 0) || (gotSlot >= MAX_SPRITES) || (spriteset[gotSlot] == NULL))
quit("!RawDrawImageResized: invalid sprite slot number specified");
// very small, don't draw it
if ((width < 1) || (height < 1))
return;
multiply_up_coordinates(&xx, &yy);
multiply_up_coordinates(&width, &height);
// resize the sprite to the requested size
Bitmap *newPic = BitmapHelper::CreateBitmap(width, height, spriteset[gotSlot]->GetColorDepth());
newPic->StretchBlt(spriteset[gotSlot],
RectWH(0, 0, spritewidth[gotSlot], spriteheight[gotSlot]),
RectWH(0, 0, width, height));
RAW_START();
if (newPic->GetColorDepth() != abuf->GetColorDepth())
quit("!RawDrawImageResized: image colour depth mismatch: the background image must have the same colour depth as the sprite being drawn");
put_sprite_256(xx, yy, newPic);
delete newPic;
invalidate_screen();
mark_current_background_dirty();
update_polled_stuff_if_runtime(); // this operation can be slow so stop music skipping
RAW_END();
}
void DrawingSurface_DrawSurface(ScriptDrawingSurface* target, ScriptDrawingSurface* source, int translev) {
if ((translev < 0) || (translev > 99))
quit("!DrawingSurface.DrawSurface: invalid parameter (transparency must be 0-99)");
target->StartDrawing();
Bitmap *surfaceToDraw = source->GetBitmapSurface();
if (surfaceToDraw == abuf)
quit("!DrawingSurface.DrawSurface: cannot draw surface onto itself");
if (translev == 0) {
// just draw it over the top, no transparency
abuf->Blit(surfaceToDraw, 0, 0, 0, 0, surfaceToDraw->GetWidth(), surfaceToDraw->GetHeight());
target->FinishedDrawing();
return;
}
if (surfaceToDraw->GetColorDepth() <= 8)
quit("!DrawingSurface.DrawSurface: 256-colour surfaces cannot be drawn transparently");
// Draw it transparently
trans_mode = ((100-translev) * 25) / 10;
put_sprite_256(0, 0, surfaceToDraw);
target->FinishedDrawing();
}
ScriptDynamicSprite* DynamicSprite_CreateFromDrawingSurface(ScriptDrawingSurface *sds, int x, int y, int width, int height)
{
int gotSlot = spriteset.findFreeSlot();
if (gotSlot <= 0)
return NULL;
// use DrawingSurface resolution
sds->MultiplyCoordinates(&x, &y);
sds->MultiplyCoordinates(&width, &height);
Bitmap *ds = sds->StartDrawing();
if ((x < 0) || (y < 0) || (x + width > ds->GetWidth()) || (y + height > ds->GetHeight()))
quit("!DynamicSprite.CreateFromDrawingSurface: requested area is outside the surface");
int colDepth = ds->GetColorDepth();
Bitmap *newPic = BitmapHelper::CreateBitmap(width, height, colDepth);
if (newPic == NULL)
return NULL;
newPic->Blit(ds, x, y, 0, 0, width, height);
sds->FinishedDrawingReadOnly();
add_dynamic_sprite(gotSlot, newPic, (sds->hasAlphaChannel != 0));
ScriptDynamicSprite *new_spr = new ScriptDynamicSprite(gotSlot);
return new_spr;
}
void DrawingSurface_DrawSurface(ScriptDrawingSurface* target, ScriptDrawingSurface* source, int translev) {
if ((translev < 0) || (translev > 99))
quit("!DrawingSurface.DrawSurface: invalid parameter (transparency must be 0-99)");
Bitmap *ds = target->StartDrawing();
Bitmap *surfaceToDraw = source->GetBitmapSurface();
if (surfaceToDraw == target->GetBitmapSurface())
quit("!DrawingSurface.DrawSurface: cannot draw surface onto itself");
if (translev == 0) {
// just draw it over the top, no transparency
ds->Blit(surfaceToDraw, 0, 0, 0, 0, surfaceToDraw->GetWidth(), surfaceToDraw->GetHeight());
target->FinishedDrawing();
return;
}
if (surfaceToDraw->GetColorDepth() <= 8)
quit("!DrawingSurface.DrawSurface: 256-colour surfaces cannot be drawn transparently");
// Draw it transparently
GfxUtil::DrawSpriteWithTransparency(ds, surfaceToDraw, 0, 0,
GfxDef::Trans100ToAlpha255(translev));
target->FinishedDrawing();
}
void DrawingSurface_DrawString(ScriptDrawingSurface *sds, int xx, int yy, int font, const char* text)
{
sds->MultiplyCoordinates(&xx, &yy);
Bitmap *ds = sds->StartDrawing();
// don't use wtextcolor because it will do a 16->32 conversion
color_t text_color = sds->currentColour;
if ((ds->GetColorDepth() <= 8) && (play.raw_color > 255)) {
text_color = ds->GetCompatibleColor(1);
debug_script_warn ("RawPrint: Attempted to use hi-color on 256-col background");
}
wouttext_outline(ds, xx, yy, font, text_color, text);
sds->FinishedDrawing();
}
int DrawingSurface_GetPixel(ScriptDrawingSurface *sds, int x, int y) {
sds->MultiplyCoordinates(&x, &y);
Bitmap *ds = sds->StartDrawing();
unsigned int rawPixel = ds->GetPixel(x, y);
unsigned int maskColor = ds->GetMaskColor();
int colDepth = ds->GetColorDepth();
if (rawPixel == maskColor)
{
rawPixel = SCR_COLOR_TRANSPARENT;
}
else if (colDepth > 8)
{
int r = getr_depth(colDepth, rawPixel);
int ds = getg_depth(colDepth, rawPixel);
int b = getb_depth(colDepth, rawPixel);
rawPixel = Game_GetColorFromRGB(r, ds, b);
}
sds->FinishedDrawingReadOnly();
return rawPixel;
}
ScriptDrawingSurface* DrawingSurface_CreateCopy(ScriptDrawingSurface *sds)
{
Bitmap *sourceBitmap = sds->GetBitmapSurface();
for (int i = 0; i < MAX_DYNAMIC_SURFACES; i++)
{
if (dynamicallyCreatedSurfaces[i] == NULL)
{
dynamicallyCreatedSurfaces[i] = BitmapHelper::CreateBitmap(sourceBitmap->GetWidth(), sourceBitmap->GetHeight(), sourceBitmap->GetColorDepth());
dynamicallyCreatedSurfaces[i]->Blit(sourceBitmap, 0, 0, 0, 0, sourceBitmap->GetWidth(), sourceBitmap->GetHeight());
ScriptDrawingSurface *newSurface = new ScriptDrawingSurface();
newSurface->dynamicSurfaceNumber = i;
newSurface->hasAlphaChannel = sds->hasAlphaChannel;
ccRegisterManagedObject(newSurface, newSurface);
return newSurface;
}
}
quit("!DrawingSurface.CreateCopy: too many copied surfaces created");
return NULL;
}
void DynamicSprite_Tint(ScriptDynamicSprite *sds, int red, int green, int blue, int saturation, int luminance)
{
Bitmap *source = spriteset[sds->slot];
Bitmap *newPic = BitmapHelper::CreateBitmap(source->GetWidth(), source->GetHeight(), source->GetColorDepth());
tint_image(newPic, source, red, green, blue, saturation, (luminance * 25) / 10);
delete source;
// replace the bitmap in the sprite set
add_dynamic_sprite(sds->slot, newPic, (game.spriteflags[sds->slot] & SPF_ALPHACHANNEL) != 0);
}
void DynamicSprite_CopyTransparencyMask(ScriptDynamicSprite *sds, int sourceSprite) {
if (sds->slot == 0)
quit("!DynamicSprite.CopyTransparencyMask: sprite has been deleted");
if ((spritewidth[sds->slot] != spritewidth[sourceSprite]) ||
(spriteheight[sds->slot] != spriteheight[sourceSprite]))
{
quit("!DynamicSprite.CopyTransparencyMask: sprites are not the same size");
}
Bitmap *target = spriteset[sds->slot];
Bitmap *source = spriteset[sourceSprite];
if (target->GetColorDepth() != source->GetColorDepth())
{
quit("!DynamicSprite.CopyTransparencyMask: sprites are not the same colour depth");
}
// set the target's alpha channel depending on the source
bool sourceHasAlpha = (game.spriteflags[sourceSprite] & SPF_ALPHACHANNEL) != 0;
game.spriteflags[sds->slot] &= ~SPF_ALPHACHANNEL;
if (sourceHasAlpha)
{
game.spriteflags[sds->slot] |= SPF_ALPHACHANNEL;
}
unsigned int maskColor = source->GetMaskColor();
int colDep = source->GetColorDepth();
int bytesPerPixel = (colDep + 1) / 8;
unsigned short *shortPtr;
unsigned int *longPtr;
for (int y = 0; y < target->GetHeight(); y++)
{
unsigned char * sourcePixel = source->GetScanLineForWriting(y);
unsigned char * targetPixel = target->GetScanLineForWriting(y);
for (int x = 0; x < target->GetWidth(); x++)
{
shortPtr = (unsigned short*)sourcePixel;
longPtr = (unsigned int*)sourcePixel;
if ((colDep == 8) && (sourcePixel[0] == maskColor))
{
targetPixel[0] = maskColor;
}
else if ((bytesPerPixel == 2) && (shortPtr[0] == maskColor))
{
((unsigned short*)targetPixel)[0] = maskColor;
}
else if ((bytesPerPixel == 3) && (memcmp(sourcePixel, &maskColor, 3) == 0))
{
memcpy(targetPixel, sourcePixel, 3);
}
else if ((bytesPerPixel == 4) && (longPtr[0] == maskColor))
{
((unsigned int*)targetPixel)[0] = maskColor;
}
else if ((bytesPerPixel == 4) && (sourceHasAlpha))
{
// the fourth byte is the alpha channel, copy it
targetPixel[3] = sourcePixel[3];
}
else if (bytesPerPixel == 4)
{
// set the alpha channel byte to opaque
targetPixel[3] = 0xff;
}
sourcePixel += bytesPerPixel;
targetPixel += bytesPerPixel;
}
}
}
void current_fade_out_effect () {
if (pl_run_plugin_hooks(AGSE_TRANSITIONOUT, 0))
return;
// get the screen transition type
int theTransition = play.fade_effect;
// was a temporary transition selected? if so, use it
if (play.next_screen_transition >= 0)
theTransition = play.next_screen_transition;
if ((theTransition == FADE_INSTANT) || (play.screen_tint >= 0)) {
if (!play.keep_screen_during_instant_transition)
set_palette_range(black_palette, 0, 255, 0);
}
else if (theTransition == FADE_NORMAL)
{
my_fade_out(5);
}
else if (theTransition == FADE_BOXOUT)
{
gfxDriver->BoxOutEffect(true, get_fixed_pixel_size(16), 1000 / GetGameSpeed());
play.screen_is_faded_out = 1;
}
else
{
get_palette(old_palette);
Bitmap *ds = GetVirtualScreen();
temp_virtual = BitmapHelper::CreateBitmap(virtual_screen->GetWidth(),virtual_screen->GetHeight(),ds->GetColorDepth());
//->Blit(abuf,temp_virtual,0,0,0,0,abuf->GetWidth(),abuf->GetHeight());
gfxDriver->GetCopyOfScreenIntoBitmap(temp_virtual);
}
}
