/* involute, Copyright (c) 2004-2014 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 *
 * Utilities for rendering OpenGL gears with involute teeth.
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif /* HAVE_CONFIG_H */

#include "screenhackI.h"

#ifndef HAVE_JWXYZ
# include <GL/glx.h>
# include <GL/glu.h>
#endif

#ifdef HAVE_ANDROID
# include <GLES/gl.h>
#endif

#ifdef HAVE_JWZGLES
# include "jwzgles.h"
#endif /* HAVE_JWZGLES */

#include "involute.h"
#include "normals.h"

#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))


/* For debugging: if true then in wireframe, do not abbreviate. */
static Bool wire_all_p = False;
static Bool show_normals_p = False;


/* Draws an uncapped tube of the given radius extending from top to bottom,
   with faces pointing either in or out.
 */
static int
draw_ring (int segments,
           GLfloat r, GLfloat top, GLfloat bottom, GLfloat slope,
           Bool in_p, Bool wire_p)
{
  int i;
  int polys = 0;
  GLfloat width = M_PI * 2 / segments;

  GLfloat s1 = 1 + ((bottom-top) * slope / 2);
  GLfloat s2 = 1 - ((bottom-top) * slope / 2);

  if (top != bottom)
    {
      glFrontFace (in_p ? GL_CCW : GL_CW);
      glBegin (wire_p ? GL_LINES : GL_QUAD_STRIP);
      for (i = 0; i < segments + (wire_p ? 0 : 1); i++)
        {
          GLfloat th = i * width;
          GLfloat cth = cos(th);
          GLfloat sth = sin(th);
          if (in_p)
            glNormal3f (-cth, -sth, 0);
          else
            glNormal3f (cth, sth, 0);
          glVertex3f (s1 * cth * r, s1 * sth * r, top);
          glVertex3f (s2 * cth * r, s2 * sth * r, bottom);
        }
      polys += segments;
      glEnd();
    }

  if (wire_p)
    {
      glBegin (GL_LINE_LOOP);
      for (i = 0; i < segments; i++)
        {
          GLfloat th = i * width;
          glVertex3f (cos(th) * r, sin(th) * r, top);
        }
      glEnd();
      glBegin (GL_LINE_LOOP);
      for (i = 0; i < segments; i++)
        {
          GLfloat th = i * width;
          glVertex3f (cos(th) * r, sin(th) * r, bottom);
        }
      glEnd();
    }

  return polys;
}


/* Draws a donut-shaped disc between the given radii,
   with faces pointing either up or down.
   The first radius may be 0, in which case, a filled disc is drawn.
 */
static int
draw_disc (int segments,
           GLfloat ra, GLfloat rb, GLfloat z, 
           Bool up_p, Bool wire_p)
{
  int i;
  int polys = 0;
  GLfloat width = M_PI * 2 / segments;

  if (ra <  0) abort();
  if (rb <= 0) abort();

  if (ra == 0)
    glFrontFace (up_p ? GL_CW : GL_CCW);
  else
    glFrontFace (up_p ? GL_CCW : GL_CW);

  if (ra == 0)
    glBegin (wire_p ? GL_LINES : GL_TRIANGLE_FAN);
  else
    glBegin (wire_p ? GL_LINES : GL_QUAD_STRIP);

  glNormal3f (0, 0, (up_p ? -1 : 1));

  if (ra == 0 && !wire_p)
    glVertex3f (0, 0, z);

  for (i = 0; i < segments + (wire_p ? 0 : 1); i++)
    {
      GLfloat th = i * width;
      GLfloat cth = cos(th);
      GLfloat sth = sin(th);
      if (wire_p || ra != 0)
        glVertex3f (cth * ra, sth * ra, z);
      glVertex3f (cth * rb, sth * rb, z);
    }
  polys += segments;
  glEnd();
  return polys;
}


/* Draws N thick radial lines between the given radii,
   with faces pointing either up or down.
 */
