Hi there, I'm quite new to allegro and try to fooling around with the library now.

Let me explain my situation here. I'm trying to make a game that (currently) runs in Windows XP with a tile based background that can scroll. So, for every frame I will (mostly) have to redraw every tile in the background since they are scrolling, thus i'm filling the entire screen with bitmaps.

Since I'm redrawing entire screen everytime, I feel like I'm already doing a double buffering. My question is, does directy drawing/blit the tiles to a triple buffer video bitmap will be faster? Would someone care to explain me what's the difference if I draw using a double buffering way?

----

Another question..for some unknown reason when I try to clear() a video bitmap in my screen some part of the screen isn't clear. This happens when I trying with triple buffering. What I did is put a bitmap on the screen and try moving it around the screen. What I means by part of the screen is that all the vertical(up / down) movement have such problem, leaving a trail of the bitmap when i move. While the same time if I try moving the box Left/Right.

The more weird problem is that when I move the box down, then move back up again the old trail will be "cleared" as if i'm using an eraser but it leaves another new trail of oppsite direction. And, it only happens when i using set_gfx_mode(GFX_AUTODETECT_WINDOWED). It works fine when this is under full screen (GFX_AUTODETECT). Can anyone tell me what actually caused the problem? Btw this problem will dissapear when I start filling up the screen full of stuffs. Again all this happens under Windows XP SP2

Sorry for the long question.

EDIT: Typos

Double buffering means using a bitmap that is the size of the screen and drawing everything to it. When it is ready, blit the buffer to the screen. This way the entire screen is updated at the same time. Simply drawing everything directly to the screen is not double buffering.

Are you clearing the screen bitmap or another video bitmap that you blit to the screen? If you're clearing a non-screen bitmap and drawing that to the screen and move it around, it will leave a trail. You have to clear the screen bitmap if you don't want the trail to be seen. This however would mean that you are clearing the screen directly and drawing a bitmap to it as well. That would produce flickering of the screen back and forth between a cleared screen and one with your bitmap drawn on it. This is what double buffering is for - to allow you to clear your bitmap without clearing the screen.

Show us some of your code and we can give you more specific advice. The forum has nice code tags you can use.

<code>
Code goes here..
</code>

Thanks for the quick respond.

Actually my question is what's the different by

drawing everything to a screen_sized bitmap(Double Buffering) and then draw the entire bitmap to a screen

comparing to

drawing everything to a page for tripple buffer / page flipping and flip them? (Am I using the correct term here?)

in terms of speed (assuming the things to be draw is filling up the whole buffer/page)

EDIT: Didnt notice the new reply when typing this
So does that means that the main differences between page flipping and double buffering is that page fliping uses video bitmap while double buffering uses memory bitmap.

And does that means that Triple buffer is the fastest way as long as video memory is enough?
----

Yes the trail is like those Doom I or II situation. I don't have the code right now ( this is a public pc ). I can't fully remember the code but what I did is something like this. basically i just copying the code from the manual to test them out.

/* main loop */

clear(video_page[current_page]);
 
// Get the mouse location and draw a sprite on the position
draw_mouse_cursor(video_page[current_page]); 

do {
} while (!poll_scroll())

request_video_bitmap(video_page[current_page]);
current_page = (current_page + 1) % 3;

by reading your post is the reason caused because i didn't call clear(screen)?

That is double buffering

Think about it another way. When you use a memory bitmap you draw to that then potentially whack all that data to the video card when you want to display it. When you use video bitmaps, they are already on the card all you do is change the address pointer.

Triple should be faster, but more importantly you can usually get it far smoother. Beware though, while memory to video is quite a fast process (e.g. copying sprites in memory to video) copying from video memory to standard memory is ridiculously slow. At the minute there are only a handful of the bitmap operations that are hardware accelerated as well. But regardless, I would always choose video over memory.

As for your coding problem, no the screen object has nothing to do with what you're doing, it's more like due to not clearing your video_page bitmap. Unless you are using the screen as that shouldn't be touched if you're using paging/triple buffering.

You need to check the result (enable_triple_buffer() if ANDing GFX_CAN_TRIPLE_BUFFER bit in the gfx_capabilities flag fails) to see if triple buffering was allowed.

Why it's working when it hasn't got it I don't know, perhaps it's just internally just flipping a page.

Not always. If you're doing anything with transparency or blending, i.e., something that needs to read from the memory and not just write to it, you don't want to be trying to draw directly into a video bitmap.

Of course, there's always OpenGL... then the GPU, not your CPU, is doing the blending stuff, and you don't have this problem.

Read my post just above yours.