/** Applies a rotation transformation to the current transformation. */
void cbeTransformRotate(CBEnchanted *cb) {
float angle = (cb->popValue().toFloat() / 180.0f) * M_PI;
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_rotate_transform(&t, angle);
al_use_transform(&t);
cb->pushValue(0);
}
void m_draw_tinted_bitmap_identity_view(MBITMAP *bmp, MCOLOR tint, int x, int y, int flags)
{
ALLEGRO_TRANSFORM backup, t;
al_copy_transform(&backup, al_get_current_transform());
al_identity_transform(&t);
al_use_transform(&t);
m_draw_tinted_bitmap(bmp, tint, x, y, flags);
al_use_transform(&backup);
}
void mapper_replace_tiles(ALLEGRO_BITMAP * bp)
{
int i, j;
T3F_ANIMATION * ap = NULL;
ALLEGRO_BITMAP * newbp = NULL;
ALLEGRO_STATE old_state;
ALLEGRO_TRANSFORM identity;
int current_tile = mapper_current_tile;
al_store_state(&old_state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_BLENDER | ALLEGRO_STATE_TRANSFORM);
al_identity_transform(&identity);
al_use_transform(&identity);
for(i = 0; i < al_get_bitmap_height(bp) / mapper_tile_height; i++)
{
for(j = 0; j < al_get_bitmap_width(bp) / mapper_tile_width; j++)
{
if(current_tile < mapper_tileset->tiles)
{
ap = t3f_create_animation();
if(ap)
{
newbp = al_create_bitmap(mapper_tile_width, mapper_tile_height);
if(newbp)
{
al_set_target_bitmap(newbp);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
al_draw_bitmap(bp, -j * mapper_tile_width, -i * mapper_tile_height, 0);
t3f_animation_add_bitmap(ap, newbp);
t3f_animation_add_frame(ap, 0, 0, 0, 0, mapper_tile_width, mapper_tile_height, 0, 1, 0);
t3f_destroy_animation(mapper_tileset->tile[current_tile]->ap);
mapper_tileset->tile[current_tile]->ap = ap;
}
}
current_tile++;
}
else
{
ap = t3f_create_animation();
if(ap)
{
newbp = al_create_bitmap(mapper_tile_width, mapper_tile_height);
if(newbp)
{
al_set_target_bitmap(newbp);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
al_draw_bitmap(bp, -j * mapper_tile_width, -i * mapper_tile_height, 0);
t3f_animation_add_bitmap(ap, newbp);
t3f_animation_add_frame(ap, 0, 0, 0, 0, mapper_tile_width, mapper_tile_height, 0, 1, 0);
t3f_add_tile(mapper_tileset, ap);
}
}
}
}
}
al_restore_state(&old_state);
}
/* Function: al_create_sub_bitmap
*/
ALLEGRO_BITMAP *al_create_sub_bitmap(ALLEGRO_BITMAP *parent,
int x, int y, int w, int h)
{
ALLEGRO_BITMAP *bitmap;
if (parent->parent) {
x += parent->xofs;
y += parent->yofs;
parent = parent->parent;
}
bitmap = al_calloc(1, sizeof *bitmap);
bitmap->vt = parent->vt;
/* Sub-bitmap inherits these from the parent.
* Leave these unchanged so they can be detected if improperly accessed
* directly. */
bitmap->_format = 0;
bitmap->_flags = 0;
bitmap->_display = (ALLEGRO_DISPLAY*)0x1;
bitmap->w = w;
bitmap->h = h;
bitmap->locked = false;
bitmap->cl = bitmap->ct = 0;
bitmap->cr_excl = w;
bitmap->cb_excl = h;
al_identity_transform(&bitmap->transform);
al_identity_transform(&bitmap->inverse_transform);
bitmap->inverse_transform_dirty = false;
al_identity_transform(&bitmap->proj_transform);
al_orthographic_transform(&bitmap->proj_transform, 0, 0, -1.0, w, h, 1.0);
bitmap->shader = NULL;
bitmap->parent = parent;
bitmap->xofs = x;
bitmap->yofs = y;
bitmap->memory = NULL;
_al_register_destructor(_al_dtor_list, "sub_bitmap", bitmap,
(void (*)(void *))al_destroy_bitmap);
return bitmap;
}
void reverse_position_transform(ALLEGRO_TRANSFORM *t)
{
// note: this is EXACTLY the same as position transform, except the
// order of transformations is reversed, and the values are negated
al_identity_transform(t);
al_rotate_transform_3d(t, 0, 1, 0, spin);
al_rotate_transform_3d(t, 1, 0, 0, tilt);
al_translate_transform_3d(t, -stepout.x, -stepout.y, -stepout.z);
}
/** Applies a translate transformation to the current transformation. */
void cbeTransformTranslate(CBEnchanted *cb) {
float transY = cb->popValue().toFloat();
float transX = cb->popValue().toFloat();
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_translate_transform(&t, transX, transY);
al_use_transform(&t);
cb->pushValue(0);
}
/** Applies a scale transformation to the current transformation. */
void cbeTransformScale(CBEnchanted *cb) {
float scaleY = cb->popValue().toFloat();
float scaleX = cb->popValue().toFloat();
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_scale_transform(&t, scaleX, scaleY);
al_use_transform(&t);
cb->pushValue(0);
}
void draw(vec3d camera_position, vec3d light_position)
{
ALLEGRO_STATE previous_state;
ALLEGRO_TRANSFORM transform;
if (shader && shader_applies_transform)
{
// construct our entity's transform
place.build_transform(&transform);
// Now apply it to the shader
shader->use();
Shader::set_vec3("camera_position", camera_position);
Shader::set_vec3("light_position", light_position);
Shader::set_mat4("position_transform", &transform);
Shader::set_bool("reflecting", cube_map_reflecting);
Shader::set_sampler("diffuse_texture", diffuse_texture, 2);
Shader::set_sampler("specular_texture", specular_texture, 3);
Shader::set_sampler("normal_texture", normal_texture, 4);
Shader::set_sampler_cube("cube_map_A", cube_map_A, 5);
Shader::set_sampler_cube("cube_map_B", cube_map_B, 6);
}
else
{
// when not using the shader, we'll need to
// apply the transform directly here
al_store_state(&previous_state, ALLEGRO_STATE_TRANSFORM);
al_identity_transform(&transform);
al_use_transform(&transform);
place.start_transform();
// also, we set the texture on this model directly
if (diffuse_texture) model->set_texture(diffuse_texture);
}
// actually draw our model here
if (model) model->draw();
if (shader && shader_applies_transform)
{
Shader::stop();
}
else
{
place.restore_transform();
al_restore_state(&previous_state);
}
}
void mw2_Rect::Draw(mw2_Camera* camera)
{
float x = WorldPosition()->x - camera->WorldPosition()->x;
float y = WorldPosition()->y - camera->WorldPosition()->y;
float teta = - camera->WorldRotation() * (float) PI / 180;
float finalAngle = WorldRotation() - camera->WorldRotation();
float finalX = (x * (float) cos(teta) - y * (float) sin(teta))
+ mw2_Application::Settings::width / 2;
float finalY = (x * (float) sin(teta) + y * (float) cos(teta))
+ mw2_Application::Settings::height / 2;
ALLEGRO_TRANSFORM T;
al_identity_transform(&T);
al_rotate_transform(&T, finalAngle * (float) PI / 180);
al_translate_transform(&T, finalX, finalY);
al_use_transform(&T);
ALLEGRO_COLOR color = al_map_rgba(mColor->x, mColor->y, mColor->z, mColor->t);
switch (mStyle)
{
case FILL:
al_draw_filled_rectangle(
- mSize->x /2, - mSize->y /2,
mSize->x /2, mSize->y /2,
color
);
break;
case LINE:
al_draw_rectangle(
- mSize->x /2, - mSize->y /2,
mSize->x /2, mSize->y /2,
color,
1
);
break;
}
al_identity_transform(&T);
al_use_transform(&T);
}
/* set up a transformation such that anything drawn will be as if its 'z'
* coordinate was at the specified 'z' */
void t3f_3d_transform_z(float z)
{
float scale = t3f_3d_project_x(1.0, z) - t3f_3d_project_x(0.0, z);
float offset_x = t3f_3d_project_x(0.0, z);
float offset_y = t3f_3d_project_y(0.0, z);
al_identity_transform(&t3f_3d_transform);
al_scale_transform(&t3f_3d_transform, scale, scale);
al_translate_transform(&t3f_3d_transform, offset_x, offset_y);
// al_transform_transform(&t3f_3d_transform, &t3f_current_transform);
al_use_transform(&t3f_3d_transform);
}
void spaceship_draw(Spaceship *s) {
ALLEGRO_TRANSFORM transform;
if(s->gone == DEAD) return;
al_identity_transform(&transform);
al_rotate_transform(&transform, DEGREES(s->heading));
al_translate_transform(&transform, s->sx, s->sy);
al_use_transform(&transform);
al_draw_line(-8, 9, 0, -11, s->color, 3.0f);
al_draw_line(0, -11, 8, 9, s->color, 3.0f);
al_draw_line(-6, 4, -1, 4, s->color, 3.0f);
al_draw_line(6, 4, 1, 4, s->color, 3.0f);
}
void draw_shoots(game *g) {
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_use_transform(&trans);
shoot *pt;
pt = first_s;
while(pt != NULL) {
al_draw_pixel(pt->position->x, pt->position->y, SHOOT_COLOR);
pt = pt->next;
}
}
int main(void)
{
al_init();
ALLEGRO_DISPLAY *d = al_create_display(W, H);
ALLEGRO_VERTEX v[POINTS];
ALLEGRO_COLOR c;
v[0].x = 0;
v[0].y = 0;
c = al_map_rgb(rand()%256, rand()%256, rand()%256);
v[0].color = al_get_prim_color(c);
v[1].x = 0+R;
v[1].y = 0;
c = al_map_rgb(rand()%256, rand()%256, rand()%256);
v[1].color = al_get_prim_color(c);
float a = 0;
float r = R;
int i;
for (i = 2; i < POINTS; i++) {
v[i].x = 0+cos(a)*r;
v[i].y = 0+sin(a)*r;
a += 0.3f;
r -= 1.5f;
c = al_map_rgb(rand()%256, rand()%256, rand()%256);
v[i].color = al_get_prim_color(c);
}
int frames = 0;
ALLEGRO_TRANSFORM t;
while (true) {
al_clear_to_color(al_map_rgb(0, 0, 0));
al_identity_transform(&t);
al_rotate_transform(&t, frames*0.1f);
al_translate_transform(&t, W/2, H/2);
al_use_transform(&t);
al_draw_prim(v, NULL, 0, POINTS, ALLEGRO_PRIM_TRIANGLE_FAN);
al_flip_display();
/* GP2X Wiz is locked to 60FPS using OpenGL */
frames++;
if (frames > 400)
break;
}
al_uninstall_system();
return 0;
}
/** Applies a scale, rotate and translate transformation to all future drawing operations. */
void cbeTransformBuild(CBEnchanted *cb) {
float angle = (cb->popValue().toFloat() / 180.0f) * M_PI;
float scaleY = cb->popValue().toFloat();
float scaleX = cb->popValue().toFloat();
float transY = cb->popValue().toFloat();
float transX = cb->popValue().toFloat();
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_build_transform(&t, transX, transY, scaleX, scaleY, angle);
al_use_transform(&t);
cb->pushValue(0);
}
/* Draw ship */
void draw_ship(Spaceship *s)
{
ALLEGRO_TRANSFORM transform;
al_identity_transform(&transform);
al_rotate_transform(&transform, 0);
al_rotate_transform(&transform, (s->heading * (M_PI/180)));
al_translate_transform(&transform, s->sx, s->sy);
al_use_transform(&transform);
al_draw_line(-8, 9, 0, -11, s->color, 3.0f);
al_draw_line(0, -11, 8, 9, s->color, 3.0f);
al_draw_line(-6, 4, -1, 4, s->color, 3.0f);
al_draw_line(6, 4, 1, 4, s->color, 3.0f);
}
static void _al_draw_transformed_scaled_bitmap_memory(
ALLEGRO_BITMAP *src, ALLEGRO_COLOR tint,
int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, int flags)
{
ALLEGRO_TRANSFORM local_trans;
al_identity_transform(&local_trans);
al_translate_transform(&local_trans, dx, dy);
al_compose_transform(&local_trans, al_get_current_transform());
_al_draw_transformed_bitmap_memory(src, tint, sx, sy, sw, sh, dw, dh,
&local_trans, flags);
}
/* Function: al_store_state
*/
void al_store_state(ALLEGRO_STATE *state, int flags)
{
thread_local_state *tls;
INTERNAL_STATE *stored;
if ((tls = tls_get()) == NULL)
return;
stored = (void *)state;
stored->flags = flags;
if (flags & ALLEGRO_STATE_NEW_DISPLAY_PARAMETERS) {
_STORE(new_display_flags);
_STORE(new_display_refresh_rate);
_STORE(new_display_adapter);
_STORE(new_window_x);
_STORE(new_window_y);
_STORE(new_display_settings);
}
if (flags & ALLEGRO_STATE_NEW_BITMAP_PARAMETERS) {
_STORE(new_bitmap_format);
_STORE(new_bitmap_flags);
}
if (flags & ALLEGRO_STATE_DISPLAY) {
_STORE(current_display);
}
if (flags & ALLEGRO_STATE_TARGET_BITMAP) {
_STORE(target_bitmap);
}
if (flags & ALLEGRO_STATE_BLENDER) {
stored->stored_blender = tls->current_blender;
}
if (flags & ALLEGRO_STATE_NEW_FILE_INTERFACE) {
_STORE(new_file_interface);
_STORE(fs_interface);
}
if (flags & ALLEGRO_STATE_TRANSFORM) {
ALLEGRO_BITMAP *target = al_get_target_bitmap();
if (!target)
al_identity_transform(&stored->stored_transform);
else
stored->stored_transform = target->transform;
}
}
void draw_menu(game *g) {
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_use_transform(&trans);
int x, y;
x = (g->Size->x - 60) / 2;
y = 0;
al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y, ALLEGRO_ALIGN_LEFT, "MENU");
char *msg;
if(g->status == Win || g->status == Lose) {
x = (g->Size->x - 250) / 2;
y = 50;
msg = g->status == Win ? "YOU WON!! GAME OVER" : "YOU LOST. GAME OVER";
al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y, ALLEGRO_ALIGN_LEFT, msg);
}
msg = "'c' to configure";
x = (g->Size->x - 640+100) / 2;
y = (g->Size->y + 5) / 2;
al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y,
ALLEGRO_ALIGN_LEFT, msg);
msg = "Enter to play";
x = (g->Size->x - 640+100) / 2;
y = (g->Size->y + 50) / 2;
al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y,
ALLEGRO_ALIGN_LEFT, msg);
msg = "Escape to exit";
x = (g->Size->x - 640+100) / 2;
y = (g->Size->y + 100) / 2;
al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y,
ALLEGRO_ALIGN_LEFT, msg);
msg = "Use the arrow keys to move and space to shoot";
y = g->Size->y - 130;
x = (g->Size->x - 640+100)/2;
al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y,
ALLEGRO_ALIGN_LEFT, msg);
msg = "If your ship is bold, you cannot be destroyed";
y = g->Size->y - 80;
x = (g->Size->x - 640+100)/2;
al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y,
ALLEGRO_ALIGN_LEFT, msg);
}
void prepareForScreenGrab1()
{
prepareForScreenGrabBackupBitmap = al_get_target_bitmap();
int dx, dy, dw, dh;
get_screen_offset_size(&dx, &dy, &dw, &dh);
m_set_target_bitmap(tmpbuffer);
ALLEGRO_TRANSFORM t;
al_copy_transform(&prepareForScreenGrabBackup, al_get_current_transform());
al_identity_transform(&t);
al_scale_transform(&t, screenScaleX, screenScaleY);
al_translate_transform(&t, dx, dy);
al_use_transform(&t);
preparingForScreenGrab = true;
}
void RenderTarget::useWorldCoords(bool t) {
if (t != worldCoordsEnabled || pixelPreciseWorldCoordsEnabled) {
setAsCurrent();
if (t) {
al_use_transform(CBEnchanted::instance()->cameraInterface->getWorldTransform());
}
else {
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_use_transform(&t);
}
worldCoordsEnabled = t;
pixelPreciseWorldCoordsEnabled = false;
}
}
void draw_ship(game *game) {
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_rotate_transform(&trans, game->Ship->angle);
al_translate_transform(&trans,
(int)game->Ship->position->x,
(int)game->Ship->position->y);
al_use_transform(&trans);
float w = game->Ship->time >= 0 ? 1 : 4;
al_draw_line(-8, 20, 0, 0, SHIP_COLOR, w);
al_draw_line(8, 20, 0, 0, SHIP_COLOR, w);
al_draw_line(-6, 15, -1, 15, SHIP_COLOR, w);
al_draw_line(6, 15, 1, 15, SHIP_COLOR, w);
}
void draw_scene()
{
// setup the render settings
al_set_render_state(ALLEGRO_DEPTH_TEST, 1);
al_set_render_state(ALLEGRO_WRITE_MASK, ALLEGRO_MASK_DEPTH | ALLEGRO_MASK_RGBA);
al_clear_depth_buffer(1);
ALLEGRO_TRANSFORM t;
Entity3D *camera = static_cast<Entity3D *>(scene_root.find_first("name", "camera"));
if (camera) camera->place.build_reverse_transform(&t);
else al_identity_transform(&t);
set_projection(backbuffer_sub_bitmap, &t);
// draw our scene
scene_root._draw();
}
void start_text()
{
if (!text_draw_on) {
text_draw_on = true;
int dx, dy, dw, dh;
get_screen_offset_size(&dx, &dy, &dw, &dh);
al_copy_transform(&old_view, al_get_current_transform());
ALLEGRO_TRANSFORM v;
al_identity_transform(&v);
al_scale_transform(&v, textScaleX, textScaleY);
if (al_get_bitmap_width(al_get_target_bitmap()) == al_get_display_width(display) && al_get_bitmap_height(al_get_target_bitmap()) == al_get_display_height(display)) {
al_translate_transform(&v, dx, dy);
}
al_use_transform(&v);
}
}
/* Function: al_create_sub_bitmap
*/
ALLEGRO_BITMAP *al_create_sub_bitmap(ALLEGRO_BITMAP *parent,
int x, int y, int w, int h)
{
ALLEGRO_BITMAP *bitmap;
if (parent->parent) {
x += parent->xofs;
y += parent->yofs;
parent = parent->parent;
}
if (parent->display && parent->display->vt &&
parent->display->vt->create_sub_bitmap)
{
bitmap = parent->display->vt->create_sub_bitmap(
parent->display, parent, x, y, w, h);
}
else {
bitmap = al_calloc(1, sizeof *bitmap);
bitmap->size = sizeof *bitmap;
bitmap->vt = parent->vt;
}
bitmap->format = parent->format;
bitmap->flags = parent->flags;
bitmap->w = w;
bitmap->h = h;
bitmap->display = parent->display;
bitmap->locked = false;
bitmap->cl = bitmap->ct = 0;
bitmap->cr_excl = w;
bitmap->cb_excl = h;
al_identity_transform(&bitmap->transform);
bitmap->parent = parent;
bitmap->xofs = x;
bitmap->yofs = y;
bitmap->memory = NULL;
if (bitmap->display) {
ALLEGRO_BITMAP **back;
back = _al_vector_alloc_back(&bitmap->display->bitmaps);
*back = bitmap;
}
return bitmap;
}
void m_draw_tinted_scaled_bitmap_identity_view(
MBITMAP *bmp, MCOLOR tint, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, int flags
)
{
ALLEGRO_TRANSFORM backup, t;
al_copy_transform(&backup, al_get_current_transform());
al_identity_transform(&t);
al_use_transform(&t);
al_draw_tinted_scaled_bitmap(
bmp->bitmap,
tint,
sx, sy, sw, sh,
dx, dy, dw, dh,
0
);
al_use_transform(&backup);
}
static void dot_game_create_score_effect(void * data, float x, float y, int number)
{
APP_INSTANCE * app = (APP_INSTANCE *)data;
ALLEGRO_STATE old_state;
ALLEGRO_TRANSFORM identity;
char buf[16] = {0};
int i, j;
ALLEGRO_COLOR c;
unsigned char r, g, b, a;
float ox;
float w, h;
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_clear_to_color(al_map_rgba_f(0.0, 0.0, 0.0, 0.0));
sprintf(buf, "%d", number);
al_set_clipping_rectangle(0, 0, 512, 512);
al_draw_text(app->font[DOT_FONT_16], t3f_color_white, 0, 0, 0, buf);
t3f_set_clipping_rectangle(0, 0, 0, 0);
al_restore_state(&old_state);
al_lock_bitmap(app->bitmap[DOT_BITMAP_SCRATCH], ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY);
ox = al_get_text_width(app->font[DOT_FONT_16], buf) / 2;
w = al_get_text_width(app->font[DOT_FONT_16], buf);
h = al_get_font_line_height(app->font[DOT_FONT_16]);
for(i = 0; i < w; i++)
{
for(j = 0; j < h; j++)
{
c = al_get_pixel(app->bitmap[DOT_BITMAP_SCRATCH], i, j);
al_unmap_rgba(c, &r, &g, &b, &a);
if(a > 0)
{
dot_create_particle(&app->particle[app->current_particle], x + (float)i - ox, y + j, 0.0, dot_spread_effect_particle(i, w, strlen(buf) * 2.5), dot_spread_effect_particle(j, h, 4.0), -10.0, 0.0, 3.0, 45, app->bitmap[DOT_BITMAP_PARTICLE], c);
app->current_particle++;
if(app->current_particle >= DOT_MAX_PARTICLES)
{
app->current_particle = 0;
}
}
}
}
al_unlock_bitmap(app->bitmap[DOT_BITMAP_SCRATCH]);
}
// Updates the aspect ratio when going full-screen or windowed
static void
aspect_ratio_transform(void)
{
int window_w = al_get_display_width(engine.display);
int window_h = al_get_display_height(engine.display);
float sw = (window_w / (float) GAME_W);
float sh = (window_h / (float) GAME_H);
float scale = (sw < sh ? sw : sh);
float scale_w = ((float) GAME_W * scale);
float scale_h = ((float) GAME_H * scale);
int scale_x_pos = (window_w - scale_w) / 2;
int scale_y_pos = (window_h - scale_h) / 2;
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_build_transform(&trans, scale_x_pos, scale_y_pos, scale, scale, 0);
al_use_transform(&trans);
}
void draw_blast(Blast *blast) {
ALLEGRO_TRANSFORM transform;
if(al_get_current_transform() == NULL) {
fprintf(stderr, "no target bitmap.");
}
al_identity_transform(&transform);
al_rotate_transform(&transform, 1.58525 + head2theta(blast->heading));
al_translate_transform(&transform, blast->sx, blast->sy);
al_use_transform(&transform);
/* many small lines will eventually create a dashed line */
al_draw_line(0, 0, 0, -10, blast->color, 3.0f);
al_draw_line(0, -15, 0, -25, blast->color, 3.0f);
al_draw_line(0, -30, 0, -40, blast->color, 3.0f);
al_draw_line(0, -45, 0, -60, blast->color, 3.0f);
al_draw_line(0, -65, 0, -80, blast->color, 3.0f);
al_draw_line(0, -85, 0, -100, blast->color, 3.0f);
al_draw_line(0, -105, 0, -120, blast->color, 3.0f);
}
/* Transform asteroid */
static void draw_roid(Asteroid *roid)
{
ALLEGRO_TRANSFORM transform;
al_identity_transform(&transform);
al_rotate_transform(&transform, (roid->twist * (M_PI/180)));
al_scale_transform(&transform, roid->scale, roid->scale);
al_translate_transform(&transform, roid->sx, roid->sy);
al_use_transform(&transform);
al_draw_line(-22, 20, -18, 4, roid->color, 2.0f);
al_draw_line(-18, 4, -18, -10, roid->color, 2.0f);
al_draw_line(-18, -10, -5, -10, roid->color, 2.0f);
al_draw_line(-5, -10, -10, -22, roid->color, 2.0f);
al_draw_line(-10, -22, 4, -22, roid->color, 2.0f);
al_draw_line(4, -22, 20, -10, roid->color, 2.0f);
al_draw_line(20, -10, 20, -5, roid->color, 2.0f);
al_draw_line(20, -5, 0, 0, roid->color, 2.0f);
al_draw_line(0, 0, 20, 10, roid->color, 2.0f);
al_draw_line(20, 10, 10, 20, roid->color, 2.0f);
al_draw_line(10, 20, 0, 15, roid->color, 2.0f);
al_draw_line(0, 15, -22, 20, roid->color, 2.0f);
}
bool DisplayResource::load(void)
{
#ifdef ALLEGRO_IPHONE
int flags = ALLEGRO_FULLSCREEN_WINDOW;
al_set_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS, ALLEGRO_DISPLAY_ORIENTATION_LANDSCAPE, ALLEGRO_REQUIRE);
#else
int flags = useFullScreenMode ? ALLEGRO_FULLSCREEN : ALLEGRO_WINDOWED;
#endif
al_set_new_display_flags(flags);
display = al_create_display(BB_W, BB_H);
if (!display)
return false;
#ifndef ALLEGRO_IPHONE
ALLEGRO_BITMAP *bmp = al_load_bitmap(getResource("gfx/icon48.png"));
al_set_display_icon(display, bmp);
al_destroy_bitmap(bmp);
#endif
BB_W = al_get_display_width(display);
BB_H = al_get_display_height(display);
#ifdef ALLEGRO_IPHONE
if (BB_W < 960) {
BB_W *= 2;
BB_H *= 2;
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_scale_transform(&t, 0.5, 0.5);
al_use_transform(&t);
}
#endif
events = al_create_event_queue();
al_register_event_source(events, al_get_display_event_source(display));
return true;
}
