home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 2000 April & May / AMIGA_2000_04.iso / patches / mesa3.1 / samples / quad.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-01  |  10.5 KB  |  456 lines
  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. }
  456.