Allegro (biblioteca de programación)

Allegro (pronunciado alegro) es una biblioteca libre y de código abierto para la programación de videojuegos desarrollada en lenguaje C. Allegro es un acrónimo de «Atari Low Level Game Routines» (rutinas de bajo nivel para videojuegos).

La biblioteca cuenta con funciones para gráficos, manipulación de imágenes, texto, sonidos, dispositivos de entrada (teclado, ratón y mandos de juego) y temporizadores, así como rutinas para aritmética de punto fijo y acceso al sistema de archivos. Hasta agosto de 2011, hay 2 versiones de Allegro que cuentan con soporte oficial por parte de los desarrolladores, la versión clásica (Allegro 4) y la nueva versión (Allegro 5). La versión más reciente de Allegro 4 incluye soporte para el manejo de archivos de datos y una implementación por software de funciones para gráficos en 3D. La versión 5 de Allegro cuenta con una nueva API y cambia la implementación por software de las rutinas gráficas por una implementación basada en OpenGL o Direct3D.

Aunque Allegro ofrece una API en lenguaje C, actualmente existen envolventes y bibliotecas adicionales que permiten utilizarlo en otros lenguajes como C++, Java, C#, Visual Basic.NET, Python, D, Lua, Pascal, Perl, Ruby, Go, Scheme, Common Lisp, Ocaml, Forth y Mercury.

Addons

La versión 4 de Allegro cuenta con varias bibliotecas adicionales creadas por la comunidad de usuarios; entre ellas se encuentran las que agregan soporte para varios formatos de archivo multimedia (por ejemplo PNG, GIF, JPEG, MPEG, Ogg, MP3 y más).

Bibliotecas adicionales como AllegroGL y OpenLayer utilizan OpenGL para agregar aceleración por hardware a los programas de Allegro. Tenga en cuenta que, en combinación con Glide y MesaFX (utilizando el hardware 3dfx), AllegroGL es una de las pocas soluciones de código abierto disponibles para hardware de aceleración 3D bajo DOS.

La versión 5 de Allegro cuenta con un sistema de Addons para facilitar la creación de complementos para la biblioteca. La distribución oficial incluye complementos para manipulación de imágenes BMP, PCX, PNG y JPEG, codecs de sonido Ogg y FLAC, fuentes FreeType y acceso al sistema de archivos mediante PhysFS, entre otros.

Ejemplos

Un ejemplo sencillo en Allegro 4

#include <allegro.h>

int main() 
{
   allegro_init();
   install_keyboard();
   set_color_depth(16);
   set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

   clear_to_color(screen, makecol(0, 128, 128));
	
   while (!key[KEY_ESC])
   {
      circlefill(screen, rand() % 640, rand() % 480, rand() % 64, makecol(rand() % 256, 0, 0));
   }

   return 0;
}

Un ejemplo equivalente en Allegro 5

#include <allegro5/allegro.h>
#include <allegro5/allegro_primitives.h>

ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *events = NULL;

int main()
{
    al_init();
    al_install_keyboard();
    al_set_new_display_option(ALLEGRO_SINGLE_BUFFER, 1, ALLEGRO_REQUIRE);
    al_set_new_display_flags(ALLEGRO_WINDOWED);
    display = al_create_display(640, 480);
    al_init_primitives_addon();
	
    events = al_create_event_queue();
    al_register_event_source(events, al_get_keyboard_event_source());
	
    al_clear_to_color(al_map_rgb(0, 128, 128));

    while (al_is_event_queue_empty(events))
    {
        al_draw_filled_circle(rand() % 640, rand() % 480, rand() % 64, al_map_rgb(rand() % 256, 0, 0));
        al_flip_display();
    }

}

Un ejemplo de la carga de una fuente en Allegro 5 para Android

#include <allegro5/allegro.h>
#include <allegro5/allegro_android.h>
#include <allegro5/allegro_font.h>
#include <allegro5/allegro_ttf.h>
#include <android/log.h>

