SGDK/tools_8h_source.html

#ifndef _TOOLS_H_

#define _TOOLS_H_


#include "bmp.h"

#include "vdp_tile.h"

#include "vdp_bg.h"

#include "map.h"


#define COMPRESSION_NONE        0

#define COMPRESSION_APLIB       1

#define COMPRESSION_LZ4W        2


typedef s16 _comparatorCallback(void* o1, void* o2);


void setRandomSeed(u16 seed);

u16 random(void);


u16 kprintf(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));


void KLog(char* text);

void KLog_U1(char* t1, u32 v1);

void KLog_U2(char* t1, u32 v1, char* t2, u32 v2);

void KLog_U3(char* t1, u32 v1, char* t2, u32 v2, char* t3, u32 v3);

void KLog_U4(char* t1, u32 v1, char* t2, u32 v2, char* t3, u32 v3, char* t4, u32 v4);

void KLog_U1_(char* t1, u32 v1, char* t2);

void KLog_U2_(char* t1, u32 v1, char* t2, u32 v2, char* t3);

void KLog_U3_(char* t1, u32 v1, char* t2, u32 v2, char* t3, u32 v3, char* t4);

void KLog_U4_(char* t1, u32 v1, char* t2, u32 v2, char* t3, u32 v3, char* t4, u32 v4, char* t5);

void KLog_U1x(u16 minSize, char* t1, u32 v1);

void KLog_U2x(u16 minSize, char* t1, u32 v1, char* t2, u32 v2);

void KLog_U3x(u16 minSize, char* t1, u32 v1, char* t2, u32 v2, char* t3, u32 v3);

void KLog_U4x(u16 minSize, char* t1, u32 v1, char* t2, u32 v2, char* t3, u32 v3, char* t4, u32 v4);

void KLog_U1x_(u16 minSize, char* t1, u32 v1, char* t2);

void KLog_U2x_(u16 minSize, char* t1, u32 v1, char* t2, u32 v2, char* t3);

void KLog_U3x_(u16 minSize, char* t1, u32 v1, char* t2, u32 v2, char* t3, u32 v3, char* t4);

void KLog_U4x_(u16 minSize, char* t1, u32 v1, char* t2, u32 v2, char* t3, u32 v3, char* t4, u32 v4, char* t5);

void KLog_S1(char* t1, s32 v1);

void KLog_S2(char* t1, s32 v1, char* t2, s32 v2);

void KLog_S3(char* t1, s32 v1, char* t2, s32 v2, char* t3, s32 v3);

void KLog_S4(char* t1, s32 v1, char* t2, s32 v2, char* t3, s32 v3, char* t4, s32 v4);

void KLog_S1_(char* t1, s32 v1, char* t2);

void KLog_S2_(char* t1, s32 v1, char* t2, s32 v2, char* t3);

void KLog_S3_(char* t1, s32 v1, char* t2, s32 v2, char* t3, s32 v3, char* t4);

void KLog_S4_(char* t1, s32 v1, char* t2, s32 v2, char* t3, s32 v3, char* t4, s32 v4, char* t5);

void KLog_S1x(u16 minSize, char* t1, s32 v1);

void KLog_S2x(u16 minSize, char* t1, s32 v1, char* t2, s32 v2);

void KLog_S3x(u16 minSize, char* t1, s32 v1, char* t2, s32 v2, char* t3, s32 v3);

void KLog_S4x(u16 minSize, char* t1, s32 v1, char* t2, s32 v2, char* t3, s32 v3, char* t4, s32 v4);

void KLog_f1(char* t1, fix16 v1);

void KLog_f2(char* t1, fix16 v1, char* t2, fix16 v2);

void KLog_f3(char* t1, fix16 v1, char* t2, fix16 v2, char* t3, fix16 v3);

void KLog_f4(char* t1, fix16 v1, char* t2, fix16 v2, char* t3, fix16 v3, char* t4, fix16 v4);

void KLog_f1x(s16 numDec, char* t1, fix16 v1);

void KLog_f2x(s16 numDec, char* t1, fix16 v1, char* t2, fix16 v2);

