Antialiasing in allegro

no-reply@allegro.cc (kovarex) — Wed, 19 Sep 2012 02:53:07 +0000

Hello,

I'm looking for way to draw bitmaps (not primitives) (zoomed and without zoom) antialised.

When I draw bitmap the normal way, allegro functions take floats as position arguments, but the position of the bitmap is rounded to whole pixels, this makes bad effects in the game. The goal would be to be able to draw the bitmap in between two pixels like I show it on this picture:
http://www.kovarex.com/download/bitmap-placement.png

I would expect, that this kind of multisampling setting would do this, but it didn't

  al_set_new_display_flags(ALLEGRO_RESIZABLE);
  al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
  al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR);
  al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
  al_set_new_display_option(ALLEGRO_SAMPLES, 6, ALLEGRO_SUGGEST);

no-reply@allegro.cc (Elias) — Wed, 19 Sep 2012 03:00:49 +0000

If you use 5.0.7 and the D3D driver, multi-sampling does not work.

no-reply@allegro.cc (kovarex) — Wed, 19 Sep 2012 03:01:34 +0000

Elias:
I used the 5.1.2 version, and today we updated to 5.1.3 and it is the same.

The goal would be to make it work either for D3D and opengl if possible.

no-reply@allegro.cc (Elias) — Wed, 19 Sep 2012 03:23:22 +0000

In 5.1.3 it should work. What happens if you run ex_multisample?

no-reply@allegro.cc (weapon_S) — Wed, 19 Sep 2012 10:47:45 +0000

kovarex said:

al_set_new_display_option(ALLEGRO_SAMPLES, 6, ALLEGRO_SUGGEST);

I'm not very familiar with exactly what capabilities Allegro can use, but 6 is a weird number for 'normal' samples, I think. Try 4?

no-reply@allegro.cc (kovarex) — Wed, 19 Sep 2012 14:01:05 +0000

weapon_S:
I tried 4 instead of 6 and it is the same, bitmap position is still rounded to pixels.

Elias:
But ex_multisample contains only primitives drawing, I need multisampling for bitmap drawing.

no-reply@allegro.cc (Elias) — Wed, 19 Sep 2012 15:06:42 +0000

Yes, but does ex_multisample work? al_draw_bitmap just calls the underlying primitive functions as far as I know so either both should work or neither. Anyway, if ex_multisample works but bitmap drawing does not, it sounds like a bug to me. If ex_multisample doesn't work as well, multisampling simply doesn't work for some reason.

no-reply@allegro.cc (kovarex) — Wed, 19 Sep 2012 15:24:54 +0000

Elias:
ex_multisample works

no-reply@allegro.cc (Elias) — Wed, 19 Sep 2012 15:28:34 +0000

I'll try modifying it to add an al_draw_bitmap call when I get home and see how it looks here.

no-reply@allegro.cc (weapon_S) — Wed, 19 Sep 2012 16:04:09 +0000

I'm just firing ideas.
What does al_get_display_option(display, ALLEGRO_RENDER_METHOD); return?
That shouldn't return 0... but I guess something has to be wrong.

no-reply@allegro.cc (kovarex) — Wed, 19 Sep 2012 22:53:29 +0000

weapon_S:
It returns 0.
Does it mean hardware acceleration isn't used?
How could it be possible? The game isn't THAT slow (I can draw up to 20k sprites 60fps, would software acceleration make it?

no-reply@allegro.cc (Elias) — Wed, 19 Sep 2012 23:11:20 +0000

I tried adding an al_draw_bitmap call to ex_multisample and it does work.

Double-check that:

- none of your bitmaps are created before al_create_display
- you set ALLEGRO_SAMPLE_BUFFERS and ALLEGRO_SAMPLES before al_create_display
- you set ALLEGRO_MIN_LINEAR and ALLEGRO_MAG_LINEAR before any bitmaps are created/loaded

no-reply@allegro.cc (kovarex) — Thu, 20 Sep 2012 02:38:22 +0000

Elas:

This is our display init function
bitmaps are loaded later

#SelectExpand
if (!al_init())
  throw std::runtime_error("failed to initialize allegro!");
/* vsync 1 means force on, 2 means forced off. */
al_set_new_display_flags(ALLEGRO_RESIZABLE);
al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
  9
al_set_new_window_position(global->properties.get<int>("screen.x", 100),
                           global->properties.get<int>("screen.y", 100));
 12
this->display = al_create_display(global->properties.get<int>("screen.width", 800),
                                  global->properties.get<int>("screen.height", 600));
if (!this->display)
  throw std::runtime_error("failed to create display!");
al_show_native_message_box(al_get_current_display(),
                           "Window Title",
                           "Content Title",
                           ssprintf("render method = %d", al_get_display_option(display, ALLEGRO_RENDER_METHOD)).c_str(),
                           NULL, ALLEGRO_MESSAGEBOX_ERROR);
 22
if (!al_init_image_addon())
  throw std::runtime_error("Failed to initialize al_init_image_addon!");
