progs/demos/geartrain.c

   1
   2 /*
   3  * GearTrain Simulator * Version:  1.00
   4  *
   5  * Copyright (C) 1999  Shobhan Kumar Dutta  All Rights Reserved.
   6  * <skdutta@del3.vsnl.net.in>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * SHOBHAN KUMAR DUTTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
  23  * OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  */
  26
  27
  28 #include <assert.h>
  29 #include <math.h>
  30 #include <stdlib.h>
  31 #include <GL/glut.h>
  32 #include <string.h>
  33 #include <stdio.h>
  34
  35 #ifndef min
  36 #define min(x, y) ( x < y ? x : y )
  37 #endif
  38
  39 #ifndef M_PI
  40 #define M_PI 3.14159265
  41 #endif  /*  */
  42 typedef GLfloat TDA[4];
  43
  44 TDA background;
  45
  46
  47 struct AXLE
  48   {
  49     char name[20];
  50       GLint id;
  51       GLfloat radius;
  52       GLint axis;
  53       TDA color;
  54       TDA position;
  55       GLfloat length;
  56       GLint motored;
  57       GLfloat angular_velocity;
  58       GLint direction;
  59   };
  60
  61
  62 struct GEAR
  63   {
  64     char name[20];
  65     char type[7];
  66       GLint face;
  67       GLint id;
  68       GLfloat radius;
  69       GLfloat width;
  70       GLint teeth;
  71       GLfloat tooth_depth;
  72       GLfloat angle;
  73       GLfloat angular_velocity;
  74       TDA color;
  75       GLint relative_position;
  76       TDA position;
  77     char axle_name[20];
  78       GLint axis;
  79       GLint direction;
  80       GLint motored;
  81   };
  82
  83
  84 struct BELT
  85   {
  86     char name[20];
  87       GLint id;
  88     char gear1_name[20];
  89     char gear2_name[20];
  90   };
  91
  92
  93 FILE * mainfile;
  94 struct GEAR g[10];
  95 struct AXLE a[10];
  96 struct BELT b[10];
  97 int number_of_gears;
  98 int number_of_axles;
  99 int number_of_belts;
 100
 101
 102 char Buf1[256], Buf2[256], Buf3[256], Buf4[256], Buf5[256];
 103
 104 static GLint T0 = 0;
 105 static GLint Frames = 0;
 106
 107
 108 #ifndef _WIN32
 109 static void
 110 strset (char buf[], char ch)
 111 {
 112     int i;
 113     for (i = 0; i < strlen (buf); i++)
 114       buf[i] = ch;
 115 }
 116 #endif
 117
 118
 119 static void
 120 Clear_Buffers ()
 121 {
 122     strset (Buf1, 0);
 123     strset (Buf2, 0);
 124     strset (Buf3, 0);
 125     strset (Buf4, 0);
 126     strset (Buf5, 0);
 127 }
 128
 129
 130 static void
 131 LoadTriplet (TDA A)
 132 {
 133     int result;
 134     Clear_Buffers ();
 135     result = fscanf (mainfile, "%s %s %s %s", Buf1, Buf2, Buf3, Buf4);
 136     assert(result != EOF);
 137     A[0] = atof (Buf2);
 138     A[1] = atof (Buf3);
 139     A[2] = atof (Buf4);
 140 }
 141
 142
 143 static void
 144 LoadReal (float *a)
 145 {
 146     int result;
 147     Clear_Buffers ();
 148     result = fscanf (mainfile, "%s %s", Buf1, Buf2);
 149     assert(result != EOF);
 150     *a = atof (Buf2);
 151 }
 152
 153
 154 static void
 155 LoadInteger (int *a)
 156 {
 157     int result;
 158     Clear_Buffers ();
 159     result = fscanf (mainfile, "%s %s", Buf1, Buf2);
 160     assert(result != EOF);
 161     *a = atoi (Buf2);
 162 }
 163
 164
 165 static void
 166 LoadText (char *a)
 167 {
 168     int result;
 169     Clear_Buffers ();
 170     result = fscanf (mainfile, "%s %s", Buf1, Buf2);
 171     assert(result != EOF);
 172     strcpy (a, Buf2);
 173 }
 174
 175
 176 static void
 177 getdata (char filename[])
 178 {
 179     int gear_count = 0, axle_count = 0, belt_count = 0, i;
 180
 181     mainfile = fopen (filename, "r");
 182     if (!mainfile) {
 183        printf("Error: couldn't open %s\n", filename);
 184        exit(-1);
 185     }
 186
 187     do
 188     {
 189         int result;
 190         Clear_Buffers ();
 191         result = fscanf (mainfile, "%s", Buf1);
 192         (void) result;
 193         if (ferror (mainfile))
 194         {
 195             printf ("\nError opening file !\n");
 196             exit (1);
 197         }
 198
 199         if (!(strcmp (Buf1, "BACKGROUND")))
 200           LoadTriplet (background);
 201
 202         if (!(strcmp (Buf1, "ANAME")))
 203         {
 204             LoadText (a[axle_count].name);
 205             axle_count++;
 206         }
 207
 208         if (!(strcmp (Buf1, "ARADIUS")))
 209           LoadReal (&a[axle_count - 1].radius);
 210
 211         if (!(strcmp (Buf1, "AAXIS")))
 212           LoadInteger (&a[axle_count - 1].axis);
 213
 214         if (!(strcmp (Buf1, "ACOLOR")))
 215           LoadTriplet (a[axle_count - 1].color);
 216
 217         if (!(strcmp (Buf1, "APOSITION")))
 218           LoadTriplet (a[axle_count - 1].position);
 219
 220         if (!(strcmp (Buf1, "ALENGTH")))
 221           LoadReal (&a[axle_count - 1].length);
 222
 223         if (!(strcmp (Buf1, "AMOTORED")))
 224           LoadInteger (&a[axle_count - 1].motored);
 225
 226         if (!(strcmp (Buf1, "AANGULARVELOCITY")))
 227           LoadReal (&a[axle_count - 1].angular_velocity);
 228
 229         if (!(strcmp (Buf1, "ADIRECTION")))
 230           LoadInteger (&a[axle_count - 1].direction);
 231
 232         if (!(strcmp (Buf1, "GNAME")))
 233         {
 234             LoadText (g[gear_count].name);
 235             gear_count++;
 236         }
 237
 238         if (!(strcmp (Buf1, "GTYPE")))
 239           LoadText (g[gear_count - 1].type);
 240
 241         if (!(strcmp (Buf1, "GFACE")))
 242           LoadInteger (&g[gear_count - 1].face);
 243
 244         if (!(strcmp (Buf1, "GRADIUS")))
 245           LoadReal (&g[gear_count - 1].radius);
 246
 247         if (!(strcmp (Buf1, "GWIDTH")))
 248           LoadReal (&g[gear_count - 1].width);
 249
 250         if (!(strcmp (Buf1, "GTEETH")))
 251           LoadInteger (&g[gear_count - 1].teeth);
 252
 253         if (!(strcmp (Buf1, "GTOOTHDEPTH")))
 254           LoadReal (&g[gear_count - 1].tooth_depth);
 255
 256         if (!(strcmp (Buf1, "GCOLOR")))
 257           LoadTriplet (g[gear_count - 1].color);
 258
 259         if (!(strcmp (Buf1, "GAXLE")))
 260           LoadText (g[gear_count - 1].axle_name);
 261
 262         if (!(strcmp (Buf1, "GPOSITION")))
 263           LoadInteger (&g[gear_count - 1].relative_position);
 264
 265         if (!(strcmp (Buf1, "BELTNAME")))
 266         {
 267             LoadText (b[belt_count].name);
 268             belt_count++;
 269         }
 270
 271         if (!(strcmp (Buf1, "GEAR1NAME")))
 272           LoadText (b[belt_count - 1].gear1_name);
 273
 274         if (!(strcmp (Buf1, "GEAR2NAME")))
 275           LoadText (b[belt_count - 1].gear2_name);
 276     }
 277
 278     while (Buf1[0] != 0);
 279
 280     for (i = 0; i < number_of_gears; i++)
 281     {
 282         g[i].axis = -1;
 283         g[i].direction = 0;
 284         g[i].angular_velocity = 0.0;
 285     }
 286
 287     number_of_gears = gear_count;
 288     number_of_axles = axle_count;
 289     number_of_belts = belt_count;
 290     fclose (mainfile);
 291 }
 292
 293
 294 static void
 295 axle (GLint j, GLfloat radius, GLfloat length)
 296 {
 297     GLfloat angle, rad, incr = 10.0 * M_PI / 180.0;
 298
 299     /* draw main cylinder */
 300     glBegin (GL_QUADS);
 301     for (angle = 0.0; angle < 360.0; angle += 5.0)
 302     {
 303         rad = angle * M_PI / 180.0;
 304         glNormal3f (cos (rad), sin (rad), 0.0);
 305         glVertex3f (radius * cos (rad), radius * sin (rad), length / 2);
 306         glVertex3f (radius * cos (rad), radius * sin (rad), -length / 2);
 307         glVertex3f (radius * cos (rad + incr), radius * sin (rad + incr), -length / 2);
 308         glVertex3f (radius * cos (rad + incr), radius * sin (rad + incr), length / 2);
 309     }
 310     glEnd ();
 311
 312     /* draw front face */
 313     glNormal3f (0.0, 0.0, 1.0);
 314     glBegin (GL_TRIANGLES);
 315     for (angle = 0.0; angle < 360.0; angle += 5.0)
 316     {
 317         rad = angle * M_PI / 180.0;
 318         glVertex3f (0.0, 0.0, length / 2);
 319         glVertex3f (radius * cos (rad), radius * sin (rad), length / 2);
 320         glVertex3f (radius * cos (rad + incr), radius * sin (rad + incr), length / 2);
 321         glVertex3f (0.0, 0.0, length / 2);
 322     }
 323     glEnd ();
 324
 325     /* draw back face */
 326     glNormal3f (0.0, 0.0, -1.0);
 327     glBegin (GL_TRIANGLES);
 328     for (angle = 0.0; angle <= 360.0; angle += 5.0)
 329     {
 330         rad = angle * M_PI / 180.0;
 331         glVertex3f (0.0, 0.0, -length / 2);
 332         glVertex3f (radius * cos (rad), radius * sin (rad), -length / 2);
 333         glVertex3f (radius * cos (rad + incr), radius * sin (rad + incr), -length / 2);
 334         glVertex3f (0.0, 0.0, -length / 2);
 335     }
 336     glEnd ();
 337 }
 338
 339
 340
 341 static void
 342 gear (GLint j, char type[], GLfloat radius, GLfloat width,
 343       GLint teeth, GLfloat tooth_depth)
 344 {
 345     GLint i;
 346     GLfloat r1, r2;
 347     GLfloat angle, da;
 348     GLfloat u, v, len, fraction = 0.5;
 349     GLfloat n = 1.0;
 350
 351     r1 = radius - tooth_depth;
 352     r2 = radius;
 353
 354     da = 2.0 * M_PI / teeth / 4.0;
 355     if (!g[j].face)
 356     {
 357         fraction = -0.5;
 358         n = -1.0;
 359     }
 360     if (!(strcmp (type, "NORMAL")))
 361     {
 362         fraction = 0.5;
 363         n = 1.0;
 364     }
 365
 366     /* draw front face */
 367     if (!(strcmp (type, "NORMAL")))
 368     {
 369         glNormal3f (0.0, 0.0, 1.0 * n);
 370         glBegin (GL_QUAD_STRIP);
 371         for (i = 0; i <= teeth; i++)
 372         {
 373             angle = i * 2.0 * M_PI / teeth;
 374             glVertex3f (0.0, 0.0, width * fraction);
 375             glVertex3f (r1 * cos (angle), r1 * sin (angle), width * fraction);
 376             glVertex3f (0.0, 0.0, width * fraction);
 377             glVertex3f (r1 * cos (angle + 3 * da), r1 * sin (angle + 3 * da), width * fraction);
 378         }
 379         glEnd ();
 380     }
 381     else
 382     {
 383         glNormal3f (0.0, 0.0, 1.0 * n);
 384         glBegin (GL_QUAD_STRIP);
 385         for (i = 0; i <= teeth; i++)
 386         {
 387             angle = i * 2.0 * M_PI / teeth;
 388             glVertex3f (0.0, 0.0, width * fraction);
 389             glVertex3f ((r2 - width) * cos (angle), (r2 - width) * sin (angle), width * fraction);
 390             glVertex3f (0.0, 0.0, width * fraction);
 391             glVertex3f ((r2 - width) * cos (angle + 3 * da), (r2 - width) * sin (angle + 3 * da), width * fraction);
 392         }
 393         glEnd ();
 394     }
 395
 396     /* draw front sides of teeth */
 397     if (!(strcmp (type, "NORMAL")))
 398     {
 399         glNormal3f (0.0, 0.0, 1.0 * n);
 400         glBegin (GL_QUADS);
 401         da = 2.0 * M_PI / teeth / 4.0;
 402         for (i = 0; i < teeth; i++)
 403         {
 404             angle = i * 2.0 * M_PI / teeth;
 405             glVertex3f (r1 * cos (angle), r1 * sin (angle), width * fraction);
 406             glVertex3f (r2 * cos (angle + da), r2 * sin (angle + da), width * fraction);
 407             glVertex3f (r2 * cos (angle + 2 * da), r2 * sin (angle + 2 * da), width * fraction);
 408             glVertex3f (r1 * cos (angle + 3 * da), r1 * sin (angle + 3 * da), width * fraction);
 409         }
 410         glEnd ();
 411     }
 412
 413     glNormal3f (0.0, 0.0, -1.0 * n);
 414
 415     /* draw back face */
 416     glBegin (GL_QUAD_STRIP);
 417     for (i = 0; i <= teeth; i++)
 418     {
 419         angle = i * 2.0 * M_PI / teeth;
 420         glVertex3f (r1 * cos (angle), r1 * sin (angle), -width * fraction);
 421         glVertex3f (0.0, 0.0, -width * fraction);
 422         glVertex3f (r1 * cos (angle + 3 * da), r1 * sin (angle + 3 * da), -width * fraction);
 423         glVertex3f (0.0, 0.0, -width * fraction);
 424     }
 425     glEnd ();
 426
 427     /* draw back sides of teeth */
 428     glNormal3f (0.0, 0.0, -1.0 * n);
 429     glBegin (GL_QUADS);
 430     da = 2.0 * M_PI / teeth / 4.0;
 431     for (i = 0; i < teeth; i++)
 432     {
 433         angle = i * 2.0 * M_PI / teeth;
 434         glVertex3f (r1 * cos (angle + 3 * da), r1 * sin (angle + 3 * da), -width * fraction);
 435         glVertex3f (r2 * cos (angle + 2 * da), r2 * sin (angle + 2 * da), -width * fraction);
 436         glVertex3f (r2 * cos (angle + da), r2 * sin (angle + da), -width * fraction);
 437         glVertex3f (r1 * cos (angle), r1 * sin (angle), -width * fraction);
 438     }
 439     glEnd ();
 440
 441
 442     /* draw outward faces of teeth */
 443     if (!(strcmp (type, "NORMAL")))
 444     {
 445         glBegin (GL_QUAD_STRIP);
 446         for (i = 0; i < teeth; i++)
 447         {
 448             angle = i * 2.0 * M_PI / teeth;
 449
 450             glVertex3f (r1 * cos (angle), r1 * sin (angle), width * fraction);
 451             glVertex3f (r1 * cos (angle), r1 * sin (angle), -width * fraction);
 452             u = r2 * cos (angle + da) - r1 * cos (angle);
 453             v = r2 * sin (angle + da) - r1 * sin (angle);
 454             len = sqrt (u * u + v * v);
 455             u /= len;
 456             v /= len;
 457             glNormal3f (v, -u, 0.0);
 458             glVertex3f (r2 * cos (angle + da), r2 * sin (angle + da), width * fraction);
 459             glVertex3f (r2 * cos (angle + da), r2 * sin (angle + da), -width * fraction);
 460             glNormal3f (cos (angle), sin (angle), 0.0);
 461             glVertex3f (r2 * cos (angle + 2 * da), r2 * sin (angle + 2 * da), width * fraction);
 462             glVertex3f (r2 * cos (angle + 2 * da), r2 * sin (angle + 2 * da), -width * fraction);
 463             u = r1 * cos (angle + 3 * da) - r2 * cos (angle + 2 * da);
 464             v = r1 * sin (angle + 3 * da) - r2 * sin (angle + 2 * da);
 465             glNormal3f (v, -u, 0.0);
 466             glVertex3f (r1 * cos (angle + 3 * da), r1 * sin (angle + 3 * da), width * fraction);
 467             glVertex3f (r1 * cos (angle + 3 * da), r1 * sin (angle + 3 * da), -width * fraction);
 468             glNormal3f (cos (angle), sin (angle), 0.0);
 469         }
 470     }
 471     else
 472     {
 473         glBegin (GL_QUAD_STRIP);
 474         for (i = 0; i < teeth; i++)
 475         {
 476             angle = i * 2.0 * M_PI / teeth;
 477             glVertex3f (r1 * cos (angle), r1 * sin (angle), width * fraction);
 478             glVertex3f (r1 * cos (angle), r1 * sin (angle), -width * fraction);
 479             u = r2 * cos (angle + da) - r1 * cos (angle);
 480             v = r2 * sin (angle + da) - r1 * sin (angle);
 481             len = sqrt (u * u + v * v);
 482             u /= len;
 483             v /= len;
 484             glNormal3f (v, -u, 0.0);
 485             glVertex3f ((r2 - width) * cos (angle + da), (r2 - width) * sin (angle + da), width * fraction);
 486             glVertex3f (r2 * cos (angle + da), r2 * sin (angle + da), -width * fraction);
 487             glNormal3f (cos (angle), sin (angle), n);
 488             glVertex3f ((r2 - width) * cos (angle + 2 * da), (r2 - width) * sin (angle + 2 * da), width * fraction);
 489             glVertex3f (r2 * cos (angle + 2 * da), r2 * sin (angle + 2 * da), -width * fraction);
 490             u = r1 * cos (angle + 3 * da) - r2 * cos (angle + 2 * da);
 491             v = r1 * sin (angle + 3 * da) - r2 * sin (angle + 2 * da);
 492             glNormal3f (v, -u, 0.0);
 493             glVertex3f (r1 * cos (angle + 3 * da), r1 * sin (angle + 3 * da), width * fraction);
 494             glVertex3f (r1 * cos (angle + 3 * da), r1 * sin (angle + 3 * da), -width * fraction);
 495             glNormal3f (cos (angle), sin (angle), n);
 496         }
 497     }
 498
 499     glVertex3f (r1 * cos (0), r1 * sin (0), width * fraction);
 500     glVertex3f (r1 * cos (0), r1 * sin (0), -width * fraction);
 501     glEnd ();
 502 }
 503
 504
 505 static void
 506 belt (struct GEAR g1, struct GEAR g2)
 507 {
 508     GLfloat D, alpha, phi, angle, incr, width;
 509     GLint indexes[3] =
 510     {
 511        0, 0, 0
 512     };
 513
 514     GLfloat col[3] =
 515     {
 516        0.0, 0.0, 0.0
 517     };
 518
 519     width = min (g1.width, g2.width);
 520     D = sqrt (pow (g1.position[0] - g2.position[0], 2) + pow (g1.position[1] - g2.position[1], 2) + pow (g1.position[2] - g2.position[2], 2));
 521     alpha = acos ((g2.position[0] - g1.position[0]) / D);
 522     phi = acos ((g1.radius - g2.radius) / D);
 523     glBegin (GL_QUADS);
 524     glColor3fv (col);
 525     glMaterialiv (GL_FRONT, GL_COLOR_INDEXES, indexes);
 526     incr = 1.2 * 360.0 / g1.teeth * M_PI / 180.00;
 527     for (angle = alpha + phi; angle <= 2 * M_PI - phi + alpha; angle += 360.0 / g1.teeth * M_PI / 180.00)
 528     {
 529         glNormal3f (cos (angle), sin (angle), 0.0);
 530         glVertex3f (g1.radius * cos (angle), g1.radius * sin (angle), width * 0.5);
 531         glVertex3f (g1.radius * cos (angle), g1.radius * sin (angle), -width * 0.5);
 532         glVertex3f (g1.radius * cos (angle + incr), g1.radius * sin (angle + incr), -width * 0.5);
 533         glVertex3f (g1.radius * cos (angle + incr), g1.radius * sin (angle + incr), width * 0.5);
 534     }
 535     glEnd ();
 536     glBegin (GL_QUADS);
 537     glColor3fv (col);
 538     glMaterialiv (GL_FRONT, GL_COLOR_INDEXES, indexes);
 539     incr = 1.2 * 360.0 / g2.teeth * M_PI / 180.00;
 540     for (angle = -phi + alpha; angle <= phi + alpha; angle += 360.0 / g1.teeth * M_PI / 180.0)
 541     {
 542         glNormal3f (cos (angle), sin (angle), 0.0);
 543         glVertex3f (g2.radius * cos (angle) + g2.position[0] - g1.position[0], g2.radius * sin (angle) + g2.position[1] - g1.position[1], width * 0.5);
 544         glVertex3f (g2.radius * cos (angle) + g2.position[0] - g1.position[0], g2.radius * sin (angle) + g2.position[1] - g1.position[1], width * -0.5);
 545         glVertex3f (g2.radius * cos (angle + incr) + g2.position[0] - g1.position[0], g2.radius * sin (angle + incr) + g2.position[1] - g1.position[1], width * -0.5);
 546         glVertex3f (g2.radius * cos (angle + incr) + g2.position[0] - g1.position[0], g2.radius * sin (angle + incr) + g2.position[1] - g1.position[1], width * 0.5);
 547     }
 548     glEnd ();
 549
 550     glBegin (GL_QUADS);
 551     glColor3fv (col);
 552     glMaterialiv (GL_FRONT, GL_COLOR_INDEXES, indexes);
 553     glVertex3f (g1.radius * cos (alpha + phi), g1.radius * sin (alpha + phi), width * 0.5);
 554     glVertex3f (g1.radius * cos (alpha + phi), g1.radius * sin (alpha + phi), width * -0.5);
 555     glVertex3f (g2.radius * cos (alpha + phi) + g2.position[0] - g1.position[0], g2.radius * sin (alpha + phi) + g2.position[1] - g1.position[1], width * -0.5);
 556     glVertex3f (g2.radius * cos (alpha + phi) + g2.position[0] - g1.position[0], g2.radius * sin (alpha + phi) + g2.position[1] - g1.position[1], width * 0.5);
 557     glVertex3f (g1.radius * cos (alpha - phi), g1.radius * sin (alpha - phi), width * 0.5);
 558     glVertex3f (g1.radius * cos (alpha - phi), g1.radius * sin (alpha - phi), width * -0.5);
 559     glVertex3f (g2.radius * cos (alpha - phi) + g2.position[0] - g1.position[0], g2.radius * sin (alpha - phi) + g2.position[1] - g1.position[1], width * -0.5);
 560     glVertex3f (g2.radius * cos (alpha - phi) + g2.position[0] - g1.position[0], g2.radius * sin (alpha - phi) + g2.position[1] - g1.position[1], width * 0.5);
 561     glEnd ();
 562 }
 563
 564
 565 static int
 566 axle_find (char axle_name[])
 567 {
 568     int i;
 569
 570     for (i = 0; i < number_of_axles; i++)
 571     {
 572         if (!(strcmp (axle_name, a[i].name)))
 573            break;
 574     }
 575     return i;
 576 }
 577
 578
 579 static int
 580 gear_find (char gear_name[])
 581 {
 582     int i;
 583
 584     for (i = 0; i < number_of_gears; i++)
 585     {
 586         if (!(strcmp (gear_name, g[i].name)))
 587            break;
 588     }
 589     return i;
 590 }
 591
 592
 593 static void
 594 process ()
 595 {
 596     GLfloat x, y, z, D, dist;
 597     GLint axle_index, i, j, g1, g2, k;
 598     char error[80];
 599
 600     for (i = 0; i < number_of_gears; i++)
 601     {
 602         x = 0.0;
 603         y = 0.0;
 604         z = 0.0;
 605         axle_index = axle_find (g[i].axle_name);
 606         g[i].axis = a[axle_index].axis;
 607         g[i].motored = a[axle_index].motored;
 608         if (a[axle_index].motored)
 609         {
 610             g[i].direction = a[axle_index].direction;
 611             g[i].angular_velocity = a[axle_index].angular_velocity;
 612         }
 613         if (g[i].axis == 0)
 614            x = 1.0;
 615         else if (g[i].axis == 1)
 616            y = 1.0;
 617         else
 618            z = 1.0;
 619
 620         g[i].position[0] = a[axle_index].position[0] + x * g[i].relative_position;
 621         g[i].position[1] = a[axle_index].position[1] + y * g[i].relative_position;
 622         g[i].position[2] = a[axle_index].position[2] + z * g[i].relative_position;
 623     }
 624
 625     for (k = 0; k < number_of_axles; k++)
 626     {
 627         for (i = 0; i < number_of_gears - 1; i++)
 628         {
 629             for (j = 0; j < number_of_gears; j++)
 630             {
 631                 if (!(strcmp (g[i].type, g[j].type)) && (!(strcmp (g[i].type, "NORMAL"))) && ((strcmp (g[i].axle_name, g[j].axle_name) != 0)) && (g[i].axis == g[j].axis))
 632                 {
 633                     D = sqrt (pow (g[i].position[0] - g[j].position[0], 2) + pow (g[i].position[1] - g[j].position[1], 2) + pow (g[i].position[2] - g[j].position[2], 2));
 634                     if (D < 1.1 * (g[i].radius - g[i].tooth_depth + g[j].radius - g[j].tooth_depth))
 635                     {
 636                         printf (error, "Gear %s and %s are too close to each other.", g[i].name, g[j].name);
 637
 638                         /*MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);*/
 639                         exit (1);
 640                     }
 641
 642                     if (g[i].axis == 0)
 643                     {
 644                         dist = g[i].position[0] - g[j].position[0];
 645                     }
 646                     else if (g[i].axis == 1)
 647                     {
 648                         dist = g[i].position[1] - g[j].position[1];
 649                     }
 650                     else
 651                        dist = g[i].position[2] - g[j].position[2];
 652
 653                     dist = fabs (dist);
 654
 655                     if (dist < (g[i].width / 2 + g[j].width / 2))
 656                     {
 657                         if ((g[i].motored) && (!(g[j].motored)) && (D < 0.95 * (g[i].radius + g[j].radius)))
 658                         {
 659                             axle_index = axle_find (g[j].axle_name);
 660                             if ((a[axle_index].direction != 0) && (g[j].angular_velocity != g[i].angular_velocity * g[i].teeth / g[j].teeth * g[i].radius / g[j].radius))
 661                             {
 662                                 printf (error, "Error in tooth linkage of gears %s and %s.", g[i].name, g[j].name);
 663                                 /*MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);*/
 664                                 exit (1);
 665                             }
 666
 667                             g[j].motored = (a[axle_index].motored = 1);
 668                             g[j].direction = (a[axle_index].direction = -g[i].direction);
 669                             a[axle_index].angular_velocity = g[i].angular_velocity * g[i].teeth / g[j].teeth;
 670                             g[j].angular_velocity = (a[axle_index].angular_velocity *= g[i].radius / g[j].radius);
 671                         }
 672
 673                         if ((!(g[i].motored)) && (g[j].motored) && (D < 0.95 * (g[i].radius + g[j].radius)))
 674                         {
 675                             axle_index = axle_find (g[i].axle_name);
 676                             if ((a[axle_index].direction != 0) && (g[i].angular_velocity != g[j].angular_velocity * g[j].teeth / g[i].teeth * g[j].radius / g[i].radius))
 677                             {
 678                                 printf (error, "Error in tooth linkage of gears %s and %s.", g[i].name, g[j].name);
 679                                 /*MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);*/
 680                                 exit (1);
 681                             }
 682
 683                             g[i].motored = (a[axle_index].motored = 1);
 684                             g[i].direction = (a[axle_index].direction = -g[j].direction);
 685                             a[axle_index].angular_velocity = g[j].angular_velocity * g[j].teeth / g[i].teeth;
 686                             g[i].angular_velocity = (a[axle_index].angular_velocity *= g[j].radius / g[i].radius);
 687
 688                         }
 689                     }
 690                 }
 691
 692                 if (!(strcmp (g[i].type, g[j].type)) && (!(strcmp (g[i].type, "BEVEL"))) && ((strcmp (g[i].axle_name, g[j].axle_name) != 0)) && (g[i].axis != g[j].axis))
 693                 {
 694                     D = sqrt (pow (g[i].position[0] - g[j].position[0], 2) + pow (g[i].position[1] - g[j].position[1], 2) + pow (g[i].position[2] - g[j].position[2], 2));
 695                     if ((g[i].motored) && (!(g[j].motored)) && (D < 0.95 * sqrt (g[i].radius * g[i].radius + g[j].radius * g[j].radius)))
 696                     {
 697                         axle_index = axle_find (g[j].axle_name);
 698                         if ((a[axle_index].direction != 0) && (g[j].angular_velocity != g[i].angular_velocity * g[i].teeth / g[j].teeth * g[i].radius / g[j].radius))
 699                         {
 700                             printf (error, "Error in tooth linkage of gears %s and %s.", g[i].name, g[j].name);
 701                             /*MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);*/
 702                             exit (1);
 703                         }
 704                         g[j].motored = (a[axle_index].motored = 1);
 705                         g[j].direction = (a[axle_index].direction = -g[i].direction);
 706                         a[axle_index].angular_velocity = g[i].angular_velocity * g[i].teeth / g[j].teeth;
 707                         g[j].angular_velocity = (a[axle_index].angular_velocity *= g[i].radius / g[j].radius);
 708                     }
 709
 710
 711                     if ((!(g[i].motored)) && (g[j].motored) && (D < 0.95 * sqrt (g[i].radius * g[i].radius + g[j].radius * g[j].radius)))
 712                     {
 713                         axle_index = axle_find (g[i].axle_name);
 714                         if ((a[axle_index].direction != 0) && (g[i].angular_velocity != g[j].angular_velocity * g[j].teeth / g[i].teeth * g[j].radius / g[i].radius))
 715                         {
 716                             printf (error, "Error in tooth linkage of gears %s and %s.", g[i].name, g[j].name);
 717                             /*MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);*/
 718                             exit (1);
 719                         }
 720                         g[i].motored = (a[axle_index].motored = 1);
 721                         g[i].direction = (a[axle_index].direction = -g[j].direction);
 722                         a[axle_index].angular_velocity = g[j].angular_velocity * g[j].teeth / g[i].teeth;
 723                         g[i].angular_velocity = (a[axle_index].angular_velocity *= g[j].radius / g[i].radius);
 724                     }
 725                 }
 726             }
 727         }
 728
 729         for (i = 0; i < number_of_gears; i++)
 730         {
 731             axle_index = axle_find (g[i].axle_name);
 732             g[i].motored = a[axle_index].motored;
 733             if (a[axle_index].motored)
 734             {
 735                 g[i].direction = a[axle_index].direction;
 736                 g[i].angular_velocity = a[axle_index].angular_velocity;
 737             }
 738         }
 739
 740         for (i = 0; i < number_of_belts; i++)
 741         {
 742             g1 = gear_find (b[i].gear1_name);
 743             g2 = gear_find (b[i].gear2_name);
 744             D = sqrt (pow (g[g1].position[0] - g[g2].position[0], 2) + pow (g[g1].position[1] - g[g2].position[1], 2) + pow (g[g1].position[2] - g[g2].position[2], 2));
 745             if (!((g[g1].axis == g[g2].axis) && (!strcmp (g[g1].type, g[g2].type)) && (!strcmp (g[g1].type, "NORMAL"))))
 746             {
 747                 printf (error, "Belt %s invalid.", b[i].name);
 748                 /*MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);*/
 749                 exit (1);
 750             }
 751
 752             if ((g[g1].axis == g[g2].axis) && (!strcmp (g[g1].type, g[g2].type)) && (!strcmp (g[g1].type, "NORMAL")))
 753             {
 754               /*
 755                  if((g[g1].motored)&&(g[g2].motored))
 756                  if(g[g2].angular_velocity!=(g[g1].angular_velocity*g[g1].radius/g[g2].radius))
 757                  {
 758                  printf(error,"Error in belt linkage of gears %s and %s".,g[g1].name,g[g2].name);
 759                  MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);
 760                  exit(1);
 761                  }
 762               */
 763                if (g[g1].axis == 0)
 764                   {
 765                     dist = g[g1].position[0] - g[g2].position[0];
 766                 }
 767                 else if (g[i].axis == 1)
 768                 {
 769                     dist = g[g1].position[1] - g[g2].position[1];
 770                 }
 771                 else
 772                    dist = g[g1].position[2] - g[g2].position[2];
 773
 774                 dist = fabs (dist);
 775
 776                 if (dist > (g[g1].width / 2 + g[g2].width / 2))
 777                 {
 778                     printf (error, "Belt %s invalid.", b[i].name);
 779                     /*MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);*/
 780                     exit (1);
 781                 }
 782
 783                 if (dist < (g[g1].width / 2 + g[g2].width / 2))
 784                 {
 785                     if (D < g[g1].radius + g[g2].radius)
 786                     {
 787                         printf (error, "Gears %s and %s too close to be linked with belts", g[g1].name, g[g2].name);
 788                         /*MessageBox(NULL,error,windowName,MB_ICONEXCLAMATION|MB_OK);*/
 789                         exit (1);
 790                     }
 791
 792                     if ((g[g1].motored) && (!(g[g2].motored)))
 793                     {
 794                         axle_index = axle_find (g[g2].axle_name);
 795                         g[g2].motored = (a[axle_index].motored = 1);
 796                         g[g2].direction = (a[axle_index].direction = g[g1].direction);
 797                         g[g2].angular_velocity = (a[axle_index].angular_velocity = g[g1].angular_velocity * g[g1].radius / g[g2].radius);
 798                     }
 799
 800                     if ((!(g[g1].motored)) && (g[g2].motored))
 801                     {
 802                         axle_index = axle_find (g[g1].axle_name);
 803                         g[g1].motored = (a[axle_index].motored = 1);
 804                         g[g1].direction = (a[axle_index].direction = g[g2].direction);
 805                         g[g1].angular_velocity = (a[axle_index].angular_velocity = g[g2].angular_velocity * g[g2].radius / g[g1].radius);
 806                     }
 807                 }
 808             }
 809         }
 810
 811         for (i = 0; i < number_of_gears; i++)
 812         {
 813             axle_index = axle_find (g[i].axle_name);
 814             g[i].motored = a[axle_index].motored;
 815             if (a[axle_index].motored)
 816             {
 817                 g[i].direction = a[axle_index].direction;
 818                 g[i].angular_velocity = a[axle_index].angular_velocity;
 819             }
 820         }
 821     }
 822 }
 823
 824
 825
 826 GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 10.0;
 827
 828
 829 static void
 830 draw (void)
 831 {
 832     int i;
 833     GLfloat x, y, z;
 834     int index;
 835
 836     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 837
 838     glPushMatrix ();
 839     glRotatef (view_rotx, 1.0, 0.0, 0.0);
 840     glRotatef (view_roty, 0.0, 1.0, 0.0);
 841     glRotatef (view_rotz, 0.0, 0.0, 1.0);
 842
 843     for (i = 0; i < number_of_gears; i++)
 844     {
 845         x = 0.0;
 846         y = 0.0;
 847         z = 0.0;
 848         glPushMatrix ();
 849 /*glTranslatef( -3.0, -2.0, 0.0 );*/
 850         glTranslatef (g[i].position[0], g[i].position[1], g[i].position[2]);
 851         if (g[i].axis == 0)
 852            y = 1.0;
 853         else if (g[i].axis == 1)
 854            x = 1.0;
 855         else
 856            z = 1.0;
 857
 858         if (z != 1.0)
 859            glRotatef (90.0, x, y, z);
 860
 861         glRotatef (g[i].direction * g[i].angle, 0.0, 0.0, 1.0);
 862         glCallList (g[i].id);
 863         glPopMatrix ();
 864     }
 865
 866     for (i = 0; i < number_of_axles; i++)
 867     {
 868         x = 0.0;
 869         y = 0.0;
 870         z = 0.0;
 871         glPushMatrix ();
 872         glTranslatef (a[i].position[0], a[i].position[1], a[i].position[2]);
 873         if (a[i].axis == 0)
 874            y = 1.0;
 875         else if (a[i].axis == 1)
 876            x = 1.0;
 877         else
 878            z = 1.0;
 879
 880         if (z != 1.0)
 881            glRotatef (90.0, x, y, z);
 882
 883         glCallList (a[i].id);
 884         glPopMatrix ();
 885     }
 886
 887     for (i = 0; i < number_of_belts; i++)
 888     {
 889         x = 0.0;
 890         y = 0.0;
 891         z = 0.0;
 892         glPushMatrix ();
 893         index = gear_find (b[i].gear1_name);
 894         glTranslatef (g[index].position[0], g[index].position[1], g[index].position[2]);
 895         if (g[index].axis == 0)
 896            y = 1.0;
 897         else if (g[index].axis == 1)
 898            x = 1.0;
 899         else
 900            z = 1.0;
 901
 902         if (z != 1.0)
 903            glRotatef (90.0, x, y, z);
 904
 905         glCallList (b[i].id);
 906         glPopMatrix ();
 907     }
 908
 909     glPopMatrix ();
 910     glutSwapBuffers ();
 911
 912     {
 913         GLint t = glutGet(GLUT_ELAPSED_TIME);
 914         Frames++;
 915         if (t - T0 >= 5000) {
 916             GLfloat seconds = (t - T0) / 1000.0;
 917             GLfloat fps = Frames / seconds;
 918             printf("%d frames in %g seconds = %g FPS\n", Frames, seconds, fps);
 919             fflush(stdout);
 920             T0 = t;
 921             Frames = 0;
 922         }
 923     }
 924 }
 925
 926
 927 static void
 928 idle (void)
 929 {
 930     int i;
 931     static double t0 = -1.;
 932     double dt, t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
 933     if (t0 < 0.0)
 934        t0 = t;
 935     dt = t - t0;
 936     t0 = t;
 937     for (i = 0; i < number_of_gears; i++)
 938       g[i].angle += g[i].angular_velocity * dt;
 939     glutPostRedisplay();
 940 }
 941
 942
 943
 944
 945 /* change view angle, exit upon ESC */
 946 static void
 947 key (unsigned char k, int x, int y)
 948 {
 949     switch (k)
 950     {
 951     case 'x':
 952         view_rotx += 5.0;
 953         break;
 954     case 'X':
 955         view_rotx -= 5.0;
 956         break;
 957     case 'y':
 958         view_roty += 5.0;
 959         break;
 960     case 'Y':
 961         view_roty -= 5.0;
 962         break;
 963     case 'z':
 964         view_rotz += 5.0;
 965         break;
 966     case 'Z':
 967         view_rotz -= 5.0;
 968         break;
 969     case 0x1B:
 970         exit(0);
 971     }
 972 }
 973
 974
 975
 976
 977 /* new window size or exposure */
 978 static void
 979 reshape (int width, int height)
 980 {
 981     glViewport (0, 0, (GLint) width, (GLint) height);
 982     glMatrixMode (GL_PROJECTION);
 983     glLoadIdentity ();
 984     if (width > height)
 985     {
 986         GLfloat w = (GLfloat) width / (GLfloat) height;
 987         glFrustum (-w, w, -1.0, 1.0, 5.0, 60.0);
 988     }
 989     else
 990     {
 991         GLfloat h = (GLfloat) height / (GLfloat) width;
 992         glFrustum (-1.0, 1.0, -h, h, 5.0, 60.0);
 993     }
 994
 995     glMatrixMode (GL_MODELVIEW);
 996     glLoadIdentity ();
 997     glTranslatef (0.0, 0.0, -40.0);
 998     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 999 }