void KLog_f3x(s16 numDec, char* t1, fix16 v1, char* t2, fix16 v2, char* t3, fix16 v3);

void KLog_f4x(s16 numDec, char* t1, fix16 v1, char* t2, fix16 v2, char* t3, fix16 v3, char* t4, fix16 v4);

void KLog_F1(char* t1, fix32 v1);

void KLog_F2(char* t1, fix32 v1, char* t2, fix32 v2);

void KLog_F3(char* t1, fix32 v1, char* t2, fix32 v2, char* t3, fix32 v3);

void KLog_F4(char* t1, fix32 v1, char* t2, fix32 v2, char* t3, fix32 v3, char* t4, fix32 v4);

void KLog_F1x(s16 numDec, char* t1, fix32 v1);

void KLog_F2x(s16 numDec, char* t1, fix32 v1, char* t2, fix32 v2);

void KLog_F3x(s16 numDec, char* t1, fix32 v1, char* t2, fix32 v2, char* t3, fix32 v3);

void KLog_F4x(s16 numDec, char* t1, fix32 v1, char* t2, fix32 v2, char* t3, fix32 v3, char* t4, fix32 v4);


Bitmap *allocateBitmap(const Bitmap *bitmap);

Bitmap *allocateBitmapEx(u16 width, u16 heigth);

TileSet *allocateTileSet(const TileSet *tileset);

TileSet *allocateTileSetEx(u16 numTile);

TileMap *allocateTileMap(const TileMap *tilemap);

TileMap *allocateTileMapEx(u16 width, u16 heigth);

Image *allocateImage(const Image *image);

Map *allocateMap(const MapDefinition *mapDef);


Bitmap *unpackBitmap(const Bitmap *src, Bitmap *dest);

TileSet *unpackTileSet(const TileSet *src, TileSet *dest);

TileMap *unpackTileMap(const TileMap *src, TileMap *dest);

Image *unpackImage(const Image *src, Image *dest);


u32 unpack(u16 compression, u8 *src, u8 *dest);


u32 aplib_unpack(u8 *src, u8 *dest);

u32 lz4w_unpack(const u8 *src, u8 *dest);


void qsort_u8(u8 *data, u16 left, u16 right);

void qsort_s8(s8 *data, u16 left, u16 right);

void qsort_u16(u16 *data, u16 left, u16 right);

void qsort_s16(s16 *data, u16 left, u16 right);

void qsort_u32(u32 *data, u16 left, u16 right);

void qsort_s32(s32 *data, u16 left, u16 right);


void qsort(void** data, u16 len, _comparatorCallback* cb);


#endif // _TOOLS_H_

bmp.h
Software bitmap engine.

map.h
MAP (large background map) management unit.

Bitmap
Genesis 4bpp Bitmap structure definition.  Use the unpackBitmap() method to unpack if compression is ...
Definition bmp.h:161

Image
Image structure which contains all data to define an image in a background plane.  Use the unpackImag...
Definition vdp_bg.h:34

MapDefinition
MapDefinition structure which contains data for large level background.  It's optimized to encode lar...
Definition map.h:77

Map
Map structure containing information for large background/plane update based on MapDefinition.
Definition map.h:141

TileMap
TileMap structure which contains tilemap background definition.  Use the unpackTileMap() method to un...
Definition vdp_tile.h:137

TileSet
Tile set structure which contains tiles definition.  Use the unpackTileSet() method to unpack if comp...
Definition vdp_tile.h:114

setRandomSeed
void setRandomSeed(u16 seed)
Set the randomizer seed (to allow different reproductible series)
Definition tools.c:30

unpackBitmap
Bitmap * unpackBitmap(const Bitmap *src, Bitmap *dest)
Unpack the specified source Bitmap and return result in a new allocated Bitmap.
Definition tools.c:1028

allocateTileSet
TileSet * allocateTileSet(const TileSet *tileset)
Allocate TileSet structure which can receive unpacked tiles data of the specified TileSet.
Definition tools.c:905

