void iV_SetFont(enum iV_fonts FontID)
{
switch (FontID)
{
case font_scaled:
iV_SetTextSize(12.f * pie_GetVideoBufferHeight() / 480);
glcFont(_glcFont_Regular);
break;
default:
case font_regular:
iV_SetTextSize(12.f);
glcFont(_glcFont_Regular);
break;
case font_large:
iV_SetTextSize(21.f);
glcFont(_glcFont_Bold);
break;
case font_medium:
iV_SetTextSize(16.f);
glcFont(_glcFont_Regular);
break;
case font_small:
iV_SetTextSize(9.f);
glcFont(_glcFont_Regular);
break;
}
}
// Set up and initialize GLC
void testApp::setupQuesoGlc()
{
ofSetVerticalSync(true);
//ofSetFrameRate(60);
//ofEnableAlphaBlending();
//ofEnableSmoothing();
//ofBackground(0, 0, 0);
ctx = glcGenContext();
glcContext(ctx);
// glcAppendCatalog(ofToDataPath("font").c_str());
glcAppendCatalog("/System/Library/Fonts");
font = glcGenFontID();
glcNewFontFromFamily(font, "Hiragino Mincho ProN");
glcFontFace(font, "W6");
glcFont(font);
glcRenderStyle(GLC_TEXTURE);
glcEnable(GLC_GL_OBJECTS);
glcEnable(GLC_MIPMAP);
glcEnable(GLC_HINTING_QSO);
glcStringType(GLC_UTF8_QSO);
}
int main(int argc, char **argv)
{
GLint ctx = 0;
GLint myFont = 0;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(640, 180);
glutCreateWindow("Test14");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glEnable(GL_TEXTURE_2D);
/* Set up and initialize GLC */
ctx = glcGenContext();
glcContext(ctx);
/* Create a font "Palatino Bold" */
myFont = glcGenFontID();
#ifdef __WIN32__
glcNewFontFromFamily(myFont, "Arial");
#else
glcNewFontFromFamily(myFont, "DejaVu Sans");
#endif
glcFont(myFont);
glcRenderStyle(GLC_TEXTURE);
glcDisable(GLC_GL_OBJECTS);
glutMainLoop();
return 0;
}
void
display(void)
{
#if 0
int len, i;
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glRotatef(angle, 0.0, 0.0, 1.0);
glTranslatef(-750, 0, 0);
len = (int) strlen(message);
for (i = 0; i < len; i++) {
glutStrokeCharacter(font, message[i]);
}
glPopMatrix();
#else
glPushMatrix();
glClear(GL_COLOR_BUFFER_BIT);
glcRotate(angle);
glRasterPos2f(100, 100);
glcFont(font);
glcRenderString(message);
glPopMatrix();
#endif
glutSwapBuffers();
}
int main(int argc, char **argv)
{
GLint ctx = 0;
GLint myFont = 0;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(640, 230);
glutCreateWindow("Tutorial 2");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
/* Set up and initialize GLC */
ctx = glcGenContext();
glcContext(ctx);
glcAppendCatalog("/usr/lib/X11/fonts/Type1");
/* Create a font "Palatino Bold" */
myFont = glcGenFontID();
#ifdef __WIN32__
glcNewFontFromFamily(myFont, "Palatino Linotype");
#else
glcNewFontFromFamily(myFont, "Palatino");
#endif
glcFontFace(myFont, "Bold");
glcFont(myFont);
/* Render the text at a size of 100 points */
glcScale(100.f, 100.f);
glcRotate(10.f);
glutMainLoop();
return 0;
}
int
main(int argc, char **argv)
{
int submenu;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(600, 600);
glutCreateWindow("GLC font library demo");
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, 2000, 0, 2000);
glMatrixMode(GL_MODELVIEW);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glLineWidth(3.0);
glTranslatef(1000, 1000, 0);
glClearColor(0.0, 0.0, 0.0, 1.0);
glColor3f(1.0, 1.0, 1.0);
glutDisplayFunc(display);
glutIdleFunc(tick);
submenu = glutCreateMenu(selectMessage);
glutAddMenuEntry("abc", 1);
glutAddMenuEntry("ABC", 2);
glutCreateMenu(selectFont);
#ifdef __WIN32__
glutAddMenuEntry("Arial", 1);
glutAddMenuEntry("Courier New", 2);
glutAddMenuEntry("Times New Roman", 3);
#else
glutAddMenuEntry("Helvetica", 1);
glutAddMenuEntry("Courier", 2);
glutAddMenuEntry("Times", 3);
#endif
glutAddSubMenu("Messages", submenu);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glcContext(glcGenContext());
glcScale(30, 30);
#ifdef __WIN32__
glcNewFontFromFamily(1, "Arial");
glcNewFontFromFamily(2, "Courier New");
glcNewFontFromFamily(3, "Times New Roman");
#else
glcNewFontFromFamily(1, "Helvetica");
glcNewFontFromFamily(2, "Courier");
glcNewFontFromFamily(3, "Times");
#endif
glcFont(font);
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
void RenderPrint (int x, int y, int font, GLrgba color, const char *fmt, ...)
{
char text[MAX_TEXT];
va_list ap;
text[0] = 0;
if (fmt == NULL) return;
va_start(ap, fmt);
vsprintf(text, fmt, ap);
va_end(ap);
for (; fonts[font % FONT_COUNT].id == 0; ++font);
glcFont(fonts[font % FONT_COUNT].id);
glColor3fv (&color.red);
glRasterPos2i (x, y);
glcRenderString(text);
}
static void
access_font()
{
/* This routine contains all the necessary steps to setup a */
/* font master and a face. Subsequent glcRenderChar() and */
/* glcRenderString() calls will draw the characters in the */
/* specified font/face. */
static GLboolean have_context = GL_FALSE;
GLint glc_context;
GLint master_count;
#ifdef _WIN32_
const char* master_name = "Times New Roman";
#else
const char* master_name = "Times";
#endif
GLint master;
GLint face_count;
const char* face_name = "Bold";
static GLint glc_font_id;
GLint result;
unsigned int i, j;
if (have_context == GL_FALSE) {
/* Only get a context once. */
/* When using SGI's implementation of GLC, don't call glcGetError() */
/* after this glcGenContext() call because it always returns */
/* GLC_STATE_ERROR. That's probably a bug in SGI's GLC. This behavior */
/* doesn't occur in QuesoGLC. */
/* So, in order to let glclogo run with both implementations, just */
/* validate the context. If it's OK, then go for it. */
glc_context = glcGenContext();
if (!glcIsContext(glc_context)) {
fprintf(stderr, "Error - glcGenContext() failed. Exiting.\n");
exit(-1);
}
else {
/* Context is valid. Make it the current context. */
glcContext(glc_context);
check_glc_error("glcContext()");
have_context = GL_TRUE;
/* Get a unique font ID. */
glc_font_id = glcGenFontID();
/* Choose a master and a face. */
master_count = glcGeti(GLC_MASTER_COUNT);
master = 0;
for (i = 0; i < master_count; i++) {
if (!strcmp((const char*)glcGetMasterc(i, GLC_FAMILY),
master_name)) {
face_count = glcGetMasteri(i, GLC_FACE_COUNT);
for (j = 0; j < face_count; j++) {
if (!strcmp((const char*)glcGetMasterListc(i, GLC_FACE_LIST, j), face_name)) {
master = i;
}
}
}
}
/* Access the font family. */
result = glcNewFontFromFamily(glc_font_id,
glcGetMasterc(master, GLC_FAMILY));
check_glc_error("glcNewFontFromFamily()");
if (result != glc_font_id) {
fprintf(stderr, "Error - glcNewFontFromFamily() failed. Exiting.\n");
exit(-1);
}
else {
/* Use the font. */
glcFont(glc_font_id);
check_glc_error("glcFont()");
/* Use the face. */
glcFontFace(glc_font_id, face_name);
check_glc_error("glcFontFace()");
#if 0
/* This only speeds up immediate mode rendering. */
/* Don't do this when compiling your own display list because */
/* the polygons will go into the GLC internal display lists */
/* rather than the display list you are trying to construct. */
glcEnable(GLC_GL_OBJECTS);
check_glc_error("glcEnable(GLC_GL_OBJECTS)");
#else
glcDisable(GLC_GL_OBJECTS);
check_glc_error("glcDisable(GLC_GL_OBJECTS)");
#endif
/* Draw as polygons for smooth rotation & zoom. */
glcRenderStyle(GLC_TRIANGLE);
check_glc_error("glcRenderStyle(GLC_TRIANGLE)");
}
}
}
}
int main(int argc, char **argv) {
GLint ctx;
GLCenum err;
GLint length = 0;
GLint i, j, n;
GLint font = 0;
GLfloat baseline1[4], baseline2[4];
GLfloat boundingBox1[8], boundingBox2[8];
GLfloat v1, v2, norm, area;
/* Needed to initialize an OpenGL context */
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("test7");
ctx = glcGenContext();
CheckError();
glcContext(ctx);
CheckError();
length = glcMeasureCountedString(GL_TRUE, strlen(string)-1, string);
CheckError();
if ((!length) || (length != (strlen(string)-1))) {
printf("glcMeasureString() failed to measure %d characters"
" (%d measured instead)\n", (int)strlen(string), length);
return -1;
}
n = glcGeti(GLC_MEASURED_CHAR_COUNT);
CheckError();
if (length != n) {
printf("glcGeti(GLC_MEASURED_CHAR_COUNT) == %d is not consistent with the"
" value returned by glcMeasureString() == %d\n", n, length);
return -1;
}
length = glcMeasureString(GL_TRUE, string);
CheckError();
if ((!length) || (length != strlen(string))) {
printf("glcMeasureString() failed to measure %d characters"
" (%d measured instead)\n", (int)strlen(string), length);
return -1;
}
n = glcGeti(GLC_MEASURED_CHAR_COUNT);
CheckError();
if (length != n) {
printf("glcGeti(GLC_MEASURED_CHAR_COUNT) == %d is not consistent with the"
" value returned by glcMeasureString() == %d\n", n, length);
return -1;
}
for (i = 0; i < strlen(string); i++) {
if (!glcGetCharMetric(string[i], GLC_BASELINE, baseline1)) {
printf("Failed to measure the baseline of the character %c\n",
string[i]);
return -1;
}
CheckError();
if (!glcGetStringCharMetric(i, GLC_BASELINE, baseline2)) {
printf("Failed to get the baseline of the %dth character of the string"
" %s\n", i, string);
return -1;
}
CheckError();
for (j = 0; j < 2; j++) {
v1 = fabs(baseline1[j + 2] - baseline1[j]);
v2 = fabs(baseline2[j + 2] - baseline2[j]);
norm = v1 > v2 ? v1 : v2;
if (fabs(v1 - v2) > EPSILON * norm) {
printf("Baseline values differ [rank %d char %d] %f (char),"
" %f (string)\n", j, i, v1, v2);
return -1;
}
}
if (!glcGetCharMetric(string[i], GLC_BOUNDS, boundingBox1)) {
printf("Failed to measure the bounding box of the character %c\n",
string[i]);
return -1;
}
CheckError();
if (!glcGetStringCharMetric(i, GLC_BOUNDS, boundingBox2)) {
printf("Failed to get the bounding box of the %dth character of the"
" string %s\n", i, string);
return -1;
}
CheckError();
for (j = 0; j < 6; j++) {
v1 = fabs(boundingBox1[j + 2] - boundingBox1[j]);
v2 = fabs(boundingBox2[j + 2] - boundingBox2[j]);
norm = v1 > v2 ? v1 : v2;
if (fabs(v1 - v2) > EPSILON * norm) {
printf("Bounding Box values differ [rank %d char %d] %f (char),"
" %f (string)", j, i, v1, v2);
return -1;
}
}
}
if (!glcGeti(GLC_FONT_COUNT)) {
printf("GLC_FONT_LIST is empty\n");
return -1;
}
CheckError();
if (!glcGeti(GLC_CURRENT_FONT_COUNT)) {
printf("GLC_CURRENT_FONT_LIST is empty\n");
return -1;
}
CheckError();
if (!glcGetMaxCharMetric(GLC_BASELINE, baseline1)) {
printf("Failed to get the max baseline of the current fonts\n");
return -1;
}
CheckError();
v1 = fabs(baseline1[1]);
v2 = fabs(baseline1[3]);
norm = v1 > v2 ? v1 : v2;
if (fabs(v1 - v2) < EPSILON * norm) {
v1 = fabs(baseline1[0]);
v2 = fabs(baseline1[2]);
norm = v1 > v2 ? v1 : v2;
if ((fabs(v1 - v2) < EPSILON * norm) || (baseline1[2] < baseline1[0])) {
printf("Right and left side of the max baseline are swapped\n");
printf("%f %f %f %f\n", baseline1[0], baseline1[1], baseline1[2],
baseline1[3]);
font = glcGetListi(GLC_FONT_LIST, 0);
printf("Family : %s\n", (char*)glcGetFontc(font, GLC_FAMILY));
printf("Face : %s\n", (char*)glcGetFontFace(font));
return -1;
}
}
if (!glcGetMaxCharMetric(GLC_BOUNDS, boundingBox1)) {
printf("Failed to get the max bounding box of the current fonts\n");
return -1;
}
CheckError();
area = 0.;
for (i = 0; i < 3; i++) {
area += boundingBox1[2*i] * boundingBox1[2*(i+1)+1]
- boundingBox1[2*(i+1)] * boundingBox1[2*i+1];
}
if (fabs(area * .5) < EPSILON) {
printf("Max area of the characters is null\n");
return -1;
}
/* Regression test for bug #1821219 (glcGetCharMetric randomly crashes when
* requesting measurement for the space character).
*/
for (i = 0; i < glcGeti(GLC_MASTER_COUNT); i++) {
GLint font = glcGenFontID();
if (!glcNewFontFromMaster(font, i)) {
printf("Can not get a font from master %s\n",
(char*)glcGetMasterc(i, GLC_FAMILY));
return -1;
}
CheckError();
glcFont(font);
CheckError();
if (!glcGetFontMap(font, ' ')) {
printf("INFO : Family %s %s has no space character\n",
(char*)glcGetFontc(font, GLC_FAMILY), (char*)glcGetFontFace(font));
continue;
}
if (!glcGetCharMetric(' ', GLC_BOUNDS, boundingBox1)) {
printf("Failed to get the bounding box of the space character\n");
printf("Family : %s\n", (char*)glcGetFontc(font, GLC_FAMILY));
printf("Face : %s\n", (char*)glcGetFontFace(font));
return -1;
}
CheckError();
if (!glcGetCharMetric(' ', GLC_BASELINE, baseline1)) {
printf("Failed to get the baseline of the space character\n");
printf("Family : %s\n", (char*)glcGetFontc(font, GLC_FAMILY));
printf("Face : %s\n", (char*)glcGetFontFace(font));
return -1;
}
CheckError();
v1 = fabs(baseline1[1]);
v2 = fabs(baseline1[3]);
norm = v1 > v2 ? v1 : v2;
if (fabs(v1 - v2) < EPSILON * norm) {
v1 = fabs(baseline1[0]);
v2 = fabs(baseline1[2]);
norm = v1 > v2 ? v1 : v2;
if ((fabs(v1 - v2) < EPSILON * norm) || (baseline1[2] < baseline1[0])) {
printf("Right and left side of the baseline are swapped\n");
printf("%f %f %f %f\n", baseline1[0], baseline1[1], baseline1[2],
baseline1[3]);
printf("Family : %s\n", (char*)glcGetFontc(font, GLC_FAMILY));
printf("Face : %s\n", (char*)glcGetFontFace(font));
return -1;
}
}
}
glcDeleteContext(ctx);
glcContext(0);
printf("Tests successful\n");
return 0;
}
