no-reply@allegro.cc (DanielH) — Sun, 22 Sep 2013 02:29:06 +0000

Hello all,

I'm looking for advice/comments for a canvas class I created.

Back story: I was playing a game on my phone and during the game you could zoom in/out and could wrap the viewing portion. I thought about creating a class that could do the same.

Here is the result:

#SelectExpand
   1#ifndef dLibraryCanvasHeader
   2#define dLibraryCanvasHeader
   3
   4#include 
   5
   6#define dMin( x, y )    ((x)<(y)?(x):(y))
   7#define dMax( x, y )    ((x)>(y)?(x):(y))
   8
   9namespace dLibrary
  10{
class dCanvas
{
public:
  enum dDistinguishers
  {
    dWidth,
    dHeight,
    dXPos,
    dYPos,
  };
  21
  dCanvas()
  {
    this->mDelete = false;
    this->mZoom = 0.0f;
    this->mWrap = false;
    this->mBitmapSize[ dCanvas::dWidth ] = 0;
    this->mBitmapSize[ dCanvas::dHeight ] = 0;
    this->mCamera[ dCanvas::dXPos ] = 0;
    this->mCamera[ dCanvas::dYPos ] = 0;
    this->mCamera[ dCanvas::dWidth ] = 0;
    this->mCamera[ dCanvas::dHeight ] = 0;
    this->mBitmap = 0;
    this->mDrawBitmap = al_draw_scaled_bitmap;
  }
  36
  dCanvas( const int width, const int height )
  {
    this->mDelete = false;
    this->mZoom = 0.0f;
    this->mWrap = false;
    this->mBitmapSize[ dCanvas::dWidth ] = 0;
    this->mBitmapSize[ dCanvas::dHeight ] = 0;
    this->mCamera[ dCanvas::dXPos ] = 0;
    this->mCamera[ dCanvas::dYPos ] = 0;
    this->mCamera[ dCanvas::dWidth ] = 0;
    this->mCamera[ dCanvas::dHeight ] = 0;
  48
    int flags = al_get_new_bitmap_flags();
    
    al_set_new_bitmap_flags( ALLEGRO_VIDEO_BITMAP | ALLEGRO_MAG_LINEAR | ALLEGRO_MIN_LINEAR );
  52
    this->mBitmap = al_create_bitmap( width, height );
  54
    al_set_new_bitmap_flags( flags );
  56
    this->mDrawBitmap = al_draw_scaled_bitmap;
  58
    if ( this->mBitmap )
    {
      this->mBitmapSize[ dCanvas::dWidth ] = width;
      this->mBitmapSize[ dCanvas::dHeight ] = height;
      this->mCamera[ dCanvas::dXPos ] = 0;
      this->mCamera[ dCanvas::dYPos ] = 0;
      this->mCamera[ dCanvas::dWidth ] = this->mBitmapSize[ dCanvas::dWidth ];
      this->mCamera[ dCanvas::dHeight ] = this->mBitmapSize[ dCanvas::dHeight ];
      this->mZoom = 1.0f;
      this->mDelete = true;
    }
  }
  71
  dCanvas( ALLEGRO_BITMAP *bitmap, bool doDelete = false )
  {
    this->mDelete = doDelete;
    this->mZoom = 0.0f;
    this->mWrap = false;
    this->mBitmapSize[ dCanvas::dWidth ] = 0;
    this->mBitmapSize[ dCanvas::dHeight ] = 0;
    this->mCamera[ dCanvas::dXPos ] = 0;
    this->mCamera[ dCanvas::dYPos ] = 0;
    this->mCamera[ dCanvas::dWidth ] = 0;
    this->mCamera[ dCanvas::dHeight ] = 0;
    this->mBitmap = bitmap;
    this->mDrawBitmap = al_draw_scaled_bitmap;
  85
    if ( this->mBitmap )
    {
      this->mBitmapSize[ dCanvas::dWidth ] = al_get_bitmap_width( this->mBitmap );
      this->mBitmapSize[ dCanvas::dHeight ] = al_get_bitmap_height( this->mBitmap );
      this->mCamera[ dCanvas::dXPos ] = 0;
      this->mCamera[ dCanvas::dYPos ] = 0;
      this->mCamera[ dCanvas::dWidth ] = this->mBitmapSize[ dCanvas::dWidth ];
      this->mCamera[ dCanvas::dHeight ] = this->mBitmapSize[ dCanvas::dHeight ];
      this->mZoom = 1.0f;
      this->mDelete = true;
    }
  }
  98
  ~dCanvas()
  {
    if ( this->mBitmap && this->mDelete )
    {
      al_destroy_bitmap( this->mBitmap );
    }
  }
 106
  void beginDrawing()
  {
    al_set_target_bitmap( this->mBitmap );
  }
 111
  void flipToDisplay( ALLEGRO_DISPLAY *display )
  {
    al_set_target_backbuffer( display );
 115
    int targetBitmapSize[ 2 ] = { al_get_display_width( display ), al_get_display_height( display ) };
 117
    if ( this->mWrap )
    {
      if ( this->mCamera[ dCanvas::dXPos ] >= 0 && 
         this->mCamera[ dCanvas::dXPos ] <= ( this->mBitmapSize[ dCanvas::dWidth ] - this->mCamera[ dCanvas::dWidth ] ) )
      {
        if ( this->mCamera[ dCanvas::dYPos ] >= 0 &&
           this->mCamera[ dCanvas::dYPos ] <= ( this->mBitmapSize[ dCanvas::dHeight ] - this->mCamera[ dCanvas::dHeight ] ) )
        {
          this->mDrawBitmap( this->mBitmap, 
                       this->mCamera[ dCanvas::dXPos ], this->mCamera[ dCanvas::dYPos ], this->mCamera[ dCanvas::dWidth ], this->mCamera[ dCanvas::dHeight ],
                       0, 0, targetBitmapSize[ dCanvas::dWidth ], targetBitmapSize[ dCanvas::dHeight ],       
                       0 );      
        }
        else
        {
          int h1 = this->mBitmapSize[ dCanvas::dHeight ] - this->mCamera[ dCanvas::dYPos ];
          int h2 = this->mCamera[ dCanvas::dHeight ] - h1;
          int y2 = ( targetBitmapSize[ dCanvas::dHeight ] * h1 ) / this->mCamera[ dCanvas::dHeight ];
 136
 137
          this->mDrawBitmap( this->mBitmap, 
                       this->mCamera[ dCanvas::dXPos ], this->mCamera[ dCanvas::dYPos ], this->mCamera[ dCanvas::dWidth ], h1,
                       0, 0, targetBitmapSize[ dCanvas::dWidth ], y2,       
                       0 );  
 142
          this->mDrawBitmap( this->mBitmap, 
                       this->mCamera[ dCanvas::dXPos ], 0, this->mCamera[ dCanvas::dWidth ], h2,
                       0, y2, targetBitmapSize[ dCanvas::dWidth ], targetBitmapSize[ dCanvas::dHeight ] - y2,
                       0 );  
        }  
      }
      else
      {
        if ( this->mCamera[ dCanvas::dYPos ] >= 0 &&
           this->mCamera[ dCanvas::dYPos ] <= ( this->mBitmapSize[ dCanvas::dHeight ] - this->mCamera[ dCanvas::dHeight ] ) )
        {
          int w1 = this->mBitmapSize[ dCanvas::dWidth ] - this->mCamera[ dCanvas::dXPos ];
          int w2 = this->mCamera[ dCanvas::dWidth ] - w1;
 156
          int x2 = ( targetBitmapSize[ dCanvas::dWidth ] * w1 ) / this->mCamera[ dCanvas::dWidth ];
 158
 159
          this->mDrawBitmap( this->mBitmap, 
                       this->mCamera[ dCanvas::dXPos ], this->mCamera[ dCanvas::dYPos ], w1, this->mCamera[ dCanvas::dHeight ],
                       0, 0, x2, targetBitmapSize[ dCanvas::dHeight ],
                       0 );  
 164
          this->mDrawBitmap( this->mBitmap, 
                       0, this->mCamera[ dCanvas::dYPos ], w2, this->mCamera[ dCanvas::dHeight ],
                       x2, 0, targetBitmapSize[ dCanvas::dWidth ] - x2, targetBitmapSize[ dCanvas::dHeight ],
                       0 );  
        }
        else
        {
          int w1 = this->mBitmapSize[ dCanvas::dWidth ] - this->mCamera[ dCanvas::dXPos ];
          int w2 = this->mCamera[ dCanvas::dWidth ] - w1;
          int h1 = this->mBitmapSize[ dCanvas::dHeight ] - this->mCamera[ dCanvas::dYPos ];
          int h2 = this->mCamera[ dCanvas::dHeight ] - h1;
 176
          int y2 = ( targetBitmapSize[ dCanvas::dHeight ] * h1 ) / this->mCamera[ dCanvas::dHeight ];
          int x2 = ( targetBitmapSize[ dCanvas::dWidth ] * w1 ) / this->mCamera[ dCanvas::dWidth ];
 179
 180
          this->mDrawBitmap( this->mBitmap, 
                       this->mCamera[ dCanvas::dXPos ], this->mCamera[ dCanvas::dYPos ], w1, h1,
                       0, 0, x2, y2,
                       0 );  
 185
          this->mDrawBitmap( this->mBitmap, 
                       this->mCamera[ dCanvas::dXPos ], 0, w1, h2,
                       0, y2, x2, targetBitmapSize[ dCanvas::dHeight ] - y2,
                       0 );  
 190
          this->mDrawBitmap( this->mBitmap, 
                       0, this->mCamera[ dCanvas::dYPos ], w2, h1,
                       x2, 0, targetBitmapSize[ dCanvas::dWidth ] - x2, y2,
                       0 );  
 195
          this->mDrawBitmap( this->mBitmap, 
                       0, 0, w2, h2,
                       x2, y2, targetBitmapSize[ dCanvas::dWidth ] - x2, targetBitmapSize[ dCanvas::dHeight ] - y2,
                       0 );  
        }
      }
    }
    else
    {
      this->mDrawBitmap( this->mBitmap, 
                 this->mCamera[ dCanvas::dXPos ], this->mCamera[ dCanvas::dYPos ], this->mCamera[ dCanvas::dWidth ], this->mCamera[ dCanvas::dHeight ],
                 0, 0, targetBitmapSize[ dCanvas::dWidth ], targetBitmapSize[ dCanvas::dHeight ], 
                 0 );
    }
 210
    al_flip_display();
  }
 213
  ALLEGRO_BITMAP *getBitmap()
  {
    return this->mBitmap;
  }
 218
  void setZoom( float zoom )
  {
    this->mZoom = dMax( 1.0f, zoom );
 222
    this->mCamera[ dCanvas::dXPos ] = 0;
    this->mCamera[ dCanvas::dYPos ] = 0;
    this->mCamera[ dCanvas::dWidth ] = int( float( this->mBitmapSize[ dCanvas::dWidth ] ) / this->mZoom );
    this->mCamera[ dCanvas::dHeight ] = int( float( this->mBitmapSize[ dCanvas::dHeight ] ) / this->mZoom );
  }
 228
  void setWrap( bool wrap )
  {
    this->mWrap = wrap;
  }
 233
  void doScroll( int dx, int dy )
  {
    if ( dx != 0 )
    {
      this->mCamera[ dCanvas::dXPos ] += dx;
 239
      if ( this->mWrap )
      {
        if ( this->mCamera[ dCanvas::dXPos ] < 0 )
        {
          this->mCamera[ dCanvas::dXPos ] += this->mBitmapSize[ dCanvas::dWidth ];
        }
 246
        if ( this->mCamera[ dCanvas::dXPos ] >= this->mBitmapSize[ dCanvas::dWidth ] )
        {
          this->mCamera[ dCanvas::dXPos ] -= this->mBitmapSize[ dCanvas::dWidth ];
        }
      }
      else
      {
        this->mCamera[ dCanvas::dXPos ] = dMax( 0, dMin( this->mCamera[ dCanvas::dXPos ], this->mBitmapSize[ dCanvas::dWidth ] - this->mCamera[ dCanvas::dWidth ] ) );
      }
    }
 257
    if ( dy != 0 )
    {
      this->mCamera[ dCanvas::dYPos ] += dy;
 261
      if ( this->mWrap )
      {
        if ( this->mCamera[ dCanvas::dYPos ] < 0 )
        {
          this->mCamera[ dCanvas::dYPos ] += this->mBitmapSize[ dCanvas::dHeight ];
        }
 268
        if ( this->mCamera[ dCanvas::dYPos ] >= this->mBitmapSize[ dCanvas::dHeight ] )
        {
          this->mCamera[ dCanvas::dYPos ] -= this->mBitmapSize[ dCanvas::dHeight ];
        }
      }
      else
      {
        this->mCamera[ dCanvas::dYPos ] = dMax( 0, dMin( this->mCamera[ dCanvas::dYPos ], this->mBitmapSize[ dCanvas::dHeight ] - this->mCamera[ dCanvas::dHeight ] ) );
      }
    }
  }
 280
  void convertMouseCoordinates( ALLEGRO_DISPLAY *display, int &x, int &y )
  {
    x = ( x * this->mBitmapSize[ dCanvas::dWidth ] ) / al_get_display_width( display );
    y = ( y * this->mBitmapSize[ dCanvas::dHeight ] ) / al_get_display_height( display );
 285
    if ( ( this->mZoom - 1.0f ) < 0.0000001f )
    {
      x += ( this->mBitmapSize[ dCanvas::dWidth ] - this->mCamera[ dCanvas::dXPos ] );
      y += ( this->mBitmapSize[ dCanvas::dHeight ] - this->mCamera[ dCanvas::dYPos ] );
    }
    else
    {
      x = ( int( float( x ) / this->mZoom ) ) + this->mCamera[ dCanvas::dXPos ];
      y = ( int( float( y ) / this->mZoom ) ) + this->mCamera[ dCanvas::dYPos ];
    }
 296
    x %= this->mBitmapSize[ dCanvas::dWidth ];
    y %= this->mBitmapSize[ dCanvas::dHeight ];
  } 
 300
  void setDrawScaledBitmapFunction( void (*drawfunc)( ALLEGRO_BITMAP *bitmap, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, int flags ) )
  {
    this->mDrawBitmap = drawfunc;
  }
 305
  int getWidth()
  {
    return this->mBitmapSize[ dCanvas::dWidth ];
  }
 310
  int getHeight()
  {
    return this->mBitmapSize[ dCanvas::dHeight ];
  }
 315
private:
  ALLEGRO_BITMAP *mBitmap;
  bool mDelete;
  int mBitmapSize[ 2 ];
  int mCamera[ 4 ];
  float mZoom;
  bool mWrap;
  void (*mDrawBitmap)( ALLEGRO_BITMAP *bitmap, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, int flags );
};
 325}
 326
 327#endif

