9d2a035a71
Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
262 lines
8.4 KiB
C++
262 lines
8.4 KiB
C++
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <zlib.h>
|
|
#include <png.h>
|
|
|
|
#define die(msg) do { fprintf(stderr, "%s\n", msg); abort(); } while(0)
|
|
|
|
#ifdef NDEBUG
|
|
#define COMPRESSION_LEVEL 9
|
|
#else
|
|
#define COMPRESSION_LEVEL 5
|
|
#endif
|
|
|
|
unsigned short* read_png(const char *filename) {
|
|
FILE *fp = fopen(filename, "rb");
|
|
if (!fp)
|
|
die("png fopen failed");
|
|
|
|
png_byte header[8] = {};
|
|
if(fread(header, 1, 8, fp) != 8)
|
|
die("png fread failed");
|
|
|
|
if(png_sig_cmp(header, 0, 8))
|
|
die("png_sig_cmp failed");
|
|
|
|
png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
|
|
if(!png)
|
|
die("png_create_read_struct failed");
|
|
|
|
png_set_expand(png);
|
|
png_set_strip_alpha(png);
|
|
|
|
png_infop png_info = png_create_info_struct(png);
|
|
if (!png_info)
|
|
die("png_create_info_struct failed");
|
|
|
|
if (setjmp(png_jmpbuf(png)))
|
|
die("png_init_io failed");
|
|
|
|
png_init_io(png, fp);
|
|
png_set_sig_bytes(png, 8);
|
|
|
|
png_read_info(png, png_info);
|
|
|
|
int width = png_get_image_width(png, png_info);
|
|
int height = png_get_image_height(png, png_info);
|
|
if(width != 16 || height != 16)
|
|
die("not a 16x16 png");
|
|
|
|
png_read_update_info(png, png_info);
|
|
|
|
if (setjmp(png_jmpbuf(png)))
|
|
die("png_read_image failed");
|
|
|
|
png_bytepp image = (png_bytepp) malloc(sizeof(png_bytep) * height);
|
|
for (int y = 0; y < height; y++)
|
|
image[y] = (png_bytep) malloc(png_get_rowbytes(png, png_info));
|
|
|
|
png_read_image(png, (png_bytepp) image);
|
|
|
|
unsigned short *glyph = (unsigned short *) calloc(16, 2);
|
|
|
|
for(int y = 0; y < height; y++) {
|
|
for(int x = 0; x < (int)png_get_rowbytes(png, png_info); x += 3) {
|
|
unsigned char r = image[y][x + 0],
|
|
g = image[y][x + 1],
|
|
b = image[y][x + 2];
|
|
|
|
if(r + g + b >= 11) {
|
|
glyph[y] |= 1 << (width - x / 3);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int y = 0; y < height; y++)
|
|
free(image[y]);
|
|
free(image);
|
|
|
|
fclose(fp);
|
|
|
|
png_destroy_read_struct(&png, &png_info, NULL);
|
|
|
|
return glyph;
|
|
}
|
|
|
|
const static unsigned short replacement[16] = {
|
|
0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA,
|
|
0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA,
|
|
0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA,
|
|
0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA,
|
|
};
|
|
|
|
struct CodepointProperties {
|
|
bool exists:1;
|
|
bool isWide:1;
|
|
};
|
|
|
|
int main(int argc, char** argv) {
|
|
if(argc < 3) {
|
|
fprintf(stderr, "Usage: %s <header/source out> <unifont.hex> <png glyph>...\n"
|
|
" where <png glyph>s are mapped into private use area\n"
|
|
" starting at U+E000.\n",
|
|
argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
const int codepoint_count = 0x10000;
|
|
unsigned short **font =
|
|
(unsigned short **)calloc(sizeof(unsigned short*), codepoint_count);
|
|
CodepointProperties *properties =
|
|
(CodepointProperties *)calloc(sizeof(CodepointProperties), codepoint_count);
|
|
|
|
const int private_start = 0xE000;
|
|
for(int i = 3; i < argc; i++) {
|
|
int codepoint = private_start + i - 3;
|
|
font[codepoint] = read_png(argv[i]);
|
|
properties[codepoint].exists = true;
|
|
}
|
|
|
|
gzFile unifont = gzopen(argv[2], "rb");
|
|
if(!unifont)
|
|
die("unifont fopen failed");
|
|
|
|
while(1) {
|
|
char buf[100];
|
|
if(!gzgets(unifont, buf, sizeof(buf))){
|
|
if(gzeof(unifont)) {
|
|
break;
|
|
} else {
|
|
die("unifont gzgets failed");
|
|
}
|
|
}
|
|
|
|
unsigned short codepoint;
|
|
unsigned short *glyph = (unsigned short *) calloc(32, 1);
|
|
bool isWide;
|
|
if( sscanf(buf, "%4hx:%4hx%4hx%4hx%4hx%4hx%4hx%4hx%4hx"
|
|
"%4hx%4hx%4hx%4hx%4hx%4hx%4hx%4hx\n",
|
|
&codepoint,
|
|
&glyph[0], &glyph[1], &glyph[2], &glyph[3],
|
|
&glyph[4], &glyph[5], &glyph[6], &glyph[7],
|
|
&glyph[8], &glyph[9], &glyph[10], &glyph[11],
|
|
&glyph[12], &glyph[13], &glyph[14], &glyph[15]) == 17) {
|
|
/* read 16x16 character */
|
|
isWide = true;
|
|
} else if(sscanf(buf, "%4hx:%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx"
|
|
"%2hx%2hx%2hx%2hx%2hx%2hx%2hx%2hx\n",
|
|
&codepoint,
|
|
&glyph[0], &glyph[1], &glyph[2], &glyph[3],
|
|
&glyph[4], &glyph[5], &glyph[6], &glyph[7],
|
|
&glyph[8], &glyph[9], &glyph[10], &glyph[11],
|
|
&glyph[12], &glyph[13], &glyph[14], &glyph[15]) == 17) {
|
|
/* read 8x16 character */
|
|
for(int i = 0; i < 16; i++)
|
|
glyph[i] <<= 8;
|
|
isWide = false;
|
|
} else {
|
|
die("parse unifont character");
|
|
}
|
|
|
|
font[codepoint] = glyph;
|
|
properties[codepoint].exists = true;
|
|
properties[codepoint].isWide = isWide;
|
|
}
|
|
|
|
gzclose(unifont);
|
|
|
|
FILE *source = fopen(argv[1], "wt");
|
|
if(!source)
|
|
die("source fopen failed");
|
|
|
|
const int chunk_size = 64 * 64,
|
|
chunks = codepoint_count / chunk_size;
|
|
|
|
const int chunk_input_size = chunk_size * 16 * 16;
|
|
unsigned int chunk_output_size[chunks] = {};
|
|
|
|
unsigned char *chunk_data = (unsigned char *)calloc(1, chunk_input_size);
|
|
unsigned int chunk_data_index;
|
|
|
|
fprintf(source, "/**** This is a generated file - do not edit ****/\n\n");
|
|
|
|
for(int chunk_index = 0; chunk_index < chunks; chunk_index++) {
|
|
chunk_data_index = 0;
|
|
|
|
const int chunk_start = chunk_index * chunk_size;
|
|
for(int codepoint = chunk_start; codepoint < chunk_start + chunk_size; codepoint++) {
|
|
const unsigned short *glyph = font[codepoint] != NULL ? font[codepoint] : replacement;
|
|
for(int x = 15; x >= 0; x--) {
|
|
for(int y = 0; y < 16; y++) {
|
|
chunk_data[chunk_data_index++] = (glyph[y] & (1 << x)) ? 0xff : 0;
|
|
}
|
|
}
|
|
|
|
if(font[codepoint] != NULL)
|
|
free(font[codepoint]);
|
|
}
|
|
|
|
fprintf(source, "static const uint8_t CompressedFontTextureChunk%d[] = {\n",
|
|
chunk_start / chunk_size);
|
|
|
|
z_stream stream;
|
|
stream.zalloc = Z_NULL;
|
|
stream.zfree = Z_NULL;
|
|
stream.opaque = Z_NULL;
|
|
if(deflateInit(&stream, COMPRESSION_LEVEL) != Z_OK)
|
|
die("deflateInit failed");
|
|
|
|
stream.next_in = chunk_data;
|
|
stream.avail_in = chunk_input_size;
|
|
|
|
do {
|
|
unsigned char compressed_chunk_data[16384] = {};
|
|
stream.next_out = compressed_chunk_data;
|
|
stream.avail_out = sizeof(compressed_chunk_data);
|
|
deflate(&stream, Z_FINISH);
|
|
|
|
chunk_output_size[chunk_index] += sizeof(compressed_chunk_data) - stream.avail_out;
|
|
for(int i = 0; i < sizeof(compressed_chunk_data) - stream.avail_out; i += 16) {
|
|
unsigned char *d = &compressed_chunk_data[i];
|
|
fprintf(source, " %3d, %3d, %3d, %3d, %3d, %3d, %3d, %3d, "
|
|
"%3d, %3d, %3d, %3d, %3d, %3d, %3d, %3d,\n",
|
|
d[ 0], d[ 1], d[ 2], d[ 3], d[ 4], d[ 5], d[ 6], d[ 7],
|
|
d[ 8], d[ 9], d[10], d[11], d[12], d[13], d[14], d[15]);
|
|
}
|
|
} while(stream.avail_out == 0);
|
|
|
|
deflateEnd(&stream);
|
|
|
|
fprintf(source, "};\n\n");
|
|
}
|
|
|
|
free(chunk_data);
|
|
free(font);
|
|
|
|
fprintf(source, "static const struct {\n"
|
|
" size_t length;"
|
|
" const uint8_t *data;"
|
|
"} CompressedFontTexture[%d] = {\n", chunks);
|
|
for(int i = 0; i < chunks; i++) {
|
|
fprintf(source, " { %d, CompressedFontTextureChunk%d },\n",
|
|
chunk_output_size[i], i);
|
|
}
|
|
fprintf(source, "};\n\n");
|
|
|
|
fprintf(source, "struct GlyphProperties {\n"
|
|
" bool exists:1;\n"
|
|
" bool isWide:1;\n"
|
|
"} CodepointProperties[%d] = {\n", codepoint_count);
|
|
for(int i = 0; i < codepoint_count; i++) {
|
|
fprintf(source, " { %s, %s },\n",
|
|
properties[i].exists ? "true" : "false",
|
|
properties[i].isWide ? "true" : "false");
|
|
}
|
|
fprintf(source, "};\n");
|
|
|
|
free(properties);
|
|
|
|
fclose(source);
|
|
}
|