src/rt/text.c

/* Copyright (c) 1991 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  text.c - functions for text patterns and mixtures.
 *
 *     11/12/86
 */

#include  "ray.h"

#include  "otypes.h"

/*
 *      A text pattern is specified as the text (a file or line),
 *  the upper left anchor point, the right motion vector, the down
 *  motion vector, and the foreground and background brightness.
 *  For a file, the description is as follows:
 *
 *      modifier brighttext id
 *      2 fontfile textfile
 *      0
 *      11
 *              Ax Ay Az
 *              Rx Ry Rz
 *              Dx Dy Dz
 *              foreground background
 *
 *  For a single line, we use:
 *
 *      modifier brighttext id
 *      N+2 fontfile . This is a line with N words...
 *      0
 *      11
 *              Ax Ay Az
 *              Rx Ry Rz
 *              Dx Dy Dz
 *              foreground background
 *
 *  Colortext is identical, except colors are given rather than
 *  brightnesses.  Mixtext has foreground and background modifiers:
 *
 *      modifier mixtext id
 *      4+ foremod backmod fontfile text..
 *      0
 *      9
 *              Ax Ay Az
 *              Rx Ry Rz
 *              Dx Dy Dz
 */

#define  fndx(m)        ((m)->otype==MIX_TEXT ? 2 : 0)
#define  tndx(m)        ((m)->otype==MIX_TEXT ? 3 : 1)

extern char  *libpath;                  /* library search path */

typedef unsigned char  GLYPH;

typedef struct font {
        GLYPH  *fg[256];                /* font glyphs */
        char  *name;                    /* font file name */
        struct font  *next;             /* next font in list */
}  FONT;

typedef struct tline {
        struct tline  *next;            /* pointer to next line */
                                        /* followed by the string */
}  TLINE;

#define  TLSTR(l)       ((char *)((l)+1))

typedef struct {
        FVECT  right, down;             /* right and down unit vectors */
        FONT  *f;                       /* our font */
        TLINE  tl;                      /* line list */
}  TEXT;

extern char  *fgetword();

TEXT  *gettext();

TLINE  *tlalloc();

FONT  *getfont();

static FONT  *fontlist = NULL;          /* our font list */


text(m, r)
register OBJREC  *m;
RAY  *r;
{
        FVECT  v;
        int  foreground;
                                /* get transformed position */
        if (r->rox != NULL)
                multp3(v, r->rop, r->rox->b.xfm);
        else
                VCOPY(v, r->rop);
                                /* check if we are within a text glyph */
        foreground = intext(v, m);
                                /* modify */
        if (m->otype == MIX_TEXT) {
                OBJECT  omod;
                char  *modname = m->oargs.sarg[foreground ? 0 : 1];
                if (!strcmp(modname, VOIDID))
                        omod = OVOID;
                else if ((omod = modifier(modname)) == OVOID) {
                        sprintf(errmsg, "undefined modifier \"%s\"", modname);
                        objerror(m, USER, errmsg);
                }
                raytexture(r, omod);
        } else if (m->otype == PAT_BTEXT) {
                if (foreground)
                        scalecolor(r->pcol, m->oargs.farg[9]);
                else
                        scalecolor(r->pcol, m->oargs.farg[10]);
        } else { /* PAT_CTEXT */
                COLOR  cval;
                if (foreground)
                        setcolor(cval, m->oargs.farg[9],
                                        m->oargs.farg[10],
                                        m->oargs.farg[11]);
                else
                        setcolor(cval, m->oargs.farg[12],
                                        m->oargs.farg[13],
                                        m->oargs.farg[14]);
                multcolor(r->pcol, cval);
        }
}


TLINE *
tlalloc(s)                      /* allocate and assign text line */
char  *s;
{
        extern char  *strcpy();
        register TLINE  *tl;

        tl = (TLINE *)malloc(sizeof(TLINE)+1+strlen(s));
        if (tl == NULL)
                error(SYSTEM, "out of memory in tlalloc");
        tl->next = NULL;
        strcpy(TLSTR(tl), s);
        return(tl);
}


