From: akin@tuolumne.asd.sgi.com (Allen Akin)
Newsgroups: comp.graphics.opengl
Subject: Re: GL question
Date: 14 Dec 1992 19:47:18 GMT
Organization: Silicon Graphics, Inc.  Mountain View, CA
NNTP-Posting-Host: tuolumne.asd.sgi.com


I've already replied by email, but for the benefit of comp.graphics.opengl
readers, here's a copy:


| What are the differences between GL by SGI and OpenGL. ...

The main difference is that OpenGL has only rendering functionality.
It has none of the menu routines, windowing routines, or input queue
routines that appeared in IRIS GL.  OpenGL applications are expected to
use their windowing system (whatever that may be -- currently X11 or
Windows NT) to perform the missing functions.

Another major difference is that OpenGL may not be subsetted.  Unlike
IRIS GL, where functionality differs from machine to machine, OpenGL
has the same functionality on all machines.  (Software rendering must
be used whenever the hardware fails to support some feature.)

The OpenGL API is a lot like the IRIS GL API, but some names and
argument lists have been changed.  This makes them more consistent, and
eliminates some name-space conflicts.

OpenGL display lists are somewhat different from IRIS GL objects.
Display lists can be created, deleted, and replaced (even at fine
granularity, like individual vertex coordinates).  However, display
lists may not be edited.  In OpenGL, display lists also replace the
"def" and "bind" routines that appear in IRIS GL.

|                                                    ... Specifically, I 
| noticed that GL only has raster fonts. It is vital for our applications to
| have fonts consisting of strokes, like the Hershey font. Does OpenGL have
| 	this or could we add it? ...

OpenGL handles fonts in two steps:

    1.	Create an array of display lists with consecutive identification
	numbers.  The contents of each display list are the instructions
	needed to draw one glyph of the character set.

    2.	Invoke a set of display lists by using each of the bytes in an
	array of characters (or larger integer types) as indices into
	the array of display lists created in step 1.

You can create the display lists in any way you like.  OpenGL provides some
utility routines to convert window-system fonts into display lists, but since
X11 provides only raster fonts, on X11 you'll only get rasters.  (On Windows
NT you also get polygonal fonts.)  Since you need Hershy fonts, I'd recommend
getting one of the public-domain versions of the glyphs and building display
lists from them.  Then you can draw vector fonts with the string-drawing
routines mentioned in step 2 above.  This is fairly easy to do, and gives
you the freedom to modify the font in whatever way you'd like.

[Mason, is there anything like this in the OpenGL books?  Might be a good
example.]

|                            ... we require publication-quality output at 
| 300dpi. Does OpenGL have this? ...

OpenGL assumes the output device is raster-based, not calligraphic.  You
can render to pixmaps (offscreen memory) at whatever resolution you like,
though you may have to render a large image in pieces if the resolution is
so high that the maximum size pixmap is too small.  This can result in
*enormous* image files if you're printing in full color, so be aware of
the limitations.

|                            ... I assume that in OpenGL I can define
| line widths and graphical objects, or?

Yes, you can define both line widths and graphical objects (in the sense
that display lists are graphical objects).

| What I'm really leading up to is whether it is a
| suitable replacement for DISSPLA from CA, from a FUNCTIONAL, not ease of
| programming point of view.

Unfortunately, I can't answer that one.  Though I've heard of it, I'm not
really familiar with DISSPLA.  I was under the impression that it was mainly
intended for calligraphic devices like storage tubes, vector scopes, and
plotters.  OpenGL is better-suited for raster displays and printers.


Allen