# Tatlap
A texture atlas packer library/CLI tool.
I know there are a lot of these out there, but I didn't find one that did
everything I wanted it to:
* Trim off transparent borders
* Remove duplicates
* Handle non-4-channel images
I also wanted a project to learn Rust with, and making a command-line tool was
a perfect candidate.
## Examples
Combine three images into a texture atlas:
``` Console
$ tatlap sprite1.png sprite2.png sprite3.png
```
You can specify the output name (defaults to `out`):
``` Console
$ tatlap --out sprites data/*.png
```
If you have a lot of images to pack you can put their names in a file:
``` Console
$ tatlap --file list_of_sprites.txt
```
Or pass them through standard input:
``` Console
Actually I'm sure sure why I have the `--file` option anymore, since you could
do this instead:
``` Console
$ tatlap < list_of_sprites.txt
```
You can also load images from a texture atlas you created previously:
``` Console
$ tatlap --atlas out newsprite.png
```
You can also remove duplicate images from the atlas:
``` Console
$ tatlap *.png --dedup
```
## Output
Tatlap will output an `out.txt` file, an `out.bin` file, and several `outN.png`
files where `N` is the number of channels the image contains.
The `.txt` output file contains locations of the packed sprites.
For example:
```
4 459 638 45 37 69 53 192 192
```
* `4` - This represent the number of color channels this image has.
* `459 638` - These are the x and y pixel coordinates where the sprite was packed into the resulting texture atlas
* `45 37` - This is the dimensions of the sprite **after** the transparent borders were trimmed off
* `67 53` - This is how many pixels from the left and top were trimmed off
* `192 192` - The dimensions of the image **before** it was trimmed
The `.bin` output file contains the same data as the `.txt` output, but contains
the values in serialized in a binary file. The first value (bytes per pixel) is
a single byte, but the others are 16-bit unsigned integers (in little endian),
so each image takes 17 bytes.
How you use the `.txt` and `.bin` is up to you; I find the `.bin` more useful
for loading the sprites. Here is an example of how to would load it in C:
``` C
FILE* fp = fopen("out.bin");
uint8_t bpp;
fread(&bpp 1, 1, fp);
uint16_t d[8];
fread(&xywh, 2, 8, fp); // Note that this won't work on big-endian systems
// Extract the sprite based on d[0-4]
// Calculate where to draw the sprite centered on `x` and `y`
// x - half uncropped width + cropped offset
int draw_x = x - d[6]/2 + d[4];
int draw_y = y - d[7]/2 + d[5];
```