home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 2000 April & May / AMIGA_2000_04.iso / patches / mesa3.1 / samples.tk / quad.c < prev    next >
C/C++ Source or Header  |  1998-10-23  |  11KB  |  465 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 "gltk.h"
  29.  
  30. #define PI 3.141592654
  31. #define    BLACK 0
  32. #define    GRAY 128
  33. #define    WHITE 255
  34. #define RD 0xA4,0x00,0x00,0xFF
  35. #define WT 0xFF,0xFF,0xFF,0xFF
  36. #define    brickImageWidth 16
  37. #define    brickImageHeight 16
  38.  
  39. GLenum rgb, doubleBuffer, directRender;
  40.  
  41. float black[3] =
  42. {
  43.   0.0, 0.0, 0.0
  44. };
  45. float blue[3] =
  46. {
  47.   0.0, 0.0, 1.0
  48. };
  49. float gray[3] =
  50. {
  51.   0.5, 0.5, 0.5
  52. };
  53. float white[3] =
  54. {
  55.   1.0, 1.0, 1.0
  56. };
  57.  
  58. GLenum doDither = GL_TRUE;
  59. GLenum shade = GL_TRUE;
  60. GLenum texture = GL_TRUE;
  61.  
  62. float xRotation = 30.0, yRotation = 30.0, zRotation = 0.0;
  63. GLint radius1, radius2;
  64. GLdouble angle1, angle2;
  65. GLint slices, stacks;
  66. GLint height;
  67. GLint orientation = GLU_OUTSIDE;
  68. GLint whichQuadric = 0;
  69. GLUquadricObj *quadObj;
  70.  
  71. GLubyte brickImage[4 * brickImageWidth * brickImageHeight] =
  72. {
  73.   RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  74.   RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  75.   RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  76.   RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  77.   WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  78.   RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  79.   RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  80.   RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  81.   RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  82.   WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  83.   RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  84.   RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  85.   RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  86.   RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  87.   WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  88.   RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD
  89. };
  90. char *texFileName = 0;
  91.  
  92. static void CALLBACK ErrorHandler(GLenum which)
  93. {
  94.  
  95.   fprintf(stderr, "Quad Error: %s\n", gluErrorString(which));
  96. }
  97.  
  98. static void Init(void)
  99. {
  100.   static GLint colorIndexes[3] =
  101.   {0, 200, 255};
  102.   static float ambient[] =
  103.   {0.1, 0.1, 0.1, 1.0};
  104.   static float diffuse[] =
  105.   {0.5, 1.0, 1.0, 1.0};
  106.   static float position[] =
  107.   {90.0, 90.0, 150.0, 0.0};
  108.   static float front_mat_shininess[] =
  109.   {30.0};
  110.   static float front_mat_specular[] =
  111.   {0.2, 0.2, 0.2, 1.0};
  112.   static float front_mat_diffuse[] =
  113.   {0.5, 0.28, 0.38, 1.0};
  114.   static float back_mat_shininess[] =
  115.   {50.0};
  116.   static float back_mat_specular[] =
  117.   {0.5, 0.5, 0.2, 1.0};
  118.   static float back_mat_diffuse[] =
  119.   {1.0, 1.0, 0.2, 1.0};
  120.   static float lmodel_ambient[] =
  121.   {1.0, 1.0, 1.0, 1.0};
  122.   static float lmodel_twoside[] =
  123.   {GL_TRUE};
  124.   static float decal[] =
  125.   {GL_DECAL};
  126.   static float repeat[] =
  127.   {GL_REPEAT};
  128.   static float nearest[] =
  129.   {GL_NEAREST};
  130.   TK_RGBImageRec *image;
  131.  
  132.   if (!rgb) {
  133.     tkSetGreyRamp();
  134.   }
  135.   glClearColor(0.0, 0.0, 0.0, 0.0);
  136.  
  137.   glEnable(GL_DEPTH_TEST);
  138.  
  139.   glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
  140.   glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
  141.   glLightfv(GL_LIGHT0, GL_POSITION, position);
  142.   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
  143.   glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
  144.   glEnable(GL_LIGHTING);
  145.   glEnable(GL_LIGHT0);
  146.  
  147.   glMaterialfv(GL_FRONT, GL_SHININESS, front_mat_shininess);
  148.   glMaterialfv(GL_FRONT, GL_SPECULAR, front_mat_specular);
  149.   glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);
  150.   glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);
  151.   glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);
  152.   glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
  153.   if (!rgb) {
  154.     glMaterialiv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, colorIndexes);
  155.   }
  156.  
  157.   glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
  158.   glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, repeat);
  159.   glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, repeat);
  160.   glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nearest);
  161.   glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nearest);
  162.   if (texFileName) {
  163.     image = tkRGBImageLoad(texFileName);
  164.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  165.     gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image->sizeX, image->sizeY,
  166.               GL_RGB, GL_UNSIGNED_BYTE, image->data);
  167.   }
  168.   else {
  169.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  170.     glTexImage2D(GL_TEXTURE_2D, 0, 4, brickImageWidth, brickImageHeight,
  171.          0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *) brickImage);
  172.   }
  173.  
  174.   quadObj = gluNewQuadric();
  175.   gluQuadricCallback(quadObj, GLU_ERROR, ErrorHandler);
  176.  
  177.   radius1 = 10;
  178.   radius2 = 5;
  179.   angle1 = 90;
  180.   angle2 = 180;
  181.   slices = 16;
  182.   stacks = 10;
  183.   height = 20;
  184. }
  185.  
  186. static void Reshape(int width, int height)
  187. {
  188.  
  189.   glViewport(0, 0, (GLint) width, (GLint) height);
  190.  
  191.   glMatrixMode(GL_PROJECTION);
  192.   glLoadIdentity();
  193.   glFrustum(-1, 1, -1, 1, 1, 10);
  194.   gluLookAt(2, 2, 2, 0, 0, 0, 0, 0, 1);
  195.   glMatrixMode(GL_MODELVIEW);
  196. }
  197.  
  198. static GLenum Key(int key, GLenum mask)
  199. {
  200.  
  201.   switch (key) {
  202.     case TK_ESCAPE:
  203.       tkQuit();
  204.  
  205.     case TK_LEFT:
  206.       yRotation += 5;
  207.       break;
  208.     case TK_RIGHT:
  209.       yRotation -= 5;
  210.       break;
  211.     case TK_UP:
  212.       xRotation += 5;
  213.       break;
  214.     case TK_DOWN:
  215.       xRotation -= 5;
  216.       break;
  217.     case TK_X:
  218.       zRotation += 5;
  219.       break;
  220.     case TK_x:
  221.       zRotation -= 5;
  222.       break;
  223.  
  224.     case TK_1:
  225.       gluQuadricDrawStyle(quadObj, GLU_FILL);
  226.       break;
  227.     case TK_2:
  228.       gluQuadricDrawStyle(quadObj, GLU_POINT);
  229.       break;
  230.     case TK_3:
  231.       gluQuadricDrawStyle(quadObj, GLU_LINE);
  232.       break;
  233.     case TK_4:
  234.       gluQuadricDrawStyle(quadObj, GLU_SILHOUETTE);
  235.       break;
  236.  
  237.     case TK_0:
  238.       shade = !shade;
  239.       if (shade) {
  240.     glShadeModel(GL_SMOOTH);
  241.     gluQuadricNormals(quadObj, GLU_SMOOTH);
  242.       }
  243.       else {
  244.     glShadeModel(GL_FLAT);
  245.     gluQuadricNormals(quadObj, GLU_FLAT);
  246.       }
  247.       break;
  248.  
  249.     case TK_A:
  250.       stacks++;
  251.       break;
  252.     case TK_a:
  253.       stacks--;
  254.       break;
  255.  
  256.     case TK_S:
  257.       slices++;
  258.       break;
  259.     case TK_s:
  260.       slices--;
  261.       break;
  262.  
  263.     case TK_d:
  264.       switch (orientation) {
  265.     case GLU_OUTSIDE:
  266.       orientation = GLU_INSIDE;
  267.       break;
  268.     case GLU_INSIDE:
  269.     default:
  270.       orientation = GLU_OUTSIDE;
  271.       break;
  272.       }
  273.       gluQuadricOrientation(quadObj, orientation);
  274.       break;
  275.  
  276.     case TK_f:
  277.       whichQuadric = (whichQuadric + 1) % 4;
  278.       break;
  279.  
  280.     case TK_G:
  281.       radius1 += 1;
  282.       break;
  283.     case TK_g:
  284.       radius1 -= 1;
  285.       break;
  286.  
  287.     case TK_J:
  288.       radius2 += 1;
  289.       break;
  290.     case TK_j:
  291.       radius2 -= 1;
  292.       break;
  293.  
  294.     case TK_H:
  295.       height += 2;
  296.       break;
  297.     case TK_h:
  298.       height -= 2;
  299.       break;
  300.  
  301.     case TK_K:
  302.       angle1 += 5;
  303.       break;
  304.     case TK_k:
  305.       angle1 -= 5;
  306.       break;
  307.  
  308.     case TK_L:
  309.       angle2 += 5;
  310.       break;
  311.     case TK_l:
  312.       angle2 -= 5;
  313.       break;
  314.  
  315.     case TK_z:
  316.       texture = !texture;
  317.       if (texture) {
  318.     gluQuadricTexture(quadObj, GL_TRUE);
  319.     glEnable(GL_TEXTURE_2D);
  320.       }
  321.       else {
  322.     gluQuadricTexture(quadObj, GL_FALSE);
  323.     glDisable(GL_TEXTURE_2D);
  324.       }
  325.       break;
  326.  
  327.     case TK_q:
  328.       glDisable(GL_CULL_FACE);
  329.       break;
  330.     case TK_w:
  331.       glEnable(GL_CULL_FACE);
  332.       glCullFace(GL_FRONT);
  333.       break;
  334.     case TK_e:
  335.       glEnable(GL_CULL_FACE);
  336.       glCullFace(GL_BACK);
  337.       break;
  338.  
  339.     case TK_r:
  340.       glFrontFace(GL_CW);
  341.       break;
  342.     case TK_t:
  343.       glFrontFace(GL_CCW);
  344.       break;
  345.  
  346.     case TK_y:
  347.       doDither = !doDither;
  348.       (doDither) ? glEnable(GL_DITHER) : glDisable(GL_DITHER);
  349.       break;
  350.  
  351.     default:
  352.       return GL_FALSE;
  353.   }
  354.   return GL_TRUE;
  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.     tkSwapBuffers();
  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.   directRender = GL_TRUE;
  400.  
  401.   for (i = 1; i < argc; i++) {
  402.     if (strcmp(argv[i], "-ci") == 0) {
  403.       rgb = GL_FALSE;
  404.     }
  405.     else if (strcmp(argv[i], "-rgb") == 0) {
  406.       rgb = GL_TRUE;
  407.     }
  408.     else if (strcmp(argv[i], "-sb") == 0) {
  409.       doubleBuffer = GL_FALSE;
  410.     }
  411.     else if (strcmp(argv[i], "-db") == 0) {
  412.       doubleBuffer = GL_TRUE;
  413.     }
  414.     else if (strcmp(argv[i], "-dr") == 0) {
  415.       directRender = GL_TRUE;
  416.     }
  417.     else if (strcmp(argv[i], "-ir") == 0) {
  418.       directRender = GL_FALSE;
  419.     }
  420.     else if (strcmp(argv[i], "-f") == 0) {
  421.       if (i + 1 >= argc || argv[i + 1][0] == '-') {
  422.     printf("-f (No file name).\n");
  423.     return GL_FALSE;
  424.       }
  425.       else {
  426.     texFileName = argv[++i];
  427.       }
  428.     }
  429.     else {
  430.       printf("%s (Bad option).\n", argv[i]);
  431.       return GL_FALSE;
  432.     }
  433.   }
  434.   return GL_TRUE;
  435. }
  436.  
  437. void main(int argc, char **argv)
  438. {
  439.   GLenum type;
  440.  
  441.   if (Args(argc, argv) == GL_FALSE) {
  442.     tkQuit();
  443.   }
  444.  
  445.   tkInitPosition(0, 0, 300, 300);
  446.  
  447.   type = TK_DEPTH;
  448.   type |= (rgb) ? TK_RGB : TK_INDEX;
  449.   type |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  450.   type |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  451.   tkInitDisplayMode(type);
  452.  
  453.   if (tkInitWindow("Quad Test") == GL_FALSE) {
  454.     tkQuit();
  455.   }
  456.  
  457.   Init();
  458.  
  459.   tkExposeFunc(Reshape);
  460.   tkReshapeFunc(Reshape);
  461.   tkKeyDownFunc(Key);
  462.   tkDisplayFunc(Draw);
  463.   tkExec();
  464. }
  465.