typedef struct Vtx2d             // 2d, projected vertex 
{
   int x, y;                     // coords
   unsigned char c;              // color, necessary for some shading routines
} Vtx2d;

typedef struct Texel             // texture coordinates
{
   int u, v;
} Texel;

class Vector
{
   Fixed x, y, z;                // whatever type you want

   // all the functions, like arithmetic, transformations, etc. defined as methods
   ...
};

class Vertex
{
  public:
   Vector world, obj;            // world and object coordinates
   Vector world_norm, obj_norm;  // world and object normals
   Vtx2d  scr;                   // projected, screen coordinates
   Texel  tex;                   // texture coordinates
   int clipped, out;             // visibility status flags
   int clipped_by[NUM_CLIP_PLANES];
};

class Poly
{
  protected:
   Vertex **v;                           // the vertex array - array of pointers, to be dynamically allocated
   int num_vertices;
   Vector world_norm, obj_norm;          // normals necessary for flat shading
   Fixed z;                              // depth value used for sorting
   int p, t, tx, e, f, g, ph, b;         // type flags - more than one can be enabled at the same time

  // some of the essential functions
  public:
   ... IS_A(...);                        // returns type information
   virtual void draw();                  // drawing function that's overloaded for different types
   ...
};

class TexPoly
{
   ...
   TexPoly(...):Poly() {}                // the Poly base class gets inherited by all types
};
...

class Object
{
  protected:
   Vertex *vertex; int num_vertices;       // array of vertices - the vertices are stored in the object structure, where they're indexed from by the polys
   Poly   **poly ; int num_polys;          // array of pointers to polys (this is necessary to be able to store different types of polys in the same array)
   Object **child; int num_children;       // the array of children as Object pointers
   Bitmap **texture;                       // the array of textures
   Bound  bbox, own_bbox;
   Matrix WrldMatrix;

