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