/*
	mkbmfont.c : Like mkfont but the output is in BMFont format.
	The code is rather messy, since it's a tool meant for personal use,
	apologies in advance.

	Copyright (c) 2026 Marisa the Magician, UnSX Team

	Permission is hereby granted, free of charge, to any person obtaining
	a copy of this software and associated documentation files (the
	"Software"), to deal in the Software without restriction, including
	without limitation the rights to use, copy, modify, merge, publish,
	distribute, sublicense, and/or sell copies of the Software, and to
	permit persons to whom the Software is furnished to do so, subject to
	the following conditions:

	The above copyright notice and this permission notice shall be
	included in all copies or substantial portions of the Software.

	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/*
	Known bugs/limitations/quirks:

	- Unlike my old mkfont tool, proportional fonts are handled just fine,
	  and non-bitmap font handling "just works". Unicode blocks beyond the
	  BMP are also covered too, funny enough.
	- Packing algorithm for the texture atlas is very naive and may not
	  offer the finest density, but at least it's fast and dead simple to
	  implement in plain C.
	- Does not recognize visually identical glyphs that share the same code
	  point, so there will be potential duplicates in the atlas.
	- Compiling with -DASCII_ONLY is required if you want to use this with
	  Godot, as it doesn't support unicode bitmap fonts for some reason.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <png.h>
#include <ft2build.h>
#include FT_FREETYPE_H

typedef struct
{
	int16_t fontSize;
	uint8_t bitField;
	uint8_t charSet;
	uint16_t stretchH;
	uint8_t aa, paddingUp, paddingRight, paddingDown, paddingLeft, spacingHoriz, spacingVert, outline;
} __attribute__((packed)) bmfinfo_t;

typedef struct
{
	uint16_t lineHeight, base, scaleW, scaleH, pages;
	uint8_t bitField, alphaChnl, redChnl, greenChnl, blueChnl;
} __attribute__((packed)) bmfcommon_t;

typedef struct
{
	uint32_t id;
	uint16_t x, y, width, height;
	int16_t xoffset, yoffset, xadvance;
	uint8_t page, chnl;
} __attribute__((packed)) bmfchar_t;

typedef struct
{
	uint32_t unicode, glyph;
	uint16_t x, y, w, h;
	int16_t xofs, yofs, xadv;
	uint8_t page, packed;
	// channels not needed (always defaults to 15)
} packglyph_t;

// BEGIN naive packing algo

static int cmpglyph( const void *p1, const void *p2 )
{
	// cast for convenience
	packglyph_t *a = (packglyph_t*)p1,
		*b = (packglyph_t*)p2;
	// check which is taller first
	int hdiff = b->h-a->h;
	if ( hdiff ) return hdiff;
	// if equal height, check which is wider
	int wdiff = b->w-a->w;
	if ( wdiff ) return wdiff;
	// equal height and width, just sort by unicode value
	return a->unicode-b->unicode;
}

static void nextbox( int* boxw, int* boxh )
{
	// increase width before height
	if ( *boxw > *boxh ) *boxh <<= 1;
	else *boxw <<= 1;
}

// some sane defaults here
#ifndef PACK_TRIES
#define PACK_TRIES 100
#endif
#ifndef MAX_PACK_SIDE
#define MAX_PACK_SIDE 1024
#endif
#ifndef MAX_PAGES
#define MAX_PAGES 36
#endif

int packglyphs( packglyph_t *glyphs, uint32_t nglyphs, int* boxw, int* boxh )
{
	// sort the glyphs first
	qsort(glyphs,nglyphs,sizeof(packglyph_t),cmpglyph);
	int pageno = 0;
	size_t packed = 0;
	for ( int i=0; i<PACK_TRIES; i++ )
	{
		int x = 0;
		int y = 0;
		int lh = 0;
		for ( uint32_t j=0; j<nglyphs; j++ )
		{
			if ( glyphs[j].packed ) continue;
			// past box width, next row
			if ( (x+glyphs[j].w+1) > *boxw )
			{
				y += lh;
				x = 0;
				lh = 0;
			}
			// past box height, bail out
			if ( y+glyphs[j].h+1 > *boxh ) break;
			// otherwise pack it and advance
			glyphs[j].x = x;
			glyphs[j].y = y;
			x += glyphs[j].w+1;
			// save tallest in row
			if ( (glyphs[j].h+1) > lh ) lh = glyphs[j].h+1;
			glyphs[j].page = pageno;
			glyphs[j].packed = 1;
			packed++;
		}
		if ( packed == nglyphs ) return 0;
		// box is already at size limit, make a new page
		if ( (*boxw >= MAX_PACK_SIDE) && (*boxh >= MAX_PACK_SIDE) )
		{
			pageno++;
			// if we're past the page limit, fail early
			if ( pageno >= MAX_PAGES ) return 2;
			continue;
		}
		// try again from scratch with a larger box
		packed = 0;
		for ( uint32_t j=0; j<nglyphs; j++ )
			glyphs[j].packed = 0;
		nextbox(boxw,boxh);
	}
	// failed to pack
	return 1;
}

// what could be improved: for optimal column coverage, we could keep looping
// until we find a glyph whose width fits the space before moving on to the
// next row. though this would require storing a bit more data inside the
// struct itself, and would increase the complexity of the inner loop
// (potentially taking even longer to execute, especially if multiple retries
// are needed until we find the optimal box size)

// END naive packing algo

uint8_t pal[768];
int palsize = 0;

int aw = 64, ah = 64;	// generous default?
uint8_t *adata = 0;

// dead simple png writing, with raw data, width, height and row pitch
int writepng( const char *filename, uint8_t *fdata, int w, int h, int p )
{
	if ( !filename ) return 0;
	png_structp pngp;
	png_infop infp;
	FILE *pf;
	if ( !(pf = fopen(filename,"wb")) ) return 0;
	pngp = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);
	if ( !pngp )
	{
		fclose(pf);
		return 0;
	}
	infp = png_create_info_struct(pngp);
	if ( !infp )
	{
		fclose(pf);
		png_destroy_write_struct(&pngp,0);
		return 0;
	}
	if ( setjmp(png_jmpbuf(pngp)) )
	{
		png_destroy_write_struct(&pngp,&infp);
		fclose(pf);
		return 0;
	}
	png_init_io(pngp,pf);
	png_set_IHDR(pngp,infp,w,h,8,PNG_COLOR_TYPE_RGBA,
		     PNG_INTERLACE_NONE,PNG_COMPRESSION_TYPE_DEFAULT,
	      PNG_FILTER_TYPE_DEFAULT);
	png_write_info(pngp,infp);
	for ( int i=0; i<h; i++ ) png_write_row(pngp,fdata+(p*i));
	png_write_end(pngp,infp);
	png_destroy_write_struct(&pngp,&infp);
	fclose(pf);
	return 1;
}

FT_Library ftlib;
FT_Face fnt;

int lh, bl;
int w = 0, h = 0;
uint8_t *idata = 0;

int calcsize = 1;
int gradient = 0;
int gw = 0, gh = 0, gx = 0, gy = 0;

// dead simple, we don't need to check if we draw out of bounds or anything
// as those are guaranteed to never be the case once glyphs are successfully
// packed into the atlas texture

int oob = 0;

void blitglyph( packglyph_t *g )
{
	if ( (g->x < 0) || (g->x >= (aw-g->w)) || (g->y < 0) || (g->y >= (ah-g->h)) )
	{
		oob = 1;
		return;
	}
	uint8_t *gpos = idata;
	uint8_t *apos = adata+(g->x+g->y*aw)*4;
	for ( int i=0; i<(g->h); i++ )
	{
		memcpy(apos,gpos,(g->w)*4);
		gpos += w*4;
		apos += aw*4;
	}
}

void putpixel_grayscale( uint8_t v, uint8_t a, int x, int y )
{
	uint32_t tpos = (x+y*w)*4;
	// add alpha
	int alph = idata[tpos+3];
	alph += a;
	if ( alph > 255 ) alph = 255;
	idata[tpos+3] = alph;
	// blend color
	int col = idata[tpos]*(a-255);
	col += v*a;
	col /= 255;
	idata[tpos] = col;
	idata[tpos+1] = col;
	idata[tpos+2] = col;
}

void putpixel_color( uint8_t v, uint8_t a, int x, int y )
{
	uint32_t tpos = (x+y*w)*4;
	// add alpha
	int alph = idata[tpos+3];
	alph += a;
	if ( alph > 255 ) alph = 255;
	idata[tpos+3] = alph;
	// blend color (RGB)
	for ( int i=0; i<3; i++ )
	{
		int col = idata[tpos+i]*(a-255);
		int palent = (v*palsize)/256;
		col += pal[palent*3+i]*a;
		col /= 255;
		idata[tpos+i] = col;
	}
}

void putpixel( uint8_t v, uint8_t a, int x, int y )
{
	if ( (x < 0) || (x >= w) || (y < 0) || (y >= h) )
	{
		oob = 1;
		return;
	}
	if ( palsize == 0 ) putpixel_grayscale(v,a,x,y);
	else putpixel_color(v,a,x,y);
}

uint8_t lerpg( float a )
{
	if ( a >= 1. ) return 255;
	if ( a <= 0. ) return 64;
	return (uint8_t)(a*191+64);
}

int draw_glyph( FT_Bitmap *bmp, uint8_t v, int px, int py, int oy )
{
	if ( !bmp->buffer ) return 0;
	int drawn = 0;
	unsigned i, j;
	for ( j=0; j<bmp->rows; j++ )
	{
		uint8_t rv = v;
		// apply gradient, if any
		if ( v == 255 )
		{
			float a;
			int ofs = j+oy;
			if ( ofs < 0 ) a = 0.;
			else a = ofs/(float)(h-gh);
			if ( (gradient&3) == 1 ) rv = lerpg(1.-a);
			else if ( (gradient&3) == 2 ) rv = lerpg(a);
			else if ( (gradient&3) == 3 ) rv = lerpg((a>.5)?((1.-a)*2.):(a*2.));
		}
		for ( i=0; i<bmp->width; i++ )
		{
			if ( bmp->pixel_mode == FT_PIXEL_MODE_GRAY )
			{
				uint8_t a = bmp->buffer[i+j*bmp->pitch];
				drawn |= (a > 0);
				putpixel(rv,a,i+px,j+py);
			}
			else if ( bmp->pixel_mode == FT_PIXEL_MODE_MONO )
			{
				// thanks to https://stackoverflow.com/a/14905971
				unsigned p = bmp->pitch;
				uint8_t *row = &bmp->buffer[p*j];
				uint8_t a = ((row[i>>3])&(128>>(i&7)))?255:0;
				drawn |= (a > 0);
				putpixel(rv,a,i+px,j+py);
			}
		}
	}
	return drawn;
}

int palinv = 0;

void loadpalette( const char *path )
{
	FILE *f = fopen(path,"rb");
	if ( !f )
	{
		fprintf(stderr,"warning: could not open palette file '%s', falling back to grayscale\n",path);
		return;
	}
	fseek(f,0,SEEK_END);
	long sz = ftell(f);
	fseek(f,0,SEEK_SET);
	if ( sz <= 0 )
	{
		fprintf(stderr,"warning: palette is empty, falling back to grayscale\n");
		goto palend;
	}
	if ( !(sz%3) )
	{
		// RGB8 palette
		if ( sz > 768 )
		{
			fprintf(stderr,"warning: palette has more than 256 entries, extra colors will be ignored\n");
			palsize = 256;
		}
		else palsize = sz/3;
		for ( int i=0; i<palsize; i++ )
		{
			int j = palinv?(palsize-(i+1)):i;
			pal[j*3] = fgetc(f);
			pal[j*3+1] = fgetc(f);
			pal[j*3+2] = fgetc(f);
		}
		fprintf(stderr,"info: RGB8 palette loaded with %d colors.\n",palsize);
	}
	else if ( !(sz%4) )
	{
		// RGBA8 palette
		if ( sz > 1024 )
		{
			fprintf(stderr,"warning: palette has more than 256 entries, extra colors will be ignored\n");
			palsize = 256;
		}
		else palsize = sz/4;
		for ( int i=0; i<palsize; i++ )
		{
			int j = palinv?(palsize-(i+1)):i;
			pal[j*3] = fgetc(f);
			pal[j*3+1] = fgetc(f);
			pal[j*3+2] = fgetc(f);
			fgetc(f);	// skip alpha
		}
		fprintf(stderr,"info: RGBA8 palette loaded with %d colors (alpha will be ignored).\n",palsize);
	}
	else fprintf(stderr,"warning: palette is in an unsupported format, falling back to grayscale\n");
	palend:
	fclose(f);
}

const char grads[12][20] =
{
	"Flat (Shadow)",
	"Top-Bottom (Shadow)",
	"Bottom-Top (Shadow)",
	"Centered (Shadow)",
	"Flat (Border)",
	"Top-Bottom (Border)",
	"Bottom-Top (Border)",
	"Centered (Border)",
	"Flat",
	"Top-Bottom",
	"Bottom-Top",
	"Centered"
};

// grad stuff: shadow adds 1 to glyph width and height
//             border adds 2 to glyph width and height
//                    and subtracts 1 from glyph x/y offsets
// ez stuff...

#define LOADFLAGS FT_LOAD_PEDANTIC
#define RENDERMODE FT_RENDER_MODE_NORMAL

#ifdef ASCII_ONLY
// only 00-FF, which Godot should expect for bitmap fonts
#define MAX_GLYPHS 256
#define MAX_UNICODE 0xFF
#else
// values as of Unicode 17.0
#define MAX_GLYPHS 303808
#define MAX_UNICODE 0x10FFFF
#endif

static int cmpglyph_final( const void *p1, const void *p2 )
{
	// cast for convenience
	packglyph_t *a = (packglyph_t*)p1,
	*b = (packglyph_t*)p2;
	// sort from lowest to highest page number first
	if ( a->page != b->page )
		return a->page-b->page;
	// sort from lowest to highest unicode value second
	return a->unicode-b->unicode;
}

// used for naming a grand total of 36 potential pages
char base36( uint8_t val )
{
	if ( val < 10 ) return '0'+val;
	else return 'A'+(val-10);
}

int main( int argc, char **argv )
{
	if ( argc < 4 )
	{
		fprintf(stderr,"usage: mkbmfont <font name>[:face index] <pxsize> <bmfont name>"
			" [gradient type (0,11)] [color palette] [-palinv]\n");
		return 1;
	}
	if ( FT_Init_FreeType(&ftlib) )
	{
		fprintf(stderr,"error: failed to init freetype library\n");
		return 2;
	}
	int pxsiz;
	sscanf(argv[2],"%d",&pxsiz);
	char bmname[256], pname[256];
	snprintf(bmname,256,"%s.fnt",argv[3]);
	if ( argc > 4 )
	{
		sscanf(argv[4],"%d",&gradient);
		if ( (gradient < 0) || (gradient >= 12) )
		{
			fprintf(stderr,"warning: gradient type out of range, falling back to type 0.\n");
			gradient = 0;
		}
	}
	if ( !(gradient&8) )
	{
		gw++;
		gh++;
		if ( gradient&4 )
		{
			gx--;
			gy--;
			gw++;
			gh++;
		}
	}
	fprintf(stderr,"info: gradient selected is '%s'.\n",grads[gradient]);
	if ( argc > 6 ) palinv = !strcmp(argv[6],"-palinv");
	if ( argc > 5 ) loadpalette(argv[5]);
	char *fidx = strrchr(argv[1],':');
	int fnum = 0;
	if ( fidx )
	{
		*fidx = 0;
		sscanf(fidx+1,"%d",&fnum);
	}
	if ( FT_New_Face(ftlib,argv[1],fnum,&fnt) )
	{
		if ( fidx ) fprintf(stderr,"error: failed to open font '%s' face %d.\n",argv[1],fnum);
		else fprintf(stderr,"error: failed to open font '%s'.\n",argv[1]);
		return 4;
	}
	fprintf(stderr,"info: loaded font \'%s %s\'.\n",fnt->family_name,fnt->style_name);
	int nfnt = fnt->num_faces;
	if ( !fidx && (nfnt > 1) )
	{
		fprintf(stderr,"info: loaded font has %d faces, you may want to load a specific one (see below).\n",nfnt);
		FT_Done_Face(fnt);
		for ( int i=0; i<nfnt; i++ )
		{
			if ( FT_New_Face(ftlib,argv[1],i,&fnt) )
			{
				fprintf(stderr,"error: failed to open font '%s' face %d. Skipping.\n",argv[1],i);
				continue;
			}
			fprintf(stderr,"info: face %d: \'%s %s\'.\n",i,fnt->family_name,fnt->style_name);
			FT_Done_Face(fnt);
		}
		FT_Done_FreeType(ftlib);
		return 0;
	}
	if ( FT_Set_Pixel_Sizes(fnt,0,pxsiz) )
	{
		if ( fnt->num_fixed_sizes <= 0 )
		{
			fprintf(stderr,"error: font pixel size of '%d' not available.\n",pxsiz);
			return 8;
		}
		fprintf(stderr,"warning: failed to set pixel size '%d', trying fixed sizes.\n",pxsiz);
		int match = -1;
		for ( int i=0; i<fnt->num_fixed_sizes; i++ )
		{
			if ( fnt->available_sizes[i].height == pxsiz ) continue;
			match = i;
			break;
		}
		if ( (match == -1) || FT_Select_Size(fnt,match) )
		{
			fprintf(stderr,"error: font fixed size of '%d' not available\n",pxsiz);
			fprintf(stderr,"available size(s): ");
			for ( int i=0; i<fnt->num_fixed_sizes; i++ )
				fprintf(stderr,"%u%s",fnt->available_sizes[i].height,(i<(fnt->num_fixed_sizes-1))?", ":".\n");
			FT_Done_Face(fnt);
			FT_Done_FreeType(ftlib);
			return 8;
		}
	}
	lh = (fnt->size->metrics.height>>6);
	FT_Select_Charmap(fnt,FT_ENCODING_UNICODE);
	// pre-allocate
	uint32_t nglyphs = MAX_GLYPHS;
	packglyph_t* glyphs = calloc(nglyphs,sizeof(packglyph_t));
	uint32_t cur = 0;
	// count up and populate valid glyphs
	for ( uint32_t i=0; i<=MAX_UNICODE; i++ )
	{
		FT_UInt glyph = FT_Get_Char_Index(fnt,i);
		if ( !glyph || FT_Load_Glyph(fnt,glyph,LOADFLAGS) ) continue;
		FT_Render_Glyph(fnt->glyph,RENDERMODE);
		glyphs[cur].unicode = i;
		glyphs[cur].glyph = glyph;
		glyphs[cur].x = 0;
		glyphs[cur].y = 0;
		if ( !fnt->glyph->bitmap.buffer )
		{
			glyphs[cur].w = 0;
			glyphs[cur].h = 0;
			glyphs[cur].xofs = 0;
			glyphs[cur].yofs = 0;
		}
		else
		{
			glyphs[cur].w = fnt->glyph->bitmap.width+gw;
			glyphs[cur].h = fnt->glyph->bitmap.rows+gh;
			glyphs[cur].xofs = fnt->glyph->bitmap_left+gx;
			glyphs[cur].yofs = (-fnt->glyph->bitmap_top)+gy;
		}
		glyphs[cur].xadv = fnt->glyph->advance.x>>6;
		// calculate baseline using 'n' as reference
		if ( i == 'n' ) bl = pxsiz-(-fnt->glyph->bitmap_top+fnt->glyph->bitmap.rows);
		cur++;
		if ( cur > nglyphs )
		{
			fprintf(stderr,"warning: font somehow covers more code points than expected\n");
			break;
		}
	}
	if ( cur <= 0 )
	{
		fprintf(stderr,"error: no valid glyphs in font.\n");
		FT_Done_Face(fnt);
		FT_Done_FreeType(ftlib);
		return 16;
	}
	// reduce array size if smaller, for convenience
	if ( nglyphs > cur )
	{
		nglyphs = cur;
		glyphs = realloc(glyphs,nglyphs*sizeof(packglyph_t));
	}
	// update offsets to account for baseline
	for ( uint32_t i=0; i<nglyphs; i++ )
	{
		// skip glyphs with no visual
		if ( !(glyphs[i].w|glyphs[i].h) ) continue;
		glyphs[i].yofs += bl;
	}
	fprintf(stderr,"info: total glyphs is %u.\n",nglyphs);
	// second pass, compute maximum glyph bitmap size, then allocate the drawing data
	for ( uint32_t i=0; i<nglyphs; i++ )
	{
		if ( glyphs[i].w > w ) w = glyphs[i].w;
		if ( glyphs[i].h > h ) h = glyphs[i].h;
	}
	fprintf(stderr,"info: max cell size is %dx%d.\n",w,h);
	idata = calloc(4,w*h);
	// third pass, pack, allocate atlas, then draw
	int retval = packglyphs(glyphs,nglyphs,&aw,&ah);
	if ( retval )
	{
		char errormsg[][32] = {"max tries hit","max pages hit"};
		fprintf(stderr,"error: failed to pack glyphs into an adequate atlas: %s.\n",errormsg[retval-1]);
		free(idata);
		FT_Done_Face(fnt);
		FT_Done_FreeType(ftlib);
		return 32;
	}
	// re-sort
	qsort(glyphs,nglyphs,sizeof(packglyph_t),cmpglyph_final);
	adata = calloc(4,aw*ah);
	int npages = 1;
	for ( uint32_t i=0; i<nglyphs; i++ )
	{
		if ( !glyphs[i].glyph || FT_Load_Glyph(fnt,glyphs[i].glyph,LOADFLAGS) ) continue;
		FT_Render_Glyph(fnt->glyph,RENDERMODE);
		if ( !fnt->glyph->bitmap.buffer ) continue;
		int oy = (h-gh) - (2+fnt->glyph->bitmap_top);
		if ( gradient&8 )
			draw_glyph(&fnt->glyph->bitmap,255,0,0,oy);
		else if ( gradient&4 )
		{
			// outline first
			for ( int x=-1; x<=1; x++ )
			for ( int y=-1; y<=1; y++ )
			{
				// ignore center
				if ( !(x|y) ) continue;
				draw_glyph(&fnt->glyph->bitmap,0,1+x,1+y,oy);
			}
			draw_glyph(&fnt->glyph->bitmap,255,1,1,oy);
		}
		else
		{
			// drop shadow first
			draw_glyph(&fnt->glyph->bitmap,0,1,1,oy);
			draw_glyph(&fnt->glyph->bitmap,255,0,0,oy);
		}
		// are we switching pages?
		if ( glyphs[i].page >= npages )
		{
			snprintf(pname,256,"%s%c.png",argv[3],base36(npages-1));
			writepng(pname,adata,aw,ah,aw*4);
			memset(adata,0,aw*ah*4);
			npages++;
		}
		// blit to canvas
		blitglyph(glyphs+i);
		// clear for next draw
		memset(idata,0,w*h*4);
	}
	fprintf(stderr,"info: texture atlas size is %ux%u, with %d page(s).\n",aw,ah,npages);
	free(idata);
	if ( npages == 1 ) snprintf(pname,256,"%s.png",argv[3]);
	else snprintf(pname,256,"%s%c.png",argv[3],base36(npages-1));
	writepng(pname,adata,aw,ah,aw*4);
	// don't forget to write the bmfont file
#ifdef USE_BINARY_BMFONT
	FILE *bmf = fopen(bmname,"wb");
	if ( !bmf )
	{
		fprintf(stderr,"error: failed to open '%s' for writing: %s\n",bmname,strerror(errno));
		free(adata);
		FT_Done_Face(fnt);
		FT_Done_FreeType(ftlib);
		return 64;
	}
	uint32_t bsiz = 0;
	// header
	fputc(66,bmf);
	fputc(77,bmf);
	fputc(70,bmf);
	fputc(3,bmf);
	// info
	char fontName[256];
	snprintf(fontName,256,"%s %s",fnt->family_name,fnt->style_name);
	bmfinfo_t info = { pxsiz, 2, 0, 100, 1, 0, 0, 0, 0, 1, 1, 0 };
	bsiz = sizeof(bmfinfo_t)+strlen(fontName)+1;
	fputc(1,bmf);
	fwrite(&bsiz,4,1,bmf);
	fwrite(&info,sizeof(bmfinfo_t),1,bmf);
	fwrite(fontName,strlen(fontName),1,bmf);
	fputc(0,bmf);
	// common
	bmfcommon_t cmn = { lh, bl, aw, ah, npages, 0, 0, 4, 4, 4 };
	bsiz = sizeof(bmfcommon_t);
	fputc(2,bmf);
	fwrite(&bsiz,4,1,bmf);
	fwrite(&cmn,sizeof(bmfcommon_t),1,bmf);
	// pages
	fputc(3,bmf);
	if ( npages == 1 )
	{
		snprintf(pname,256,"%s.png",argv[3]);
		bsiz = strlen(pname)+1;
		fwrite(&bsiz,4,1,bmf);
		fwrite(pname,strlen(pname),1,bmf);
		fputc(0,bmf);
	}
	else
	{
		snprintf(pname,256,"%s0.png",argv[3]);
		bsiz = (strlen(pname)+1)*npages;
		fwrite(&bsiz,4,1,bmf);
		for ( int i=0; i<npages; i++ )
		{
			fwrite(pname,strlen(pname),1,bmf);
			fputc(0,bmf);
			snprintf(pname,256,"%s%c.png",argv[3],base36(i+1));
		}
	}
	// chars
	bmfchar_t *chars = calloc(nglyphs,sizeof(bmfchar_t));
	for ( uint32_t i=0; i<nglyphs; i++ )
	{
		chars[i].id = glyphs[i].unicode;
		chars[i].x = glyphs[i].x;
		chars[i].y = glyphs[i].y;
		chars[i].width = glyphs[i].w;
		chars[i].height = glyphs[i].h;
		chars[i].xoffset = glyphs[i].xofs;
		chars[i].yoffset = glyphs[i].yofs;
		chars[i].xadvance = glyphs[i].xadv;
		chars[i].page = glyphs[i].page;
		chars[i].chnl = 15;
	}
	fputc(4,bmf);
	bsiz = nglyphs*sizeof(bmfchar_t);
	fwrite(&bsiz,4,1,bmf);
	fwrite(chars,sizeof(bmfchar_t),nglyphs,bmf);
	free(chars);
#else
	FILE *bmf = fopen(bmname,"w");
	if ( !bmf )
	{
		fprintf(stderr,"error: failed to open '%s' for writing: %s\n",bmname,strerror(errno));
		free(adata);
		FT_Done_Face(fnt);
		FT_Done_FreeType(ftlib);
		return 64;
	}
	// info
	fprintf(bmf,"info face=\"%s %s\" size=%u bold=0 italic=0 charset=\"\" unicode=1 stretchH=100 smooth=0 aa=1 padding=0,0,0,0 spacing=1,1 outline=0\n",fnt->family_name,fnt->style_name,pxsiz);
	// common
	fprintf(bmf,"common lineHeight=%u base=%u scaleW=%u scaleH=%u pages=%d packed=0 alphaChnl=0 redChnl=4 greenChnl=4 blueChnl=4\n",lh,bl,aw,ah,npages);
	// pages
	if ( npages == 1 )
	{
		snprintf(pname,256,"%s.png",argv[3]);
		fprintf(bmf,"page id=0 file=\"%s\"\n",pname);
	}
	else for ( int i=0; i<npages; i++ )
	{
		snprintf(pname,256,"%s%c.png",argv[3],base36(i));
		fprintf(bmf,"page id=%d file=\"%s\"\n",i,pname);
	}
	// chars
	fprintf(bmf,"chars count=%u\n",nglyphs);
	for ( uint32_t i=0; i<nglyphs; i++ )
		fprintf(bmf,"char id=%u x=%u y=%u width=%u height=%u xoffset=%d yoffset=%d xadvance=%d page=%d chnl=15\n",glyphs[i].unicode,glyphs[i].x,glyphs[i].y,glyphs[i].w,glyphs[i].h,glyphs[i].xofs,glyphs[i].yofs,glyphs[i].xadv,glyphs[i].page);
#endif
	fclose(bmf);
	free(adata);
	FT_Done_Face(fnt);
	FT_Done_FreeType(ftlib);
	return 0;
}