Product Home • Class Index • Download • License

CK_BitmapTable

A bitmap table contains an array of CK_Bitmap objects, which are drawable. A bitmap table is always created from an image table (CK_ImageTable). An image table contains an array of CK_Image objects, which are not drawable because each image can be in a pixel format different from that of the application's display. The CK_BitmapTable class gives the programmer full control over when images are loaded into memory and converted to the display's pixel format. By default, when the CK_BitmapTable is created, none of the images are loaded into memory. When a bitmap is needed, the image is automatically loaded from disk and converted to the display's pixel format. To be more specific, when getBitmap() is called, the underlying CK_ImageTable creates the CK_Image object by loading it from disk. The CK_Bitmap is then created from the CK_Image and returned.

The CK_BitmapTable class provides methods to cache and convert all bitmaps in the table. Methods are also provided to flush bitmaps and/or images from memory. This allows the programmer to pre-load and convert bitmaps at any time. An example of this would be when advancing to the next 'level' in a game. The artwork for the next level would be cached, and the artwork from the previous level would be flushed from memory.

Constructors

(A CK_BitmapTable must be created using one of the factory methods.)

Factory Methods

create

Creates a bitmap table from a serialized CK_ImageTable.

createFromTable

Creates a bitmap table from a CK_ImageTable.

Public Methods

cacheAllBitmaps

Loads and converts all bitmaps in the table.

cacheAllImages

Loads all images into the underlying CK_ImageTable, but does not convert them to bitmaps.

cacheBitmap

Loads and converts a single bitmap in the table.

cacheImage

Loads a single image, but does not convert it.

fileClosed

Indicate that the file is closed and images can no longer be loaded.

flushAllBitmaps

Flushes all CK_Bitmap objects from memory.

flushAllImages

Flushes all CK_Image objects from memory.

flushBitmap

Flushes one CK_Bitmap object from memory.

flushImage

Flushes one CK_Image object from memory.

getBitmap

Returns a bitmap from the table. The bitmap is automatically loaded and converted in not already done.

getNumBitmaps

Returns the number of slots in the bitmap table.

keepImages

Prevents underlying CK_Image objects from being automatically flushed.

• static CK_BitmapTable *create(FILE *fp);

Creates a CK_BitmapTable from a serialized CK_ImageTable. The CK_ImageTable is contained within the CK_BitmapTable, and the images are loaded as needed.

Parameters

fp

An open file pointer pointing the beginning of a serialize CK_ImageTable.

• static CK_BitmapTable *createFromTable(CK_ImageTable *table, int ownsTable = 1);

Creates a CK_BitmapTable from a CK_ImageTable. By default, the bitmap table owns the image table. This means that the bitmap table will delete the image table when it is deleted.

Parameters

table

The underlying image table. Each bitmap in the bitmap table corresponds to the image in the same indexed slot in the image table. The bitmap table and the image table should have the same number of slots.

ownsTable

If 0, then the bitmap table does not own the image table, and will not delete it when it is deleted.

• void cacheAllBitmaps(void);

Ensures that all bitmaps are loaded and converted. If keepImages() was not called, all images in the underlying image table will be flushed from memory.

• void cacheAllImages(void);

This is the same as calling CK_ImageTable::cacheAll() on the underlying image table.

• void cacheBitmap(int index);

Ensures that the specified bitmap is loaded, converted, and ready to draw. If keepImages() was not called, the underlying CK_Image is automatically flushed from memory.

Parameters

index

The index of the bitmap in the table to load.

• void cacheImage(int index);

Ensures that the specified image is loaded into memory. To draw the bitmap at the specified index, the image will still need to be converted. This will be done automatically when the bitmap is needed, or manually when cacheBitmap() is called.

Parameters

index

The index of the image in the underlying table to load.

• void fileClosed(void);

Calling this member function tells the bitmap table that the underlying CK_ImageTable's file is closed, and that images can no longer be cached from disk. This is typically called if all the images are cached, the file is closed, and the images are never deleted from memory. The getBitmap() member function will return a null pointer if a bitmap is not loaded and the file is closed.

• void flushAllBitmaps(void);

Flushes all bitmaps from memory. Images in the underlying image table are not affected.

• void flushAllImages(void);

This is the equivalent of calling CK_ImageTable::flushAll() in the underlying image table.

• void flushBitmap(int index);

Flushes one bitmap from memory. The underlying image is not affected.

Parameters

index

The index of the bitmap in the table to flush.

• void flushImage(int index);

This is equivalent to calling CK_ImageTable::flushImage() in the underlying image table.

Parameters

index

The index of the image in the underlying table to flush.

• CK_Bitmap *getBitmap(int index);

Fetches a bitmap from the bitmap table. If the bitmap is not loaded or converted, this is done automatically.

Parameters

index

The index of the bitmap in the table to fetch.

• int getNumBitmaps(void);

Returns the number of slots in the bitmap table.

• void keepImages(void);

Tells the bitmap table to not automatically delete the underlying CK_Image when a CK_Bitmap is created. Normally, once the bitmap is created, the underlying image is no longer needed.