home *** CD-ROM | disk | FTP | other *** search
/ Amiga Magazin: Amiga-CD 2000 April & May / AMIGA_2000_04.iso / patches / mesa3.1 / test / glut / test17.c < prev    next >
C/C++ Source or Header  |  1998-10-23  |  7KB  |  290 lines
  1.  
  2. /* Copyright (c) Mark J. Kilgard, 1996. */
  3.  
  4. /* This program is freely distributable without licensing fees 
  5.    and is provided without guarantee or warrantee expressed or 
  6.    implied. This program is -not- in the public domain. */
  7.  
  8. /* Test for GLUT 3.0's overlay functionality. */
  9.  
  10. #include <stdlib.h>
  11. #include <stdio.h>
  12. #include <GL/glut.h>
  13.  
  14. static int transP;
  15. static int main_win;
  16. static float x = 0, y = 0;
  17.  
  18. static void
  19. render_normal(void)
  20. {
  21.   glutUseLayer(GLUT_NORMAL);
  22.   glClear(GL_COLOR_BUFFER_BIT);
  23.   glColor3f(0.0, 0.0, 1.0);
  24.   glBegin(GL_POLYGON);
  25.   glVertex2f(.2, .28);
  26.   glVertex2f(.5, .58);
  27.   glVertex2f(.2, .58);
  28.   glEnd();
  29.   glFlush();
  30. }
  31.  
  32. static void
  33. render_overlay(void)
  34. {
  35.   glClear(GL_COLOR_BUFFER_BIT);
  36.   glBegin(GL_POLYGON);
  37.   glVertex2f(.2 + x, .2 + y);
  38.   glVertex2f(.5 + x, .5 + y);
  39.   glVertex2f(.2 + x, .5 + y);
  40.   glEnd();
  41.   glFlush();
  42. }
  43.  
  44. static void
  45. render(void)
  46. {
  47.   glutUseLayer(GLUT_NORMAL);
  48.   render_normal();
  49.   if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  50.     glutUseLayer(GLUT_OVERLAY);
  51.     render_overlay();
  52.   }
  53. }
  54.  
  55. static void
  56. render_sub(void)
  57. {
  58.   printf("render_sub\n");
  59.   glutUseLayer(GLUT_NORMAL);
  60.   render_normal();
  61.   if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  62.     glutUseLayer(GLUT_OVERLAY);
  63.     render_overlay();
  64.   }
  65. }
  66.  
  67. static int display_count = 0;
  68. static int damage_expectation;
  69.  
  70. static void
  71. timer(int value)
  72. {
  73.   if (value != 777) {
  74.     printf("FAIL: unexpected timer value\n");
  75.     exit(1);
  76.   }
  77.   damage_expectation = 1;
  78.   glutShowWindow();
  79. }
  80.  
  81. static void
  82. time2(int value)
  83. {
  84.   if (value == 666) {
  85.     printf("PASS: test17\n");
  86.     exit(0);
  87.   }
  88.   if (value != 888) {
  89.     printf("FAIL: bad value\n");
  90.     exit(1);
  91.   }
  92.   glutDestroyWindow(main_win);
  93.   glutTimerFunc(500, time2, 666);
  94. }
  95.  
  96. static void
  97. move_on(void)
  98. {
  99.   display_count++;
  100.   if (display_count == 2) {
  101.     damage_expectation = 1;
  102.     glutIconifyWindow();
  103.     glutTimerFunc(500, timer, 777);
  104.   }
  105.   if (display_count == 4) {
  106.     printf("display_count == 4\n");
  107.     glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  108.     glutCreateSubWindow(main_win, 10, 10, 150, 150);
  109.     glClearColor(0.5, 0.5, 0.5, 0.0);
  110.     glutDisplayFunc(render_sub);
  111.     glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
  112.     glutEstablishOverlay();
  113.     glutCopyColormap(main_win);
  114.     glutSetColor((transP + 1) % 2, 0.0, 1.0, 1.0);
  115.     glutRemoveOverlay();
  116.     glutEstablishOverlay();
  117.     glutCopyColormap(main_win);
  118.     glutCopyColormap(main_win);
  119.     glutSetColor((transP + 1) % 2, 1.0, 1.0, 1.0);
  120.     glClearIndex(transP);
  121.     glIndexf((transP + 1) % 2);
  122.     glutSetWindow(main_win);
  123.     glutRemoveOverlay();
  124.     glutTimerFunc(500, time2, 888);
  125.   }
  126. }
  127.  
  128. static void
  129. display_normal(void)
  130. {
  131.   if (glutLayerGet(GLUT_NORMAL_DAMAGED) != damage_expectation) {
  132.     printf("FAIL: normal damage not expected\n");
  133.     exit(1);
  134.   }
  135.   render_normal();
  136.   move_on();
  137. }
  138.  
  139. static void
  140. display_overlay(void)
  141. {
  142.   if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != damage_expectation) {
  143.     printf("FAIL: overlay damage not expected\n");
  144.     exit(1);
  145.   }
  146.   render_overlay();
  147.   move_on();
  148. }
  149.  
  150. static void
  151. display2(void)
  152. {
  153.   static int been_here = 0;
  154.  
  155.   if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) {
  156.     printf("FAIL: normal damage not expected\n");
  157.     exit(1);
  158.   }
  159.   if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != 0) {
  160.     printf("FAIL: overlay damage not expected\n");
  161.     exit(1);
  162.   }
  163.   if (been_here) {
  164.     glutPostOverlayRedisplay();
  165.   } else {
  166.     glutOverlayDisplayFunc(display_overlay);
  167.     glutDisplayFunc(display_normal);
  168.     damage_expectation = 0;
  169.     glutPostOverlayRedisplay();
  170.     glutPostRedisplay();
  171.   }
  172. }
  173.  
  174. static void
  175. display(void)
  176. {
  177.   if (glutLayerGet(GLUT_NORMAL_DAMAGED) == 0) {
  178.     printf("FAIL: normal damage expected\n");
  179.     exit(1);
  180.   }
  181.   if (glutLayerGet(GLUT_OVERLAY_DAMAGED) == 0) {
  182.     printf("FAIL: overlay damage expected\n");
  183.     exit(1);
  184.   }
  185.   render();
  186.  
  187.   glutDisplayFunc(display2);
  188.   glutPostRedisplay();
  189. }
  190.  
  191. int
  192. main(int argc, char **argv)
  193. {
  194.   glutInit(&argc, argv);
  195.   glutInitWindowSize(300, 300);
  196.   glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
  197.  
  198.   if (!glutLayerGet(GLUT_OVERLAY_POSSIBLE)) {
  199.     printf("UNRESOLVED: need overlays for this test (your window system lacks overlays)\n");
  200.     exit(0);
  201.   }
  202.   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  203.   main_win = glutCreateWindow("test17");
  204.  
  205.   if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_OVERLAY) {
  206.     printf("FAIL: overlay should not be in use\n");
  207.     exit(1);
  208.   }
  209.   if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  210.     printf("FAIL: overlay should not exist\n");
  211.     exit(1);
  212.   }
  213.   if (glutLayerGet(GLUT_TRANSPARENT_INDEX) != -1) {
  214.     printf("FAIL: transparent pixel of normal plane should be -1\n");
  215.     exit(1);
  216.   }
  217.   if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) {
  218.     printf("FAIL: no normal damage yet\n");
  219.     exit(1);
  220.   }
  221.   if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != -1) {
  222.     printf("FAIL: no overlay damage status yet\n");
  223.     exit(1);
  224.   }
  225.   glClearColor(0.0, 1.0, 0.0, 0.0);
  226.  
  227.   glutInitDisplayMode(GLUT_SINGLE | GLUT_INDEX);
  228.  
  229.   /* Small torture test. */
  230.   glutEstablishOverlay();
  231.   glutRemoveOverlay();
  232.   glutEstablishOverlay();
  233.   glutEstablishOverlay();
  234.   glutShowOverlay();
  235.   glutHideOverlay();
  236.   glutShowOverlay();
  237.   glutRemoveOverlay();
  238.   glutRemoveOverlay();
  239.   glutEstablishOverlay();
  240.  
  241.   if (glutGet(GLUT_WINDOW_RGBA)) {
  242.     printf("FAIL: overlay should not be RGBA\n");
  243.     exit(1);
  244.   }
  245.   glutUseLayer(GLUT_NORMAL);
  246.   if (!glutGet(GLUT_WINDOW_RGBA)) {
  247.     printf("FAIL: normal should be RGBA\n");
  248.     exit(1);
  249.   }
  250.   glutUseLayer(GLUT_OVERLAY);
  251.   if (glutGet(GLUT_WINDOW_RGBA)) {
  252.     printf("FAIL: overlay should not be RGBA\n");
  253.     exit(1);
  254.   }
  255.   if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_NORMAL) {
  256.     printf("FAIL: overlay should be in use\n");
  257.     exit(1);
  258.   }
  259.   if (glutLayerGet(GLUT_HAS_OVERLAY) == 0) {
  260.     printf("FAIL: overlay should exist\n");
  261.     exit(1);
  262.   }
  263.   if (glutLayerGet(GLUT_TRANSPARENT_INDEX) == -1) {
  264.     printf("FAIL: transparent pixel should exist\n");
  265.     exit(1);
  266.   }
  267.   if (glutLayerGet(GLUT_NORMAL_DAMAGED) != 0) {
  268.     printf("FAIL: no normal damage yet\n");
  269.     exit(1);
  270.   }
  271.   if (glutLayerGet(GLUT_OVERLAY_DAMAGED) != 0) {
  272.     printf("FAIL: no overlay damage yet\n");
  273.     exit(1);
  274.   }
  275.   transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  276.   glClearIndex(glutLayerGet(GLUT_TRANSPARENT_INDEX));
  277.   glutSetColor((transP + 1) % 2, 1.0, 0.0, 1.0);
  278.   glIndexi((transP + 1) % 2);
  279.  
  280.   glutUseLayer(GLUT_NORMAL);
  281.   if (glutLayerGet(GLUT_LAYER_IN_USE) == GLUT_OVERLAY) {
  282.     printf("FAIL: overlay should not be in use\n");
  283.     exit(1);
  284.   }
  285.   glutDisplayFunc(display);
  286.  
  287.   glutMainLoop();
  288.   return 0;             /* ANSI C requires main to return int. */
  289. }
  290.