Recently I have exchanged some emails with a customer and AW citizen
about low polygon modeling for real time rendering. So I thought I
would post some comments here for any one who is interested.

For low polygon models:
-----------------------
-- Design your geometry to use the lowest number of triangles.
-- If triangles will never be seen by the camera then do not include
them in the model.
-- If a group of triangles appear to share the same vertex make sure
that the coordinate values are the same and that the vertex is really a
common vertex.
-- if a texture is applied to a group of triangles at a common vertex,
whenever possible, have the same UV coordinates for all the triangles.
-- Count triangles. Do not count vertices, quads and polygons with more
than 4 edges.
-- If quads are used make sure they are flat and not bent. A quad or
any polygon should have all its vertices in the same plane.
-- Do not worry about things over which you have no control.

< pause >

Now that you have come down off the ceiling because I told you not to
count vertices, I will give some points in very general terms.

What does a graphics card do?
-----------------------------
(Note: Specifications are always changing so things once not done may be
done now and this discussion is very general)
-- It does clipping. Clipping determines whether all or part of a
triangle is in the view volume which will be displayed on the computer
screen.
-- It does culling. For single sided rendering, if the visible side of
the triangle does not face the camera, the triangle is culled or not
rendered.
-- It does lighting calculations.
-- It draws or renders point clouds. Point clouds are just vertices
that are not connected. By default, a point cloud vertex lights up one
pixel. The graphics card can be told to make the vertex larger than one
pixel. Point clouds render very quickly.
-- It renders 2D lines. Lines are defined by the two vertices at either
end of the line. By default the lines are 1 pixel thick and are solid
from one vertex to the other. The thickness of the lines can be changed
and the hatching pattern used can be changed. 2D lines render quickly
but not as fast as point clouds.
-- It renders polygons. Polygons render the slowest of all. Polygons
are triangles, quads and polygons with 5 or more sides. The vertices
are used to determine an outline for the polygon and then this outline
is either filled with a solid color or a texture. The larger the
triangle appears on the screen the longer it takes to render the polygon
because more pixels have to be assigned some color value.

Which polygons are rendered by the graphics card?
-------------------------------------------------
For your particular card, you will have to read the technical
specifications for the card.

You will probably find that your card does not render polygons with 5 or
more sides and that it does not render CSG models (solids created with
Booleans and other fun things). This just means that the software
sending commands to the graphics card must convert the objects into
something acceptable to the graphics card.

You will probably find out that the card renders triangles and quads.
Digging a little deeper you will probably find out that the GPU on the
card only accepts triangles and that the software driver for the card
uses your CPU and converts the quads into triangles and then only sends
the triangles to the GPU.

Model data can be either cached or not cached for use by the GPU. If
the data is not cached and the driver has to continually convert the
quad to triangles every time the quad is rendered then your model will
render slower using quads then if it used all triangles.

Note: You have no control over how the AW browser, the Renderware engine
(that the browser uses) and the card driver handles quads, CSG solids
and polygons with more than 4 sides. The only control you have is
whether you use these things in your models.

Commands to control the graphics card
-------------------------------------
There are several ways in DirectX and OpenGL to tell the graphics card
how it should render the polygons.

One method in OpenGL to render a triangle on the graphics card. The
triangle will be textured and use vertex normals for smooth rendering.
Commands to set material properties and to load the texture are sent to
the graphics card before you send the commands to render the triangles.

A triangle is described by the three vertices that make it up. Variables
are needed to store the numbers.

// for vertex 1
//
GLfloat nx1, ny1, nz1; // normal
GLfloat u1, v1; // uv coordinates
GLfloat x1, y1, z1; // vertex

// for vertex 2
//
GLfloat nx2, ny2, nz2; // normal
GLfloat u2, v2; // uv coordinates
GLfloat x2, y2, z2; // vertex

// for vertex 3
//
GLfloat nx3, ny3, nz3; // normal
GLfloat u3, v3; // uv coordinates
GLfloat x3, y3, z3; // vertex

// start of commands to tell OpenGL to render the triangle
//
glNormal3f(nx1, ny1, nz1);
glTexCoord2f(u1, v1);
glVertex3f(x1, y1, z1);

glNormal3f(nx2, ny2, nz2);
glTexCoord2f(u2, v2);
glVertex3f(x2, y2, z2);

glNormal3f(nx3, ny3, nz3);
glTexCoord2f(u3, v3);
glVertex3f(x3, y3, z3);
//
// end of commands to tell OpenGL to render the triangle
// nine OpenGL functions were called to render the triangle.

To render 1000 triangles on the graphics card, the same set of 9
functions were called 1000 times with appropriate changes in the variables.

The rendered object could have come from RWX, COB or whatever file and
it would not matter if the file had or did not have duplicate vertices
as the same amount of data would be fed to the graphics card. If the
file contains duplicate vertices and vertex - uv pairs, the AW browser
has to allocate more RAM to hold the object but it does not have to send
more data to the graphics card to render the same amount of triangles.

There are other methods of sending data to the graphics card. For these
other methods, duplicate vertices, etc. mean that unnecessary data has
to be sent to the card which uses up RAM on the card and takes extra
time. One of these methods uses arrays of vertices, normals, uv
coordinates and then indices stored in the triangle array reference the
data in the other arrays. Another method called Vertex Buffer Objects
runs very fast but is only available on the newer cards.

Note: You have no control over how the AW browser organizes the model
data before sending it to the RenderWare engine and no control over how
the RenderWare handles the data before it sends it on to either the
DirectX or OpenGL drivers.

AW browser reading files
------------------------
I have no contact with AW and don't know what they are doing since they
dropped their TechTalks.

The AW browser converts the RWX and COB files and puts the data into a
format that is acceptable to the RenderWare engine.

RenderWare created the RWX file format and a DLL to read the files.
They have now dropped all support for this. Roland had to write a
conversion routine for the browser so that it could continue to read the
RWX files.

Hamfon wrote his cobdump program to read COB files. I think that this
code forms the basis for the COB conversion now used in the AW browser.
If so, then the conversion you see done by cobdump is what you have
inside the browser.

A lot of decisions have to be made when writing conversion programs and
thus you see many varied results when you convert the same file with
different programs.

Note: Vertex - uv pairs are stored in the RWX file but the RenderWare
engine may want them in separate lists. What ever way they want them
could change at any time and you have no control over this.

Note: You have no control over how AW browser converts files. How it
handles Boolean objects. How it tessellates (divides into triangles)
polygons. You do have control of only saving triangles to the file so
you know what you will have when the file is converted.

Building Identical Objects
--------------------------
You could take a collection of modeling programs: Wings3D, 3DCanvas,
trueSpace, LightWave, 3DS Max, SoftImage XSI, Maya, etc. and build the
identical model using textured and non textured triangles. You save the
model to the native file format for each program. File sizes will vary
because all the file formats are different. The zipped files will vary
somewhat in size and thus take different amounts of time to transmit
over the Internet.

Now assume the AW browser can read all known file formats and even those
not yet invented (since we are assuming). The browser reads all the
various file formats and converts the data to the format needed by the
RenderWare engine. All the models are rendered and what do you know.
They all rendered at the same speed because they were identical except
for the size of the file they were stored in.

Summary
-------
-- When rendering polygons, the vertices describing the polygon are
rendered as part of the surface making up the triangle.
-- To have a polygon model render faster reduce the number of polygons.
Counting two triangles as one quad doesn't make it render faster.
-- Keep the polygon count low and make sure common vertices are really
identical and the vertex count will be whatever it is.

Time to end as this is getting kind of verbose.

Cheers]
Wayne