ogl_display.c

/*         ______   ___    ___
 *        /\  _  \ /\_ \  /\_ \
 *        \ \ \L\ \\//\ \ \//\ \      __     __   _ __   ___ 
 *         \ \  __ \ \ \ \  \ \ \   /'__`\ /'_ `\/\`'__\/ __`\
 *          \ \ \/\ \ \_\ \_ \_\ \_/\  __//\ \L\ \ \ \//\ \L\ \
 *           \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
 *            \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
 *                                           /\____/
 *                                           \_/__/
 *
 *      OpenGL routines common to all OpenGL drivers.
 *
 *      By Elias Pschernig and Milan Mimica.
 *
 */

#include "allegro5/allegro.h"
#include "allegro5/allegro_opengl.h"
#include "allegro5/internal/aintern.h"
#include "allegro5/internal/aintern_opengl.h"
#include "allegro5/internal/aintern_pixels.h"
#include "allegro5/transformations.h"	

#ifdef ALLEGRO_IPHONE
#include "allegro5/internal/aintern_iphone.h"
#endif

#ifdef ALLEGRO_ANDROID
#include "allegro5/internal/aintern_android.h"
#endif

#include "ogl_helpers.h"

ALLEGRO_DEBUG_CHANNEL("opengl")

/* Helper to set up GL state as we want it. */
void _al_ogl_setup_gl(ALLEGRO_DISPLAY *d)
{
   ALLEGRO_OGL_EXTRAS *ogl = d->ogl_extras;

   if (ogl->backbuffer) {
      ALLEGRO_BITMAP *target = al_get_target_bitmap();
      _al_ogl_resize_backbuffer(ogl->backbuffer, d->w, d->h);
      /* If we are currently targetting the backbuffer, we need to update the
       * transformations. */
      if (target && (target == ogl->backbuffer ||
                     target->parent == ogl->backbuffer)) {
         /* vt should be set at this point, but doesn't hurt to check */
         ASSERT(d->vt);
         d->vt->update_transformation(d, target);
      }
   } else {
      ogl->backbuffer = _al_ogl_create_backbuffer(d);
   }
}


void _al_ogl_set_target_bitmap(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *bitmap)
{
   ALLEGRO_BITMAP *target = bitmap;
   if (bitmap->parent)
      target = bitmap->parent;

   /* if either this bitmap or its parent (in the case of subbitmaps)
    * is locked then don't do anything
    */
   if (bitmap->locked)
      return;
   if (bitmap->parent && bitmap->parent->locked)
      return;

   _al_ogl_setup_fbo(display, bitmap);
   if (display->ogl_extras->opengl_target == target) {
      _al_ogl_setup_bitmap_clipping(bitmap);
   }
}


void _al_ogl_unset_target_bitmap(ALLEGRO_DISPLAY *display,
   ALLEGRO_BITMAP *target)
{
   if (!target)
      return;
   _al_ogl_finalize_fbo(display, target);
}


/* Function: al_set_current_opengl_context
 */
void al_set_current_opengl_context(ALLEGRO_DISPLAY *display)
{
   ASSERT(display);

   if (!(display->flags & ALLEGRO_OPENGL))
      return;

   if (display) {
      ALLEGRO_BITMAP *bmp = al_get_target_bitmap();
      if (bmp && _al_get_bitmap_display(bmp) &&
            _al_get_bitmap_display(bmp) != display) {
         al_set_target_bitmap(NULL);
      }
   }

   _al_set_current_display_only(display);
}


void _al_ogl_setup_bitmap_clipping(const ALLEGRO_BITMAP *bitmap)
{
   int x_1, y_1, x_2, y_2, h;
   bool use_scissor = true;

   x_1 = bitmap->cl;
   y_1 = bitmap->ct;
   x_2 = bitmap->cr_excl;
   y_2 = bitmap->cb_excl;
   h = bitmap->h;

   /* Drawing onto the sub bitmap is handled by clipping the parent. */
   if (bitmap->parent) {
      x_1 += bitmap->xofs;
      y_1 += bitmap->yofs;
      x_2 += bitmap->xofs;
      y_2 += bitmap->yofs;
      h = bitmap->parent->h;
   }

   if (x_1 == 0 &&  y_1 == 0 && x_2 == bitmap->w && y_2 == bitmap->h) {
      if (bitmap->parent) {
         /* Can only disable scissor if the sub-bitmap covers the
          * complete parent.
          */
         if (bitmap->xofs == 0 && bitmap->yofs == 0 &&
            bitmap->w == bitmap->parent->w && bitmap->h == bitmap->parent->h)
         {
            use_scissor = false;
         }
      }
      else {
         use_scissor = false;
      }
   }
   if (!use_scissor) {
      glDisable(GL_SCISSOR_TEST);
   }
   else {
      glEnable(GL_SCISSOR_TEST);
       
      #ifdef ALLEGRO_IPHONE
      _al_iphone_clip(bitmap, x_1, y_1, x_2, y_2);
      #else
      /* OpenGL is upside down, so must adjust y_2 to the height. */
      glScissor(x_1, h - y_2, x_2 - x_1, y_2 - y_1);
      #endif
   }
}


