Allegro and OpenGL Drawing Problem

no-reply@allegro.cc (jBacher18) — Tue, 02 Jan 2018 22:27:32 +0000

I'm working on a large project that was initially developed on an OSX machine but is now being ported to windows. I expected some degree of difficulty in porting the code, but I solved all issues pertaining to problematic includes and have already made sure to include the proper OpenGL libraries.

My current issue is that, for example, with the following code segment which should display a Quad that takes up most of the screen displays nothing, or, rather, it displays the clearing color (blue or green) but never the quad. Peculiarly, this same code works on my OSX machine.

#SelectExpand
  1void init(){
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0, viewWidth, 0, viewHeight, -1, 1);
  glMatrixMode(GL_MODELVIEW);
  glClearColor (0.0, 0.0, 0.0, 1.0);
  glColor3f(1.0,0.0,0.0);
  glDisable(GL_DEPTH_TEST);
  9}
 10
 11int main(int argc, char **argv) {
  al_init();
  al_install_keyboard();
al_init_primitives_addon();
 15
  std::cout << winWidth << "\t" << winHeight << std::endl;
  ALLEGRO_DISPLAY* display = al_create_display(winWidth, winHeight);

  init(); // Init OpenGL vars
 20
int j = 0, target = 0;

while (true) {
  if (j > 750) {
    glClear(GL_COLOR_BUFFER_BIT);
    al_clear_to_color(al_map_rgb(0, 255, 0));
    al_flip_display();
    if (j < 1500) {
      j++;
    }
    else {
      j = 0;
    }
  }
  else{
    glClear(GL_COLOR_BUFFER_BIT);
    al_clear_to_color(al_map_rgb(0, 0, 255));
    glColor3ub(125, 125, 0);
    glBegin(GL_QUADS);
    glVertex2i(10, 10);
    glVertex2i(viewWidth - 10, 10);
    glVertex2i(viewWidth - 10, viewHeight - 10);
    glVertex2i(10, viewHeight - 10);
    glEnd();
    al_flip_display();
    j++;
  }
  
  
}
 51}

As it stands, my best guess is that I've made some mistake with my includes or I missed something important to setting up OpenGL in Allegro that I didn't have to do on my OSX machine.

Also important: I know now that Allegro includes primitives that I should've been using from the get-go, but I wanted to use OpenGL for a variety of reasons and so, at the moment, switching to Allegro primitives is not a preferred option.

Any ideas as to what is going wrong would be appreciated.

no-reply@allegro.cc (Edgar Reynaldo) — Wed, 03 Jan 2018 00:02:19 +0000

Allegro and OpenGL each have their own transformations. Allegro uses OpenGL's under the hood, but doesn't respect OpenGL transformations you set yourself.

In your 'init' function you're not setting an identity matrix for the MODELVIEW matrix. Also, just try to draw one thing once and see if it works or not.

Mixing Allegro and OpenGL does work, but has some problems when you change global GL state that one or the other was expecting.

This simple example should show you how to draw your Quad with OpenGL :