There is also a function to convert mouse display coordinates to corresponding position of canvas.

Example:

void dGameView::draw( ALLEGRO_DISPLAY *display )
{
  this->mCanvas->beginDrawing();

  // TODO: do all drawing here

  this->mCanvas->flipToDisplay( display );
}

The advice I'm looking for is if there are any optimizations that I could do to speed things up.

no-reply@allegro.cc (jmasterx) — Sun, 22 Sep 2013 22:16:17 +0000

Any particular reason you don't use the graphics card to do your transformations?
https://www.allegro.cc/manual/5/transformations.html

And this for the mouse: http://alleg.sourceforge.net/a5docs/refman/transformations.html#al_transform_coordinates

no-reply@allegro.cc (DanielH) — Sun, 22 Sep 2013 23:21:24 +0000

I was reading this article about resolution independence. It said that "using a stretched buffer" ... "is preferred if your game is using a lot of bitmaps."

Still trying to wrap my head about the whole resolution independence idea.

no-reply@allegro.cc (jmasterx) — Sun, 22 Sep 2013 23:31:39 +0000

I wonder where that conclusion came from.

If you use transformations, everything you draw is sent to the graphics card, then the graphics card multiplies the view matrix by your transformation matrix to figure out where the fragments will be in screen space.

Using a stretched buffer I would fear would drive a game closer to being fill limited. Graphics cards have a limit to the number of pixels they can fill. So first you 'fill' your buffer, then you blit that, effectivly doing tripple buffering amd filling a lot more pixels.

no-reply@allegro.cc (Thomas Fjellstrom) — Mon, 23 Sep 2013 03:07:40 +0000

jmasterx said:

Allegro 5 uses geometry and tex coords to stretch bitmaps to the display or textures (most bitmaps) afaik. So I don't think it's much different than using transforms.

Custom Canvas Optimization