This is geomview, produced by Makeinfo version 3.12h from geomview.texi.

INFO-DIR-SECTION Graphics Applications
START-INFO-DIR-ENTRY
* Geomview: (geomview).         The interactive 3D viewing program.
END-INFO-DIR-ENTRY


File: geomview,  Node: Geomview.m,  Next: RenderMan,  Prev: OOGL.m,  Up: Mathematica

Using Geomview as Mathematica's Default 3D Display
==================================================

   The package `Geomview.m' arranges for Geomview to be the default
display program for 3D graphics in Mathematica.  To load it, give the
command `<< Geomview.m' to Mathematica.  Thereafter, whenever you
display 3D graphics with `Plot3D' or `Show', Mathematica will send the
graphics to Geomview.

   Loading `Geomview.m' implicitly loads `OOGL.m' as well, so you can
use the `Geomview' and `WriteOOGL' as described above after loading
`Geomview.m'.  You do not have to separately load `OOGL.m'.
     % math
     Mathematica 2.0 for SGI Iris
     Copyright 1988-91 Wolfram Research, Inc.
      -- GL graphics initialized --
     
     In[1] := <<Geomview.m
     
     In[2] := Plot3D[x^2 + y^2, {x, -2, 2}, {y, -2, 2}]
     
     Out[2] := -SurfaceGraphics-

This invokes geomivew and loads the graphics object into it.
     In[3] := Plot3D[{x*y + 6, RGBColor[0,x,y]}, {x,0,1}, {y,0,1}]
     
     Out[3] := -SurfaceGraphics-

This replaces the previous Geomview object by the new object.
     In[4] := Geomview[{%2,%3}]
     
     Out[4] := {-SurfaceGraphics-, -SurfaceGraphics-}

This displays both objects at once.  You also can have more than one
Mathematica object at a time on display in Geomview, and have separate
control over them, by using the `Geomview' command with a name, *Note
OOGL.m::.
     In[5] := Graphics3D[ {RGBColor[1,0,0], Line[{ {2,2,2},{1,1,1} }] }]
     
     Out[5] := -Graphics3D-
     
     In[6] := Geomview["myline", %5]

This addes the `Line' specified in `In[5]' to the existing Geomview
display.  It can be controlled independently of the "Mathematica"
object, which is currently the list of two plots.
     In[7] := <<GL.m

If you're on an SGI, loading `GL.m' returns Mathematica to its usual 3D
graphics display.  The following plot will appear in a normal static
Mathematica window.
     In[8] := ParametricPlot3D[{Sin[x],Sin[y],Sin[x]*Cos[y]}, {x,0,Pi},{y,0,Pi}]
     
     Out[8] := -Graphics3D-

We can return to Geomview graphics at any time by reloading
`Geomview.m'.
     In[9] := <<Geomview.m
     
     In[10] := Show[%8]
     
     Out[10] := -Graphics3D-
     
     In[11] := ParametricPlot3D[
     	   {(2*(Cos[u] + u*Sin[u])*Sin[v])/(1 + u^2*Sin[v]^2),
     	   (2*(Sin[u] - u*Cos[u])*Sin[v])/(1 + u^2*Sin[v]^2),
     	   Log[Tan[v/2]] + (2*Cos[v])/(1 + u^2*Sin[v]^2)},
     	  {u,-4,4},{v,.01,Pi-.01}]
     
     Out[11] := -Graphics3D-
   This last plot is Kuen's surface, a surface of constant negative
curvature.  Parametrization from Alfred Gray's _Modern Differential
Geometry of Curves and Surfaces_ textbook.


File: geomview,  Node: RenderMan,  Next: Remote Display,  Prev: Geomview.m,  Up: Mathematica

Using Mathematica to generate RenderMan files
=============================================

   In addition to the `WriteOOGL' and `Geomview' commands described
