/* function to squeeze a large bitmap to fit within the GPU's maximum texture size */
ALLEGRO_BITMAP * t3f_squeeze_bitmap(ALLEGRO_BITMAP * bp, int * ow, int * oh)
{
int start_w = al_get_bitmap_width(bp);
int start_h = al_get_bitmap_height(bp);
int width = al_get_display_option(t3f_display, ALLEGRO_MAX_BITMAP_SIZE);
int height = width;
printf("max size = %d\n", width);
if(start_w < width)
{
width = start_w;
}
if(start_h < height)
{
height = start_h;
}
/* store original bitmap size if pointers passed */
if(ow)
{
*ow = start_w;
}
if(oh)
{
*oh = start_h;
}
/* return original bitmap if it already fits */
if(start_w <= width && start_h <= height)
{
printf("clone (%d, %d) (%d, %d)\n", start_w, start_h, width, height);
return al_clone_bitmap(bp);
}
return t3f_resize_bitmap(bp, width, width);
}
int main(void)
{
GLuint pid;
ALLEGRO_DISPLAY *d;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
int frames = 0;
double start;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_set_new_display_flags(ALLEGRO_OPENGL);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
d = al_create_display(WINDOW_W, WINDOW_H);
if (!d) {
abort_example("Unable to open a OpenGL display.\n");
return -1;
}
if (al_get_display_option(ALLEGRO_SAMPLE_BUFFERS)) {
printf("With multisampling, level %i\n", al_get_display_option(ALLEGRO_SAMPLES));
}
else {
printf("Without multisampling.\n");
}
al_install_keyboard();
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(d));
if (al_get_opengl_extension_list()->ALLEGRO_GL_ARB_multisample) {
glEnable(GL_MULTISAMPLE_ARB);
}
if (!al_get_opengl_extension_list()->ALLEGRO_GL_ARB_vertex_program) {
abort_example("This example requires a video card that supports "
" the ARB_vertex_program extension.\n");
return -1;
}
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDisable(GL_CULL_FACE);
/* Setup projection and modelview matrices */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, WINDOW_W/(float)WINDOW_H, 0.1, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* Position the camera to look at our mesh from a distance */
gluLookAt(0.0f, 20.0f, -45.0f, 0.0f, 0.0f, 0.0f, 0, 1, 0);
create_mesh();
/* Define the vertex program */
glEnable(GL_VERTEX_PROGRAM_ARB);
glGenProgramsARB(1, &pid);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, pid);
glGetError();
if (al_get_opengl_extension_list()->ALLEGRO_GL_NV_vertex_program2_option) {
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program_nv), program_nv);
}
else {
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(program), program);
}
/* Check for errors */
if (glGetError()) {
const char *pgm = al_get_opengl_extension_list()->ALLEGRO_GL_NV_vertex_program2_option
? program_nv : program;
GLint error_pos;
const GLubyte *error_str = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
abort_example("Error compiling the vertex program:\n%s\n\nat "
"character: %i\n%s\n", error_str, (int)error_pos,
pgm + error_pos);
return -1;
}
start = al_current_time();
while (1) {
if (!al_event_queue_is_empty(queue)) {
while (al_get_next_event(queue, &event)) {
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
goto done;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
goto done;
break;
}
}
}
draw_mesh();
al_flip_display();
frames++;
}
done:
printf("%.1f FPS\n", frames / (al_current_time() - start));
glDeleteProgramsARB(1, &pid);
al_destroy_event_queue(queue);
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display, *ms_display;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_TIMER *timer;
ALLEGRO_BITMAP *memory;
char title[1024];
bool quit = false;
bool redraw = true;
int wx, wy;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Couldn't initialise Allegro.\n");
}
al_init_primitives_addon();
al_install_keyboard();
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
memory = create_bitmap();
/* Create the normal display. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 0, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_SAMPLES, 0, ALLEGRO_SUGGEST);
display = al_create_display(300, 450);
if (!display) {
abort_example("Error creating display\n");
}
al_set_window_title(display, "Normal");
/* Create bitmaps for the normal display. */
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
bitmap_filter = al_clone_bitmap(memory);
al_set_new_bitmap_flags(0);
bitmap_normal = al_clone_bitmap(memory);
font = al_create_builtin_font();
al_get_window_position(display, &wx, &wy);
if (wx < 160)
wx = 160;
/* Create the multi-sampling display. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_REQUIRE);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
ms_display = al_create_display(300, 450);
if (!ms_display) {
abort_example("Multisampling not available.\n");
}
sprintf(title, "Multisampling (%dx)", al_get_display_option(
ms_display, ALLEGRO_SAMPLES));
al_set_window_title(ms_display, title);
/* Create bitmaps for the multi-sampling display. */
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
bitmap_filter_ms = al_clone_bitmap(memory);
al_set_new_bitmap_flags(0);
bitmap_normal_ms = al_clone_bitmap(memory);
font_ms = al_create_builtin_font();
/* Move the windows next to each other, because some window manager
* would put them on top of each other otherwise.
*/
al_set_window_position(display, wx - 160, wy);
al_set_window_position(ms_display, wx + 160, wy);
timer = al_create_timer(1.0 / 30.0);
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_display_event_source(ms_display));
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
while (!quit) {
ALLEGRO_EVENT event;
/* Check for ESC key or close button event and quit in either case. */
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_DISPLAY_CLOSE:
quit = true;
break;
case ALLEGRO_EVENT_KEY_DOWN:
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
quit = true;
break;
case ALLEGRO_EVENT_TIMER:
bitmap_move();
redraw = true;
break;
}
if (redraw && al_is_event_queue_empty(queue)) {
/* Draw the multi-sampled version into the first window. */
al_set_target_backbuffer(ms_display);
al_clear_to_color(al_map_rgb_f(1, 1, 1));
draw(bitmap_filter_ms, 0, "filtered, multi-sample");
draw(bitmap_normal_ms, 250, "no filter, multi-sample");
al_flip_display();
/* Draw the normal version into the second window. */
al_set_target_backbuffer(display);
al_clear_to_color(al_map_rgb_f(1, 1, 1));
draw(bitmap_filter, 0, "filtered");
draw(bitmap_normal, 250, "no filter");
al_flip_display();
redraw = false;
}
}
return 0;
}