static int
draw_spokes (int n, GLfloat thickness, int segments,
             GLfloat ra, GLfloat rb, GLfloat z1, GLfloat z2, GLfloat slope,
             Bool wire_p)
{
  int i;
  int polys = 0;
  GLfloat width;
  int segments2 = 0;
  int insegs, outsegs;
  int tick;
  int state;

  GLfloat s1 = 1 + ((z2-z1) * slope / 2);
  GLfloat s2 = 1 - ((z2-z1) * slope / 2);

  if (ra <= 0 || rb <= 0) abort();

  segments *= 3;

  while (segments2 < segments) /* need a multiple of N >= segments */
    segments2 += n;            /* (yes, this is a moronic way to find that) */

  insegs  = ((float) (segments2 / n) + 0.5) / thickness;
  outsegs = (segments2 / n) - insegs;
  if (insegs  <= 0) insegs = 1;
  if (outsegs <= 0) outsegs = 1;

  segments2 = (insegs + outsegs) * n;
  width = M_PI * 2 / segments2;

  tick = 0;
  state = 0;
  for (i = 0; i < segments2; i++, tick++)
    {
      GLfloat th1 = i * width;
      GLfloat th2 = th1 + width;
      GLfloat cth1 = cos(th1);
      GLfloat sth1 = sin(th1);
      GLfloat cth2 = cos(th2);
      GLfloat sth2 = sin(th2);
      GLfloat orb = rb;

      int changed = (i == 0);

      if (state == 0 && tick == insegs)
        tick = 0, state = 1, changed = 1;
      else if (state == 1 && tick == outsegs)
        tick = 0, state = 0, changed = 1;

      if ((state == 1 ||                /* in */
           (state == 0 && changed)) &&
          (!wire_p || wire_all_p))
        {
          /* top */
          glFrontFace (GL_CCW);
          glBegin (wire_p ? GL_LINES : GL_QUADS);
          glNormal3f (0, 0, -1);
          glVertex3f (s1 * cth1 * ra, s1 * sth1 * ra, z1);
          glVertex3f (s1 * cth1 * rb, s1 * sth1 * rb, z1);
          glVertex3f (s1 * cth2 * rb, s1 * sth2 * rb, z1);
          glVertex3f (s1 * cth2 * ra, s1 * sth2 * ra, z1);
          polys++;
          glEnd();

          /* bottom */
          glFrontFace (GL_CW);
          glBegin (wire_p ? GL_LINES : GL_QUADS);
          glNormal3f (0, 0, 1);
          glVertex3f (s2 * cth1 * ra, s2 * sth1 * ra, z2);
          glVertex3f (s2 * cth1 * rb, s2 * sth1 * rb, z2);
          glVertex3f (s2 * cth2 * rb, s2 * sth2 * rb, z2);
          glVertex3f (s2 * cth2 * ra, s2 * sth2 * ra, z2);
          polys++;
          glEnd();
        }

      if (state == 1 && changed)   /* entering "in" state */
        {
          /* left */
          glFrontFace (GL_CW);
          glBegin (wire_p ? GL_LINES : GL_QUADS);
          do_normal (s1 * cth1 * rb, s1 * sth1 * rb, z1,
                     s1 * cth1 * ra, s1 * sth1 * ra, z1,
                     s2 * cth1 * rb, s2 * sth1 * rb, z2);
          glVertex3f (s1 * cth1 * ra, s1 * sth1 * ra, z1);
          glVertex3f (s1 * cth1 * rb, s1 * sth1 * rb, z1);
          glVertex3f (s2 * cth1 * rb, s2 * sth1 * rb, z2);
          glVertex3f (s2 * cth1 * ra, s2 * sth1 * ra, z2);
          polys++;
          glEnd();
        }

      if (state == 0 && changed)   /* entering "out" state */
        {
          /* right */
          glFrontFace (GL_CCW);
          glBegin (wire_p ? GL_LINES : GL_QUADS);
          do_normal (s1 * cth2 * ra, s1 * sth2 * ra, z1,
                     s1 * cth2 * rb, s1 * sth2 * rb, z1,
                     s2 * cth2 * rb, s2 * sth2 * rb, z2);
          glVertex3f (s1 * cth2 * ra, s1 * sth2 * ra, z1);
          glVertex3f (s1 * cth2 * rb, s1 * sth2 * rb, z1);
          glVertex3f (s2 * cth2 * rb, s2 * sth2 * rb, z2);
          glVertex3f (s2 * cth2 * ra, s2 * sth2 * ra, z2);
          polys++;
          glEnd();
        }

      rb = orb;
    }
  return polys;
}


/* Draws some bumps (embedded cylinders) on the gear.
 */