above, the package `OOGL.m' also defines the command `WriteRI'b which
writes a 3D graphics object to a RenderMan RIB file:  `WriteRIB[FILE,
GRAPHICS]' writes GRAPHICS to file FILE.  RenderMan is a commercial
rendering system available from Pixar, Inc., which can produce
extremely high quality images.
     In[1] := <<OOGL.m
     
     In[2] := <<Graphics/Polyhedra.m
     
     In[3] := Graphics3D[Cube[]]
     
     Out[3] := -Graphics3D-
     
     In[4] := WriteRIB["cube.rib", %3]
     
     Out[4] := -Graphics3D-

This generates the file `math.ri'b.  This is a ready-to-render RIB file
of the given geometry, using a default camera position, lighting, and
the "plastic" shader. In a shell window, type `render cube.ri'b to
generate the image file `mma.tiff'. Of course, you need to have
RenderMan installed for this to work. A shortcut to render from inside
Mathematica is `WriteRIB["!render", foo]'.

   `WriteRI'b works by first converting the Mathematica graphics object
to OOGL format using `WriteOOGL' and then calls an external program
`oogl2ri'b to convert OOGL to RIB format.  The oogl2rib program takes
several options which you can specify in a string as an optional third
argument to `WriteRI'b.  The default option string is `" -n mma.tiff
"', which indicates that the RIB file should generate a rendered TIFF
file named `mma.tiff'.  A particularly useful option is `-g', which
tells oogl2rib to convert only the geometry into a RIB fragment. You
can insert that fragment into a full RIB file of your own making with
camera positions and shaders of your choice, to harness the full power
of RenderMan.

   The full usage of oogl2rib is:
     oogl2rib [-n NAME] [-B R,G,b] [-w WIDTH] [-h HEIGHT] [-fgb] [INFILE] [OUTFILE]

By default it reads from stdin and writes to stdout.  Either INFILE or
OUTFILE may be `-', which means use stdin/stdout.  The options are:
`-n NAME'
     Use NAME for the name of the rendered TIFF file (default
     "geom.tiff") or framebuffer window (default "geom.rib").

`-B R,G,b'
     Use background color (R,G,b).  Each component ranges from 0 to 1.
     Default: none.

`-w WIDTH -h HEIGHT'
     Rendered frame will be WIDTH by HEIGHT pixels.

`-f'
     RIB file renders to on-screen framebuffer instead of TIFF file.

`-g'
     Output only the geometry in RIB format.

`-b'
     Output only a Quick Renderman clip object.  Ignores -nBwhf.


File: geomview,  Node: Remote Display,  Next: Networked Geomview,  Prev: RenderMan,  Up: Mathematica

Using Geomview and Mathematica on Different Computers
=====================================================

   It is possible to use Geomview to display graphics generated by
Mathematica running on a different computer.  If you want to use
Mathematica on a computer that is not networked with your Geomview
computer, you can write out _chunk_ files in Mathematica which you
transfer to the Geomview computer and then translate to OOGL format for
displaying in Geomview.

* Menu:

* Networked Geomview::	Using a networked Geomview host.
* Chunks::		Transporting Mathematica files to Geomview by Hand.


File: geomview,  Node: Networked Geomview,  Next: Chunks,  Prev: Remote Display,  Up: Remote Display

Using a Networked Geomview Host
-------------------------------

   The `Geomview' command looks at the `DISPLAY' or `REMOTEHOST'
environment variables to try to determine if you are logged in from
another computer.  If either of these indicates that you are,
`Geomview' will attempt to run Geomview on that computer.  In order for
this to work, your network must be configured such that the Mathematica
computer can successfully `rsh' to the Geomview computer without giving
a password.

   You can also explicitly set the `DisplayHost' option to the
`Geomview' command to a string which is the desired hostname, for
example:
     In[1] := << OOGL.m
     
     In[2] := Plot3D[Sin[x + Sin[y]], {x,-2,2},{y,-2,2}]
     
     Out[2] := -Graphics3D-
     
     In[3] := Geomview[%3, DisplayHost->"riemann"]

This displays the graphics `%3' on the remote host named `riemann'.

   `Geomview' recognizes the string `"local"' as a value for