int main(int arga, char** argc) {
    __android_log_print(ANDROID_LOG_DEBUG, "GAME-INIT","ATARI LOW LEVEL ROUTINE GAME");
    ALLEGRO_DISPLAY *display;
    int error;

    // Inicia complemento de fuentes
    al_init_font_addon();
    // Inicia complemento de TTF
    al_init_ttf_addon();
    // Configurar la interfaz de acceso a archivos APK en la aplicación Android.
    al_android_set_apk_file_interface();
    // Validar inicialización de Allegro5
    if (!al_init()) {
        __android_log_print(ANDROID_LOG_ERROR, "GAME-INFO",
                            "Error: Follo al inicializar Allegro5.");
        return -1;
    }
    __android_log_print(ANDROID_LOG_DEBUG, "GAME-INFO", "Allegro5 Inicializado.");
    //Define el ANCHO de la pantalla
    int screenWidth = 720;
    //Define el ALTO de la pantalla
    int screenHeight = 1600;
    // Crea el Display
    display = al_create_display(screenWidth, screenHeight);
    // Valida la creación del Display
    if (!display) {
        // Manejar el error si la creación de la pantalla falla
        __android_log_print(ANDROID_LOG_ERROR, "GAME-ERROR", "ERROR: Fallo al crear la pantalla.");
        return -1;
    }
    __android_log_print(ANDROID_LOG_DEBUG, "GAME-INFO", "Display Creado");

    // Define el archivo de fuente que será cargado.
    const char *fileName ="name_of_your_ttf_font_file.ttf";

    // Abre el archivo de fuente
    ALLEGRO_FILE *fontFile = al_fopen(fileName, "r");
    __android_log_print(ANDROID_LOG_DEBUG, "GAME-INFO", "Archivo de Fuente [%s] abierto.",fileName);
    // Carga la fuente desde el archivo en diferentes
    // tamaños usando diferentes funciones
    // Carga fuentes bitmap o de mapa de bits desde archivos de imagen, como BMP, PNG o PCX.
    ALLEGRO_FONT *mouly = al_load_font(fileName, 30, 0);
    ALLEGRO_FONT *mouly2 = al_load_font(fileName, 60, 0);
    // al_load_font Carga la fuente TrueType (TTF) desde un archivo.
    ALLEGRO_FONT *mouly3 = al_load_ttf_font(fileName, 90, 0);
    if (!mouly) {
        error = al_get_errno();
        // Manejar el error si la creación de la pantalla falla
        return -1;
    }
    __android_log_print(ANDROID_LOG_DEBUG, "GAME-INFO", "FUENTE Cargada: %s",fileName);

    // Define el color de fondo de la pantalla
    al_clear_to_color(al_map_rgb(80,30,180));
    // Define Crea un objeto de tipo ALLEGRO_COLOR
    ALLEGRO_COLOR fontColor = al_map_rgb(255, 255, 255);
    // Dibuja un mensaje en la pantalla
    al_draw_text(mouly, fontColor, screenHeight/2, 200, ALLEGRO_ALIGN_CENTER, "Allegro5 - Android");
    al_draw_textf(mouly2, fontColor, screenHeight/2, screenWidth/2, ALLEGRO_ALIGN_CENTER, "Allegro5 - Android");
    al_draw_text(mouly3, fontColor, 360, 900, ALLEGRO_ALIGN_CENTER, "Allegro5 - Android");

    al_flip_display();
    al_rest(5);// Wait for 5 seconds
    __android_log_print(ANDROID_LOG_DEBUG, "GAME-END","HASTA LA PRÓXIMA :)");
    al_rest(5);// Wait for 5 seconds
    al_free(fontFile);
    al_destroy_font(mouly);
    al_destroy_font(mouly2);
    al_destroy_display(display);

    return 0;
}

Historia

Allegro inicialmente significaba "Rutinas para Juegos de Bajo Nivel para Atari" (Atari Low-Level Game Routines). Fue originalmente creado por Shawn Hargreaves para el Atari ST a principios de 1990. Sin embargo, Shawn abandonó la versión de Atari al darse cuenta de que la plataforma estaba muriendo y reimplementaría su trabajo para los compiladores Borland C++ y DJGPP. En 1995 se abandonó el soporte para Borland C++ en la versión 2.0, y DJGPP sería el único compilador soportado. Como DJGPP era un compilador DOS, todos los juegos que utilizaban Allegro corrían en ese sistema operativo. Alrededor de 1998, Allegro se ramificó en varias versiones. Se creó una distribución para Microsoft Windows (WinAllegro) y también una para Unix (XwinAllegro). Estas distribuciones se reunieron durante las versiones WIP de Allegro 3.9. Allegro 4.0 sería la primera versión estable de Allegro para múltiples plataformas. La versión actual de Allegro es compatible con Unix (Android, Linux, FreeBSD, Irix, Solaris, Darwin), Windows (MSVC, MinGW, Cygwin, Borland C++), Mac OS X y, hasta la versión 4.2, BeOS, QNX, y DOS (DJGPP, Watcom). Una versión de iPhone Ya se encuentra disponible en el repositorio oficial de GitHub. Shawn Hargreaves no volverá a intervenir con Allegro.

Enlaces externos

Datos: Q1503415