Rooba
/
boinc
mirror of https://github.com/BOINC/boinc.git
1
0
Fork 0
Code Issues 1 Packages Projects Releases Wiki Activity
boinc/api/texfont.C

613 lines
15 KiB
C
Raw Blame History

// Copyright (c) Mark J. Kilgard, 1997.
// This program is freely distributable without licensing fees and is
// provided without guarantee or warrantee expressed or implied.
// This program is -not- in the public domain.
#if defined(_WIN32)
#pragma warning (disable:4244) // disable bogus conversion warnings
#endif
#include <assert.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef _WIN32
#include <windows.h>
#endif
#ifdef _WIN32
#include <GL/gl.h>
#endif
#ifdef __APPLE_CC__
#include <OpenGL/gl.h>
#endif
#include "texfont.h"
const char *font_names [] =
{
"Helvetica.txf", // 0. This is the default
"Helvetica-Bold.txf", // 1
"Helvetica-Oblique.txf", // 2
"Helvetica-BoldOblique.txf", // 3
"AvantGarde-Book.txf", // 4
"AvantGarde-BookOblique.txf", // 5
"AvantGarde-Demi.txf", // 6
"AvantGarde-DemiOblique.txf", // 7
"Bookman-Light.txf", // 8
"Bookman-LightItalic.txf", // 9
"Bookman-Demi.txf", // 10
"Bookman-DemiItalic.txf", // 11
"Courier.txf", // 12
"Courier-Bold.txf", // 13
"Courier-Oblique.txf", // 14
"Courier-BoldOblique.txf", // 15
"NewCenturySchlbk-Roman.txf", // 16
"NewCenturySchlbk-Italic.txf", // 17
"NewCenturySchlbk-Bold.txf", // 18
"NewCenturySchlbk-BoldItalic.txf", // 19
"Palatino-Roman.txf", // 20
"Palatino-Italic.txf", // 21
"Palatino-Bold.txf", // 22
"Palatino-BoldItalic.txf", // 23
"Times-Roman.txf", // 24
"Times-Italic.txf", // 25
"Times-Bold.txf", // 26
"Times-BoldItalic.txf", // 27
"ZapfChancery-MediumItalic.txf", // 28
NULL
} ;
#if 1
// Uncomment to debug various scenarios.
#undef GL_VERSION_1_1
#undef GL_EXT_texture_object
#undef GL_EXT_texture
#endif
#ifndef GL_VERSION_1_1
# if defined(GL_EXT_texture_object)
# define glGenTextures glGenTexturesEXT
# define glBindTexture glBindTextureEXT
# else
// Without OpenGL 1.1 or the texture object extension, use display lists.
# define USE_DISPLAY_LISTS
# endif
# if defined(GL_EXT_texture)
# define GL_INTENSITY4 GL_INTENSITY4_EXT
int useLuminanceAlpha = 0;
# else
// Intensity texture format not in OpenGL 1.0; added by the EXT_texture
// extension and now part of OpenGL 1.1.
int useLuminanceAlpha = 1;
# endif
#else
// OpenGL 1.1 case.
int useLuminanceAlpha = 0;
#endif
// byte swap a 32-bit value
#define SWAPL(x, n) { \
n = ((char *) (x))[0];\
((char *) (x))[0] = ((char *) (x))[3];\
((char *) (x))[3] = n;\
n = ((char *) (x))[1];\
((char *) (x))[1] = ((char *) (x))[2];\
((char *) (x))[2] = n; }
// byte swap a short
#define SWAPS(x, n) { \
n = ((char *) (x))[0];\
((char *) (x))[0] = ((char *) (x))[1];\
((char *) (x))[1] = n; }
static TexGlyphVertexInfo * getTCVI(TexFont * txf, int c){
TexGlyphVertexInfo *tgvi;
// Automatically substitute uppercase letters with lowercase if not
// uppercase available (and vice versa).
if ((c >= txf->min_glyph) && (c < txf->min_glyph + txf->range)) {
tgvi = txf->lut[c - txf->min_glyph];
if (tgvi) {
return tgvi;
}
if (islower(c)) {
c = toupper(c);
if ((c >= txf->min_glyph) && (c < txf->min_glyph + txf->range)) {
return txf->lut[c - txf->min_glyph];
}
}
if (isupper(c)) {
c = tolower(c);
if ((c >= txf->min_glyph) && (c < txf->min_glyph + txf->range)) {
return txf->lut[c - txf->min_glyph];
}
}
}
fprintf(stderr, "texfont: tried to access unavailable font character \"%c\" (%d)\n",isprint(c) ? c : ' ', c);
abort();
// NOT REACHED
return NULL;
}
static char *lastError;
char * txfErrorString(void) {
return lastError;
}
TexFont * txfLoadFont(const char *filename) {
TexFont *txf;
FILE *file;
GLfloat w, h, xstep, ystep;
char fileid[4], tmp;
unsigned char *texbitmap;
int min_glyph, max_glyph;
int endianness, swap, format, stride, width, height;
int i, j;
unsigned long got;
txf = NULL;
file = fopen(filename, "rb");
if (file == NULL) {
lastError = "file open failed.";
goto error;
}
txf = (TexFont *) malloc(sizeof(TexFont));
if (txf == NULL) {
lastError = "out of memory.";
goto error;
}
// For easy cleanup in error case.
txf->tgi = NULL;
txf->tgvi = NULL;
txf->lut = NULL;
txf->teximage = NULL;
got = fread(fileid, 1, 4, file);
if (got != 4 || strncmp(fileid, "\377txf", 4)) {
lastError = "not a texture font file.";
goto error;
}
// CONSTANT CONDITION
assert(sizeof(int) == 4); // Ensure external file format size.
got = fread(&endianness, sizeof(int), 1, file);
if (got == 1 && endianness == 0x12345678) {
swap = 0;
} else if (got == 1 && endianness == 0x78563412) {
swap = 1;
} else {
lastError = "not a texture font file.";
goto error;
}
#define EXPECT(n) if (got != (unsigned long) n) { lastError = "premature end of file."; goto error; }
got = fread(&format, sizeof(int), 1, file);
EXPECT(1);
got = fread(&txf->tex_width, sizeof(int), 1, file);
EXPECT(1);
got = fread(&txf->tex_height, sizeof(int), 1, file);
EXPECT(1);
got = fread(&txf->max_ascent, sizeof(int), 1, file);
EXPECT(1);
got = fread(&txf->max_descent, sizeof(int),1, file);
EXPECT(1);
got = fread(&txf->num_glyphs, sizeof(int), 1, file);
EXPECT(1);
if (swap) {
SWAPL(&format, tmp);
SWAPL(&txf->tex_width, tmp);
SWAPL(&txf->tex_height, tmp);
SWAPL(&txf->max_ascent, tmp);
SWAPL(&txf->max_descent,tmp);
SWAPL(&txf->num_glyphs, tmp);
}
txf->tgi = (TexGlyphInfo *) malloc(txf->num_glyphs * sizeof(TexGlyphInfo));
if (txf->tgi == NULL) {
lastError = "out of memory.";
goto error;
}
// CONSTANT CONDITION
assert(sizeof(TexGlyphInfo) == 12); // Ensure external file format size.
got = fread(txf->tgi, sizeof(TexGlyphInfo), txf->num_glyphs, file);
EXPECT(txf->num_glyphs);
if (swap) {
for (i = 0; i < txf->num_glyphs; i++) {
SWAPS(&txf->tgi[i].c, tmp);
SWAPS(&txf->tgi[i].x, tmp);
SWAPS(&txf->tgi[i].y, tmp);
}
}
txf->tgvi = (TexGlyphVertexInfo *)
malloc(txf->num_glyphs * sizeof(TexGlyphVertexInfo));
if (txf->tgvi == NULL) {
lastError = "out of memory.";
goto error;
}
w = txf->tex_width;
h = txf->tex_height;
xstep = 0.5 / w;
ystep = 0.5 / h;
for (i = 0; i < txf->num_glyphs; i++) {
TexGlyphInfo *tgi;
tgi = &txf->tgi[i];
txf->tgvi[i].t0[0] = tgi->x / w + xstep;
txf->tgvi[i].t0[1] = tgi->y / h + ystep;
txf->tgvi[i].v0[0] = tgi->xoffset;
txf->tgvi[i].v0[1] = tgi->yoffset;
txf->tgvi[i].t1[0] = (tgi->x + tgi->width) / w + xstep;
txf->tgvi[i].t1[1] = tgi->y / h + ystep;
txf->tgvi[i].v1[0] = tgi->xoffset + tgi->width;
txf->tgvi[i].v1[1] = tgi->yoffset;
txf->tgvi[i].t2[0] = (tgi->x + tgi->width) / w + xstep;
txf->tgvi[i].t2[1] = (tgi->y + tgi->height) / h + ystep;
txf->tgvi[i].v2[0] = tgi->xoffset + tgi->width;
txf->tgvi[i].v2[1] = tgi->yoffset + tgi->height;
txf->tgvi[i].t3[0] = tgi->x / w + xstep;
txf->tgvi[i].t3[1] = (tgi->y + tgi->height) / h + ystep;
txf->tgvi[i].v3[0] = tgi->xoffset;
txf->tgvi[i].v3[1] = tgi->yoffset + tgi->height;
txf->tgvi[i].advance = tgi->advance;
}
min_glyph = txf->tgi[0].c;
max_glyph = txf->tgi[0].c;
for (i = 1; i < txf->num_glyphs; i++) {
if (txf->tgi[i].c < min_glyph) {
min_glyph = txf->tgi[i].c;
}
if (txf->tgi[i].c > max_glyph) {
max_glyph = txf->tgi[i].c;
}
}
txf->min_glyph = min_glyph;
txf->range = max_glyph - min_glyph + 1;
txf->lut = (TexGlyphVertexInfo **)
calloc(txf->range, sizeof(TexGlyphVertexInfo *));
if (txf->lut == NULL) {
lastError = "out of memory.";
goto error;
}
for (i = 0; i < txf->num_glyphs; i++) {
txf->lut[txf->tgi[i].c - txf->min_glyph] = &txf->tgvi[i];
}
switch (format) {
case TXF_FORMAT_BYTE:
if (useLuminanceAlpha) {
unsigned char *orig;
orig = (unsigned char *) malloc(txf->tex_width * txf->tex_height);
if (orig == NULL) {
lastError = "out of memory.";
goto error;
}
got = fread(orig, 1, txf->tex_width * txf->tex_height, file);
EXPECT(txf->tex_width * txf->tex_height);
txf->teximage = (unsigned char *)
malloc(2 * txf->tex_width * txf->tex_height);
if (txf->teximage == NULL) {
lastError = "out of memory.";
goto error;
}
for (i = 0; i < txf->tex_width * txf->tex_height; i++) {
txf->teximage[i * 2] = orig[i];
txf->teximage[i * 2 + 1] = orig[i];
}
free(orig);
}
else {
txf->teximage = (unsigned char *)
malloc(txf->tex_width * txf->tex_height);
if (txf->teximage == NULL) {
lastError = "out of memory.";
goto error;
}
got = fread(txf->teximage, 1, txf->tex_width * txf->tex_height, file);
EXPECT(txf->tex_width * txf->tex_height);
}
break;
case TXF_FORMAT_BITMAP:
width = txf->tex_width;
height = txf->tex_height;
stride = (width + 7) >> 3;
texbitmap = (unsigned char *) malloc(stride * height);
if (texbitmap == NULL) {
lastError = "out of memory.";
goto error;
}
got = fread(texbitmap, 1, stride * height, file);
EXPECT(stride * height);
if (useLuminanceAlpha) {
txf->teximage = (unsigned char *) calloc(width * height * 2, 1);
if (txf->teximage == NULL) {
lastError = "out of memory.";
goto error;
}
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
if (texbitmap[i * stride + (j >> 3)] & (1 << (j & 7))) {
txf->teximage[(i * width + j) * 2] = 255;
txf->teximage[(i * width + j) * 2 + 1] = 255;
}
}
}
}
else {
txf->teximage = (unsigned char *) calloc(width * height, 1);
if (txf->teximage == NULL) {
lastError = "out of memory.";
goto error;
}
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) {
if (texbitmap[i * stride + (j >> 3)] & (1 << (j & 7))) {
txf->teximage[i * width + j] = 255;
}
}
}
}
free(texbitmap);
break;
}
fclose(file);
return txf;
error:
if (txf) {
if (txf->tgi) free(txf->tgi);
if (txf->tgvi)free(txf->tgvi);
if (txf->lut) free(txf->lut);
if (txf->teximage) free(txf->teximage);
free(txf);
}
if (file) fclose(file);
return NULL;
}
GLuint CreateTexFont(TexFont * txf,GLuint texobj, GLboolean setupMipmaps){
glGenTextures(1, &txf->texobj);
glBindTexture(GL_TEXTURE_2D, txf->texobj);
#if 1
// XXX Indigo2 IMPACT in IRIX 5.3 and 6.2 does not support the GL_INTENSITY
// internal texture format. Sigh. Win32 non-GLX users should disable this code.
if (useLuminanceAlpha == 0) {
char *vendor, *renderer, *version;
renderer = (char *) glGetString(GL_RENDERER);
vendor = (char *) glGetString(GL_VENDOR);
if (!strcmp(vendor, "SGI") && !strncmp(renderer, "IMPACT", 6)) {
version = (char *) glGetString(GL_VERSION);
if (!strcmp(version, "1.0 Irix 6.2") || !strcmp(version, "1.0 Irix 5.3")) {
unsigned char *latex;
int width = txf->tex_width;
int height = txf->tex_height;
int i;
useLuminanceAlpha = 1;
latex = (unsigned char *) calloc(width * height * 2, 1);
// XXX unprotected alloc.
for (i = 0; i < height * width; i++) {
latex[i * 2] = txf->teximage[i];
latex[i * 2 + 1] = txf->teximage[i];
}
free(txf->teximage);
txf->teximage = latex;
}
}
}
#endif
if (useLuminanceAlpha) {
if (setupMipmaps) {
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_LUMINANCE_ALPHA,
txf->tex_width, txf->tex_height,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, txf->teximage);
}
else {
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
txf->tex_width, txf->tex_height, 0,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, txf->teximage);
}
}
else {
#if defined(GL_VERSION_1_1) || defined(GL_EXT_texture)
// Use GL_INTENSITY4 as internal texture format since we want to use as
// little texture memory as possible.
if (setupMipmaps) {
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_INTENSITY4,
txf->tex_width, txf->tex_height,
GL_LUMINANCE, GL_UNSIGNED_BYTE, txf->teximage);
}
else {
glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY4,
txf->tex_width, txf->tex_height, 0,
GL_LUMINANCE, GL_UNSIGNED_BYTE, txf->teximage);
}
#endif
}
return txf->texobj;
}
void txfUnloadFont(TexFont * txf){
if (txf->teximage) {
free(txf->teximage);
}
free(txf->tgi);
free(txf->tgvi);
free(txf->lut);
free(txf);
}
void txfGetStringMetrics(
TexFont * txf,
char *string,
int len,
int *width,
int *max_ascent,
int *max_descent){
TexGlyphVertexInfo *tgvi;
int w, i;
w = 0;
for (i = 0; i < len; i++) {
if (string[i] == 27) {
switch (string[i + 1]) {
case 'M': i += 4; break;
case 'T': i += 7; break;
case 'L': i += 7; break;
case 'F': i += 13;break;
}
}
else {
tgvi = getTCVI(txf, string[i]);
w += (int)tgvi->advance;
}
}
*width = w;
*max_ascent = txf->max_ascent;
*max_descent = txf->max_descent;
}
void txfRenderGlyph(TexFont * txf, int c){
TexGlyphVertexInfo *tgvi;
tgvi = getTCVI(txf, c);
glBegin(GL_QUADS);
glTexCoord2fv(tgvi->t0);
glVertex2sv(tgvi->v0);
glTexCoord2fv(tgvi->t1);
glVertex2sv(tgvi->v1);
glTexCoord2fv(tgvi->t2);
glVertex2sv(tgvi->v2);
glTexCoord2fv(tgvi->t3);
glVertex2sv(tgvi->v3);
glEnd();
glTranslatef(tgvi->advance, 0.0, 0.0);
}
void txfRenderString(TexFont * txf, char *string, int len){
int i;
for (i = 0; i < len; i++) {
txfRenderGlyph(txf, string[i]);
}
}
enum {
MONO, TOP_BOTTOM, LEFT_RIGHT, FOUR
};
void txfRenderFancyString( TexFont * txf, char *string, int len){
TexGlyphVertexInfo *tgvi;
GLubyte c[4][3];
int mode = MONO;
int i;
for (i = 0; i < len; i++) {
if (string[i] == 27) {
switch (string[i + 1]) {
case 'M':
mode = MONO;
glColor3ubv((GLubyte *) & string[i + 2]);
i += 4;
break;
case 'T':
mode = TOP_BOTTOM;
memcpy(c, &string[i + 2], 6);
i += 7;
break;
case 'L':
mode = LEFT_RIGHT;
memcpy(c, &string[i + 2], 6);
i += 7;
break;
case 'F':
mode = FOUR;
memcpy(c, &string[i + 2], 12);
i += 13;
break;
}
}
else {
switch (mode) {
case MONO:
txfRenderGlyph(txf, string[i]);
break;
case TOP_BOTTOM:
tgvi = getTCVI(txf, string[i]);
glBegin(GL_QUADS);
glColor3ubv(c[0]);
glTexCoord2fv(tgvi->t0);
glVertex2sv(tgvi->v0);
glTexCoord2fv(tgvi->t1);
glVertex2sv(tgvi->v1);
glColor3ubv(c[1]);
glTexCoord2fv(tgvi->t2);
glVertex2sv(tgvi->v2);
glTexCoord2fv(tgvi->t3);
glVertex2sv(tgvi->v3);
glEnd();
glTranslatef(tgvi->advance, 0.0, 0.0);
break;
case LEFT_RIGHT:
tgvi = getTCVI(txf, string[i]);
glBegin(GL_QUADS);
glColor3ubv(c[0]);
glTexCoord2fv(tgvi->t0);
glVertex2sv(tgvi->v0);
glColor3ubv(c[1]);
glTexCoord2fv(tgvi->t1);
glVertex2sv(tgvi->v1);
glColor3ubv(c[1]);
glTexCoord2fv(tgvi->t2);
glVertex2sv(tgvi->v2);
glColor3ubv(c[0]);
glTexCoord2fv(tgvi->t3);
glVertex2sv(tgvi->v3);
glEnd();
glTranslatef(tgvi->advance, 0.0, 0.0);
break;
case FOUR:
tgvi = getTCVI(txf, string[i]);
glBegin(GL_QUADS);
glColor3ubv(c[0]);
glTexCoord2fv(tgvi->t0);
glVertex2sv(tgvi->v0);
glColor3ubv(c[1]);
glTexCoord2fv(tgvi->t1);
glVertex2sv(tgvi->v1);
glColor3ubv(c[2]);
glTexCoord2fv(tgvi->t2);
glVertex2sv(tgvi->v2);
glColor3ubv(c[3]);
glTexCoord2fv(tgvi->t3);
glVertex2sv(tgvi->v3);
glEnd();
glTranslatef(tgvi->advance, 0.0, 0.0);
break;
}
}
}
}
int txfInFont(TexFont * txf, int c) {
// NOTE: No uppercase/lowercase substituion.
if ((c >= txf->min_glyph) && (c < txf->min_glyph + txf->range)) {
if (txf->lut[c - txf->min_glyph]) {
return 1;
}
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink