progs/demos/ipers.c

   1 /*
   2  * This program is under the GNU GPL.
   3  * Use at your own risk.
   4  *
   5  * written by David Bucciarelli (tech.hmw@plus.it)
   6  *            Humanware s.r.l.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <math.h>
  12 #include <string.h>
  13
  14 #if defined (WIN32)|| defined(_WIN32)
  15 #include <windows.h>
  16 #include <mmsystem.h>
  17 #endif
  18
  19 #include <GL/glut.h>
  20
  21 #include "readtex.h"
  22
  23 #ifdef XMESA
  24 #include "GL/xmesa.h"
  25 static int fullscreen = 1;
  26 #endif
  27
  28 static int WIDTH = 640;
  29 static int HEIGHT = 480;
  30
  31 static GLint T0;
  32 static GLint Frames;
  33
  34 #define MAX_LOD 9
  35
  36 #define TEX_SKY_WIDTH 256
  37 #define TEX_SKY_HEIGHT TEX_SKY_WIDTH
  38
  39 #ifndef M_PI
  40 #define M_PI 3.1415926535
  41 #endif
  42
  43 #define FROM_NONE   0
  44 #define FROM_DOWN   1
  45 #define FROM_UP     2
  46 #define FROM_LEFT   3
  47 #define FROM_RIGHT  4
  48 #define FROM_FRONT  5
  49 #define FROM_BACK   6
  50
  51 static int win = 0;
  52
  53 static float obs[3] = { 3.8, 0.0, 0.0 };
  54 static float dir[3];
  55 static float v = 0.0;
  56 static float alpha = -90.0;
  57 static float beta = 90.0;
  58
  59 static int fog = 1;
  60 static int bfcull = 1;
  61 static int usetex = 1;
  62 static int help = 1;
  63 static int poutline = 0;
  64 static int normext = 1;
  65 static int joyavailable = 0;
  66 static int joyactive = 0;
  67 static int LODbias = 3;
  68 static int maxdepth = MAX_LOD;
  69
  70 static unsigned int totpoly = 0;
  71
  72 static GLuint t1id, t2id;
  73 static GLuint skydlist, LODdlist[MAX_LOD], LODnumpoly[MAX_LOD];
  74
  75 static void
  76 initlight(void)
  77 {
  78    GLfloat lspec[4] = { 1.0, 1.0, 1.0, 1.0 };
  79    static GLfloat lightpos[4] = { 30, 15.0, 30.0, 1.0 };
  80
  81    glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
  82    glLightfv(GL_LIGHT0, GL_SPECULAR, lspec);
  83
  84    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 32.0);
  85    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, lspec);
  86 }
  87
  88 static void
  89 initdlists(void)
  90 {
  91    static int slicetable[MAX_LOD][2] = {
  92       {21, 10},
  93       {18, 9},
  94       {15, 8},
  95       {12, 7},
  96       {9, 6},
  97       {7, 5},
  98       {5, 4},
  99       {4, 3},
 100       {3, 2}
 101    };
 102    GLUquadricObj *obj;
 103    int i, xslices, yslices;
 104
 105    obj = gluNewQuadric();
 106
 107    skydlist = glGenLists(1);
 108    glNewList(skydlist, GL_COMPILE);
 109    glBindTexture(GL_TEXTURE_2D, t2id);
 110    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 111    glColor3f(1.0f, 1.0f, 1.0f);
 112
 113    gluQuadricDrawStyle(obj, GLU_FILL);
 114    gluQuadricNormals(obj, GLU_NONE);
 115    gluQuadricTexture(obj, GL_TRUE);
 116    gluQuadricOrientation(obj, GLU_INSIDE);
 117    gluSphere(obj, 40.0f, 18, 9);
 118
 119    glEndList();
 120
 121    for (i = 0; i < MAX_LOD; i++) {
 122       LODdlist[i] = glGenLists(1);
 123       glNewList(LODdlist[i], GL_COMPILE);
 124
 125       gluQuadricDrawStyle(obj, GLU_FILL);
 126       gluQuadricNormals(obj, GLU_SMOOTH);
 127       gluQuadricTexture(obj, GL_TRUE);
 128       gluQuadricOrientation(obj, GLU_OUTSIDE);
 129       xslices = slicetable[i][0];
 130       yslices = slicetable[i][1];
 131       gluSphere(obj, 1.0f, xslices, yslices);
 132       LODnumpoly[i] = xslices * (yslices - 2) + 2 * (xslices - 1);
 133
 134       glEndList();
 135    }
 136
 137    gluDeleteQuadric(obj);
 138 }
 139
 140 static void
 141 inittextures(void)
 142 {
 143    GLubyte tsky[TEX_SKY_HEIGHT][TEX_SKY_WIDTH][3];
 144    GLuint x, y;
 145    GLfloat fact;
 146    GLenum gluerr;
 147
 148    /* Brick */
 149
 150    glGenTextures(1, &t1id);
 151    glBindTexture(GL_TEXTURE_2D, t1id);
 152
 153    if (!LoadRGBMipmaps("../images/bw.rgb", 3)) {
 154       fprintf(stderr, "Error reading a texture.\n");
 155       exit(-1);
 156    }
 157
 158    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 159    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 160
 161    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 162                    GL_LINEAR_MIPMAP_LINEAR);
 163    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 164
 165    /* Sky */
 166
 167    glGenTextures(1, &t2id);
 168    glBindTexture(GL_TEXTURE_2D, t2id);
 169
 170    for (y = 0; y < TEX_SKY_HEIGHT; y++)
 171       for (x = 0; x < TEX_SKY_WIDTH; x++)
 172          if (y < TEX_SKY_HEIGHT / 2) {
 173             fact = y / (GLfloat) (TEX_SKY_HEIGHT / 2);
 174             tsky[y][x][0] =
 175                (GLubyte) (255.0f * (0.1f * fact + 0.3f * (1.0f - fact)));
 176             tsky[y][x][1] =
 177                (GLubyte) (255.0f * (0.2f * fact + 1.0f * (1.0f - fact)));
 178             tsky[y][x][2] = 255;
 179          }
 180          else {
 181             tsky[y][x][0] = tsky[TEX_SKY_HEIGHT - y - 1][x][0];
 182             tsky[y][x][1] = tsky[TEX_SKY_HEIGHT - y - 1][x][1];
 183             tsky[y][x][2] = 255;
 184          }
 185
 186    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 187    if (
 188        (gluerr =
 189         gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TEX_SKY_WIDTH, TEX_SKY_HEIGHT,
 190                           GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *) (tsky)))) {
 191       fprintf(stderr, "GLULib%s\n", (char *) gluErrorString(gluerr));
 192       exit(-1);
 193    }
 194
 195    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 196    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 197
 198    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 199                    GL_LINEAR_MIPMAP_LINEAR);
 200    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 201 }
 202
 203 static void
 204 calcposobs(void)
 205 {
 206    dir[0] = sin(alpha * M_PI / 180.0);
 207    dir[1] = cos(alpha * M_PI / 180.0) * sin(beta * M_PI / 180.0);
 208    dir[2] = cos(beta * M_PI / 180.0);
 209
 210    if (dir[0] < 1.0e-5 && dir[0] > -1.0e-5)
 211       dir[0] = 0;
 212    if (dir[1] < 1.0e-5 && dir[1] > -1.0e-5)
 213       dir[1] = 0;
 214    if (dir[2] < 1.0e-5 && dir[2] > -1.0e-5)
 215       dir[2] = 0;
 216
 217    obs[0] += v * dir[0];
 218    obs[1] += v * dir[1];
 219    obs[2] += v * dir[2];
 220 }
 221
 222 static void
 223 special(int k, int x, int y)
 224 {
 225    switch (k) {
 226    case GLUT_KEY_LEFT:
 227       alpha -= 2.0;
 228       break;
 229    case GLUT_KEY_RIGHT:
 230       alpha += 2.0;
 231       break;
 232    case GLUT_KEY_DOWN:
 233       beta -= 2.0;
 234       break;
 235    case GLUT_KEY_UP:
 236       beta += 2.0;
 237       break;
 238    }
 239 }
 240
 241 static void
 242 cleanup(void)
 243 {
 244    int i;
 245
 246    glDeleteTextures(1, &t1id);
 247    glDeleteTextures(1, &t2id);
 248
 249    glDeleteLists(skydlist, 1);
 250    for (i = 0; i < MAX_LOD; i++) {
 251       glDeleteLists(LODdlist[i], 1);
 252       glDeleteLists(LODnumpoly[i], 1);
 253    }
 254 }
 255
 256
 257 static void
 258 key(unsigned char k, int x, int y)
 259 {
 260    switch (k) {
 261    case 27:
 262       cleanup();
 263       exit(0);
 264       break;
 265
 266    case 'a':
 267       v += 0.01;
 268       break;
 269    case 'z':
 270       v -= 0.01;
 271       break;
 272
 273 #ifdef XMESA
 274    case ' ':
 275       fullscreen = (!fullscreen);
 276       XMesaSetFXmode(fullscreen ? XMESA_FX_FULLSCREEN : XMESA_FX_WINDOW);
 277       break;
 278 #endif
 279
 280    case '+':
 281       LODbias--;
 282       break;
 283    case '-':
 284       LODbias++;
 285       break;
 286    case 'j':
 287       joyactive = (!joyactive);
 288       break;
 289    case 'h':
 290       help = (!help);
 291       break;
 292    case 'f':
 293       fog = (!fog);
 294       break;
 295    case 't':
 296       usetex = (!usetex);
 297       break;
 298    case 'n':
 299       normext = (!normext);
 300       break;
 301    case 'b':
 302       if (bfcull) {
 303          glDisable(GL_CULL_FACE);
 304          bfcull = 0;
 305       }
 306       else {
 307          glEnable(GL_CULL_FACE);
 308          bfcull = 1;
 309       }
 310       break;
 311    case 'p':
 312       if (poutline) {
 313          glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 314          poutline = 0;
 315          usetex = 1;
 316       }
 317       else {
 318          glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 319          poutline = 1;
 320          usetex = 0;
 321       }
 322       break;
 323    }
 324 }
 325
 326 static void
 327 reshape(int w, int h)
 328 {
 329    WIDTH = w;
 330    HEIGHT = h;
 331    glMatrixMode(GL_PROJECTION);
 332    glLoadIdentity();
 333    gluPerspective(90.0, w / (float) h, 0.8, 100.0);
 334    glMatrixMode(GL_MODELVIEW);
 335    glLoadIdentity();
 336    glViewport(0, 0, w, h);
 337 }
 338
 339 static void
 340 printstring(void *font, char *string)
 341 {
 342    int len, i;
 343
 344    len = (int) strlen(string);
 345    for (i = 0; i < len; i++)
 346       glutBitmapCharacter(font, string[i]);
 347 }
 348
 349 static void
 350 printhelp(void)
 351 {
 352    glEnable(GL_BLEND);
 353    glColor4f(0.5, 0.5, 0.5, 0.5);
 354    glRecti(40, 40, 600, 440);
 355    glDisable(GL_BLEND);
 356
 357    glColor3f(1.0, 0.0, 0.0);
 358    glRasterPos2i(300, 420);
 359    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "Help");
 360
 361    glRasterPos2i(60, 390);
 362    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "h - Toggle Help");
 363    glRasterPos2i(60, 360);
 364    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "t - Toggle Textures");
 365    glRasterPos2i(60, 330);
 366    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "f - Toggle Fog");
 367    glRasterPos2i(60, 300);
 368    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "b - Toggle Back face culling");
 369    glRasterPos2i(60, 270);
 370    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "Arrow Keys - Rotate");
 371    glRasterPos2i(60, 240);
 372    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "a - Increase velocity");
 373    glRasterPos2i(60, 210);
 374    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "z - Decrease velocity");
 375    glRasterPos2i(60, 180);
 376    printstring(GLUT_BITMAP_TIMES_ROMAN_24, "p - Toggle Wire frame");
 377    glRasterPos2i(60, 150);
 378    printstring(GLUT_BITMAP_TIMES_ROMAN_24,
 379                "n - Toggle GL_EXT_rescale_normal extension");
 380    glRasterPos2i(60, 120);
 381    printstring(GLUT_BITMAP_TIMES_ROMAN_24,
 382                "+/- - Increase/decrease the Object maximum LOD");
 383
 384    glRasterPos2i(60, 90);
 385    if (joyavailable)
 386       printstring(GLUT_BITMAP_TIMES_ROMAN_24,
 387                   "j - Toggle jostick control (Joystick control available)");
 388    else
 389       printstring(GLUT_BITMAP_TIMES_ROMAN_24,
 390                   "(No Joystick control available)");
 391 }
 392
 393 static void
 394 dojoy(void)
 395 {
 396 #ifdef _WIN32
 397    static UINT max[2] = { 0, 0 };
 398    static UINT min[2] = { 0xffffffff, 0xffffffff }, center[2];
 399    MMRESULT res;
 400    JOYINFO joy;
 401
 402    res = joyGetPos(JOYSTICKID1, &joy);
 403
 404    if (res == JOYERR_NOERROR) {
 405       joyavailable = 1;
 406
 407       if (max[0] < joy.wXpos)
 408          max[0] = joy.wXpos;
 409       if (min[0] > joy.wXpos)
 410          min[0] = joy.wXpos;
 411       center[0] = (max[0] + min[0]) / 2;
 412
 413       if (max[1] < joy.wYpos)
 414          max[1] = joy.wYpos;
 415       if (min[1] > joy.wYpos)
 416          min[1] = joy.wYpos;
 417       center[1] = (max[1] + min[1]) / 2;
 418
 419       if (joyactive) {
 420          if (fabs(center[0] - (float) joy.wXpos) > 0.1 * (max[0] - min[0]))
 421             alpha -=
 422                2.0 * (center[0] - (float) joy.wXpos) / (max[0] - min[0]);
 423          if (fabs(center[1] - (float) joy.wYpos) > 0.1 * (max[1] - min[1]))
 424             beta += 2.0 * (center[1] - (float) joy.wYpos) / (max[1] - min[1]);
 425
 426          if (joy.wButtons & JOY_BUTTON1)
 427             v += 0.01;
 428          if (joy.wButtons & JOY_BUTTON2)
 429             v -= 0.01;
 430       }
 431    }
 432    else
 433       joyavailable = 0;
 434 #endif
 435 }
 436
 437 static void
 438 drawipers(int depth, int from)
 439 {
 440    int lod;
 441
 442    if (depth == maxdepth)
 443       return;
 444
 445    lod = depth + LODbias;
 446    if (lod < 0)
 447       lod = 0;
 448    if (lod >= MAX_LOD)
 449       return;
 450
 451    switch (from) {
 452    case FROM_NONE:
 453       glCallList(LODdlist[lod]);
 454
 455       depth++;
 456       drawipers(depth, FROM_DOWN);
 457       drawipers(depth, FROM_UP);
 458       drawipers(depth, FROM_FRONT);
 459       drawipers(depth, FROM_BACK);
 460       drawipers(depth, FROM_LEFT);
 461       drawipers(depth, FROM_RIGHT);
 462       break;
 463    case FROM_FRONT:
 464       glPushMatrix();
 465       glTranslatef(0.0f, -1.5f, 0.0f);
 466       glScalef(0.5f, 0.5f, 0.5f);
 467
 468       glCallList(LODdlist[lod]);
 469
 470       depth++;
 471       drawipers(depth, FROM_DOWN);
 472       drawipers(depth, FROM_UP);
 473       drawipers(depth, FROM_FRONT);
 474       drawipers(depth, FROM_LEFT);
 475       drawipers(depth, FROM_RIGHT);
 476       glPopMatrix();
 477       break;
 478    case FROM_BACK:
 479       glPushMatrix();
 480       glTranslatef(0.0f, 1.5f, 0.0f);
 481       glScalef(0.5f, 0.5f, 0.5f);
 482
 483       glCallList(LODdlist[lod]);
 484
 485       depth++;
 486       drawipers(depth, FROM_DOWN);
 487       drawipers(depth, FROM_UP);
 488       drawipers(depth, FROM_BACK);
 489       drawipers(depth, FROM_LEFT);
 490       drawipers(depth, FROM_RIGHT);
 491       glPopMatrix();
 492       break;
 493    case FROM_LEFT:
 494       glPushMatrix();
 495       glTranslatef(-1.5f, 0.0f, 0.0f);
 496       glScalef(0.5f, 0.5f, 0.5f);
 497
 498       glCallList(LODdlist[lod]);
 499
 500       depth++;
 501       drawipers(depth, FROM_DOWN);
 502       drawipers(depth, FROM_UP);
 503       drawipers(depth, FROM_FRONT);
 504       drawipers(depth, FROM_BACK);
 505       drawipers(depth, FROM_LEFT);
 506       glPopMatrix();
 507       break;
 508    case FROM_RIGHT:
 509       glPushMatrix();
 510       glTranslatef(1.5f, 0.0f, 0.0f);
 511       glScalef(0.5f, 0.5f, 0.5f);
 512
 513       glCallList(LODdlist[lod]);
 514
 515       depth++;
 516       drawipers(depth, FROM_DOWN);
 517       drawipers(depth, FROM_UP);
 518       drawipers(depth, FROM_FRONT);
 519       drawipers(depth, FROM_BACK);
 520       drawipers(depth, FROM_RIGHT);
 521       glPopMatrix();
 522       break;
 523    case FROM_DOWN:
 524       glPushMatrix();
 525       glTranslatef(0.0f, 0.0f, 1.5f);
 526       glScalef(0.5f, 0.5f, 0.5f);
 527
 528       glCallList(LODdlist[lod]);
 529
 530       depth++;
 531       drawipers(depth, FROM_DOWN);
 532       drawipers(depth, FROM_FRONT);
 533       drawipers(depth, FROM_BACK);
 534       drawipers(depth, FROM_LEFT);
 535       drawipers(depth, FROM_RIGHT);
 536       glPopMatrix();
 537       break;
 538    case FROM_UP:
 539       glPushMatrix();
 540       glTranslatef(0.0f, 0.0f, -1.5f);
 541       glScalef(0.5f, 0.5f, 0.5f);
 542
 543       glCallList(LODdlist[lod]);
 544
 545       depth++;
 546       drawipers(depth, FROM_UP);
 547       drawipers(depth, FROM_FRONT);
 548       drawipers(depth, FROM_BACK);
 549       drawipers(depth, FROM_LEFT);
 550       drawipers(depth, FROM_RIGHT);
 551       glPopMatrix();
 552       break;
 553    }
 554
 555    totpoly += LODnumpoly[lod];
 556 }
 557
 558 static void
 559 draw(void)
 560 {
 561    static char frbuf[80] = "";
 562    static GLfloat alpha = 0.0f;
 563    static GLfloat beta = 0.0f;
 564    static float fr = 0.0;
 565    static double t0 = -1.;
 566    double dt, t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
 567    if (t0 < 0.0)
 568       t0 = t;
 569    dt = t - t0;
 570    t0 = t;
 571
 572    dojoy();
 573
 574    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 575
 576    if (usetex)
 577       glEnable(GL_TEXTURE_2D);
 578    else
 579       glDisable(GL_TEXTURE_2D);
 580
 581    if (fog)
 582       glEnable(GL_FOG);
 583    else
 584       glDisable(GL_FOG);
 585
 586    glPushMatrix();
 587    calcposobs();
 588    gluLookAt(obs[0], obs[1], obs[2],
 589              obs[0] + dir[0], obs[1] + dir[1], obs[2] + dir[2],
 590              0.0, 0.0, 1.0);
 591
 592    /* Scene */
 593    glEnable(GL_DEPTH_TEST);
 594
 595    glShadeModel(GL_SMOOTH);
 596    glBindTexture(GL_TEXTURE_2D, t1id);
 597    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 598    glColor3f(1.0f, 1.0f, 1.0f);
 599    glEnable(GL_LIGHT0);
 600    glEnable(GL_LIGHTING);
 601
 602    if (normext)
 603       glEnable(GL_RESCALE_NORMAL_EXT);
 604    else
 605       glEnable(GL_NORMALIZE);
 606
 607    glPushMatrix();
 608    glRotatef(alpha, 0.0f, 0.0f, 1.0f);
 609    glRotatef(beta, 1.0f, 0.0f, 0.0f);
 610    totpoly = 0;
 611    drawipers(0, FROM_NONE);
 612    glPopMatrix();
 613
 614    alpha += 4.f * dt;
 615    beta += 2.4f * dt;
 616
 617    glDisable(GL_LIGHTING);
 618    glDisable(GL_LIGHT0);
 619    glShadeModel(GL_FLAT);
 620
 621    if (normext)
 622       glDisable(GL_RESCALE_NORMAL_EXT);
 623    else
 624       glDisable(GL_NORMALIZE);
 625
 626    glCallList(skydlist);
 627
 628    glPopMatrix();
 629
 630    /* Help Screen */
 631
 632    sprintf(frbuf,
 633            "Frame rate: %0.2f   LOD: %d   Tot. poly.: %d   Poly/sec: %.1f",
 634            fr, LODbias, totpoly, totpoly * fr);
 635
 636    glDisable(GL_TEXTURE_2D);
 637    glDisable(GL_FOG);
 638    glShadeModel(GL_FLAT);
 639    glDisable(GL_DEPTH_TEST);
 640
 641    glMatrixMode(GL_PROJECTION);
 642    glPushMatrix();
 643    glLoadIdentity();
 644    glOrtho(-0.5, 639.5, -0.5, 479.5, -1.0, 1.0);
 645
 646    glMatrixMode(GL_MODELVIEW);
 647    glLoadIdentity();
 648
 649    glColor3f(1.0, 0.0, 0.0);
 650    glRasterPos2i(10, 10);
 651    printstring(GLUT_BITMAP_HELVETICA_18, frbuf);
 652    glRasterPos2i(350, 470);
 653    printstring(GLUT_BITMAP_HELVETICA_10,
 654                "IperS V1.0 Written by David Bucciarelli (tech.hmw@plus.it)");
 655
 656    if (help)
 657       printhelp();
 658
 659    glMatrixMode(GL_PROJECTION);
 660    glPopMatrix();
 661    glMatrixMode(GL_MODELVIEW);
 662
 663    glutSwapBuffers();
 664
 665    Frames++;
 666    {
 667       GLint t = glutGet(GLUT_ELAPSED_TIME);
 668       if (t - T0 >= 2000) {
 669          GLfloat seconds = (t - T0) / 1000.0;
 670          fr = Frames / seconds;
 671          T0 = t;
 672          Frames = 0;
 673       }
 674    }
 675 }
 676
 677 int
 678 main(int ac, char **av)
 679 {
 680    float fogcolor[4] = { 0.7, 0.7, 0.7, 1.0 };
 681
 682    fprintf(stderr,
 683            "IperS V1.0\nWritten by David Bucciarelli (tech.hmw@plus.it)\n");
 684
 685    glutInitWindowSize(WIDTH, HEIGHT);
 686    glutInit(&ac, av);
 687
 688    glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
 689
 690    if (!(win = glutCreateWindow("IperS"))) {
 691       fprintf(stderr, "Error, couldn't open window\n");
 692       exit(-1);
 693    }
 694
 695    reshape(WIDTH, HEIGHT);
 696
 697    glShadeModel(GL_SMOOTH);
 698    glEnable(GL_DEPTH_TEST);
 699    glEnable(GL_CULL_FACE);
 700    glEnable(GL_TEXTURE_2D);
 701
 702    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 703
 704    glEnable(GL_FOG);
 705    glFogi(GL_FOG_MODE, GL_EXP2);
 706    glFogfv(GL_FOG_COLOR, fogcolor);
 707
 708    glFogf(GL_FOG_DENSITY, 0.006);
 709
 710    glHint(GL_FOG_HINT, GL_NICEST);
 711
 712    inittextures();
 713    initdlists();
 714    initlight();
 715
 716    glClearColor(fogcolor[0], fogcolor[1], fogcolor[2], fogcolor[3]);
 717    glClear(GL_COLOR_BUFFER_BIT);
 718
 719    calcposobs();
 720
 721    glutReshapeFunc(reshape);
 722    glutDisplayFunc(draw);
 723    glutKeyboardFunc(key);
 724    glutSpecialFunc(special);
 725    glutIdleFunc(draw);
 726
 727    glutMainLoop();
 728    cleanup();
 729
 730    return 0;
 731 }