Hidden Surface Removal

Fifth part of The 3D Coding Blackhole tutorial series

Home at http://3Dblackhole.base.org

NOTE: Some part of functions and some members of structures are not
explained here, but we'll discuss them in other tutorials of the series.
They're usually displayed in totality for the sake of similarity between
the different tutorials and with the complete 3D engine.

   * The Dilemna
   * Backfaces removal
   * Z-Buffering

The Dilemna

The heart of a 3D engine is its HSR system... So you must think twice about
which one to chose... I'll point right now the pros and cons of the most
popular ones:

Painter's algorithm

        o Required time increase faster
        o Hard to implement (especially overlapping tests)
        o Unable to sort correctly complex scenes

BinarySpacePartitioning trees

        o Extremely fast
        o Hard to implement
        o Can only sort static polygons
        o Need stored trees


        o Required time increasing linearly with the number of polygons
        o Faster than the Painter's above 5000 polygons
        o Able to render any scene perfectly, even logically incorrect ones
        o Extremely easy to implement
        o Straightforward
        o Requires a lot of memory
        o Usually slow

My own choice is Z-Buffering. I will only talk about it, so if you want
some reference for the other algorithms, take a look at my list in the last

Backfaces removal

In addition to these methods, we can easily remove back facing polygons to
save a lot of computing time. We will start by defining some useful
function to compute our plane and normals and all that stuff. Later, we
will add texture and shading computaions to this function. These numbers
will be kept in global variables:

float A,B,C,D;
BOOL backface;

And our function's beginning will look like this. We start by extracting
every coordinate in float variables:

void ENG3D_SetPlane(Polygon_t *Polygon,Object_t *Object)
   float x1=Vert(0).Aligned.x;
   float x2=Vert(1).Aligned.x;
   float x3=Vert(2).Aligned.x;
   float y1=Vert(0).Aligned.y;
   float y2=Vert(1).Aligned.y;
   float y3=Vert(2).Aligned.y;
   float z1=Vert(0).Aligned.z;
   float z2=Vert(1).Aligned.z;
   float z3=Vert(2).Aligned.z;

Then we compute every member of the plane equation:


Then we check if it's facing us or not:



Z-Buffering consists in keeping the z coordinate of every point we put on
the screen in a huge array, and when we come to put another at the same
place, we check if it is closer to the viewer or if it behind. We only draw
it in the first case. As you can see, the only thing we have to do is to
compute the z value for every point. But first of all, we declare a global
array and allocate space for it (MEMORYSIZE is the product of the vertical
and horizontal resolutions):

typedef long ZBUFTYPE;
ZBUFTYPE *zbuffer;
zbuffer=(ZBUFTYPE *)malloc(sizeof(ZBUFTYPE)*MEMORYSIZE);

We use a long as the z-buffer type, because we're gonna use fixed points.
And you must not forget to set every z coordinate to the farthest value

   int c;
   for(c=0; cZBuffer[offset])

And we got it!
E-mail me at jerstlouis@videotron.ca
Back to Jerome St-Louis's Homepage
Back to The 3D Coding BlackHole

                                                  Last Updated: 08-24-1997

Discuss this article in the forums

Date this article was posted to GameDev.net: 7/16/1999
(Note that this date does not necessarily correspond to the date the article was written)

See Also:

© 1999-2011 Gamedev.net. All rights reserved. Terms of Use Privacy Policy
Comments? Questions? Feedback? Click here!