bmp2gbtile

Download

Abstract

Program Features

• Both sprite and background tile information can be generated. The generated information can be copied directly into the GBA's sprite / tile memory.
• When 16 color sprites are used, the program will make an effort to use the palettes in an efficient way. For example: If two 12 color sprites share 8 identical colors, the program can combine these two sprites to only use one 16 color palette (with 8 shared and 4 unique colors each).
• 16 and 256 color sprite/tile information can be intermixed. In this scenerio, bmp2gbtile will attempt to arrange palette information to accomidate both the 16 color and 256 color image(s).
• If needed, you can supply palette contraints, defining palette entries that must be present at certain color indexes. This provides a clean way to merge the output of this program with other sprite data.
• The program can optionally define OBJ sprite definitions that relate to generated data. These can be copied directly into GBA hardware, making sprite setup more convienent.
• The source code is included, allowing you to tweak the code to your specific tastes
• The source code is fairly simple, is contained in a single file, and does not require you to download any external support libraries.
• The source uses standard ANSI C or C++ and will compile under either Windows or Linux.

Usage

usage: bmp2gbtile   ?file2.bmp? ... ?-classname ? ?-obj_offset ?

This program converts a set of 16/256 color bmp files into GBA sprite/tile data

The program takes one or more .bmp files as input and generates 
a single header file based on all read files.  This header will 
contain a single '1D' binary stream of the tile data along with an 
enumeration of palette information for each sprite.

This program also generates an index structure that will give correct
GBA hardware settings for each object.  The format of this structure
will be the OBJ format

This program will perform limited palette mactching using the following algorithm:
  1) All bitmaps are loaded into memory 16x16 palettes are cleared
  2) bitmaps are split into 2 groups (A,B) where 0 < A <= 16 < B < 256 colors
  3) For each group A_i from A from the most colors to the least:
     a) select a palette that has the lowest palette delta from A_i,
        expand the palette to support A_i, remap A_i, and continue
  4) Try to fit group B into existing palette.

If any of the above steps fail, the program will not complete and
will return an error

Options include:

  -classname [name]      The header file will be generated as a static
                         class with a default classname of .
                         This option can be used to override this name.

  -lang [name]           The language format to use.  Currently c or c++ is
                         accepted as input

  -obj_offset [n]        This can be used to set the object offset.  This
                         parameter is useful when using bitmapped graphics
                         modes (set obj_offset to 512 in these modes for
                         correct header information

  -tile                  This puts the bmp2gbtile program in tile mode.  In tile
                         mode, any bmp dimension that is a multiple of 8 is accepted.
                         in this mode, the bitmap is scanned from left to right and 8x8
                         chunks are outputted

  -no_attr               This surpresses attrN data from the output files

  -no_palette            This surpresses palette data from the output files

  -palette_file [file]   This loads a specially formatted palette constraint file
                         that can be used to manually constrain parts of a palette
                         This is useful when combining the results of multiple
                         Invovations on bmp2gbtile, when it makes sence to do things
                         this way.

The format of the palette file is simple, here is an example:

# This is a comment

# start a palette by stating 'pal' followed by a palette number (0-15)
# if using 256 colors, simply use '0'

pal 0
# The rest is the colors in 5 bpp, BGR format, the same as the GBA
# hardware would expect.  The color idx always starts at zero, there
# is currently no way to start at a non zero index.  Palette data is
# assumed hex
#Here are two colors (0 and 1):
7FFF
0000

Future Enhancements

• Currently only uncompressed .bmp file can be read
• .bmp images stored with 1 bit depth (i.e. black and white) are not directly supported and must first be converted into a 4-bit images usinge convert, gimp, MS Paint, or other bitmap manipulation programs first.
• Only '1D' (single strip) GBA tile encoding is supported. This means that bit 6 of the DSPCNT register (VRAM_MAP) should be set to 1. I believe that this is a superior way to work because it supports DMA memory copies better but '2D' mode could be added for completeness
• The code was written, not for its own sake, but as a means to other goals (writing actual games for the GBA). In light of this, there is opportunity for code reorganization and cleanup.

Example