TEXT *
gettext(tm)                     /* get text structure for material */
register OBJREC  *tm;
{
#define  R      (tm->oargs.farg+3)
#define  D      (tm->oargs.farg+6)
        extern char  *strcpy(), *fgets();
        FVECT  DxR;
        double  d;
        FILE  *fp;
        char  linbuf[512];
        TEXT  *t;
        register int  i;
        register TLINE  *tlp;
        register char  *s;

        if ((t = (TEXT *)tm->os) != NULL)
                return(t);
                                                /* check arguments */
        if (tm->oargs.nsargs - tndx(tm) < 1 ||
                        tm->oargs.nfargs != (tm->otype == PAT_BTEXT ? 11 :
                                        tm->otype == PAT_CTEXT ? 15 : 9))
                objerror(tm, USER, "bad # arguments");
        if ((t = (TEXT *)malloc(sizeof(TEXT))) == NULL)
                error(SYSTEM, "out of memory in gettext");
                                                /* compute vectors */
        fcross(DxR, D, R);
        fcross(t->right, DxR, D);
        d = DOT(D,D)/DOT(t->right,t->right);
        for (i = 0; i < 3; i++)
                t->right[i] *= d;
        fcross(t->down, R, DxR);
        d = DOT(R,R)/DOT(t->down,t->down);
        for (i = 0; i < 3; i++)
                t->down[i] *= d;
                                                /* get text */
        tlp = &t->tl;
        if (tm->oargs.nsargs - tndx(tm) > 1) {  /* single line */
                s = linbuf;
                for (i = tndx(tm)+1; i < tm->oargs.nsargs; i++) {
                        strcpy(s, tm->oargs.sarg[i]);
                        s += strlen(s);
                        *s++ = ' ';
                }
                *--s = '\0';
                tlp->next = tlalloc(linbuf);
                tlp = tlp->next;
        } else {                                /* text file */
                if ((s = getpath(tm->oargs.sarg[tndx(tm)],
                                libpath, R_OK)) == NULL) {
                        sprintf(errmsg, "cannot find text file \"%s\"",
                                        tm->oargs.sarg[tndx(tm)]);
                        error(USER, errmsg);
                }
                if ((fp = fopen(s, "r")) == NULL) {
                        sprintf(errmsg, "cannot open text file \"%s\"",
                                        s);
                        error(SYSTEM, errmsg);
                }
                while (fgets(linbuf, sizeof(linbuf), fp) != NULL) {
                        s = linbuf + strlen(linbuf) - 1;
                        if (*s == '\n')
                                *s = '\0';
                        tlp->next = tlalloc(linbuf);
                        tlp = tlp->next;
                }
                fclose(fp);
        }
        tlp->next = NULL;
                                                /* get the font */
        t->f = getfont(tm->oargs.sarg[fndx(tm)]);
                                                /* we're done */
        tm->os = (char *)t;
        return(t);
#undef  R
#undef  D
}


freetext(m)                     /* free text structures associated with m */
OBJREC  *m;
{
        register TEXT  *tp;
        register TLINE  *tlp;

        tp = (TEXT *)m->os;
        if (tp == NULL)
                return;
        for (tlp = tp->tl.next; tlp != NULL; tlp = tlp->next);
                free((char *)tlp);
        free((char *)tp);
        m->os = NULL;
}


intext(p, m)                    /* check to see if p is in text glyph */
FVECT  p;
OBJREC  *m;
{
        register TEXT  *tp;
        register TLINE  *tlp;
        FVECT  v;
        double  y, x;
        int  col;
        register int  lno;
                                /* first, compute position in text */
        tp = gettext(m);
        v[0] = p[0] - m->oargs.farg[0];
        v[1] = p[1] - m->oargs.farg[1];
        v[2] = p[2] - m->oargs.farg[2];
        col = x = DOT(v, tp->right);
        lno = y = DOT(v, tp->down);
        if (x < 0.0 || y < 0.0)
                return(0);
        x -= (double)col;
        y = (lno+1) - y;
                                /* get the font character */
        for (tlp = tp->tl.next; tlp != NULL; tlp = tlp->next)
                if (--lno < 0)
                        break;
        if (tlp == NULL || col >= strlen(TLSTR(tlp)))
                return(0);
        return(inglyph(x, y, tp->f->fg[TLSTR(tlp)[col]]));
}