static int
draw_gear_nubs (gear *g, Bool wire_p)
{
  int polys = 0;
  int i;
  int steps = (g->size < INVOLUTE_LARGE ? 5 : 20);
  double r, size, height;
  GLfloat *cc;
  int which;
  GLfloat width, off;

  if (! g->nubs) return 0;

  which = involute_biggest_ring (g, &r, &size, &height);
  size /= 5;
  height *= 0.7;

  cc = (which == 1 ? g->color : g->color2);
  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cc);

  if (g->inverted_p)
    r = g->r + size + g->tooth_h;

  width = M_PI * 2 / g->nubs;
  off = M_PI / (g->nteeth * 2);  /* align first nub with a tooth */

  for (i = 0; i < g->nubs; i++)
    {
      GLfloat th = (i * width) + off;
      glPushMatrix();

      glRotatef (th * 180 / M_PI, 0, 0, 1);
      glTranslatef (r, 0, 0);

      if (g->inverted_p)	/* nubs go on the outside rim */
        {
          size = g->thickness / 3;
          height = (g->r - g->inner_r)/2;
          glTranslatef (height, 0, 0);
          glRotatef (90, 0, 1, 0);
        }

      if (wire_p && !wire_all_p)
        polys += draw_ring ((g->size >= INVOLUTE_LARGE ? steps/2 : steps),
                            size, 0, 0, 0, False, wire_p);
      else
        {
          polys += draw_disc (steps, 0, size, -height,      True,  wire_p);
          polys += draw_disc (steps, 0, size,  height,      False, wire_p);
          polys += draw_ring (steps, size, -height, height, 0, False, wire_p);
        }
      glPopMatrix();
    }
  return polys;
}



/* Draws a much simpler representation of a gear.
   Returns the number of polygons.
 */
int
draw_involute_schematic (gear *g, Bool wire_p)
{
  int polys = 0;
  int i;
  GLfloat width = M_PI * 2 / g->nteeth;

  if (!wire_p) glDisable(GL_LIGHTING);
  glColor3f (g->color[0] * 0.6, g->color[1] * 0.6, g->color[2] * 0.6);

  glBegin (GL_LINES);
  for (i = 0; i < g->nteeth; i++)
    {
      GLfloat th = (i * width) + (width/4);
      glVertex3f (0, 0, -g->thickness/2);
      glVertex3f (cos(th) * g->r, sin(th) * g->r, -g->thickness/2);
    }
  polys += g->nteeth;
  glEnd();

  glBegin (GL_LINE_LOOP);
  for (i = 0; i < g->nteeth; i++)
    {
      GLfloat th = (i * width) + (width/4);
      glVertex3f (cos(th) * g->r, sin(th) * g->r, -g->thickness/2);
    }
  polys += g->nteeth;
  glEnd();

  if (!wire_p) glEnable(GL_LIGHTING);
  return polys;
}


/* Renders all the interior (non-toothy) parts of a gear:
   the discs, axles, etc.
 */
static int
draw_gear_interior (gear *g, Bool wire_p)
{
  int polys = 0;

  int steps = g->nteeth * 2;
  if (steps < 10) steps = 10;
  if ((wire_p && !wire_all_p) || g->size < INVOLUTE_LARGE) steps /= 2;
  if (g->size < INVOLUTE_LARGE && steps > 16) steps = 16;

  /* ring 1 (facing in) is done in draw_gear_teeth */

  /* ring 2 (facing in) and disc 2
   */
  if (g->inner_r2)
    {
      GLfloat ra = g->inner_r * 1.04;  /* slightly larger than inner_r */
      GLfloat rb = g->inner_r2;        /*  since the points don't line up */
      GLfloat za = -g->thickness2/2;
      GLfloat zb =  g->thickness2/2;
      GLfloat s1 = 1 + (g->thickness2 * g->tooth_slope / 2);
      GLfloat s2 = 1 - (g->thickness2 * g->tooth_slope / 2);

      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, g->color2);

      if ((g->coax_p != 1 && !g->inner_r3) ||
          (wire_p && wire_all_p))
        polys +=   /* ring facing in */
          draw_ring (steps, rb, za, zb, g->tooth_slope, True, wire_p);

      if (wire_p && wire_all_p)
        polys +=  /* ring facing in */
          draw_ring (steps, ra, za, zb, g->tooth_slope, True, wire_p);

      if (g->spokes)
        polys += draw_spokes (g->spokes, g->spoke_thickness,
                              steps, ra, rb, za, zb, g->tooth_slope, wire_p);
      else if (!wire_p || wire_all_p)
        {
          polys +=   /* top plate */
            draw_disc (steps, s1*ra, s1*rb, za, True, wire_p);
          polys +=   /* bottom plate */
            draw_disc (steps, s2*ra, s2*rb, zb, False, wire_p);
        }
    }

  /* ring 3 (facing in and out) and disc 3
   */
  if (g->inner_r3)
    {
      GLfloat ra = g->inner_r2;
      GLfloat rb = g->inner_r3;
      GLfloat za = -g->thickness3/2;
      GLfloat zb =  g->thickness3/2;
      GLfloat s1 = 1 + (g->thickness3 * g->tooth_slope / 2);
      GLfloat s2 = 1 - (g->thickness3 * g->tooth_slope / 2);

      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, g->color);

      polys +=   /* ring facing out */
        draw_ring (steps, ra, za, zb, g->tooth_slope, False, wire_p);

      if (g->coax_p != 1 || (wire_p && wire_all_p))
        polys += /* ring facing in */
          draw_ring (steps, rb, za, zb, g->tooth_slope, True, wire_p);

      if (!wire_p || wire_all_p)
        {
          polys +=   /* top plate */
            draw_disc (steps, s1*ra, s1*rb, za, True, wire_p);
          polys +=  /* bottom plate */
            draw_disc (steps, s2*ra, s2*rb, zb, False, wire_p);
        }
    }

  /* axle tube
   */
  if (g->coax_p == 1)
    {
      GLfloat cap_height = g->coax_thickness/3;

      GLfloat ra = (g->inner_r3 ? g->inner_r3 :
                    g->inner_r2 ? g->inner_r2 :
                    g->inner_r);
      GLfloat za = -(g->thickness/2 + cap_height);
      GLfloat zb = g->coax_thickness/2 + g->coax_displacement + cap_height;

      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, g->color);

      if (wire_p && !wire_all_p) steps /= 2;

      polys += 
        draw_ring (steps, ra, za, zb, g->tooth_slope, False, wire_p);

      if (!wire_p || wire_all_p)
        {
          polys += 
            draw_disc (steps, 0,  ra, za, True, wire_p);  /* top plate */
          polys +=
            draw_disc (steps, 0,  ra, zb, False, wire_p); /* bottom plate */
        }
    }
  return polys;
}


