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