if (!al_install_keyboard())
  throw std::runtime_error("failed to initialize the keyboard!");
if (!al_install_mouse())
  throw std::runtime_error("failed to initialize the mouse!");
al_init_font_addon();
if (!al_init_ttf_addon())
  throw std::runtime_error("failed to initialize the ttf addon!");
this->font = al_load_ttf_font((global->resourcePath + "pirulen.ttf").c_str(), 24, 0);
if (!Display::font)
  throw std::runtime_error("Could not load 'pirulen.ttf'.");
Display::itemCountFont = al_load_ttf_font((global->resourcePath + "pirulen.ttf").c_str(), 14, 0);
if (!Display::itemCountFont)
  throw std::runtime_error("Could not load 'pirulen.ttf'.");
Display::tileLabelFont = al_load_ttf_font((global->resourcePath + "pirulen.ttf").c_str(), 14, 0);
if (!Display::tileLabelFont)
  throw std::runtime_error("Could not load 'pirulen.ttf'.");
if (!al_init_primitives_addon())
  throw std::runtime_error("failed to load primitives addon!");

no-reply@allegro.cc (Elias) — Thu, 20 Sep 2012 03:44:13 +0000

This is my modified ex_multisample. If you either comment out the multi-sampling or the bitmap filtering you can clearly see what both do - the former anti-aliases the outline, the latter filters the inside of the texture. So without multisampling the bitmap seems to jump in one-pixel steps. Without the filtering the texture seems to jump in one-pixel steps. With both on it's all smooth.

I'm using Ubuntu/OpenGL here.

#SelectExpand
  1#include 
  2#include 
  3
  4int main(void)
  5{
 ALLEGRO_DISPLAY *display;
 ALLEGRO_EVENT_QUEUE *queue;
 ALLEGRO_TIMER *timer;
 ALLEGRO_BITMAP *bitmap;
 float bx, by;
 bool quit = false;
 bool redraw = true;
 unsigned char *rgba;
 int p;
 int x, y;
 16
 al_init();
 al_install_keyboard();
 19
 al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_REQUIRE);
 al_set_new_display_option(ALLEGRO_SAMPLES, 16, ALLEGRO_SUGGEST);
 display = al_create_display(200, 200);
 23
 al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
 bitmap = al_create_bitmap(16, 16);
 ALLEGRO_LOCKED_REGION *locked;
 locked = al_lock_bitmap(bitmap, ALLEGRO_PIXEL_FORMAT_ABGR_8888, 0);
 rgba = locked->data;
 p = locked->pitch;
 for (y = 0; y < 16; y++) {
    for (x = 0; x < 16; x++) {
       int c = (((x / 4) + (y / 4)) & 1) * 255;
       rgba[y * p + x * 4 + 0] = c;
       rgba[y * p + x * 4 + 1] = c;
       rgba[y * p + x * 4 + 2] = c;
       rgba[y * p + x * 4 + 3] = 255;
    }
 }
 al_unlock_bitmap(bitmap);
 40
 timer = al_create_timer(1.0 / 60.0);
 42
 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_timer_event_source(timer));
 
 al_start_timer(timer);
 while (!quit) {
    ALLEGRO_EVENT event;
    al_wait_for_event(queue, &event);
    switch (event.type) {
       case ALLEGRO_EVENT_DISPLAY_CLOSE:
          quit = true;
 55
       case ALLEGRO_EVENT_KEY_DOWN:
          if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
             quit = true;
          break;
       
       case ALLEGRO_EVENT_TIMER:
          bx = fmod(bx + 0.1, 200);
          by = fmod(by + 0.1, 200);
          redraw = true;
          break;
    }
    
    if (redraw && al_is_event_queue_empty(queue)) {
       al_clear_to_color(al_map_rgb_f(0.5, 0.5, 1));
       al_draw_bitmap(bitmap, bx, by, 0);
       al_flip_display();
       
       redraw = false;
    }
 }
 76
 return 0;
 78}

no-reply@allegro.cc (kovarex) — Thu, 20 Sep 2012 17:00:10 +0000

In the first post I had only ALLEGRO_MIN_LINEAR, adding ALLEGRO_MAG_LINEAR to new bitmap flags seems to solve the problem.
Could it be, that unscaled bitmaps are affected by the ALLEGRO_MAG_LINEAR flag?

no-reply@allegro.cc (Elias) — Thu, 20 Sep 2012 17:55:54 +0000

It doesn't say on MSDN ^[1]. But you almost always want either both or none (and if you scale your bitmaps down more than about 50% you want to enable mipmaps as well). Maybe we should provide new defines like

#define ALLEGRO_BILINEAR_FILTER ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR
#define ALLEGRO_TRILINEAR_FILTER ALLEGRO_BILINEAR_FILTER | ALLEGRO_MIPMAP

and then you'd just use bi-linear or tri-linear. And now with all the added 3D support, we also should add an anisotropic filtering option.

References

http://msdn.microsoft.com/en-us/library/windows/desktop/bb172357%28v=vs.85%29.aspx