`$DisplayHost'; it forces the graphics to be displayed on the local
machine.

   In addition to knowing the name of the machine you want to run
Geomview on, `Geomview' needs to know the type of that machine (the
setting of the CPU variable that corresponds to the machine; *Note
Source Code Installation::).  By default, `Geomview' assumes that it is
the same kind of computer as the one you are running Mathematica on.
The `MachType' option lets you explicitly specify the type of the
`DisplayHost' computer; it should be one of the strings `"sgi"' or
`"next"' or `"x11"'.

   You can use `SetOptions' to change the default `DisplayHost' and
`MachType'.  For example,
     In[4] := SetOptions[Geomview, DisplayHost->"riemann", MachType->"sgi"]

arranges for `Geomview' to run Geomview on an SGI workstation named
`riemann'.


File: geomview,  Node: Chunks,  Next: Package Details,  Prev: Networked Geomview,  Up: Remote Display

Transporting Mathematica Files to Geomview by Hand
--------------------------------------------------

   The auxilliary function `WriteChunk' is for those who can only use
Mathematica on a computer that Geomview isn't installed on.
`WriteChunk[FILE, GRAPHICS]' generates a file named FILE which contains
the graphics object GRAPHICS in the format accepted by `math2oogl'.

   You can transfer that file to a computer that has Geomview installed
on it and then use the programs `math2oogl', `oogl2ri'b, and `geomview'
directly from the shell.  These programs are distributed in the
`bin/<CPU>' subdirectory of the Geomview directory, and may have been
installed so that they are on your `path'.

     In[1]:= <<OOGL.m
     
     In[2]:= Plot3D[ Sin[x + Sin[y]], {x,-2,2}, {y,-2,2} ]
     
     Out[2]= -SurfaceGraphics-
     
     In[3]:= WriteChunk["mychunk",%2]

This writes the file `mychunk' which contains a description of the
graphics object.  You can then transfer this file to a system with
Geomview and type
     math2oogl < mychunk > mma.oogl

to convert it to the OOGL file `mma.oogl' which you can then view using
Geomview. This is the equivalent of the `WriteOOGL' command.

   For a result equivalent to the `Geomview' or `Show' commands, type
     math2oogl -togeomview Mathematica geomview < mychunk

The `WriteRI'b command can be emulated from the shell as
     math2oogl < mychunk | oogl2rib -n mma.tiff


File: geomview,  Node: Package Details,  Next: Package Installation,  Prev: Chunks,  Up: Mathematica

Details of the Mathematica->Geomview Package
============================================

The `OOGL.m' package uses the external program `math2oogl' to convert
`Graphics3D' objects to OOGL format, because a compiled external
program is able to do this conversion many times faster than
Mathematica.

   The converter will sometimes handle colored SurfaceGraphics objects
correctly that Mathematica does not handle correctly, which means that
Geomview[object] sometimes works where Show[object] will give errors.

   The converter supports the `Polygon', `Line', and `Point' graphics
primitives, `RGBColor Graphics3D' directives, and `SurfaceGraphics'
objects with or without `RGBColor' directives, and lists of any
combination of these. It silently ignores all other directives.

   The Mathematica to RenderMan conversion is actually a two-step
process: Mathematica->OOGL (math2oogl), and OOGL->RenderMan (oogl2rib).

   In the `WriteOOGL' and `WriteRI'b commands, filename can either be a
string containing a filename, an `OutputStream' object, or a string
starting with a `!' to send the output to a command.  Object can be a
`Graphics3D' object, a `SurfaceGraphics' object, or a list of these.

   The packages work best with Mathematica 2.0 or better.  With version
1.2, the Geomview display is always on the local host.


File: geomview,  Node: Package Installation,  Next: Installation,  Prev: Package Details,  Up: Mathematica

Installing the Mathematica Packages
===================================

   If Geomview is properly installed on your system according to the