1000
1001
1002
1003 static void
1004 init (void)
1005 {
1006     GLfloat matShine = 20.00F;
1007     GLfloat light0Pos[4] =
1008     {
1009        0.70F, 0.70F, 1.25F, 0.50F
1010     };
1011     int i;
1012
1013     glClearColor (background[0], background[1], background[2], 1.0F);
1014     glClearIndex ((GLfloat) 0.0);
1015
1016     glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, matShine);
1017     glLightfv (GL_LIGHT0, GL_POSITION, light0Pos);
1018     glEnable (GL_LIGHT0);
1019
1020     glEnable (GL_LIGHTING);
1021     glEnable (GL_DEPTH_TEST);
1022     for (i = 0; i < number_of_gears; i++)
1023       g[i].angle = 0.0;
1024
1025     for (i = 0; i < number_of_gears; i++)
1026     {
1027         g[i].id = glGenLists (1);
1028         glNewList (g[i].id, GL_COMPILE);
1029         glColor3fv (g[i].color);
1030         glMaterialfv (GL_FRONT, GL_SPECULAR, g[i].color);
1031         gear (i, g[i].type, g[i].radius, g[i].width, g[i].teeth, g[i].tooth_depth);
1032         glEndList ();
1033     }
1034
1035     for (i = 0; i < number_of_axles; i++)
1036     {
1037         a[i].id = glGenLists (1);
1038         glNewList (a[i].id, GL_COMPILE);
1039         glColor3fv (a[i].color);
1040         glMaterialfv (GL_FRONT, GL_SPECULAR, a[i].color);
1041         axle (i, a[i].radius, a[i].length);
1042         glEndList ();
1043     }
1044
1045     for (i = 0; i < number_of_belts; i++)
1046     {
1047         b[i].id = glGenLists (1);
1048         glNewList (b[i].id, GL_COMPILE);
1049         belt (g[gear_find (b[i].gear1_name)], g[gear_find (b[i].gear2_name)]);
1050         glEndList ();
1051     }
1052
1053     glEnable (GL_COLOR_MATERIAL);
1054 }
1055
1056
1057
1058 int
1059 main (int argc, char *argv[])
1060 {
1061     char *file;
1062
1063     glutInitWindowSize(640,480);
1064     glutInit(&argc, argv);
1065     glutInitDisplayMode (GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE );
1066
1067     if (glutCreateWindow ("Gear Train Simulation") == GL_FALSE)
1068       exit (1);
1069
1070     if (argc < 2)
1071        file = "geartrain.dat";
1072     else
1073        file = argv[1];
1074
1075     getdata (file);
1076     process ();
1077     init ();
1078
1079     glutDisplayFunc (draw);
1080     glutReshapeFunc (reshape);
1081     glutKeyboardFunc (key);
1082     glutIdleFunc (idle);
1083     glutMainLoop ();
1084     return 0;
1085 }