I want to draw everything to a non-screen ALLEGRO_BITMAP, then blit it to the screen at twice the size (stretched). How?

ALLEGRO_DISPLAY *dpy;
dpy = al_create_display(800, 480);  /* Doen't always actually make it this size... weird bug*/
ALLEGRO_DISPLAY *zoom;
zoom = al_create_display(400, 240);

//...
/* blit(source, dest,0,0,0,0,w,h); */
al_draw_bitmap(source,/*NO DEST ,*/ w, h,0);
//...

al_flip_display();

al_set_target_bitmap(NULL);

Don't you mean al_set_target_bitmap(al_get_backbuffer(display));

Do you really need to draw to the non-screen bitmap first? Its easier (and better) to set up a transformation on the screen and just do normal drawing. If you draw to a different bitmap you will be using FBO's which is not always the best idea.

ALLEGRO_TRANSFORM transform;
al_identity_transform(&transform);
al_scale_transform(&transform, 2, 2); // scale x and y by 2
al_use_transform(&transform);
.. do normal drawing ..

<edit> Ok I see you want to draw to two screens. It might be simpler just to draw with the identity transform on screen 1 and with a scaled transform on screen 2.

I want to do two things:

(1) Make everything 2X as big (16x16 pixel blocks should be 32x32)
(2) Have resolution independence (Additional zooming as needed)

Program LOTS of BITMAPS and zero primitives. I tried the second part of http://wiki.allegro.cc/index.php?title=Achieving_Resolution_Independence but it just turns the full screen black.

I thought transforming was bad if not a lot of primitives were used.

Luiji99's original code doesn't work, I will try re-putting it in with Edgar Reynaldo's addition.

From talking with other people I think that transformations are the way to go. They are not slower for bitmaps. I recommend it.

Ok, I will use transforms then, they seem to be working.

How do you get the transformed Screen dimensions from Allegro, or must I have some global variables?

You can get the screen dimensions by calling al_get_bitmap_width/height on the current backbuffer.

ALLEGRO_BITMAP * backbuffer = al_get_backbuffer(al_get_current_display());

There are some advantages to using an explicit secondary buffer instead of transformations. Firstly, primitives will use the correct size pixels. Secondly, if you use fractional positions for bitmaps and other stuff they'll also be placed correctly. Also a buffer allows you to use a shader to perform the final scaling.

There's no question that transforms are faster though.

ALLEGRO_BITMAP * backbuffer = al_get_backbuffer(al_get_current_display());
How is that different from checking the screensize? It gives me the same values (1280x1024) regardless of the transforms I apply, even though I request the screen to be 800x480 on initialization.

And what about comparing the difference between two different transforms, say the current transform and the identity (I think that's the right term for the transform at initialization)?

Edgar: whoops. I was thinking of a different function...

Other than getting the difference between two transforms (which wasn't the original question anyway) I think I got it.

Thanks everyone.

Well I'm not a linear algebra expert but a transform is just a 4x4 matrix so in theory you could use some linear algebra operations to compare two matrices.

What exactly do you want to know about two transformations?

The scaling difference between the two of them - their ratios to each other.

In general I'm not sure but if you only ever apply a scaling factor to transformations starting from the identity transformation then you can transform a coordinate and use the output to do comparisons.

ALLEGRO_TRANSFORM t1, t2;
al_identity_transform(&t1);
al_scale_transform(&t1, 2, 2);
al_identity_transform(&t2);
al_scale_transform(&t2, 1.4, 1.4);

float x1, y1, x2, y2;
x1 = y1 = x2 = y2 = 1;
al_transform_coordinates(&t1, &x1, &y1);
al_transform_coordinates(&t2, &x2, &y2);

printf("scaling factor of t1 is %f\n", x1);
printf("scaling factor of t2 is %f\n", x2);
printf("scaling ratio between t1 and t2 is %f\n", x1 / x2);

You can tell what the scaling factor is by how much the initial coordinate, x1 or x2, changes after transforming it with the given transformation.

If you apply any translations or rototations then you can't use this simple method and things get much more complicated.

Thanks~!