March 4, 2021
Hot Topics:

Working with SVGAlib Fonts

  • By Jay Link
  • Send Email »
  • More Articles »

SuperVGA Graphics Library -- SVGAlib for short -- is a low level graphics library for Linux that eliminates having to delve into the complexities of the X Windows system. One aspect of SVGAlib that frequently baffles programmers, however, is the use of fonts. Many coders find themselves with more questions than answers on the subject. How are SVGAlib fonts created? How are they displayed? Several programs (such as the Linux game Sasteroids) clearly use lettering on the screen, yet there's no obvious explanation given. You won't find any tutorials regarding SVGAlib fonts on the Net, nor will you find any mention of fonts in the standard FAQs. It almost seems like there's been a deliberate omission -- a veritable conspiracy of silence.

This article aims to give you all the basic information you need to program SVGAlib fonts, from manipulating existing character sets to creating new ones. You'll learn where to download some good typefaces (hint: www.svgalib.org), and how to use a new external library to display TrueType fonts -- the visually superior, cross-platform standard. But let's start at the beginning, by considering some basics about fonts.

Types of Fonts

It's important to know that there are two types of fonts available: bitmapped and scalable. These two font types are nearly identical in concept to the bitmapped and vectored graphic files commonly available. A bitmapped font (the simpler of the two) is like a BMP or GIF image. It's stored as a matrix (or grid) of pixel values, and is displayed exactly as it's written -- no interpretation is involved. It's a perfect copy, but as a result, it can't be resized without a significant loss of quality. See the diagram below for an example.

Figure 1: Bitmapped Font
Figure 1: Bitmapped Font

A scalable font, on the other hand, is stored in the same manner as a vectored graphic. Rather than being mapped pixel by pixel, a scalable font's "stylistic information" is saved in its data file. This information includes the angles of each character's curves, and how they're proportioned. Because no actual picture exists, it's up to the program that reads in the font to construct it for display. This adds some processing overhead, but the end result is well worth it. Scalable fonts can be resized without losing any quality, and often have smooth (or antialiased) edges. Now, have a look at the next diagram for an example of a scalable font. It's quite nice, isn't it? This is Arial, a TrueType font.

Figure 2: Scalable Font
Figure 2: Scalable Font

Unfortunately, SVGAlib is only capable of displaying bitmapped fonts. (However, we can get around that later by using another library). The good news is that the code is fairly simple. To use it, you'll have to employ SVGAlib's sister library: vgagl.

Here's how you prepare a bitmapped font for use, using gl_font8x8:

void *font = malloc(256 * FONT_WIDTH * FONT_HEIGHT * BYTESPERPIXEL);
gl_expandfont(FONT_WIDTH, FONT_HEIGHT, COLOR, gl_font8x8, font);
gl_setfont(FONT_WIDTH, FONT_HEIGHT, font);
This loads SVGAlib's one internal font, gl_font8x8, into memory. The "8x8" means that each character in the font is eight pixels high by eight pixels across. That means you'll need to define
<font color="0000EE">FONT_HEIGHT</font>
<font color="0000EE">FONT_WIDTH</font>
as being 8.
<font color="0000EE">COLOR</font>
can be any color value, as long as it's within the parameters of your chosen screen mode. Finally,
<font color="0000EE">BYTESPERPIXEL</font>
is defined in vgagl.h.

The next step is to actually display your words on the screen. This is accomplished with gl_write():

gl_write(10, 10, "Hello, world.");

The first two arguments (10 and 10) place the words on the screen -- they refer to the x and y corrdinates of the upper left-hand corner of the first character.

Here's a complete program, using the four commands you just learned:

#include <stdlib.h>
#include <vga.h>
#include <vgagl.h>

#define FONT_HEIGHT 8
#define FONT_WIDTH 8

void prepare_font(void);

int main(void)
int x = 10,
y = 10;

char text[] = "Hello, world!";


gl_write(x, y, text);



return 0;

void prepare_font(void)
int color = 15; /* white */

void *font = malloc(256 * FONT_WIDTH * FONT_HEIGHT * BYTESPERPIXEL);
gl_expandfont(FONT_WIDTH, FONT_HEIGHT, color, gl_font8x8, font);
gl_setfont(FONT_WIDTH, FONT_HEIGHT, font);

Upon running this program, you should see the words "Hello, world!" displayed in white at the top of the screen. Hooray! You've done it. Feel free to play around -- for example, try varying the placement of your text by providing different x and y values to gl_write().

It's worth noting that gl_writen(int x, int y, int n, char *s) is identical to gl_write(), except that it only displays the first "n" characters of your string.

Should you choose to include your string directly in gl_write() or gl_writen(), you'll have to terminate it with "\0" like so:

gl_write(10, 10, "Hello, World!\0");

If you don't, you won't see any results.

Bitmapped Fonts

After you've experimented with gl_font8x8, you'll probably want to try your hand with some other character sets. This, too, is easy. Other fonts are simply stored as "char" arrays, and look like this:
unsigned char font01[2048] =


(I went ahead and eliminated some of the lines for brevity). A full font array will have information for 256 characters. Each character contained in an 8 x 8 font is comprised of eight numbers, which means that a complete 8 x 8 font has 2048 numeric values (256 * 8 = 2048).

To use a "char" font, simply substitute "gl_font8x8" with the name of your char array, like so:

gl_expandfont(WIDTH, HEIGHT, color, font01, font);

You can find this font, and more, at the official SVGAlib website: www.svgalib.org

Page 1 of 2

This article was originally published on January 13, 2000

Enterprise Development Update

Don't miss an article. Subscribe to our newsletter below.

Thanks for your registration, follow us on our social networks to keep up-to-date