static void dot_create_grab_spot_effect(void * data)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
ALLEGRO_STATE old_state;
ALLEGRO_TRANSFORM identity;
float s;
float sx = 512.0 / (float)t3f_virtual_display_width;
bool held = al_is_bitmap_drawing_held();
if(held)
{
al_hold_bitmap_drawing(false);
}
al_store_state(&old_state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_TRANSFORM | ALLEGRO_STATE_BLENDER);
al_set_target_bitmap(app->bitmap[DOT_BITMAP_SCRATCH]);
al_identity_transform(&identity);
al_use_transform(&identity);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
al_set_clipping_rectangle(0, 0, 512, 512);
al_clear_to_color(al_map_rgba_f(0.0, 0.0, 0.0, 1.0));
al_set_blender(ALLEGRO_ADD, ALLEGRO_ZERO, ALLEGRO_INVERSE_ALPHA);
s = DOT_GAME_GRAB_SPOT_SIZE;
t3f_draw_scaled_bitmap(app->bitmap[DOT_BITMAP_COMBO], al_map_rgba_f(0.0, 0.0, 0.0, 1.0), (float)(app->game.player.ball.x - DOT_GAME_GRAB_SPOT_SIZE) * sx, app->game.player.ball.y - DOT_GAME_GRAB_SPOT_SIZE, 0.0, (s * 2.0) * sx, s * 2, 0);
al_restore_state(&old_state);
al_hold_bitmap_drawing(held);
t3f_set_clipping_rectangle(0, 0, 0, 0);
}
static void dot_create_touch_dots_effect(void * data)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
ALLEGRO_STATE old_state;
ALLEGRO_TRANSFORM identity;
float sx = 512.0 / (float)t3f_virtual_display_width;
int i;
bool held = al_is_bitmap_drawing_held();
if(held)
{
al_hold_bitmap_drawing(false);
}
al_store_state(&old_state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_TRANSFORM);
al_set_target_bitmap(app->bitmap[DOT_BITMAP_SCRATCH]);
al_identity_transform(&identity);
al_use_transform(&identity);
al_set_clipping_rectangle(0, 0, 512, 512);
al_clear_to_color(al_map_rgba_f(0.0, 0.0, 0.0, 0.0));
al_hold_bitmap_drawing(true);
for(i = 0; i < DOT_GAME_MAX_BALLS; i++)
{
if(app->game.ball[i].active)
{
t3f_draw_scaled_bitmap(app->bitmap[DOT_BITMAP_BALL_RED + app->game.ball[i].type], al_map_rgba_f(1.0, 1.0, 1.0, 1.0), (app->game.ball[i].x - app->game.ball[i].r) * sx, app->game.ball[i].y - app->game.ball[i].r, app->game.ball[i].z, (app->game.ball[i].r * 2.0) * sx, app->game.ball[i].r * 2.0, 0);
}
}
al_hold_bitmap_drawing(false);
al_restore_state(&old_state);
al_hold_bitmap_drawing(held);
t3f_set_clipping_rectangle(0.0, 0.0, 0.0, 0.0);
}
void render(void)
{
al_hold_bitmap_drawing(true);
switch(state)
{
case STATE_LOGO:
{
logo_render();
break;
}
case STATE_INTRO:
{
cinema_render(cinema);
break;
}
case STATE_TITLE:
{
title_render();
break;
}
case STATE_GAME:
{
game_render();
break;
}
case STATE_ENDING:
{
cinema_render(ending_cinema);
break;
}
}
al_hold_bitmap_drawing(false);
}
static void t3f_render_static_tilemap(T3F_TILEMAP * tmp, T3F_TILESET * tsp, int layer, int tick, float ox, float oy, float oz, ALLEGRO_COLOR color)
{
ALLEGRO_STATE old_blender;
int i, j;
bool held;
held = al_is_bitmap_drawing_held();
al_store_state(&old_blender, ALLEGRO_STATE_BLENDER);
if(tmp->layer[layer]->flags & T3F_TILEMAP_LAYER_SOLID)
{
if(held)
{
al_hold_bitmap_drawing(false);
}
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
}
al_hold_bitmap_drawing(true);
for(i = 0; i < (t3f_virtual_display_height / tsp->height) + 1; i++)
{
for(j = 0; j < (t3f_virtual_display_width / tsp->width) + 1; j++)
{
t3f_draw_scaled_animation(tsp->tile[t3f_get_tile(tsp, tmp->layer[layer]->data[i][j], tick)]->ap, color, tick, (float)(j * tsp->width) * tmp->layer[layer]->scale, (float)(i * tsp->height) * tmp->layer[layer]->scale, 0, tmp->layer[layer]->scale, 0);
}
}
if(tmp->layer[layer]->flags & T3F_TILEMAP_LAYER_SOLID)
{
al_hold_bitmap_drawing(false);
}
al_hold_bitmap_drawing(held);
al_restore_state(&old_blender);
}
void dot_intro_render(void * data)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
al_clear_to_color(app->level_color[0]);
al_hold_bitmap_drawing(true);
dot_bg_objects_render(data);
al_draw_bitmap(app->bitmap[DOT_BITMAP_BG], 0, 0, 0);
if(!app->desktop_mode || !app->menu_showing)
{
al_draw_bitmap(app->bitmap[DOT_BITMAP_LOGO], DOT_GAME_PLAYFIELD_WIDTH / 2 - al_get_bitmap_width(app->bitmap[DOT_BITMAP_LOGO]) / 2 + app->logo_ox, DOT_GAME_PLAYFIELD_HEIGHT / 2 - al_get_bitmap_height(app->bitmap[DOT_BITMAP_LOGO]) / 2, 0);
dot_credits_render(data, app->credits_ox);
dot_shadow_text(app->font[DOT_FONT_16], t3f_color_white, al_map_rgba_f(0.0, 0.0, 0.0, 0.5), t3f_virtual_display_width / 2 + app->logo_ox, DOT_GAME_PLAYFIELD_HEIGHT - al_get_font_line_height(app->font[DOT_FONT_16]) * 2, DOT_SHADOW_OX, DOT_SHADOW_OY, ALLEGRO_ALIGN_CENTRE, "Copyright (c) 2016 T^3 Software.");
}
al_hold_bitmap_drawing(false);
dot_intro_render_split(data);
if(app->menu_showing)
{
al_hold_bitmap_drawing(true);
t3f_render_gui(app->menu[app->current_menu]);
if(app->entering_name)
{
if((app->tick / 15) % 2)
{
dot_shadow_text(app->font[DOT_FONT_32], t3f_color_white, al_map_rgba_f(0.0, 0.0, 0.0, 0.5), app->menu[DOT_MENU_PROFILE]->ox + app->menu[DOT_MENU_PROFILE]->element[1].ox + al_get_text_width(app->menu[DOT_MENU_PROFILE]->element[1].aux_data, app->menu[DOT_MENU_PROFILE]->element[1].data) / 2, app->menu[DOT_MENU_PROFILE]->oy + app->menu[DOT_MENU_PROFILE]->element[1].oy, DOT_SHADOW_OX, DOT_SHADOW_OY, 0, "_");
}
}
al_hold_bitmap_drawing(false);
}
}
void mapper_help_render(void)
{
al_hold_bitmap_drawing(false);
al_draw_filled_rectangle(0, 0, t3f_virtual_display_width, t3f_virtual_display_height, al_map_rgba_f(0.0, 0.0, 0.0, 0.75));
al_hold_bitmap_drawing(true);
al_draw_textf(mapper_font, t3f_color_white, 0, 0, 0, "Global Keys");
al_draw_textf(mapper_font, t3f_color_white, 0, 16, 0, "-------------");
al_draw_textf(mapper_font, t3f_color_white, 0, 32, 0, "F1: Help");
al_draw_textf(mapper_font, t3f_color_white, 0, 48, 0, "Tab: Change View");
al_draw_textf(mapper_font, t3f_color_white, 0, 80, 0, "Tileset Keys");
al_draw_textf(mapper_font, t3f_color_white, 0, 96, 0, "-------------");
al_draw_textf(mapper_font, t3f_color_white, 0, 112, 0, "F2: Save tileset");
al_draw_textf(mapper_font, t3f_color_white, 0, 128, 0, "F3: Load tileset");
al_draw_textf(mapper_font, t3f_color_white, 0, 144, 0, "F4: Create new tileset");
al_draw_textf(mapper_font, t3f_color_white, 0, 160, 0, "Insert: Add tile");
al_draw_textf(mapper_font, t3f_color_white, 0, 176, 0, "Delete: Delete tile");
al_draw_textf(mapper_font, t3f_color_white, 0, 208, 0, "Tilemap Keys");
al_draw_textf(mapper_font, t3f_color_white, 0, 224, 0, "-------------");
al_draw_textf(mapper_font, t3f_color_white, 0, 240, 0, "F2: Save tilemap");
al_draw_textf(mapper_font, t3f_color_white, 0, 256, 0, "F3: Load tilemap");
al_draw_textf(mapper_font, t3f_color_white, 0, 272, 0, "F4: Create new tilemap");
al_draw_textf(mapper_font, t3f_color_white, 0, 288, 0, "-/=: Select tile");
al_draw_textf(mapper_font, t3f_color_white, 0, 304, 0, "PGUP/PGDN: Select layer");
al_draw_textf(mapper_font, t3f_color_white, 0, 320, 0, "Pad +/-: Change Z-position of current layer");
al_draw_textf(mapper_font, t3f_color_white, 0, 336, 0, "Ctrl+*: Scale current layer so tiles appear 1:1");
al_draw_textf(mapper_font, t3f_color_white, 0, 352, 0, "Ctrl+Shift+*: Reset layer scale");
al_draw_textf(mapper_font, t3f_color_white, 0, 368, 0, "*: Reset layer Z-position");
al_draw_textf(mapper_font, t3f_color_white, 0, 384, 0, "S: Toggle layer solid flag");
al_draw_textf(mapper_font, t3f_color_white, 0, 400, 0, "Ctrl+S: Toggle layer static flag");
al_draw_textf(mapper_font, t3f_color_white, 0, 416, 0, "Insert: Insert layer");
al_draw_textf(mapper_font, t3f_color_white, 0, 432, 0, "Delete: Delete layer");
}
void dot_credits_render(void * data, float ox)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
int i;
float pos_y;
float pos_ox;
al_hold_bitmap_drawing(true);
dot_bg_objects_render(data);
for(i = 0; i < 540 / 32; i++)
{
al_draw_bitmap(app->bitmap[DOT_BITMAP_BALL_RED + i % 6], i * 32 + 18 + ox, sin((float)(i * 4 + app->tick) / 10.0) * 32 + 32 + 12, 0);
al_draw_bitmap(app->bitmap[DOT_BITMAP_BALL_RED + (i + 3) % 6], i * 32 + 18 + ox, cos((float)(i * 4 + app->tick) / 10.0) * 32 + DOT_GAME_PLAYFIELD_HEIGHT - 32 - 32 - 12 - 1, 0);
}
al_hold_bitmap_drawing(false);
if(app->credits.state != DOT_CREDITS_STATE_WAIT)
{
if(app->credits.current_credit < app->credits.credits)
{
pos_y = DOT_GAME_PLAYFIELD_HEIGHT / 2.0 - ((app->credits.credit[app->credits.current_credit].names + 1) * al_get_font_line_height(app->font[DOT_FONT_32])) / 2.0;
dot_shadow_text(app->font[DOT_FONT_32], al_map_rgba_f(1.0, 1.0, 0.0, 1.0), al_map_rgba_f(0.0, 0.0, 0.0, 0.5), t3f_virtual_display_width / 2 + app->credits.ox + ox, pos_y, DOT_SHADOW_OX * 2, DOT_SHADOW_OY * 2, ALLEGRO_ALIGN_CENTRE, app->credits.credit[app->credits.current_credit].header);
for(i = 0; i < app->credits.credit[app->credits.current_credit].names; i++)
{
pos_y += al_get_font_line_height(app->font[DOT_FONT_32]);
pos_ox = i % 2 ? app->credits.ox : -app->credits.ox;
dot_shadow_text(app->font[DOT_FONT_32], t3f_color_white, al_map_rgba_f(0.0, 0.0, 0.0, 0.5), t3f_virtual_display_width / 2 + pos_ox + ox, pos_y, DOT_SHADOW_OX * 2, DOT_SHADOW_OY * 2, ALLEGRO_ALIGN_CENTRE, app->credits.credit[app->credits.current_credit].name[i]);
}
}
}
}
void mapper_render(void * data)
{
if(mapper_bg_color == 0)
{
al_clear_to_color(al_map_rgb_f(0.0, 0.0, 0.1));
}
else
{
al_clear_to_color(al_map_rgb_f(0.25, 0.25, 1.0));
}
al_hold_bitmap_drawing(true);
switch(mapper_view)
{
case MAPPER_VIEW_TILESET:
{
mapper_tileset_render();
break;
}
case MAPPER_VIEW_TILEMAP:
{
mapper_tilemap_render();
break;
}
case MAPPER_VIEW_TILE_ANI:
{
mapper_tile_ani_render();
break;
}
}
if(t3f_key[ALLEGRO_KEY_F1])
{
mapper_help_render();
}
al_hold_bitmap_drawing(false);
}
void mapper_tile_ani_render(void)
{
int i;
float x, y;
bool held = al_is_bitmap_drawing_held();
if(mapper_tileset->tile[mapper_current_tile]->flags & T3F_TILE_FLAG_ANIMATED)
{
for(i = 0; i < mapper_tileset->tile[mapper_current_tile]->frame_list_total; i++)
{
x = (i % 20) * 32;
y = (i / 20) * 32;
t3f_draw_animation(mapper_tileset->tile[mapper_tileset->tile[mapper_current_tile]->frame_list[i]]->ap, t3f_color_white, mapper_tick, x, y, 0, 0);
if(i == mapper_current_frame)
{
al_hold_bitmap_drawing(true);
al_draw_rectangle(x + 0.5, y + 0.5, x + 31 + 0.5, y + 31 + 0.5, al_map_rgba_f(0.0, 1.0, 0.0, 1.0), 1.0);
al_hold_bitmap_drawing(held);
}
}
}
else
{
t3f_draw_animation(mapper_tileset->tile[mapper_current_tile]->ap, t3f_color_white, mapper_tick, 0, 0, 0, 0);
}
}
void dot_privacy_render(void * data)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
int i;
al_clear_to_color(app->level_color[0]);
al_hold_bitmap_drawing(true);
dot_bg_objects_render(data);
al_draw_bitmap(app->bitmap[DOT_BITMAP_BG], 0, 0, 0);
for(i = 0; i < 128; i++)
{
if(privacy_text[i])
{
dot_shadow_text(app->font[DOT_FONT_16], t3f_color_white, al_map_rgba_f(0.0, 0.0, 0.0, 0.5), 8, i * 16, DOT_SHADOW_OX, DOT_SHADOW_OY, 0, privacy_text[i]);
}
else
{
break;
}
}
if(!app->desktop_mode)
{
t3f_render_gui(app->menu[app->current_menu]);
}
al_hold_bitmap_drawing(false);
dot_intro_render_split(data);
}
static void dot_create_bg_object_effect(void * data)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
ALLEGRO_STATE old_state;
ALLEGRO_TRANSFORM identity;
float sx = 512.0 / (float)t3f_virtual_display_width;
int i;
bool held = al_is_bitmap_drawing_held();
if(held)
{
al_hold_bitmap_drawing(false);
}
al_store_state(&old_state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_TRANSFORM);
al_set_target_bitmap(app->bitmap[DOT_BITMAP_SCRATCH]);
al_identity_transform(&identity);
al_use_transform(&identity);
al_set_clipping_rectangle(0, 0, 512, 512);
al_clear_to_color(al_map_rgba_f(0.0, 0.0, 0.0, 0.0));
al_set_clipping_rectangle(0, 0, 512, DOT_GAME_PLAYFIELD_HEIGHT);
al_hold_bitmap_drawing(true);
for(i = 0; i < DOT_MAX_BG_OBJECTS; i++)
{
t3f_draw_scaled_bitmap(app->bitmap[DOT_BITMAP_BALL_RED], al_map_rgba_f(1.0, 1.0, 1.0, 1.0), app->bg_object[i].x * sx, app->bg_object[i].y, app->bg_object[i].z, DOT_GAME_BALL_SIZE * 2.0 * sx, DOT_GAME_BALL_SIZE * 2.0, 0);
}
al_hold_bitmap_drawing(false);
t3f_set_clipping_rectangle(0, 0, 0, 0);
al_restore_state(&old_state);
al_hold_bitmap_drawing(held);
}
static void dot_create_touch_start_effect(void * data)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
ALLEGRO_STATE old_state;
ALLEGRO_TRANSFORM identity;
float sx = 512.0 / (float)t3f_virtual_display_width;
bool held = al_is_bitmap_drawing_held();
if(held)
{
al_hold_bitmap_drawing(false);
}
al_store_state(&old_state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_TRANSFORM | ALLEGRO_STATE_BLENDER);
al_set_target_bitmap(app->bitmap[DOT_BITMAP_SCRATCH]);
al_identity_transform(&identity);
al_use_transform(&identity);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
al_set_clipping_rectangle(0, 0, 512, 512);
al_clear_to_color(al_map_rgba_f(0.0, 0.0, 0.0, 1.0));
al_set_blender(ALLEGRO_ADD, ALLEGRO_ZERO, ALLEGRO_INVERSE_ALPHA);
al_draw_filled_rectangle(DOT_GAME_TOUCH_START_X * sx, DOT_GAME_TOUCH_START_Y, DOT_GAME_TOUCH_END_X * sx, DOT_GAME_TOUCH_END_Y, al_map_rgba_f(1.0, 1.0, 1.0, 1.0));
al_restore_state(&old_state);
al_hold_bitmap_drawing(held);
t3f_set_clipping_rectangle(0, 0, 0, 0);
}
void Menu::GenerateBackground()
{
backgroundindex = rand() % 3;
if( background == nullptr )
{
background = al_create_bitmap( 1024, 512 );
}
DISPLAY->SetTarget( background );
int iw = al_get_bitmap_width( GameResources::BackgroundTiles.at(backgroundindex) );
int ih = al_get_bitmap_height( GameResources::BackgroundTiles.at(backgroundindex) );
int bx = 0;
int by = 0;
al_hold_bitmap_drawing( true );
while( by < 512 )
{
while( bx < 1024 )
{
al_draw_bitmap( GameResources::BackgroundTiles.at(backgroundindex), bx, by, 0 );
bx += iw;
}
by += ih;
bx = 0;
}
al_hold_bitmap_drawing( false );
DISPLAY->ClearTarget();
}
void TileMap::Render( int OffsetX, int OffsetY, float ScaleX, float ScaleY )
{
// Prevent non-graphical tilemaps from drawing
if( tileGraphics == 0 )
{
return;
}
float scaledTileW = tileWidth * ScaleX;
float scaledTileH = tileHeight * ScaleY;
int startX = OffsetX / scaledTileW;
int startY = OffsetY / scaledTileH;
int endX = startX + (DISPLAY->GetWidth() / scaledTileW) + 1;
int endY = startY + (DISPLAY->GetHeight() / scaledTileH) + 1;
al_hold_bitmap_drawing( true );
for( int ty = startY; ty <= endY; ty++ )
{
if( ty >= height )
{
break;
}
int actualy = (ty * scaledTileH) - OffsetY;
for( int tx = startX; tx <= endX; tx++ )
{
if( tx >= width )
{
break;
}
int actualx = (tx * scaledTileW) - OffsetX;
int tileIdx = tileData[ (ty * width) + tx ];
if( tileIdx < 0 )
{
// Draw Animated Tile
int animidx = (tileIdx * -1) - 1;
if( animidx < (int)tileAnimations.size() )
{
Animation* a = tileAnimations.at( animidx );
a->SetScale( ScaleX, ScaleY );
a->DrawFrame( actualx, actualy );
}
} else {
// Draw Normal Tile
tileGraphics->DrawSprite( tileIdx, actualx, actualy, ScaleX, ScaleY, 0 );
}
}
}
al_hold_bitmap_drawing( false );
}
void draw_nine_patch_bitmap(NINE_PATCH_BITMAP *p9, ALLEGRO_COLOR tint, int dx, int dy, int dw, int dh)
{
int i, j;
bool release_drawing = false;
/* don't draw bitmaps that are smaller than the fixed area */
if (dw < p9->h.fix || dh < p9->v.fix) return;
/* if the bitmap is the same size as the origin, then draw it as-is */
if (dw == p9->width && dh == p9->height)
{
al_draw_tinted_bitmap_region(p9->bmp, tint, 1, 1, dw, dh, dx, dy, 0);
return;
}
/* due to the caching mechanism, multiple threads cannot draw this image at the same time */
al_lock_mutex(p9->mutex);
/* only recalculate the offsets if they have changed since the last draw */
if (p9->cached_dw != dw || p9->cached_dh != dh)
{
calc_nine_patch_offsets(&p9->h, dw);
calc_nine_patch_offsets(&p9->v, dh);
p9->cached_dw = dw;
p9->cached_dh = dh;
}
if (!al_is_bitmap_drawing_held())
{
release_drawing = true;
al_hold_bitmap_drawing(true);
}
/* draw each region */
for (i = 0; i < p9->v.count; ++i)
{
for (j = 0; j < p9->h.count; ++j)
{
al_draw_tinted_scaled_bitmap(p9->bmp, tint,
p9->h.m[j].offset, p9->v.m[i].offset,
p9->h.m[j].length, p9->v.m[i].length,
dx + p9->h.m[j].dest_offset, dy + p9->v.m[i].dest_offset,
p9->h.m[j].dest_length, p9->v.m[i].dest_length,
0
);
}
}
al_unlock_mutex(p9->mutex);
if (release_drawing)
al_hold_bitmap_drawing(false);
}
void render(void * data)
{
int i;
al_clear_to_color(al_map_rgba_f(0.0, 0.0, 0.0, 0.0));
al_hold_bitmap_drawing(true);
for(i = 0; i < 1024; i++)
{
al_draw_bitmap(bitmap[object[i].bitmap], object[i].x, object[i].y, 0);
}
al_hold_bitmap_drawing(false);
}
static void ogl_lock_region_nonbb_readwrite(
ALLEGRO_BITMAP *bitmap, ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_bitmap,
int x, int gl_y, int w, int h, int format)
{
ALLEGRO_BITMAP *old_target = NULL;
/* Create an FBO if there isn't one. */
if (!ogl_bitmap->fbo_info) {
old_target = al_get_target_bitmap();
bitmap->locked = false; // FIXME: hack :(
if (al_is_bitmap_drawing_held())
al_hold_bitmap_drawing(false);
al_set_target_bitmap(bitmap); // This creates the fbo
bitmap->locked = true;
}
if (ogl_bitmap->fbo_info) {
ogl_lock_region_nonbb_readwrite_fbo(bitmap, ogl_bitmap,
x, gl_y, w, h, format);
}
else {
ogl_lock_region_nonbb_readwrite_nonfbo(bitmap, ogl_bitmap,
x, gl_y, w, h, format);
}
if (old_target) {
al_set_target_bitmap(old_target);
}
}
void mapper_tilemap_render(void)
{
int i;
float lx, ty, scale;
if(mapper_tilemap)
{
for(i = 0; i < mapper_tilemap->layers; i++)
{
if(!t3f_key[ALLEGRO_KEY_L] || i == mapper_current_layer)
{
t3f_render_tilemap(mapper_tilemap, mapper_tileset, i, mapper_tick, mapper_camera.x, mapper_camera.y, mapper_camera.z, t3f_color_white);
}
}
al_hold_bitmap_drawing(false);
if(!mapper_tilemap_hover_fail)
{
scale = mapper_tilemap->layer[mapper_current_layer]->scale;
lx = mapper_tilemap_hover_x * mapper_tileset->width * scale + mapper_tilemap->layer[mapper_current_layer]->x - mapper_camera.x + 0.5;
ty = mapper_tilemap_hover_y * mapper_tileset->height * scale + mapper_tilemap->layer[mapper_current_layer]->y - mapper_camera.y + 0.5;
al_draw_rectangle(lx, ty, lx + (float)mapper_tileset->width * scale - 1.0 + 0.5, ty + (float)mapper_tileset->height * scale - 1.0 + 0.5, al_map_rgba_f(0.0, 1.0, 0.0, 0.5), 1.0);
}
t3f_draw_animation(mapper_tileset->tile[mapper_current_tile]->ap, al_map_rgba_f(1.0, 1.0, 1.0, 0.5), mapper_tick, t3f_mouse_x + 16, t3f_mouse_y + 16, 0, 0);
al_draw_textf(mapper_font, t3f_color_white, 0, 416, 0, "Layer Position = (%4.2f, %4.2f, %4.2f)", mapper_tilemap->layer[mapper_current_layer]->x, mapper_tilemap->layer[mapper_current_layer]->y, mapper_tilemap->layer[mapper_current_layer]->z);
al_draw_textf(mapper_font, t3f_color_white, 0, 432, 0, "Camera Position = (%4.2f, %4.2f, %4.2f)", mapper_camera.x, mapper_camera.y, mapper_camera.z);
al_draw_textf(mapper_font, t3f_color_white, 0, 448, 0, "Current Layer = %d", mapper_current_layer);
al_draw_textf(mapper_font, t3f_color_white, 0, 464, 0, "Current Tile = %d", mapper_current_tile);
}
else
{
al_draw_textf(mapper_font, t3f_color_white, 0, 0, 0, "Please create or load a tilemap.");
}
}
void entityGUIChat::render(float oX,float oY){
ALLEGRO_MOUSE_STATE mState; //Mouse state
al_get_mouse_state(&mState); //Get the state of the mouse
al_hold_bitmap_drawing(true);
al_draw_bitmap(chatBoxCache,x,y-31-al_get_bitmap_height(chatBoxCache),0);
if (resizingChatVertical || gameEngine::globalFunctions::pointInRegion(mState.x,mState.y,x,y-31-(drawLines*lineHeight)-7,x+chatWidth,y-31-(drawLines*lineHeight)+2)) {
al_draw_line(x,y-31-al_get_bitmap_height(chatBoxCache),x+chatWidth,y-31-al_get_bitmap_height(chatBoxCache),al_map_rgb(255,255,255),1);
al_draw_line(x,y-31-al_get_bitmap_height(chatBoxCache)+2,x+chatWidth,y-31-al_get_bitmap_height(chatBoxCache)+2,al_map_rgb(255,255,255),1);
}
al_draw_bitmap(chatTypeBG,x,y-26,0);
textEntryBox->render(x+99,y-26,1);
al_hold_bitmap_drawing(false);
}
static mrb_value
hold_drawing(mrb_state *mrb, mrb_value self)
{
int b;
mrb_get_args(mrb, "b", &b);
al_hold_bitmap_drawing(b);
return mrb_nil_value();
}
void draw_particles() {
list_node *node = particle_list->head;
al_hold_bitmap_drawing(true); // better performance for repeated draws
while (node != NULL) {
particle *p = (particle*)(node->value);
al_draw_tinted_scaled_bitmap(
particle_bitmap, // bitmap
p->color, // tint
0, 0, BMP_SIZE, BMP_SIZE, // source coordinates
p->position.x, p->position.y, // destination coordinates
p->radius, p->radius, // scale
0 // flags
);
node = node->next;
}
al_hold_bitmap_drawing(false);
}
static void _al_draw_orthogonal_tile_layer(ALLEGRO_MAP_LAYER *layer, ALLEGRO_MAP *map, ALLEGRO_COLOR tint, float sx, float sy, float sw, float sh, float dx, float dy, int flags)
{
if (!layer->visible) {
return;
}
float r, g, b, a;
al_unmap_rgba_f(tint, &r, &g, &b, &a);
ALLEGRO_COLOR color = al_map_rgba_f(r, g, b, a * layer->opacity);
int mx, my;
int ystart = sy / map->tile_height, yend = (sy + sh) / map->tile_height;
int xstart = sx / map->tile_width, xend = (sx + sw) / map->tile_width;
// defer rendering until everything is drawn
al_hold_bitmap_drawing(true);
for (my = ystart; my <= yend; my++) {
for (mx = xstart; mx <= xend; mx++) {
ALLEGRO_MAP_TILE *tile = al_get_single_tile(map, layer, mx, my);
flags = 0;
if (!tile) {
continue;
}
float x = mx*(map->tile_width) - sx + dx;
float y = my*(map->tile_height) - sy + dy;
if (flipped_vertically(layer, mx, my)) flags ^= ALLEGRO_FLIP_VERTICAL;
if (flipped_horizontally(layer, mx, my)) flags ^= ALLEGRO_FLIP_HORIZONTAL;
if (flipped_diagonally(layer, mx, my)) {
int tile_center_h = map->tile_width / 2;
int tile_center_w = map->tile_height / 2;
flags ^= ALLEGRO_FLIP_VERTICAL;
al_draw_tinted_rotated_bitmap(tile->bitmap, color, tile_center_w, tile_center_h, x + tile_center_h, y + tile_center_w, -ALLEGRO_PI/2, flags);
} else {
al_draw_tinted_bitmap(tile->bitmap, color, x, y, flags);
}
}
}
al_hold_bitmap_drawing(false);
}
void
draw_text(const font_t* font, color_t color, int x, int y, text_align_t alignment, const char* text)
{
bool is_draw_held;
int cp;
if (alignment == TEXT_ALIGN_CENTER)
x -= get_text_width(font, text) / 2;
else if (alignment == TEXT_ALIGN_RIGHT)
x -= get_text_width(font, text);
is_draw_held = al_is_bitmap_drawing_held();
al_hold_bitmap_drawing(true);
while ((cp = *text++) != '\0') {
draw_image_masked(font->glyphs[cp].image, color, x, y);
x += font->glyphs[cp].width;
}
al_hold_bitmap_drawing(is_draw_held);
}
void TransitionTiled::Render()
{
// Draw original source
al_draw_bitmap( SourceScreen, 0, 0, 0 );
al_hold_bitmap_drawing( true );
// Draw tilemap
for( int y = 0; y < tileHigh; y++ )
{
for( int x = 0; x < tileWide; x++ )
{
if( tileMap[(y * tileWide) + x] != 0 )
{
al_draw_bitmap_region( TargetScreen, x * tileWidth, y * tileHeight, tileWidth, tileHeight, x * tileWidth, y * tileHeight, 0 );
}
}
}
al_hold_bitmap_drawing( false );
}
void dot_intro_render_split(void * data)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
char buffer[256] = {0};
ALLEGRO_COLOR shadow = al_map_rgba_f(0.0, 0.0, 0.0, 0.25);
bool held = al_is_bitmap_drawing_held();
if(held)
{
al_hold_bitmap_drawing(false);
}
al_draw_filled_rectangle(0, DOT_GAME_PLAYFIELD_HEIGHT, 540, DOT_GAME_PLAYFIELD_HEIGHT + 80, al_map_rgba_f(0.0, 0.0, 0.0, 0.5));
al_hold_bitmap_drawing(true);
sprintf(buffer, "High Score");
dot_shadow_text(app->font[DOT_FONT_32], t3f_color_white, shadow, t3f_virtual_display_width / 2, 440 + 40 - al_get_font_line_height(app->font[DOT_FONT_32]), DOT_SHADOW_OX * 2, DOT_SHADOW_OY * 2, ALLEGRO_ALIGN_CENTRE, buffer);
sprintf(buffer, "%d", app->game.high_score);
dot_shadow_text(app->font[DOT_FONT_32], t3f_color_white, shadow, t3f_virtual_display_width / 2, 440 + 40, DOT_SHADOW_OX * 2, DOT_SHADOW_OY * 2, ALLEGRO_ALIGN_CENTRE, buffer);
al_hold_bitmap_drawing(false);
al_hold_bitmap_drawing(held);
}
/* render the HUD */
void dot_game_render_hud(void * data)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
char buffer[256] = {0};
ALLEGRO_COLOR shadow = al_map_rgba_f(0.0, 0.0, 0.0, 0.25);
bool held = al_is_bitmap_drawing_held();
if(held)
{
al_hold_bitmap_drawing(false);
}
al_draw_filled_rectangle(0, DOT_GAME_PLAYFIELD_HEIGHT, 540, DOT_GAME_PLAYFIELD_HEIGHT + 80, al_map_rgba_f(0.0, 0.0, 0.0, 0.5));
if(app->desktop_mode)
{
if(app->state == DOT_STATE_GAME && (app->game.state == DOT_GAME_STATE_PAUSE || app->game.state == DOT_GAME_STATE_START))
{
al_draw_filled_rectangle(0, DOT_GAME_PLAYFIELD_HEIGHT, 540, DOT_GAME_PLAYFIELD_HEIGHT + 80, al_map_rgba_f(0.0, 0.0, 0.0, 0.5));
}
}
al_hold_bitmap_drawing(true);
sprintf(buffer, "Score");
dot_shadow_text(app->font[DOT_FONT_32], t3f_color_white, shadow, t3f_virtual_display_width - 8, 440 + 40 - al_get_font_line_height(app->font[DOT_FONT_32]), DOT_SHADOW_OX * 2, DOT_SHADOW_OY * 2, ALLEGRO_ALIGN_RIGHT, buffer);
sprintf(buffer, "%d", app->game.score);
dot_shadow_text(app->font[DOT_FONT_32], t3f_color_white, shadow, t3f_virtual_display_width - 8, 440 + 40, DOT_SHADOW_OX * 2, DOT_SHADOW_OY * 2, ALLEGRO_ALIGN_RIGHT, buffer);
sprintf(buffer, "Lives");
dot_shadow_text(app->font[DOT_FONT_32], t3f_color_white, shadow, 8, 440 + 40 - al_get_font_line_height(app->font[DOT_FONT_32]), DOT_SHADOW_OX * 2, DOT_SHADOW_OY * 2, 0, buffer);
sprintf(buffer, "%d", app->game.lives);
dot_shadow_text(app->font[DOT_FONT_32], t3f_color_white, shadow, 8, 440 + 40, DOT_SHADOW_OX * 2, DOT_SHADOW_OY * 2, 0, buffer);
t3f_draw_scaled_bitmap(app->bitmap[DOT_BITMAP_BALL_RED + app->game.player.ball.type], shadow, t3f_virtual_display_width / 2 - 32 + DOT_SHADOW_OX * 2, DOT_GAME_PLAYFIELD_HEIGHT + 40 - 32 + DOT_SHADOW_OY * 2, 0, 64, 64, 0);
t3f_draw_scaled_bitmap(app->bitmap[DOT_BITMAP_BALL_RED + app->game.player.ball.type], t3f_color_white, t3f_virtual_display_width / 2 - 32, DOT_GAME_PLAYFIELD_HEIGHT + 40 - 32, 0, 64, 64, 0);
t3f_draw_scaled_bitmap(app->bitmap[DOT_BITMAP_EMO_NORMAL + app->game.emo_state], t3f_color_white, t3f_virtual_display_width / 2 - 32, DOT_GAME_PLAYFIELD_HEIGHT + 40 - 32, 0.0, 64, 64, 0);
al_hold_bitmap_drawing(false);
al_hold_bitmap_drawing(held);
}
static void _al_draw_orthogonal_object_layer(ALLEGRO_MAP_LAYER *layer, ALLEGRO_MAP *map, ALLEGRO_COLOR tint, float sx, float sy, float sw, float sh, float dx, float dy, int flags)
{
if (!layer->visible) {
return;
}
float r, g, b, a;
al_unmap_rgba_f(tint, &r, &g, &b, &a);
ALLEGRO_COLOR color = al_map_rgba_f(r, g, b, a * layer->opacity);
// defer rendering until everything is drawn
al_hold_bitmap_drawing(true);
GSList *objects = layer->objects;
while (objects) {
ALLEGRO_MAP_OBJECT *object = (ALLEGRO_MAP_OBJECT*)objects->data;
objects = g_slist_next(objects);
// no need to draw invisible objects
if (!object->bitmap) {
continue;
}
int x = object->x - sx;
int y = object->y - sy;
// make sure it's on-screen; if it's not, don't draw it
if ((x + object->width) < 0 || x > sw || y < 0 || (y - object->height) > sh) {
continue;
}
al_draw_tinted_bitmap(object->bitmap, color, x, y-object->height, flags);
}
al_hold_bitmap_drawing(false);
}
// FIXME: Add a special case for when a single glyph rendering won't fit
// into 256x256 pixels.
static ALLEGRO_BITMAP *push_new_page(ALLEGRO_TTF_FONT_DATA *data)
{
ALLEGRO_BITMAP **back;
ALLEGRO_BITMAP *page;
ALLEGRO_STATE state;
unlock_current_page(data);
/* The bitmap will be destroyed when the parent font is destroyed so
* it is not safe to register a destructor for it.
*/
_al_push_destructor_owner();
al_store_state(&state, ALLEGRO_STATE_NEW_BITMAP_PARAMETERS);
al_set_new_bitmap_format(data->bitmap_format);
al_set_new_bitmap_flags(data->bitmap_flags);
page = al_create_bitmap(256, 256);
al_restore_state(&state);
_al_pop_destructor_owner();
back = _al_vector_alloc_back(&data->page_bitmaps);
*back = page;
/* Sometimes OpenGL will partly sample texels from the border of
* glyphs. So we better clear the texture to transparency.
* XXX This is very slow and avoidable with some effort.
*/
al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP);
al_hold_bitmap_drawing(false);
al_set_target_bitmap(*back);
al_clear_to_color(al_map_rgba_f(0, 0, 0, 0));
al_restore_state(&state);
data->page_pos_x = 0;
data->page_pos_y = 0;
data->page_line_height = 0;
return page;
}
void pp2_intro_render(void)
{
int i;
ALLEGRO_COLOR tint_color;
float alpha;
t3f_select_view(t3f_default_view);
al_hold_bitmap_drawing(false);
al_clear_to_color(al_map_rgb(255, 255, 255));
if(pp2_tick < 210)
{
for(i = 0; i < pp2_intro_pixels; i++)
{
al_draw_filled_rectangle(t3f_project_x(pp2_intro_pixel[i].x, pp2_intro_pixel[i].z), t3f_project_y(pp2_intro_pixel[i].y, pp2_intro_pixel[i].z), t3f_project_x(pp2_intro_pixel[i].x + 10, pp2_intro_pixel[i].z), t3f_project_y(pp2_intro_pixel[i].y + 10, pp2_intro_pixel[i].z), alpha_color(pp2_intro_pixel[i].color, 1.0 - fabs(pp2_intro_pixel[i].z / 640.0)));
}
}
if(pp2_tick < 180)
{
tint_color = al_map_rgba_f(0.0, 0.0, 0.0, 0.0);
}
else if(pp2_tick >= 180 && pp2_tick < 210)
{
alpha = (float)(pp2_tick - 180) / 30.0;
tint_color = al_map_rgba_f(alpha, alpha, alpha, alpha);
}
else
{
tint_color = al_map_rgba_f(1.0, 1.0, 1.0, 1.0);
}
t3f_draw_bitmap(pp2_bitmap[PP2_BITMAP_T3_LOGO], tint_color, 120.0, 40.0, 0.0, 0);
if(pp2_tick > 270)
{
alpha = (float)(pp2_tick - 270) / 60.0;
al_draw_filled_rectangle(0, 0, PP2_SCREEN_WIDTH, PP2_SCREEN_HEIGHT, al_map_rgba_f(0.0, 0.0, 0.0, alpha));
}
}
void mapper_tileset_render(void)
{
int i;
int prow;
int row, col;
if(mapper_tileset)
{
prow = (t3f_virtual_display_width / mapper_tileset->width);
for(i = 0; i < mapper_tileset->tiles; i++)
{
row = i % prow;
col = i / prow;
t3f_draw_animation(mapper_tileset->tile[i]->ap, t3f_color_white, mapper_tick, row * mapper_tileset->width, col * mapper_tileset->height, 0, 0);
if(i == mapper_hover_tile)
{
al_hold_bitmap_drawing(false);
al_draw_rectangle(row * mapper_tileset->width + 0.5, col * mapper_tileset->height + 0.5, row * mapper_tileset->width + mapper_tileset->width - 1 + 0.5, col * mapper_tileset->height + mapper_tileset->height - 1 + 0.5, al_map_rgba_f(0.0, 1.0, 0.0, 0.5), 1.0);
al_hold_bitmap_drawing(true);
}
if(i == mapper_tileset->tiles - 1)
{
al_hold_bitmap_drawing(false);
al_draw_rectangle(row * mapper_tileset->width + 0.5, col * mapper_tileset->height + 0.5, row * mapper_tileset->width + mapper_tileset->width - 1 + 0.5, col * mapper_tileset->height + mapper_tileset->height - 1 + 0.5, al_map_rgba_f(1.0, 0.0, 0.0, 0.5), 1.0);
al_hold_bitmap_drawing(true);
}
if(i == mapper_current_tile)
{
al_hold_bitmap_drawing(false);
al_draw_rectangle(row * mapper_tileset->width + 0.5, col * mapper_tileset->height + 0.5, row * mapper_tileset->width + mapper_tileset->width - 1 + 0.5, col * mapper_tileset->height + mapper_tileset->height - 1 + 0.5, al_map_rgba_f(1.0, 1.0, 1.0, 0.5), 1.0);
al_hold_bitmap_drawing(true);
}
}
}
else
{
al_draw_textf(mapper_font, t3f_color_white, 0, 0, 0, "Please create or load a tileset.");
}
}
