It returns a pointer to a freshly created bitmap using the following arguments:

<b>BITMAP source
This is a single BITMAP which acts as a sheet of sprites you want to grab a sprite from.

int width, int height
The size of each sprite on the sprite sheet. Each sprite on the sheet should be the exact same size and arranged in a grid.

int startx, int starty
Almost pointless. The top left corner of the grid. Most of the time this will be 0,0.

int columns
The number of sprites there are in a single row of sprites on the sprite sheet. For instance, if the grid has 80 sprites, arranged in rows of 10, you would use the number 10 here.

int frame
The sprite number to grab, from left to right then top to bottom. So given a 10x8 grid of sprites, sprite number 23 would be the fourth sprite in the third row. In a 7x15 grid, 23 would be the third sprite in the fourth row.

Since this routine actually creates the BITMAP object, you must store the result into a BITMAP pointer that hasn't been initialized, or is NULL.

--- Kris Asick (Gemini)
--- http://www.pixelships.com

I can't imagine how the code you posted could possibly generate that ...

temp isn't a very good identifier for this variable. It's temporary in the sense that all local variables are temporary, but in the context of the function it actually stores the BITMAP of the frame you're grabbing.

Out of curiosity, is there an advantage to storing your frames as a sheet of sprites as opposed to an array of BITMAPs or self-defined FRAME objects? It seems that memory usage should be slightly less then if each frame had a separate BITMAP object.

Is the processing time of ripping frames from a sheet of sprites small enough to make it worthwhile getting them from a sheet every time you access them or is it better to store them as separate BITMAPs?

Or was that function designed to initialize an ANIMATION object with FRAME objects?

create_sub_bitmap() sounds somewhat more appropriate for this function (maybe), however, my question still remains. Is it common/good practice to leave your sprites on a sheet-bitmap and rip them over and over again to save memory or is it better to rip them once into memory (when loading the game or level and reuse them)?

Thanks everyone, I think I'm going to try out create_sub_bitmap. I guess that's what this guy was trying to make.

Of course, you're using more HD space by keeping them separate.

But then there's the argument for taking them in as one big bitmap and splitting them up on initialization.

I'm not so sure if I can really use create_sub_bitmap. It seems to be missing some parameters that this other function has, namely int columns and int frame.

My sprite sheet (bmp) looks sorta like this (each number represents the frame):

// yeah.. please try to picture this as 40x80 sprites. hehe

n  n  n  n  n // north
0  1  2  3  4

e  e  e  e  e // east
5  6  7  8  9

s  s  s  s  s // south
10  11  12  13  14

w  w  w  w  w // west
15  16  17  18  19

Hm.. But, how would that work if those two variables aren't even being used?

I'm trying to avoid using the whole BITMAP *grabframe function thing since I can't seem to get it to work properly.

Edit:

What does "%" and "/" mean and do anyhow?

Um. Just because I don't know what those two mean, means I don't know how to code? If you don't have a helpful reply, please don't reply at all.

Edit:

NM asked someone else about it. Thanks for your help.

I may have missed a thing or two along the way. I've just never used these before, or seen them being used.. Well until now.

Isn't there a bridge you should be guarding? Like I said, there's the odd thing I didn't learn when I started c++ (like half a year ago.)