FONT *
getfont(fname)                          /* return font fname */
char  *fname;
{
        char  buf[16];
        FILE  *fp;
        char  *pathname, *err;
        int  gn, ngv, gv;
        register GLYPH  *g;
        register FONT  *f;

        for (f = fontlist; f != NULL; f = f->next)
                if (!strcmp(f->name, fname))
                        return(f);
                                                /* load the font file */
        if ((pathname = getpath(fname, libpath, R_OK)) == NULL) {
                sprintf(errmsg, "cannot find font file \"%s\"", fname);
                error(USER, errmsg);
        }
        f = (FONT *)calloc(1, sizeof(FONT));
        if (f == NULL)
                goto memerr;
        f->name = savestr(fname);
        if ((fp = fopen(pathname, "r")) == NULL) {
                sprintf(errmsg, "cannot open font file \"%s\"",
                                pathname);
                error(SYSTEM, errmsg);
        }
        while (fgetword(buf,sizeof(buf),fp) != NULL) {  /* get each glyph */
                if (!isint(buf))
                        goto nonint;
                gn = atoi(buf);
                if (gn < 0 || gn > 255) {
                        err = "illegal";
                        goto fonterr;
                }
                if (f->fg[gn] != NULL) {
                        err = "duplicate";
                        goto fonterr;
                }
                if (fgetword(buf,sizeof(buf),fp) == NULL || !isint(buf) ||
                                (ngv = atoi(buf)) < 0 || ngv > 255) {
                        err = "bad # vertices for";
                        goto fonterr;
                }
                g = (GLYPH *)malloc((2*ngv+1)*sizeof(GLYPH));
                if (g == NULL)
                        goto memerr;
                f->fg[gn] = g;
                *g++ = ngv;
                ngv *= 2;
                while (ngv--) {
                        if (fgetword(buf,sizeof(buf),fp) == NULL ||
                                        !isint(buf) ||
                                        (gv = atoi(buf)) < 0 || gv > 255) {
                                err = "bad vertex for";
                                goto fonterr;
                        }
                        *g++ = gv;
                }
        }
        fclose(fp);
        f->next = fontlist;
        return(fontlist = f);
nonint:
        sprintf(errmsg, "non-integer in font file \"%s\"", pathname);
        error(USER, errmsg);
fonterr:
        sprintf(errmsg, "%s character (%d) in font file \"%s\"",
                        err, gn, pathname);
        error(USER, errmsg);
memerr:
        error(SYSTEM, "out of memory in fontglyph");
}


