mirror of
https://github.com/UpsilonNumworks/Upsilon.git
synced 2026-01-19 00:37:25 +01:00
230 lines
8.3 KiB
C
230 lines
8.3 KiB
C
/* example1.c */
|
|
/* */
|
|
/* This small program shows how to print a rotated string with the */
|
|
/* FreeType 2 library. */
|
|
|
|
/*
|
|
* Usage: rasterizer font_name glyph_width glyph_height
|
|
* -> Generates a .png image with the font rasterized
|
|
* -> Generates a .c file with the content of the font
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#include <ft2build.h>
|
|
#include FT_FREETYPE_H
|
|
|
|
#define ENSURE(action, description...) { if (!(action)) { fprintf(stderr, "Error: "); fprintf(stderr, description); fprintf(stderr, "\n"); exit(-1);}}
|
|
|
|
// Pixel format is RGB888
|
|
|
|
typedef struct {
|
|
unsigned char red;
|
|
unsigned char green;
|
|
unsigned char blue;
|
|
} pixel_t;
|
|
|
|
typedef struct {
|
|
pixel_t * pixels;
|
|
int width;
|
|
int height;
|
|
} image_t;
|
|
|
|
#ifdef GENERATE_PNG
|
|
#include <png.h>
|
|
void writeImageToPNGFile(image_t * image, char * filename);
|
|
#endif
|
|
|
|
#define CHARACTER_RANGE_START 0x20
|
|
#define CHARACTER_RANGE_END 0x7E
|
|
|
|
#define GRID_WIDTH 19
|
|
#define GRID_HEIGHT 5
|
|
|
|
#if (GRID_WIDTH*GRID_HEIGHT < (CHARACTER_RANGE_END-CHARACTER_RANGE_START+1))
|
|
#error Grid too small. Consider increasing GRID_WIDTH or GRID_HEIGHT
|
|
#endif
|
|
|
|
|
|
void drawGlyphInImage(FT_Bitmap * glyphBitmap, image_t * image, int x, int y);
|
|
|
|
int main(int argc, char * argv[]) {
|
|
FT_Library library;
|
|
FT_Face face;
|
|
image_t bitmap_image;
|
|
|
|
if (argc != 4) {
|
|
fprintf(stderr, "Usage: %s font_file glyph_width glyph_height\n", argv[0]);
|
|
fprintf(stderr, " font_file: Path of the font file to load\n");
|
|
fprintf(stderr, " glyph_width: Width of bitmap glyphs, in pixels\n");
|
|
fprintf(stderr, " glyph_height: Height of bitmap glyphs, in pixels\n");
|
|
exit(1);
|
|
}
|
|
|
|
char * font_file = argv[1];
|
|
int requested_glyph_width = atoi(argv[2]);
|
|
int requested_glyph_height = atoi(argv[3]);
|
|
|
|
ENSURE(!FT_Init_FreeType(&library), "Initializing library");
|
|
|
|
// 0 means we're picking the first face in the provided file
|
|
ENSURE(!FT_New_Face(library, font_file, 0, &face), "Loading font file %s", font_file);
|
|
|
|
ENSURE(!FT_Set_Pixel_Sizes(face, requested_glyph_width, requested_glyph_height), "Setting face pixel size to %dx%d", requested_glyph_width, requested_glyph_height);
|
|
|
|
int maxHeight = 0;
|
|
int maxWidth = 0;
|
|
int minTop = requested_glyph_height;
|
|
for (unsigned char character = CHARACTER_RANGE_START; character <= CHARACTER_RANGE_END; character++) {
|
|
ENSURE(!FT_Load_Char(face, character, FT_LOAD_RENDER), "Loading character 0x%02x", character);
|
|
int top = requested_glyph_height - face->glyph->bitmap_top;
|
|
int height = top + face->glyph->bitmap.rows;
|
|
int width = face->glyph->bitmap.width;
|
|
if (top < minTop) {
|
|
minTop = top;
|
|
}
|
|
if (height > maxHeight) {
|
|
maxHeight = height;
|
|
}
|
|
if (width > maxWidth) {
|
|
maxWidth = width;
|
|
}
|
|
}
|
|
|
|
int glyph_width = maxWidth;
|
|
int glyph_height = maxHeight-minTop;
|
|
printf("Actual glyph size = %dx%d\n", glyph_width, glyph_height);
|
|
|
|
int grid_size = 1;
|
|
|
|
bitmap_image.width = GRID_WIDTH*glyph_width+(GRID_WIDTH-1)*grid_size;
|
|
bitmap_image.height = GRID_HEIGHT*glyph_height+(GRID_HEIGHT-1)*grid_size;
|
|
bitmap_image.pixels = malloc(sizeof(pixel_t)*bitmap_image.width*bitmap_image.height);
|
|
ENSURE(bitmap_image.pixels != NULL, "Allocating bitmap image of size %dx%d at %ld bytes per pixel", bitmap_image.width, bitmap_image.height, sizeof(pixel_t));
|
|
|
|
// Draw the grid and the background
|
|
for (int i = 0; i<bitmap_image.width;i++) {
|
|
for (int j = 0; j<bitmap_image.height;j++) {
|
|
pixel_t pixel = {.red = 0xFF, .green = 0xFF, .blue = 0xFF};
|
|
if (i%(glyph_width+grid_size) >= glyph_width || j%(glyph_height+grid_size) >= glyph_height) {
|
|
pixel = (pixel_t){.red = 0xFF, .green = 0, .blue = 0};
|
|
}
|
|
*(bitmap_image.pixels + j*bitmap_image.width + i) = pixel;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// We're doing the ASCII table, so characters from 0 to 255 inclusive
|
|
for (unsigned char character = CHARACTER_RANGE_START; character <= CHARACTER_RANGE_END; character++) {
|
|
int x = (character-CHARACTER_RANGE_START)%(GRID_WIDTH);
|
|
int y = (character-CHARACTER_RANGE_START)/(GRID_WIDTH);
|
|
// FT_LOAD_RENDER: Render the glyph upon load
|
|
ENSURE(!FT_Load_Char(face, character, FT_LOAD_RENDER), "Loading character 0x%02x", character);
|
|
//printf("Advances = %dx%d\n", face->glyph->bitmap_left, face->glyph->bitmap_top);
|
|
drawGlyphInImage(&face->glyph->bitmap,
|
|
&bitmap_image,
|
|
x*(glyph_width+grid_size) /* + face->glyph->bitmap_left*/,
|
|
y*(glyph_height+grid_size) + requested_glyph_height - face->glyph->bitmap_top - minTop);// + glyph_height - face->glyph->bitmap_top - maxHeight);
|
|
}
|
|
|
|
#if GENERATE_PNG
|
|
writeImageToPNGFile(&bitmap_image, "out.png");
|
|
#endif
|
|
|
|
FILE * headerFile = fopen("out.h", "w");
|
|
fprintf(headerFile, "/* Auto-generated by rasterizer */\n\n");
|
|
fprintf(headerFile, "#define BITMAP_FONT_FIRST_CHARACTER 0x%2x\n", CHARACTER_RANGE_START);
|
|
fprintf(headerFile, "#define BITMAP_FONT_LAST_CHARACTER 0x%2x\n\n", CHARACTER_RANGE_END);
|
|
fprintf(headerFile, "#define BITMAP_FONT_CHARACTER_WIDTH %d\n", glyph_width);
|
|
fprintf(headerFile, "#define BITMAP_FONT_CHARACTER_HEIGHT %d\n\n", glyph_height);
|
|
fprintf(headerFile, "extern unsigned char bitmapFont[%d][%d][%d];\n", CHARACTER_RANGE_END-CHARACTER_RANGE_START+1, glyph_height, glyph_width);
|
|
fclose(headerFile);
|
|
|
|
FILE * sourceFile = fopen("out.c", "w");
|
|
fprintf(sourceFile, "/* Auto-generated by rasterizer */\n\n");
|
|
fprintf(sourceFile, "unsigned char bitmapFont[%d][%d][%d] = {\n", CHARACTER_RANGE_END-CHARACTER_RANGE_START+1, glyph_height, glyph_width);
|
|
for (unsigned char character = CHARACTER_RANGE_START; character <= CHARACTER_RANGE_END; character++) {
|
|
fprintf(sourceFile, " {\n");
|
|
int characterX = ((character-CHARACTER_RANGE_START)%GRID_WIDTH * (glyph_width+grid_size));
|
|
int characterY = ((character-CHARACTER_RANGE_START)/GRID_WIDTH * (glyph_height+grid_size));
|
|
for (int y = 0; y < glyph_height; y++) {
|
|
fprintf(sourceFile, " {");
|
|
for (int x = 0; x < glyph_width; x++) {
|
|
pixel_t * pixel = (bitmap_image.pixels + (y+characterY)*bitmap_image.width + (x+characterX));
|
|
fprintf(sourceFile, "0x%02x", pixel->green);
|
|
if (x+1 < glyph_width) {
|
|
fprintf(sourceFile, ", ");
|
|
}
|
|
}
|
|
fprintf(sourceFile, "}");
|
|
if (y+1 < glyph_height) {
|
|
fprintf(sourceFile, ",");
|
|
}
|
|
fprintf(sourceFile, "\n");
|
|
}
|
|
fprintf(sourceFile, " }");
|
|
if (character+1 <= CHARACTER_RANGE_END) {
|
|
fprintf(sourceFile, ",");
|
|
}
|
|
fprintf(sourceFile, "\n");
|
|
}
|
|
|
|
fprintf(sourceFile, "};\n");
|
|
fclose(sourceFile);
|
|
|
|
free(bitmap_image.pixels);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void drawGlyphInImage(FT_Bitmap * glyphBitmap, image_t * image, int x, int y) {
|
|
// printf("Drawing glyph. Size is %dx%d, pitch is %d\n", glyphBitmap->width, glyphBitmap->rows, glyphBitmap->pitch);
|
|
ENSURE(glyphBitmap->pixel_mode == FT_PIXEL_MODE_GRAY, "Checking glyph is in FT_PIXEL_MODE_GRAY");
|
|
for (int j=0;j<glyphBitmap->rows;j++) {
|
|
for (int i=0;i<glyphBitmap->width;i++) {
|
|
uint8_t glyphPixel = *(glyphBitmap->buffer + j*glyphBitmap->pitch + i);
|
|
pixel_t * currentPixelPointer = (image->pixels + (y+j)*image->width + (x+i));
|
|
*currentPixelPointer = (pixel_t){.red = (0xFF-glyphPixel), .green = (0xFF-glyphPixel), .blue = (0xFF-glyphPixel)}; // Alpha blending
|
|
}
|
|
}
|
|
}
|
|
|
|
#if GENERATE_PNG
|
|
|
|
void writeImageToPNGFile(image_t * image, char * filename) {
|
|
FILE * file = fopen(filename, "wb"); // Write in binary mode
|
|
ENSURE(file != NULL, "Opening file %s", filename);
|
|
|
|
png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
|
|
ENSURE(png != NULL, "Allocating PNG write structure");
|
|
|
|
png_infop info = png_create_info_struct(png);
|
|
ENSURE(info != NULL, "Allocating info structure");
|
|
|
|
png_init_io(png, file);
|
|
|
|
png_set_IHDR(png, info,
|
|
image->width, image->height,
|
|
8, // Number of bits per channel
|
|
PNG_COLOR_TYPE_RGB,
|
|
PNG_INTERLACE_NONE,
|
|
PNG_COMPRESSION_TYPE_DEFAULT,
|
|
PNG_FILTER_TYPE_DEFAULT);
|
|
|
|
png_write_info(png, info);
|
|
|
|
for (int j=0;j<image->height;j++) {
|
|
png_write_row(png, (png_bytep)(image->pixels+j*image->width));
|
|
}
|
|
|
|
png_write_end(png, NULL);
|
|
|
|
png_free_data(png, info, PNG_FREE_ALL, -1); // -1 = all items
|
|
png_destroy_write_struct(&png, (png_infopp)NULL);
|
|
fclose(file);
|
|
}
|
|
#endif
|