Allegro has transforms as well. See http://docs.liballeg.org. You could use the code you have with some added transformations.

Thanks guys. Edgar, that would work but I need to draw regions.

Trent, can you offer any insight on how I would use Allegro transforms to handle scaling and rotation?

al_create_sub_bitmap

Yes, you have to use al_use_transform. You have to save the old transformation if you want to reset back to it.

You'll have to add a few translate transforms in there.

identity
translate (to origin, center on the middle of your region)
scale
rotate
translate (back to where your sprite was)
use transform

Try:

ALLEGRO_TRANSFORM T;
al_identity_transform(&T);
al_translate_transform(&T, -this->width / 2, -this->height / 2);
al_scale_transform(&T, this->getScale(), this->getScale());
al_rotate_transform(&T, this->getRotation());
al_translate_transform(&T, this->getX() + this->width / 2, this->getY() + this->height / 2);
al_use_transform(&T);

No, you need to copy it elsewhere:

ALLEGRO_TRANSFORM old;
al_copy_transform(&old, al_get_current_transform());

this->beginTransform();
al_draw_bitmap_region(this->image, fx, fy, this->width, this->height, this->getX(), this->getY(), 0);

al_use_transform(&old);

Oh, I missed one bit. With the set of transforms I suggested you need to draw like this:

al_draw_bitmap_region(this->image, fx, fy, this->width, this->height, 0, 0, 0);

Note the 0's in the destination: the transformation takes entirely of the positioning.

One question - are your coordinates in real space or screen space?

Nevermind - I guess Siegelord is right.

Okay, well if you ever use a camera, just remember that you need to subtract the camera position from the object position to get its screen coordinates.

Well, thing is, (0, 0) is the initial pair of coordinates that you specify before they get transformed. The full explanation probably requires pictures, but I don't feel like drawing right now. Let me try to explain in words then. Let's go through the list of transformations and see how it affects the output of al_draw_bitmap(bmp, 0, 0, 0):

1. al_identity_transform(&T);

After this call al_draw_bitmap draws like usual, with the top-left corner at (0, 0).

2. al_translate_transform(&T, -this->width / 2, -this->height / 2);

After this call the al_draw_bitmap call will be offset, so that the top left corner will now be at (-this->width / 2, -this->height / 2). We do this so that the middle of the bitmap is at (0, 0). Note that this step (and this step alone) can be removed by doing al_draw_bitmap(bmp, -this->width / 2, -this->height / 2, 0).

3. al_scale_transform(&T, this->getScale(), this->getScale());

After this call the top left corner will be at (this->getScale() * -this->width / 2, this->getScale() * -this->height / 2) and the bitmap will also be drawn bigger. The critical bit here (and why we did step #2) is that the center of the bitmap doesn't move with scaling. If the center was not at (0, 0) it would be scaled, and we'd have a mess.

4. al_rotate_transform(&T, this->getRotation());

After this call the bitmap will be rotated about (0, 0). Since we took care to place the bitmap's center at (0, 0) it will be rotated around its center.

5. al_translate_transform(&T, this->getX() + this->width / 2, this->getY() + this->height / 2);

After this call the bitmap's center will move to (this->getX() + this->width / 2, this->getY() + this->height / 2).

If we had no rotation and scaling, then we'd just have this:

ALLEGRO_TRANSFORM T;
al_identity_transform(&T);
al_translate_transform(&T, -this->width / 2, -this->height / 2);
al_translate_transform(&T, this->getX() + this->width / 2, this->getY() + this->height / 2);
al_use_transform(&T);
al_draw_bitmap(bmp, 0, 0, 0);

Translations simply add, so if you followed the steps above it should be clear to see how this code is exactly equivalent to:

al_draw_bitmap(bmp, this->getX(), this->getY(), 0);

Lastly, there is a function to simplify this process a bit:

ALLEGRO_TRANSFORM T;
al_build_transform(&T, this->getX() + this->width / 2, this->getY() + this->height / 2, this->getScale(), this->getScale(), this->getRotation());
al_use_transform(&T);
al_draw_bitmap(bmp, -this->width / 2, -this->height / 2, 0, 0);

Right, except there are two sets of translations. Here's what happens:

Original set of transformations | New set of transformations
Initial location: 0, 0            Initial location: -w/2, -h/2
Translate(-w/2, -h/2)  ---------------------------------^ moved to here
Scale       \
Rotate      |-------------------> combined into al_build_transform
Translate   /

Fine, except for that's not what your code example shows.