Quake III Arena: code/renderer/tr

00328                                                                             {
00329 #ifdef BUILD_FREETYPE
00330   FT_Face face;
00331   int j, k, xOut, yOut, lastStart, imageNumber;
00332   int scaledSize, newSize, maxHeight, left, satLevels;
00333   unsigned char *out, *imageBuff;
00334   glyphInfo_t *glyph;
00335   image_t *image;
00336   qhandle_t h;
00337     float max;
00338 #endif
00339   void *faceData;
00340     int i, len;
00341   char name[1024];
00342     float dpi = 72;                                         //
00343     float glyphScale =  72.0f / dpi;        // change the scale to be relative to 1 based on 72 dpi ( so dpi of 144 means a scale of .5 )
00344 
00345     if (pointSize <= 0) {
00346         pointSize = 12;
00347     }
00348     // we also need to adjust the scale based on point size relative to 48 points as the ui scaling is based on a 48 point font
00349     glyphScale *= 48.0f / pointSize;
00350 
00351     // make sure the render thread is stopped
00352     R_SyncRenderThread();
00353 
00354   if (registeredFontCount >= MAX_FONTS) {
00355     ri.Printf(PRINT_ALL, "RE_RegisterFont: Too many fonts registered already.\n");
00356     return;
00357   }
00358 
00359     Com_sprintf(name, sizeof(name), "fonts/fontImage_%i.dat",pointSize);
00360     for (i = 0; i < registeredFontCount; i++) {
00361         if (Q_stricmp(name, registeredFont[i].name) == 0) {
00362             Com_Memcpy(font, &registeredFont[i], sizeof(fontInfo_t));
00363             return;
00364         }
00365     }
00366 
00367     len = ri.FS_ReadFile(name, NULL);
00368     if (len == sizeof(fontInfo_t)) {
00369         ri.FS_ReadFile(name, &faceData);
00370         fdOffset = 0;
00371         fdFile = faceData;
00372         for(i=0; i<GLYPHS_PER_FONT; i++) {
00373             font->glyphs[i].height      = readInt();
00374             font->glyphs[i].top         = readInt();
00375             font->glyphs[i].bottom      = readInt();
00376             font->glyphs[i].pitch       = readInt();
00377             font->glyphs[i].xSkip       = readInt();
00378             font->glyphs[i].imageWidth  = readInt();
00379             font->glyphs[i].imageHeight = readInt();
00380             font->glyphs[i].s           = readFloat();
00381             font->glyphs[i].t           = readFloat();
00382             font->glyphs[i].s2          = readFloat();
00383             font->glyphs[i].t2          = readFloat();
00384             font->glyphs[i].glyph       = readInt();
00385             Com_Memcpy(font->glyphs[i].shaderName, &fdFile[fdOffset], 32);
00386             fdOffset += 32;
00387         }
00388         font->glyphScale = readFloat();
00389         Com_Memcpy(font->name, &fdFile[fdOffset], MAX_QPATH);
00390 
00391 //      Com_Memcpy(font, faceData, sizeof(fontInfo_t));
00392         Q_strncpyz(font->name, name, sizeof(font->name));
00393         for (i = GLYPH_START; i < GLYPH_END; i++) {
00394             font->glyphs[i].glyph = RE_RegisterShaderNoMip(font->glyphs[i].shaderName);
00395         }
00396       Com_Memcpy(&registeredFont[registeredFontCount++], font, sizeof(fontInfo_t));
00397         return;
00398     }
00399 
00400 #ifndef BUILD_FREETYPE
00401     ri.Printf(PRINT_ALL, "RE_RegisterFont: FreeType code not available\n");
00402 #else
00403   if (ftLibrary == NULL) {
00404     ri.Printf(PRINT_ALL, "RE_RegisterFont: FreeType not initialized.\n");
00405     return;
00406   }
00407 
00408   len = ri.FS_ReadFile(fontName, &faceData);
00409   if (len <= 0) {
00410     ri.Printf(PRINT_ALL, "RE_RegisterFont: Unable to read font file\n");
00411     return;
00412   }
00413 
00414   // allocate on the stack first in case we fail
00415   if (FT_New_Memory_Face( ftLibrary, faceData, len, 0, &face )) {
00416     ri.Printf(PRINT_ALL, "RE_RegisterFont: FreeType2, unable to allocate new face.\n");
00417     return;
00418   }
00419 
00420 
00421   if (FT_Set_Char_Size( face, pointSize << 6, pointSize << 6, dpi, dpi)) {
00422     ri.Printf(PRINT_ALL, "RE_RegisterFont: FreeType2, Unable to set face char size.\n");
00423     return;
00424   }
00425 
00426   //*font = &registeredFonts[registeredFontCount++];
00427 
00428   // make a 256x256 image buffer, once it is full, register it, clean it and keep going 
00429   // until all glyphs are rendered
00430 
00431   out = Z_Malloc(1024*1024);
00432   if (out == NULL) {
00433     ri.Printf(PRINT_ALL, "RE_RegisterFont: Z_Malloc failure during output image creation.\n");
00434     return;
00435   }
00436   Com_Memset(out, 0, 1024*1024);
00437 
00438   maxHeight = 0;
00439 
00440   for (i = GLYPH_START; i < GLYPH_END; i++) {
00441     glyph = RE_ConstructGlyphInfo(out, &xOut, &yOut, &maxHeight, face, (unsigned char)i, qtrue);
00442   }
00443 
00444   xOut = 0;
00445   yOut = 0;
00446   i = GLYPH_START;
00447   lastStart = i;
00448   imageNumber = 0;
00449 
00450   while ( i <= GLYPH_END ) {
00451 
00452     glyph = RE_ConstructGlyphInfo(out, &xOut, &yOut, &maxHeight, face, (unsigned char)i, qfalse);
00453 
00454     if (xOut == -1 || yOut == -1 || i == GLYPH_END)  {
00455       // ran out of room
00456       // we need to create an image from the bitmap, set all the handles in the glyphs to this point
00457       // 
00458 
00459       scaledSize = 256*256;
00460       newSize = scaledSize * 4;
00461       imageBuff = Z_Malloc(newSize);
00462       left = 0;
00463       max = 0;
00464       satLevels = 255;
00465       for ( k = 0; k < (scaledSize) ; k++ ) {
00466         if (max < out[k]) {
00467           max = out[k];
00468         }
00469       }
00470 
00471             if (max > 0) {
00472                 max = 255/max;
00473             }
00474 
00475       for ( k = 0; k < (scaledSize) ; k++ ) {
00476         imageBuff[left++] = 255;
00477         imageBuff[left++] = 255;
00478         imageBuff[left++] = 255;
00479 
00480         imageBuff[left++] = ((float)out[k] * max);
00481       }
00482 
00483             Com_sprintf (name, sizeof(name), "fonts/fontImage_%i_%i.tga", imageNumber++, pointSize);
00484             if (r_saveFontData->integer) { 
00485               WriteTGA(name, imageBuff, 256, 256);
00486             }
00487 
00488         //Com_sprintf (name, sizeof(name), "fonts/fontImage_%i_%i", imageNumber++, pointSize);
00489       image = R_CreateImage(name, imageBuff, 256, 256, qfalse, qfalse, GL_CLAMP);
00490       h = RE_RegisterShaderFromImage(name, LIGHTMAP_2D, image, qfalse);
00491       for (j = lastStart; j < i; j++) {
00492         font->glyphs[j].glyph = h;
00493                 Q_strncpyz(font->glyphs[j].shaderName, name, sizeof(font->glyphs[j].shaderName));
00494       }
00495       lastStart = i;
00496           Com_Memset(out, 0, 1024*1024);
00497       xOut = 0;
00498       yOut = 0;
00499       Z_Free(imageBuff);
00500             i++;
00501     } else {
00502       Com_Memcpy(&font->glyphs[i], glyph, sizeof(glyphInfo_t));
00503       i++;
00504     }
00505   }
00506 
00507     registeredFont[registeredFontCount].glyphScale = glyphScale;
00508     font->glyphScale = glyphScale;
00509   Com_Memcpy(&registeredFont[registeredFontCount++], font, sizeof(fontInfo_t));
00510 
00511     if (r_saveFontData->integer) { 
00512         ri.FS_WriteFile(va("fonts/fontImage_%i.dat", pointSize), font, sizeof(fontInfo_t));
00513     }
00514 
00515   Z_Free(out);
00516   
00517   ri.FS_FreeFile(faceData);
00518 #endif
00519 }

Data Structures
union	poor
Defines
#define	MAX_FONTS 6
Functions
void	R_DoneFreeType ()
void	R_InitFreeType ()
void	RE_RegisterFont (const char fontName, int pointSize, fontInfo_t font)
float	readFloat ()
int	readInt ()
Variables
byte *	fdFile
int	fdOffset
fontInfo_t	registeredFont [MAX_FONTS]
int	registeredFontCount = 0
tr_font.c File Reference

Data Structures

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation
