The scenario, pseudo-like:

set_target_bitmap(create_sub_bitmap(somebitmap))
draw_some_stuff()
draw_filled_rectangle()
draw_some_more_stuff()

When I do this, everything in the same frame after the primitive is drawn as if the sub-bitmap originated at (0, 0) rather than wherever it originates. In other words, half the stuff or so on screen ends up massively offset. xofs and yofs in the ALLEGRO_BITMAP structure are still correct, however. It does appear to draw to the correct parent bitmap (i.e. somebitmap).

If I remove the call to draw_filled_rectangle(), everything works correctly, so this surely cannot be an issue in my code.

Suggestions?

APPEND: Surrounding the primitive draw call with al_store_state(&st, ALLEGRO_STATE_TRANSFORM); causes the error to disappear, so the primitive rendering is apparently doing something inappropriate to the transforms.

Sounds like a bad bug... Is there any primitive specifically that triggers the behavior?

Edit: I'm unable to reproduce it using a small test program on Windows with D3D or OpenGL. What types of bitmaps are you working with? Backbuffer, memory, etc.

I'm having trouble reproducing it as well. Here's the test code I used:

Aside from the backbuffer provided by Allegro, I have a separate bitmap that is 1/4 the size of the backbuffer (256x240 vs. 512x480). I then have a sub-bitmap inside this second bitmap, which is 256x244 and offset by 8 on the y-axis. I don't know if it matters, but there is then a clipping rectangle in place on top of this, but in this case it equals the size of the 256x244 sub-bitmap.

Then I draw some bitmaps, then the filled rectangle, then some more bitmaps. Finally the larger bitmap is draw_scaled to the real backbuffer. Then I flip. The second batch of bitmaps is drawn 8 pixels above the first. The exact distance changes if I change where the sub-bitmap starts, along both the X and Y axes.

I only tried with filled and stroked rectangles, but it happens for both of those.

I assume you mean 256x224. But still I cannot duplicate your behavior.

However, it looks like OpenGL totally ignores the clipping on a sub bitmap. Using the D3D driver, I get results I expect when clipping a sub bitmap. On OpenGL, it's as if the clipping rectangle was never set.

Update: The patch here might help, if this was somehow related to the clipping not being set.

Yes, I meant 256x224. I forgot to check last night, but I don't think this is a clipping issue. The bitmaps are literally offset, not inappropriately clipped. I don't know if I'm using the OpenGL driver; whatever is the default on Windows 7.

I'll try and cook up a smaller reproduction sample...

If it's particular to D3D or OpenGL you can easily find out:

#include <allegro5/allegro_direct3d.h>
#include <allegro5/allegro_opengl.h>

al_set_new_display_flags(ALLEGRO_OPENGL);
// al_set_new_display_flags(ALLEGRO_DIRECT3D);