How would I implement a FPS counter w/ Allegro 5 events?

DocHoliday

in Allegro 4 a FPS counter could be implemented as in http://wiki.allegro.cc/index.php?title=Timers:

#SelectExpand
  1#include <allegro.h>

  3volatile int ticks = 0;
  4void ticker()
  5{
ticks++;
  7}
  8END_OF_FUNCTION(ticker)

 10//a new set of timing variables to keep the game time
 11volatile int game_time = 0;
 12void game_time_ticker()
 13{
game_time++;
 15}
 16END_OF_FUNCTION(game_time_ticker)

 18const int updates_per_second = 60;

 20int main()
 21{
allegro_init();
install_timer();

LOCK_VARIABLE(ticks);
LOCK_FUNCTION(ticker);
install_int_ex(ticker, BPS_TO_TIMER(updates_per_second));

LOCK_VARIABLE(game_time);
LOCK_FUNCTION(game_time_ticker);
install_int_ex(game_time_ticker, BPS_TO_TIMER(10));//i.e. game time is in tenths of seconds

bool quit = false;

int fps = 0;
int frames_done = 0;
int old_time = 0;

while(!quit)
{
  while(ticks == 0)
  {
    rest(1);
  }

  while(ticks > 0)
  {
    int old_ticks = ticks;

    DoLogic();

    ticks--;
    if(old_ticks <= ticks)
      break; 
  }

  if(game_time - old_time >= 10)//i.e. a second has passed since we last measured the frame rate
  {
    fps = frames_done;
    //fps now holds the the number of frames done in the last second
    //you can now output it using textout_ex et al.

    //reset for the next second
    frames_done = 0;
    old_time = game_time;
  }

  DrawEverything();
  frames_done++;//we drew a frame!
}
return 0;
 72}
 73END_OF_MAIN()

In Allegro 5 a simple mouse input program could look like the following (from http://wiki.allegro.cc/index.php?title=Allegro_5_Tutorial/Input):

#SelectExpand
   1#include <stdio.h>
   2#include <allegro5/allegro.h>

   4const float FPS = 60;
   5const int SCREEN_W = 640;
   6const int SCREEN_H = 480;
   7const int BOUNCER_SIZE = 32;

   9int main(int argc, char **argv)
  10{
 ALLEGRO_DISPLAY *display = NULL;
 ALLEGRO_EVENT_QUEUE *event_queue = NULL;
 ALLEGRO_TIMER *timer = NULL;
 ALLEGRO_BITMAP *bouncer = NULL;
 float bouncer_x = SCREEN_W / 2.0 - BOUNCER_SIZE / 2.0;
 float bouncer_y = SCREEN_H / 2.0 - BOUNCER_SIZE / 2.0;
 bool redraw = true;

 if(!al_init()) {
    fprintf(stderr, "failed to initialize allegro!\n");
    return -1;
 }

 if(!al_install_mouse()) {
    fprintf(stderr, "failed to initialize the mouse!\n");
    return -1;
 }

 timer = al_create_timer(1.0 / FPS);
 if(!timer) {
    fprintf(stderr, "failed to create timer!\n");
    return -1;
 }

 display = al_create_display(SCREEN_W, SCREEN_H);
 if(!display) {
    fprintf(stderr, "failed to create display!\n");
    al_destroy_timer(timer);
    return -1;
 }

 bouncer = al_create_bitmap(BOUNCER_SIZE, BOUNCER_SIZE);
 if(!bouncer) {
    fprintf(stderr, "failed to create bouncer bitmap!\n");
    al_destroy_display(display);
    al_destroy_timer(timer);
    return -1;
 }

 al_set_target_bitmap(bouncer);

 al_clear_to_color(al_map_rgb(255, 0, 255));

 al_set_target_bitmap(al_get_backbuffer(display));

 event_queue = al_create_event_queue();
 if(!event_queue) {
    fprintf(stderr, "failed to create event_queue!\n");
    al_destroy_bitmap(bouncer);
    al_destroy_display(display);
    al_destroy_timer(timer);
    return -1;
 }

 al_register_event_source(event_queue, al_get_display_event_source(display));

 al_register_event_source(event_queue, al_get_timer_event_source(timer));

 al_register_event_source(event_queue, al_get_mouse_event_source());

 al_clear_to_color(al_map_rgb(0,0,0));

 al_flip_display();

 al_start_timer(timer);

 while(1)
 {
    ALLEGRO_EVENT ev;
    al_wait_for_event(event_queue, &ev);

    if(ev.type == ALLEGRO_EVENT_TIMER) {
       redraw = true;
    }
    else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
       break;
    }
    else if(ev.type == ALLEGRO_EVENT_MOUSE_AXES ||
            ev.type == ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY) {

       bouncer_x = ev.mouse.x;
       bouncer_y = ev.mouse.y;
    }
    else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP) {
        break;
    }

    if(redraw && al_is_event_queue_empty(event_queue)) {
       redraw = false;

       al_clear_to_color(al_map_rgb(0,0,0));

       al_draw_bitmap(bouncer, bouncer_x, bouncer_y, 0);

       al_flip_display();
    }
 }

 al_destroy_bitmap(bouncer);
 al_destroy_timer(timer);
 al_destroy_display(display);
 al_destroy_event_queue(event_queue);

 return 0;
 115}

How could I efficiently measure the FPS and display this to the screen in Allegro 5?

SiegeLord

Same approach will work. Allegro 5 comes with a much better way to measure current time (game time in that example), al_get_time, so using a separate game timer is not necessary.

So the code would roughly be:

#SelectExpand
  1double fps = 0;
  2int frames_done = 0;
  3double old_time = al_get_time();
  4
  5while(1)
  6{
  7  ...
  8
  9  if(redraw && al_is_event_queue_empty(event_queue)) {
 10    ...
 11    
 12    double game_time = al_get_time();
 13    if(game_time - old_time >= 1.0) {
 14      fps = frames_done / (game_time - old_time);
 15    
 16      frames_done = 0;
 17      old_time = game_time;
 18    }
 19    
 20    frames_done++;
 21  }
 22}

There are probably 100 other ways to do it, though... I think pretty much every example that comes with A5 that displays FPS uses a different method of calculating it.

DocHoliday

That was perfect.
Thank you.

Thread #606085. Printed from Allegro.cc