progs/samples/quad.c

   1 /*
   2  * Copyright (c) 1991, 1992, 1993 Silicon Graphics, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that (i) the above copyright notices and this permission notice appear in
   7  * all copies of the software and related documentation, and (ii) the name of
   8  * Silicon Graphics may not be used in any advertising or
   9  * publicity relating to the software without the specific, prior written
  10  * permission of Silicon Graphics.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF
  13  * ANY KIND,
  14  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  15  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  16  *
  17  * IN NO EVENT SHALL SILICON GRAPHICS BE LIABLE FOR
  18  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  19  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  20  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  21  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22  * OF THIS SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <GL/glut.h>
  29
  30
  31 #ifndef CALLBACK
  32 #define CALLBACK
  33 #endif
  34
  35
  36 #define PI 3.141592654
  37 #define BLACK 0
  38 #define GRAY 128
  39 #define WHITE 255
  40 #define RD 0xA4,0x00,0x00,0xFF
  41 #define WT 0xFF,0xFF,0xFF,0xFF
  42 #define brickImageWidth 16
  43 #define brickImageHeight 16
  44
  45
  46 #include "loadppm.c"
  47
  48 GLenum rgb, doubleBuffer;
  49
  50 #include "tkmap.c"
  51
  52 float black[3] = {
  53     0.0, 0.0, 0.0
  54 };
  55 float blue[3] =  {
  56     0.0, 0.0, 1.0
  57 };
  58 float gray[3] =  {
  59     0.5, 0.5, 0.5
  60 };
  61 float white[3] = {
  62     1.0, 1.0, 1.0
  63 };
  64
  65 GLenum doDither = GL_TRUE;
  66 GLenum shade = GL_TRUE;
  67 GLenum texture = GL_TRUE;
  68
  69 float xRotation = 30.0, yRotation = 30.0, zRotation = 0.0;
  70 GLint radius1, radius2;
  71 GLdouble angle1, angle2;
  72 GLint slices, stacks;
  73 GLint height;
  74 GLint orientation = GLU_OUTSIDE;
  75 GLint whichQuadric=0;
  76 GLUquadricObj *quadObj;
  77
  78 GLubyte brickImage[4*brickImageWidth*brickImageHeight] = {
  79     RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  80     RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  81     RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  82     RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  83     WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  84     RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  85     RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  86     RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  87     RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  88     WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  89     RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  90     RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  91     RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  92     RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  93     WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  94     RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD
  95 };
  96 char *texFileName = 0;
  97
  98
  99 static void CALLBACK ErrorHandler(GLenum which)
 100 {
 101
 102     fprintf(stderr, "Quad Error: %s\n", gluErrorString(which));
 103 }
 104
 105 static void Init(void)
 106 {
 107     static GLint colorIndexes[3] = {0, 200, 255};
 108     static float ambient[] = {0.1, 0.1, 0.1, 1.0};
 109     static float diffuse[] = {0.5, 1.0, 1.0, 1.0};
 110     static float position[] = {90.0, 90.0, 150.0, 0.0};
 111     static float front_mat_shininess[] = {30.0};
 112     static float front_mat_specular[] = {0.2, 0.2, 0.2, 1.0};
 113     static float front_mat_diffuse[] = {0.5, 0.28, 0.38, 1.0};
 114     static float back_mat_shininess[] = {50.0};
 115     static float back_mat_specular[] = {0.5, 0.5, 0.2, 1.0};
 116     static float back_mat_diffuse[] = {1.0, 1.0, 0.2, 1.0};
 117     static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0};
 118     static float lmodel_twoside[] = {GL_TRUE};
 119     static float decal[] = {GL_DECAL};
 120     static float repeat[] = {GL_REPEAT};
 121     static float nearest[] = {GL_NEAREST};
 122     static PPMImage *image;
 123
 124     if (!rgb) {
 125         SetGreyRamp();
 126     }
 127     glClearColor(0.0, 0.0, 0.0, 0.0);
 128
 129     glEnable(GL_DEPTH_TEST);
 130
 131     glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
 132     glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
 133     glLightfv(GL_LIGHT0, GL_POSITION, position);
 134     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
 135     glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
 136     glEnable(GL_LIGHTING);
 137     glEnable(GL_LIGHT0);
 138
 139     glMaterialfv(GL_FRONT, GL_SHININESS, front_mat_shininess);
 140     glMaterialfv(GL_FRONT, GL_SPECULAR, front_mat_specular);
 141     glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);
 142     glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);
 143     glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);
 144     glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
 145     if (!rgb) {
 146         glMaterialiv( GL_FRONT_AND_BACK, GL_COLOR_INDEXES, colorIndexes);
 147     }
 148
 149     glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
 150     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, repeat);
 151     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, repeat);
 152     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nearest);
 153     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nearest);
 154     if (texFileName) {
 155         image = LoadPPM(texFileName);
 156         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 157         gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image->sizeX, image->sizeY,
 158                           GL_RGB, GL_UNSIGNED_BYTE, image->data);
 159     } else {
 160         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 161         glTexImage2D(GL_TEXTURE_2D, 0, 4, brickImageWidth, brickImageHeight,
 162                      0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)brickImage);
 163     }
 164
 165     quadObj = gluNewQuadric();
 166     gluQuadricCallback(quadObj, GLU_ERROR, ErrorHandler);
 167
 168     radius1 = 10;
 169     radius2 = 5;
 170     angle1 = 90;
 171     angle2 = 180;
 172     slices = 16;
 173     stacks = 10;
 174     height = 20;
 175 }
 176
 177 static void Reshape(int width, int height)
 178 {
 179
 180     glViewport(0, 0, (GLint)width, (GLint)height);
 181
 182     glMatrixMode(GL_PROJECTION);
 183     glLoadIdentity();
 184     glFrustum(-1, 1, -1, 1, 1, 10);
 185     gluLookAt(2, 2, 2, 0, 0, 0, 0, 0, 1);
 186     glMatrixMode(GL_MODELVIEW);
 187 }
 188
 189 static void Key2(int key, int x, int y)
 190 {
 191
 192     switch (key) {
 193       case GLUT_KEY_LEFT:
 194         yRotation += 5;
 195         break;
 196       case GLUT_KEY_RIGHT:
 197         yRotation -= 5;
 198         break;
 199       case GLUT_KEY_UP:
 200         xRotation += 5;
 201         break;
 202       case GLUT_KEY_DOWN:
 203         xRotation -= 5;
 204         break;
 205       default:
 206         return;
 207     }
 208
 209     glutPostRedisplay();
 210 }
 211
 212 static void Key(unsigned char key, int x, int y)
 213 {
 214
 215     switch (key) {
 216       case 27:
 217         exit(1);
 218
 219       case 'X':
 220         zRotation += 5;
 221         break;
 222       case 'x':
 223         zRotation -= 5;
 224         break;
 225
 226       case '1':
 227         gluQuadricDrawStyle(quadObj, GLU_FILL);
 228         break;
 229       case '2':
 230         gluQuadricDrawStyle(quadObj, GLU_POINT);
 231         break;
 232       case '3':
 233         gluQuadricDrawStyle(quadObj, GLU_LINE);
 234         break;
 235       case '4':
 236         gluQuadricDrawStyle(quadObj, GLU_SILHOUETTE);
 237         break;
 238
 239       case '0':
 240         shade = !shade;
 241         if (shade) {
 242             glShadeModel(GL_SMOOTH);
 243             gluQuadricNormals(quadObj, GLU_SMOOTH);
 244         } else {
 245             glShadeModel(GL_FLAT);
 246             gluQuadricNormals(quadObj, GLU_FLAT);
 247         }
 248         break;
 249
 250       case 'A':
 251         stacks++;
 252         break;
 253       case 'a':
 254         stacks--;
 255         break;
 256
 257       case 'S':
 258         slices++;
 259         break;
 260       case 's':
 261         slices--;
 262         break;
 263
 264       case 'd':
 265         switch(orientation) {
 266           case GLU_OUTSIDE:
 267             orientation = GLU_INSIDE;
 268             break;
 269           case GLU_INSIDE:
 270           default:
 271             orientation = GLU_OUTSIDE;
 272             break;
 273         }
 274         gluQuadricOrientation(quadObj, orientation);
 275         break;
 276
 277       case 'f':
 278         whichQuadric = (whichQuadric + 1) % 4;
 279         break;
 280
 281       case 'G':
 282         radius1 += 1;
 283         break;
 284       case 'g':
 285         radius1 -= 1;
 286         break;
 287
 288       case 'J':
 289         radius2 += 1;
 290         break;
 291       case 'j':
 292         radius2 -= 1;
 293         break;
 294
 295       case 'H':
 296         height += 2;
 297         break;
 298       case 'h':
 299         height -= 2;
 300         break;
 301
 302       case 'K':
 303         angle1 += 5;
 304         break;
 305       case 'k':
 306         angle1 -= 5;
 307         break;
 308
 309       case 'L':
 310         angle2 += 5;
 311         break;
 312       case 'l':
 313         angle2 -= 5;
 314         break;
 315
 316       case 'z':
 317         texture = !texture;
 318         if (texture) {
 319             gluQuadricTexture(quadObj, GL_TRUE);
 320             glEnable(GL_TEXTURE_2D);
 321         } else {
 322             gluQuadricTexture(quadObj, GL_FALSE);
 323             glDisable(GL_TEXTURE_2D);
 324         }
 325         break;
 326
 327       case 'q':
 328         glDisable(GL_CULL_FACE);
 329         break;
 330       case 'w':
 331         glEnable(GL_CULL_FACE);
 332         glCullFace(GL_FRONT);
 333         break;
 334       case 'e':
 335         glEnable(GL_CULL_FACE);
 336         glCullFace(GL_BACK);
 337         break;
 338
 339       case 'r':
 340         glFrontFace(GL_CW);
 341         break;
 342       case 't':
 343         glFrontFace(GL_CCW);
 344         break;
 345
 346       case 'y':
 347         doDither = !doDither;
 348         (doDither) ? glEnable(GL_DITHER) : glDisable(GL_DITHER);
 349         break;
 350       default:
 351         return;
 352     }
 353
 354     glutPostRedisplay();
 355 }
 356
 357 static void Draw(void)
 358 {
 359
 360     glLoadIdentity();
 361     glRotatef(xRotation, 1, 0, 0);
 362     glRotatef(yRotation, 0, 1, 0);
 363     glRotatef(zRotation, 0, 0, 1);
 364
 365     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 366
 367     glColor3f(1.0, 1.0, 1.0);
 368     switch (whichQuadric) {
 369       case 0:
 370         glTranslatef(0, 0, -height/20.0);
 371         gluCylinder(quadObj, radius1/10.0, radius2/10.0, height/10.0,
 372                     slices, stacks);
 373         break;
 374       case 1:
 375         gluSphere(quadObj, radius1/10.0, slices, stacks);
 376         break;
 377       case 2:
 378         gluPartialDisk(quadObj, radius2/10.0, radius1/10.0, slices,
 379                        stacks, angle1, angle2);
 380         break;
 381       case 3:
 382         gluDisk(quadObj, radius2/10.0, radius1/10.0, slices, stacks);
 383         break;
 384     }
 385
 386     glFlush();
 387
 388     if (doubleBuffer) {
 389         glutSwapBuffers();
 390     }
 391 }
 392
 393 static GLenum Args(int argc, char **argv)
 394 {
 395     GLint i;
 396
 397     rgb = GL_TRUE;
 398     doubleBuffer = GL_FALSE;
 399
 400     for (i = 1; i < argc; i++) {
 401         if (strcmp(argv[i], "-ci") == 0) {
 402             rgb = GL_FALSE;
 403         } else if (strcmp(argv[i], "-rgb") == 0) {
 404             rgb = GL_TRUE;
 405         } else if (strcmp(argv[i], "-sb") == 0) {
 406             doubleBuffer = GL_FALSE;
 407         } else if (strcmp(argv[i], "-db") == 0) {
 408             doubleBuffer = GL_TRUE;
 409         } else if (strcmp(argv[i], "-f") == 0) {
 410             if (i+1 >= argc || argv[i+1][0] == '-') {
 411                 printf("-f (No file name).\n");
 412                 return GL_FALSE;
 413             } else {
 414                 texFileName = argv[++i];
 415             }
 416         } else {
 417             printf("%s (Bad option).\n", argv[i]);
 418             return GL_FALSE;
 419         }
 420     }
 421     return GL_TRUE;
 422 }
 423
 424 int main(int argc, char **argv)
 425 {
 426     GLenum type;
 427
 428     glutInit(&argc, argv);
 429
 430     if (Args(argc, argv) == GL_FALSE) {
 431         exit(1);
 432     }
 433
 434     glutInitWindowPosition(0, 0); glutInitWindowSize( 300, 300);
 435
 436     type = GLUT_DEPTH;
 437     type |= (rgb) ? GLUT_RGB : GLUT_INDEX;
 438     type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
 439     glutInitDisplayMode(type);
 440
 441     if (glutCreateWindow("Quad Test") == GL_FALSE) {
 442         exit(1);
 443     }
 444
 445     InitMap();
 446
 447     Init();
 448
 449     glutReshapeFunc(Reshape);
 450     glutKeyboardFunc(Key);
 451     glutSpecialFunc(Key2);
 452     glutDisplayFunc(Draw);
 453     glutMainLoop();
 454         return 0;
 455 }