/* gear_teeth_geometry computes the vertices and normals of the teeth
   of a gear.  This is the heavy lifting: there are a ton of polygons
   around the perimiter of a gear, and the normals are difficult (not
   radial or right angles.)

   It would be nice if we could cache this, but the numbers are
   different for essentially every gear:

      - Every gear has a different inner_r, so the vertices of the
        inner ring (and thus, the triangle fans on the top and bottom
        faces) are different in a non-scalable way.

      - If the ratio between tooth_w and tooth_h changes, the normals
        on the outside edges of the teeth are invalid (this can happen
        every time we start a new train.)

   So instead, we rely on OpenGL display lists to do the cacheing for
   us -- we only compute all these normals once per gear, instead of
   once per gear per frame.
 */

typedef struct {
  int npoints;
  XYZ *points;
  XYZ *fnormals;  /* face normals */
  XYZ *pnormals;  /* point normals */
} tooth_face;


static void
tooth_normals (tooth_face *f, GLfloat tooth_slope)
{
  int i;

  /* Compute the face normals for each facet. */
  for (i = 0; i < f->npoints; i++)
    {
      XYZ p1, p2, p3;
      int a = i;
      int b = (i == f->npoints-1 ? 0 : i+1);
      p1 = f->points[a];
      p2 = f->points[b];
      p3 = p1;
      p3.x -= (p3.x * tooth_slope);
      p3.y -= (p3.y * tooth_slope);
      p3.z++;
      f->fnormals[i] = calc_normal (p1, p2, p3);
    }

  /* From the face normals, compute the vertex normals
     (by averaging the normals of adjascent faces.)
   */
  for (i = 0; i < f->npoints; i++)
    {
      int a = (i == 0 ? f->npoints-1 : i-1);
      int b = i;
      XYZ n1 = f->fnormals[a];   /* normal of [i-1 - i] face */
      XYZ n2 = f->fnormals[b];   /* normal of [i - i+1] face */
      f->pnormals[i].x = (n1.x + n2.x) / 2;
      f->pnormals[i].y = (n1.y + n2.y) / 2;
      f->pnormals[i].z = (n1.z + n2.z) / 2;
    }
}


