mirror of https://gitlab.freedesktop.org/mesa/mesa
376 lines
11 KiB
C
376 lines
11 KiB
C
/*
|
|
* Mesa 3-D graphics library
|
|
*
|
|
* Copyright (C) 1999 Brian Paul All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
|
|
/* xfonts.c -- glXUseXFont() for Mesa written by
|
|
* Copyright (C) 1995 Thorsten.Ohl @ Physik.TH-Darmstadt.de
|
|
*/
|
|
|
|
/*
|
|
This was take from Mesa and modified to work in the real GLX structure.
|
|
It provides a fully client side implementation of glXUseXFont and is
|
|
called by that routine when direct rendering is enabled.
|
|
*/
|
|
|
|
#ifdef GLX_DIRECT_RENDERING
|
|
|
|
#include "glxclient.h"
|
|
|
|
/* Some debugging info. */
|
|
|
|
#ifdef DEBUG
|
|
#undef _R
|
|
#undef _G
|
|
#undef _B
|
|
#include <ctype.h>
|
|
|
|
int debug_xfonts = 0;
|
|
|
|
static void
|
|
dump_char_struct(XCharStruct * ch, char *prefix)
|
|
{
|
|
printf("%slbearing = %d, rbearing = %d, width = %d\n",
|
|
prefix, ch->lbearing, ch->rbearing, ch->width);
|
|
printf("%sascent = %d, descent = %d, attributes = %u\n",
|
|
prefix, ch->ascent, ch->descent, (unsigned int) ch->attributes);
|
|
}
|
|
|
|
static void
|
|
dump_font_struct(XFontStruct * font)
|
|
{
|
|
printf("ascent = %d, descent = %d\n", font->ascent, font->descent);
|
|
printf("char_or_byte2 = (%u,%u)\n",
|
|
font->min_char_or_byte2, font->max_char_or_byte2);
|
|
printf("byte1 = (%u,%u)\n", font->min_byte1, font->max_byte1);
|
|
printf("all_chars_exist = %s\n", font->all_chars_exist ? "True" : "False");
|
|
printf("default_char = %c (\\%03o)\n",
|
|
(char) (isprint(font->default_char) ? font->default_char : ' '),
|
|
font->default_char);
|
|
dump_char_struct(&font->min_bounds, "min> ");
|
|
dump_char_struct(&font->max_bounds, "max> ");
|
|
#if 0
|
|
for (c = font->min_char_or_byte2; c <= font->max_char_or_byte2; c++) {
|
|
char prefix[8];
|
|
sprintf(prefix, "%d> ", c);
|
|
dump_char_struct(&font->per_char[c], prefix);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void
|
|
dump_bitmap(unsigned int width, unsigned int height, GLubyte * bitmap)
|
|
{
|
|
unsigned int x, y;
|
|
|
|
printf(" ");
|
|
for (x = 0; x < 8 * width; x++)
|
|
printf("%o", 7 - (x % 8));
|
|
putchar('\n');
|
|
for (y = 0; y < height; y++) {
|
|
printf("%3o:", y);
|
|
for (x = 0; x < 8 * width; x++)
|
|
putchar((bitmap[width * (height - y - 1) + x / 8] & (1 << (7 - (x %
|
|
8))))
|
|
? '*' : '.');
|
|
printf(" ");
|
|
for (x = 0; x < width; x++)
|
|
printf("0x%02x, ", bitmap[width * (height - y - 1) + x]);
|
|
putchar('\n');
|
|
}
|
|
}
|
|
#endif /* DEBUG */
|
|
|
|
|
|
/* 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, int screen, 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, RootWindow(dpy, screen), 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, int which)
|
|
{
|
|
unsigned int rows, pages;
|
|
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);
|
|
}
|
|
|
|
_X_HIDDEN void
|
|
DRI_glXUseXFont(struct glx_context *CC, Font font, int first, int count, int listbase)
|
|
{
|
|
Display *dpy;
|
|
int screen;
|
|
Pixmap pixmap;
|
|
GC gc;
|
|
XGCValues values;
|
|
unsigned long valuemask;
|
|
XFontStruct *fs;
|
|
|
|
GLint swapbytes, lsbfirst, rowlength;
|
|
GLint skiprows, skippixels, alignment;
|
|
|
|
unsigned int max_width, max_height, max_bm_width, max_bm_height;
|
|
GLubyte *bm;
|
|
|
|
int i;
|
|
|
|
dpy = CC->currentDpy;
|
|
screen = CC->screen;
|
|
|
|
fs = XQueryFont(dpy, font);
|
|
if (!fs) {
|
|
__glXSetError(CC, GL_INVALID_VALUE);
|
|
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);
|
|
__glXSetError(CC, GL_OUT_OF_MEMORY);
|
|
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
|
|
|
|
/* 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);
|
|
|
|
pixmap = XCreatePixmap(dpy, RootWindow(dpy, screen), 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);
|
|
|
|
#ifdef DEBUG
|
|
if (debug_xfonts)
|
|
dump_font_struct(fs);
|
|
#endif
|
|
|
|
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;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (debug_xfonts) {
|
|
char s[7];
|
|
sprintf(s, isprint(c) ? "%c> " : "\\%03o> ", c);
|
|
dump_char_struct(ch, s);
|
|
}
|
|
#endif
|
|
|
|
/* glBitmap()' parameters:
|
|
straight from the glXUseXFont(3) manpage. */
|
|
width = ch->rbearing - ch->lbearing;
|
|
height = ch->ascent + ch->descent;
|
|
x0 = -ch->lbearing;
|
|
y0 = ch->descent - 1;
|
|
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;
|
|
|
|
glNewList(list, GL_COMPILE);
|
|
if (valid && (bm_width > 0) && (bm_height > 0)) {
|
|
|
|
memset(bm, '\0', bm_width * bm_height);
|
|
fill_bitmap(dpy, screen, gc, bm_width, bm_height, x, y, c, bm);
|
|
|
|
glBitmap(width, height, x0, y0, dx, dy, bm);
|
|
#ifdef DEBUG
|
|
if (debug_xfonts) {
|
|
printf("width/height = %u/%u\n", width, height);
|
|
printf("bm_width/bm_height = %u/%u\n", bm_width, bm_height);
|
|
dump_bitmap(bm_width, bm_height, bm);
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
glBitmap(0, 0, 0.0, 0.0, dx, dy, NULL);
|
|
}
|
|
glEndList();
|
|
}
|
|
|
|
free(bm);
|
|
XFreeFontInfo(NULL, fs, 1);
|
|
XFreeGC(dpy, gc);
|
|
|
|
/* 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
|