instructions in *Note Installation::, then the Mathematica-to-Geomview
packages should work as described here; there should be no need for
additional installation procedures.  In practice, however, it is
sometimes necessary to taylor the installation of the Mathematica
packages and/or of Geomview itself to suit the needs of a particular
system.  This section contains details about how the installation works;
if the Mathematica-to-Geomview connection does not seem to work for you
after following the Geomview installation procedure, consult this
section to see what might need to be fixed.

   In this section, the phrase _Geomview installation_ refers any of
the procedures in *Note Installation::.  The way the Mathematica
packages work and are installed is the same regardless of whether you
have one of the binary distributions or the source distribution.

  1. The relevant mathematica files are `OOGL.m', `Geomview.m', and
     `BezierPlot.m'; Mathematica must be able to find these files.  They
     are distributed in the `$GEOMROOT/mathematica' subdirectory of the
     binary distributions, and in the
     `$GEOMROOT/src/bin/geomutil/math2oogl' subdirectory of the source
     distribution.  These files need to be in a directory that is on
     Mathematica's search path.  You can look at the value of the
     `$Path' variable in a Mathematica session on your system to see a
     list of the directories on Mathematica's search path.

     The Geomview installation procedure puts copies of the Mathematica
     packages into a directory that you specify (`MMAPACKAGEDIR').  This
     should ensure that Mathematica can find them.  Alternately, you
     could arrange to append the pathname of the Mathmematica package
     subdirectory of the Geomview distribution to the `$Path' variable
     each time you run Mathematica.

  2. The package `OOGL.m' needs to be able to invoke the programs
     `geomview', `math2oogl', and `oogl2ri'b.  The Geomview
     installation procedure installs these programs into a directory
     that you specify for executables (`BINDIR').  Ideally, this
     directory should be on your shell's `$path'.  More specifically,
     it should be on the `$path' of the shell in which Mathematica
     runs; the directory `/usr/local/bin' is usually a good choice.
     You can see the list of directories on this path by giving the
     command `!echo $path' in Mathematica.

     If for some reason you can't arrange for `geomview', `math2oogl',
     and `oogl2ri'b to be in a directory on the shell's `$path', you
     can modify `OOGL.m' to cause it to look for them using absolute
     pathnames.  To do this, change the definitions of the variables
     `$GeomviewPath' and `$GeomRoot', which are defined near the top of
     the file.  Change `$GeomviewPath' to the absolute pathname of the
     `geomview' shell script on your system.  Change `$GeomRoot' to the
     absolute pathname of the `$GEOMROOT' directory on your system.  If
     you do this, you should also make sure there are copies of
     `geomview', `math2oogl', and `oogl2ri'b in the
     `$GEOMROOT/bin/<CPU>'.

  3. The `geomview' shell script, which `OOGL.m' uses to invoke
     Geomview, needs to be able to find the geomview executable file (
     called `gvx').  The Geomview installation procedure should have
     been taken care of this, but if your Mathematica session doesn't
     seem to be able to invoke Geomview, it's worth double-checking
     that the settings in the `geomview' script are correct.



File: geomview,  Node: Installation,  Next: Unix Binary Installation,  Prev: Package Installation,  Up: Top

Installation
************

   What you do to install Geomview depends on which kind of computer you
have and on whether you have the source distribution or the binary
distribution.

   In general, if you don't care about looking at Geomview's source
code, you should get one of the binary distribution.  The binary
installation is much easier and quicker than compiling and installing
the source code.

* Menu:

* Unix Binary Installation::  Installing the Unix Binary Distribution
* Source Code Installation::  Compiling and Installing the Source Code Distribution.


File: geomview,  Node: Unix Binary Installation,  Next: Unix Binary Detail,  Prev: Installation,  Up: Installation

Installing the Unix Binary Distribution
=======================================

   If you have just obtained a copy of the binary distribution for a
Unix system (Linux, SGI, Solaris, HP, etc), you should be able to run
Geomview and make use of most of its features immediately after
unpacking it by `cd''ing to the directory that it is in and typing
`geomview'.

   In order to fully install Geomview so that you can run it from any
directory and use all of its features, follow the steps in this section.
In particular, you must go through this installation procedure in order
to use Geomview to display Mathematica graphics.

   Geomview is distributed in a directory that contains various files
and subdirectories that Geomview needs at run-time, such as data files
and external modules.  It also contains other things distributed with
Geomview, such as documentation and (in the soure-code distribution)
source-code.  We refer to the root directory of this tree as the
`$GEOMROOT' directory.  This is the directory called `Geomview' that is
created when you unpack the distribution file.

   To install Geomview on your system, arrange for the `$GEOMROOT'
directory to be in a permanent place.  Then, in a shell window, `cd' to
that directory and type `install'.  This runs a shell script which does
the installation after asking you several questions about where you
want to install the various components of Geomview.

   After running the `install' script you should now be able to run
Geomview from any directory on your system.  (You may need to give the
`rehash' command in any shells on your computer that were started up
before you did the installation.)

   The `install' script puts copies of the files in
`$GEOMROOT/bin/<CPU>' and `$GEOMROOT/man' into the directories you
specified for executables and man pages, respectively.  Once you have
done the installation you can cut down one the disk space required by
Geomview by removing some files from these directories, since copies
have been installed elsewhere.  You should first test that your
installed Geomview works properly because once you remove these files
from their distribution directories you will not be able to do the
installation again.

   In particular, the files you can remove are

`$GEOMROOT/bin/<MACHTYPE>':
     (where `<MACHTYPE>' is the type of system you are on, e.g.
     `linux', `sgi', `hpux', etc).  Remove all files from here except
     `gvx', which is the geomview executable file.  DO NOT REMOVE
     `gvx'.  It is not installed elsewhere.

`$GEOMROOT/man':
     You can remove all the files in this directory.


File: geomview,  Node: Unix Binary Detail,  Next: Source Code Installation,  Prev: Unix Binary Installation,  Up: Unix Binary Installation

Details of the Unix Binary Installation
---------------------------------------

   The `install' script should be self-explanatory; just run it and
answer the questions.  This section gives some details for system
administrators and other users who may want to know more about the
installation.

   The installation is actually done by `make'; the `install' script
queries the user for the settings of the following `make' variables and
then invokes `make install'.

`GEOMROOT':
     the absolute pathname of the Geomview root directory.  The
     `geomview' shell script, which is what users invoke to run
     Geomview, uses this to set various environment variables that
     Geomview needs.  It is very important that this be an _absolute_
     pathname -- i.e. it should start with a '/'.

`BINDIR':
     a directory where executable files are installed.  The `geomview'
     shell script goes here, as well as various other auxiliary
     programs that can be used in conjunction with `geomview'.  This
     should be a directory that is on users' `$path'.  These auxiliary
     programs are distributed in the `$GEOMROOT/bin/<MACHTYPE>'
     directory; if you specify this directory for `BINDIR', they are
     left in that directory.

`MANDIR':
     a directory where Unix manual pages are installed.  These are
     distributed in the `$GEOMROOT/man' subdirectory; if you specify
     this directory for `MANDIR', they are left in that directory.

`MMAPACKAGEDIR':
     a directory where Mathematica packages are installed.  This should
     be a directory that Mathematica searches for packages that it
     loads; you can see what directories your Mathematica searches by
     looking at the value of the `$Path' variable in a Mathematica
     session.  The installation process will install some packages
     there which allow you to use Geomview to display Mathematica
     graphics.  These packages are distributed in the
     `$GEOMROOT/mathematica' subdirectory; if you specify this
     directory for `MMAPACKAGEDIR', or if you specify the empty string
     for `MMAPACKAGEDIR', the packages are left in that directory.  For
     more details about the way these Mathematica packages connect to
     Geomview, *note Package Installation::..


File: geomview,  Node: Source Code Installation,  Next: Support,  Prev: Unix Binary Detail,  Up: Installation

Compiling and Installing the Source Code Distribution
=====================================================

   The main reason to get the source code distribution is to look at
and/or work with the source code.  If you are only concered with _using_
Geomview it is better to get the binary distribution.  It takes anywhere
from a few minutes to an hour or more to compile the entire source
distribution, depending on what kind of computer you have.

   Let `$GEOMROOT' denote the full pathname of the Geomview source code
directory; this is the directory called `Geomview' that is created when
you unpack the distribution.  This directory contains the Geomview
source code as well as various other files and subdirectories that
Geomview needs when it runs.

   Before doing any compilation you should edit the file
`$GEOMROOT/makefiles/mk.site.default'.  This file defines some `make'
variables which specify your local configuration.  This includes the
pathnames of the directories into which Geomview will be installed, and
possibly some other settings as well.  There are comments in the file
telling you what to do.  This file is included by every Makefile in the
source tree, so the settings you specify here are used throughout the
source.

   If you will be compiling for multiple systems, you can do them all
in the same directory tree.  By default the Makefiles are set up to put
the objects files, libraries, and executables in directories which
depend on the type of computer, so the two architectures will not
interfere with each other.  The Makefiles use a variable called `CPU'
to determine the type of machine. Before doing any compilation you must
arrange for this variable to have a value.  There are two ways you can
do this.

  1.  If you will always be compiling Geomview on the same type of
     computer edit the file `$GEOMROOT/makefiles/Makedefs.global' to
     set the `CPU' variable to one of the values `linux', `FreeBSD',
     `sgi', `hpux', `hpux-gcc', `solaris', `sun4os4' (for Suns with
     SunOS 4, not Solaris), `rs6000', or `alpha'.  If you're using a
     type of system not in this list, make up a new value for CPU, and
     write a `mk.<CPU>' file for it patterned after the other `mk.*' in
     the `makefiles' subdirectory.

  2. If you will be compiling on more than one type of computer you can
     set a shell environment variable named `CPU' to one of the values
     above and the Makefiles will inherit the value from the
     environment.


Note that many of the Makefiles refer to a variable called `MACHTYPE';
this variable tells which type of graphics system to compile Geomview
for.  The `mk.<CPU>' files set this variable for you; in most cases its
value is `x11', which specifies that Geomview should be compiled for X
windows.

   Once you have configured your source tree by editing the files as
described above and setting the `CPU' variable, you can compile and
install Geomview by typing `make install' in the `$GEOMROOT' directory.
You can also type `make all', or equivalently just `make', to compile
without installing, and then type `make install' later to install.

   You can use these same `make' comands in any subdirectory in the
tree to recompile and/or install a part of Geomview or a module.

   If you want to modify the complier flags used during compilation,
edit the file `$GEOMROOT/makefiles/Makedefs.global'; the `COPTS'
variable specifies the flags passed to the C compiler (cc).


File: geomview,  Node: Support,  Next: Contributing,  Prev: Installation,  Up: Top

Getting Technical Support for Geomview
**************************************

   There are several ways to get support for Geomview.

  1. Visit the Geomview web site, http://www.geomview.org .  It
     contains the latest documentation, news about development, and FAQ
     (Frequently Asked Questions) list.

  2. Send email to the geomview-users@lists.sourceforge.net mailing
     list.  This is a mailing list for discussing any issues related to
     using Geomview.  To join the list, send an empty note with
     'subscribe' in the subject line to
     geomview-users-request@lists.sourceforge.net, or visit the list
     web page at
     http://lists.sourceforge.net/mailman/listinfo/geomview-users.

  3. Contract with Geometry Technologies for support.  Geometry
     Technologies is a contract support and programming company that
     emerged from the Geometry Center, where Geomview was written.  For
     more information, send email to info@geomtech.com, or visit the
     Geometry Technologies web site at http://www.geomtech.com



File: geomview,  Node: Contributing,  Next: Function Index,  Prev: Support,  Up: Top

Contributing to Geomview's Development
**************************************

   If you are interested in contributing to the development of Geomview,
there are several things you can do:

  1. *Volunteer programming work*.

     If you are a programmer and make an improvement to Geomview,
     contact the Geomview team by emailing software@geomview.org.  In
     general, if you intend to work on Geomview very much please
     contact us so that we can coordinate your work with other
     development work.

  2. *Volunteer documentation work*.

     Geomview also needs updated documentation; if you use Geomview a
     lot and are familiar with it, you can help by working on revised
     documentation.  For information on this, email
     software@geomview.org.

  3. *Contract with Geometry Technologies*.

     Geometry Technologies, Inc. is a consulting firm that provides
     contract technical support and custom programming services in the
     area of 3D graphics.  This includes a wide range of services
     related to 3D graphics, included but not limited to applications
     involving Geomview.  To the extent that resources allow, Geometry
     Technologies supports the developement of Geomview; in particular
     it hosts the http://www.geomview.org web site, and its staff make
     ongoing improvements to Geomview itself.  If you are in a position
     to pay for technical support or custom programming work,
     contracting with Geometry Technologies indirectly supports
     Geomview.  You can also contract with with Geometry Technologies
     to have particular features that you want added to Geomview, or to
     port Geomview to a new platform.  For more information see
     Geometry Technologies web site at http://www.geomtech.com , or
     email info@geomtech.com.

  4. *make a donation*

     If you want to donate money directly to support Geomview, you can
     send it to Geometry Technologies which will use it to fund Geomview
     development and to help offset other costs associated with
     maintaining Geomview. See their Geomview Contributions web page at
     http://www.geomtech.com/products/geomview/contributions for
     details.


   Thank you.


File: geomview,  Node: Function Index,  Prev: Contributing,  Up: Top

Function Index
**************

* Menu:

* !:                                     Gcl Reference.
* ?:                                     Gcl Reference.
* ??:                                    Gcl Reference.
* <:                                     Gcl Reference.
* =:                                     Gcl Reference.
* >:                                     Gcl Reference.
* |:                                     Gcl Reference.
* all:                                   Gcl Reference.
* ap-override:                           Gcl Reference.
* backcolor:                             Gcl Reference.
* background-image:                      Gcl Reference.
* bbox-color:                            Gcl Reference.
* bbox-draw:                             Gcl Reference.
* camera:                                Gcl Reference.
* camera-draw:                           Gcl Reference.
* camera-prop:                           Gcl Reference.
* camera-reset:                          Gcl Reference.
* car:                                   Gcl Reference.
* cdr:                                   Gcl Reference.
* clock:                                 Gcl Reference.
* command:                               Gcl Reference.
* copy:                                  Gcl Reference.
* cursor-still:                          Gcl Reference.
* cursor-twitch:                         Gcl Reference.
* delete:                                Gcl Reference.
* dice:                                  Gcl Reference.
* dimension:                             Gcl Reference.
* dither:                                Gcl Reference.
* draw:                                  Gcl Reference.
* echo:                                  Gcl Reference.
* emodule-clear:                         Gcl Reference.
* emodule-define:                        Gcl Reference.
* emodule-defined:                       Gcl Reference.
* emodule-isrunning:                     Gcl Reference.
* emodule-path:                          Gcl Reference.
* emodule-run:                           Gcl Reference.
* emodule-sort:                          Gcl Reference.
* emodule-start:                         Gcl Reference.
* emodule-transmit:                      Gcl Reference.
* escale:                                Gcl Reference.
* event-keys:                            Gcl Reference.
* event-mode:                            Gcl Reference.
* event-pick:                            Gcl Reference.
* evert:                                 Gcl Reference.
* exit:                                  Gcl Reference.
* ezoom:                                 Gcl Reference.
* freeze:                                Gcl Reference.
* geometry:                              Gcl Reference.
* geomview-version:                      Gcl Reference.
* hdefine:                               Gcl Reference.
* help:                                  Gcl Reference.
* hmodel:                                Gcl Reference.
* hsphere-draw:                          Gcl Reference.
* if:                                    Gcl Reference.
* inhibit-warning:                       Gcl Reference.
* input-translator:                      Gcl Reference.
* interest:                              Gcl Reference.
* lines-closer:                          Gcl Reference.
* load:                                  Gcl Reference.
* load-path:                             Gcl Reference.
* look:                                  Gcl Reference.
* look-encompass:                        Gcl Reference.
* look-encompass-size:                   Gcl Reference.
* look-recenter:                         Gcl Reference.
* look-toward:                           Gcl Reference.
* merge:                                 Gcl Reference.
* merge-ap:                              Gcl Reference.
* merge-baseap:                          Gcl Reference.
* merge-base-ap:                         Gcl Reference.
* morehelp:                              Gcl Reference.
* name-object:                           Gcl Reference.
* ND-axes:                               Gcl Reference.
* ND-color:                              Gcl Reference.
* ND-xform:                              Gcl Reference.
* ND-xform-get:                          Gcl Reference.
* new-alien:                             Gcl Reference.
* new-camera:                            Gcl Reference.
* new-center:                            Gcl Reference.
* new-geometry:                          Gcl Reference.
* new-reset:                             Gcl Reference.
* NeXT:                                  Gcl Reference.
* normalization:                         Gcl Reference.
* pick:                                  Gcl Reference.
* pickable:                              Gcl Reference.
* pick-invisible:                        Gcl Reference.
* position:                              Gcl Reference.
* position-at:                           Gcl Reference.
* position-toward:                       Gcl Reference.
* progn:                                 Gcl Reference.
* quit:                                  Gcl Reference.
* quote:                                 Gcl Reference.
* rawevent:                              Gcl Reference.
* rawpick:                               Gcl Reference.
* read:                                  Gcl Reference.
* real-id:                               Gcl Reference.
* redraw:                                Gcl Reference.
* regtable:                              Gcl Reference.
* rehash-emodule-path:                   Gcl Reference.
* replace-geometry:                      Gcl Reference.
* rib-display:                           Gcl Reference.
* rib-snapshot:                          Gcl Reference.
* scale:                                 Gcl Reference.
* scene:                                 Gcl Reference.
* set-clock:                             Gcl Reference.
* set-conformal-refine:                  Gcl Reference.
* set-emodule-path:                      Gcl Reference.
* setenv:                                Gcl Reference.
* set-load-path:                         Gcl Reference.
* set-motionscale:                       Gcl Reference.
* sgi:                                   Gcl Reference.
* shell:                                 Gcl Reference.
* sleep-for:                             Gcl Reference.
* sleep-until:                           Gcl Reference.
* snapshot:                              Gcl Reference.
* soft-shader:                           Gcl Reference.
* space:                                 Gcl Reference.
* stereowin:                             Gcl Reference.
* time-interests:                        Gcl Reference.
* transform:                             Gcl Reference.
* transform-incr:                        Gcl Reference.
* transform-set:                         Gcl Reference.
* ui-center:                             Gcl Reference.
* ui-emotion-program:                    Gcl Reference.
* ui-emotion-run:                        Gcl Reference.
* ui-freeze:                             Gcl Reference.
* ui-panel:                              Gcl Reference.
* ui-target:                             Gcl Reference.
* uninterest:                            Gcl Reference.
* update:                                Gcl Reference.
* update-draw:                           Gcl Reference.
* window:                                Gcl Reference.
* winenter:                              Gcl Reference.
* write:                                 Gcl Reference.
* write-comments:                        Gcl Reference.
* write-sexpr:                           Gcl Reference.
* xform:                                 Gcl Reference.
* xform-incr:                            Gcl Reference.
* xform-set:                             Gcl Reference.
* zoom:                                  Gcl Reference.