static void
gear_teeth_geometry (gear *g,
                     tooth_face *orim,      /* outer rim (the teeth) */
                     tooth_face *irim)      /* inner rim (the hole)  */
{
  int i;
  int ppt = 20;   /* max points per tooth */
  GLfloat width = M_PI * 2 / g->nteeth;
  GLfloat rh = g->tooth_h;
  GLfloat tw = width;

  /* Approximate shape of an "involute" gear tooth.

                                 (TH)
                 th0 th2 th4 th6 th8 t10 t12 t14 th16  th18   th20
                   :  :  :   :    :    :   :  :  :      :      :
                   :  :  :   :    :    :   :  :  :      :      :
        r0 ........:..:..:...___________...:..:..:......:......:..
                   :  :  :  /:    :    :\  :  :  :      :      :
                   :  :  : / :    :    : \ :  :  :      :      :
                   :  :  :/  :    :    :  \:  :  :      :      :
        r2 ........:.....@...:....:....:...@..:..:......:......:..
                   :  : @:   :    :    :   :@ :  :      :      :
    (R) ...........:...@.:...:....:....:...:.@..........:......:......
                   :  :@ :   :    :    :   : @:  :      :      :
        r4 ........:..@..:...:....:....:...:..@:........:......:..
                   : /:  :   :    :    :   :  :\ :      :      :
                   :/ :  :   :    :    :   :  : \:      :      : /
        r6 ......__/..:..:...:....:....:...:..:..\______________/
                   :  :  :   :    :    :   :  :  :      :      :
                   |  :  :   :    :    :   :  :  |      :      :
                   :  :  :   :    :    :   :  :  :      :      :
                   |  :  :   :    :    :   :  :  |      :      :
        r8 ......__:_____________________________:________________
   */

  GLfloat r[30];
  GLfloat th[30];
  GLfloat R = g->r;

  r[0] = R + (rh * 0.50);
  r[1] = R + (rh * 0.40);
  r[2] = R + (rh * 0.25);
  r[3] = R + (rh * 0.05);
  r[4] = R - (r[2]-R);
  r[5] = R - (r[1]-R);
  r[6] = R - (r[0]-R);
  r[7] = r[6]; /* unused */
  r[8] = g->inner_r;

  th[0]  = -tw * (g->size == INVOLUTE_SMALL ? 0.5 : 
                  g->size == INVOLUTE_MEDIUM ? 0.41 : 0.45);
  th[1]  = -tw * 0.375;
  th[2]  = -tw * 0.300;
  th[3]  = -tw * 0.230;
  th[4]  = -tw * (g->nteeth >= 5 ? 0.16 : 0.12);
  th[5]  = -tw * 0.100;
  th[6]  = -tw * (g->size == INVOLUTE_MEDIUM ? 0.1 : 0.04);
  th[7]  = -tw * 0.020;
  th[8]  =  0;
  th[9]  = -th[7];
  th[10] = -th[6];
  th[11] = -th[5];
  th[12] = -th[4];
  th[13] = -th[3];
  th[14] = -th[2];
  th[15] = -th[1];
  th[16] = -th[0];
  th[17] =  width * 0.47;
  th[18] =  width * 0.50;
  th[19] =  width * 0.53;
  th[20] =  th[0] + width; /* unused */

  if (g->inverted_p)   /* put the teeth on the inside */
    {
      for (i = 0; i < countof(th); i++)
        th[i] = -th[i];
      for (i = 0; i < countof(r); i++)
        r[i] = R - (r[i] - R);
    }

  orim->npoints  = 0;
  orim->points   = (XYZ *) calloc(ppt * g->nteeth+1, sizeof(*orim->points));
  orim->fnormals = (XYZ *) calloc(ppt * g->nteeth+1, sizeof(*orim->fnormals));
  orim->pnormals = (XYZ *) calloc(ppt * g->nteeth+1, sizeof(*orim->pnormals));

  irim->npoints  = 0;
  irim->points   = (XYZ *) calloc(ppt * g->nteeth+1, sizeof(*irim->points));
  irim->fnormals = (XYZ *) calloc(ppt * g->nteeth+1, sizeof(*irim->fnormals));
  irim->pnormals = (XYZ *) calloc(ppt * g->nteeth+1, sizeof(*irim->pnormals));

  if (!orim->points || !orim->pnormals || !orim->fnormals ||
      !irim->points || !irim->pnormals || !irim->fnormals)
    {
      fprintf (stderr, "%s: out of memory\n", progname);
      exit (1);
    }

  /* First, compute the coordinates of every point used for every tooth.
   */
  for (i = 0; i < g->nteeth; i++)
    {
      GLfloat TH = (i * width) + (width/4);
      int oon = orim->npoints;
      int oin = irim->npoints;

#     undef PUSH
#     define PUSH(OPR,IPR,PTH) \
        orim->points[orim->npoints].x = cos(TH+th[(PTH)]) * r[(OPR)]; \
        orim->points[orim->npoints].y = sin(TH+th[(PTH)]) * r[(OPR)]; \
        orim->npoints++; \
        irim->points[irim->npoints].x = cos(TH+th[(PTH)]) * r[(IPR)]; \
        irim->points[irim->npoints].y = sin(TH+th[(PTH)]) * r[(IPR)]; \
        irim->npoints++

      switch (g->size) {
      case INVOLUTE_SMALL:
        PUSH(6, 8, 0);       /* tooth left 1 */
        PUSH(0, 8, 8);       /* tooth top middle */
        break;
      case INVOLUTE_MEDIUM:
        PUSH(6, 8, 0);       /* tooth left 1 */
        PUSH(0, 8, 6);       /* tooth top left */
        PUSH(0, 8, 10);      /* tooth top right */
        PUSH(6, 8, 16);      /* tooth right 6 */
        break;
      case INVOLUTE_LARGE:
        PUSH(6, 8, 0);       /* tooth left 1 */
        PUSH(4, 8, 2);       /* tooth left 3 */
        PUSH(2, 8, 4);       /* tooth left 5 */
        PUSH(0, 8, 6);       /* tooth top left */
        PUSH(0, 8, 10);      /* tooth top right */
        PUSH(2, 8, 12);      /* tooth right 1 */
        PUSH(4, 8, 14);      /* tooth right 3 */
        PUSH(6, 8, 16);      /* tooth right 5 */
        PUSH(6, 8, 18);      /* gap top */
        break;
      case INVOLUTE_HUGE:
        PUSH(6, 8, 0);       /* tooth left 1 */
        PUSH(5, 8, 1);       /* tooth left 2 */
        PUSH(4, 8, 2);       /* tooth left 3 */
        PUSH(3, 8, 3);       /* tooth left 4 */
        PUSH(2, 8, 4);       /* tooth left 5 */
        PUSH(1, 8, 5);       /* tooth left 6 */
        PUSH(0, 8, 6);       /* tooth top left */
        PUSH(0, 8, 8);       /* tooth top left */
        PUSH(0, 8, 10);      /* tooth top right */
        PUSH(1, 8, 11);      /* tooth top right */
        PUSH(2, 8, 12);      /* tooth right 1 */
        PUSH(3, 8, 13);      /* tooth right 2 */
        PUSH(4, 8, 14);      /* tooth right 3 */
        PUSH(5, 8, 15);      /* tooth right 4 */
        PUSH(6, 8, 16);      /* tooth right 5 */
        PUSH(6, 8, 17);      /* tooth right 6 */
        PUSH(6, 8, 18);      /* gap top */
        PUSH(6, 8, 19);      /* gap top */
        break;
      default:
        abort();
      }
#     undef PUSH

      if (i == 0 && orim->npoints > ppt) abort();  /* go update "ppt"! */

      if (g->inverted_p)
        {
          int start, end, j;
          start = oon;
          end = orim->npoints;
          for (j = 0; j < (end-start)/2; j++)
            {
              XYZ swap = orim->points[end-j-1];
              orim->points[end-j-1] = orim->points[start+j];
              orim->points[start+j] = swap;
            }

          start = oin;
          end = irim->npoints;
          for (j = 0; j < (end-start)/2; j++)
            {
              XYZ swap = irim->points[end-j-1];
              irim->points[end-j-1] = irim->points[start+j];
              irim->points[start+j] = swap;
            }
        }
    }

  tooth_normals (orim, g->tooth_slope);
  tooth_normals (irim, 0);

  if (g->inverted_p)   /* flip the normals */
    {
      for (i = 0; i < orim->npoints; i++)
        {
          orim->fnormals[i].x = -orim->fnormals[i].x;
          orim->fnormals[i].y = -orim->fnormals[i].y;
          orim->fnormals[i].z = -orim->fnormals[i].z;

          orim->pnormals[i].x = -orim->pnormals[i].x;
          orim->pnormals[i].y = -orim->pnormals[i].y;
          orim->pnormals[i].z = -orim->pnormals[i].z;
        }

      for (i = 0; i < irim->npoints; i++)
        {
          irim->fnormals[i].x = -irim->fnormals[i].x;
          irim->fnormals[i].y = -irim->fnormals[i].y;
          irim->fnormals[i].z = -irim->fnormals[i].z;

          irim->pnormals[i].x = -irim->pnormals[i].x;
          irim->pnormals[i].y = -irim->pnormals[i].y;
          irim->pnormals[i].z = -irim->pnormals[i].z;
        }
    }
}


