home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / oglgold.zip / SAMPLES / TK / PRIM.C < prev    next >
C/C++ Source or Header  |  1997-09-30  |  12KB  |  584 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. //#include <unistd.h>
  4. #include <stdlib.h>
  5. #include "tk.h"
  6.  
  7.  
  8. float tkRGBMap[8][3] = {
  9.     {
  10.     0, 0, 0
  11.     },
  12.     {
  13.     1, 0, 0
  14.     },
  15.     {
  16.     0, 1, 0
  17.     },
  18.     {
  19.     1, 1, 0
  20.     },
  21.     {
  22.     0, 0, 1
  23.     },
  24.     {
  25.     1, 0, 1
  26.     },
  27.     {
  28.     0, 1, 1
  29.     },
  30.     {
  31.     1, 1, 1
  32.     }
  33. };
  34.  
  35. #define PIXEL_CENTER(x) ((long)(x) + 0.5)
  36.  
  37. #define GAP 10
  38. #define ROWS 3
  39. #define COLS 4
  40.  
  41. #define OPENGL_WIDTH 48
  42. #define OPENGL_HEIGHT 13
  43.  
  44.  
  45. GLenum rgb, doubleBuffer, directRender, windType;
  46. GLint windW, windH;
  47.  
  48. GLenum mode1, mode2;
  49. GLint boxW, boxH;
  50. GLubyte OpenGL_bits[] = {
  51.    0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 
  52.    0x7f, 0xfb, 0xff, 0xff, 0xff, 0x01,
  53.    0x7f, 0xfb, 0xff, 0xff, 0xff, 0x01, 
  54.    0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
  55.    0x3e, 0x8f, 0xb7, 0xf9, 0xfc, 0x01, 
  56.    0x63, 0xdb, 0xb0, 0x8d, 0x0d, 0x00,
  57.    0x63, 0xdb, 0xb7, 0x8d, 0x0d, 0x00, 
  58.    0x63, 0xdb, 0xb6, 0x8d, 0x0d, 0x00,
  59.    0x63, 0x8f, 0xf3, 0xcc, 0x0d, 0x00, 
  60.    0x63, 0x00, 0x00, 0x0c, 0x4c, 0x0a,
  61.    0x63, 0x00, 0x00, 0x0c, 0x4c, 0x0e, 
  62.    0x63, 0x00, 0x00, 0x8c, 0xed, 0x0e,
  63.    0x3e, 0x00, 0x00, 0xf8, 0x0c, 0x00, 
  64. };
  65.  
  66.  
  67. static void Init(void)
  68. {
  69.  
  70.     mode1 = GL_TRUE;
  71.     mode2 = GL_TRUE;
  72. }
  73.  
  74. static void Reshape(int width, int height)
  75. {
  76.  
  77.     windW = (GLint)width;
  78.     windH = (GLint)height;
  79. }
  80.  
  81. static void RotateColorMask(void)
  82. {
  83.     static GLint rotation = 0;
  84.     
  85.     rotation = (rotation + 1) & 0x3;
  86.     switch (rotation) {
  87.       case 0:
  88.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  89.     glIndexMask( 0xff );
  90.     break;
  91.       case 1:
  92.     glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
  93.     glIndexMask(0xFE);
  94.     break;
  95.       case 2:
  96.     glColorMask(GL_TRUE, GL_FALSE, GL_TRUE, GL_TRUE);
  97.     glIndexMask(0xFD);
  98.     break;
  99.       case 3:
  100.     glColorMask(GL_TRUE, GL_TRUE, GL_FALSE, GL_TRUE);
  101.     glIndexMask(0xFB);
  102.     break;
  103.     }
  104. }
  105.  
  106. static GLenum Key(int key, GLenum mask)
  107. {
  108.  
  109.     switch (key) {
  110.       case TK_B:
  111. /*
  112.     tkClipBoard();
  113. */
  114.     break;
  115.       case TK_ESCAPE:
  116.     tkQuit();
  117.       case TK_1:
  118.     mode1 = !mode1;
  119.     break;
  120.       case TK_2:
  121.     mode2 = !mode2;
  122.     break;
  123.       case TK_3:
  124.     RotateColorMask();
  125.     break;
  126.       default:
  127.     return GL_FALSE;
  128.     }
  129.     return GL_TRUE;
  130. }
  131.  
  132. static void Viewport(GLint row, GLint column)
  133. {
  134.     GLint x, y;
  135.  
  136.     boxW = (windW - (COLS + 1) * GAP) / COLS;
  137.     boxH = (windH - (ROWS + 1) * GAP) / ROWS;
  138.  
  139.     x = GAP + column * (boxW + GAP);
  140.     y = GAP + row * (boxH + GAP);
  141.  
  142.     glViewport(x, y, boxW, boxH);
  143.  
  144.     glMatrixMode(GL_PROJECTION);
  145.     glLoadIdentity();
  146.     glOrtho(-boxW/2, boxW/2, -boxH/2, boxH/2, 0.0, 1.0);
  147.     glMatrixMode(GL_MODELVIEW);
  148.  
  149.     glEnable(GL_SCISSOR_TEST);
  150.     glScissor(x, y, boxW, boxH);
  151. }
  152.  
  153. static void Point(void)
  154. {
  155.     GLint i;
  156.  
  157.     glBegin(GL_POINTS);
  158.     TK_SETCOLOR(windType, TK_WHITE);
  159.     glVertex2i(0, 0);
  160.     for (i = 1; i < 8; i++) {
  161.         GLint j = i * 2;
  162.         TK_SETCOLOR(windType, TK_RED+i);
  163.         glVertex2i(-j, -j);
  164.         glVertex2i(-j, 0);
  165.         glVertex2i(-j, j);
  166.         glVertex2i(0, j);
  167.         glVertex2i(j, j);
  168.         glVertex2i(j, 0);
  169.         glVertex2i(j, -j);
  170.         glVertex2i(0, -j);
  171.     }
  172.     glEnd();
  173. }
  174.  
  175. static void Lines(void)
  176. {
  177.     GLint i;
  178.  
  179.     glPushMatrix();
  180.  
  181.     glTranslatef(-12, 0, 0);
  182.     for (i = 1; i < 8; i++) {
  183.     TK_SETCOLOR(windType, TK_RED+i);
  184.     glBegin(GL_LINES);
  185.         glVertex2i(-boxW/4, -boxH/4);
  186.         glVertex2i(boxW/4, boxH/4);
  187.     glEnd();
  188.     glTranslatef(4, 0, 0);
  189.     }
  190.  
  191.     glPopMatrix();
  192.  
  193.     glBegin(GL_LINES);
  194.     glVertex2i(0, 0);
  195.     glEnd();
  196. }
  197.  
  198. static void LineStrip(void)
  199. {
  200.  
  201.     glBegin(GL_LINE_STRIP);
  202.     TK_SETCOLOR(windType, TK_RED);
  203.     glVertex2f(PIXEL_CENTER(-boxW/4), PIXEL_CENTER(-boxH/4));
  204.     TK_SETCOLOR(windType, TK_GREEN);
  205.     glVertex2f(PIXEL_CENTER(-boxW/4), PIXEL_CENTER(boxH/4));
  206.     TK_SETCOLOR(windType, TK_BLUE);
  207.     glVertex2f(PIXEL_CENTER(boxW/4), PIXEL_CENTER(boxH/4));
  208.     TK_SETCOLOR(windType, TK_WHITE);
  209.     glVertex2f(PIXEL_CENTER(boxW/4), PIXEL_CENTER(-boxH/4));
  210.     glEnd();
  211.  
  212.     glBegin(GL_LINE_STRIP);
  213.     glVertex2i(0, 0);
  214.     glEnd();
  215. }
  216.  
  217. static void LineLoop(void)
  218. {
  219.  
  220.     glBegin(GL_LINE_LOOP);
  221.     TK_SETCOLOR(windType, TK_RED);
  222.     glVertex2f(PIXEL_CENTER(-boxW/4), PIXEL_CENTER(-boxH/4));
  223.     TK_SETCOLOR(windType, TK_GREEN);
  224.     glVertex2f(PIXEL_CENTER(-boxW/4), PIXEL_CENTER(boxH/4));
  225.     TK_SETCOLOR(windType, TK_BLUE);
  226.     glVertex2f(PIXEL_CENTER(boxW/4), PIXEL_CENTER(boxH/4));
  227.     TK_SETCOLOR(windType, TK_WHITE);
  228.     glVertex2f(PIXEL_CENTER(boxW/4), PIXEL_CENTER(-boxH/4));
  229.     glEnd();
  230.  
  231.     glEnable(GL_LOGIC_OP);
  232.     glLogicOp(GL_XOR);
  233.  
  234.     glEnable(GL_BLEND);
  235.     glBlendFunc(GL_ONE, GL_ONE);
  236.  
  237.     TK_SETCOLOR(windType, TK_MAGENTA);
  238.     glBegin(GL_LINE_LOOP);
  239.     glVertex2f(PIXEL_CENTER(-boxW/8), PIXEL_CENTER(-boxH/8));
  240.     glVertex2f(PIXEL_CENTER(-boxW/8), PIXEL_CENTER(boxH/8));
  241.     glEnd();
  242.     glBegin(GL_LINE_LOOP);
  243.     glVertex2f(PIXEL_CENTER(-boxW/8), PIXEL_CENTER(boxH/8+5));
  244.     glVertex2f(PIXEL_CENTER(boxW/8), PIXEL_CENTER(boxH/8+5));
  245.     glEnd();
  246.     glDisable(GL_LOGIC_OP);
  247.     glDisable(GL_BLEND);
  248.  
  249.     TK_SETCOLOR(windType, TK_GREEN);
  250.     glBegin(GL_POINTS);
  251.     glVertex2i(0, 0);
  252.     glEnd();
  253.  
  254.     glBegin(GL_LINE_LOOP);
  255.     glVertex2i(0, 0);
  256.     glEnd();
  257. }
  258.  
  259. static void Bitmap(void)
  260. {
  261.  
  262.     glBegin(GL_LINES);
  263.     TK_SETCOLOR(windType, TK_GREEN);
  264.     glVertex2i(-boxW/2, 0);
  265.     glVertex2i(boxW/2, 0);
  266.     glVertex2i(0, -boxH/2);
  267.     glVertex2i(0, boxH/2);
  268.     TK_SETCOLOR(windType, TK_RED);
  269.     glVertex2i(0, -3);
  270.     glVertex2i(0, -3+OPENGL_HEIGHT);
  271.     TK_SETCOLOR(windType, TK_BLUE);
  272.     glVertex2i(0, -3);
  273.     glVertex2i(OPENGL_WIDTH, -3);
  274.     glEnd();
  275.  
  276.     TK_SETCOLOR(windType, TK_GREEN);
  277.  
  278.     glPixelStorei(GL_UNPACK_LSB_FIRST, GL_TRUE);
  279.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  280.  
  281.     glRasterPos2i(0, 0);
  282.     glBitmap(OPENGL_WIDTH, OPENGL_HEIGHT, 0, 3, 0.0, 0.0, OpenGL_bits);
  283. }
  284.  
  285. static void Triangles(void)
  286. {
  287.  
  288.     glBegin(GL_TRIANGLES);
  289.     TK_SETCOLOR(windType, TK_GREEN);
  290.     glVertex2i(-boxW/4, -boxH/4);
  291.     TK_SETCOLOR(windType, TK_RED);
  292.     glVertex2i(-boxW/8, -boxH/16);
  293.     TK_SETCOLOR(windType, TK_BLUE);
  294.     glVertex2i(boxW/8, -boxH/16);
  295.  
  296.     TK_SETCOLOR(windType, TK_GREEN);
  297.     glVertex2i(-boxW/4, boxH/4);
  298.     TK_SETCOLOR(windType, TK_RED);
  299.     glVertex2i(-boxW/8, boxH/16);
  300.     TK_SETCOLOR(windType, TK_BLUE);
  301.     glVertex2i(boxW/8, boxH/16);
  302.     glEnd();
  303.  
  304.     glBegin(GL_TRIANGLES);
  305.     glVertex2i(0, 0);
  306.     glVertex2i(-100, 100);
  307.     glEnd();
  308. }
  309.  
  310. static void TriangleStrip(void)
  311. {
  312.  
  313.     glBegin(GL_TRIANGLE_STRIP);
  314.     TK_SETCOLOR(windType, TK_GREEN);
  315.     glVertex2i(-boxW/4, -boxH/4);
  316.     TK_SETCOLOR(windType, TK_RED);
  317.     glVertex2i(-boxW/4, boxH/4);
  318.     TK_SETCOLOR(windType, TK_BLUE);
  319.     glVertex2i(0, -boxH/4);
  320.     TK_SETCOLOR(windType, TK_WHITE);
  321.     glVertex2i(0, boxH/4);
  322.     TK_SETCOLOR(windType, TK_CYAN);
  323.     glVertex2i(boxW/4, -boxH/4);
  324.     TK_SETCOLOR(windType, TK_YELLOW);
  325.     glVertex2i(boxW/4, boxH/4);
  326.     glEnd();
  327.  
  328.     glBegin(GL_TRIANGLE_STRIP);
  329.     glVertex2i(0, 0);
  330.     glVertex2i(-100, 100);
  331.     glEnd();
  332. }
  333.  
  334. static void TriangleFan(void)
  335. {
  336.     GLint vx[8][2];
  337.     GLint x0, y0, x1, y1, x2, y2, x3, y3;
  338.     GLint i;
  339.  
  340.     y0 = -boxH/4;
  341.     y1 = y0 + boxH/2/3;
  342.     y2 = y1 + boxH/2/3;
  343.     y3 = boxH/4;
  344.     x0 = -boxW/4;
  345.     x1 = x0 + boxW/2/3;
  346.     x2 = x1 + boxW/2/3;
  347.     x3 = boxW/4;
  348.  
  349.     vx[0][0] = x0; vx[0][1] = y1;
  350.     vx[1][0] = x0; vx[1][1] = y2;
  351.     vx[2][0] = x1; vx[2][1] = y3;
  352.     vx[3][0] = x2; vx[3][1] = y3;
  353.     vx[4][0] = x3; vx[4][1] = y2;
  354.     vx[5][0] = x3; vx[5][1] = y1;
  355.     vx[6][0] = x2; vx[6][1] = y0;
  356.     vx[7][0] = x1; vx[7][1] = y0;
  357.  
  358.     glBegin(GL_TRIANGLE_FAN);
  359.     TK_SETCOLOR(windType, TK_WHITE);
  360.     glVertex2i(0, 0);
  361.     for (i = 0; i < 8; i++) {
  362.         TK_SETCOLOR(windType, TK_WHITE-i);
  363.         glVertex2iv(vx[i]);
  364.     }
  365.     glEnd();
  366.  
  367.     glBegin(GL_TRIANGLE_FAN);
  368.     glVertex2i(0, 0);
  369.     glVertex2i(-100, 100);
  370.     glEnd();
  371. }
  372.  
  373. static void Rect(void)
  374. {
  375.  
  376.     TK_SETCOLOR(windType, TK_GREEN);
  377.     glRecti(-boxW/4, -boxH/4, boxW/4, boxH/4);
  378. }
  379.  
  380. static void Polygon(void)
  381. {
  382.     GLint vx[8][2];
  383.     GLint x0, y0, x1, y1, x2, y2, x3, y3;
  384.     GLint i;
  385.  
  386.     y0 = -boxH/4;
  387.     y1 = y0 + boxH/2/3;
  388.     y2 = y1 + boxH/2/3;
  389.     y3 = boxH/4;
  390.     x0 = -boxW/4;
  391.     x1 = x0 + boxW/2/3;
  392.     x2 = x1 + boxW/2/3;
  393.     x3 = boxW/4;
  394.  
  395.     vx[0][0] = x0; vx[0][1] = y1;
  396.     vx[1][0] = x0; vx[1][1] = y2;
  397.     vx[2][0] = x1; vx[2][1] = y3;
  398.     vx[3][0] = x2; vx[3][1] = y3;
  399.     vx[4][0] = x3; vx[4][1] = y2;
  400.     vx[5][0] = x3; vx[5][1] = y1;
  401.     vx[6][0] = x2; vx[6][1] = y0;
  402.     vx[7][0] = x1; vx[7][1] = y0;
  403.  
  404.     glBegin(GL_POLYGON);
  405.     for (i = 0; i < 8; i++) {
  406.         TK_SETCOLOR(windType, TK_WHITE-i);
  407.         glVertex2iv(vx[i]);
  408.     }
  409.     glEnd();
  410.  
  411.     glBegin(GL_POLYGON);
  412.     glVertex2i(0, 0);
  413.     glVertex2i(100, 100);
  414.     glEnd();
  415. }
  416.  
  417. static void Quads(void)
  418. {
  419.  
  420.     glBegin(GL_QUADS);
  421.     TK_SETCOLOR(windType, TK_GREEN);
  422.     glVertex2i(-boxW/4, -boxH/4);
  423.     TK_SETCOLOR(windType, TK_RED);
  424.     glVertex2i(-boxW/8, -boxH/16);
  425.     TK_SETCOLOR(windType, TK_BLUE);
  426.     glVertex2i(boxW/8, -boxH/16);
  427.     TK_SETCOLOR(windType, TK_WHITE);
  428.     glVertex2i(boxW/4, -boxH/4);
  429.  
  430.     TK_SETCOLOR(windType, TK_GREEN);
  431.     glVertex2i(-boxW/4, boxH/4);
  432.     TK_SETCOLOR(windType, TK_RED);
  433.     glVertex2i(-boxW/8, boxH/16);
  434.     TK_SETCOLOR(windType, TK_BLUE);
  435.     glVertex2i(boxW/8, boxH/16);
  436.     TK_SETCOLOR(windType, TK_WHITE);
  437.     glVertex2i(boxW/4, boxH/4);
  438.     glEnd();
  439.  
  440.     glBegin(GL_QUADS);
  441.     glVertex2i(0, 0);
  442.     glVertex2i(100, 100);
  443.     glVertex2i(-100, 100);
  444.     glEnd();
  445. }
  446.  
  447. static void QuadStrip(void)
  448. {
  449.  
  450.     glBegin(GL_QUAD_STRIP);
  451.     TK_SETCOLOR(windType, TK_GREEN);
  452.     glVertex2i(-boxW/4, -boxH/4);
  453.     TK_SETCOLOR(windType, TK_RED);
  454.     glVertex2i(-boxW/4, boxH/4);
  455.     TK_SETCOLOR(windType, TK_BLUE);
  456.     glVertex2i(0, -boxH/4);
  457.     TK_SETCOLOR(windType, TK_WHITE);
  458.     glVertex2i(0, boxH/4);
  459.     TK_SETCOLOR(windType, TK_CYAN);
  460.     glVertex2i(boxW/4, -boxH/4);
  461.     TK_SETCOLOR(windType, TK_YELLOW);
  462.     glVertex2i(boxW/4, boxH/4);
  463.     glEnd();
  464.  
  465.     glBegin(GL_QUAD_STRIP);
  466.     glVertex2i(0, 0);
  467.     glVertex2i(100, 100);
  468.     glVertex2i(-100, 100);
  469.     glEnd();
  470. }
  471.  
  472. static void Draw(void)
  473. {
  474.  
  475.     glViewport(0, 0, windW, windH);
  476.     glDisable(GL_SCISSOR_TEST);
  477.  
  478.     glPushAttrib(GL_COLOR_BUFFER_BIT);
  479.  
  480.     glColorMask(1, 1, 1, 1);
  481.     glIndexMask(~0);
  482.  
  483.     glClearColor(0.0, 0.0, 0.0, 1.0);
  484.     glClearIndex(0xff);
  485.     glClear(GL_COLOR_BUFFER_BIT);
  486.  
  487.     glPopAttrib();
  488.     glClearColor(0.68, 0.68, 0.68, 1.0);
  489.     glClearIndex(0xaf);
  490.     glClear(GL_COLOR_BUFFER_BIT);
  491.  
  492.     if (mode1) {
  493.     glShadeModel(GL_SMOOTH);
  494.     } else {
  495.     glShadeModel(GL_FLAT);
  496.     }
  497.  
  498.     if (mode2) {
  499.     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  500.     } else {
  501.     glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  502.     }
  503.  
  504.     Viewport(0, 0); Point();
  505.     Viewport(0, 1); Lines();
  506.     Viewport(0, 2); LineStrip();
  507.     Viewport(0, 3); LineLoop();
  508.  
  509.     Viewport(1, 0); Bitmap();
  510.  
  511.     Viewport(1, 1); TriangleFan();
  512.     Viewport(1, 2); Triangles();
  513.     Viewport(1, 3); TriangleStrip();
  514.  
  515.     Viewport(2, 0); Rect();
  516.     Viewport(2, 1); Polygon();
  517.     Viewport(2, 2); Quads();
  518.     Viewport(2, 3); QuadStrip();
  519.  
  520.     glFlush();
  521.  
  522.     if (doubleBuffer) {
  523.     tkSwapBuffers();
  524.     }
  525. }
  526.  
  527. static GLenum Args(int argc, char **argv)
  528. {
  529.     GLint i;
  530.  
  531.     rgb = GL_TRUE;
  532.     doubleBuffer = GL_FALSE;
  533.     directRender = GL_TRUE;
  534.  
  535.     for (i = 1; i < argc; i++) {
  536.     if (strcmp(argv[i], "-ci") == 0) {
  537.         rgb = GL_FALSE;
  538.     } else if (strcmp(argv[i], "-rgb") == 0) {
  539.         rgb = GL_TRUE;
  540.     } else if (strcmp(argv[i], "-sb") == 0) {
  541.         doubleBuffer = GL_FALSE;
  542.     } else if (strcmp(argv[i], "-db") == 0) {
  543.         doubleBuffer = GL_TRUE;
  544.     } else if (strcmp(argv[i], "-dr") == 0) {
  545.         directRender = GL_TRUE;
  546.     } else if (strcmp(argv[i], "-ir") == 0) {
  547.         directRender = GL_FALSE;
  548.     } else {
  549.         printf("%s (Bad option).\n", argv[i]);
  550.         return GL_FALSE;
  551.     }
  552.     }
  553.     return GL_TRUE;
  554. }
  555.  
  556. void main(int argc, char **argv)
  557. {
  558.  
  559.     if (Args(argc, argv) == GL_FALSE) {
  560.     tkQuit();
  561.     }
  562.  
  563.     windW = 600;
  564.     windH = 300;
  565.     tkInitPosition(0, 0, windW, windH);
  566.  
  567.     windType = (rgb) ? TK_RGB : TK_INDEX;
  568.     windType |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  569.     windType |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  570.     tkInitDisplayMode(windType);
  571.  
  572.     if (tkInitWindow("Primitive Test") == GL_FALSE) {
  573.     tkQuit();
  574.     }
  575.  
  576.     Init();
  577.  
  578.     tkExposeFunc(Reshape);
  579.     tkReshapeFunc(Reshape);
  580.     tkKeyDownFunc(Key);
  581.     tkDisplayFunc(Draw);
  582.     tkExec();
  583. }
  584.