luke
/
magic
mirror of https://github.com/RTimothyEdwards/magic.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
magic/graphics/grOGL3.c

850 lines
22 KiB
C
Raw Blame History

/* grOGL3.c -
*
* *********************************************************************
* * Copyright (C) 1985, 1990 Regents of the University of California. *
* * Permission to use, copy, modify, and distribute this *
* * software and its documentation for any purpose and without *
* * fee is hereby granted, provided that the above copyright *
* * notice appear in all copies. The University of California *
* * makes no representations about the suitability of this *
* * software for any purpose. It is provided "as is" without *
* * express or implied warranty. Export of this software outside *
* * of the United States of America may require an export license. *
* *********************************************************************
*
* This file contains additional functions to manipulate an X window system
* color display. Included here are device-dependent routines to draw and
* erase text and draw a grid.
*
*/
#include <stdio.h>
#include <string.h>
#include <GL/gl.h>
#include <GL/glx.h>
#include <GL/glu.h>
#include "utils/magic.h"
#include "utils/geometry.h"
#include "graphics/graphics.h"
#include "windows/windows.h"
#include "graphics/graphicsInt.h"
#include "textio/textio.h"
#include "utils/signals.h"
#include "utils/utils.h"
#include "utils/hash.h"
#include "dbwind/dbwind.h"
#include "database/fonts.h"
#include "grOGLInt.h"
/* C99 compat */
#include "utils/malloc.h"
extern Display *grXdpy;
static XFontStruct *grXFonts[4];
#define grSmallFont grXFonts[0]
#define grMediumFont grXFonts[1]
#define grLargeFont grXFonts[2]
#define grXLargeFont grXFonts[3]
GLuint grXBases[4];
/*---------------------------------------------------------
* groglDrawGrid:
* groglDrawGrid adds a grid to the grid layer, using the current
* write mask and color.
*
* Results:
* TRUE is returned normally. However, if the grid gets too small
* to be useful, then nothing is drawn and FALSE is returned.
*
* Side Effects: None.
*---------------------------------------------------------
*/
bool
groglDrawGrid (prect, outline, clip)
Rect *prect; /* A rectangle that forms the template
* for the grid. Note: in order to maintain
* precision for the grid, the rectangle
* coordinates are specified in units of
* screen coordinates multiplied by SUBPIXEL.
*/
int outline; /* the outline style */
Rect *clip; /* a clipping rectangle */
{
int xsize, ysize;
int x, y;
int xstart, ystart;
int snum, low, hi, shifted;
xsize = prect->r_xtop - prect->r_xbot;
ysize = prect->r_ytop - prect->r_ybot;
if (!xsize || !ysize)
return FALSE;
if (GRID_TOO_SMALL(xsize, ysize))
return FALSE;
xstart = prect->r_xbot % xsize;
while (xstart < clip->r_xbot << SUBPIXELBITS) xstart += xsize;
ystart = prect->r_ybot % ysize;
while (ystart < clip->r_ybot << SUBPIXELBITS) ystart += ysize;
groglSetLineStyle(outline);
glBegin(GL_LINES);
snum = 0;
low = clip->r_ybot;
hi = clip->r_ytop;
for (x = xstart; x < (clip->r_xtop + 1) << SUBPIXELBITS; x += xsize)
{
shifted = x >> SUBPIXELBITS;
glVertex2i(shifted, low);
glVertex2i(shifted, hi);
snum++;
}
snum = 0;
low = clip->r_xbot;
hi = clip->r_xtop;
for (y = ystart; y < (clip->r_ytop + 1) << SUBPIXELBITS; y += ysize)
{
shifted = y >> SUBPIXELBITS;
glVertex2i(low, shifted);
glVertex2i(hi, shifted);
snum++;
}
glEnd();
return TRUE;
}
/*---------------------------------------------------------
* groglPreLoadFont
* This local routine loads the X fonts used by Magic.
* At this time, we need the font information to size
* the window (making room for the title at the top),
* but with no rendering context set (no window to
* draw to) we defer transferring the font bitmaps to
* OpenGL display lists until later.
*
* Results: Success/Fail
*
* Side Effects: None.
*---------------------------------------------------------
*/
bool
groglPreLoadFont()
{
XFontStruct *fontInfo;
int i;
char *s;
char *unable = "Unable to load font";
static char *fontnames[4] = {
X_FONT_SMALL,
X_FONT_MEDIUM,
X_FONT_LARGE,
X_FONT_XLARGE };
static char *optionnames[4] = {
"small",
"medium",
"large",
"xlarge"};
for (i = 0; i < 4; i++) {
s = XGetDefault(grXdpy,"magic",optionnames[i]);
if (s) fontnames[i] = s;
if ((fontInfo = XLoadQueryFont(grXdpy, fontnames[i])) == NULL) {
TxError("%s %s\n",unable,fontnames[i]);
if ((grXFonts[i]= XLoadQueryFont(grXdpy,GR_DEFAULT_FONT))==NULL) {
TxError("%s %s\n",unable,GR_DEFAULT_FONT);
return FALSE;
}
}
grXFonts[i] = fontInfo;
}
return TRUE;
}
/*---------------------------------------------------------
* groglLoadFont
* This local routine transfers the X font bitmaps
* into OpenGL display lists for simple text
* rendering.
*
* Results: Success/Fail.
*
* Side Effects: None.
*---------------------------------------------------------
*/
bool
groglLoadFont()
{
XFontStruct *fontInfo;
Font id;
unsigned int first, last, i;
for (i = 0; i < 4; i++) {
fontInfo = grXFonts[i];
id = fontInfo->fid;
first = fontInfo->min_char_or_byte2;
last = fontInfo->max_char_or_byte2;
grXBases[i] = glGenLists(last+1);
if (grXBases[i] == 0) {
TxError("Out of display lists!\n");
return FALSE;
}
glXUseXFont(id, first, last-first+1, grXBases[i]+first);
}
return TRUE;
}
/*---------------------------------------------------------
* groglSetCharSize:
* This local routine sets the character size in the display,
* if necessary.
*
* Results: None.
*
* Side Effects: None.
*---------------------------------------------------------
*/
void
groglSetCharSize (size)
int size; /* Width of characters */
{
oglCurrent.fontSize = size;
switch (size) {
case GR_TEXT_DEFAULT:
case GR_TEXT_SMALL:
oglCurrent.font = grSmallFont;
break;
case GR_TEXT_MEDIUM:
oglCurrent.font = grMediumFont;
break;
case GR_TEXT_LARGE:
oglCurrent.font = grLargeFont;
break;
case GR_TEXT_XLARGE:
oglCurrent.font = grXLargeFont;
break;
default:
TxError("%s%d\n", "groglSetCharSize: Unknown character size ",
size );
break;
break;
}
}
/*
* ----------------------------------------------------------------------------
* GrOGLTextSize --
*
* Determine the size of a text string.
*
* Results:
* Returns 0 when 'r' updated, otherwise -1 on error (no side-effects).
*
* Side effects:
* A rectangle is filled in that is the size of the text in pixels.
* The origin (0, 0) of this rectangle is located on the baseline
* at the far left side of the string.
* ----------------------------------------------------------------------------
*/
int
GrOGLTextSize(text, size, r)
char *text;
int size;
Rect *r;
{
XCharStruct overall;
XFontStruct *font;
int dir,fa,fd;
switch (size) {
case GR_TEXT_DEFAULT:
case GR_TEXT_SMALL:
font = grSmallFont;
break;
case GR_TEXT_MEDIUM:
font = grMediumFont;
break;
case GR_TEXT_LARGE:
font = grLargeFont;
break;
case GR_TEXT_XLARGE:
font = grXLargeFont;
break;
default:
font = NULL;
TxError("%s%d\n", "GrOGLTextSize: Unknown character size ",
size );
break;
}
if (font == NULL) return -1;
XTextExtents(font, text, strlen(text), &dir, &fa, &fd, &overall);
r->r_ytop = overall.ascent;
r->r_ybot = -overall.descent;
r->r_xtop = overall.width - overall.lbearing;
r->r_xbot = -overall.lbearing - 1;
return 0;
}
/*
* ----------------------------------------------------------------------------
* GrOGLReadPixel --
*
* Read one pixel from the screen.
*
* Results:
* An integer containing the pixel's color.
* (Except OpenGL has no such function, so we just return 0)
*
* Side effects:
* none.
*
* ----------------------------------------------------------------------------
*/
int
GrOGLReadPixel (w, x, y)
MagWindow *w;
int x,y; /* the location of a pixel in screen coords */
{
return 0;
}
/*
* ----------------------------------------------------------------------------
* GrOGLBitBlt --
*
* Copy information from one part of the screen to the other.
*
* Results:
* None.
*
* Side effects:
* changes the screen.
* ----------------------------------------------------------------------------
*/
void
GrOGLBitBlt(r, p)
Rect *r;
Point *p;
{
glCopyPixels(r->r_xbot, r->r_ybot, r->r_xtop - r->r_xbot + 1,
r->r_ytop - r->r_ybot + 1, GL_COLOR);
}
#ifdef VECTOR_FONTS
/*
*----------------------------------------------------------------------
*
* Technically, there should be no self-intersecting polygons in outline
* fonts. However, decomposition of bezier curves into line segments
* may occasionally produce one, so it needs to be handled.
*----------------------------------------------------------------------
*/
void
myCombine(GLdouble coords[3], GLdouble *vertex_data[4],
GLfloat weight[4], GLdouble **outData, void *dataptr)
{
/* This needs to be free'd at the end of gluTessEndPolygon()! */
GLdouble *new = (GLdouble *)mallocMagic(2 * sizeof(GLdouble));
new[0] = coords[0];
new[1] = coords[1];
*outData = new;
/* Diagnostic */
TxError("Intersecting polygon in char \"%c\" at %g %g!\n",
*((char *)dataptr), coords[0], coords[1]);
}
/*
*----------------------------------------------------------------------
* Draw a text character
* This routine differs from grtoglFillPolygon() in that it uses the
* glu library to handle non-convex polygons as may appear in font
* outlines.
*----------------------------------------------------------------------
*/
void
groglDrawCharacter(clist, tc, pixsize)
FontChar *clist;
unsigned char tc;
int pixsize;
{
Point *tp;
int np, nptotal;
int i, j;
static GLUtesselator *tess = NULL;
static GLdouble *v = NULL;
static int maxnp = 0;
FontChar *ccur;
if (pixsize < 5) return; /* Label too small to be useful */
if (tess == NULL)
{
tess = gluNewTess();
gluTessCallback(tess, GLU_TESS_BEGIN, (_GLUfuncptr)glBegin);
gluTessCallback(tess, GLU_TESS_VERTEX, (_GLUfuncptr)glVertex3dv);
gluTessCallback(tess, GLU_TESS_END, (_GLUfuncptr)glEnd);
gluTessCallback(tess, GLU_TESS_COMBINE_DATA, (_GLUfuncptr)myCombine);
}
// Boundary-only does not look particularly good. . .
gluTessProperty(tess, GLU_TESS_BOUNDARY_ONLY, GL_FALSE);
nptotal = 0;
for (ccur = clist; ccur != NULL; ccur = ccur->fc_next)
nptotal += ccur->fc_numpoints;
if (nptotal > maxnp)
{
if (v != NULL) freeMagic((char *)v);
maxnp = nptotal;
v = (GLdouble *)mallocMagic(nptotal * 3 * sizeof(GLdouble));
}
j = 0;
for (ccur = clist; ccur != NULL; ccur = ccur->fc_next)
{
tp = ccur->fc_points;
np = ccur->fc_numpoints;
for (i = 0; i < np; i++, j += 3) {
v[j] = tp[i].p_x;
v[j + 1] = tp[i].p_y;
v[j + 2] = 0;
}
}
gluTessBeginPolygon(tess, (GLvoid *)(&tc));
j = 0;
for (ccur = clist; ccur != NULL; ccur = ccur->fc_next)
{
np = ccur->fc_numpoints;
gluTessBeginContour(tess);
for (i = 0; i < np; i++, j += 3) {
gluTessVertex(tess, &v[j], &v[j]);
}
gluTessEndContour(tess);
}
gluTessEndPolygon(tess);
}
/*---------------------------------------------------------
* groglFontText:
*
* This routine draws text from font vectors using the
* font vector routines in DBlabel.c. Text is clipped
* to the clipping rectangle.
*
* For speed, we should be transferring the font
* vectors into OpenGL display lists!
*
*---------------------------------------------------------
*/
void
groglFontText(text, font, size, rotate, pos, clip, obscure)
char *text; /* The text to be drawn */
int font; /* Font to use from fontList */
int size; /* Pixel size of the font */
int rotate; /* Text rotation */
Point *pos; /* Text base position */
Rect *clip; /* Clipping area */
LinkedRect *obscure; /* List of obscuring areas */
{
char *tptr;
Point *coffset; /* vector to next character */
Rect *cbbox;
GLfloat fsize, matvals[16];
FontChar *clist;
int cheight, baseline;
float tmp;
/* Keep it simple for now---ignore clip and obscure */
glDisable(GL_BLEND);
glPushMatrix();
glTranslated(pos->p_x, pos->p_y, 0);
glRotated(rotate, 0, 0, 1);
/* Get label size */
cbbox = &DBFontList[font]->mf_extents;
fsize = (GLfloat)size / (GLfloat)cbbox->r_ytop;
glScalef(fsize, fsize, 1.0);
/* Adjust to baseline */
baseline = 0;
for (tptr = text; *tptr != '\0'; tptr++)
{
DBFontChar(font, *tptr, NULL, NULL, &cbbox);
if (cbbox->r_ybot < baseline)
baseline = cbbox->r_ybot;
}
glTranslated(0, -baseline, 0);
for (tptr = text; *tptr != '\0'; tptr++)
{
DBFontChar(font, *tptr, &clist, &coffset, NULL);
groglDrawCharacter(clist, *tptr, size);
glTranslated(coffset->p_x, coffset->p_y, 0);
}
glPopMatrix();
}
#endif /* VECTOR_FONTS */
static GC grXcopyGC = (GC)NULL;
/*
* ----------------------------------------------------------------------------
* groglFreeBackingStore --
* Free up Pixmap memory for a backing store cell.
*
* Results:
* None.
*
* Side effects:
* memory Free'd
* ----------------------------------------------------------------------------
*/
void
groglFreeBackingStore(MagWindow *window)
{
Pixmap pmap = (Pixmap)window->w_backingStore;
if (pmap == (Pixmap)NULL) return;
XFreePixmap(grXdpy, pmap);
window->w_backingStore = (ClientData)NULL;
/* XFreeGC(grXdpy, grXcopyGC); */
/* TxPrintf("groglFreeBackingStore called\n"); */
}
/*
* ----------------------------------------------------------------------------
* groglCreateBackingStore --
* Create Pixmap memory for a backing store cell and copy data
* from the window into it.
*
* Results:
* None.
*
* Side effects:
* memory Allocated.
*
* ----------------------------------------------------------------------------
*/
void
groglCreateBackingStore(MagWindow *w)
{
Pixmap pmap;
Window wind = (Window)w->w_grdata;
unsigned int width, height;
GC gc;
XGCValues gcValues;
/* ignore for all windows except layout */
if (w->w_client != DBWclientID) return;
/* deferred */
if (w->w_grdata == (Window)NULL) return;
width = w->w_screenArea.r_xtop - w->w_screenArea.r_xbot;
height = w->w_screenArea.r_ytop - w->w_screenArea.r_ybot;
if (w->w_backingStore != (ClientData)NULL) groglFreeBackingStore(w);
if (grXcopyGC == (GC)NULL)
{
gcValues.graphics_exposures = FALSE;
grXcopyGC = XCreateGC(grXdpy, wind, GCGraphicsExposures, &gcValues);
}
pmap = XCreatePixmap(grXdpy, wind, width, height, oglCurrent.depth);
w->w_backingStore = (ClientData)pmap;
/* TxPrintf("groglCreateBackingStore area %d %d %d %d\n",
w->w_screenArea.r_xbot, w->w_screenArea.r_ybot,
w->w_screenArea.r_xtop, w->w_screenArea.r_ytop); */
}
/*
* ----------------------------------------------------------------------------
* groglGetBackingStore --
* Copy data from a backing store Pixmap into the indicated window.
*
* Results:
* TRUE if backing store was copied successfully, FALSE if not.
*
* Side effects:
* Data copied into Pixmap memory.
*
* ----------------------------------------------------------------------------
*/
bool
groglGetBackingStore(MagWindow *w, Rect *area)
{
Pixmap pmap;
Window wind = (Window)w->w_grdata;
unsigned int width, height;
int ybot;
int xoff, yoff;
Rect r;
pmap = (Pixmap)w->w_backingStore;
if (pmap == (Pixmap)NULL)
return FALSE;
/* Make a local copy of area so we don't disturb the original */
r = *area;
GeoClip(&r, &(w->w_screenArea));
width = r.r_xtop - r.r_xbot;
height = r.r_ytop - r.r_ybot;
ybot = glTransY(w, r.r_ytop);
xoff = w->w_screenArea.r_xbot - w->w_allArea.r_xbot;
yoff = w->w_allArea.r_ytop - w->w_screenArea.r_ytop;
XCopyArea(grXdpy, pmap, wind, grXcopyGC, r.r_xbot - xoff, ybot - yoff,
width, height, r.r_xbot, ybot);
/* TxPrintf("groglGetBackingStore %d %d %d %d\n",
r.r_xbot, r.r_ybot, r.r_xtop, r.r_ytop); */
return TRUE;
}
/*
* ----------------------------------------------------------------------------
* groglScrollBackingStore --
* Enable fast scrolling by shifting part of the backing store
* from one position to another, with the amount of shift indicated
* by the X and/or Y value of the indicated point.
*
* Results:
* TRUE on success, FALSE on failure.
*
* Side effects:
* Data shifted in Pixmap memory.
*
* ----------------------------------------------------------------------------
*/
bool
groglScrollBackingStore(MagWindow *w, Point *shift)
{
Pixmap pmap;
unsigned int width, height;
int xorigin, yorigin, xshift, yshift;
pmap = (Pixmap)w->w_backingStore;
if (pmap == (Pixmap)NULL)
{
TxPrintf("groglScrollBackingStore %d %d failure\n",
shift->p_x, shift->p_y);
return FALSE;
}
width = w->w_screenArea.r_xtop - w->w_screenArea.r_xbot;
height = w->w_screenArea.r_ytop - w->w_screenArea.r_ybot;
xorigin = 0;
yorigin = 0;
xshift = shift->p_x;
yshift = -shift->p_y;
if (xshift > 0)
width -= xshift;
else if (xshift < 0)
{
width += xshift;
xorigin = -xshift;
xshift = 0;
}
if (yshift > 0)
height -= yshift;
else if (yshift < 0)
{
height += yshift;
yorigin = -yshift;
yshift = 0;
}
XCopyArea(grXdpy, pmap, pmap, grXcopyGC, xorigin, yorigin, width, height,
xshift, yshift);
/* TxPrintf("groglScrollBackingStore %d %d\n", shift->p_x, shift->p_y); */
return TRUE;
}
/*
* ----------------------------------------------------------------------------
* groglPutBackingStore --
* Copy data from the window into backing store.
*
* Results:
* None.
*
* Side effects:
* Graphics drawing into the window.
* ----------------------------------------------------------------------------
*/
void
groglPutBackingStore(MagWindow *w, Rect *area)
{
Pixmap pmap = (Pixmap)w->w_backingStore;
Window wind = (Window)w->w_grdata;
unsigned int width, height;
int ybot, xoff, yoff;
if (pmap == (Pixmap)NULL) return;
/* Attempting to write backing store into an obscured */
/* window (which we keep track of with Visibility events) */
/* causes backing store to be invalid. */
if (w->w_flags & WIND_OBSCURED)
{
groglFreeBackingStore(w);
w->w_backingStore = (ClientData)NULL;
return;
}
width = area->r_xtop - area->r_xbot;
height = area->r_ytop - area->r_ybot;
ybot = glTransY(w, area->r_ytop);
xoff = w->w_screenArea.r_xbot - w->w_allArea.r_xbot;
yoff = w->w_allArea.r_ytop - w->w_screenArea.r_ytop;
XCopyArea(grXdpy, wind, pmap, grXcopyGC, area->r_xbot, ybot,
width, height, area->r_xbot - xoff, ybot - yoff);
/* TxPrintf("groglPutBackingStore %d %d %d %d\n",
area->r_xbot, area->r_ybot, area->r_xtop, area->r_ytop); */
}
/*---------------------------------------------------------
* groglPutText:
* (modified on SunPutText)
*
* This routine puts a chunk of text on the screen in the current
* color, size, etc. The caller must ensure that it fits on
* the screen -- no clipping is done except to the obscuring rectangle
* list and the clip rectangle.
*
* Results:
* none.
*
* Side Effects:
* The text is drawn on the screen.
*
*---------------------------------------------------------
*/
void
groglPutText (text, pos, clip, obscure)
char *text; /* The text to be drawn. */
Point *pos; /* A point located at the leftmost point of
* the baseline for this string.
*/
Rect *clip; /* A rectangle to clip against */
LinkedRect *obscure; /* A list of obscuring rectangles */
{
Rect location;
Rect overlap;
Rect textrect;
LinkedRect *ob;
void grOGLGeoSub();
int i;
float tscale;
if (GrOGLTextSize(text, oglCurrent.fontSize, &textrect) < 0)
return;
location.r_xbot = pos->p_x + textrect.r_xbot;
location.r_xtop = pos->p_x + textrect.r_xtop;
location.r_ybot = pos->p_y + textrect.r_ybot;
location.r_ytop = pos->p_y + textrect.r_ytop;
/* erase parts of the bitmap that are obscured */
for (ob = obscure; ob != NULL; ob = ob->r_next)
{
if (GEO_TOUCH(&ob->r_r, &location))
{
overlap = location;
GeoClip(&overlap, &ob->r_r);
grOGLGeoSub(&location, &overlap);
}
}
overlap = location;
GeoClip(&overlap, clip);
/* copy the text to the color screen */
if ((overlap.r_xbot < overlap.r_xtop)&&(overlap.r_ybot <= overlap.r_ytop))
{
glScissor(overlap.r_xbot, overlap.r_ybot, overlap.r_xtop - overlap.r_xbot,
overlap.r_ytop - overlap.r_ybot);
glEnable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glRasterPos2i(pos->p_x, pos->p_y);
glListBase(grXBases[(oglCurrent.fontSize == GR_TEXT_DEFAULT) ?
GR_TEXT_SMALL : oglCurrent.fontSize]);
glCallLists(strlen(text), GL_UNSIGNED_BYTE, (unsigned char *)text);
glDisable(GL_SCISSOR_TEST);
}
}
/* grOGLGeoSub:
* return the tallest sub-rectangle of r not obscured by area
* area must be within r.
*/
void
grOGLGeoSub(r, area)
Rect *r; /* Rectangle to be subtracted from. */
Rect *area; /* Area to be subtracted. */
{
if (r->r_xbot == area->r_xbot) r->r_xbot = area->r_xtop;
else
if (r->r_xtop == area->r_xtop) r->r_xtop = area->r_xbot;
else
if (r->r_ybot <= area->r_ybot) r->r_ybot = area->r_ytop;
else
if (r->r_ytop == area->r_ytop) r->r_ytop = area->r_ybot;
else
r->r_xtop = area->r_xbot;
}
Reference in New Issue View Git Blame Copy Permalink