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