ALLEGRO_BITMAP *_al_ogl_get_backbuffer(ALLEGRO_DISPLAY *d)
{
   return (ALLEGRO_BITMAP *)d->ogl_extras->backbuffer;
}


bool _al_ogl_resize_backbuffer(ALLEGRO_BITMAP *b, int w, int h)
{
   int pitch;
   ALLEGRO_BITMAP_EXTRA_OPENGL *extra = b->extra;
         
   pitch = w * al_get_pixel_size(al_get_bitmap_format(b));

   b->w = w;
   b->h = h;
   b->pitch = pitch;
   b->cl = 0;
   b->ct = 0;
   b->cr_excl = w;
   b->cb_excl = h;
   al_identity_transform(&b->proj_transform);
   al_orthographic_transform(&b->proj_transform, 0, 0, -1.0, w, h, 1.0);

   /* There is no texture associated with the backbuffer so no need to care
    * about texture size limitations. */
   extra->true_w = w;
   extra->true_h = h;

   b->memory = NULL;

   return true;
}


ALLEGRO_BITMAP* _al_ogl_create_backbuffer(ALLEGRO_DISPLAY *disp)
{
   ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_backbuffer;
   ALLEGRO_BITMAP *backbuffer;
   int format;

   ALLEGRO_DEBUG("Creating backbuffer\n");

   // FIXME: _al_deduce_color_format would work fine if the display paramerers
   // are filled in, for OpenGL ES
   if (IS_OPENGLES) {
      if (disp->extra_settings.settings[ALLEGRO_COLOR_SIZE] == 16) {
         format = ALLEGRO_PIXEL_FORMAT_RGB_565;
      }
      else {
         format = ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE;
      }
   }
   else {
      format = _al_deduce_color_format(&disp->extra_settings);
      /* Eww. No OpenGL hardware in the world does that - let's just
       * switch to some default.
       */
      if (al_get_pixel_size(format) == 3) {
         /* Or should we use RGBA? Maybe only if not Nvidia cards? */
         format = ALLEGRO_PIXEL_FORMAT_ABGR_8888;
      }
   }
   ALLEGRO_TRACE_CHANNEL_LEVEL("display", 1)("Deduced format %s for backbuffer.\n",
      _al_pixel_format_name(format));

   /* Now that the display backbuffer has a format, update extra_settings so
    * the user can query it back.
    */
   _al_set_color_components(format, &disp->extra_settings, ALLEGRO_REQUIRE);
   disp->backbuffer_format = format;

   ALLEGRO_DEBUG("Creating backbuffer bitmap\n");
   /* Using ALLEGRO_NO_PRESERVE_TEXTURE prevents extra memory being allocated */
   backbuffer = _al_ogl_create_bitmap(disp, disp->w, disp->h,
      format, ALLEGRO_VIDEO_BITMAP | ALLEGRO_NO_PRESERVE_TEXTURE);
   if (!backbuffer) {
      ALLEGRO_DEBUG("Backbuffer bitmap creation failed.\n");
      return NULL;
   }

   backbuffer->w = disp->w;
   backbuffer->h = disp->h;
   backbuffer->cl = 0;
   backbuffer->ct = 0;
   backbuffer->cr_excl = disp->w;
   backbuffer->cb_excl = disp->h;
   al_identity_transform(&backbuffer->transform);
   al_identity_transform(&backbuffer->proj_transform);
   al_orthographic_transform(&backbuffer->proj_transform, 0, 0, -1.0, disp->w, disp->h, 1.0);

   ALLEGRO_TRACE_CHANNEL_LEVEL("display", 1)(
      "Created backbuffer bitmap (actual format: %s)\n",
      _al_pixel_format_name(al_get_bitmap_format(backbuffer)));

   ogl_backbuffer = backbuffer->extra;
   ogl_backbuffer->true_w = disp->w;
   ogl_backbuffer->true_h = disp->h;
   ogl_backbuffer->is_backbuffer = 1;
   backbuffer->_display = disp;

   return backbuffer;
}


void _al_ogl_destroy_backbuffer(ALLEGRO_BITMAP *b)
{
   al_destroy_bitmap(b);
}


/* vi: set sts=3 sw=3 et: */