[Piglit] [PATCH 1/2] piglit: add new bitmap font support
Brian Paul
brian.e.paul at gmail.com
Sat Dec 8 16:12:41 PST 2012
From: Brian Paul <brianp at vmware.com>
Back when we used GLUT some tests printed text (in non-auto mode) to
help understand the test and aid in debugging. This was all removed
when we switched to waffle.
This code adds a simple bitmap text drawing function: piglit_draw_string().
It uses glBitmap but it wouldn't be too much work to implement a version
based on texture mapping.
The piglit-create-font-data.c program is a utility for generating the
piglit-font-data.c file from an X font. It will probably never be used
unless someone wants a font other than "8x13" but I'm including it for
completeness.
---
tests/util/CMakeLists.gl.txt | 2 +
tests/util/piglit-create-font-data.c | 376 +++++++++
tests/util/piglit-font-data.c | 1545 ++++++++++++++++++++++++++++++++++
tests/util/piglit-font.c | 46 +
tests/util/piglit-font.h | 25 +
5 files changed, 1994 insertions(+), 0 deletions(-)
create mode 100644 tests/util/piglit-create-font-data.c
create mode 100644 tests/util/piglit-font-data.c
create mode 100644 tests/util/piglit-font.c
create mode 100644 tests/util/piglit-font.h
diff --git a/tests/util/CMakeLists.gl.txt b/tests/util/CMakeLists.gl.txt
index 10be17a..22029dc 100644
--- a/tests/util/CMakeLists.gl.txt
+++ b/tests/util/CMakeLists.gl.txt
@@ -2,6 +2,8 @@ set(UTIL_GL_SOURCES
${UTIL_GL_SOURCES}
piglit-dispatch.c
piglit-dispatch-init.c
+ piglit-font.c
+ piglit-font-data.c
piglit-shader.c
piglit-shader-gl.c
piglit-util-gl-enum.c
diff --git a/tests/util/piglit-create-font-data.c b/tests/util/piglit-create-font-data.c
new file mode 100644
index 0000000..99c05e0
--- /dev/null
+++ b/tests/util/piglit-create-font-data.c
@@ -0,0 +1,376 @@
+/**
+ * Create the piglit-font-data.c file
+ *
+ * This code is cobled together from the Mesa Xlib driver and a
+ * GLX font demo.
+ *
+ * To build:
+ * cc piglit-create-font-data.c -lX11 -o piglit-create-font-data
+ *
+ * To generate the font data file:
+ * ./piglit-create-font-data 8x13 > piglit-font-data.c
+ *
+ * where "8x13" is just one example of an X font that may be used.
+ *
+ * Brian Paul
+ * Dec 2012
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <X11/Xlib.h>
+#include <GL/gl.h>
+
+
+static int CurChar = 0;
+
+static void
+PrintHeader(int firstChar)
+{
+ printf("/* piglit bitmap font data generated with piglit-create-font-data.c program */\n\n");
+ printf("#include \"piglit-font.h\" \n\n");
+ printf("int piglit_font_first_char = %d;\n\n", firstChar);
+}
+
+
+static void
+PrintFooter(void)
+{
+ int i;
+
+ printf("\n");
+ printf("const struct piglit_glyph *piglit_font[] = {\n");
+
+ for (i = 0; i < CurChar; i++) {
+ printf(" &glyph%d,\n", i);
+ }
+ printf("};\n\n");
+}
+
+
+static void
+NewList(int list)
+{
+ CurChar = list;
+}
+
+
+static void
+EndList(void)
+{
+}
+
+
+static void
+Bitmap(GLsizei width, GLsizei height,
+ GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
+ const GLubyte *bitmap )
+{
+ int n = height * (width + 7) / 8;
+ int i;
+
+ printf("static const GLubyte bits%d[] = {\n", CurChar);
+ for (i = 0; i < n; i++) {
+ printf("0x%02x, ", bitmap[i]);
+ }
+ printf("\n};\n");
+
+ printf("static const struct piglit_glyph glyph%d = {", CurChar);
+ printf(" %d, %d, %f, %f, %f, bits%d };\n\n",
+ width, height, xorig, yorig, xmove, CurChar);
+
+}
+
+
+
+/* Implementation. */
+
+/* Fill a BITMAP with a character C from thew current font
+ in the graphics context GC. WIDTH is the width in bytes
+ and HEIGHT is the height in bits.
+
+ Note that the generated bitmaps must be used with
+
+ glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
+ glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
+ glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
+ glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
+ glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
+ glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+
+ Possible optimizations:
+
+ * use only one reusable pixmap with the maximum dimensions.
+ * draw the entire font into a single pixmap (careful with
+ proportional fonts!).
+*/
+
+
+/*
+ * Generate OpenGL-compatible bitmap.
+ */
+static void
+fill_bitmap(Display * dpy, Window win, GC gc,
+ unsigned int width, unsigned int height,
+ int x0, int y0, unsigned int c, GLubyte * bitmap)
+{
+ XImage *image;
+ unsigned int x, y;
+ Pixmap pixmap;
+ XChar2b char2b;
+
+ pixmap = XCreatePixmap(dpy, win, 8 * width, height, 1);
+ XSetForeground(dpy, gc, 0);
+ XFillRectangle(dpy, pixmap, gc, 0, 0, 8 * width, height);
+ XSetForeground(dpy, gc, 1);
+
+ char2b.byte1 = (c >> 8) & 0xff;
+ char2b.byte2 = (c & 0xff);
+
+ XDrawString16(dpy, pixmap, gc, x0, y0, &char2b, 1);
+
+ image = XGetImage(dpy, pixmap, 0, 0, 8 * width, height, 1, XYPixmap);
+ if (image) {
+ /* Fill the bitmap (X11 and OpenGL are upside down wrt each other). */
+ for (y = 0; y < height; y++)
+ for (x = 0; x < 8 * width; x++)
+ if (XGetPixel(image, x, y))
+ bitmap[width * (height - y - 1) + x / 8] |=
+ (1 << (7 - (x % 8)));
+ XDestroyImage(image);
+ }
+
+ XFreePixmap(dpy, pixmap);
+}
+
+/*
+ * determine if a given glyph is valid and return the
+ * corresponding XCharStruct.
+ */
+static XCharStruct *
+isvalid(XFontStruct * fs, unsigned int which)
+{
+ unsigned int rows, pages;
+ unsigned int byte1 = 0, byte2 = 0;
+ int i, valid = 1;
+
+ rows = fs->max_byte1 - fs->min_byte1 + 1;
+ pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
+
+ if (rows == 1) {
+ /* "linear" fonts */
+ if ((fs->min_char_or_byte2 > which) || (fs->max_char_or_byte2 < which))
+ valid = 0;
+ }
+ else {
+ /* "matrix" fonts */
+ byte2 = which & 0xff;
+ byte1 = which >> 8;
+ if ((fs->min_char_or_byte2 > byte2) ||
+ (fs->max_char_or_byte2 < byte2) ||
+ (fs->min_byte1 > byte1) || (fs->max_byte1 < byte1))
+ valid = 0;
+ }
+
+ if (valid) {
+ if (fs->per_char) {
+ if (rows == 1) {
+ /* "linear" fonts */
+ return (fs->per_char + (which - fs->min_char_or_byte2));
+ }
+ else {
+ /* "matrix" fonts */
+ i = ((byte1 - fs->min_byte1) * pages) +
+ (byte2 - fs->min_char_or_byte2);
+ return (fs->per_char + i);
+ }
+ }
+ else {
+ return (&fs->min_bounds);
+ }
+ }
+ return (NULL);
+}
+
+
+static void
+process_font(Display *dpy, Font font, int first, int count, int listbase)
+{
+ Window win;
+ Pixmap pixmap;
+ GC gc;
+ XGCValues values;
+ unsigned long valuemask;
+ XFontStruct *fs;
+#if 0
+ GLint swapbytes, lsbfirst, rowlength;
+ GLint skiprows, skippixels, alignment;
+#endif
+ unsigned int max_width, max_height, max_bm_width, max_bm_height;
+ GLubyte *bm;
+ int i;
+
+ win = RootWindow(dpy, DefaultScreen(dpy));
+
+ fs = XQueryFont(dpy, font);
+ if (!fs) {
+ fprintf(stderr, "Couldn't get font structure information\n");
+ return;
+ }
+
+ /* Allocate a bitmap that can fit all characters. */
+ max_width = fs->max_bounds.rbearing - fs->min_bounds.lbearing;
+ max_height = fs->max_bounds.ascent + fs->max_bounds.descent;
+ max_bm_width = (max_width + 7) / 8;
+ max_bm_height = max_height;
+
+ bm = malloc((max_bm_width * max_bm_height) * sizeof(GLubyte));
+ if (!bm) {
+ XFreeFontInfo(NULL, fs, 1);
+ fprintf(stderr, "Couldn't allocate bitmap in glXUseXFont()");
+ return;
+ }
+
+#if 0
+ /* get the page info */
+ pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
+ firstchar = (fs->min_byte1 << 8) + fs->min_char_or_byte2;
+ lastchar = (fs->max_byte1 << 8) + fs->max_char_or_byte2;
+ rows = fs->max_byte1 - fs->min_byte1 + 1;
+ unsigned int first_char, last_char, pages, rows;
+#endif
+
+#if 0
+ /* Save the current packing mode for bitmaps. */
+ glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes);
+ glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst);
+ glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength);
+ glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows);
+ glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels);
+ glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
+
+ /* Enforce a standard packing mode which is compatible with
+ fill_bitmap() from above. This is actually the default mode,
+ except for the (non)alignment. */
+ glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+ glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+ glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+ glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+#endif
+
+ pixmap = XCreatePixmap(dpy, win, 10, 10, 1);
+ values.foreground = BlackPixel(dpy, DefaultScreen(dpy));
+ values.background = WhitePixel(dpy, DefaultScreen(dpy));
+ values.font = fs->fid;
+ valuemask = GCForeground | GCBackground | GCFont;
+ gc = XCreateGC(dpy, pixmap, valuemask, &values);
+ XFreePixmap(dpy, pixmap);
+
+ for (i = 0; i < count; i++) {
+ unsigned int width, height, bm_width, bm_height;
+ GLfloat x0, y0, dx, dy;
+ XCharStruct *ch;
+ int x, y;
+ unsigned int c = first + i;
+ int list = listbase + i;
+ int valid;
+
+ /* check on index validity and get the bounds */
+ ch = isvalid(fs, c);
+ if (!ch) {
+ ch = &fs->max_bounds;
+ valid = 0;
+ }
+ else {
+ valid = 1;
+ }
+
+ /* glBitmap()' parameters:
+ straight from the glXUseXFont(3) manpage. */
+ width = ch->rbearing - ch->lbearing;
+ height = ch->ascent + ch->descent;
+ x0 = -ch->lbearing;
+ y0 = ch->descent - 0; /* XXX used to subtract 1 here */
+ /* but that caused a conformace failure */
+ dx = ch->width;
+ dy = 0;
+
+ /* X11's starting point. */
+ x = -ch->lbearing;
+ y = ch->ascent;
+
+ /* Round the width to a multiple of eight. We will use this also
+ for the pixmap for capturing the X11 font. This is slightly
+ inefficient, but it makes the OpenGL part real easy. */
+ bm_width = (width + 7) / 8;
+ bm_height = height;
+
+ NewList(list);
+ if (valid && (bm_width > 0) && (bm_height > 0)) {
+
+ memset(bm, '\0', bm_width * bm_height);
+ fill_bitmap(dpy, win, gc, bm_width, bm_height, x, y, c, bm);
+
+ Bitmap(width, height, x0, y0, dx, dy, bm);
+ }
+ else {
+ Bitmap(0, 0, 0.0, 0.0, dx, dy, NULL);
+ }
+ EndList();
+ }
+
+ free(bm);
+ XFreeFontInfo(NULL, fs, 1);
+ XFreeGC(dpy, gc);
+
+#if 0
+ /* Restore saved packing modes. */
+ glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
+ glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
+ glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
+ glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
+#endif
+}
+
+
+
+int
+main(int argc, char *argv[])
+{
+ Display *dpy;
+ XFontStruct *fontInfo;
+ Font id;
+ unsigned int first, last;
+ int listbase = 0;
+
+ if (argc != 2) {
+ printf("need a font name\n");
+ return 1;
+ }
+
+ dpy = XOpenDisplay(NULL);
+ if (!dpy)
+ return; /* I guess glXMakeCurrent wasn't called */
+
+ fontInfo = XLoadQueryFont(dpy, argv[1]);
+ if (!fontInfo) {
+ printf("Error: font %s not found\n", argv[1]);
+ exit(0);
+ }
+
+ id = fontInfo->fid;
+ first = fontInfo->min_char_or_byte2;
+ last = fontInfo->max_char_or_byte2;
+
+ PrintHeader(first);
+ process_font(dpy, id, first, last-first+1, listbase);
+ PrintFooter();
+
+ return 0;
+}
diff --git a/tests/util/piglit-font-data.c b/tests/util/piglit-font-data.c
new file mode 100644
index 0000000..28eeffd
--- /dev/null
+++ b/tests/util/piglit-font-data.c
@@ -0,0 +1,1545 @@
+/* piglit bitmap font data generated with piglit-create-font-data.c program */
+
+#include "piglit-font.h"
+
+int piglit_font_first_char = 0;
+
+static const GLubyte bits0[] = {
+0xaa, 0x00, 0x82, 0x00, 0x82, 0x00, 0x82, 0x00, 0xaa, 0x00, 0x8f, 0xbf, 0xf8, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph0 = { 7, 9, 0.000000, 0.000000, 8.000000, bits0 };
+
+static const GLubyte bits1[] = {
+0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00, 0xaa, 0x00, 0x8f, 0xbf,
+};
+static const struct piglit_glyph glyph1 = { 7, 7, 0.000000, -1.000000, 8.000000, bits1 };
+
+static const GLubyte bits2[] = {
+0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x9b, 0x61, 0x09, 0x18, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00,
+};
+static const struct piglit_glyph glyph2 = { 8, 13, 0.000000, 2.000000, 8.000000, bits2 };
+
+static const GLubyte bits3[] = {
+0x04, 0x04, 0x04, 0x04, 0xae, 0xa0, 0xe0, 0xa0, 0xa0, 0x55, 0xaa, 0x55, 0xaa, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph3 = { 7, 9, 0.000000, 0.000000, 8.000000, bits3 };
+
+static const GLubyte bits4[] = {
+0x08, 0x08, 0x0c, 0x08, 0x8e, 0x80, 0xc0, 0x80, 0xe0, 0x55, 0xaa, 0x55, 0xaa, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph4 = { 7, 9, 0.000000, 0.000000, 8.000000, bits4 };
+
+static const GLubyte bits5[] = {
+0x0a, 0x0a, 0x0c, 0x0a, 0x6c, 0x80, 0x80, 0x80, 0x60, 0x55, 0xaa, 0x55, 0xaa, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph5 = { 7, 9, 0.000000, 0.000000, 8.000000, bits5 };
+
+static const GLubyte bits6[] = {
+0x08, 0x08, 0x0c, 0x08, 0xee, 0x80, 0x80, 0x80, 0x80, 0x55, 0xaa, 0x55, 0xaa, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph6 = { 7, 9, 0.000000, 0.000000, 8.000000, bits6 };
+
+static const GLubyte bits7[] = {
+0x60, 0x90, 0x90, 0x60, 0xee,
+};
+static const struct piglit_glyph glyph7 = { 4, 4, -2.000000, -5.000000, 8.000000, bits7 };
+
+static const GLubyte bits8[] = {
+0xf8, 0x00, 0x20, 0x20, 0xf8, 0x20, 0x20, 0x80, 0x80, 0x55,
+};
+static const struct piglit_glyph glyph8 = { 5, 7, -1.000000, -1.000000, 8.000000, bits8 };
+
+static const GLubyte bits9[] = {
+0x0e, 0x08, 0x08, 0x08, 0xa8, 0xa0, 0xa0, 0xa0, 0xc0, 0x55, 0xaa, 0x55, 0xaa, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph9 = { 7, 9, 0.000000, 0.000000, 8.000000, bits9 };
+
+static const GLubyte bits10[] = {
+0x04, 0x04, 0x04, 0x04, 0x2e, 0x50, 0x50, 0x88, 0x88, 0x55, 0xaa, 0x55, 0xaa, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph10 = { 7, 9, 0.000000, 0.000000, 8.000000, bits10 };
+
+static const GLubyte bits11[] = {
+0xf0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x88, 0x88,
+};
+static const struct piglit_glyph glyph11 = { 4, 7, 0.000000, -4.000000, 8.000000, bits11 };
+
+static const GLubyte bits12[] = {
+0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0, 0x88, 0x88,
+};
+static const struct piglit_glyph glyph12 = { 4, 7, 0.000000, 2.000000, 8.000000, bits12 };
+
+static const GLubyte bits13[] = {
+0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xf8, 0x88, 0x88, 0x55,
+};
+static const struct piglit_glyph glyph13 = { 5, 7, -3.000000, 2.000000, 8.000000, bits13 };
+
+static const GLubyte bits14[] = {
+0xf8, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x88, 0x88, 0x55,
+};
+static const struct piglit_glyph glyph14 = { 5, 7, -3.000000, -4.000000, 8.000000, bits14 };
+
+static const GLubyte bits15[] = {
+0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x9b, 0x61, 0x09, 0x18, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00,
+};
+static const struct piglit_glyph glyph15 = { 8, 13, 0.000000, 2.000000, 8.000000, bits15 };
+
+static const GLubyte bits16[] = {
+0xff,
+};
+static const struct piglit_glyph glyph16 = { 8, 1, 0.000000, -10.000000, 8.000000, bits16 };
+
+static const GLubyte bits17[] = {
+0xff,
+};
+static const struct piglit_glyph glyph17 = { 8, 1, 0.000000, -7.000000, 8.000000, bits17 };
+
+static const GLubyte bits18[] = {
+0xff,
+};
+static const struct piglit_glyph glyph18 = { 8, 1, 0.000000, -4.000000, 8.000000, bits18 };
+
+static const GLubyte bits19[] = {
+0xff,
+};
+static const struct piglit_glyph glyph19 = { 8, 1, 0.000000, -1.000000, 8.000000, bits19 };
+
+static const GLubyte bits20[] = {
+0xff,
+};
+static const struct piglit_glyph glyph20 = { 8, 1, 0.000000, 2.000000, 8.000000, bits20 };
+
+static const GLubyte bits21[] = {
+0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xf8, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18, 0x00, 0x00,
+};
+static const struct piglit_glyph glyph21 = { 5, 13, -3.000000, 2.000000, 8.000000, bits21 };
+
+static const GLubyte bits22[] = {
+0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph22 = { 4, 13, 0.000000, 2.000000, 8.000000, bits22 };
+
+static const GLubyte bits23[] = {
+0xff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+};
+static const struct piglit_glyph glyph23 = { 8, 7, 0.000000, -4.000000, 8.000000, bits23 };
+
+static const GLubyte bits24[] = {
+0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xff, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+};
+static const struct piglit_glyph glyph24 = { 8, 7, 0.000000, 2.000000, 8.000000, bits24 };
+
+static const GLubyte bits25[] = {
+0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph25 = { 1, 13, -3.000000, 2.000000, 8.000000, bits25 };
+
+static const GLubyte bits26[] = {
+0xfe, 0x00, 0x0e, 0x30, 0xc0, 0x30, 0x0e, 0x80, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph26 = { 7, 7, 0.000000, 0.000000, 8.000000, bits26 };
+
+static const GLubyte bits27[] = {
+0xfe, 0x00, 0xe0, 0x18, 0x06, 0x18, 0xe0, 0x80, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph27 = { 7, 7, 0.000000, 0.000000, 8.000000, bits27 };
+
+static const GLubyte bits28[] = {
+0x44, 0x44, 0x44, 0x44, 0x44, 0xfe, 0xe0, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph28 = { 7, 6, 0.000000, 0.000000, 8.000000, bits28 };
+
+static const GLubyte bits29[] = {
+0x40, 0x40, 0xfc, 0x20, 0x10, 0xfc, 0x08, 0x08, 0x80, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph29 = { 6, 8, -1.000000, 0.000000, 8.000000, bits29 };
+
+static const GLubyte bits30[] = {
+0xdc, 0x62, 0x20, 0x20, 0x20, 0x70, 0x20, 0x22, 0x1c, 0x80, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph30 = { 7, 9, 0.000000, 0.000000, 8.000000, bits30 };
+
+static const GLubyte bits31[] = {
+0xc0,
+};
+static const struct piglit_glyph glyph31 = { 2, 1, -3.000000, -4.000000, 8.000000, bits31 };
+
+static const GLubyte bits32[] = {
+
+};
+static const struct piglit_glyph glyph32 = { 0, 0, 0.000000, 0.000000, 8.000000, bits32 };
+
+static const GLubyte bits33[] = {
+0x80, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph33 = { 1, 9, -3.000000, 0.000000, 8.000000, bits33 };
+
+static const GLubyte bits34[] = {
+0x90, 0x90, 0x90, 0x80,
+};
+static const struct piglit_glyph glyph34 = { 4, 3, -2.000000, -6.000000, 8.000000, bits34 };
+
+static const GLubyte bits35[] = {
+0x48, 0x48, 0xfc, 0x48, 0xfc, 0x48, 0x48, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph35 = { 6, 7, -1.000000, -1.000000, 8.000000, bits35 };
+
+static const GLubyte bits36[] = {
+0x20, 0xf0, 0x28, 0x28, 0x70, 0xa0, 0xa0, 0x78, 0x20, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph36 = { 5, 9, -1.000000, 0.000000, 8.000000, bits36 };
+
+static const GLubyte bits37[] = {
+0x88, 0x54, 0x48, 0x20, 0x10, 0x10, 0x48, 0xa4, 0x44, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph37 = { 6, 9, -1.000000, 0.000000, 8.000000, bits37 };
+
+static const GLubyte bits38[] = {
+0x74, 0x88, 0x94, 0x60, 0x90, 0x90, 0x60, 0xa4, 0x44, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph38 = { 6, 7, -1.000000, 0.000000, 8.000000, bits38 };
+
+static const GLubyte bits39[] = {
+0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph39 = { 1, 3, -3.000000, -6.000000, 8.000000, bits39 };
+
+static const GLubyte bits40[] = {
+0x20, 0x40, 0x40, 0x80, 0x80, 0x80, 0x40, 0x40, 0x20, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph40 = { 3, 9, -3.000000, 0.000000, 8.000000, bits40 };
+
+static const GLubyte bits41[] = {
+0x80, 0x40, 0x40, 0x20, 0x20, 0x20, 0x40, 0x40, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph41 = { 3, 9, -2.000000, 0.000000, 8.000000, bits41 };
+
+static const GLubyte bits42[] = {
+0x48, 0x30, 0xfc, 0x30, 0x48, 0x20, 0x40, 0x40,
+};
+static const struct piglit_glyph glyph42 = { 6, 5, -1.000000, -4.000000, 8.000000, bits42 };
+
+static const GLubyte bits43[] = {
+0x20, 0x20, 0xf8, 0x20, 0x20, 0x20, 0x40,
+};
+static const struct piglit_glyph glyph43 = { 5, 5, -1.000000, -2.000000, 8.000000, bits43 };
+
+static const GLubyte bits44[] = {
+0x80, 0x60, 0x70, 0x20,
+};
+static const struct piglit_glyph glyph44 = { 4, 3, -1.000000, 1.000000, 8.000000, bits44 };
+
+static const GLubyte bits45[] = {
+0xf8,
+};
+static const struct piglit_glyph glyph45 = { 5, 1, -1.000000, -4.000000, 8.000000, bits45 };
+
+static const GLubyte bits46[] = {
+0x40, 0xe0, 0x40,
+};
+static const struct piglit_glyph glyph46 = { 3, 3, -2.000000, 1.000000, 8.000000, bits46 };
+
+static const GLubyte bits47[] = {
+0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x02, 0x80, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph47 = { 7, 9, 0.000000, 0.000000, 8.000000, bits47 };
+
+static const GLubyte bits48[] = {
+0x30, 0x48, 0x84, 0x84, 0x84, 0x84, 0x84, 0x48, 0x30, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph48 = { 6, 9, -1.000000, 0.000000, 8.000000, bits48 };
+
+static const GLubyte bits49[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xa0, 0x60, 0x20, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph49 = { 5, 9, -1.000000, 0.000000, 8.000000, bits49 };
+
+static const GLubyte bits50[] = {
+0xfc, 0x80, 0x40, 0x30, 0x08, 0x04, 0x84, 0x84, 0x78, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph50 = { 6, 9, -1.000000, 0.000000, 8.000000, bits50 };
+
+static const GLubyte bits51[] = {
+0x78, 0x84, 0x04, 0x04, 0x38, 0x10, 0x08, 0x04, 0xfc, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph51 = { 6, 9, -1.000000, 0.000000, 8.000000, bits51 };
+
+static const GLubyte bits52[] = {
+0x08, 0x08, 0xfc, 0x88, 0x88, 0x48, 0x28, 0x18, 0x08, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph52 = { 6, 9, -1.000000, 0.000000, 8.000000, bits52 };
+
+static const GLubyte bits53[] = {
+0x78, 0x84, 0x04, 0x04, 0xc4, 0xb8, 0x80, 0x80, 0xfc, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph53 = { 6, 9, -1.000000, 0.000000, 8.000000, bits53 };
+
+static const GLubyte bits54[] = {
+0x78, 0x84, 0x84, 0xc4, 0xb8, 0x80, 0x80, 0x40, 0x38, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph54 = { 6, 9, -1.000000, 0.000000, 8.000000, bits54 };
+
+static const GLubyte bits55[] = {
+0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x08, 0x04, 0xfc, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph55 = { 6, 9, -1.000000, 0.000000, 8.000000, bits55 };
+
+static const GLubyte bits56[] = {
+0x78, 0x84, 0x84, 0x84, 0x78, 0x84, 0x84, 0x84, 0x78, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph56 = { 6, 9, -1.000000, 0.000000, 8.000000, bits56 };
+
+static const GLubyte bits57[] = {
+0x70, 0x08, 0x04, 0x04, 0x74, 0x8c, 0x84, 0x84, 0x78, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph57 = { 6, 9, -1.000000, 0.000000, 8.000000, bits57 };
+
+static const GLubyte bits58[] = {
+0x40, 0xe0, 0x40, 0x00, 0x00, 0x40, 0xe0, 0x40, 0x78, 0x80,
+};
+static const struct piglit_glyph glyph58 = { 3, 8, -2.000000, 1.000000, 8.000000, bits58 };
+
+static const GLubyte bits59[] = {
+0x80, 0x60, 0x70, 0x00, 0x00, 0x20, 0x70, 0x20, 0x78, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph59 = { 4, 8, -1.000000, 1.000000, 8.000000, bits59 };
+
+static const GLubyte bits60[] = {
+0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x20, 0x10, 0x08, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph60 = { 5, 9, -2.000000, 0.000000, 8.000000, bits60 };
+
+static const GLubyte bits61[] = {
+0xfc, 0x00, 0x00, 0xfc, 0x80, 0x40,
+};
+static const struct piglit_glyph glyph61 = { 6, 4, -1.000000, -2.000000, 8.000000, bits61 };
+
+static const GLubyte bits62[] = {
+0x80, 0x40, 0x20, 0x10, 0x08, 0x10, 0x20, 0x40, 0x80, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph62 = { 5, 9, -1.000000, 0.000000, 8.000000, bits62 };
+
+static const GLubyte bits63[] = {
+0x10, 0x00, 0x10, 0x10, 0x08, 0x04, 0x84, 0x84, 0x78, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph63 = { 6, 9, -1.000000, 0.000000, 8.000000, bits63 };
+
+static const GLubyte bits64[] = {
+0x78, 0x80, 0x94, 0xac, 0xa4, 0x9c, 0x84, 0x84, 0x78, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph64 = { 6, 9, -1.000000, 0.000000, 8.000000, bits64 };
+
+static const GLubyte bits65[] = {
+0x84, 0x84, 0x84, 0xfc, 0x84, 0x84, 0x84, 0x48, 0x30, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph65 = { 6, 9, -1.000000, 0.000000, 8.000000, bits65 };
+
+static const GLubyte bits66[] = {
+0xf0, 0x88, 0x84, 0x88, 0xf0, 0x88, 0x84, 0x88, 0xf0, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph66 = { 6, 9, -1.000000, 0.000000, 8.000000, bits66 };
+
+static const GLubyte bits67[] = {
+0x78, 0x84, 0x80, 0x80, 0x80, 0x80, 0x80, 0x84, 0x78, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph67 = { 6, 9, -1.000000, 0.000000, 8.000000, bits67 };
+
+static const GLubyte bits68[] = {
+0xf0, 0x88, 0x84, 0x84, 0x84, 0x84, 0x84, 0x88, 0xf0, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph68 = { 6, 9, -1.000000, 0.000000, 8.000000, bits68 };
+
+static const GLubyte bits69[] = {
+0xfc, 0x80, 0x80, 0x80, 0xf0, 0x80, 0x80, 0x80, 0xfc, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph69 = { 6, 9, -1.000000, 0.000000, 8.000000, bits69 };
+
+static const GLubyte bits70[] = {
+0x80, 0x80, 0x80, 0x80, 0xf0, 0x80, 0x80, 0x80, 0xfc, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph70 = { 6, 9, -1.000000, 0.000000, 8.000000, bits70 };
+
+static const GLubyte bits71[] = {
+0x74, 0x8c, 0x84, 0x9c, 0x80, 0x80, 0x80, 0x84, 0x78, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph71 = { 6, 9, -1.000000, 0.000000, 8.000000, bits71 };
+
+static const GLubyte bits72[] = {
+0x84, 0x84, 0x84, 0x84, 0xfc, 0x84, 0x84, 0x84, 0x84, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph72 = { 6, 9, -1.000000, 0.000000, 8.000000, bits72 };
+
+static const GLubyte bits73[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph73 = { 5, 9, -1.000000, 0.000000, 8.000000, bits73 };
+
+static const GLubyte bits74[] = {
+0x70, 0x88, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3e, 0x80, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph74 = { 7, 9, -1.000000, 0.000000, 8.000000, bits74 };
+
+static const GLubyte bits75[] = {
+0x84, 0x88, 0x90, 0xa0, 0xc0, 0xa0, 0x90, 0x88, 0x84, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph75 = { 6, 9, -1.000000, 0.000000, 8.000000, bits75 };
+
+static const GLubyte bits76[] = {
+0xfc, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph76 = { 6, 9, -1.000000, 0.000000, 8.000000, bits76 };
+
+static const GLubyte bits77[] = {
+0x82, 0x82, 0x82, 0x92, 0x92, 0xaa, 0xc6, 0x82, 0x82, 0x80, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph77 = { 7, 9, 0.000000, 0.000000, 8.000000, bits77 };
+
+static const GLubyte bits78[] = {
+0x84, 0x84, 0x84, 0x8c, 0x94, 0xa4, 0xc4, 0x84, 0x84, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph78 = { 6, 9, -1.000000, 0.000000, 8.000000, bits78 };
+
+static const GLubyte bits79[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x78, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph79 = { 6, 9, -1.000000, 0.000000, 8.000000, bits79 };
+
+static const GLubyte bits80[] = {
+0x80, 0x80, 0x80, 0x80, 0xf8, 0x84, 0x84, 0x84, 0xf8, 0x80, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph80 = { 6, 9, -1.000000, 0.000000, 8.000000, bits80 };
+
+static const GLubyte bits81[] = {
+0x04, 0x78, 0x94, 0xa4, 0x84, 0x84, 0x84, 0x84, 0x84, 0x78, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph81 = { 6, 10, -1.000000, 1.000000, 8.000000, bits81 };
+
+static const GLubyte bits82[] = {
+0x84, 0x88, 0x90, 0xa0, 0xf8, 0x84, 0x84, 0x84, 0xf8, 0x78, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph82 = { 6, 9, -1.000000, 0.000000, 8.000000, bits82 };
+
+static const GLubyte bits83[] = {
+0x78, 0x84, 0x04, 0x04, 0x78, 0x80, 0x80, 0x84, 0x78, 0x78, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph83 = { 6, 9, -1.000000, 0.000000, 8.000000, bits83 };
+
+static const GLubyte bits84[] = {
+0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xfe, 0x78, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph84 = { 7, 9, 0.000000, 0.000000, 8.000000, bits84 };
+
+static const GLubyte bits85[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x78, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph85 = { 6, 9, -1.000000, 0.000000, 8.000000, bits85 };
+
+static const GLubyte bits86[] = {
+0x10, 0x28, 0x28, 0x28, 0x44, 0x44, 0x44, 0x82, 0x82, 0x78, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph86 = { 7, 9, 0.000000, 0.000000, 8.000000, bits86 };
+
+static const GLubyte bits87[] = {
+0x44, 0xaa, 0x92, 0x92, 0x92, 0x82, 0x82, 0x82, 0x82, 0x78, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph87 = { 7, 9, 0.000000, 0.000000, 8.000000, bits87 };
+
+static const GLubyte bits88[] = {
+0x82, 0x82, 0x44, 0x28, 0x10, 0x28, 0x44, 0x82, 0x82, 0x78, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph88 = { 7, 9, 0.000000, 0.000000, 8.000000, bits88 };
+
+static const GLubyte bits89[] = {
+0x10, 0x10, 0x10, 0x10, 0x10, 0x28, 0x44, 0x82, 0x82, 0x78, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph89 = { 7, 9, 0.000000, 0.000000, 8.000000, bits89 };
+
+static const GLubyte bits90[] = {
+0xfc, 0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0xfc, 0x78, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph90 = { 6, 9, -1.000000, 0.000000, 8.000000, bits90 };
+
+static const GLubyte bits91[] = {
+0xf0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xf0, 0x78, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph91 = { 4, 9, -2.000000, 0.000000, 8.000000, bits91 };
+
+static const GLubyte bits92[] = {
+0x02, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x80, 0x78, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph92 = { 7, 9, 0.000000, 0.000000, 8.000000, bits92 };
+
+static const GLubyte bits93[] = {
+0xf0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xf0, 0x78, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph93 = { 4, 9, -1.000000, 0.000000, 8.000000, bits93 };
+
+static const GLubyte bits94[] = {
+0x88, 0x50, 0x20, 0x10,
+};
+static const struct piglit_glyph glyph94 = { 5, 3, -1.000000, -6.000000, 8.000000, bits94 };
+
+static const GLubyte bits95[] = {
+0xfe,
+};
+static const struct piglit_glyph glyph95 = { 7, 1, 0.000000, 1.000000, 8.000000, bits95 };
+
+static const GLubyte bits96[] = {
+0x40, 0x80,
+};
+static const struct piglit_glyph glyph96 = { 2, 2, -3.000000, -8.000000, 8.000000, bits96 };
+
+static const GLubyte bits97[] = {
+0x74, 0x8c, 0x84, 0x7c, 0x04, 0x78, 0x10, 0x10, 0xf0,
+};
+static const struct piglit_glyph glyph97 = { 6, 6, -1.000000, 0.000000, 8.000000, bits97 };
+
+static const GLubyte bits98[] = {
+0xb8, 0xc4, 0x84, 0x84, 0xc4, 0xb8, 0x80, 0x80, 0x80, 0x78, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph98 = { 6, 9, -1.000000, 0.000000, 8.000000, bits98 };
+
+static const GLubyte bits99[] = {
+0x78, 0x84, 0x80, 0x80, 0x84, 0x78, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph99 = { 6, 6, -1.000000, 0.000000, 8.000000, bits99 };
+
+static const GLubyte bits100[] = {
+0x74, 0x8c, 0x84, 0x84, 0x8c, 0x74, 0x04, 0x04, 0x04, 0x78, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph100 = { 6, 9, -1.000000, 0.000000, 8.000000, bits100 };
+
+static const GLubyte bits101[] = {
+0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x04, 0x04, 0x04,
+};
+static const struct piglit_glyph glyph101 = { 6, 6, -1.000000, 0.000000, 8.000000, bits101 };
+
+static const GLubyte bits102[] = {
+0x40, 0x40, 0x40, 0x40, 0xf8, 0x40, 0x40, 0x44, 0x38, 0x78, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph102 = { 6, 9, -1.000000, 0.000000, 8.000000, bits102 };
+
+static const GLubyte bits103[] = {
+0x78, 0x84, 0x78, 0x80, 0x70, 0x88, 0x88, 0x74, 0x38, 0x78, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph103 = { 6, 8, -1.000000, 2.000000, 8.000000, bits103 };
+
+static const GLubyte bits104[] = {
+0x84, 0x84, 0x84, 0x84, 0xc4, 0xb8, 0x80, 0x80, 0x80, 0x78, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph104 = { 6, 9, -1.000000, 0.000000, 8.000000, bits104 };
+
+static const GLubyte bits105[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x00, 0x20, 0x80, 0x78, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph105 = { 5, 8, -1.000000, 0.000000, 8.000000, bits105 };
+
+static const GLubyte bits106[] = {
+0x70, 0x88, 0x88, 0x08, 0x08, 0x08, 0x08, 0x18, 0x00, 0x08, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph106 = { 5, 10, -1.000000, 2.000000, 8.000000, bits106 };
+
+static const GLubyte bits107[] = {
+0x84, 0x88, 0x90, 0xe0, 0x90, 0x88, 0x80, 0x80, 0x80, 0x08, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph107 = { 6, 9, -1.000000, 0.000000, 8.000000, bits107 };
+
+static const GLubyte bits108[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x60, 0x08, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph108 = { 5, 9, -1.000000, 0.000000, 8.000000, bits108 };
+
+static const GLubyte bits109[] = {
+0x82, 0x92, 0x92, 0x92, 0x92, 0xec, 0x20, 0x20, 0x60, 0x08,
+};
+static const struct piglit_glyph glyph109 = { 7, 6, 0.000000, 0.000000, 8.000000, bits109 };
+
+static const GLubyte bits110[] = {
+0x84, 0x84, 0x84, 0x84, 0xc4, 0xb8, 0x20, 0x20, 0x60,
+};
+static const struct piglit_glyph glyph110 = { 6, 6, -1.000000, 0.000000, 8.000000, bits110 };
+
+static const GLubyte bits111[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x20, 0x20, 0x60,
+};
+static const struct piglit_glyph glyph111 = { 6, 6, -1.000000, 0.000000, 8.000000, bits111 };
+
+static const GLubyte bits112[] = {
+0x80, 0x80, 0x80, 0xb8, 0xc4, 0x84, 0xc4, 0xb8, 0x60, 0x08, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph112 = { 6, 8, -1.000000, 2.000000, 8.000000, bits112 };
+
+static const GLubyte bits113[] = {
+0x04, 0x04, 0x04, 0x74, 0x8c, 0x84, 0x8c, 0x74, 0x60, 0x08, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph113 = { 6, 8, -1.000000, 2.000000, 8.000000, bits113 };
+
+static const GLubyte bits114[] = {
+0x40, 0x40, 0x40, 0x40, 0x44, 0xb8, 0x8c, 0x74, 0x60,
+};
+static const struct piglit_glyph glyph114 = { 6, 6, -1.000000, 0.000000, 8.000000, bits114 };
+
+static const GLubyte bits115[] = {
+0x78, 0x84, 0x18, 0x60, 0x84, 0x78, 0x8c, 0x74, 0x60,
+};
+static const struct piglit_glyph glyph115 = { 6, 6, -1.000000, 0.000000, 8.000000, bits115 };
+
+static const GLubyte bits116[] = {
+0x38, 0x44, 0x40, 0x40, 0x40, 0xf8, 0x40, 0x40, 0x60, 0x08, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph116 = { 6, 8, -1.000000, 0.000000, 8.000000, bits116 };
+
+static const GLubyte bits117[] = {
+0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x40, 0x40, 0x60,
+};
+static const struct piglit_glyph glyph117 = { 6, 6, -1.000000, 0.000000, 8.000000, bits117 };
+
+static const GLubyte bits118[] = {
+0x20, 0x50, 0x50, 0x88, 0x88, 0x88, 0x40, 0x40, 0x60,
+};
+static const struct piglit_glyph glyph118 = { 5, 6, -1.000000, 0.000000, 8.000000, bits118 };
+
+static const GLubyte bits119[] = {
+0x44, 0xaa, 0x92, 0x92, 0x82, 0x82, 0x40, 0x40, 0x60, 0x08,
+};
+static const struct piglit_glyph glyph119 = { 7, 6, 0.000000, 0.000000, 8.000000, bits119 };
+
+static const GLubyte bits120[] = {
+0x84, 0x48, 0x30, 0x30, 0x48, 0x84, 0x40, 0x40, 0x60,
+};
+static const struct piglit_glyph glyph120 = { 6, 6, -1.000000, 0.000000, 8.000000, bits120 };
+
+static const GLubyte bits121[] = {
+0x78, 0x84, 0x04, 0x74, 0x8c, 0x84, 0x84, 0x84, 0x60, 0x08, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph121 = { 6, 8, -1.000000, 2.000000, 8.000000, bits121 };
+
+static const GLubyte bits122[] = {
+0xfc, 0x40, 0x20, 0x10, 0x08, 0xfc, 0x84, 0x84, 0x60,
+};
+static const struct piglit_glyph glyph122 = { 6, 6, -1.000000, 0.000000, 8.000000, bits122 };
+
+static const GLubyte bits123[] = {
+0x38, 0x40, 0x40, 0x20, 0xc0, 0x20, 0x40, 0x40, 0x38, 0x08, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph123 = { 5, 9, -2.000000, 0.000000, 8.000000, bits123 };
+
+static const GLubyte bits124[] = {
+0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph124 = { 1, 9, -3.000000, 0.000000, 8.000000, bits124 };
+
+static const GLubyte bits125[] = {
+0xe0, 0x10, 0x10, 0x20, 0x18, 0x20, 0x10, 0x10, 0xe0, 0x08, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph125 = { 5, 9, -1.000000, 0.000000, 8.000000, bits125 };
+
+static const GLubyte bits126[] = {
+0x90, 0xa8, 0x48, 0x20,
+};
+static const struct piglit_glyph glyph126 = { 5, 3, -1.000000, -6.000000, 8.000000, bits126 };
+
+static const GLubyte bits127[] = {
+
+};
+static const struct piglit_glyph glyph127 = { 0, 0, 0.000000, 0.000000, 0.000000, bits127 };
+
+static const GLubyte bits128[] = {
+
+};
+static const struct piglit_glyph glyph128 = { 0, 0, 0.000000, 0.000000, 0.000000, bits128 };
+
+static const GLubyte bits129[] = {
+
+};
+static const struct piglit_glyph glyph129 = { 0, 0, 0.000000, 0.000000, 0.000000, bits129 };
+
+static const GLubyte bits130[] = {
+
+};
+static const struct piglit_glyph glyph130 = { 0, 0, 0.000000, 0.000000, 0.000000, bits130 };
+
+static const GLubyte bits131[] = {
+
+};
+static const struct piglit_glyph glyph131 = { 0, 0, 0.000000, 0.000000, 0.000000, bits131 };
+
+static const GLubyte bits132[] = {
+
+};
+static const struct piglit_glyph glyph132 = { 0, 0, 0.000000, 0.000000, 0.000000, bits132 };
+
+static const GLubyte bits133[] = {
+
+};
+static const struct piglit_glyph glyph133 = { 0, 0, 0.000000, 0.000000, 0.000000, bits133 };
+
+static const GLubyte bits134[] = {
+
+};
+static const struct piglit_glyph glyph134 = { 0, 0, 0.000000, 0.000000, 0.000000, bits134 };
+
+static const GLubyte bits135[] = {
+
+};
+static const struct piglit_glyph glyph135 = { 0, 0, 0.000000, 0.000000, 0.000000, bits135 };
+
+static const GLubyte bits136[] = {
+
+};
+static const struct piglit_glyph glyph136 = { 0, 0, 0.000000, 0.000000, 0.000000, bits136 };
+
+static const GLubyte bits137[] = {
+
+};
+static const struct piglit_glyph glyph137 = { 0, 0, 0.000000, 0.000000, 0.000000, bits137 };
+
+static const GLubyte bits138[] = {
+
+};
+static const struct piglit_glyph glyph138 = { 0, 0, 0.000000, 0.000000, 0.000000, bits138 };
+
+static const GLubyte bits139[] = {
+
+};
+static const struct piglit_glyph glyph139 = { 0, 0, 0.000000, 0.000000, 0.000000, bits139 };
+
+static const GLubyte bits140[] = {
+
+};
+static const struct piglit_glyph glyph140 = { 0, 0, 0.000000, 0.000000, 0.000000, bits140 };
+
+static const GLubyte bits141[] = {
+
+};
+static const struct piglit_glyph glyph141 = { 0, 0, 0.000000, 0.000000, 0.000000, bits141 };
+
+static const GLubyte bits142[] = {
+
+};
+static const struct piglit_glyph glyph142 = { 0, 0, 0.000000, 0.000000, 0.000000, bits142 };
+
+static const GLubyte bits143[] = {
+
+};
+static const struct piglit_glyph glyph143 = { 0, 0, 0.000000, 0.000000, 0.000000, bits143 };
+
+static const GLubyte bits144[] = {
+
+};
+static const struct piglit_glyph glyph144 = { 0, 0, 0.000000, 0.000000, 0.000000, bits144 };
+
+static const GLubyte bits145[] = {
+
+};
+static const struct piglit_glyph glyph145 = { 0, 0, 0.000000, 0.000000, 0.000000, bits145 };
+
+static const GLubyte bits146[] = {
+
+};
+static const struct piglit_glyph glyph146 = { 0, 0, 0.000000, 0.000000, 0.000000, bits146 };
+
+static const GLubyte bits147[] = {
+
+};
+static const struct piglit_glyph glyph147 = { 0, 0, 0.000000, 0.000000, 0.000000, bits147 };
+
+static const GLubyte bits148[] = {
+
+};
+static const struct piglit_glyph glyph148 = { 0, 0, 0.000000, 0.000000, 0.000000, bits148 };
+
+static const GLubyte bits149[] = {
+
+};
+static const struct piglit_glyph glyph149 = { 0, 0, 0.000000, 0.000000, 0.000000, bits149 };
+
+static const GLubyte bits150[] = {
+
+};
+static const struct piglit_glyph glyph150 = { 0, 0, 0.000000, 0.000000, 0.000000, bits150 };
+
+static const GLubyte bits151[] = {
+
+};
+static const struct piglit_glyph glyph151 = { 0, 0, 0.000000, 0.000000, 0.000000, bits151 };
+
+static const GLubyte bits152[] = {
+
+};
+static const struct piglit_glyph glyph152 = { 0, 0, 0.000000, 0.000000, 0.000000, bits152 };
+
+static const GLubyte bits153[] = {
+
+};
+static const struct piglit_glyph glyph153 = { 0, 0, 0.000000, 0.000000, 0.000000, bits153 };
+
+static const GLubyte bits154[] = {
+
+};
+static const struct piglit_glyph glyph154 = { 0, 0, 0.000000, 0.000000, 0.000000, bits154 };
+
+static const GLubyte bits155[] = {
+
+};
+static const struct piglit_glyph glyph155 = { 0, 0, 0.000000, 0.000000, 0.000000, bits155 };
+
+static const GLubyte bits156[] = {
+
+};
+static const struct piglit_glyph glyph156 = { 0, 0, 0.000000, 0.000000, 0.000000, bits156 };
+
+static const GLubyte bits157[] = {
+
+};
+static const struct piglit_glyph glyph157 = { 0, 0, 0.000000, 0.000000, 0.000000, bits157 };
+
+static const GLubyte bits158[] = {
+
+};
+static const struct piglit_glyph glyph158 = { 0, 0, 0.000000, 0.000000, 0.000000, bits158 };
+
+static const GLubyte bits159[] = {
+
+};
+static const struct piglit_glyph glyph159 = { 0, 0, 0.000000, 0.000000, 0.000000, bits159 };
+
+static const GLubyte bits160[] = {
+
+};
+static const struct piglit_glyph glyph160 = { 0, 0, 0.000000, 0.000000, 8.000000, bits160 };
+
+static const GLubyte bits161[] = {
+0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x80,
+};
+static const struct piglit_glyph glyph161 = { 1, 9, -3.000000, 0.000000, 8.000000, bits161 };
+
+static const GLubyte bits162[] = {
+0x20, 0x70, 0xa8, 0xa0, 0xa0, 0xa8, 0x70, 0x20, 0x80, 0x08, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph162 = { 5, 8, -1.000000, -1.000000, 8.000000, bits162 };
+
+static const GLubyte bits163[] = {
+0xdc, 0x62, 0x20, 0x20, 0x20, 0x70, 0x20, 0x22, 0x1c, 0x08, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph163 = { 7, 9, 0.000000, 0.000000, 8.000000, bits163 };
+
+static const GLubyte bits164[] = {
+0x84, 0x78, 0x48, 0x48, 0x78, 0x84, 0x20, 0x22, 0x1c,
+};
+static const struct piglit_glyph glyph164 = { 6, 6, -1.000000, -1.000000, 8.000000, bits164 };
+
+static const GLubyte bits165[] = {
+0x10, 0x10, 0x7c, 0x10, 0x7c, 0x28, 0x44, 0x82, 0x82, 0x08, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph165 = { 7, 9, 0.000000, 0.000000, 8.000000, bits165 };
+
+static const GLubyte bits166[] = {
+0x80, 0x80, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph166 = { 1, 9, -3.000000, 0.000000, 8.000000, bits166 };
+
+static const GLubyte bits167[] = {
+0x60, 0x90, 0x10, 0x60, 0x90, 0x90, 0x60, 0x80, 0x90, 0x60, 0x80, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph167 = { 4, 10, -2.000000, 0.000000, 8.000000, bits167 };
+
+static const GLubyte bits168[] = {
+0x90, 0x90,
+};
+static const struct piglit_glyph glyph168 = { 4, 2, -2.000000, -8.000000, 8.000000, bits168 };
+
+static const GLubyte bits169[] = {
+0x38, 0x44, 0x92, 0xaa, 0xa2, 0xaa, 0x92, 0x44, 0x38, 0x60, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph169 = { 7, 9, 0.000000, -1.000000, 8.000000, bits169 };
+
+static const GLubyte bits170[] = {
+0xf8, 0x00, 0x78, 0x88, 0x78, 0x08, 0x70, 0x44, 0x38, 0x60,
+};
+static const struct piglit_glyph glyph170 = { 5, 7, -1.000000, -2.000000, 8.000000, bits170 };
+
+static const GLubyte bits171[] = {
+0x12, 0x24, 0x48, 0x90, 0x48, 0x24, 0x12, 0x44, 0x38, 0x60, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph171 = { 7, 7, 0.000000, -1.000000, 8.000000, bits171 };
+
+static const GLubyte bits172[] = {
+0x04, 0x04, 0x04, 0xfc, 0x48, 0x24,
+};
+static const struct piglit_glyph glyph172 = { 6, 4, -1.000000, -1.000000, 8.000000, bits172 };
+
+static const GLubyte bits173[] = {
+0xf0,
+};
+static const struct piglit_glyph glyph173 = { 4, 1, -2.000000, -4.000000, 8.000000, bits173 };
+
+static const GLubyte bits174[] = {
+0x38, 0x44, 0xaa, 0xb2, 0xaa, 0xaa, 0x92, 0x44, 0x38, 0x60, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph174 = { 7, 9, 0.000000, -1.000000, 8.000000, bits174 };
+
+static const GLubyte bits175[] = {
+0xfc,
+};
+static const struct piglit_glyph glyph175 = { 6, 1, -1.000000, -8.000000, 8.000000, bits175 };
+
+static const GLubyte bits176[] = {
+0x60, 0x90, 0x90, 0x60, 0xaa,
+};
+static const struct piglit_glyph glyph176 = { 4, 4, -2.000000, -5.000000, 8.000000, bits176 };
+
+static const GLubyte bits177[] = {
+0xf8, 0x00, 0x20, 0x20, 0xf8, 0x20, 0x20, 0x44, 0x38, 0x60,
+};
+static const struct piglit_glyph glyph177 = { 5, 7, -1.000000, -1.000000, 8.000000, bits177 };
+
+static const GLubyte bits178[] = {
+0xf0, 0x80, 0x60, 0x10, 0x90, 0x60, 0x20, 0x44,
+};
+static const struct piglit_glyph glyph178 = { 4, 6, -1.000000, -4.000000, 8.000000, bits178 };
+
+static const GLubyte bits179[] = {
+0x60, 0x90, 0x10, 0x20, 0x90, 0x60, 0x20, 0x44,
+};
+static const struct piglit_glyph glyph179 = { 4, 6, -1.000000, -4.000000, 8.000000, bits179 };
+
+static const GLubyte bits180[] = {
+0x80, 0x40,
+};
+static const struct piglit_glyph glyph180 = { 2, 2, -3.000000, -8.000000, 8.000000, bits180 };
+
+static const GLubyte bits181[] = {
+0x80, 0xb4, 0xcc, 0x84, 0x84, 0x84, 0x84, 0x44, 0x38, 0x60, 0x80,
+};
+static const struct piglit_glyph glyph181 = { 6, 7, -1.000000, 1.000000, 8.000000, bits181 };
+
+static const GLubyte bits182[] = {
+0x28, 0x28, 0x28, 0x28, 0x68, 0xe8, 0xe8, 0xe8, 0x7c, 0x60, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph182 = { 6, 9, -1.000000, 0.000000, 8.000000, bits182 };
+
+static const GLubyte bits183[] = {
+0xc0,
+};
+static const struct piglit_glyph glyph183 = { 2, 1, -3.000000, -4.000000, 8.000000, bits183 };
+
+static const GLubyte bits184[] = {
+0xc0, 0x40,
+};
+static const struct piglit_glyph glyph184 = { 2, 2, -3.000000, 2.000000, 8.000000, bits184 };
+
+static const GLubyte bits185[] = {
+0xe0, 0x40, 0x40, 0x40, 0xc0, 0x40, 0xe8,
+};
+static const struct piglit_glyph glyph185 = { 3, 6, -1.000000, -4.000000, 8.000000, bits185 };
+
+static const GLubyte bits186[] = {
+0xf0, 0x00, 0x60, 0x90, 0x90, 0x60, 0xe8, 0xe8,
+};
+static const struct piglit_glyph glyph186 = { 4, 6, -1.000000, -3.000000, 8.000000, bits186 };
+
+static const GLubyte bits187[] = {
+0x90, 0x48, 0x24, 0x12, 0x24, 0x48, 0x90, 0xe8, 0x7c, 0x60, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph187 = { 7, 7, 0.000000, -1.000000, 8.000000, bits187 };
+
+static const GLubyte bits188[] = {
+0x06, 0x1a, 0x12, 0x0a, 0xe6, 0x42, 0x40, 0x40, 0xc0, 0x40, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph188 = { 7, 10, 0.000000, 0.000000, 8.000000, bits188 };
+
+static const GLubyte bits189[] = {
+0x1e, 0x10, 0x0c, 0x02, 0xf2, 0x4c, 0x40, 0x40, 0xc0, 0x40, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph189 = { 7, 10, 0.000000, 0.000000, 8.000000, bits189 };
+
+static const GLubyte bits190[] = {
+0x06, 0x1a, 0x12, 0x0a, 0x66, 0x92, 0x10, 0x20, 0x90, 0x60, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph190 = { 7, 10, 0.000000, 0.000000, 8.000000, bits190 };
+
+static const GLubyte bits191[] = {
+0x78, 0x84, 0x84, 0x80, 0x40, 0x20, 0x20, 0x00, 0x20, 0x60, 0x80, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph191 = { 6, 9, -1.000000, 0.000000, 8.000000, bits191 };
+
+static const GLubyte bits192[] = {
+0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x00, 0x10, 0x20, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph192 = { 6, 10, -1.000000, 0.000000, 8.000000, bits192 };
+
+static const GLubyte bits193[] = {
+0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x00, 0x20, 0x10, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph193 = { 6, 10, -1.000000, 0.000000, 8.000000, bits193 };
+
+static const GLubyte bits194[] = {
+0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x00, 0x48, 0x30, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph194 = { 6, 10, -1.000000, 0.000000, 8.000000, bits194 };
+
+static const GLubyte bits195[] = {
+0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x00, 0x98, 0x64, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph195 = { 6, 10, -1.000000, 0.000000, 8.000000, bits195 };
+
+static const GLubyte bits196[] = {
+0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x00, 0x48, 0x48, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph196 = { 6, 10, -1.000000, 0.000000, 8.000000, bits196 };
+
+static const GLubyte bits197[] = {
+0x84, 0x84, 0xfc, 0x84, 0x84, 0x48, 0x30, 0x30, 0x48, 0x30, 0x80, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph197 = { 6, 10, -1.000000, 0.000000, 8.000000, bits197 };
+
+static const GLubyte bits198[] = {
+0x9e, 0x90, 0x90, 0xf0, 0x9c, 0x90, 0x90, 0x90, 0x6e, 0x30, 0x80, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph198 = { 7, 9, 0.000000, 0.000000, 8.000000, bits198 };
+
+static const GLubyte bits199[] = {
+0x20, 0x10, 0x78, 0x84, 0x80, 0x80, 0x80, 0x80, 0x80, 0x84, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph199 = { 6, 11, -1.000000, 2.000000, 8.000000, bits199 };
+
+static const GLubyte bits200[] = {
+0xfc, 0x80, 0x80, 0xf0, 0x80, 0x80, 0xfc, 0x00, 0x10, 0x20, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph200 = { 6, 10, -1.000000, 0.000000, 8.000000, bits200 };
+
+static const GLubyte bits201[] = {
+0xfc, 0x80, 0x80, 0xf0, 0x80, 0x80, 0xfc, 0x00, 0x20, 0x10, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph201 = { 6, 10, -1.000000, 0.000000, 8.000000, bits201 };
+
+static const GLubyte bits202[] = {
+0xfc, 0x80, 0x80, 0xf0, 0x80, 0x80, 0xfc, 0x00, 0x48, 0x30, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph202 = { 6, 10, -1.000000, 0.000000, 8.000000, bits202 };
+
+static const GLubyte bits203[] = {
+0xfc, 0x80, 0x80, 0xf0, 0x80, 0x80, 0xfc, 0x00, 0x48, 0x48, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph203 = { 6, 10, -1.000000, 0.000000, 8.000000, bits203 };
+
+static const GLubyte bits204[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x00, 0x20, 0x40, 0x78, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph204 = { 5, 10, -1.000000, 0.000000, 8.000000, bits204 };
+
+static const GLubyte bits205[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x00, 0x20, 0x10, 0x78, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph205 = { 5, 10, -1.000000, 0.000000, 8.000000, bits205 };
+
+static const GLubyte bits206[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x00, 0x48, 0x30, 0x78, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph206 = { 5, 10, -1.000000, 0.000000, 8.000000, bits206 };
+
+static const GLubyte bits207[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x20, 0xf8, 0x00, 0x88, 0x88, 0x78, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph207 = { 5, 10, -1.000000, 0.000000, 8.000000, bits207 };
+
+static const GLubyte bits208[] = {
+0x78, 0x44, 0x42, 0x42, 0xe2, 0x42, 0x42, 0x44, 0x78, 0x88, 0x78, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph208 = { 7, 9, 0.000000, 0.000000, 8.000000, bits208 };
+
+static const GLubyte bits209[] = {
+0x82, 0x86, 0x8a, 0x92, 0xa2, 0xc2, 0x82, 0x00, 0x98, 0x64, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph209 = { 7, 10, 0.000000, 0.000000, 8.000000, bits209 };
+
+static const GLubyte bits210[] = {
+0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x10, 0x20, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph210 = { 7, 10, 0.000000, 0.000000, 8.000000, bits210 };
+
+static const GLubyte bits211[] = {
+0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x10, 0x08, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph211 = { 7, 10, 0.000000, 0.000000, 8.000000, bits211 };
+
+static const GLubyte bits212[] = {
+0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x24, 0x18, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph212 = { 7, 10, 0.000000, 0.000000, 8.000000, bits212 };
+
+static const GLubyte bits213[] = {
+0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x98, 0x64, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph213 = { 7, 10, 0.000000, 0.000000, 8.000000, bits213 };
+
+static const GLubyte bits214[] = {
+0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x44, 0x44, 0x78, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph214 = { 7, 10, 0.000000, 0.000000, 8.000000, bits214 };
+
+static const GLubyte bits215[] = {
+0x84, 0x48, 0x30, 0x30, 0x48, 0x84, 0x7c, 0x00, 0x44,
+};
+static const struct piglit_glyph glyph215 = { 6, 6, -1.000000, -1.000000, 8.000000, bits215 };
+
+static const GLubyte bits216[] = {
+0x80, 0x78, 0xc4, 0xa4, 0xa4, 0xa4, 0x94, 0x94, 0x8c, 0x78, 0x04, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph216 = { 6, 11, -1.000000, 1.000000, 8.000000, bits216 };
+
+static const GLubyte bits217[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x00, 0x20, 0x40, 0x04, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph217 = { 6, 10, -1.000000, 0.000000, 8.000000, bits217 };
+
+static const GLubyte bits218[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x00, 0x20, 0x10, 0x04, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph218 = { 6, 10, -1.000000, 0.000000, 8.000000, bits218 };
+
+static const GLubyte bits219[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x00, 0x48, 0x30, 0x04, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph219 = { 6, 10, -1.000000, 0.000000, 8.000000, bits219 };
+
+static const GLubyte bits220[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x00, 0x48, 0x48, 0x04, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph220 = { 6, 10, -1.000000, 0.000000, 8.000000, bits220 };
+
+static const GLubyte bits221[] = {
+0x20, 0x20, 0x20, 0x20, 0x50, 0x88, 0x88, 0x00, 0x20, 0x10, 0x04, 0x80, 0x80, 0x9b, 0x61,
+};
+static const struct piglit_glyph glyph221 = { 5, 10, -1.000000, 0.000000, 8.000000, bits221 };
+
+static const GLubyte bits222[] = {
+0x80, 0x80, 0x80, 0xf8, 0x84, 0x84, 0x84, 0xf8, 0x80, 0x10, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph222 = { 6, 9, -1.000000, 0.000000, 8.000000, bits222 };
+
+static const GLubyte bits223[] = {
+0xb8, 0x84, 0x84, 0x98, 0xa0, 0x90, 0x88, 0x88, 0x70, 0x10, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph223 = { 6, 9, -1.000000, 0.000000, 8.000000, bits223 };
+
+static const GLubyte bits224[] = {
+0x74, 0x8c, 0x84, 0x7c, 0x04, 0x78, 0x00, 0x10, 0x20, 0x10, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph224 = { 6, 9, -1.000000, 0.000000, 8.000000, bits224 };
+
+static const GLubyte bits225[] = {
+0x74, 0x8c, 0x84, 0x7c, 0x04, 0x78, 0x00, 0x10, 0x08, 0x10, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph225 = { 6, 9, -1.000000, 0.000000, 8.000000, bits225 };
+
+static const GLubyte bits226[] = {
+0x74, 0x8c, 0x84, 0x7c, 0x04, 0x78, 0x00, 0x48, 0x30, 0x10, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph226 = { 6, 9, -1.000000, 0.000000, 8.000000, bits226 };
+
+static const GLubyte bits227[] = {
+0x74, 0x8c, 0x84, 0x7c, 0x04, 0x78, 0x00, 0x98, 0x64, 0x10, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph227 = { 6, 9, -1.000000, 0.000000, 8.000000, bits227 };
+
+static const GLubyte bits228[] = {
+0x74, 0x8c, 0x84, 0x7c, 0x04, 0x78, 0x00, 0x48, 0x48, 0x10, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph228 = { 6, 9, -1.000000, 0.000000, 8.000000, bits228 };
+
+static const GLubyte bits229[] = {
+0x74, 0x8c, 0x84, 0x7c, 0x04, 0x78, 0x00, 0x30, 0x48, 0x30, 0x04, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph229 = { 6, 10, -1.000000, 0.000000, 8.000000, bits229 };
+
+static const GLubyte bits230[] = {
+0x6c, 0x92, 0x90, 0x7c, 0x12, 0x6c, 0x00, 0x30, 0x48, 0x30,
+};
+static const struct piglit_glyph glyph230 = { 7, 6, 0.000000, 0.000000, 8.000000, bits230 };
+
+static const GLubyte bits231[] = {
+0x20, 0x10, 0x78, 0x84, 0x80, 0x80, 0x84, 0x78, 0x48, 0x30, 0x04, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph231 = { 6, 8, -1.000000, 2.000000, 8.000000, bits231 };
+
+static const GLubyte bits232[] = {
+0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x00, 0x10, 0x20, 0x30, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph232 = { 6, 9, -1.000000, 0.000000, 8.000000, bits232 };
+
+static const GLubyte bits233[] = {
+0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x00, 0x20, 0x10, 0x30, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph233 = { 6, 9, -1.000000, 0.000000, 8.000000, bits233 };
+
+static const GLubyte bits234[] = {
+0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x00, 0x48, 0x30, 0x30, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph234 = { 6, 9, -1.000000, 0.000000, 8.000000, bits234 };
+
+static const GLubyte bits235[] = {
+0x78, 0x84, 0x80, 0xfc, 0x84, 0x78, 0x00, 0x48, 0x48, 0x30, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph235 = { 6, 9, -1.000000, 0.000000, 8.000000, bits235 };
+
+static const GLubyte bits236[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x00, 0x20, 0x40, 0x30, 0x04, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph236 = { 5, 9, -1.000000, 0.000000, 8.000000, bits236 };
+
+static const GLubyte bits237[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x00, 0x40, 0x20, 0x30, 0x04, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph237 = { 5, 9, -1.000000, 0.000000, 8.000000, bits237 };
+
+static const GLubyte bits238[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x00, 0x90, 0x60, 0x30, 0x04, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph238 = { 5, 9, -1.000000, 0.000000, 8.000000, bits238 };
+
+static const GLubyte bits239[] = {
+0xf8, 0x20, 0x20, 0x20, 0x20, 0x60, 0x00, 0x90, 0x90, 0x30, 0x04, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph239 = { 5, 9, -1.000000, 0.000000, 8.000000, bits239 };
+
+static const GLubyte bits240[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x08, 0x50, 0x30, 0x48, 0x04, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph240 = { 6, 10, -1.000000, 0.000000, 8.000000, bits240 };
+
+static const GLubyte bits241[] = {
+0x84, 0x84, 0x84, 0x84, 0xc4, 0xb8, 0x00, 0x98, 0x64, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph241 = { 6, 9, -1.000000, 0.000000, 8.000000, bits241 };
+
+static const GLubyte bits242[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x00, 0x20, 0x40, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph242 = { 6, 9, -1.000000, 0.000000, 8.000000, bits242 };
+
+static const GLubyte bits243[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x00, 0x20, 0x10, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph243 = { 6, 9, -1.000000, 0.000000, 8.000000, bits243 };
+
+static const GLubyte bits244[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x00, 0x48, 0x30, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph244 = { 6, 9, -1.000000, 0.000000, 8.000000, bits244 };
+
+static const GLubyte bits245[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x00, 0x98, 0x64, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph245 = { 6, 9, -1.000000, 0.000000, 8.000000, bits245 };
+
+static const GLubyte bits246[] = {
+0x78, 0x84, 0x84, 0x84, 0x84, 0x78, 0x00, 0x48, 0x48, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph246 = { 6, 9, -1.000000, 0.000000, 8.000000, bits246 };
+
+static const GLubyte bits247[] = {
+0x20, 0x20, 0x00, 0xf8, 0x00, 0x20, 0x20, 0x48, 0x48, 0x48,
+};
+static const struct piglit_glyph glyph247 = { 5, 7, -1.000000, -1.000000, 8.000000, bits247 };
+
+static const GLubyte bits248[] = {
+0x80, 0x78, 0xc4, 0xa4, 0x94, 0x8c, 0x78, 0x04, 0x48, 0x48, 0x04, 0x80, 0x80,
+};
+static const struct piglit_glyph glyph248 = { 6, 8, -1.000000, 1.000000, 8.000000, bits248 };
+
+static const GLubyte bits249[] = {
+0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x20, 0x40, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph249 = { 6, 9, -1.000000, 0.000000, 8.000000, bits249 };
+
+static const GLubyte bits250[] = {
+0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x20, 0x10, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph250 = { 6, 9, -1.000000, 0.000000, 8.000000, bits250 };
+
+static const GLubyte bits251[] = {
+0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x48, 0x30, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph251 = { 6, 9, -1.000000, 0.000000, 8.000000, bits251 };
+
+static const GLubyte bits252[] = {
+0x74, 0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x50, 0x50, 0x48, 0x04, 0x80, 0x80, 0x9b,
+};
+static const struct piglit_glyph glyph252 = { 6, 9, -1.000000, 0.000000, 8.000000, bits252 };
+
+static const GLubyte bits253[] = {
+0x78, 0x84, 0x04, 0x74, 0x8c, 0x84, 0x84, 0x84, 0x00, 0x20, 0x10, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph253 = { 6, 11, -1.000000, 2.000000, 8.000000, bits253 };
+
+static const GLubyte bits254[] = {
+0x80, 0x80, 0xb8, 0xc4, 0x84, 0x84, 0xc4, 0xb8, 0x80, 0x80, 0x10, 0x80, 0x80, 0x9b, 0x61, 0x09,
+};
+static const struct piglit_glyph glyph254 = { 6, 10, -1.000000, 2.000000, 8.000000, bits254 };
+
+static const GLubyte bits255[] = {
+0x78, 0x84, 0x04, 0x74, 0x8c, 0x84, 0x84, 0x84, 0x00, 0x48, 0x48, 0x80, 0x80, 0x9b, 0x61, 0x09, 0x18,
+};
+static const struct piglit_glyph glyph255 = { 6, 11, -1.000000, 2.000000, 8.000000, bits255 };
+
+
+const struct piglit_glyph *piglit_font[] = {
+ &glyph0,
+ &glyph1,
+ &glyph2,
+ &glyph3,
+ &glyph4,
+ &glyph5,
+ &glyph6,
+ &glyph7,
+ &glyph8,
+ &glyph9,
+ &glyph10,
+ &glyph11,
+ &glyph12,
+ &glyph13,
+ &glyph14,
+ &glyph15,
+ &glyph16,
+ &glyph17,
+ &glyph18,
+ &glyph19,
+ &glyph20,
+ &glyph21,
+ &glyph22,
+ &glyph23,
+ &glyph24,
+ &glyph25,
+ &glyph26,
+ &glyph27,
+ &glyph28,
+ &glyph29,
+ &glyph30,
+ &glyph31,
+ &glyph32,
+ &glyph33,
+ &glyph34,
+ &glyph35,
+ &glyph36,
+ &glyph37,
+ &glyph38,
+ &glyph39,
+ &glyph40,
+ &glyph41,
+ &glyph42,
+ &glyph43,
+ &glyph44,
+ &glyph45,
+ &glyph46,
+ &glyph47,
+ &glyph48,
+ &glyph49,
+ &glyph50,
+ &glyph51,
+ &glyph52,
+ &glyph53,
+ &glyph54,
+ &glyph55,
+ &glyph56,
+ &glyph57,
+ &glyph58,
+ &glyph59,
+ &glyph60,
+ &glyph61,
+ &glyph62,
+ &glyph63,
+ &glyph64,
+ &glyph65,
+ &glyph66,
+ &glyph67,
+ &glyph68,
+ &glyph69,
+ &glyph70,
+ &glyph71,
+ &glyph72,
+ &glyph73,
+ &glyph74,
+ &glyph75,
+ &glyph76,
+ &glyph77,
+ &glyph78,
+ &glyph79,
+ &glyph80,
+ &glyph81,
+ &glyph82,
+ &glyph83,
+ &glyph84,
+ &glyph85,
+ &glyph86,
+ &glyph87,
+ &glyph88,
+ &glyph89,
+ &glyph90,
+ &glyph91,
+ &glyph92,
+ &glyph93,
+ &glyph94,
+ &glyph95,
+ &glyph96,
+ &glyph97,
+ &glyph98,
+ &glyph99,
+ &glyph100,
+ &glyph101,
+ &glyph102,
+ &glyph103,
+ &glyph104,
+ &glyph105,
+ &glyph106,
+ &glyph107,
+ &glyph108,
+ &glyph109,
+ &glyph110,
+ &glyph111,
+ &glyph112,
+ &glyph113,
+ &glyph114,
+ &glyph115,
+ &glyph116,
+ &glyph117,
+ &glyph118,
+ &glyph119,
+ &glyph120,
+ &glyph121,
+ &glyph122,
+ &glyph123,
+ &glyph124,
+ &glyph125,
+ &glyph126,
+ &glyph127,
+ &glyph128,
+ &glyph129,
+ &glyph130,
+ &glyph131,
+ &glyph132,
+ &glyph133,
+ &glyph134,
+ &glyph135,
+ &glyph136,
+ &glyph137,
+ &glyph138,
+ &glyph139,
+ &glyph140,
+ &glyph141,
+ &glyph142,
+ &glyph143,
+ &glyph144,
+ &glyph145,
+ &glyph146,
+ &glyph147,
+ &glyph148,
+ &glyph149,
+ &glyph150,
+ &glyph151,
+ &glyph152,
+ &glyph153,
+ &glyph154,
+ &glyph155,
+ &glyph156,
+ &glyph157,
+ &glyph158,
+ &glyph159,
+ &glyph160,
+ &glyph161,
+ &glyph162,
+ &glyph163,
+ &glyph164,
+ &glyph165,
+ &glyph166,
+ &glyph167,
+ &glyph168,
+ &glyph169,
+ &glyph170,
+ &glyph171,
+ &glyph172,
+ &glyph173,
+ &glyph174,
+ &glyph175,
+ &glyph176,
+ &glyph177,
+ &glyph178,
+ &glyph179,
+ &glyph180,
+ &glyph181,
+ &glyph182,
+ &glyph183,
+ &glyph184,
+ &glyph185,
+ &glyph186,
+ &glyph187,
+ &glyph188,
+ &glyph189,
+ &glyph190,
+ &glyph191,
+ &glyph192,
+ &glyph193,
+ &glyph194,
+ &glyph195,
+ &glyph196,
+ &glyph197,
+ &glyph198,
+ &glyph199,
+ &glyph200,
+ &glyph201,
+ &glyph202,
+ &glyph203,
+ &glyph204,
+ &glyph205,
+ &glyph206,
+ &glyph207,
+ &glyph208,
+ &glyph209,
+ &glyph210,
+ &glyph211,
+ &glyph212,
+ &glyph213,
+ &glyph214,
+ &glyph215,
+ &glyph216,
+ &glyph217,
+ &glyph218,
+ &glyph219,
+ &glyph220,
+ &glyph221,
+ &glyph222,
+ &glyph223,
+ &glyph224,
+ &glyph225,
+ &glyph226,
+ &glyph227,
+ &glyph228,
+ &glyph229,
+ &glyph230,
+ &glyph231,
+ &glyph232,
+ &glyph233,
+ &glyph234,
+ &glyph235,
+ &glyph236,
+ &glyph237,
+ &glyph238,
+ &glyph239,
+ &glyph240,
+ &glyph241,
+ &glyph242,
+ &glyph243,
+ &glyph244,
+ &glyph245,
+ &glyph246,
+ &glyph247,
+ &glyph248,
+ &glyph249,
+ &glyph250,
+ &glyph251,
+ &glyph252,
+ &glyph253,
+ &glyph254,
+};
+
diff --git a/tests/util/piglit-font.c b/tests/util/piglit-font.c
new file mode 100644
index 0000000..12acfd4
--- /dev/null
+++ b/tests/util/piglit-font.c
@@ -0,0 +1,46 @@
+
+#include "piglit-font.h"
+
+
+/**
+ * Draw a bitmap string.
+ * XXX we should also have a version of this function which does
+ * not rely on glBitmap (for ES, GL core, etc).
+ */
+void
+piglit_draw_string(const char *s)
+{
+ GLint swapbytes, lsbfirst, rowlength;
+ GLint skiprows, skippixels, alignment;
+
+ /* Save pixel packing params */
+ glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes);
+ glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst);
+ glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength);
+ glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows);
+ glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels);
+ glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
+
+ /* Set params we need */
+ glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
+ glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+ glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+ glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+ while (*s) {
+ const struct piglit_glyph *g = piglit_font[*s - piglit_font_first_char];
+ glBitmap(g->width, g->height, g->xorig, g->yorig,
+ g->advance, 0, g->bitmap);
+ s++;
+ }
+
+ /* Restore pixel packing params */
+ glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
+ glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
+ glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
+ glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
+}
diff --git a/tests/util/piglit-font.h b/tests/util/piglit-font.h
new file mode 100644
index 0000000..b970640
--- /dev/null
+++ b/tests/util/piglit-font.h
@@ -0,0 +1,25 @@
+
+
+#ifndef PIGLIT_FONT_H
+#define PIGLIT_FONT_H
+
+#include <GL/gl.h>
+
+
+struct piglit_glyph {
+ int width;
+ int height;
+ int xorig;
+ int yorig;
+ int advance;
+ const GLubyte *bitmap;
+};
+
+extern int piglit_font_first_char;
+extern const struct piglit_glyph *piglit_font[];
+
+void
+piglit_draw_string(const char *s);
+
+
+#endif /* PIGLIT_FONT_H */
--
1.7.4.1
More information about the Piglit
mailing list