#SelectExpand
   1
   2
   3
   4#include "allegro5/allegro.h"
   5#include "allegro5/allegro_primitives.h"
   6#include "allegro5/allegro_opengl.h"
   7
   8int ww = 800;
   9int wh = 600;
  
  11
  12void resetOpenGLmatrices();
  13
  14int main(int argc , char** argv) {
  
  if (!al_init()) {return 1;}
  if (!al_init_primitives_addon()) {return 2;}
  
  if (!al_install_keyboard()) {return 3;}
  
  
  al_set_new_display_flags(ALLEGRO_OPENGL | ALLEGRO_WINDOWED);
  
  ALLEGRO_DISPLAY* d = al_create_display(ww,wh);
  
  if (!d) {return -1;}
  
  ALLEGRO_TIMER* t = al_create_timer(1.0/60.0);
  
  if (!t) {return -2;}
  
  ALLEGRO_EVENT_QUEUE* q = al_create_event_queue();
  
  if (!q) {return -3;}
  
  al_register_event_source(q , al_get_display_event_source(d));
  al_register_event_source(q , al_get_timer_event_source(t));
  al_register_event_source(q , al_get_keyboard_event_source());
  
  bool redraw = true;
  bool quit = false;
  
  int shrink = 0;
  int shrink_dir = 1;
  
  al_start_timer(t);
  
  al_clear_to_color(al_map_rgb(0,0,0));
  al_flip_display();
  
  while (!quit) {
      if (redraw) {
          al_set_target_backbuffer(d);
          al_clear_to_color(al_map_rgb(255,255,255));
      
          resetOpenGLmatrices();
          
          glColor3ub(0,0,0);
          
          glBegin(GL_QUADS);
          
          glVertex2i(shrink,shrink);
          glVertex2i(shrink,wh-shrink);
          glVertex2i(ww-shrink,wh-shrink);
          glVertex2i(ww-shrink,shrink);
          
          glEnd();
          
          al_flip_display();
          
          redraw = false;
      }
      do {
          ALLEGRO_EVENT ev;
          al_wait_for_event(q , &ev);
          if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {quit = true;}
          if (ev.type == ALLEGRO_EVENT_KEY_DOWN && ev.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {quit = true;}
          if (ev.type == ALLEGRO_EVENT_TIMER) {
              redraw = true;
              shrink += shrink_dir;
              if (shrink > ww/2) {
                  shrink = ww/2;
                  shrink_dir = -1;
              }
              if (shrink < 0) {
                  shrink = 0;
                  shrink_dir = 1;
              }
          }
      } while (!al_is_event_queue_empty(q));
      
  }
  
  
  return 0;
  96}
  97
  98
  99void resetOpenGLmatrices() {
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0 , ww , 0 , wh , -1 , 1);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
 105}

Basically, any time you draw with allegro, you reset the target bitmap, which resets opengl state. Any time you want to draw with opengl, you need to reset the state yourself.

no-reply@allegro.cc (jBacher18) — Wed, 03 Jan 2018 01:22:31 +0000

Thank you so much, Wonderful explanation. That fixes the problem and provides me a nice example to look back on. Thanks Again!

no-reply@allegro.cc (kenmasters1976) — Wed, 03 Jan 2018 11:01:23 +0000

I had a similar problem just recently with mixing Allegro and OpenGL. Take a look at this thread for the details.

no-reply@allegro.cc (Edgar Reynaldo) — Wed, 03 Jan 2018 18:29:32 +0000

I managed to get a colored textured spinning cube drawn. Here's how I did it :

Download src + win32 binary here

