#include "ft2.h"
#include "ft2_defs.h"
#include "ft2_fontdefs.h"
+#include "image.h"
static int img_fontmap[256] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
cvar_t r_font_use_alpha_textures = {CVAR_SAVE, "r_font_use_alpha_textures", "0", "use alpha-textures for font rendering, this should safe memory"};
cvar_t r_font_size_snapping = {CVAR_SAVE, "r_font_size_snapping", "1", "stick to good looking font sizes whenever possible - bad when the mod doesn't support it!"};
cvar_t r_font_kerning = {CVAR_SAVE, "r_font_kerning", "1", "Use kerning if available"};
+cvar_t r_font_diskcache = {CVAR_SAVE, "r_font_diskcache", "0", "save font textures to disk for future loading rather than generating them every time"};
+cvar_t r_font_compress = {CVAR_SAVE, "r_font_compress", "0", "use texture compression on font textures to save video memory"};
+cvar_t r_font_nonpoweroftwo = {CVAR_SAVE, "r_font_nonpoweroftwo", "1", "use nonpoweroftwo textures for font (saves memory, potentially slower)"};
cvar_t developer_font = {CVAR_SAVE, "developer_font", "0", "prints debug messages about fonts"};
+#ifndef DP_FREETYPE_STATIC
+
/*
================================================================================
Function definitions. Taken from the freetype2 headers.
/// Handle for FreeType2 DLL
static dllhandle_t ft2_dll = NULL;
+#else
+
+FT_EXPORT( FT_Error )
+(FT_Init_FreeType)( FT_Library *alibrary );
+FT_EXPORT( FT_Error )
+(FT_Done_FreeType)( FT_Library library );
+/*
+FT_EXPORT( FT_Error )
+(FT_New_Face)( FT_Library library,
+ const char* filepathname,
+ FT_Long face_index,
+ FT_Face *aface );
+*/
+FT_EXPORT( FT_Error )
+(FT_New_Memory_Face)( FT_Library library,
+ const FT_Byte* file_base,
+ FT_Long file_size,
+ FT_Long face_index,
+ FT_Face *aface );
+FT_EXPORT( FT_Error )
+(FT_Done_Face)( FT_Face face );
+FT_EXPORT( FT_Error )
+(FT_Select_Size)( FT_Face face,
+ FT_Int strike_index );
+FT_EXPORT( FT_Error )
+(FT_Request_Size)( FT_Face face,
+ FT_Size_Request req );
+FT_EXPORT( FT_Error )
+(FT_Set_Char_Size)( FT_Face face,
+ FT_F26Dot6 char_width,
+ FT_F26Dot6 char_height,
+ FT_UInt horz_resolution,
+ FT_UInt vert_resolution );
+FT_EXPORT( FT_Error )
+(FT_Set_Pixel_Sizes)( FT_Face face,
+ FT_UInt pixel_width,
+ FT_UInt pixel_height );
+FT_EXPORT( FT_Error )
+(FT_Load_Glyph)( FT_Face face,
+ FT_UInt glyph_index,
+ FT_Int32 load_flags );
+FT_EXPORT( FT_Error )
+(FT_Load_Char)( FT_Face face,
+ FT_ULong char_code,
+ FT_Int32 load_flags );
+FT_EXPORT( FT_UInt )
+(FT_Get_Char_Index)( FT_Face face,
+ FT_ULong charcode );
+FT_EXPORT( FT_Error )
+(FT_Render_Glyph)( FT_GlyphSlot slot,
+ FT_Render_Mode render_mode );
+FT_EXPORT( FT_Error )
+(FT_Get_Kerning)( FT_Face face,
+ FT_UInt left_glyph,
+ FT_UInt right_glyph,
+ FT_UInt kern_mode,
+ FT_Vector *akerning );
+FT_EXPORT( FT_Error )
+(FT_Attach_Stream)( FT_Face face,
+ FT_Open_Args* parameters );
+
+#define qFT_Init_FreeType FT_Init_FreeType
+#define qFT_Done_FreeType FT_Done_FreeType
+//#define qFT_New_Face FT_New_Face
+#define qFT_New_Memory_Face FT_New_Memory_Face
+#define qFT_Done_Face FT_Done_Face
+#define qFT_Select_Size FT_Select_Size
+#define qFT_Request_Size FT_Request_Size
+#define qFT_Set_Char_Size FT_Set_Char_Size
+#define qFT_Set_Pixel_Sizes FT_Set_Pixel_Sizes
+#define qFT_Load_Glyph FT_Load_Glyph
+#define qFT_Load_Char FT_Load_Char
+#define qFT_Get_Char_Index FT_Get_Char_Index
+#define qFT_Render_Glyph FT_Render_Glyph
+#define qFT_Get_Kerning FT_Get_Kerning
+#define qFT_Attach_Stream FT_Attach_Stream
+
+#endif
+
/// Memory pool for fonts
static mempool_t *font_mempool= NULL;
-static rtexturepool_t *font_texturepool = NULL;
/// FreeType library handle
static FT_Library font_ft2lib = NULL;
font_postprocess_t;
static font_postprocess_t pp;
+typedef struct fontfilecache_s
+{
+ unsigned char *buf;
+ fs_offset_t len;
+ int refcount;
+ char path[MAX_QPATH];
+}
+fontfilecache_t;
+#define MAX_FONTFILES 8
+static fontfilecache_t fontfiles[MAX_FONTFILES];
+static const unsigned char *fontfilecache_LoadFile(const char *path, qboolean quiet, fs_offset_t *filesizepointer)
+{
+ int i;
+ unsigned char *buf;
+
+ for(i = 0; i < MAX_FONTFILES; ++i)
+ {
+ if(fontfiles[i].refcount > 0)
+ if(!strcmp(path, fontfiles[i].path))
+ {
+ *filesizepointer = fontfiles[i].len;
+ ++fontfiles[i].refcount;
+ return fontfiles[i].buf;
+ }
+ }
+
+ buf = FS_LoadFile(path, font_mempool, quiet, filesizepointer);
+ if(buf)
+ {
+ for(i = 0; i < MAX_FONTFILES; ++i)
+ if(fontfiles[i].refcount <= 0)
+ {
+ strlcpy(fontfiles[i].path, path, sizeof(fontfiles[i].path));
+ fontfiles[i].len = *filesizepointer;
+ fontfiles[i].buf = buf;
+ fontfiles[i].refcount = 1;
+ return buf;
+ }
+ }
+
+ return buf;
+}
+static void fontfilecache_Free(const unsigned char *buf)
+{
+ int i;
+ for(i = 0; i < MAX_FONTFILES; ++i)
+ {
+ if(fontfiles[i].refcount > 0)
+ if(fontfiles[i].buf == buf)
+ {
+ if(--fontfiles[i].refcount <= 0)
+ {
+ Mem_Free(fontfiles[i].buf);
+ fontfiles[i].buf = NULL;
+ }
+ return;
+ }
+ }
+ // if we get here, it used regular allocation
+ Mem_Free((void *) buf);
+}
+static void fontfilecache_FreeAll(void)
+{
+ int i;
+ for(i = 0; i < MAX_FONTFILES; ++i)
+ {
+ if(fontfiles[i].refcount > 0)
+ Mem_Free(fontfiles[i].buf);
+ fontfiles[i].buf = NULL;
+ fontfiles[i].refcount = 0;
+ }
+}
+
/*
====================
Font_CloseLibrary
*/
void Font_CloseLibrary (void)
{
+ fontfilecache_FreeAll();
if (font_mempool)
Mem_FreePool(&font_mempool);
- if (font_texturepool)
- R_FreeTexturePool(&font_texturepool);
if (font_ft2lib && qFT_Done_FreeType)
{
qFT_Done_FreeType(font_ft2lib);
font_ft2lib = NULL;
}
+#ifndef DP_FREETYPE_STATIC
Sys_UnloadLibrary (&ft2_dll);
+#endif
pp.buf = NULL;
}
*/
qboolean Font_OpenLibrary (void)
{
+#ifndef DP_FREETYPE_STATIC
const char* dllnames [] =
{
#if defined(WIN32)
#endif
NULL
};
+#endif
if (r_font_disable_freetype.integer)
return false;
+#ifndef DP_FREETYPE_STATIC
// Already loaded?
if (ft2_dll)
return true;
// Load the DLL
if (!Sys_LoadLibrary (dllnames, &ft2_dll, ft2funcs))
return false;
+#endif
return true;
}
Font_CloseLibrary();
return;
}
-
- font_texturepool = R_AllocTexturePool();
- if (!font_texturepool)
- {
- Con_Print("ERROR: Failed to allocate FONT texture pool!\n");
- Font_CloseLibrary();
- return;
- }
}
void font_shutdown(void)
void Font_Init(void)
{
+ Cvar_RegisterVariable(&r_font_nonpoweroftwo);
Cvar_RegisterVariable(&r_font_disable_freetype);
Cvar_RegisterVariable(&r_font_use_alpha_textures);
Cvar_RegisterVariable(&r_font_size_snapping);
Cvar_RegisterVariable(&r_font_kerning);
+ Cvar_RegisterVariable(&r_font_diskcache);
+ Cvar_RegisterVariable(&r_font_compress);
Cvar_RegisterVariable(&developer_font);
// let's open it at startup already
ft2_font_t *Font_Alloc(void)
{
+#ifndef DP_FREETYPE_STATIC
if (!ft2_dll)
+#else
+ if (r_font_disable_freetype.integer)
+#endif
return NULL;
return (ft2_font_t *)Mem_Alloc(font_mempool, sizeof(ft2_font_t));
}
-qboolean Font_Attach(ft2_font_t *font, ft2_attachment_t *attachment)
+static qboolean Font_Attach(ft2_font_t *font, ft2_attachment_t *attachment)
{
ft2_attachment_t *na;
{
int s, count, i;
ft2_font_t *ft2, *fbfont, *fb;
+ char vabuf[1024];
ft2 = Font_Alloc();
if (!ft2)
if (!Font_LoadFile(dpfnt->fallbacks[i], dpfnt->fallback_faces[i], &dpfnt->settings, fb))
{
- if(!FS_FileExists(va("%s.tga", dpfnt->fallbacks[i])))
- if(!FS_FileExists(va("%s.png", dpfnt->fallbacks[i])))
- if(!FS_FileExists(va("%s.jpg", dpfnt->fallbacks[i])))
- if(!FS_FileExists(va("%s.pcx", dpfnt->fallbacks[i])))
+ if(!FS_FileExists(va(vabuf, sizeof(vabuf), "%s.tga", dpfnt->fallbacks[i])))
+ if(!FS_FileExists(va(vabuf, sizeof(vabuf), "%s.png", dpfnt->fallbacks[i])))
+ if(!FS_FileExists(va(vabuf, sizeof(vabuf), "%s.jpg", dpfnt->fallbacks[i])))
+ if(!FS_FileExists(va(vabuf, sizeof(vabuf), "%s.pcx", dpfnt->fallbacks[i])))
Con_Printf("Failed to load font %s for fallback %i of font %s\n", dpfnt->fallbacks[i], i, name);
Mem_Free(fb);
continue;
char filename[MAX_QPATH];
int status;
size_t i;
- unsigned char *data;
+ const unsigned char *data;
fs_offset_t datasize;
memset(font, 0, sizeof(*font));
font->settings = settings;
namelen = strlen(name);
+ if (namelen + 5 > sizeof(filename))
+ {
+ Con_Printf("WARNING: too long font name. Cannot load this.\n");
+ return false;
+ }
// try load direct file
memcpy(filename, name, namelen+1);
- data = FS_LoadFile(filename, font_mempool, false, &datasize);
+ data = fontfilecache_LoadFile(filename, false, &datasize);
// try load .ttf
if (!data)
{
memcpy(filename + namelen, ".ttf", 5);
- data = FS_LoadFile(filename, font_mempool, false, &datasize);
+ data = fontfilecache_LoadFile(filename, false, &datasize);
}
// try load .otf
if (!data)
{
memcpy(filename + namelen, ".otf", 5);
- data = FS_LoadFile(filename, font_mempool, false, &datasize);
+ data = fontfilecache_LoadFile(filename, false, &datasize);
}
// try load .pfb/afm
if (!data)
ft2_attachment_t afm;
memcpy(filename + namelen, ".pfb", 5);
- data = FS_LoadFile(filename, font_mempool, false, &datasize);
+ data = fontfilecache_LoadFile(filename, false, &datasize);
if (data)
{
memcpy(filename + namelen, ".afm", 5);
- afm.data = FS_LoadFile(filename, font_mempool, false, &afm.size);
+ afm.data = fontfilecache_LoadFile(filename, false, &afm.size);
if (afm.data)
Font_Attach(font, &afm);
{
Con_Printf("Failed to load face %i of %s. Falling back to face 0\n", _face, name);
_face = 0;
- status = qFT_New_Memory_Face(font_ft2lib, (FT_Bytes)data, datasize, 0, (FT_Face*)&font->face);
+ status = qFT_New_Memory_Face(font_ft2lib, (FT_Bytes)data, datasize, _face, (FT_Face*)&font->face);
}
font->data = data;
if (status)
Con_Printf("Failed to add attachment %u to %s\n", (unsigned)i, font->name);
}
- memcpy(font->name, name, namelen+1);
+ strlcpy(font->name, name, sizeof(font->name));
font->image_font = false;
font->has_kerning = !!(((FT_Face)(font->face))->face_flags & FT_FACE_FLAG_KERNING);
return true;
}
-void Font_Postprocess_Update(ft2_font_t *fnt, int bpp, int w, int h)
+static void Font_Postprocess_Update(ft2_font_t *fnt, int bpp, int w, int h)
{
int needed, x, y;
float gausstable[2*POSTPROCESS_MAXRADIUS+1];
}
}
-void Font_Postprocess(ft2_font_t *fnt, unsigned char *imagedata, int pitch, int bpp, int w, int h, int *pad_l, int *pad_r, int *pad_t, int *pad_b)
+static void Font_Postprocess(ft2_font_t *fnt, unsigned char *imagedata, int pitch, int bpp, int w, int h, int *pad_l, int *pad_r, int *pad_t, int *pad_b)
{
int x, y;
+
+ // calculate gauss table
Font_Postprocess_Update(fnt, bpp, w, h);
+
if(imagedata)
{
// enlarge buffer
-
// perform operation, not exceeding the passed padding values,
// but possibly reducing them
*pad_l = min(*pad_l, pp.padding_l);
*pad_t = min(*pad_t, pp.padding_t);
*pad_b = min(*pad_b, pp.padding_b);
- // calculate gauss table
-
// outline the font (RGBA only)
if(bpp == 4 && (pp.outline > 0 || pp.blur > 0 || pp.shadowx != 0 || pp.shadowy != 0 || pp.shadowz != 0)) // we can only do this in BGRA
{
}
}
}
+ else if(pitch)
+ {
+ // perform operation, not exceeding the passed padding values,
+ // but possibly reducing them
+ *pad_l = min(*pad_l, pp.padding_l);
+ *pad_r = min(*pad_r, pp.padding_r);
+ *pad_t = min(*pad_t, pp.padding_t);
+ *pad_b = min(*pad_b, pp.padding_b);
+ }
else
{
// just calculate parameters
memset(&temp, 0, sizeof(temp));
temp.size = size;
- temp.glyphSize = CeilPowerOf2(size*2 + max(gpad_l + gpad_r, gpad_t + gpad_b));
+ temp.glyphSize = size*2 + max(gpad_l + gpad_r, gpad_t + gpad_b);
+ if (!r_font_nonpoweroftwo.integer)
+ temp.glyphSize = CeilPowerOf2(temp.glyphSize);
temp.sfx = (1.0/64.0)/(double)size;
temp.sfy = (1.0/64.0)/(double)size;
temp.intSize = -1; // negative value: LoadMap must search now :)
if (!maps[m])
continue;
// "round up" to the bigger size if two equally-valued matches exist
- nval = 0.5 * (abs(maps[m]->size - fsize_x) + abs(maps[m]->size - fsize_y));
+ nval = 0.5 * (fabs(maps[m]->size - fsize_x) + fabs(maps[m]->size - fsize_y));
if (match == -1 || nval < value || (nval == value && matchsize < maps[m]->size))
{
value = nval;
static void UnloadMapRec(ft2_font_map_t *map)
{
- if (map->texture)
+ if (map->pic)
{
- R_FreeTexture(map->texture);
- map->texture = NULL;
+ //Draw_FreePic(map->pic); // FIXME: refcounting needed...
+ map->pic = NULL;
}
if (map->next)
UnloadMapRec(map->next);
{
for (i = 0; i < (int)font->attachmentcount; ++i) {
if (font->attachments[i].data)
- Mem_Free(font->attachments[i].data);
+ fontfilecache_Free(font->attachments[i].data);
}
Mem_Free(font->attachments);
font->attachmentcount = 0;
font->font_maps[i] = NULL;
}
}
+#ifndef DP_FREETYPE_STATIC
if (ft2_dll)
+#else
+ if (!r_font_disable_freetype.integer)
+#endif
{
if (font->face)
{
}
}
if (font->data) {
- Mem_Free(font->data);
+ fontfilecache_Free(font->data);
font->data = NULL;
}
}
{
char map_identifier[MAX_QPATH];
unsigned long mapidx = _ch / FONT_CHARS_PER_MAP;
- unsigned char *data;
+ unsigned char *data = NULL;
FT_ULong ch, mapch;
int status;
int tp;
FT_Int32 load_flags;
int gpad_l, gpad_r, gpad_t, gpad_b;
+ char vabuf[1024];
int pitch;
int gR, gC; // glyph position: row and column
return false;
}
+ // create a totally unique name for this map, then we will use it to make a unique cachepic_t to avoid redundant textures
+ dpsnprintf(map_identifier, sizeof(map_identifier),
+ "%s_cache_%g_%d_%g_%g_%g_%g_%g_%u",
+ font->name,
+ (double) mapstart->intSize,
+ (int) load_flags,
+ (double) font->settings->blur,
+ (double) font->settings->outline,
+ (double) font->settings->shadowx,
+ (double) font->settings->shadowy,
+ (double) font->settings->shadowz,
+ (unsigned) mapidx);
+
+ // create a cachepic_t from the data now, or reuse an existing one
+ if (developer_font.integer)
+ Con_Printf("Generating font map %s (size: %.1f MB)\n", map_identifier, mapstart->glyphSize * (256 * 4 / 1048576.0) * mapstart->glyphSize);
+
Font_Postprocess(font, NULL, 0, bytesPerPixel, mapstart->size*2, mapstart->size*2, &gpad_l, &gpad_r, &gpad_t, &gpad_b);
// copy over the information
Mem_Free(map);
return false;
}
- memset(map->width_of, 0, sizeof(map->width_of));
-
// initialize as white texture with zero alpha
tp = 0;
while (tp < (FONT_CHAR_LINES * map->glyphSize) * pitch)
data[tp++] = 0x00;
}
+ memset(map->width_of, 0, sizeof(map->width_of));
+
// insert the map
map->start = mapidx * FONT_CHARS_PER_MAP;
next = mapstart;
int w, h, x, y;
FT_GlyphSlot glyph;
FT_Bitmap *bmp;
- unsigned char *imagedata, *dst, *src;
+ unsigned char *imagedata = NULL, *dst, *src;
glyph_slot_t *mapglyph;
FT_Face face;
int pad_l, pad_r, pad_t, pad_b;
++gR;
}
- imagedata = data + gR * pitch * map->glyphSize + gC * map->glyphSize * bytesPerPixel;
- imagedata += gpad_t * pitch + gpad_l * bytesPerPixel;
+ if (data)
+ {
+ imagedata = data + gR * pitch * map->glyphSize + gC * map->glyphSize * bytesPerPixel;
+ imagedata += gpad_t * pitch + gpad_l * bytesPerPixel;
+ }
//status = qFT_Load_Char(face, ch, FT_LOAD_RENDER);
// we need the glyphIndex
face = (FT_Face)font->face;
h = map->glyphSize;
}
- switch (bmp->pixel_mode)
- {
- case FT_PIXEL_MODE_MONO:
- if (developer_font.integer)
- Con_DPrint("glyphinfo: Pixel Mode: MONO\n");
- break;
- case FT_PIXEL_MODE_GRAY2:
- if (developer_font.integer)
- Con_DPrint("glyphinfo: Pixel Mode: GRAY2\n");
- break;
- case FT_PIXEL_MODE_GRAY4:
- if (developer_font.integer)
- Con_DPrint("glyphinfo: Pixel Mode: GRAY4\n");
- break;
- case FT_PIXEL_MODE_GRAY:
- if (developer_font.integer)
- Con_DPrint("glyphinfo: Pixel Mode: GRAY\n");
- break;
- default:
- if (developer_font.integer)
- Con_DPrintf("glyphinfo: Pixel Mode: Unknown: %i\n", bmp->pixel_mode);
- Mem_Free(data);
- Con_Printf("ERROR: Unrecognized pixel mode for font %s size %f: %i\n", font->name, mapstart->size, bmp->pixel_mode);
- return false;
- }
- for (y = 0; y < h; ++y)
+ if (imagedata)
{
- dst = imagedata + y * pitch;
- src = bmp->buffer + y * bmp->pitch;
-
switch (bmp->pixel_mode)
{
case FT_PIXEL_MODE_MONO:
- dst += bytesPerPixel - 1; // shift to alpha byte
- for (x = 0; x < bmp->width; x += 8)
- {
- unsigned char ch = *src++;
- *dst = 255 * !!((ch & 0x80) >> 7); dst += bytesPerPixel;
- *dst = 255 * !!((ch & 0x40) >> 6); dst += bytesPerPixel;
- *dst = 255 * !!((ch & 0x20) >> 5); dst += bytesPerPixel;
- *dst = 255 * !!((ch & 0x10) >> 4); dst += bytesPerPixel;
- *dst = 255 * !!((ch & 0x08) >> 3); dst += bytesPerPixel;
- *dst = 255 * !!((ch & 0x04) >> 2); dst += bytesPerPixel;
- *dst = 255 * !!((ch & 0x02) >> 1); dst += bytesPerPixel;
- *dst = 255 * !!((ch & 0x01) >> 0); dst += bytesPerPixel;
- }
+ if (developer_font.integer)
+ Con_DPrint("glyphinfo: Pixel Mode: MONO\n");
break;
case FT_PIXEL_MODE_GRAY2:
- dst += bytesPerPixel - 1; // shift to alpha byte
- for (x = 0; x < bmp->width; x += 4)
- {
- unsigned char ch = *src++;
- *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
- *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
- *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
- *dst = ( ((ch & 0xA0) >> 6) * 0x55 ); ch <<= 2; dst += bytesPerPixel;
- }
+ if (developer_font.integer)
+ Con_DPrint("glyphinfo: Pixel Mode: GRAY2\n");
break;
case FT_PIXEL_MODE_GRAY4:
- dst += bytesPerPixel - 1; // shift to alpha byte
- for (x = 0; x < bmp->width; x += 2)
- {
- unsigned char ch = *src++;
- *dst = ( ((ch & 0xF0) >> 4) * 0x11); dst += bytesPerPixel;
- *dst = ( ((ch & 0x0F) ) * 0x11); dst += bytesPerPixel;
- }
+ if (developer_font.integer)
+ Con_DPrint("glyphinfo: Pixel Mode: GRAY4\n");
break;
case FT_PIXEL_MODE_GRAY:
- // in this case pitch should equal width
- for (tp = 0; tp < bmp->pitch; ++tp)
- dst[(bytesPerPixel - 1) + tp*bytesPerPixel] = src[tp]; // copy the grey value into the alpha bytes
-
- //memcpy((void*)dst, (void*)src, bmp->pitch);
- //dst += bmp->pitch;
+ if (developer_font.integer)
+ Con_DPrint("glyphinfo: Pixel Mode: GRAY\n");
break;
default:
- break;
+ if (developer_font.integer)
+ Con_DPrintf("glyphinfo: Pixel Mode: Unknown: %i\n", bmp->pixel_mode);
+ Mem_Free(data);
+ Con_Printf("ERROR: Unrecognized pixel mode for font %s size %f: %i\n", font->name, mapstart->size, bmp->pixel_mode);
+ return false;
+ }
+ for (y = 0; y < h; ++y)
+ {
+ dst = imagedata + y * pitch;
+ src = bmp->buffer + y * bmp->pitch;
+
+ switch (bmp->pixel_mode)
+ {
+ case FT_PIXEL_MODE_MONO:
+ dst += bytesPerPixel - 1; // shift to alpha byte
+ for (x = 0; x < bmp->width; x += 8)
+ {
+ unsigned char c = *src++;
+ *dst = 255 * !!((c & 0x80) >> 7); dst += bytesPerPixel;
+ *dst = 255 * !!((c & 0x40) >> 6); dst += bytesPerPixel;
+ *dst = 255 * !!((c & 0x20) >> 5); dst += bytesPerPixel;
+ *dst = 255 * !!((c & 0x10) >> 4); dst += bytesPerPixel;
+ *dst = 255 * !!((c & 0x08) >> 3); dst += bytesPerPixel;
+ *dst = 255 * !!((c & 0x04) >> 2); dst += bytesPerPixel;
+ *dst = 255 * !!((c & 0x02) >> 1); dst += bytesPerPixel;
+ *dst = 255 * !!((c & 0x01) >> 0); dst += bytesPerPixel;
+ }
+ break;
+ case FT_PIXEL_MODE_GRAY2:
+ dst += bytesPerPixel - 1; // shift to alpha byte
+ for (x = 0; x < bmp->width; x += 4)
+ {
+ unsigned char c = *src++;
+ *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytesPerPixel;
+ *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytesPerPixel;
+ *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytesPerPixel;
+ *dst = ( ((c & 0xA0) >> 6) * 0x55 ); c <<= 2; dst += bytesPerPixel;
+ }
+ break;
+ case FT_PIXEL_MODE_GRAY4:
+ dst += bytesPerPixel - 1; // shift to alpha byte
+ for (x = 0; x < bmp->width; x += 2)
+ {
+ unsigned char c = *src++;
+ *dst = ( ((c & 0xF0) >> 4) * 0x11); dst += bytesPerPixel;
+ *dst = ( ((c & 0x0F) ) * 0x11); dst += bytesPerPixel;
+ }
+ break;
+ case FT_PIXEL_MODE_GRAY:
+ // in this case pitch should equal width
+ for (tp = 0; tp < bmp->pitch; ++tp)
+ dst[(bytesPerPixel - 1) + tp*bytesPerPixel] = src[tp]; // copy the grey value into the alpha bytes
+
+ //memcpy((void*)dst, (void*)src, bmp->pitch);
+ //dst += bmp->pitch;
+ break;
+ default:
+ break;
+ }
}
+
+ pad_l = gpad_l;
+ pad_r = gpad_r;
+ pad_t = gpad_t;
+ pad_b = gpad_b;
+ Font_Postprocess(font, imagedata, pitch, bytesPerPixel, w, h, &pad_l, &pad_r, &pad_t, &pad_b);
+ }
+ else
+ {
+ pad_l = gpad_l;
+ pad_r = gpad_r;
+ pad_t = gpad_t;
+ pad_b = gpad_b;
+ Font_Postprocess(font, NULL, pitch, bytesPerPixel, w, h, &pad_l, &pad_r, &pad_t, &pad_b);
}
- pad_l = gpad_l;
- pad_r = gpad_r;
- pad_t = gpad_t;
- pad_b = gpad_b;
- Font_Postprocess(font, imagedata, pitch, bytesPerPixel, w, h, &pad_l, &pad_r, &pad_t, &pad_b);
// now fill map->glyphs[ch - map->start]
mapglyph = &map->glyphs[mapch];
map->glyphs[mapch].image = false;
}
- // create a texture from the data now
-
- if (developer_font.integer > 100)
{
- // LordHavoc: why are we writing this? And why not write it as TGA using the appropriate function?
- // view using `display -depth 8 -size 512x512 name_page.rgba` (be sure to use a correct -size parameter)
- dpsnprintf(map_identifier, sizeof(map_identifier), "%s_%u.rgba", font->name, (unsigned)map->start/FONT_CHARS_PER_MAP);
- FS_WriteFile(map_identifier, data, pitch * FONT_CHAR_LINES * map->glyphSize);
- }
- dpsnprintf(map_identifier, sizeof(map_identifier), "%s_%u", font->name, (unsigned)map->start/FONT_CHARS_PER_MAP);
+ int w = map->glyphSize * FONT_CHARS_PER_LINE;
+ int h = map->glyphSize * FONT_CHAR_LINES;
+ // update the pic returned by Draw_CachePic_Flags earlier to contain our texture
+ map->pic = Draw_NewPic(map_identifier, w, h, data, r_font_use_alpha_textures.integer ? TEXTYPE_ALPHA : TEXTYPE_RGBA, TEXF_ALPHA | TEXF_CLAMP | (r_font_compress.integer > 0 ? TEXF_COMPRESS : 0));
- // probably use bytesPerPixel here instead?
- if (r_font_use_alpha_textures.integer)
- {
- map->texture = R_LoadTexture2D(font_texturepool, map_identifier,
- map->glyphSize * FONT_CHARS_PER_LINE,
- map->glyphSize * FONT_CHAR_LINES,
- data, TEXTYPE_ALPHA, TEXF_ALPHA /*gone: | TEXF_ALWAYSPRECACHE*/ /* | TEXF_MIPMAP*/, -1, NULL);
- } else {
- map->texture = R_LoadTexture2D(font_texturepool, map_identifier,
- map->glyphSize * FONT_CHARS_PER_LINE,
- map->glyphSize * FONT_CHAR_LINES,
- data, TEXTYPE_RGBA, TEXF_ALPHA /*gone: | TEXF_ALWAYSPRECACHE*/ /* | TEXF_MIPMAP*/, -1, NULL);
+ if (r_font_diskcache.integer >= 1)
+ {
+ // swap to BGRA for tga writing...
+ int s = w * h;
+ int x;
+ int b;
+ for (x = 0;x < s;x++)
+ {
+ b = data[x*4+0];
+ data[x*4+0] = data[x*4+2];
+ data[x*4+2] = b;
+ }
+ Image_WriteTGABGRA(va(vabuf, sizeof(vabuf), "%s.tga", map_identifier), w, h, data);
+#ifndef USE_GLES2
+ if (r_font_compress.integer && Draw_IsPicLoaded(map->pic))
+ R_SaveTextureDDSFile(Draw_GetPicTexture(map->pic), va(vabuf, sizeof(vabuf), "dds/%s.dds", map_identifier), r_texture_dds_save.integer < 2, true);
+#endif
+ }
}
- Mem_Free(data);
- if (!map->texture)
+ if(data)
+ Mem_Free(data);
+
+ if (!Draw_IsPicLoaded(map->pic))
{
// if the first try isn't successful, keep it with a broken texture
// otherwise we retry to load it every single frame where ft2 rendering is used
projects / xonotic / darkplaces.git / blobdiff