Hey Guys,

My parallax scrolling code for my 2D game uses up too much memory and I'm trying to learn an effective way to code it.

Here's the logic code:

Here's the drawing code:

Obviously there's some stuff that I need to change with this. I've heard using a camera is good, but I want to implement one for a 9 layer background with the middle layer a tile map that's drawn by mappy.

What's the best course of action? If it's the camera method, could someone help me or at least get me started past the point where I've created a class?

Thanks guys!

hey gnolam,

I already have a for loop in there. I just didn't post it. It's ok........

As far as the camera code, I'll try that out and let you know.

What?

Really?

I was looking at that tutorial and it mention parallax but really didn't elaborate on it.

I'll look into that!

Ok.

I have the speed a comfortable speed now(Rage 128 30FPS, Radeon 60FPS) with all all layers and also with other sprites than the player. Although I do have one question.

Which bitmaps use less memory?

Reg Bitmap?
Video Bitmap?
System Bitmap?
Loaded Bitmap?
Datafile Bitmap?
Loaded Bitmap and then copied to Video Bitmap?
Loaded Bitmap and then copied to System Bitmap?
Loaded Bitmap and then copied to Reg Bitmap?

For RAM usage, it doesn't matter how you load or create a bitmap, or in what ways you copy it around.
A memory ("regular") bitmap uses pretty much the exact amount of memory needed to store the uncompressed bitmap data, plus some overhead. You can calculate it like this:

int bmp_size =
  bmp->w * bmp->h * (bitmap_color_depth(bmp)+7) / 8 + // bitmap data
  bmp->h * sizeof(char*) + // the line pointers
  overhead; // whatever the constant overhead is; usually negligible for larger bitmaps.

Video bitmaps consume almost no RAM at all, just the overhead, but they do consume VRAM. The actual size depends on how your graphics cards stores the data, but it is probably at least the size of a memory bitmap. Video cards tend to be pickier about memory alignment (in order to favour speed over memory usage), so they may add padding to the end of each scanline.
System bitmaps are as unpredictable as video bitmaps; they try to imitate the bitmap format of the video bitmaps to provide faster blitting to and from vram. On some platforms, though, they are just aliases for vanilla memory bitmaps.
"Loaded" and "datafile" bitmaps are just normal memory bitmaps, and blittiing them to a video bitmap produces a normal video bitmap. There is nothing special about them.

As for disk space usage; this depends heavily on the file format you use. Plain BMP, PCX and TGA files offer almost no compression at all (except for a whimsy RLE), but they load very fast, are lossless, allegro loads them natively, and virtually all image editing programs support them. Putting them into a datafile enables you to load them all in one go, and offers moderate compression, still lossless. For a beginner's tilemap game, this is what I recommend. Other image formats (GIF, PNG, JPG) offer higher compression rates, but you need add-on libraries to read them. JPG and some PNG sub-formats are also lossy, meaning that after running through the encoding-decoding process, you lose image quality. Most GIF implementation support 256 colors max., and it's a proprietary format. For massive amounts of high-quality bitmap data, (lossless) PNG is probably the way to go; for photo-realistic images with no sharp edges, and without masking, JPG may work too.

(I am reposting this from the other similar thread, because maybe it was not read)

Dear Kevin,

in order to ensure a good frame rate in a bitmap-based game, you have to do the following (assuming bitmap blitting is the issue here):

1) ensure that you use a mode like triple-buffering or page-flipping that uses vram buffers.

2) ensure your most frequently used/large bitmaps are loaded in vram.

An effective way to do parallax scrolling with multiple layers is to avoid drawing blocks twice.

You need a flag for each block of each layer that tells you if the block has already been covered by one of the above layers. Then you need to do two passes over your layers:

a) the first pass will be from top layer to bottom in order to set the 'covered' flag;

b) the second pass will be from bottom to top layer to draw those blocks at each layer that have not been covered yet.

By carefully choosing block sizes (i.e. not too small, not too big) you can minimize overdraw and do many layers of scrolling (even more than 9!).