I have the following code:

I am trying to create a buffer in video ram that does not overlap the screen...the function is_same_bitmap reports that bmp is not the same bitmap as the screen, but when I draw a line in bmp, the line is displayed. Is this a bug?

EDIT: the same happens when GFX_AUTODETECT_WINDOWED is used.

allegro version: 4.2.0
O/S: WinXP SP2
video memory: 128 MB ram
chipset: Mobile Intel(R) 915GM/GMS,910GML Express Chipset Family

I get "80000000 80000000".

EDIT:

If I remove the 'while', then it works: a different bitmap is created.

That's a nasty memory leak you have there. And is not gauranteed to do what you want. On non-Windows platforms, video bitmaps are always sub-bitmaps of the screen, so that would always be true.

The way to get an off-screen video buffer is to create a screen-sized video bitmap after set_gfx_mode and use it as a 'screen' replacement, then create another screen-sized buffer. You need to remember to destroy video bitmaps that you're no longer using since they use system-wide shared memory that may not be freed even after your process ends.

If you're doing page-flipping, you'd use the two as the two buffers. I'm not sure if you can destroy the initial video bitmap like that, since Allegro-Windows does some funky behind-the-scene hacks to get it to work.

The patch was just to fix that is_same_bitmap apparently won't work for windows video bitmaps, it wouldn't really help with your problem.

If you want VRAM blitting, you must not use 'screen', but instead as first call to create_video_bitmap create a bitmap which is SCREEN_W x SCREEN_H big and use that instead. It's simply how Allegro was designed.

(Allegro 4.3 will do this in a better way and automatically HW accelerate stuff without the need to mess with video bitmaps.)

Well, whenever you use video_bitmaps with Allegro, you should not use screen, but that first screen-sized bitmap created by the first call to create_video_bitmap.

As the documentation says:

Well, per design you should not use screen if you use video bitmaps, as the documentation states. If it works now, that could change any time (although realistically, I doubt someone will change the Allegro 4.2.x DirectX driver much - so you should be safe).

is_same_bitmap wouldn't help you much, since the correct way would be to return true for any video bitmap and screen. The only bug is that currently it seems to always return false.

Actually, they are not the same BITMAP objects, but they are the same bitmaps: they share the same drawing surface.

So it is ok to use 'screen' along with any video bitmap created, and this is what I have done.

I wanted to use 'is_same_bitmap' because I wanted to know when a video page is not the same as the screen...and I want to use 'screen' in my library, because it is the expected Allegro interface: clients of my library can use their drawing routines which draw on the screen, whereas I can do whatever I want with it.

Yes and no. It's ok as long as you create (and don't use) a dummy video bitmap sized SCREEN_W x SCREEN_Hbefore all others, but it's still not recommended.

This will be platform dependent; if you're using it in this way the result will not be reliable or portable across different platforms.

Nope. the "screen" has a separate vtable, as well as the "screen" may also be the size of VRAM, not just SCREEN_W, SCREEN_H.

Video Bitmap != Screen Bitmap. Ever.

Wrong again. The main "screen" is a wee different from video bitmaps created by allegro. the first created Video Bitmap is always taken from the same area (weather or not its the same size, you can have multiple small video bitmaps be allocated from the same space that "screen" is using).

[edited out stuff here] Once you create a video bitmap, FORGET about "screen". Just use the first two video bitmaps created, and switch between them. That IS the proper way.

Which part of the "they are not the same BITMAP objects" you did not understand?

Hey, that's basic allegro knowledge...otherwise SCREEN_W and SCREEN_H would not have been there.

But I am not implementing a page flipping algorithm. I am writing a GUI library and I just want to blit the GUI buffer to the screen. So I am using one video bitmap and the screen.

And I do not want to use the first page allocated, because the 'screen' value could be set to anything the user of my library desires.

The solution I am using works perfectly under Windows, both in windowed and full screen mode. Wouldn't it work for Linux?

Due to design then.

Yes, but it does not say anything about 'is_same_bitmap'.

The problem is neither of what you or anyone else keeps referring to. The problem is that the function 'is_same_bitmap' does not work as expected: when I write to one bitmap, the drawing appears in the other bitmap, but the function 'is_same_bitmap' does not report any relationship between the two bitmaps.

Actually, Elias already said in his first post that that was probably a bug.
Leaving that aside, the point made is that you are using video bitmaps diferently from how they are intended and the results can be unreliable.

No one should ever set screen to anything else than what it's set at after a call to set_gfx_mode(). I'm not sure if that's what you meant though?

The X11 driver fakes video bitmaps if the virtual screen is larger than the actual screen.