{"name":"611190","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/6\/a\/6aab5988fe9697b0f23d12cce0e2da92.png","w":802,"h":641,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/6\/a\/6aab5988fe9697b0f23d12cce0e2da92"}

#SelectExpand
   1
   2#include "allegro5/allegro.h"
   3#include "allegro5/allegro_memfile.h"
   4#include "allegro5/allegro_primitives.h"
   5#include "allegro5/allegro_font.h"
   6#include "allegro5/allegro_ttf.h"
   7#include "allegro5/allegro_color.h"
   8#include "allegro5/allegro_opengl.h"
   9
  10#include "GL/glu.h"
  11#include 
  12#include 
  13
  14#include "Consola.h"
  15
  16
  17int ww = 800;
  18int wh = 600;
  
  20
  
  22void resetOpenGLmatrices();
  23
  24struct XYZ {
  float x,y,z;
  26};
  27
  28XYZ uc[8] = {
  {-0.5f,-0.5f,-0.5f},
  {-0.5f, 0.5f,-0.5f},
  { 0.5f, 0.5f,-0.5f},
  { 0.5f,-0.5f,-0.5f},
  { 0.5f,-0.5f, 0.5f},
  { 0.5f, 0.5f, 0.5f},
  {-0.5f, 0.5f, 0.5f},
  {-0.5f,-0.5f, 0.5f}
  37};
  38
  39struct RGB {
  float r,g,b,a;
  41};
  42
  43RGB cc1[8] = {
  {1.0f,1.0f,1.0f,1.0f},
  {1.0f,0.0f,0.0f,1.0f},
  {0.0f,1.0f,0.0f,1.0f},
  {0.0f,0.0f,1.0f,1.0f},
  {1.0f,1.0f,0.0f,1.0f},
  {0.0f,0.0f,0.0f,1.0f},
  {0.0f,1.0f,1.0f,1.0f},
  {1.0f,0.0f,1.0f,1.0f}
  52};
  53
  54RGB cc[8] = {
  {1.0f,1.0f,1.0f,1.0f},
  {1.0f,0.0f,0.0f,1.0f},
  {0.0f,0.0f,1.0f,1.0f},
  {0.0f,1.0f,1.0f,1.0f},
  {1.0f,1.0f,0.0f,1.0f},
  {0.0f,0.0f,0.0f,1.0f},
  {0.0f,1.0f,1.0f,1.0f},
  {1.0f,0.0f,1.0f,1.0f}
  63};
  64
  65struct TEX2D {
  float u,v;
  67};
  68
  69TEX2D tex2d[4] = {
  {0.0,1.0},
  {0.0,0.0},
  {1.0,0.0},
  {1.0,1.0}
  74};
  75
  76struct TRI {
 XYZ* p1;
 XYZ* p2;
 XYZ* p3;
 RGB* c1;
 RGB* c2;
 RGB* c3;
 TEX2D* tuv1;
 TEX2D* tuv2;
 TEX2D* tuv3;
 
  87};
  88
  89TRI cube_faces[12] = {
  {&uc[0] , &uc[1] , &uc[2], &cc[0] , &cc[1] , &cc[2] , &tex2d[0] , &tex2d[1] , &tex2d[2]},
  {&uc[2] , &uc[3] , &uc[0], &cc[2] , &cc[3] , &cc[0] , &tex2d[2] , &tex2d[3] , &tex2d[0]},
  {&uc[3] , &uc[2] , &uc[5], &cc[3] , &cc[2] , &cc[5] , &tex2d[0] , &tex2d[1] , &tex2d[2]},
  {&uc[5] , &uc[4] , &uc[3], &cc[5] , &cc[4] , &cc[3] , &tex2d[2] , &tex2d[3] , &tex2d[0]},
  {&uc[4] , &uc[5] , &uc[6], &cc[4] , &cc[5] , &cc[6] , &tex2d[0] , &tex2d[1] , &tex2d[2]},
  {&uc[6] , &uc[7] , &uc[4], &cc[6] , &cc[7] , &cc[4] , &tex2d[2] , &tex2d[3] , &tex2d[0]},
  {&uc[7] , &uc[6] , &uc[1], &cc[7] , &cc[6] , &cc[1] , &tex2d[0] , &tex2d[1] , &tex2d[2]},
  {&uc[1] , &uc[0] , &uc[7], &cc[1] , &cc[0] , &cc[7] , &tex2d[2] , &tex2d[3] , &tex2d[0]},
  {&uc[0] , &uc[3] , &uc[4], &cc[0] , &cc[3] , &cc[4] , &tex2d[0] , &tex2d[1] , &tex2d[2]},
  {&uc[4] , &uc[7] , &uc[0], &cc[4] , &cc[7] , &cc[0] , &tex2d[2] , &tex2d[3] , &tex2d[0]},
  {&uc[1] , &uc[6] , &uc[5], &cc[1] , &cc[6] , &cc[5] , &tex2d[0] , &tex2d[1] , &tex2d[2]},
  {&uc[5] , &uc[2] , &uc[1], &cc[5] , &cc[2] , &cc[1] , &tex2d[2] , &tex2d[3] , &tex2d[0]}
 102};
 103
 104
 105int main(int argc , char** argv) {
  
  if (!al_init()) {return 1;}
  if (!al_init_primitives_addon()) {return 2;}
  if (!al_init_font_addon()) {return 3;}
  if (!al_init_ttf_addon()) {return 4;}
  
  
  if (!al_install_keyboard()) {return 5;}
  if (!al_install_mouse()) {return 6;}
  
 116///    al_set_new_display_option(ALLEGRO_FLOAT_DEPTH , ALLEGRO_REQUIRE , 1);
  al_set_new_display_option(ALLEGRO_DEPTH_SIZE , ALLEGRO_SUGGEST , 32);
  
  al_set_new_display_flags(ALLEGRO_RESIZABLE | ALLEGRO_OPENGL | ALLEGRO_WINDOWED);
  
  ALLEGRO_DISPLAY* d = al_create_display(ww,wh);
  
  if (!d) {return -1;}
  
  ALLEGRO_TIMER* t = al_create_timer(1.0/60.0);
  
  if (!t) {return -2;}
  
  ALLEGRO_EVENT_QUEUE* q = al_create_event_queue();
  
  if (!q) {return -3;}
  
  al_register_event_source(q , al_get_display_event_source(d));
  al_register_event_source(q , al_get_timer_event_source(t));
  al_register_event_source(q , al_get_keyboard_event_source());
  al_register_event_source(q , al_get_mouse_event_source());
  
  int tw = 256;
 139
  /// Consola_ttf comes from our Consola.h header, it is the data for the Consola.ttf file
  
  ALLEGRO_FILE* file = al_open_memfile(Consola_ttf , sizeof(Consola_ttf)/sizeof(unsigned char) , "r");
 143
  if (!file) {
      return -5;
  }
  ALLEGRO_FONT* f = al_load_ttf_font_f(file , "Consola.ttf" , 3*tw/8 , 0);
  
  if (!f) {
      printf("Failed to load ttf font from memfile.\n");
      return -6;
  }
  
  
  /// Create a 2x2 black and white checker texture with text on it
  ALLEGRO_BITMAP* atex = al_create_bitmap(tw,tw);
  
  al_set_target_bitmap(atex);
  al_clear_to_color(al_map_rgba(255,255,255,255));
  
  al_draw_filled_rectangle(0,0,tw/2,tw/2 , al_map_rgba(0,0,0,255));
  al_draw_filled_rectangle(tw/2,tw/2,tw,tw,al_map_rgba(0,0,0,255));
 163
  al_draw_text(f , al_map_rgb(255,255,255) , tw/4 , tw/4 - al_get_font_line_height(f)/2 , ALLEGRO_ALIGN_CENTER , "A");
  al_draw_text(f , al_map_rgb(0,0,0) , 3*tw/4 , tw/4 - al_get_font_line_height(f)/2 , ALLEGRO_ALIGN_CENTER , "B");
  al_draw_text(f , al_map_rgb(0,0,0) , tw/4 , 3*tw/4 - al_get_font_line_height(f)/2 , ALLEGRO_ALIGN_CENTER , "C");
  al_draw_text(f , al_map_rgb(255,255,255) , 3*tw/4 , 3*tw/4 - al_get_font_line_height(f)/2 , ALLEGRO_ALIGN_CENTER , "D");
  
  float rotx = 0.0;
  float roty = 0.0;
  float rotz = 180.0;
 172
  float rotv = 0.5;
  float rotxv = 4*rotv;
  float rotyv = 2*rotv;
  float rotzv = rotv;
  float rotlimit = 360;
  
  bool redraw = true;
  bool quit = false;
  
  int shrink = 0;
  int shrink_dir = 1;
  
  al_start_timer(t);
  
  glEnable(GL_TEXTURE_2D);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
  glDisable(GL_LIGHTING);
  glFrontFace(GL_CCW);
  glCullFace(GL_NONE);
  
  while (!quit) {
      if (redraw) {
          al_set_target_backbuffer(d);
          al_clear_to_color(al_map_rgb(255,255,255));
      
          glClear(GL_DEPTH_BUFFER_BIT);
      
          resetOpenGLmatrices();
          
          float scale = 1.0 - (shrink/(ww/2.0f));
 204///            glScalef(2.0*scale , 2*scale , 2*scale);
          scale = 1.5;
          glScalef(scale , scale , scale);
          glRotatef(rotz , 0 , 0 , 1);
          glRotatef(rotx , 1 , 0 , 0);
          glRotatef(roty , 0 , 1 , 0);
          
          GLuint texid = al_get_opengl_texture(atex);
          glBindTexture(GL_TEXTURE_2D , texid);
 213
 214//*
          /// Draw outside of cube
          glFrontFace(GL_CCW);
          glCullFace(GL_BACK);
          glBegin(GL_TRIANGLES);
          int i = 0;
          while (i < 12) {
              float r,g,b;
              al_color_hsl_to_rgb((i/2)*60.0f , 1.0 , 0.5 , &r , &g , &b);
              
              RGB hue = {r,g,b};
              
              TRI* face = &cube_faces[i];
              XYZ* f[3] = {face->p1 , face->p2 , face->p3};
 228///                XYZ* f2[3] = {face->p3 , face->p2 , face->p1};
 229///                RGB* col[3] = {face->c1 , face->c2 , face->c3};
              TEX2D* txy[3] = {face->tuv1 , face->tuv2 , face->tuv3};
 231
              int j = 0;
              while (j < 3) {
                  XYZ* p = f[j];
 235///                    RGB* c = col[j];
                  RGB* c = &hue;
                  TEX2D* t = txy[j];
                  glColor4f(c->r,c->g,c->b,1.0f);
                  glTexCoord2f(t->u , t->v);
                  glVertex3f(p->x , p->y , p->z);
                  ++j;
              }
              ++i;
          }
          glEnd();
 246
          al_flip_display();
          
          redraw = false;
      }
      do {
          ALLEGRO_EVENT ev;
          al_wait_for_event(q , &ev);
          if (ev.type == ALLEGRO_EVENT_DISPLAY_RESIZE) {
              al_acknowledge_resize(d);
              ww = al_get_display_width(d);
              wh = al_get_display_height(d);
          }
          if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {quit = true;}
          if (ev.type == ALLEGRO_EVENT_KEY_DOWN && ev.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {quit = true;}
          if (ev.type == ALLEGRO_EVENT_TIMER) {
              redraw = true;
 263
              shrink += shrink_dir;
              if (shrink > ww/2) {
                  shrink = ww/2;
                  shrink_dir = -1;
              }
              if (shrink < 0) {
                  shrink = 0;
                  shrink_dir = 1;
              }
              /*
              rotx += rotxv;
              rotx = fmod(rotx , rotlimit);
              roty += rotyv;
              roty = fmod(roty , rotlimit);
              rotz += rotzv;
              rotz = fmod(rotz , rotlimit);
              */
          }
 282//*
          if (ev.type == ALLEGRO_EVENT_MOUSE_AXES) {
              roty = 360.0f*((ww/2) - ev.mouse.x)/(ww/2);
              rotx = 360.0f*((wh/2) - ev.mouse.y)/(wh/2);
              rotz += 30.0f*ev.mouse.dz;
              rotz = fmod(rotz , rotlimit);
              redraw = true;
          }
 290//*/
      } while (!al_is_event_queue_empty(q));
      
  }
  
  
  return 0;
 297}
 298
 299
 300void resetOpenGLmatrices() {
  /// Set the projection matrix
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();/// Reset
 304
 305///    glOrtho(0 , ww , 0 , wh , -1 , 1);/// Use this for 2D projections the size of the screen (ww,wh)
 306
  gluPerspective(90 , ww/(float)wh , 0.5 , 5);/// gluPerspective values for Z should ALWAYS be postive and non-zero
 308
 309
  /// Set the model view matrix
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();/// Reset
  gluLookAt(0 , 0 , -2 , 0 , 0 , 0 , 0 , 1 , 0);/// setup our camera matrix at z = -2 looking at the origin, with a regular up vector
 314}