I'm trying to work with Allegro 5 transformations but I'm struggling to understand how they work. Maybe I'm just getting it all wrong so I wrote a couple code samples.

For the previous code this is what I get vs. what I'd expect:
{"name":"611169","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/e\/d\/ede6f44fc3e93134343ee41009defbe9.png","w":1524,"h":378,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/e\/d\/ede6f44fc3e93134343ee41009defbe9"}

If instead I use the following code:

{"name":"611170","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/9\/3\/934e0a438a9a35741a7fbb6c2e9c494a.png","w":1524,"h":378,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/9\/3\/934e0a438a9a35741a7fbb6c2e9c494a"}

So, what am I doing wrong here?.

Thanks.

But that's incredibly counter-intuitive, at least for me; even more so considering that the Allegro documentation says that transformations are applied in the order you write them. In your sample code, the way you have to use that al_identity_transform() + al_translate_transform() + al_compose_transform() combo every time just proves how counter-intuitive it is.

Consider the following shape:

What should be a really simple shape to draw, requires the following code which, no matter how much I try to understand, I can't quite get what the transformations are doing:

    al_identity_transform(&t);
    al_scale_transform(&t, .5, .5);
    al_use_transform(&t);
    al_draw_filled_rectangle(0, 0, 400, 400, al_map_rgb(255, 0, 0));
    al_scale_transform(&t, .5, .5);
    al_translate_transform(&t, 100, 100);
    al_use_transform(&t);
    al_draw_filled_rectangle(-200, -200, 200, 200, al_map_rgb(0, 255, 0));
    al_scale_transform(&t, .5, .5);
    al_translate_transform(&t, 50, 50); 
    al_use_transform(&t);
    al_draw_filled_rectangle(-200, -200, 200, 200, al_map_rgb(0, 0, 255));

The marked line, for example, what is it supposed to do? It's translating the transform by 50 units relative to what? I really don't understand how this works, I played with the values just to get the expected output which, by the way, makes this code only work at the corner of the screen, if I try to draw to the center of the screen, for example, then the values become totally different. Add translations, scale and rotations and the code becomes a real mess!. Can someone care to explain how the code above produces the result? How can you draw that same result at, say, the center of the screen?.

Maybe it's just me but I find the way transformations work to be incredibly counter-intuitive. Might as well prefer to instead use OpenGL matrices at this point.

Just curious, what was the reasoning or train of thought that resulted in this?

Allegro's transforms are pretty straight forward. That code you posted is misleading because it keeps applying progressive transforms instead of rebuild it anew for each shape.

The transformations are applied in the order that you apply them. Whether allegro is performing a left or right hand multiply behind the scenes doesn't matter. And yes it's backwards to OpenGL, but thank God for that, because IMO OpenGL is backwards.

EDIT
https://github.com/EdgarReynaldo/EagleGUI/blob/master/include/Eagle/Transforms.hpp

Because the way OpenGL does it is backwards. There's nothing complicated, or counter intuitive about the way Allegro does it as long as your mind hasn't been poisoned by OpenGL's matrix stack order.

Your example is (unintentionally) contrived to favor OpenGL's order of multiplication, but in a realistic setting there is less difference between the two orders.

Here's a slightly more realistic use example (you can try to uncomment some lines to see how things compose):

The OpenGL order version of the above code would not be that much different.

The correct transformation for each rectangle would be 'translate' (center on origin), 'scale' (and/or) 'rotate' , 'translate' (move to proper destination).

Or you could simply draw a rectangle centered on 0.0 yourself, that is 1.0 units wide, and 1.0 units high, scaled appropriately, and then centered on your destination.

The performance hit for rebuilding a matrix is pretty slim. Don't worry about it. And if you're worried about function calls, please don't.

void DrawMyRectangle(float width , float height , float cx , float cy , ALLEGRO_COLOR col) {
   ALLEGRO_TRANSFORM t;
   al_identity_transform(&t);
   al_scale_transform(&t , width , height);
   al_translate_transform(&t , cx , cy);
   al_use_transform(&t);
   al_draw_filled_rectangle(-0.5f , -0.5f , 0.5f , 0.5f , col);
}

/// later in main
DrawMyRectangle(400 , 400 , 200 , 200 , al_map_rgb(255,255,255));
DrawMyRectangle(200 , 200 , 200 , 200 , al_map_rgb(192,192,192));
DrawMyRectangle(100 , 100 , 200 , 200 , al_map_rgb(128,128,128));
DrawMyRectangle(50 , 50 , 200 , 200 , al_map_rgb(64,64,64));

{"name":"611175","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/d\/9\/d990e56a38578790702d0b238a8b9150.png","w":428,"h":452,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/d\/9\/d990e56a38578790702d0b238a8b9150"}

Calling al_draw_bitmap does not reset the transformations, but al_set_target_bitmap will and does.

I don't know if al_draw_bitmap_region respects the current transformations or not.

EDIT
I know the primitives addon respects the transformations. You could render your bitmap as a primitive triangle fan.

Thing is, every time you change the target bitmap, the view and projection matrices get reset.

If you want to do it with OpenGL alone, you have to do it this way :

void ResetTransforms() {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0 , SCREEN_WIDTH , 0 , SCREEN_HEIGHT , -1.0 , 1.0);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

This sets you up with a plain orthographic 2D projection matrix and an identity view matrix.

Call this after setting the target bitmap. If you're using a buffer, use its width and height for SCREEN_WIDTH and SCREEN_HEIGHT.

Then make your OpenGL calls and you can draw directly on the allegro screen.

Anytime you want to restore your projections, reset the target bitmap (hope they don't cache the previous target and NOP if its the same).

Personally I think allegro's transforms are easier.

EDIT
I checked the allegro source, and al_draw_bitmap uses its own transformations, along with every other bitmap drawing routine, because they all use the same underlying function but it doesn't respect OpenGL state, only the current allegro transform for the current target bitmap

Edgar, I don't want to reset the transformations, on the contrary, I'd expect for al_draw_bitmap() not to.

Yeah, exactly my thought but apparently it's not so in practice.
Can't check the Allegro source right now but if, as Edgar points out in his edit, al_draw_bitmap() (and all other bitmap drawing routines) work based on Allegro transformations then if the first thing these functions do is, for example, call al_get_current_transform() then the result might not reflect any changes you manually made using OpenGL function calls.

So, I guess I have to understand Allegro transformations or attempt to draw the bitmaps using primitives, as suggested earlier.

I did listen to you, I was just poiting out what I originally expected.

As mentioned in the last line of my previous post, that's what I will do.

Thanks everyone for your help in this thread. It was really useful.

Yeah, after all the explanations in this thread and studying the contributed code I was able to make the Allegro transforms work as expected in my project. I still don't find them quite as intuitive but I guess I'm starting to get the hold of it.

Thanks again and I will take a look at those links.