kprintf
u16 kprintf(const char *fmt,...) __attribute__((format(printf
Composes a string with the same text that would be printed if format was used on printf,...

unpack
u32 unpack(u16 compression, u8 *src, u8 *dest)
Unpack the specified source data buffer in the specified destination buffer.  if source is not packed...
Definition tools.c:1136

unpackTileSet
TileSet * unpackTileSet(const TileSet *src, TileSet *dest)
Unpack the specified TileSet structure and return result in a new allocated TileSet.
Definition tools.c:1057

_comparatorCallback
s16 _comparatorCallback(void *o1, void *o2)
Callback for QSort comparaison.
Definition tools.h:46

qsort_s32
void qsort_s32(s32 *data, u16 left, u16 right)
Quick sort algo on s32 data array.

qsort
void qsort(void **data, u16 len, _comparatorCallback *cb)
Quick sort algo on array of pointer (object)

qsort_u16
void qsort_u16(u16 *data, u16 left, u16 right)
Quick sort algo on u16 data array.

allocateImage
Image * allocateImage(const Image *image)
Allocate Image structure which can receive unpacked image data of the specified Image....
Definition tools.c:952

qsort_u8
void qsort_u8(u8 *data, u16 left, u16 right)
Quick sort algo on u8 data array.

unpackTileMap
TileMap * unpackTileMap(const TileMap *src, TileMap *dest)
Unpack the specified TileMap structure and return result in a new allocated TileMap.
Definition tools.c:1084

random
u16 random(void)
Returns a random u16 integer value.
Definition tools.c:37

unpackImage
Image * unpackImage(const Image *src, Image *dest)
Unpack the specified Image structure and return result in a new allocated Image.
Definition tools.c:1112

lz4w_unpack
u32 lz4w_unpack(const u8 *src, u8 *dest)
Unpack (LZ4W) the specified source data buffer in the specified destination buffer.

qsort_s16
void qsort_s16(s16 *data, u16 left, u16 right)
Quick sort algo on s16 data array.

qsort_u32
void qsort_u32(u32 *data, u16 left, u16 right)
Quick sort algo on u32 data array.

KLog
u16 void KLog(char *text)
KDebug log helper methods.
Definition tools.c:77

allocateTileSetEx
TileSet * allocateTileSetEx(u16 numTile)
Allocate a new TileSet structure which can receive the data for the specified number of tile.
Definition tools.c:910

allocateTileMapEx
TileMap * allocateTileMapEx(u16 width, u16 heigth)
Allocate a new TileMap structure which can receive tilemap data for the specified TileMap dimension.
Definition tools.c:933

allocateMap
Map * allocateMap(const MapDefinition *mapDef)
Allocate Map structure which can receive unpacked data of the specified MapDefinition.
Definition tools.c:977

qsort_s8
void qsort_s8(s8 *data, u16 left, u16 right)
Quick sort algo on s8 data array.

aplib_unpack
u32 aplib_unpack(u8 *src, u8 *dest)
Unpack (aplib packer) the specified source data buffer in the specified destination buffer.

allocateBitmapEx
Bitmap * allocateBitmapEx(u16 width, u16 heigth)
Allocate a new Bitmap structure which can receive the bitmap data for the specified Bitmap dimension....
Definition tools.c:889

allocateBitmap
Bitmap * allocateBitmap(const Bitmap *bitmap)
Allocate a new Bitmap structure which can receive unpacked bitmap data of the specified Bitmap....
Definition tools.c:884

allocateTileMap
TileMap * allocateTileMap(const TileMap *tilemap)
Allocate TileMap structure which can receive unpacked tilemap data of the specified TileMap.
Definition tools.c:928

u32
unsigned long u32
Definition types.h:105

fix32
s32 fix32
Definition types.h:186

s8
char s8
Definition types.h:79

u16
unsigned short u16
Definition types.h:100

u8
unsigned char u8
Definition types.h:95

s32
long s32
Definition types.h:89

s16
short s16
Definition types.h:84

fix16
s16 fix16
Definition types.h:181

vdp_bg.h
VDP background plane support.

vdp_tile.h
VDP General Tile / Tilemap operations.