class classic_sbuffer_span {
             float start_x;
             float end_x;
             float start_ooz; // 1/z, d(1/z)/dx

             ...              // gradient setup for u and v, etc

             classic_sbuffer_poly * poly;
             classic_sbuffer_span * next;
       };
 

         class immediate_sbuffer_span {
               float start_x;
               float end_x;
               float start_ooz;
               float doozdx;
               immediate_sbuffer_span * next;
         };
 

       class bst_span {
             float start_x, end_x; 
             bst_span * next, * prev;
       };
 

       class cbuffer_span {
           float start_x, end_x;
           cbuffer_span * next;
       };
 

  Example 1               
    Poly to draw         -------------|XXXXXXXXXXXX|-----------  
    Existing Span        -----|XXXXXXXXXXXX|-------------------  
    Rendered portion     ------------------|XXXXXXX|-----------  
    New Span in cbuffer  -----|XXXXXXXXXXXXXXXXXXXX|-----------  

  Example 2 
    Poly to draw         ---------|XXXXXXXXXXXX|---------------  
    Existing Spans       ------|XXXXX|------|XXXXXX|-----------  
    Rendered Portion     ------------|XXXXXX|------------------  
    New Span in cbuffer  ------|XXXXXXXXXXXXXXXXXXX|-----------  

  Example 3 
    Poly to draw         ---|XXXXXXXXXXXXXXXXXX|---------------  
    Existing Spans       ------|XXXXX|------|XXXXXX|-----------  
    Rendered Portions    ---|XX|-----|XXXXXX|------------------  
    New Span in cbuffer  ---|XXXXXXXXXXXXXXXXXXXXXX|-----------  
 

  
            bool test_visible(cbuffer_line & line,int start_x,int end_x) {
                 cbuffer_span *scan = line.spans;
                 while (scan) {
                    if (end_x <  scan->start_x) return false;
                    if (start_x <= scan->end_x) return true;
                    scan = scan->next;
                 }
                 return false;
            }
 

      class aeh_edge {
            int type;  // start or end of a span - 1 or -1.
            float x, ooz;
            int y, last_y;
            float dxdy, doozdx, doozdy;
            aeh_poly * poly;
      };
 

  
         while (heap isnt empty) {
             look at node at top of heap
                if its the start of an edge add poly to the list of current spans. 
                else remove poly from the list of current spans.

             increase y, if its less than last_y then
                add dxdy and doozdy to the x and ooz values and reinsert (you can
                quickly reinsert the top node of a binomial heap by decreasing its
                priority and then verifying the heap sorting property.)

             draw from the coordinate stated to the node at the top of the heap.
         }
 

plane' = (v1-eye) cross (v2-eye) 

side = the sign of ((vertex-eye) . plane') 

  
    left
   /    \
solid   right
        /    \
    solid    top
             /  \
         solid  bottom
                /    \
             solid   open
 

     #define EPSILON 1.0e-6

     int convervative_signof(float value) {
          int result;
          if (value < -EPSILON) return 1;
          else if (value > EPSILON) return 2;
          else return 0;
     }

     bool recursive_insertion(vertex * fragment, int nvertices, beamtree_node & node) {
          int sign=0, * signs = (int *)alloca(nvertices*sizeof(int));
          for (int i=0;i<nvertices;++i) {
              sign |= signs[i] = conservative_signof (fragment[i] dot node.plane);
          }
          if (sign == 1) {
              // generally you just throw these away as terminating on a solid node.
          } else if (sign == 2) {
              right_attach(fragment,nvertices,node);
          } else if (sign == 3) {
              if (node->left) {

                  in here find the contiguous set of vertices that have a
                  conservative_signof of all 0's and 1's, passing along any
                  2's that precede or follow a beginning or final 1. this
                  needs to wrap around to the beginning of the set as well.

                  recursive_insertion(the set, # of verts, *node->left);
             } else {
                  // throw it away as terminating on a solid node
             }

             out here find the contiguous set of vertices that have a
             conservative_signof of all 0's and 2's, and along any 1's
             that precede or follow a beginning or final 2.

             if (node->right) {
                 recursive_insertion(the set, # of verts, *node->right);
             } else {
                 right_attach(the set, number of vertices in the set, node);
             }
          }
     }
 

  
         plane
         /   \ 
      -plane  open
       /  \
   solid   open