/**
* Draw the amount of squares a structure would take. The X and Y coordinates are the top
* left coordinates of an icon.
*
* @param structureId
* @param x
* @param y
*/
void cBuildingListDrawer::drawStructureSize(int structureId, int x, int y) {
// figure out size
int iW=structures[structureId].bmp_width/32;
int iH=structures[structureId].bmp_height/32;
int iTile = GRID_1X1;
if (iW == 2 && iH == 2) {
iTile = GRID_2X2;
}
if (iW == 3 && iH == 2) {
iTile = GRID_3X2;
}
if (iW == 3 && iH == 3) {
iTile = GRID_3X3;
}
BITMAP *temp=create_bitmap(19,19);
clear_bitmap(temp);
set_trans_blender(0, 0, 0, 192);
draw_trans_sprite(temp, bmp_screen, x + 43, y + 20);
draw_sprite(temp, (BITMAP *)gfxinter[GRID_0X0].dat, 0, 0);
draw_trans_sprite(bmp_screen, temp, x + 43, y + 20);
draw_sprite(bmp_screen, (BITMAP *)gfxinter[iTile].dat, x + 43, y + 20);
destroy_bitmap(temp);
}
void PlaceItDrawer::drawStructureIdAtCell(cBuildingListItem *itemToPlace, int cell) {
assert(itemToPlace);
assert(cell >= 0);
int structureId = itemToPlace->getBuildId();
int iDrawX = map->mouse_draw_x();
int iDrawY = map->mouse_draw_y();
if (structureId == SLAB1) {
draw_trans_sprite(bmp_screen, (BITMAP *) gfxdata[PLACE_SLAB1].dat, iDrawX, iDrawY);
} else if (structureId == SLAB4) {
draw_trans_sprite(bmp_screen, (BITMAP *) gfxdata[PLACE_SLAB4].dat, iDrawX, iDrawY);
} else if (structureId == WALL) {
draw_trans_sprite(bmp_screen, (BITMAP *) gfxdata[PLACE_WALL].dat, iDrawX, iDrawY);
} else {
BITMAP *temp;
temp = create_bitmap(structures[structureId].bmp_width, structures[structureId].bmp_height);
clear_bitmap(temp);
blit(structures[structureId].bmp, temp, 0, 0, 0, 0, structures[structureId].bmp_width, structures[structureId].bmp_height);
draw_trans_sprite(bmp_screen, temp, iDrawX, iDrawY);
destroy_bitmap(temp);
}
}
void draw_pickup_message(void)
{
if(pickup.ready)
{
if(pickup.alpha==255)
{
if(pickup.pic!=NULL){
set_trans_blender(0,0,0,158);
draw_trans_sprite(virt, pickup.pic, 240-pickup.pic->w/2,240-120);}
draw_sprite(virt, pickup.buffer, 0, 145);
}
else
{
if(pickup.pic!=NULL){
set_trans_blender(0,0,0,((float)pickup.alpha/200)*158);
draw_trans_sprite(virt, pickup.pic, 240-pickup.pic->w/2,240-120);}
set_trans_blender(0,0,0,pickup.alpha);
draw_trans_sprite(virt, pickup.buffer, 0, 145);
}
}
}
/* Desenha o botão */
void ClassButton::DrawButton(BITMAP *GameBuffer)
{
set_trans_blender(0, 0, 0, 180);
if(clicked)
draw_trans_sprite(GameBuffer, ButtonSelect, x, y);
else
draw_trans_sprite(GameBuffer, ButtonNull, x, y);
}
// desenha o fundo
// TODO: fazer esta funcao de verdade
void desenha_fundo( TipoCenario *cenario, BITMAP *fundo, BITMAP *fundo2 ) {
set_alpha_blender();
//--cenario obsoleto-----------------------------------------------
clear_to_color(fundo2, makecol(70,255,255));
draw_trans_sprite(fundo2, cenario->nuvem, HRES-350-cenario->posicao, VRES-430);
clear_to_color(fundo, makecol(255,0,255));
draw_trans_sprite(fundo, cenario->coco, HRES-200-cenario->posicao, VRES-370);
draw_trans_sprite(fundo, cenario->sol, 40-cenario->posicao, 20);
//-----------------------------------------------------------------
}
void Check_Point::draw(bool editor){
if(!occupied){
draw_trans_sprite(BUFFER,CHECK_POINT_SPRITE_VACANT,x,y);
}else{
draw_trans_sprite(BUFFER,CHECK_POINT_SPRITE_OCCUPIED,x,y);
}
if(editor)
rect(BUFFER,x,y,
x+CHECK_POINT_LENG_X,
y+CHECK_POINT_LENG_Y,
HIGHLIGHT_COLOR);
}
void Menu::draw()
{
// Draw background to screen
rectfill( buffer, 0, 0, SCREEN_W, SCREEN_H, makecol( 255,255,255));
// Draw live background
tile_map -> draw_map(buffer);
// Overlay
draw_trans_sprite(buffer, credits, 0, 0);
draw_trans_sprite(buffer, menu, 0, SCREEN_H-461);
draw_trans_sprite(buffer, menuselect, selectorX, selectorY);
// Level selection
draw_trans_sprite(buffer, levelSelectLeft, SCREEN_W-180, 80);
draw_trans_sprite(buffer, levelSelectNumber, SCREEN_W-160, 80);
textprintf_centre_ex(buffer,font,SCREEN_W-112,73,makecol(0,0,0),-1,"%i",levelOn + 1);
draw_trans_sprite(buffer, levelSelectRight, SCREEN_W-80, 80);
// Hover select left
if(collisionAny(mouse_x,mouse_x,SCREEN_W-180,SCREEN_W-140,mouse_y,mouse_y, 80, 120)){
draw_trans_sprite(buffer, levelSelectLeft, SCREEN_W-180, 80);
}
// Hover select right
if(collisionAny(mouse_x,mouse_x,SCREEN_W-80,SCREEN_W-40,mouse_y,mouse_y, 80, 120)){
draw_trans_sprite(buffer, levelSelectRight, SCREEN_W-80, 80);
}
// Cursor
draw_sprite(buffer, cursor[0], mouse_x, mouse_y);
// Select button
if (mouse_b & 1 || key[KEY_ENTER] || joy[0].button[0].b){
if (selectorY==610){
do{
draw_sprite(buffer, menu, 0, 0);
draw_sprite(buffer, help,0,0);
draw_sprite(screen,buffer,0,0);
}
while(!key[KEY_ESC] && !mouse_b & 1 && !joy[0].button[0].b);
}
}
if( menuOpen){
draw_trans_sprite( buffer,help,0,0);
}
draw_trans_sprite(buffer,copyright,SCREEN_W-350,SCREEN_H-40);
draw_sprite(buffer,cursor[0],mouse_x,mouse_y);
// Draw buffer
stretch_sprite( screen, buffer, 0, 0, SCREEN_W, SCREEN_H);
}
void Font::draw( BITMAP* aBuffer, const std::string& aText, int aX, int aY, Blending aBlending)
{
int x = aX;
int y = aY;
bool addBlend = aBlending == Blending_Add;
setBlending(aBlending);
for(unsigned int i = 0; i < aText.size(); i++)
{
BITMAP* bitmap = getBitmapForGlyph(aText[i]);
if (aBlending == Blending_None)
{
draw_sprite(aBuffer, bitmap, x, y);
}
else if (addBlend)
{
draw_trans_sprite(aBuffer, bitmap, x, y);
}
else
{
draw_lit_sprite(aBuffer, bitmap, x, y, 0);
}
x += bitmap->w;
}
}
void highcolor_fade_out(int speed)
{
BITMAP *bmp_orig, *bmp_buff;
if ((bmp_orig = create_bitmap(SCREEN_W, SCREEN_H)))
{
if ((bmp_buff = create_bitmap(SCREEN_W, SCREEN_H)))
{
int a;
blit(screen, bmp_orig, 0,0, 0,0, SCREEN_W, SCREEN_H);
if (speed <= 0) speed = 16;
for (a = 255-speed; a > 0; a-=speed)
{
clear(bmp_buff);
set_trans_blender(0,0,0,a);
draw_trans_sprite(bmp_buff, bmp_orig, 0, 0);
vsync();
blit(bmp_buff, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
}
destroy_bitmap(bmp_buff);
}
destroy_bitmap(bmp_orig);
}
rectfill(screen, 0,0, SCREEN_W,SCREEN_H, makecol(0,0,0));
}
void c_osi2_switch::draw_packet(c_drawtarget &drawtarget, c_layer &layer_any) {
double draw_step = 1./static_cast<double>(g_max_anim_frame);
const auto & gui = * drawtarget.m_gui;
auto layer = dynamic_cast<c_layer_allegro &>(layer_any);
BITMAP *frame = layer.m_frame;
c_osi2_switch &tmp_osi2_switch = m_world.find_object_by_uuid_as_switch(m_draw_outbox.front().first);
const int this_vx = gui.view_x(m_x), this_vy = gui.view_y(m_y);
const int next_vx = gui.view_x(tmp_osi2_switch.m_x), next_vy = gui.view_y(tmp_osi2_switch.m_y);
t_geo_point A(this_vx,this_vy);
t_geo_point B(next_vx,next_vy);
t_geo_point between = c_geometry::point_on_line_between_part(A,B,m_draw_outbox.front().second);
//_dbg1("DEBUG<<<<: " << between.x << " " << between.y);
//_dbg1("Layer_allegro nr: " << layer.m_layer_nr);
draw_trans_sprite(frame, c_bitmaps::get_instance().m_package_green,
between.x - c_bitmaps::get_instance().m_package_green->w / 2,
between.y - c_bitmaps::get_instance().m_package_green->h / 2);
std::string send_percent = std::to_string(static_cast<int>(100*m_draw_outbox.front().second)) + "%";
textout_ex(frame, font, send_percent.c_str(), between.x+15, between.y, makecol(0,15,25), -1);
if(m_draw_outbox.front().second < 1.
&& !m_world.get_is_pause()) {
m_draw_outbox.front().second += draw_step;
} else {
m_draw_outbox.pop();
}
}
void drawEnemy(Enemy *enemy, BITMAP *buffer, BITMAP *auxiliar, unsigned int tick)
{
if(enemy != NULL)
{
if(enemy->hp > 0)
{
masked_blit(enemy->sheet, buffer, ((int)(enemy->speed * tick)/(10) % 2) * TILE_SIZE, (enemy->orientation * TILE_SIZE),
(enemy->centre->x - TILE_SIZE/2), (enemy->centre->y - TILE_SIZE/1.5),
TILE_SIZE, TILE_SIZE);
}
else
{
set_trans_blender(255, 255, 255, enemy->blenderTax);
blit(enemy->sheet, auxiliar, ((int)(enemy->speed * tick)/(10) % 2) * TILE_SIZE, (4 * TILE_SIZE),
0, 0, TILE_SIZE, TILE_SIZE);
draw_trans_sprite(buffer, auxiliar, (enemy->centre->x - TILE_SIZE/2), (enemy->centre->y - TILE_SIZE/1.5));
if(enemy->blenderTax > 0)
{
enemy->blenderTax--;
}
}
}
}
void renderFlaresAndFlashes_DDR(int player)
{
static int columnSource[10] = { 0, 1, 2, 3, 4, 5, 0, 2, 3, 5 };
int x = getStepZonePos_DDR(player);
for ( int i = 0; i < 10; i++ )
{
int arrow = columnSource[i];
int frame = 3 - (gs.player[player].laneFlareTimers[i] / (HIT_FLASH_DISPLAY_TIME / 4)) % 4;
if ( (i == 1 || i == 4) && !gs.isSolo )
{
continue;
}
if ( (i == 0 || i == 2 || i == 3 || i == 5) && !gs.isDoubles && !gs.isSolo )
{
continue;
}
if ( i >= 6 && gs.isSolo && !gs.isDoubles )
{
continue;
}
if ( gs.player[player].laneFlareTimers[i] > 0 )
{
// also draw a bright white flash on the spot for a marvelous
if ( gs.player[player].laneFlareColors[i] == 0 || gs.player[player].laneFlareColors[i] == 3 )
{
draw_trans_sprite(rm.m_backbuf, m_flashes[frame][0], x-5, DDR_STEP_ZONE_Y-5);
}
// render a yellow flash for O.K.!
if ( gs.player[player].laneFlareColors[i] == 4 )
{
draw_trans_sprite(rm.m_backbuf, m_flashes[frame][1], x-5, DDR_STEP_ZONE_Y-5);
}
// TODO: while holding a note ( == 2 )
}
// render the fading arrow outline last
if ( gs.player[player].laneFlareTimers[i] > 0 && gs.player[player].laneFlareColors[i] < 3 )
{
draw_trans_sprite(rm.m_backbuf, m_flares[arrow][frame][gs.player[player].laneFlareColors[i]], x, DDR_STEP_ZONE_Y);
}
x += 64;
}
}
void draw_display_bitmap(display_item *pDI, int undo, BITMAP *pScreen, RECT *pRect)
{
BITMAP *pContents = (BITMAP*) pDI->pContents;
BITMAP *pOldContents = pDI->pOldContents;
BITMAP *p = (BITMAP*) (undo?pOldContents:pContents);
RECT r = {pDI->x, pDI->y, undo?p->w:pDI->is_scaled?pDI->w:p->w, undo?p->h:pDI->is_scaled?pDI->h:p->h};
RECT tmp_r;
// dirty rectangle.
if (pRect)
{
rect_copy(&tmp_r, pRect);
if (pRect->x == -1)
{
rect_copy(pRect, &r);
} else {
rect_combine(pRect, &tmp_r, &r);
}
}
if (undo)
{
// draw it
if (pDI->is_saving)
blit(pOldContents, pScreen, 0, 0, pDI->x, pDI->y, pOldContents->w, pOldContents->h);
} else {
// draw it.
if (pDI->is_scaled)
{
if (pDI->is_saving)
blit(pScreen, pOldContents, pDI->x, pDI->y, 0, 0, pDI->w, pDI->h);
if (pDI->is_sprite)
{
stretch_sprite((BITMAP*) pContents, pScreen, pDI->x, pDI->y, pDI->w, pDI->h);
} else {
stretch_blit((BITMAP*) pContents, pScreen, 0, 0, pContents->w, pContents->h, pDI->x, pDI->y, pDI->w, pDI->h);
}
} else {
if (pDI->is_saving)
blit(pScreen, pOldContents, pDI->x, pDI->y, 0, 0, pContents->w, pContents->h);
if (pDI->is_sprite)
{
draw_sprite(pScreen, pContents, pDI->x, pDI->y);
} else
if (pDI->is_translucent)
{
pDI->pParent->display_prev_table = color_map;
color_map = pDI->type==DISPLAY_LIGHT?pDI->pParent->display_light_table:pDI->pParent->display_trans_table;
draw_trans_sprite(pScreen, pContents, pDI->x, pDI->y);
color_map = pDI->pParent->display_prev_table;
} else {
blit(pContents, pScreen, 0, 0, pDI->x, pDI->y, pContents->w, pContents->h);
}
}
}
}
void renderStepZonePiece_DDR(BITMAP* src, int x, int y, int scale)
{
// copy to a temporary space, scale there, then do a transparent blit
clear_to_color(rm.m_temp64, 0x00000000); // argb format for the color
int s = (64 * scale) / 100;
int d = (64 - s) / 2;
stretch_blit(src, rm.m_temp64, 0, 0, 64, 64, d, d, s, s);
draw_trans_sprite(rm.m_backbuf, rm.m_temp64, x, y);
}
void Spike::draw(bool editor){
if(spd_x==0 && spd_y==0){
draw_trans_sprite(BUFFER,RED_SPIKE_SPRITE,x,y);
}else{
draw_trans_sprite(BUFFER,GREEN_SPIKE_SPRITE,x,y);
}
if(editor && check_placed()){
rect(BUFFER,x,y,x+SPIKE_LENG_X,y+SPIKE_LENG_Y,HIGHLIGHT_COLOR);
int x2,y2;
x2=x==min_x?max_x:min_x;
y2=y==min_y?max_y:min_y;
rect(BUFFER,x2,y2,x2+SPIKE_LENG_X,y2+SPIKE_LENG_Y,HIGHLIGHT_COLOR);
line(BUFFER,
x+SPIKE_LENG_X/2,y+SPIKE_LENG_Y/2,
x2+SPIKE_LENG_X/2,y2+SPIKE_LENG_Y/2,
HIGHLIGHT_COLOR);
}
}
void Lock::draw(bool editor){
if(!opened){
draw_sprite(BUFFER,GATE_SPRITE,gate_x,gate_y);
draw_trans_sprite(BUFFER,KEY_SPRITE,key_x,key_y);
}
if(editor){
draw_sprite(BUFFER,GATE_SPRITE,gate_x,gate_y);
draw_trans_sprite(BUFFER,KEY_SPRITE,key_x,key_y);
rect(BUFFER,gate_x,gate_y,
gate_x+GATE_LENG_X,gate_y+GATE_LENG_Y,
HIGHLIGHT_COLOR);
rect(BUFFER,key_x,key_y,
key_x+KEY_LENG_X,key_y+KEY_LENG_Y,
HIGHLIGHT_COLOR);
if(check_placed())
line(BUFFER,gate_x+GATE_LENG_X/2,gate_y+GATE_LENG_Y/2,
key_x+KEY_LENG_X/2,key_y+KEY_LENG_Y/2,HIGHLIGHT_COLOR);
}
}
// Draw
void key_manager::draw( BITMAP *tempImage){
if( !switch_flicked){
// Background
rectfill( tempImage, x+15, y+75, x +209-80, y +83+ (key_queue.size() * 90), makecol( 155, 155, 155));
// Draw keys
for( unsigned int i = 0; i < key_queue.size(); i++){
set_trans_blender(255, 255, 255, 255 - ((255/4) * i));
draw_trans_sprite( tempImage, keys[key_queue.at(i).getValue()], x + 20, -(i * 90)+y + 350);
}
}
}
void Tabs::drawTab(BITMAP* bmp, JRect box, Tab* tab, int y_delta, bool selected)
{
// Is the tab outside the bounds of the widget?
if (box->x1 >= this->rc->x2 || box->x2 <= this->rc->x1)
return;
SkinTheme* theme = static_cast<SkinTheme*>(this->getTheme());
int text_color;
int face_color;
// Selected
if (selected) {
text_color = theme->get_tab_selected_text_color();
face_color = theme->get_tab_selected_face_color();
}
// Non-selected
else {
text_color = theme->get_tab_normal_text_color();
face_color = theme->get_tab_normal_face_color();
}
if (jrect_w(box) > 2) {
theme->draw_bounds_nw(bmp,
box->x1, box->y1+y_delta, box->x2-1, box->y2-1,
(selected) ? PART_TAB_SELECTED_NW:
PART_TAB_NORMAL_NW, face_color);
jdraw_text(bmp, this->getFont(), tab->text.c_str(),
box->x1+4*jguiscale(),
(box->y1+box->y2)/2-text_height(this->getFont())/2+1 + y_delta,
text_color, face_color, false, jguiscale());
}
if (selected) {
theme->draw_bounds_nw(bmp,
box->x1, box->y2, box->x2-1, this->rc->y2-1,
PART_TAB_BOTTOM_SELECTED_NW,
theme->get_tab_selected_face_color());
}
else {
theme->draw_part_as_hline(bmp,
box->x1, box->y2, box->x2-1, this->rc->y2-1,
PART_TAB_BOTTOM_NORMAL);
}
#ifdef CLOSE_BUTTON_IN_EACH_TAB
BITMAP* close_icon = theme->get_part(PART_WINDOW_CLOSE_BUTTON_NORMAL);
set_alpha_blender();
draw_trans_sprite(doublebuffer, close_icon,
box->x2-4*jguiscale()-close_icon->w,
(box->y1+box->y2)/2-close_icon->h/2+1*jguiscale());
#endif
}
void Alleg4Surface::drawRgbaSurface(const Surface* src, int srcx, int srcy, int dstx, int dsty, int w, int h)
{
if (w < 1 || h < 1)
return;
set_alpha_blender();
BITMAP* tmp = create_sub_bitmap(
static_cast<const Alleg4Surface*>(src)->m_bmp,
srcx, srcy, w, h);
draw_trans_sprite(m_bmp, tmp, dstx, dsty);
destroy_bitmap(tmp);
}
void renderDDRComboNum(int num, int size, int color, int x, int y)
{
static int heights[] = { 43, 40, 48, 56, 64 };
// copy to a temporary space, maybe scale there, then do a transparent blit
clear_to_color(rm.m_temp64, 0x00000000); // argb format for the color
if ( size == 0 )
{
blit(m_comboNums, rm.m_temp64, num*32, color*43, 0, 0, 32, 43);
}
else
{
stretch_blit(m_comboNums, rm.m_temp64, num*32, color*43, 32, 43, 0, 0, 32, heights[size]);
}
draw_trans_sprite(rm.m_backbuf, rm.m_temp64, x, y-heights[size]);
}
// Fade in
void highcolor_fade_in(BITMAP* bmp_orig, int speed){
BITMAP* bmp_buff = create_bitmap(SCREEN_W,SCREEN_H);
BITMAP* str_orig = create_bitmap( SCREEN_W, SCREEN_H);
stretch_sprite( str_orig, bmp_orig, 0, 0, SCREEN_W, SCREEN_H);
if ( speed<=0)
speed=16;
for(int a=0; a<256; a+=speed){
clear( bmp_buff);
set_trans_blender( 0, 0, 0, a);
draw_trans_sprite( bmp_buff, str_orig, 0, 0);
vsync();
stretch_sprite( screen, bmp_buff, 0, 0, SCREEN_W, SCREEN_H);
}
stretch_sprite( screen, str_orig, 0, 0, SCREEN_W, SCREEN_H);
}
void Tilemap::Draw(BITMAP* buffer) // Uncomment the code in here to turn fog of war on
{
for (int i=0; i<(int)tiles.size(); ++i) {
for (int j=0; j<(int)tiles[i].size(); ++j) {
//if (visible[i][j] > 0)
tiles[i][j].Draw(buffer, Vector(tile_dim.XInt()*i, tile_dim.YInt()*j));
}
}
draw_sprite(buffer, grid, 0, 0);
for (int i=0; i<(int)tiles.size(); ++i) {
for (int j=0; j<(int)tiles[i].size(); ++j) {
//if (visible[i][j] == 256)
tiles[i][j].DrawObjects(buffer, Vector(tile_dim.XInt()*i, tile_dim.YInt()*j));
/*else {
set_trans_blender(0, 0, 0, 256 - visible[i][j]);
drawing_mode(DRAW_MODE_TRANS, 0, 0, 0);
rectfill(buffer, tile_dim.XInt()*i, tile_dim.YInt()*j, tile_dim.XInt()*(i+1)-1, tile_dim.YInt()*(j+1)-1, Colour::Black());
drawing_mode(DRAW_MODE_SOLID, 0, 0, 0);
}*/
}
}
if (need_to_draw_message) {
int w = citizen_saved->w * message_scale;
int h = citizen_saved->h * message_scale;
int x = scr_w/2 - w/2;
int y = scr_h/2 - h/2;
stretch_sprite(buffer, citizen_saved, x, y, w, h);
}
if (need_to_draw_blood) {
set_trans_blender(0, 0, 0, blood_alpha);
drawing_mode(DRAW_MODE_TRANS, 0, 0, 0);
draw_trans_sprite(buffer, blood, 0, 0);
drawing_mode(DRAW_MODE_SOLID, 0, 0, 0);
}
if (!need_to_draw_blood && need_fresh_blood && blood != NULL) {
clear_to_color(blood, Colour::MagicPink());
int how_many_splatters = 4 + rand() % 6;
for (int i=0; i<how_many_splatters; ++i)
draw_sprite(blood, GetBloodSplatter(), rand() % 540, rand() % 300);
need_fresh_blood = false;
}
}
void renderDDRJudgement(int judgement, int time, int x, int y)
{
BITMAP* source = m_judgements[judgement-1][0];
if ( judgement >= 1 && judgement <= 8 )
{
int percent = time * 100 / JUDGEMENT_DISPLAY_TIME; // 0-100, how much time has passed?
// happy judgements bounce slightly
if ( judgement < GOOD && judgement >= MARVELLOUS )
{
if ( percent < 5 )
{
source = m_judgements[judgement-1][1];
}
else if ( percent < 10 )
{
source = m_judgements[judgement-1][2];
}
}
// bads shake from side to side (goods are stationary)
/*
else if ( judgement == BAD )
{
percent = percent % 25;
if ( percent < 13 )
{
x -= percent / 2;
}
else
{
x += (percent-12) / 2;
}
}
*/
// misses sink slightly
else if ( judgement == MISS )
{
y = y + percent/10 - 4;
}
draw_trans_sprite(rm.m_backbuf, source, x-source->w/2, y-source->h/2);
}
}
void ALSoftwareGraphicsDriver::draw_sprite_with_transparency(BITMAP* piccy, int xxx, int yyy, int transparency)
{
int screen_depth = bitmap_color_depth(virtualScreen);
int sprite_depth = bitmap_color_depth(piccy);
if (sprite_depth < screen_depth) {
if ((sprite_depth == 8) && (screen_depth >= 24)) {
// 256-col sprite -> truecolor background
// this is automatically supported by allegro, no twiddling needed
draw_sprite(virtualScreen, piccy, xxx, yyy);
return;
}
// 256-col spirte -> hi-color background, or
// 16-bit sprite -> 32-bit background
BITMAP* hctemp=create_bitmap_ex(screen_depth, piccy->w, piccy->h);
blit(piccy,hctemp,0,0,0,0,hctemp->w,hctemp->h);
int bb,cc,mask_col = bitmap_mask_color(virtualScreen);
if (sprite_depth == 8) {
// only do this for 256-col, cos the blit call converts
// transparency for 16->32 bit
for (bb=0; bb<hctemp->w; bb++) {
for (cc=0; cc<hctemp->h; cc++)
if (_getpixel(piccy,bb,cc)==0) putpixel(hctemp,bb,cc,mask_col);
}
}
draw_sprite(virtualScreen, hctemp, xxx, yyy);
destroy_bitmap(hctemp);
}
else
{
if ((transparency != 0) && (screen_depth > 8) &&
(sprite_depth > 8) && (bitmap_color_depth(virtualScreen) > 8))
{
set_trans_blender(0,0,0, transparency);
draw_trans_sprite(virtualScreen, piccy, xxx, yyy);
}
else
draw_sprite(virtualScreen, piccy, xxx, yyy);
}
}
void shadowed_masked_image::sub_changed_hook(const zone* list)
{
if (image)
{
set_multiply_blender(0,0,0,255);
for (; list; list = list->next)
{
masked_blit(image, get_sub_buffer(), list->ax, list->ay, list->ax, list->ay, list->w() + 1, list->h() + 1);
if (shadow_mask)
{
bmp_clip(get_sub_buffer(), list->ax, list->ay, list->bx, list->by);
draw_trans_sprite(get_sub_buffer(), shadow_mask, x_offset, y_offset);
bmp_clip(get_sub_buffer(), 0, 0, get_sub_buffer()->w, get_sub_buffer()->h);
}
}
}
}
/**
fade.c - High Color Fading Routines
Last Revision: 21 June, 2002
Author: Matthew Leverton
**/
void ALSoftwareGraphicsDriver::highcolor_fade_in(BITMAP *currentVirtScreen, int speed, int targetColourRed, int targetColourGreen, int targetColourBlue)
{
BITMAP *bmp_buff;
BITMAP *bmp_orig = currentVirtScreen;
if ((_global_y_offset != 0) || (_global_x_offset != 0))
{
bmp_orig = create_bitmap(_screenWidth, _screenHeight);
clear(bmp_orig);
blit(currentVirtScreen, bmp_orig, 0, 0, _global_x_offset, _global_y_offset, currentVirtScreen->w, currentVirtScreen->h);
}
bmp_buff = create_bitmap(bmp_orig->w, bmp_orig->h);
int clearColor = makecol_depth(bitmap_color_depth(bmp_buff),
targetColourRed, targetColourGreen, targetColourBlue);
int a;
if (speed <= 0) speed = 16;
for (a = 0; a < 256; a+=speed)
{
int timerValue = *_loopTimer;
clear_to_color(bmp_buff, clearColor);
set_trans_blender(0,0,0,a);
draw_trans_sprite(bmp_buff, bmp_orig, 0, 0);
this->Vsync();
_filter->RenderScreen(bmp_buff, 0, 0);
do
{
if (_callback)
_callback();
Sleep(1);
}
while (timerValue == *_loopTimer);
}
destroy_bitmap(bmp_buff);
_filter->RenderScreen(currentVirtScreen, _global_x_offset, _global_y_offset);
if ((_global_y_offset != 0) || (_global_x_offset != 0))
destroy_bitmap(bmp_orig);
}
void AnimFrame::Draw(BITMAP* bmp, Vector pos, float scale, bool vertical_flip, float rotation, int alpha)
{
BITMAP* graphic = (BITMAP*)global_datafile[graphic_id].dat;
if (graphic == NULL) {
erlog("Graphic ID out of bounds in frame draw", 3);
return;
}
if (bmp == NULL) {
erlog("Buffer out of bounds in frame draw", 3);
return;
}
if (scale == 0.0 && vertical_flip == false && rotation == 0.0 && (alpha >= 256 || alpha < 0)) {
draw_sprite(bmp, graphic, pos.XInt(), pos.YInt());
return;
}
if (alpha >= 256 || alpha < 0) {
if (vertical_flip == false) {
rotate_scaled_sprite(bmp, graphic, pos.XInt(), pos.YInt(), fixmul(ftofix(rotation), radtofix_r), ftofix(scale));
return;
}
rotate_scaled_sprite_v_flip(bmp, graphic, pos.XInt(), pos.YInt(), fixmul(ftofix(rotation), radtofix_r), ftofix(scale));
return;
}
float fdiagonal = sqrt(static_cast<float>(graphic->w*graphic->w + graphic->h*graphic->h));
int diagonal = static_cast<int>(fdiagonal + 1);
BITMAP* temp_bmp = create_bitmap(diagonal, diagonal);
if (vertical_flip == false) {
rotate_scaled_sprite(temp_bmp, graphic, 0, 0, fixmul(ftofix(rotation), radtofix_r), ftofix(scale));
}
else {
rotate_scaled_sprite_v_flip(temp_bmp, graphic, 0, 0, fixmul(ftofix(rotation), radtofix_r), ftofix(scale));
}
set_trans_blender(0, 0, 0, alpha);
drawing_mode(DRAW_MODE_TRANS, 0, 0, 0);
draw_trans_sprite(temp_bmp, bmp, pos.XInt(), pos.YInt());
drawing_mode(DRAW_MODE_SOLID, 0, 0, 0);
}
void renderDDRCombo(int combo, int time, int centerX, int color)
{
int numDigits = 1, frame = 0;
if ( combo < 4 )
{
return;
}
if ( combo > 9999 )
{
combo = 9999;
}
// this is for the counting-up scaling animation
frame = time >= 100 ? 0 : (time / 25) + 1;
// how many digits to render?
if ( combo >= 1000 )
{
numDigits = 4;
}
else if ( combo >= 100 )
{
numDigits = 3;
}
else if ( combo >= 10 )
{
numDigits = 2;
}
// center the split of the word "combo" and the number
int x = centerX;
draw_trans_sprite(rm.m_backbuf, m_combo[color], x, DDR_COMBO_Y-21+35);
for ( int i = 0, tens = 1; i < numDigits; i++, tens *= 10 )
{
int num = (combo/tens) % 10;
renderDDRComboNum(num, frame, color, x - (i+1)*32, DDR_COMBO_Y+35);
}
}
void ALSoftwareGraphicsDriver::highcolor_fade_out(int speed, int targetColourRed, int targetColourGreen, int targetColourBlue)
{
BITMAP *bmp_orig, *bmp_buff;
int clearColor = makecol_depth(bitmap_color_depth(screen),
targetColourRed, targetColourGreen, targetColourBlue);
if ((bmp_orig = create_bitmap(_screenWidth, _screenHeight)))
{
if ((bmp_buff = create_bitmap(bmp_orig->w, bmp_orig->h)))
{
int a;
_filter->GetCopyOfScreenIntoBitmap(bmp_orig, false);
if (speed <= 0) speed = 16;
for (a = 255-speed; a > 0; a-=speed)
{
int timerValue = *_loopTimer;
clear_to_color(bmp_buff, clearColor);
set_trans_blender(0,0,0,a);
draw_trans_sprite(bmp_buff, bmp_orig, 0, 0);
this->Vsync();
_filter->RenderScreen(bmp_buff, 0, 0);
do
{
if (_callback)
_callback();
Sleep(1);
}
while (timerValue == *_loopTimer);
}
destroy_bitmap(bmp_buff);
}
destroy_bitmap(bmp_orig);
}
clear_to_color(screen, clearColor);
_filter->RenderScreen(screen, _global_x_offset, _global_y_offset);
}
void highcolor_fade_in(BITMAP *bmp_orig, int speed)
{
BITMAP *bmp_buff;
if ((bmp_buff = create_bitmap(SCREEN_W, SCREEN_H)))
{
int a;
if (speed <= 0) speed = 16;
for (a = 0; a < 256; a+=speed)
{
clear(bmp_buff);
set_trans_blender(0,0,0,a);
draw_trans_sprite(bmp_buff, bmp_orig, 0, 0);
vsync();
blit(bmp_buff, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
}
destroy_bitmap(bmp_buff);
}
blit(bmp_orig, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
}