  public:
   // essential functions
   void transform(const Matrix &M);
   void draw(...);                         // an object also draws itself, just like a Poly
   void make_box(...);                     // this creates a box object (maybe more appropriate as friend...)
};

   while(!stop)
   {
      Vector rotate, translate;  //define it in here, so it gets automatically cleared every frame

      if(key_up_pressed)    translate.z=1;
      if(key_down_pressed)  translate.z=-1; 
      if(key_right_pressed) rotate.y=1;   
      ...
      Matrix rotation_matrix = create_rotation_matrix(rotation);
      Matrix translation_matrix = create_translation_matrix(translation);

      object.WorldMatrix *= rotation_matrix; //matrix concatenation
      object.WorldMatrix *= translation_matrix;

      object.draw();
   }

   Vector rotate, translate; //define it out here, so it's static

   while(!stop)
   {
      if(key_up_pressed)    translate.z++;
      if(key_down_pressed)  translate.z--; 
      if(key_right_pressed) rotate.y++;   
      ...
      Matrix rotation_matrix = create_rotation_matrix(rotation); //create full transformation matrices, since "rotate" and "translate" are absolute 
      Matrix translation_matrix = create_translation_matrix(translation);

      object.WorldMatrix = Matrix();          //initialize to identity
      object.WorldMatrix *= rotation_matrix; 
    //an optimization would be to replace the above two lines with:
    //object.WorldMatrix = rotation_matrix;
      object.WorldMatrix *= translation_matrix;

      object.draw();
   }

   void get_camera_matrix(Vector rotate, Vector move)
   {
      direction+=rotate;                    // increment rotation
      move.rotate(direction);               // rotate translation increment, so you're moving in the direction you're looking
      location+=move;                       // increment translation
   
      CameraMatrix=Matrix();                // clear camera matrix to identity
      CameraMatrix.translate(-location);    // translate world _in the opposite direction_ of where you're moving
      CameraMatrix.rotate(-direction);      // rotate        ||            ||
   }

   void get_camera_matrix(Vector rotate, Vector move)
   {
      CameraMatrix.translate(-move);   
      CameraMatrix.rotate(-rotate);
      // BTW, incrementing a matrix made of low precision numbers such as fixed point can screw up
      // the integrity of the matrix, so you might have to orthonormalize it from time to time
   }

   main()
   {
      ...
      for(int o=0; o < num_objects; o++)      // main object handling loop - "get transformation" stage
      {
         object[o].transform(WhateverMotion); // transform the object to world space
         object[o].transform(CameraMatrix);   // transform it to camera space
         object[o].draw();                    // render it
      }
   }
   ...

   Object::draw()
   {
      ...
      for(int v=0; v < num_vertices; v++)
         vertex[v].wrld = vertex[v].obj * WorldMatrix;   // the object coordinates always stay constant
      ...
      WorldMatrix=Matrix()                               // clear, because we're using absolute transformations
   }

                 WorldMatrix                 CameraMatrix
  OBJECT SPACE    -------->    WORLD SPACE    -------->    CAMERA/VIEW SPACE
                   Rot*Trl                     Trl*Rot

   Object::draw()
   {
      // draw the object itself
      ...

      // draw its children
      for(int c=0; c < num_children; c++)
      {
         child[c]->transform(WorldMatrix); // child->WorldMatrix *= this->WorldMatrix
         // this of course messes up the child's world matrix, so you can't
         // use it incrementally anymore; there are ways around this
         child[c]->draw();
      }
   }

              child.WorldMatrix                   parent.child_pos
  CHILD SPACE     -------->     RELATIVE POSITION    --------->    PARENT SPACE
               Rot and/or Trl                            Trl

   class Object
   {
      ...
      Object **child;
      Vector *child_pos;                     // to be dynamically allocated
      ...
   };

   Object::draw()
   {
      ...
      for(int c=0; c < num_children; c++)
      {
         child[c]->translate(child_pos[c]);  // get the child into this parent object's space
         child[c]->transform(WorldMatrix);   // child goes wherever the parent does
         child[c]->draw();
      }
      ...
   }

   #define IN 1
   #define PART 0
   #define OUT -1

   // 'clip' is the clipping status of the parent object
   // 'own_clip' is the status of the bounding volume encompassing only the current object's vertices

   void Object::draw(int clip=2)                 // the default, saying clipping status unknown - only happens for base objects
   {
      if(clip==2) {update_bound(); clip=PART;}   // get bounding volume 
      int own_clip=IN;

      if(clip==PART)                             // partial clipping of the parent object means uncertain status for the current object, so 'clip' has to be reevaluated
      {
         clip=MyFrustum.clip(bbox);              // clip now means the status of the bounding volume encompassing the object together with all its child objects
         own_clip=clip;                          // bbox is this all-encompassing volume
      }

      if(clip!=OUT)                              // if the whole object is not out
      {
         if(clip==PART)                          // if the whole object with children is partially in, 
            own_clip=MyFrustum.clip(own_bbox);   // there's still a chance for the main object (encompassed by own_bbox) to be totally in, eliminating unnecessary checks
   
         if(own_clip!=OUT)                       // as long as the main object is not out, try drawing it
         {
            for(int v=0; v < num_vertices; v++)  // go through all the vertices
            {
               if(own_clip==PART)                // if main object is partially out, check which parts of it are where
               {
                  if(MyFrustum.in(vertex[v]))    // checks if vertex is in the frustrum
                  {
                     vertex[v].wrld=vertex[v].obj * WrldMatrix;  // do transform and project
                     vertex[v].project();
                     vertex[v].out=0;            // flag as in
                  }
                  else
                  {
                     vertex[v].out=1;            // flag as out
                  }
               }
               else                              // if it's totally in, do everything automatically
               {
                  vertex[v].wrld=vertex[v].obj * WrldMatrix;
                  vertex[v].project();
                  vertex[v].out=0;               
               }
            }

            // if the object is not out, it's worth trying to draw its polys

            for(int p=0; p < num_polys; p++)
            {
               int p_in = poly[p] - > restore(WrldMatrix); // if restore says it makes sense
               if(p_in)
                  poly[p].draw();                          // then draw the poly
            }
         }

         // if the 'all-encompassing-volume' isn't out, it's worth trying to draw the children

         for(int c=0; c < num_children; c++)
         {
            child[c] - > draw(clip);                       // notice how I pass the current object's clipping status on to the children
         }
      }
   }


   int Poly::restore(Matrix &M)                       // accepts the WorldMatrix to restore the transformations
   {
      for(int i=0, ins=0; i < num_vertices; i++)
         if( !v[i] - > out )
            ins++;                                    // count the ins and outs
      
      if(!ins) return 0;                              // if it's all out don't even bother
   
      if(ins < num_vertices)                          // if some vertices are in, the rest have to be restored to have enough information to draw any poly at all
      {
         for(int i=0; i < num_vertices; i++)
            if(v[i]->out)
            {
               v[i]->wrld=v[i]->obj * M;
               v[i]->project();
               v[i]->out=0;
            }   
      }
   
      if(v[0]->clipped || v[1]->clipped || v[2]->clipped)  // if any of the vertices are out
      {
         MyFrustum.clip(this);                             // the poly has to be clipped
         return 0;                                         // the clipping routine manages the poly itself, so 0 is returned to not draw the old unclipped poly
      }
   
      return 1;
   }

   for(int v=0; v < num_vertices; v++)
   {
      viewvector = vertex[v].world - viewpoint;
      if ( vertex[v].world_normal · viewvector < 0 )  
         vertex[v].out=1;
   }

   int Poly::restore(Matrix &M)
   {
      for(int i=0, ins=0; i < num_vertices; i++)
      ...

      if(!ins) return 0;
      if(ins==num_vertices && cull()) return 0;  // even if the normals say everything's fine, this checks if the vertices are really clockwise; this check can only be done when all the vertex data is available

      if(ins < num_vertices)
      {
         ...
         if(cull()) return 0;                    // after reconstructing the vertex data, we can check for clockwiseness
      }
      ...
   }

   void Object::draw(int clip=2)
   {
      Matrix InverseWorldMatrix=WorldMatrix.inverse();
      Vector InverseLightVector=MyLight*InverseWorldMatrix;        // since the light is in world space, the world matrix' inverse has to be used
   
      // or
   
      Vector InverseLightVector=MyLight.rotate(InverseWorldMatrix) // if it's a directional light source, only the rotation should be applied; same goes to any directional vector
   
      transform(CameraMatrix);
      Matrix InverseWrldMatrix=WrldMatrix.inverse();
      MyFrustum.transform(InverseWrldMatrix);                      // the frustrum is defined in view space, so we have to use the whole view space transformation's inverse to get it into object space
   
      Vector InverseViewPoint=Vector(0, 0, 0)*InverseWorldMatrix;   // same with the view point
   
      ...
      if(MyFrustum.in(vertex[v]))                                    // this checks object coordinates against the above inverse transformed frustrum
      {
         if((vertex[v].obj_norm*(InverseViewPoint-vertex[0].obj))>0) // the object normal and point is used with the inverse transfromed view point
         {
             vertex[v].world=vertex[v].obj * WorldMatrix;
             vertex[v].project();
             vertex[v].out=0;
         }
         else
         {
             vertex[v].out=1;
         }
      }
      ...
   }

Further References

Check out my collection of docs for all kinds of categories

---

---

This page was last updated on 12/06/97

Back to Steel's Programming Resources