A copy of toogl is in the /usr/share directory. The exact location depends on the operating system version you are using. If you want to look at the source (it's in C++), you can get a copy from the OpenGL directory.

You can also get a copy of the tool from the “Contributed Tools” area of the Silicon Graphics OpenGL home page (http://www.sgi.com/Technology/openGL/)

To build the tool, enter:

# setenv OBJECT_STYLE 32
# make

---

Warning: If you build toogl with OBJECT_STYLE set to n32 (the default on current systems), the tool does not work!

---

toogl syntax:

toogl [-cwq] < infile > outfile

You can use any of these options with toogl:

---

Note: toogl doesn't attempt to translate event queue and windowing calls. It simply removes them, and replaces them with warning comments. The -w and -q flags merely suppress the comments.

---

Keep your original source! Accidents happen.

To process a directory full of source files automatically, you could use a shell script like the following:

#!/bin/sh
mkdir OpenGL
for i in *.c
   do
      echo "Converting " $i " ..."
      toogl < $i > OpenGL/$i
   done

toogl is a filter that scans each line of an input file, looking for IRIS GL calls. When toogl finds an IRIS GL function, it replaces the function with the corresponding OpenGL function(s).

Because toogl can't translate everything, you have to edit its output. Any time toogl translates code that you may have to look at, check, or change, it marks the potential problem with a comment starting with “OGLXXX”. (You can use the -c option to suppress the comments.)

toogl can't translate sections of code that make window manager, window configuration, device, or event calls, or that load a color map. You have to rewrite these code sections yourself. You can use the -w and -q options to make toogl leave this code untouched, so you can still read it to translate it manually. If your windowing and event handling calls are simple and straightforward, you can replace them with calls from the GLUT library. For more information on GLUT, see the OpenGL home page http://www.OpenGL.org or the Silicon Graphics OpenGL page http://www.sgi.com/Technology/openGL/. See also “GLX and GLUT Documentation”.

If your windowing and event handling calls are fairly sophisticated, you have to incorporate the OpenGL code into X Windows directly, either using the OpenGL widget or using Xlib. This is explained in Chapter 4, “OpenGL in the X Window System.”

toogl understands a little about matching parentheses and quotes. It translates

v3f( v[strlen(strcat(foo, "foo("))] );

into

glVertex3fv( v[strlen(strcat(foo, "foo("))] );

IRIS GL provides defined color constants: BLACK, BLUE, RED, GREEN, MAGENTA, CYAN, YELLOW, and WHITE. OpenGL does not provide these constants and toogl does not translate them, so you have to port them explicitly.

Make sure clear() calls are correctly translated. For example, assume your program clears the window as follows:

color(BLACK);
clear();

toogl translates those two lines as follows:

glIndex(BLACK);
glClear(GL_COLOR_BUFFER_BIT);

The above code fragment is incorrect for these reasons:

A better translation is the following:

glIndex(0);
glClearIndex(0);
glClear(GL_COLOR_BUFFER_BIT);

toogl does not always translate IRIS GL “get” calls (such as getdepth(), getcolor(), and so on) correctly. toogl translates

i = getcolor();
getdepth(&near, &far);

into

/* OGLXXX replace value with your variable */
i = glGetIntegerv(GL_CURRENT_INDEX, &value);

/* OGLXXX You can probably do better than this. */
{
  int get_depth_tmp[2];
  glGetIntegerv(GL_DEPTH_RANGE, get_depth_tmp);
  *(&near)=get_depth_tmp[0];
  *( &far)=get_depth_tmp[1];
};

This guide lists the glGet*() calls related to a particular topic in the section on that topic. For general information on replacing get calls, see “Porting IRIS GL get* Commands”.

The OpenGL rotation call glRotate() is different from rotate(). You will probably have to modify the code after translating the program with toogl. See “Porting Matrix and Transformation Calls” for details.

OpenGL has no equivalent for swaptmesh(); toogl flags occurrences of the function and leaves it up to you to restructure your triangles.

toogl correctly translates texture coordinate calls. You have to do additional work, as explained in “Porting Texture Calls”.

---

Note: If you're using OpenGL 1.1, you can take advantage of subtextures. Because toogl was developed for OpenGL 1.0, you have to implement the use of OpenGL subtextures yourself.

---

OpenGL does not keep tables of predefined lights and materials, so it has no equivalent for “binds.” You can use display lists to mimic the behavior. See “Porting defs, binds, and sets: Replacing `Tables' of Stored Definitions” for more information. See also “Porting Lighting and Materials Calls” and “Porting Texture Calls” for more discussion and some examples.

There are some IRIS GL calls that toogl cannot directly translate into OpenGL calls. arcf() is one example. You have to port such calls explicitly. “Editing toogl Output: An Example” gives an example for porting a call like arcf().

Appendix A, “OpenGL Commands and Their IRIS GL Equivalents,” contains a table listing IRIS GL commands and the corresponding OpenGL commands, and tells you where to go for more information. This table also indicates which IRIS GL calls are not supported in OpenGL.

toogl doesn't necessarily produce fast OpenGL code; in fact, such an automatic port usually results in loss of performance. Details of improving OpenGL performance are beyond the scope of the current edition of this guide; however, you can find some specific tips in “Porting Screen and Buffer Clearing Commands” and “Porting Lighting and Materials Calls”.

---

Note: The performance chapters of OpenGL on Silicon Graphics Systems provide additional information.

---

Two features of OpenGL that can drastically improve performance are display lists and direct rendering. Use these features whenever possible in OpenGL programs. For information on display lists, see “Porting Display Lists” in Chapter 3. For information on direct rendering, see the glXCreateContext reference page. If you aren't careful, you may set up indirect rendering without noticing that it's indirect; specify direct rendering explicitly where possible.

Here are few more tips: