/* Creates a memory bitmap.
*/
static ALLEGRO_BITMAP *_al_create_memory_bitmap(int w, int h)
{
ALLEGRO_BITMAP *bitmap;
int pitch;
int format = al_get_new_bitmap_format();
format = _al_get_real_pixel_format(al_get_current_display(), format);
bitmap = al_calloc(1, sizeof *bitmap);
bitmap->size = sizeof(*bitmap);
pitch = w * al_get_pixel_size(format);
bitmap->vt = NULL;
bitmap->format = format;
bitmap->flags = (al_get_new_bitmap_flags() | ALLEGRO_MEMORY_BITMAP) &
~ALLEGRO_VIDEO_BITMAP;
bitmap->w = w;
bitmap->h = h;
bitmap->pitch = pitch;
bitmap->display = NULL;
bitmap->locked = false;
bitmap->cl = bitmap->ct = 0;
bitmap->cr_excl = w;
bitmap->cb_excl = h;
al_identity_transform(&bitmap->transform);
bitmap->parent = NULL;
bitmap->xofs = bitmap->yofs = 0;
bitmap->memory = al_malloc(pitch * h);
bitmap->preserve_texture = !(al_get_new_bitmap_flags() & ALLEGRO_NO_PRESERVE_TEXTURE);
return bitmap;
}
Overlay::Overlay(renderer* parent) : parent(parent)
{
{
CoreSuspender suspend;
//parent->zoom(df::zoom_commands::zoom_reset);
good_viewscreen = false;
ReadTileLocations();
copy_from_inner();
}
front_mutex = al_create_mutex();
int32_t flags = al_get_new_bitmap_flags();
if(al_get_current_display() != NULL){
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_ALPHA_TEST);
}
front = al_create_bitmap(0,0);
if(al_get_current_display() != NULL){
al_set_new_bitmap_flags(al_get_bitmap_flags(al_get_backbuffer(al_get_current_display())));
}
back = al_create_bitmap(0,0);
al_set_new_bitmap_flags(flags);
Flip();
};
void _reload_loaded_bitmaps_delayed(void)
{
int flags = al_get_new_bitmap_flags();
int format = al_get_new_bitmap_format();
for (size_t i = 0; i < loaded_bitmaps.size(); i++) {
MBITMAP *m = loaded_bitmaps[i]->bitmap;
if ((loaded_bitmaps[i]->flags & ALLEGRO_NO_PRESERVE_TEXTURE) && loaded_bitmaps[i]->delayed) {
al_set_new_bitmap_flags(loaded_bitmaps[i]->flags);
al_set_new_bitmap_format(loaded_bitmaps[i]->format);
if (loaded_bitmaps[i]->load_type == LOAD_LOAD) {
m->bitmap = my_load_bitmap(loaded_bitmaps[i]->load.filename.c_str());
if (loaded_bitmaps[i]->load.redraw) {
loaded_bitmaps[i]->load.redraw(m, loaded_bitmaps[i]->load.data);
}
}
else { // create
Recreate *d = &loaded_bitmaps[i]->recreate;
m->bitmap = my_al_create_bitmap(d->w, d->h);
if (d->func) { // recreate with func
d->func(m, d->data);
}
}
al_use_shader(NULL);
}
}
al_set_new_bitmap_flags(flags);
al_set_new_bitmap_format(format);
}
void Overlay::Flip()
{
//do the starting timer stuff
clock_t starttime = clock();
al_lock_mutex(front_mutex);
{
al_unlock_bitmap(front);
if(al_get_bitmap_width(front) != ssState.ScreenW
|| al_get_bitmap_height(front) != ssState.ScreenH){
al_destroy_bitmap(front);
int32_t flags = al_get_new_bitmap_flags();
if(al_get_current_display() != NULL){
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_ALPHA_TEST);
}
front = al_create_bitmap(ssState.ScreenW, ssState.ScreenH);
al_set_new_bitmap_flags(flags);
}
al_set_target_bitmap(front);
al_draw_bitmap(back, 0, 0, 0);
front_data = al_lock_bitmap(front,
al_get_bitmap_format(front), ALLEGRO_LOCK_READONLY);
}
front_updated = true;
al_unlock_mutex(front_mutex);
if(al_get_bitmap_width(back) != ssState.ScreenW
|| al_get_bitmap_height(back) != ssState.ScreenH){
al_destroy_bitmap(back);
int32_t flags = al_get_new_bitmap_flags();
if(al_get_current_display() != NULL){
al_set_new_bitmap_flags(al_get_bitmap_flags(al_get_backbuffer(al_get_current_display())));
}
back = al_create_bitmap(ssState.ScreenW, ssState.ScreenH);
al_set_new_bitmap_flags(flags);
}
al_set_target_bitmap(back);
//do the ending timer stuff
clock_t donetime = clock();
ssTimers.overlay_time = (donetime - starttime)*0.1 + ssTimers.overlay_time*0.9;
}
MBITMAP *m_create_alpha_bitmap(int w, int h, void (*create)(MBITMAP *bitmap, RecreateData *), RecreateData *data, void (*destroy)(MBITMAP *b), bool delayed) // check
{
int f = al_get_new_bitmap_format();
al_set_new_bitmap_format(ALPHA_FMT);
ALLEGRO_BITMAP *bitmap;
int flags = al_get_new_bitmap_flags();
int new_flags = flags;
if (config.getUseOnlyMemoryBitmaps()) {
al_set_new_bitmap_flags(new_flags|ALLEGRO_MEMORY_BITMAP);
bitmap = my_al_create_bitmap(w, h);
}
else {
bitmap = my_al_create_bitmap(w, h);
}
al_set_new_bitmap_flags(flags);
al_set_new_bitmap_format(f);
MBITMAP *m = new_mbitmap(bitmap);
if (create) {
create(m, data);
}
#if defined ALLEGRO_ANDROID || defined ALLEGRO_WINDOWS
if (
#ifdef ALLEGRO_WINDOWS
(al_get_display_flags(display) & ALLEGRO_DIRECT3D) &&
#endif
(al_get_bitmap_flags(bitmap) & ALLEGRO_NO_PRESERVE_TEXTURE) &&
!(al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP)
) {
LoadedBitmap *lb = new LoadedBitmap;
null_lb(lb);
lb->load_type = LOAD_CREATE;
lb->flags = al_get_bitmap_flags(bitmap);
lb->format = al_get_bitmap_format(bitmap);
lb->destroy.func = destroy;
lb->recreate.func = create;
lb->recreate.data = data;
lb->recreate.w = w;
lb->recreate.h = h;
lb->bitmap = m;
lb->delayed = delayed;
loaded_bitmaps.push_back(lb);
}
else {
#endif
if (data) {
delete data;
}
#if defined ALLEGRO_ANDROID || defined ALLEGRO_WINDOWS
}
#endif
return m;
}
/* Run the FPS test. */
static void run(void)
{
ALLEGRO_EVENT event;
int frames = 0;
double start;
target = al_create_bitmap(W, H);
al_set_target_bitmap(target);
al_clear_to_color(al_map_rgba_f(1, 1, 0, 1));
al_set_target_backbuffer(display);
dx = 81;
dy = 63;
start = al_get_time();
while (true) {
/* Check for ESC key or close button event and quit in either case. */
if (!al_is_event_queue_empty(queue)) {
while (al_get_next_event(queue, &event)) {
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
quit = true;
goto done;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
quit = true;
goto done;
}
if (event.keyboard.keycode == ALLEGRO_KEY_SPACE) {
goto done;
}
break;
}
}
}
draw();
print(0, 0, "FPS: %.1f", frames / (al_get_time() - start));
if (al_get_new_bitmap_flags() & ALLEGRO_FORCE_LOCKING) {
print(0, al_get_font_line_height(myfont), "using forced bitmap locking");
}
else {
print(0, al_get_font_line_height(myfont), "drawing directly to bitmap");
}
print(0, al_get_font_line_height(myfont) * 2,
"Press SPACE to toggle drawing method.");
al_flip_display();
frames++;
}
done:
al_destroy_bitmap(target);
}
/* Function: al_load_bitmap_font
*/
ALLEGRO_FONT *al_load_bitmap_font(const char *fname)
{
int flags = 0;
/* For backwards compatibility with the 5.0 branch. */
if (al_get_new_bitmap_flags() & ALLEGRO_NO_PREMULTIPLIED_ALPHA) {
flags |= ALLEGRO_NO_PREMULTIPLIED_ALPHA;
}
return _al_load_bitmap_font(fname, 0, flags);
}
/* The menu item owns the icon bitmap. It is converted to a memory bitmap
* when set to make sure any system threads will be able to read the data.
*/
static void set_item_icon(ALLEGRO_MENU_ITEM *item, ALLEGRO_BITMAP *icon)
{
item->icon = icon;
if (icon && al_get_bitmap_flags(item->icon) & ALLEGRO_VIDEO_BITMAP) {
int old_flags = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
item->icon = al_clone_bitmap(icon);
al_destroy_bitmap(icon);
al_set_new_bitmap_flags(old_flags);
}
}
/* Function: al_create_bitmap
*/
ALLEGRO_BITMAP *al_create_bitmap(int w, int h)
{
ALLEGRO_BITMAP *bitmap;
bitmap = _al_create_bitmap_params(al_get_current_display(), w, h,
al_get_new_bitmap_format(), al_get_new_bitmap_flags());
if (bitmap) {
_al_register_destructor(_al_dtor_list, "bitmap", bitmap,
(void (*)(void *))al_destroy_bitmap);
}
return bitmap;
}
bool Imgui_ImplA5_CreateDeviceObjects()
{
ImGuiIO &io = ImGui::GetIO();
// Build texture
unsigned char *pixels;
int width, height;
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
// Create texture
int flags = al_get_new_bitmap_flags();
int fmt = al_get_new_bitmap_format();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP|ALLEGRO_MIN_LINEAR|ALLEGRO_MAG_LINEAR);
al_set_new_bitmap_format(ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE);
ALLEGRO_BITMAP* img = al_create_bitmap(width, height);
al_set_new_bitmap_flags(flags);
al_set_new_bitmap_format(fmt);
if (!img)
return false;
ALLEGRO_LOCKED_REGION *locked_img = al_lock_bitmap(img, al_get_bitmap_format(img), ALLEGRO_LOCK_WRITEONLY);
if (!locked_img)
{
al_destroy_bitmap(img);
return false;
}
memcpy(locked_img->data, pixels, sizeof(int)*width*height);
al_unlock_bitmap(img);
// Convert software texture to hardware texture.
ALLEGRO_BITMAP* cloned_img = al_clone_bitmap(img);
al_destroy_bitmap(img);
if (!cloned_img)
return false;
// Store our identifier
io.Fonts->TexID = (void*)cloned_img;
g_Texture = cloned_img;
// Cleanup (don't clear the input data if you want to append new fonts later)
io.Fonts->ClearInputData();
io.Fonts->ClearTexData();
// Create an invisible mouse cursor
// Because al_hide_mouse_cursor() seems to mess up with the actual inputs..
ALLEGRO_BITMAP* mouse_cursor = al_create_bitmap(8,8);
g_MouseCursorInvisible = al_create_mouse_cursor(mouse_cursor, 0, 0);
al_destroy_bitmap(mouse_cursor);
return true;
}
ALLEGRO_BITMAP *Object::create_memory_bitmap()
{
setBit(ER_BITMAP);
setBit(ISMEM_BITMAP);
int flags = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(flags | ALLEGRO_MEMORY_BITMAP);
ALLEGRO_BITMAP *bmp;
bmp = al_create_bitmap(w, h);
al_set_new_bitmap_flags(flags);
return bmp;
}
MBITMAP *create_trapezoid(int dir, int topw, int bottomw, int length, MCOLOR color)
{
MBITMAP *b;
color.a = 1.0f;
m_push_target_bitmap();
int flgs = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(flgs & ~ALLEGRO_NO_PRESERVE_TEXTURE);
if (dir == DIRECTION_NORTH) {
b = m_create_bitmap(bottomw, length); // check
}
else if (dir == DIRECTION_EAST) {
b = m_create_bitmap(length, bottomw); // check
}
else if (dir == DIRECTION_SOUTH) {
b = m_create_bitmap(bottomw, length); // check
}
else {
b = m_create_bitmap(length, bottomw); // check
}
al_set_new_bitmap_flags(flgs);
m_set_target_bitmap(b);
m_clear(m_map_rgba(0, 0, 0, 0));
float y = get_trap_peak(topw, bottomw, length);
if (dir == DIRECTION_NORTH) {
m_draw_triangle(bottomw/2, length+y-1, 0, 0, bottomw-1, 0, color);
}
else if (dir == DIRECTION_EAST) {
m_draw_triangle(-y, bottomw/2, length-1, 0, length-1, bottomw-1, color);
}
else if (dir == DIRECTION_SOUTH) {
m_draw_triangle(bottomw/2, -y, bottomw-1, length-1, 0, length-1, color);
}
else if (dir == DIRECTION_WEST) {
m_draw_triangle(length+y-1, bottomw/2, 0, 0, 0, bottomw-1, color);
}
m_pop_target_bitmap();
return b;
}
MBITMAP *m_load_bitmap(const char *name, bool force_memory, bool ok_to_fail)
{
ALLEGRO_BITMAP *bitmap = 0;
int flags = al_get_new_bitmap_flags();
if (force_memory || config.getUseOnlyMemoryBitmaps()) {
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
}
else {
al_set_new_bitmap_flags((flags & ~ALLEGRO_MEMORY_BITMAP));
}
bitmap = my_load_bitmap(name, ok_to_fail);
al_set_new_bitmap_flags(flags);
if (!bitmap) {
return NULL;
}
MBITMAP *m = new_mbitmap(bitmap);
#if defined ALLEGRO_ANDROID || defined ALLEGRO_WINDOWS
if (
#ifdef ALLEGRO_WINDOWS
(al_get_display_flags(display) & ALLEGRO_DIRECT3D) &&
#endif
(al_get_bitmap_flags(bitmap) & ALLEGRO_NO_PRESERVE_TEXTURE) &&
!(al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP)
) {
LoadedBitmap *lb = new LoadedBitmap;
null_lb(lb);
lb->load_type = LOAD_LOAD;
lb->flags = al_get_bitmap_flags(bitmap);
lb->format = al_get_bitmap_format(bitmap);
lb->load.filename = name;
lb->load.redraw = NULL;
lb->load.data = NULL;
lb->bitmap = m;
loaded_bitmaps.push_back(lb);
}
#endif
return m;
}
BigBitmap::BigBitmap(std::string bitmap_to_load, float sector_width, float sector_height) : region_size_w(sector_width), region_size_h(sector_height)
{
ALLEGRO_BITMAP *restoreto =al_get_target_bitmap();
orig_flags = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR);
big_bitmap = al_load_bitmap(bitmap_to_load.c_str());
if(big_bitmap == nullptr)
{
al_show_native_message_box(NULL, "Error", "Failed to load Image", bitmap_to_load.c_str(), NULL, ALLEGRO_MESSAGEBOX_ERROR);
}
orig_width = width = al_get_bitmap_width(big_bitmap);
orig_height = height = al_get_bitmap_height(big_bitmap);
w_regions = ceil(orig_width / region_size_w);
h_regions = ceil(orig_height / region_size_h);
float vector_size = w_regions+1 + h_regions+1;
bitmaps.reserve(vector_size);
al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP | ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR);
for(int h = 0; h < h_regions; h++)
{
for(int w = 0; w < w_regions; w++)
{
bitmaps.push_back(al_create_bitmap(region_size_w, region_size_h));
al_set_target_bitmap(bitmaps[bitmaps.size()-1]);
al_clear_to_color(al_map_rgb(0,0,0));
al_draw_bitmap_region(big_bitmap, w*region_size_w, h*region_size_h, region_size_w, region_size_h, 0, 0, 0);
#ifdef _BBDEBUG
std::string cont = "["+ std::to_string(h) +","+ std::to_string(w) +"]";
al_draw_text(dgbf, al_map_rgb(255,0,0),region_size_w/2,region_size_h/2,ALLEGRO_ALIGN_CENTRE,cont.c_str());
al_draw_rectangle(0,0,region_size_w, region_size_h, al_map_rgb(255,0,0),0);
#endif // _BBDEBUG
}
}
al_set_new_bitmap_flags(orig_flags);
al_set_target_bitmap(restoreto);
}
MFONT *m_load_font(const char *name)
{
ALLEGRO_FONT *f;
int flags = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(flags & ~ALLEGRO_NO_PRESERVE_TEXTURE);
f = al_load_font(name, 0, 0);
if (f) {
al_set_new_bitmap_flags(flags);
return f;
}
debug_message("couldn't load font: using mem bitmaps");
al_set_new_bitmap_flags(flags|ALLEGRO_MEMORY_BITMAP);
f = al_load_font(name, 0, 0);
al_set_new_bitmap_flags(flags);
return f;
}
int main(void)
{
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_init_primitives_addon();
al_install_keyboard();
al_init_image_addon();
al_init_font_addon();
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display\n");
return 1;
}
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
myfont = al_load_font("data/font.tga", 0, 0);
if (!myfont) {
abort_example("font.tga not found\n");
return 1;
}
while (!quit) {
if (al_get_new_bitmap_flags() & ALLEGRO_FORCE_LOCKING)
al_set_new_bitmap_flags(ALLEGRO_VIDEO_BITMAP);
else
al_set_new_bitmap_flags(ALLEGRO_FORCE_LOCKING);
run();
}
al_destroy_event_queue(queue);
return 0;
}
static int allua_Bitmap_get_new_flags(lua_State * L)
{
lua_pushinteger(L, al_get_new_bitmap_flags());
return 1;
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP* bkg;
ALLEGRO_COLOR black;
ALLEGRO_EVENT_QUEUE *queue;
// Initialize Allegro 5 and addons
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_init_image_addon();
al_init_font_addon();
al_init_primitives_addon();
// Create a window to display things on: 640x480 pixels
display = al_create_display(ScreenW, ScreenH);
if (!display) {
abort_example("Error creating display.\n");
return 1;
}
// Install the keyboard handler
if (!al_install_keyboard()) {
abort_example("Error installing keyboard.\n");
return 1;
}
if (!al_install_mouse()) {
abort_example("Error installing mouse.\n");
return 1;
}
// Load a font
Font = al_load_font("data/fixed_font.tga", 0, 0);
if (!Font) {
abort_example("Error loading \"data/fixed_font.tga\".\n");
return 1;
}
solid_white = al_map_rgba_f(1, 1, 1, 1);
bkg = al_load_bitmap("data/bkg.png");
Texture = al_load_bitmap("data/texture.tga");
// Make and set some color to draw with
black = al_map_rgba_f(0.0, 0.0, 0.0, 1.0);
// Start the event queue to handle keyboard input and our timer
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_mouse_event_source());
al_set_window_title(display, "Primitives Example");
{
int refresh_rate = 60;
int frames_done = 0;
double time_diff = al_get_time();
double fixed_timestep = 1.0f / refresh_rate;
double real_time = al_get_time();
double game_time = al_get_time();
int ii;
int cur_screen = 0;
bool done = false;
int clip = 0;
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *timer_queue;
int old;
timer = al_create_timer(ALLEGRO_BPS_TO_SECS(refresh_rate));
al_start_timer(timer);
timer_queue = al_create_event_queue();
al_register_event_source(timer_queue, al_get_timer_event_source(timer));
old = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
Buffer = al_create_bitmap(ScreenW, ScreenH);
al_set_new_bitmap_flags(old);
al_identity_transform(&Identity);
Screens[0] = LowPrimitives;
Screens[1] = IndexedPrimitives;
Screens[2] = HighPrimitives;
Screens[3] = TransformationsPrimitives;
Screens[4] = FilledPrimitives;
Screens[5] = IndexedFilledPrimitives;
Screens[6] = HighFilledPrimitives;
Screens[7] = TexturePrimitives;
Screens[8] = FilledTexturePrimitives;
Screens[9] = CustomVertexFormatPrimitives;
ScreenName[0] = "Low Level Primitives";
ScreenName[1] = "Indexed Primitives";
ScreenName[2] = "High Level Primitives";
ScreenName[3] = "Transformations";
ScreenName[4] = "Low Level Filled Primitives";
ScreenName[5] = "Indexed Filled Primitives";
ScreenName[6] = "High Level Filled Primitives";
ScreenName[7] = "Textured Primitives";
ScreenName[8] = "Filled Textured Primitives";
ScreenName[9] = "Custom Vertex Format";
for (ii = 0; ii < NUM_SCREENS; ii++)
Screens[ii](INIT);
while (!done) {
double frame_duration = al_get_time() - real_time;
al_rest(fixed_timestep - frame_duration); //rest at least fixed_dt
frame_duration = al_get_time() - real_time;
real_time = al_get_time();
if (real_time - game_time > frame_duration) { //eliminate excess overflow
game_time += fixed_timestep * floor((real_time - game_time) / fixed_timestep);
}
while (real_time - game_time >= 0) {
ALLEGRO_EVENT key_event;
double start_time = al_get_time();
game_time += fixed_timestep;
Screens[cur_screen](LOGIC);
while (al_get_next_event(queue, &key_event)) {
switch (key_event.type) {
case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN: {
cur_screen++;
if (cur_screen >= NUM_SCREENS) {
cur_screen = 0;
}
break;
}
case ALLEGRO_EVENT_DISPLAY_CLOSE: {
done = true;
break;
}
case ALLEGRO_EVENT_KEY_CHAR: {
switch (key_event.keyboard.keycode) {
case ALLEGRO_KEY_ESCAPE: {
done = true;
break;
}
case ALLEGRO_KEY_S: {
Soft = !Soft;
time_diff = al_get_time();
frames_done = 0;
break;
}
case ALLEGRO_KEY_C: {
clip = !clip;
time_diff = al_get_time();
frames_done = 0;
break;
}
case ALLEGRO_KEY_L: {
Blend = !Blend;
time_diff = al_get_time();
frames_done = 0;
break;
}
case ALLEGRO_KEY_B: {
Background = !Background;
time_diff = al_get_time();
frames_done = 0;
break;
}
case ALLEGRO_KEY_LEFT: {
Speed -= ROTATE_SPEED;
break;
}
case ALLEGRO_KEY_RIGHT: {
Speed += ROTATE_SPEED;
break;
}
case ALLEGRO_KEY_PGUP: {
Thickness += 0.5f;
if (Thickness < 1.0f)
Thickness = 1.0f;
break;
}
case ALLEGRO_KEY_PGDN: {
Thickness -= 0.5f;
if (Thickness < 1.0f)
Thickness = 0.0f;
break;
}
case ALLEGRO_KEY_UP: {
cur_screen++;
if (cur_screen >= NUM_SCREENS) {
cur_screen = 0;
}
break;
}
case ALLEGRO_KEY_SPACE: {
Speed = 0;
break;
}
case ALLEGRO_KEY_DOWN: {
cur_screen--;
if (cur_screen < 0) {
cur_screen = NUM_SCREENS - 1;
}
break;
}
}
}
}
}
if (al_get_time() - start_time >= fixed_timestep) { //break if we start taking too long
break;
}
}
al_clear_to_color(black);
if (Soft == 1) {
al_set_target_bitmap(Buffer);
al_clear_to_color(black);
}
if (Background && bkg) {
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
al_draw_scaled_bitmap(bkg, 0, 0, al_get_bitmap_width(bkg), al_get_bitmap_height(bkg), 0, 0, ScreenW, ScreenH, 0);
}
if (clip == 1) {
al_set_clipping_rectangle(ScreenW / 2, ScreenH / 2, ScreenW / 2, ScreenH / 2);
}
Screens[cur_screen](DRAW);
al_set_clipping_rectangle(0, 0, ScreenW, ScreenH);
if (Soft == 1) {
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
al_set_target_backbuffer(display);
al_draw_bitmap(Buffer, 0, 0, 0);
}
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
al_draw_textf(Font, solid_white, ScreenW / 2, ScreenH - 20, ALLEGRO_ALIGN_CENTRE, "%s", ScreenName[cur_screen]);
al_draw_textf(Font, solid_white, 0, 0, 0, "FPS: %f", (float)frames_done / (al_get_time() - time_diff));
al_draw_textf(Font, solid_white, 0, 20, 0, "Change Screen (Up/Down). Esc to Quit.");
al_draw_textf(Font, solid_white, 0, 40, 0, "Rotation (Left/Right/Space): %f", Speed);
al_draw_textf(Font, solid_white, 0, 60, 0, "Thickness (PgUp/PgDown): %f", Thickness);
al_draw_textf(Font, solid_white, 0, 80, 0, "Software (S): %d", Soft);
al_draw_textf(Font, solid_white, 0, 100, 0, "Blending (L): %d", Blend);
al_draw_textf(Font, solid_white, 0, 120, 0, "Background (B): %d", Background);
al_draw_textf(Font, solid_white, 0, 140, 0, "Clip (C): %d", clip);
al_flip_display();
frames_done++;
}
}
return 0;
}
static ALLEGRO_BITMAP *do_create_bitmap(int w, int h)
{
ALLEGRO_BITMAP *bitmap;
ALLEGRO_BITMAP **back;
ALLEGRO_SYSTEM *system = al_get_system_driver();
ALLEGRO_DISPLAY *current_display = al_get_current_display();
int64_t mul;
/* Reject bitmaps where a calculation pixel_size*w*h would overflow
* int. Supporting such bitmaps would require a lot more work.
*/
mul = 4 * (int64_t) w * (int64_t) h;
if (mul > (int64_t) INT_MAX) {
ALLEGRO_WARN("Rejecting %dx%d bitmap\n", w, h);
return NULL;
}
if ((al_get_new_bitmap_flags() & ALLEGRO_MEMORY_BITMAP) ||
(!current_display || !current_display->vt || current_display->vt->create_bitmap == NULL) ||
(system->displays._size < 1)) {
return _al_create_memory_bitmap(w, h);
}
/* Else it's a display bitmap */
bitmap = current_display->vt->create_bitmap(current_display, w, h);
if (!bitmap) {
ALLEGRO_ERROR("failed to create display bitmap\n");
return NULL;
}
/* XXX the ogl_display driver sets some of these variables. It's not clear
* who should be responsible for setting what.
* The pitch must be set by the driver.
*/
bitmap->display = current_display;
bitmap->w = w;
bitmap->h = h;
bitmap->locked = false;
bitmap->cl = 0;
bitmap->ct = 0;
bitmap->cr_excl = w;
bitmap->cb_excl = h;
al_identity_transform(&bitmap->transform);
bitmap->parent = NULL;
bitmap->xofs = 0;
bitmap->yofs = 0;
bitmap->preserve_texture = !(al_get_new_bitmap_flags() & ALLEGRO_NO_PRESERVE_TEXTURE);
ASSERT(bitmap->pitch >= w * al_get_pixel_size(bitmap->format));
/* The display driver should have set the bitmap->memory field if
* appropriate; video bitmaps may leave it NULL.
*/
if (!bitmap->vt->upload_bitmap(bitmap)) {
al_destroy_bitmap(bitmap);
return NULL;
}
/* We keep a list of bitmaps depending on the current display so that we can
* convert them to memory bimaps when the display is destroyed. */
back = _al_vector_alloc_back(¤t_display->bitmaps);
*back = bitmap;
return bitmap;
}
static inline void HandleEvent(struct Game* game, ALLEGRO_EVENT* ev) {
switch (ev->type) {
case ALLEGRO_EVENT_DISPLAY_HALT_DRAWING:
PauseExecution(game);
al_acknowledge_drawing_halt(game->display);
break;
case ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING:
al_acknowledge_drawing_resume(game->display);
ReloadGamestates(game);
ResumeExecution(game);
break;
case ALLEGRO_EVENT_DISPLAY_SWITCH_OUT:
if (game->config.autopause) {
PrintConsole(game, "Focus lost, autopausing...");
PauseExecution(game);
}
break;
case ALLEGRO_EVENT_DISPLAY_SWITCH_IN:
if (game->config.autopause) {
if (game->config.debug.enabled && game->config.debug.livereload) {
ReloadCode(game);
}
ResumeExecution(game);
}
break;
case ALLEGRO_EVENT_DISPLAY_RESIZE:
PrintConsole(game, "Resize event: %dx%d", ev->display.width, ev->display.height);
#ifdef LIBSUPERDERPY_IMGUI
ImGui_ImplAllegro5_InvalidateDeviceObjects();
#endif
al_acknowledge_resize(game->display);
#ifdef LIBSUPERDERPY_IMGUI
ImGui_ImplAllegro5_CreateDeviceObjects();
#endif
// SetupViewport can be expensive, so don't do it when the resize event is already outdated or doesn't change anything
if (((ev->display.width != game->_priv.window_width) || (ev->display.height != game->_priv.window_height)) &&
(ev->display.width == al_get_display_width(game->display)) && (ev->display.height == al_get_display_height(game->display))) {
SetupViewport(game);
}
break;
case ALLEGRO_EVENT_KEY_DOWN:
#ifdef ALLEGRO_ANDROID
if ((ev->keyboard.keycode == ALLEGRO_KEY_MENU) || (ev->keyboard.keycode == ALLEGRO_KEY_TILDE) || (ev->keyboard.keycode == ALLEGRO_KEY_BACKQUOTE)) {
#else
if ((ev->keyboard.keycode == ALLEGRO_KEY_TILDE) || (ev->keyboard.keycode == ALLEGRO_KEY_BACKQUOTE)) {
#endif
game->_priv.showconsole = !game->_priv.showconsole;
if ((ev->keyboard.modifiers & ALLEGRO_KEYMOD_CTRL) && (game->config.debug.enabled)) {
game->_priv.showtimeline = game->_priv.showconsole;
}
}
if (ev->keyboard.keycode == ALLEGRO_KEY_F12) {
DrawGamestates(game);
int flags = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
ALLEGRO_BITMAP* bitmap = al_create_bitmap(al_get_display_width(game->display), al_get_display_height(game->display));
al_set_new_bitmap_flags(flags);
ALLEGRO_BITMAP* target = al_get_target_bitmap();
al_set_target_bitmap(bitmap);
al_draw_bitmap(al_get_backbuffer(game->display), 0, 0, 0);
al_set_target_bitmap(target);
PrintConsole(game, "Screenshot made! Storing...");
struct ScreenshotThreadData* data = malloc(sizeof(struct ScreenshotThreadData));
data->game = game;
data->bitmap = bitmap;
#ifndef LIBSUPERDERPY_SINGLE_THREAD
al_run_detached_thread(ScreenshotThread, data);
#else
ScreenshotThread(data);
#endif
}
break;
default:
break;
}
#ifdef MAEMO5
// on Maemo we get mouse events instead of touch ones, so we'll rewrite them by ourselves
if ((ev->type == ALLEGRO_EVENT_MOUSE_AXES) || (ev->type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) || (ev->type == ALLEGRO_EVENT_MOUSE_BUTTON_UP)) {
switch (ev->type) {
case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:
ev->type = ALLEGRO_EVENT_TOUCH_BEGIN;
break;
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
ev->type = ALLEGRO_EVENT_TOUCH_END;
break;
case ALLEGRO_EVENT_MOUSE_AXES:
ev->type = ALLEGRO_EVENT_TOUCH_MOVE;
break;
default:
break;
}
ALLEGRO_DISPLAY* display = ev->mouse.display;
float dx = ev->mouse.dx;
float dy = ev->mouse.dy;
float x = ev->mouse.x;
float y = ev->mouse.y;
double timestamp = ev->mouse.timestamp;
ev->touch.display = display;
ev->touch.dx = dx;
ev->touch.dy = dy;
ev->touch.id = 0;
ev->touch.primary = true;
ev->touch.source = (ALLEGRO_TOUCH_INPUT*)al_get_touch_input_event_source();
ev->touch.timestamp = timestamp;
ev->touch.x = x;
ev->touch.y = y;
}
#endif
}
static inline void HandleDebugEvent(struct Game* game, ALLEGRO_EVENT* ev) {
switch (ev->type) {
case ALLEGRO_EVENT_KEY_DOWN:
switch (ev->keyboard.keycode) {
case ALLEGRO_KEY_F1:
if (!game->_priv.paused) {
PauseExecution(game);
} else {
ReloadCode(game);
ResumeExecution(game);
}
break;
case ALLEGRO_KEY_F9:
game->_priv.speed = ALLEGRO_BPS_TO_SECS(60.0);
game->_priv.showconsole = true;
PrintConsole(game, "DEBUG: Gameplay speed: 1.00x");
break;
case ALLEGRO_KEY_F10: {
double speed = ALLEGRO_BPS_TO_SECS(game->_priv.speed); // inverting
speed -= 10;
if (speed < 10) { speed = 10; }
game->_priv.speed = ALLEGRO_BPS_TO_SECS(speed);
game->_priv.showconsole = true;
PrintConsole(game, "DEBUG: Gameplay speed: %.2fx", speed / 60.0);
} break;
case ALLEGRO_KEY_F11: {
double speed = ALLEGRO_BPS_TO_SECS(game->_priv.speed); // inverting
speed += 10;
if (speed > 600) { speed = 600; }
game->_priv.speed = ALLEGRO_BPS_TO_SECS(speed);
game->_priv.showconsole = true;
PrintConsole(game, "DEBUG: Gameplay speed: %.2fx", speed / 60.0);
} break;
}
break;
default:
break;
}
}
static inline bool MainloopEvents(struct Game* game) {
do {
ALLEGRO_EVENT ev;
if (game->_priv.paused && !IS_EMSCRIPTEN) {
// there's no frame flipping when paused, so avoid pointless busylooping
al_wait_for_event(game->_priv.event_queue, &ev);
} else if (!al_get_next_event(game->_priv.event_queue, &ev)) {
break;
}
#ifdef LIBSUPERDERPY_IMGUI
ImGui_ImplAllegro5_ProcessEvent(&ev);
switch (ev.type) {
case ALLEGRO_EVENT_KEY_CHAR:
case ALLEGRO_EVENT_KEY_DOWN:
case ALLEGRO_EVENT_KEY_UP:
if (igGetIO()->WantCaptureKeyboard) {
continue;
}
break;
case ALLEGRO_EVENT_MOUSE_AXES:
case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
case ALLEGRO_EVENT_TOUCH_BEGIN:
case ALLEGRO_EVENT_TOUCH_CANCEL:
case ALLEGRO_EVENT_TOUCH_END:
case ALLEGRO_EVENT_TOUCH_MOVE:
if (igGetIO()->WantCaptureMouse) {
continue;
}
break;
default:
break;
}
#endif
if (game->_priv.params.handlers.event) {
if ((*game->_priv.params.handlers.event)(game, &ev)) {
continue;
}
}
if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
EventGamestates(game, &ev);
return false;
}
HandleEvent(game, &ev);
if (game->config.debug.enabled) {
HandleDebugEvent(game, &ev);
}
EventGamestates(game, &ev);
} while (!al_is_event_queue_empty(game->_priv.event_queue));
return true;
}
static inline bool MainloopTick(struct Game* game) {
if (game->_priv.paused) {
return true;
}
struct Gamestate* tmp = game->_priv.gamestates;
#ifdef __EMSCRIPTEN__
emscripten_pause_main_loop();
#endif
game->_priv.loading.to_load = 0;
game->_priv.loading.loaded = 0;
game->_priv.loading.lock = true;
game->loading.progress = 0;
// TODO: support gamestate dependences/ordering
while (tmp) {
if (tmp->pending_stop) {
PrintConsole(game, "Stopping gamestate \"%s\"...", tmp->name);
game->_priv.current_gamestate = tmp;
(*tmp->api->stop)(game, tmp->data);
tmp->started = false;
tmp->pending_stop = false;
PrintConsole(game, "Gamestate \"%s\" stopped successfully.", tmp->name);
}
if (tmp->pending_load) { game->_priv.loading.to_load++; }
tmp = tmp->next;
}
tmp = game->_priv.gamestates;
while (tmp) {
if (tmp->pending_unload) {
#ifdef __EMSCRIPTEN__
al_detach_voice(game->audio.v);
#endif
PrintConsole(game, "Unloading gamestate \"%s\"...", tmp->name);
tmp->loaded = false;
tmp->pending_unload = false;
game->_priv.current_gamestate = tmp;
(*tmp->api->unload)(game, tmp->data);
PrintConsole(game, "Gamestate \"%s\" unloaded successfully.", tmp->name);
#ifdef __EMSCRIPTEN__
al_attach_mixer_to_voice(game->audio.mixer, game->audio.v);
#endif
}
if (tmp->pending_load) {
#ifdef __EMSCRIPTEN__
al_detach_voice(game->audio.v);
#endif
if (tmp->show_loading && game->_priv.loading.gamestate->open) {
(*game->_priv.loading.gamestate->api->start)(game, game->_priv.loading.gamestate->data);
}
if (!tmp->api) {
if (!OpenGamestate(game, tmp, true) || !LinkGamestate(game, tmp)) {
tmp->pending_load = false;
tmp->pending_start = false;
continue;
}
}
if (tmp->api) {
PrintConsole(game, "Loading gamestate \"%s\"...", tmp->name);
game->_priv.loading.progress = 0;
game->_priv.loading.current = tmp;
game->_priv.current_gamestate = tmp;
struct GamestateLoadingThreadData data = {.game = game, .gamestate = tmp, .bitmap_flags = al_get_new_bitmap_flags()};
game->_priv.loading.in_progress = true;
double time = al_get_time();
game->_priv.loading.time = time;
CalculateProgress(game);
if (tmp->show_loading) {
game->loading.shown = true;
DrawGamestates(game);
DrawConsole(game);
al_flip_display();
#ifdef __EMSCRIPTEN__
emscripten_sleep(0);
#endif
}
#ifndef LIBSUPERDERPY_SINGLE_THREAD
al_run_detached_thread(GamestateLoadingThread, &data);
while (game->_priv.loading.in_progress) {
double delta = al_get_time() - game->_priv.loading.time;
game->time += delta; // TODO: ability to disable passing time during loading
game->_priv.loading.time += delta;
if (game->loading.shown && game->_priv.loading.gamestate->open) {
(*game->_priv.loading.gamestate->api->logic)(game, game->_priv.loading.gamestate->data, delta);
}
DrawGamestates(game);
if (game->_priv.texture_sync) {
al_convert_memory_bitmaps();
game->_priv.texture_sync = false;
al_signal_cond(game->_priv.texture_sync_cond);
game->_priv.loading.time = al_get_time(); // TODO: rethink time management during loading
}
DrawConsole(game);
al_flip_display();
if (game->_priv.bsod_sync) {
al_set_target_bitmap(NULL);
game->_priv.bsod_sync = false;
al_signal_cond(game->_priv.bsod_cond);
}
al_lock_mutex(game->_priv.bsod_mutex);
while (game->_priv.in_bsod) {
al_wait_cond(game->_priv.bsod_cond, game->_priv.bsod_mutex);
}
al_unlock_mutex(game->_priv.bsod_mutex);
}
#else
GamestateLoadingThread(&data);
DrawGamestates(game);
DrawConsole(game);
al_flip_display();
#ifdef __EMSCRIPTEN__
emscripten_sleep(0);
#endif
al_convert_memory_bitmaps();
#endif
al_set_new_bitmap_flags(data.bitmap_flags);
ReloadShaders(game, false);
if (tmp->api->post_load) {
PrintConsole(game, "[%s] Post-loading...", tmp->name);
tmp->api->post_load(game, tmp->data);
}
game->_priv.loading.progress++;
CalculateProgress(game);
PrintConsole(game, "Gamestate \"%s\" loaded successfully in %f seconds.", tmp->name, al_get_time() - time);
game->_priv.loading.loaded++;
DrawGamestates(game);
DrawConsole(game);
al_flip_display();
#ifdef __EMSCRIPTEN__
emscripten_sleep(0);
#endif
tmp->loaded = true;
tmp->pending_load = false;
}
if (tmp->show_loading && game->_priv.loading.gamestate->open) {
(*game->_priv.loading.gamestate->api->stop)(game, game->_priv.loading.gamestate->data);
}
tmp->show_loading = true;
game->loading.shown = false;
game->_priv.timestamp = al_get_time();
#ifdef __EMSCRIPTEN__
al_attach_mixer_to_voice(game->audio.mixer, game->audio.v);
#endif
}
tmp = tmp->next;
}
