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