inglyph(x, y, gl)               /* (x,y) within font glyph gl? */
double  x, y;
GLYPH  *gl;
{
        int  n, ncross;
        int  xlb, ylb;
        register GLYPH  *p0, *p1;

        if (gl == NULL)
                return(0);
        x *= 256.0;                     /* get glyph coordinates */
        y *= 256.0;
        xlb = x + 0.5;
        ylb = y + 0.5;
        n = *gl++;                      /* get # of vertices */
        p0 = gl + 2*(n-1);              /* connect last to first */
        p1 = gl;
        ncross = 0;
                                        /* positive x axis cross test */
        while (n--) {
                if ((p0[1] > ylb) ^ (p1[1] > ylb))
                        if (p0[0] > xlb && p1[0] > xlb)
                                ncross++;
                        else if (p0[0] > xlb || p1[0] > xlb)
                                ncross += (p1[1] > p0[1]) ^
                                                ((p0[1]-y)*(p1[0]-x) >
                                                (p0[0]-x)*(p1[1]-y));
                p0 = p1;
                p1 += 2;
        }
        return(ncross & 01);
}
Revision:	2.1
Committed:	Tue Nov 12 17:10:02 1991 UTC (32 years, 5 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.10:	+0 -0 lines
Log Message:	updated revision number for release 2.0
#	User	Rev	Content
1	greg	1.7	/* Copyright (c) 1991 Regents of the University of California */
2	greg	1.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* text.c - functions for text patterns and mixtures.
9			*
10			* 11/12/86
11			*/
12
13			#include "ray.h"
14
15			#include "otypes.h"
16
17			/*
18			* A text pattern is specified as the text (a file or line),
19			* the upper left anchor point, the right motion vector, the down
20			* motion vector, and the foreground and background brightness.
21			* For a file, the description is as follows:
22			*
23			* modifier brighttext id
24			* 2 fontfile textfile
25			* 0
26			* 11
27			* Ax Ay Az
28			* Rx Ry Rz
29			* Dx Dy Dz
30			* foreground background
31			*
32			* For a single line, we use:
33			*
34			* modifier brighttext id
35			* N+2 fontfile . This is a line with N words...
36			* 0
37			* 11
38			* Ax Ay Az
39			* Rx Ry Rz
40			* Dx Dy Dz
41			* foreground background
42			*
43			* Colortext is identical, except colors are given rather than
44			* brightnesses. Mixtext has foreground and background modifiers:
45			*
46			* modifier mixtext id
47			* 4+ foremod backmod fontfile text..
48			* 0
49			* 9
50			* Ax Ay Az
51			* Rx Ry Rz
52			* Dx Dy Dz
53			*/
54
55			#define fndx(m) ((m)->otype==MIX_TEXT ? 2 : 0)
56			#define tndx(m) ((m)->otype==MIX_TEXT ? 3 : 1)
57
58			extern char libpath; / library search path */
59
60			typedef unsigned char GLYPH;
61
62			typedef struct font {
63			GLYPH fg[256]; / font glyphs */
64			char name; / font file name */
65			struct font next; / next font in list */
66			} FONT;
67
68	greg	1.8	typedef struct tline {
69			struct tline next; / pointer to next line */
70			/* followed by the string */
71			} TLINE;
72
73	greg	1.9	#define TLSTR(l) ((char *)((l)+1))
74	greg	1.8
75	greg	1.7	typedef struct {
76			FVECT right, down; /* right and down unit vectors */
77			FONT f; / our font */
78	greg	1.8	TLINE tl; /* line list */
79	greg	1.7	} TEXT;
80
81	greg	1.6	extern char *fgetword();
82
83	greg	1.7	TEXT *gettext();
84	greg	1.1
85	greg	1.8	TLINE *tlalloc();
86
87	greg	1.7	FONT *getfont();
88	greg	1.1
89			static FONT fontlist = NULL; / our font list */
90
91
92			text(m, r)
93			register OBJREC *m;
94			RAY *r;
95			{
96	greg	1.10	FVECT v;
97	greg	1.1	int foreground;
98	greg	1.7	/* get transformed position */
99	greg	1.4	if (r->rox != NULL)
100			multp3(v, r->rop, r->rox->b.xfm);
101			else
102			VCOPY(v, r->rop);
103	greg	1.7	/* check if we are within a text glyph */
104			foreground = intext(v, m);
105	greg	1.1	/* modify */
106			if (m->otype == MIX_TEXT) {
107			OBJECT omod;
108			char *modname = m->oargs.sarg[foreground ? 0 : 1];
109			if (!strcmp(modname, VOIDID))
110			omod = OVOID;
111			else if ((omod = modifier(modname)) == OVOID) {
112			sprintf(errmsg, "undefined modifier \"%s\"", modname);
113			objerror(m, USER, errmsg);
114			}
115	greg	1.7	raytexture(r, omod);
116	greg	1.1	} else if (m->otype == PAT_BTEXT) {
117			if (foreground)
118	greg	1.7	scalecolor(r->pcol, m->oargs.farg[9]);
119	greg	1.1	else
120	greg	1.7	scalecolor(r->pcol, m->oargs.farg[10]);
121	greg	1.1	} else { /* PAT_CTEXT */
122			COLOR cval;
123			if (foreground)
124	greg	1.7	setcolor(cval, m->oargs.farg[9],
125			m->oargs.farg[10],
126			m->oargs.farg[11]);
127	greg	1.1	else
128	greg	1.7	setcolor(cval, m->oargs.farg[12],
129			m->oargs.farg[13],
130			m->oargs.farg[14]);
131	greg	1.1	multcolor(r->pcol, cval);
132			}
133			}
134
135
136	greg	1.8	TLINE *
137			tlalloc(s) /* allocate and assign text line */
138			char *s;
139			{
140			extern char *strcpy();
141			register TLINE *tl;
142
143			tl = (TLINE *)malloc(sizeof(TLINE)+1+strlen(s));
144			if (tl == NULL)
145			error(SYSTEM, "out of memory in tlalloc");
146			tl->next = NULL;
147			strcpy(TLSTR(tl), s);
148			return(tl);
149			}
150
151
152	greg	1.7	TEXT *
153			gettext(tm) /* get text structure for material */
154	greg	1.1	register OBJREC *tm;
155			{
156	greg	1.7	#define R (tm->oargs.farg+3)
157			#define D (tm->oargs.farg+6)
158	greg	1.1	extern char strcpy(), fgets();
159	greg	1.7	FVECT DxR;
160			double d;
161	greg	1.1	FILE *fp;
162			char linbuf[512];
163	greg	1.8	TEXT *t;
164	greg	1.1	register int i;
165	greg	1.8	register TLINE *tlp;
166	greg	1.1	register char *s;
167
168	greg	1.7	if ((t = (TEXT *)tm->os) != NULL)
169			return(t);
170			/* check arguments */
171			if (tm->oargs.nsargs - tndx(tm) < 1 \|\|
172			tm->oargs.nfargs != (tm->otype == PAT_BTEXT ? 11 :
173			tm->otype == PAT_CTEXT ? 15 : 9))
174			objerror(tm, USER, "bad # arguments");
175			if ((t = (TEXT *)malloc(sizeof(TEXT))) == NULL)
176	greg	1.8	error(SYSTEM, "out of memory in gettext");
177	greg	1.7	/* compute vectors */
178			fcross(DxR, D, R);
179			fcross(t->right, DxR, D);
180	greg	1.9	d = DOT(D,D)/DOT(t->right,t->right);
181	greg	1.7	for (i = 0; i < 3; i++)
182			t->right[i] *= d;
183			fcross(t->down, R, DxR);
184	greg	1.9	d = DOT(R,R)/DOT(t->down,t->down);
185	greg	1.7	for (i = 0; i < 3; i++)
186			t->down[i] *= d;
187			/* get text */
188	greg	1.8	tlp = &t->tl;
189	greg	1.7	if (tm->oargs.nsargs - tndx(tm) > 1) { /* single line */
190			s = linbuf;
191			for (i = tndx(tm)+1; i < tm->oargs.nsargs; i++) {
192			strcpy(s, tm->oargs.sarg[i]);
193			s += strlen(s);
194			*s++ = ' ';
195	greg	1.1	}
196	greg	1.7	*--s = '\0';
197	greg	1.8	tlp->next = tlalloc(linbuf);
198			tlp = tlp->next;
199	greg	1.7	} else { /* text file */
200			if ((s = getpath(tm->oargs.sarg[tndx(tm)],
201			libpath, R_OK)) == NULL) {
202			sprintf(errmsg, "cannot find text file \"%s\"",
203			tm->oargs.sarg[tndx(tm)]);
204			error(USER, errmsg);
205			}
206			if ((fp = fopen(s, "r")) == NULL) {
207			sprintf(errmsg, "cannot open text file \"%s\"",
208			s);
209			error(SYSTEM, errmsg);
210			}
211	greg	1.8	while (fgets(linbuf, sizeof(linbuf), fp) != NULL) {
212	greg	1.7	s = linbuf + strlen(linbuf) - 1;
213			if (*s == '\n')
214			*s = '\0';
215	greg	1.8	tlp->next = tlalloc(linbuf);
216			tlp = tlp->next;
217	greg	1.7	}
218			fclose(fp);
219	greg	1.1	}
220	greg	1.8	tlp->next = NULL;
221	greg	1.7	/* get the font */
222			t->f = getfont(tm->oargs.sarg[fndx(tm)]);
223			/* we're done */
224			tm->os = (char *)t;
225			return(t);
226			#undef R
227			#undef D
228	greg	1.1	}
229
230
231	greg	1.7	freetext(m) /* free text structures associated with m */
232			OBJREC *m;
233			{
234			register TEXT *tp;
235	greg	1.8	register TLINE *tlp;
236	greg	1.7
237			tp = (TEXT *)m->os;
238			if (tp == NULL)
239			return;
240	greg	1.8	for (tlp = tp->tl.next; tlp != NULL; tlp = tlp->next);
241	greg	1.9	free((char *)tlp);
242	greg	1.7	free((char *)tp);
243			m->os = NULL;
244			}
245
246
247			intext(p, m) /* check to see if p is in text glyph */
248			FVECT p;
249	greg	1.8	OBJREC *m;
250	greg	1.7	{
251			register TEXT *tp;
252	greg	1.8	register TLINE *tlp;
253	greg	1.10	FVECT v;
254			double y, x;
255	greg	1.8	int col;
256			register int lno;
257	greg	1.7	/* first, compute position in text */
258	greg	1.9	tp = gettext(m);
259	greg	1.7	v[0] = p[0] - m->oargs.farg[0];
260			v[1] = p[1] - m->oargs.farg[1];
261			v[2] = p[2] - m->oargs.farg[2];
262			col = x = DOT(v, tp->right);
263			lno = y = DOT(v, tp->down);
264			if (x < 0.0 \|\| y < 0.0)
265			return(0);
266			x -= (double)col;
267			y = (lno+1) - y;
268			/* get the font character */
269	greg	1.8	for (tlp = tp->tl.next; tlp != NULL; tlp = tlp->next)
270			if (--lno < 0)
271			break;
272			if (tlp == NULL \|\| col >= strlen(TLSTR(tlp)))
273	greg	1.7	return(0);
274	greg	1.8	return(inglyph(x, y, tp->f->fg[TLSTR(tlp)[col]]));
275	greg	1.7	}
276
277
278	greg	1.1	FONT *
279			getfont(fname) /* return font fname */
280			char *fname;
281			{
282	greg	1.6	char buf[16];
283	greg	1.1	FILE *fp;
284			char pathname, err;
285			int gn, ngv, gv;
286			register GLYPH *g;
287			register FONT *f;
288
289			for (f = fontlist; f != NULL; f = f->next)
290			if (!strcmp(f->name, fname))
291			return(f);
292			/* load the font file */
293	greg	1.3	if ((pathname = getpath(fname, libpath, R_OK)) == NULL) {
294	greg	1.1	sprintf(errmsg, "cannot find font file \"%s\"", fname);
295			error(USER, errmsg);
296			}
297			f = (FONT *)calloc(1, sizeof(FONT));
298			if (f == NULL)
299			goto memerr;
300			f->name = savestr(fname);
301			if ((fp = fopen(pathname, "r")) == NULL) {
302			sprintf(errmsg, "cannot open font file \"%s\"",
303			pathname);
304			error(SYSTEM, errmsg);
305			}
306	greg	1.6	while (fgetword(buf,sizeof(buf),fp) != NULL) { /* get each glyph */
307			if (!isint(buf))
308			goto nonint;
309			gn = atoi(buf);
310	greg	1.1	if (gn < 0 \|\| gn > 255) {
311			err = "illegal";
312			goto fonterr;
313			}
314			if (f->fg[gn] != NULL) {
315			err = "duplicate";
316			goto fonterr;
317			}
318	greg	1.6	if (fgetword(buf,sizeof(buf),fp) == NULL \|\| !isint(buf) \|\|
319			(ngv = atoi(buf)) < 0 \|\| ngv > 255) {
320	greg	1.1	err = "bad # vertices for";
321			goto fonterr;
322			}
323			g = (GLYPH )malloc((2ngv+1)*sizeof(GLYPH));
324			if (g == NULL)
325			goto memerr;
326			f->fg[gn] = g;
327			*g++ = ngv;
328			ngv *= 2;
329			while (ngv--) {
330	greg	1.6	if (fgetword(buf,sizeof(buf),fp) == NULL \|\|
331			!isint(buf) \|\|
332			(gv = atoi(buf)) < 0 \|\| gv > 255) {
333	greg	1.1	err = "bad vertex for";
334			goto fonterr;
335			}
336			*g++ = gv;
337			}
338			}
339			fclose(fp);
340			f->next = fontlist;
341			return(fontlist = f);
342	greg	1.6	nonint:
343			sprintf(errmsg, "non-integer in font file \"%s\"", pathname);
344			error(USER, errmsg);
345	greg	1.1	fonterr:
346			sprintf(errmsg, "%s character (%d) in font file \"%s\"",
347			err, gn, pathname);
348			error(USER, errmsg);
349			memerr:
350			error(SYSTEM, "out of memory in fontglyph");
351			}
352
353
354			inglyph(x, y, gl) /* (x,y) within font glyph gl? */
355			double x, y;
356			GLYPH *gl;
357			{
358			int n, ncross;
359			int xlb, ylb;
360			register GLYPH p0, p1;
361
362	greg	1.7	if (gl == NULL)
363	greg	1.1	return(0);
364	greg	1.5	x = 256.0; / get glyph coordinates */
365			y *= 256.0;
366			xlb = x + 0.5;
367			ylb = y + 0.5;
368	greg	1.1	n = gl++; / get # of vertices */
369			p0 = gl + 2(n-1); / connect last to first */
370			p1 = gl;
371			ncross = 0;
372			/* positive x axis cross test */
373			while (n--) {
374			if ((p0[1] > ylb) ^ (p1[1] > ylb))
375			if (p0[0] > xlb && p1[0] > xlb)
376			ncross++;
377			else if (p0[0] > xlb \|\| p1[0] > xlb)
378			ncross += (p1[1] > p0[1]) ^
379			((p0[1]-y)*(p1[0]-x) >
380			(p0[0]-x)*(p1[1]-y));
381			p0 = p1;
382			p1 += 2;
383			}
384			return(ncross & 01);
385			}