/* Which of the gear's inside rings is the biggest? 
 */
int
involute_biggest_ring (gear *g, double *posP, double *sizeP, double *heightP)
{
  double r0 = (g->r - g->tooth_h/2);
  double r1 = g->inner_r;
  double r2 = g->inner_r2;
  double r3 = g->inner_r3;
  double w1 = (r1 ? r0 - r1 : r0);
  double w2 = (r2 ? r1 - r2 : 0);
  double w3 = (r3 ? r2 - r3 : 0);
  double h1 = g->thickness;
  double h2 = g->thickness2;
  double h3 = g->thickness3;

  if (g->spokes) w2 = 0;

  if (w1 > w2 && w1 > w3)
    {
      if (posP)    *posP = (r0+r1)/2;
      if (sizeP)   *sizeP = w1;
      if (heightP) *heightP = h1;
      return 0;
    }
  else if (w2 > w1 && w2 > w3)
    {
      if (posP)  *posP = (r1+r2)/2;
      if (sizeP) *sizeP = w2;
      if (heightP) *heightP = h2;
      return 1;
    }
  else
    {
      if (posP)  *posP = (r2+r3)/2;
      if (sizeP) *sizeP = w3;
      if (heightP) *heightP = h3;
      return 1;
    }
}


/* Renders all teeth of a gear.
 */
static int
draw_gear_teeth (gear *g, Bool wire_p)
{
  int polys = 0;
  int i;

  GLfloat z1 = -g->thickness/2;
  GLfloat z2 =  g->thickness/2;
  GLfloat s1 = 1 + (g->thickness * g->tooth_slope / 2);
  GLfloat s2 = 1 - (g->thickness * g->tooth_slope / 2);

  tooth_face orim, irim;
  gear_teeth_geometry (g, &orim, &irim);

  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, g->color);

  /* Draw the outer rim (the teeth)
     (In wire mode, this draws just the upright lines.)
   */
  glFrontFace (g->inverted_p ? GL_CCW : GL_CW);
  glBegin (wire_p ? GL_LINES : GL_QUAD_STRIP);
  for (i = 0; i < orim.npoints; i++)
    {
      glNormal3f (orim.pnormals[i].x, orim.pnormals[i].y, orim.pnormals[i].z);
      glVertex3f (s1*orim.points[i].x, s1*orim.points[i].y, z1);
      glVertex3f (s2*orim.points[i].x, s2*orim.points[i].y, z2);

      /* Show the face normal vectors */
      if (0&&wire_p && show_normals_p)
        {
          XYZ n = orim.fnormals[i];
          int a = i;
          int b = (i == orim.npoints-1 ? 0 : i+1);
          GLfloat x = (orim.points[a].x + orim.points[b].x) / 2;
          GLfloat y = (orim.points[a].y + orim.points[b].y) / 2;
          GLfloat z = (z1 + z2) / 2;
          glVertex3f (x, y, z);
          glVertex3f (x + n.x, y + n.y, z + n.z);
        }

      /* Show the vertex normal vectors */
      if (wire_p && show_normals_p)
        {
          XYZ n = orim.pnormals[i];
          GLfloat x = orim.points[i].x;
          GLfloat y = orim.points[i].y;
          GLfloat z = (z1 + z2) / 2;
          glVertex3f (x, y, z);
          glVertex3f (x + n.x, y + n.y, z + n.z);
        }
    }

  if (!wire_p)  /* close the quad loop */
    {
      glNormal3f (orim.pnormals[0].x, orim.pnormals[0].y, orim.pnormals[0].z);
      glVertex3f (s1*orim.points[0].x, s1*orim.points[0].y, z1);
      glVertex3f (s2*orim.points[0].x, s2*orim.points[0].y, z2);
    }
  polys += orim.npoints;
  glEnd();

  /* Draw the outer rim circles, in wire mode */
  if (wire_p)
    {
      glBegin (GL_LINE_LOOP);
      for (i = 0; i < orim.npoints; i++)
        glVertex3f (s1*orim.points[i].x, s1*orim.points[i].y, z1);
      glEnd();
      glBegin (GL_LINE_LOOP);
      for (i = 0; i < orim.npoints; i++)
        glVertex3f (s2*orim.points[i].x, s2*orim.points[i].y, z2);
      glEnd();
    }

  /* Draw the inner rim (the hole)
     (In wire mode, this draws just the upright lines.)
   */
  glFrontFace (g->inverted_p ? GL_CW : GL_CCW);
  glBegin (wire_p ? GL_LINES : GL_QUAD_STRIP);
  for (i = 0; i < irim.npoints; i++)
    {
      glNormal3f(-irim.pnormals[i].x, -irim.pnormals[i].y,-irim.pnormals[i].z);
      glVertex3f (s1*irim.points[i].x, s1*irim.points[i].y, z1);
      glVertex3f (s2*irim.points[i].x, s2*irim.points[i].y, z2);

      /* Show the face normal vectors */
      if (wire_p && show_normals_p)
        {
          XYZ n = irim.fnormals[i];
          int a = i;
          int b = (i == irim.npoints-1 ? 0 : i+1);
          GLfloat x = (irim.points[a].x + irim.points[b].x) / 2;
          GLfloat y = (irim.points[a].y + irim.points[b].y) / 2;
          GLfloat z  = (z1 + z2) / 2;
          glVertex3f (x, y, z);
          glVertex3f (x - n.x, y - n.y, z);
        }

      /* Show the vertex normal vectors */
      if (wire_p && show_normals_p)
        {
          XYZ n = irim.pnormals[i];
          GLfloat x = irim.points[i].x;
          GLfloat y = irim.points[i].y;
          GLfloat z = (z1 + z2) / 2;
          glVertex3f (x, y, z);
          glVertex3f (x - n.x, y - n.y, z);
        }
    }

  if (!wire_p)  /* close the quad loop */
    {
      glNormal3f (-irim.pnormals[0].x,-irim.pnormals[0].y,-irim.pnormals[0].z);
      glVertex3f (s1*irim.points[0].x, s1*irim.points[0].y, z1);
      glVertex3f (s2*irim.points[0].x, s2*irim.points[0].y, z2);
    }
  polys += irim.npoints;
  glEnd();

  /* Draw the inner rim circles, in wire mode
   */
  if (wire_p)
    {
      glBegin (GL_LINE_LOOP);
      for (i = 0; i < irim.npoints; i++)
        glVertex3f (irim.points[i].x, irim.points[i].y, z1);
      glEnd();
      glBegin (GL_LINE_LOOP);
      for (i = 0; i < irim.npoints; i++)
        glVertex3f (irim.points[i].x, irim.points[i].y, z2);
      glEnd();
    }

  /* Draw the side (the flat bit)
   */
  if (!wire_p || wire_all_p)
    {
      GLfloat z;
      if (irim.npoints != orim.npoints) abort();
      for (z = z1; z <= z2; z += z2-z1)
        {
          GLfloat s = (z == z1 ? s1 : s2);
          glFrontFace (((z == z1) ^ g->inverted_p) ? GL_CCW : GL_CW);
          glNormal3f (0, 0, z);
          glBegin (wire_p ? GL_LINES : GL_QUAD_STRIP);
          for (i = 0; i < orim.npoints; i++)
            {
              glVertex3f (s*orim.points[i].x, s*orim.points[i].y, z);
              glVertex3f (s*irim.points[i].x, s*irim.points[i].y, z);
            }
          if (!wire_p)  /* close the quad loop */
            {
              glVertex3f (s*orim.points[0].x, s*orim.points[0].y, z);
              glVertex3f (s*irim.points[0].x, s*irim.points[0].y, z);
            }
          polys += orim.npoints;
          glEnd();
        }
    }

  free (irim.points);
  free (irim.fnormals);
  free (irim.pnormals);

  free (orim.points);
  free (orim.fnormals);
  free (orim.pnormals);

  return polys;
}


/* Render one gear, unrotated at 0,0.
   Returns the number of polygons.
 */
int
draw_involute_gear (gear *g, Bool wire_p)
{
  int polys = 0;

  static const GLfloat spec[4] = {1.0, 1.0, 1.0, 1.0};
  GLfloat shiny   = 128.0;

  glMaterialfv (GL_FRONT, GL_SPECULAR,  spec);
  glMateriali  (GL_FRONT, GL_SHININESS, shiny);
  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, g->color);
  glColor3f (g->color[0], g->color[1], g->color[2]);

  if (wire_p > 1)
    polys += draw_involute_schematic (g, wire_p);
  else
    {
      glPushMatrix();
      glRotatef (g->wobble, 1, 0, 0);
      polys += draw_gear_teeth (g, wire_p);
      polys += draw_gear_interior (g, wire_p);
      polys += draw_gear_nubs (g, wire_p);
      glPopMatrix();
    }
  return polys;
}
