home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / sviluppo / mesa-glut / test / glut / over_test.c < prev    next >
C/C++ Source or Header  |  1998-10-23  |  8KB  |  389 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. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <GL/glut.h>
  11.  
  12. int on = 0;
  13. int independent = 0;
  14. int main_w, hidden_w, s1, s2;
  15. float x = 0, y = 0;
  16.  
  17. void
  18. overlay_display(void)
  19. {
  20.   printf("overlay_display: damaged=%d\n", glutLayerGet(GLUT_OVERLAY_DAMAGED));
  21.   if (on) {
  22.     glutUseLayer(GLUT_OVERLAY);
  23.     glClear(GL_COLOR_BUFFER_BIT);
  24.     glBegin(GL_POLYGON);
  25.     glVertex2f(.2 + x, .2 + y);
  26.     glVertex2f(.5 + x, .5 + y);
  27.     glVertex2f(.2 + x, .5 + y);
  28.     glEnd();
  29.     glFlush();
  30.   }
  31. }
  32.  
  33. void
  34. display(void)
  35. {
  36.   printf("normal_display: damaged=%d\n", glutLayerGet(GLUT_NORMAL_DAMAGED));
  37.   glutUseLayer(GLUT_NORMAL);
  38.   glClear(GL_COLOR_BUFFER_BIT);
  39.   glColor3f(1.0, 0.0, 0.0);
  40.   glBegin(GL_POLYGON);
  41.   glVertex2f(.2, .28);
  42.   glVertex2f(.5, .58);
  43.   glVertex2f(.2, .58);
  44.   glEnd();
  45.  
  46.   if (!independent) {
  47.     overlay_display();
  48.   } else {
  49.     printf("not calling overlay_display\n");
  50.   }
  51. }
  52.  
  53. void
  54. hidden_display(void)
  55. {
  56.   printf("hidden_display: this should not be called ever\n");
  57. }
  58.  
  59. void
  60. reshape(int w, int h)
  61. {
  62.   glutUseLayer(GLUT_NORMAL);
  63.   glViewport(0, 0, w, h);
  64.  
  65.   if (on) {
  66.     glutUseLayer(GLUT_OVERLAY);
  67.     glViewport(0, 0, w, h);
  68.     printf("w=%d, h=%d\n", w, h);
  69.   }
  70. }
  71.  
  72. void
  73. special(int c, int w, int h)
  74. {
  75.   printf("special %d  w=%d h=%d\n", c, w, h);
  76.   if (on) {
  77.     switch (c) {
  78.     case GLUT_KEY_LEFT:
  79.       x -= 0.1;
  80.       break;
  81.     case GLUT_KEY_RIGHT:
  82.       x += 0.1;
  83.       break;
  84.     case GLUT_KEY_UP:
  85.       y += 0.1;
  86.       break;
  87.     case GLUT_KEY_DOWN:
  88.       y -= 0.1;
  89.       break;
  90.     }
  91.     glutPostOverlayRedisplay();
  92.   }
  93. }
  94.  
  95. void
  96. key(unsigned char c, int w, int h)
  97. {
  98.   int transP;
  99.  
  100.   printf("c=%d  w=%d h=%d\n", c, w, h);
  101.   switch (c) {
  102.   case 'e':
  103.     glutEstablishOverlay();
  104.     independent = 0;
  105.     transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  106.     glClearIndex(transP);
  107.     glutSetColor((transP + 1) % 2, 1.0, 1.0, 0.0);
  108.     glIndexi((transP + 1) % 2);
  109.     on = 1;
  110.     break;
  111.   case 'r':
  112.     glutRemoveOverlay();
  113.     on = 0;
  114.     break;
  115.   case 'm':
  116.     if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  117.       int pixel;
  118.       GLfloat red, green, blue;
  119.  
  120.       transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  121.       pixel = (transP + 1) % 2;
  122.       red = glutGetColor(pixel, GLUT_RED) + 0.2;
  123.       if (red > 1.0)
  124.         red = red - 1.0;
  125.       green = glutGetColor(pixel, GLUT_GREEN) - 0.1;
  126.       if (green > 1.0)
  127.         green = green - 1.0;
  128.       blue = glutGetColor(pixel, GLUT_BLUE) + 0.1;
  129.       if (blue > 1.0)
  130.         blue = blue - 1.0;
  131.       glutSetColor(pixel, red, green, blue);
  132.     }
  133.     break;
  134.   case 'h':
  135.     glutSetWindow(hidden_w);
  136.     glutHideWindow();
  137.     glutSetWindow(s2);
  138.     glutHideWindow();
  139.     break;
  140.   case 's':
  141.     glutSetWindow(hidden_w);
  142.     glutShowWindow();
  143.     glutSetWindow(s2);
  144.     glutShowWindow();
  145.     break;
  146.   case 'H':
  147.     glutHideOverlay();
  148.     break;
  149.   case 'S':
  150.     glutShowOverlay();
  151.     break;
  152.   case 'D':
  153.     glutDestroyWindow(main_w);
  154.     exit(0);
  155.     break;
  156.   case ' ':
  157.     printf("overlay possible: %d\n", glutLayerGet(GLUT_OVERLAY_POSSIBLE));
  158.     printf("layer in  use: %d\n", glutLayerGet(GLUT_LAYER_IN_USE));
  159.     printf("has overlay: %d\n", glutLayerGet(GLUT_HAS_OVERLAY));
  160.     printf("transparent index: %d\n", glutLayerGet(GLUT_TRANSPARENT_INDEX));
  161.     break;
  162.   }
  163. }
  164.  
  165. /* ARGSUSED1 */
  166. void
  167. key2(unsigned char c, int w, int h)
  168. {
  169.   int transP;
  170.  
  171.   printf("c=%d\n", c);
  172.   switch (c) {
  173.   case 'g':
  174.     glutReshapeWindow(
  175.       glutGet(GLUT_WINDOW_WIDTH) + 2, glutGet(GLUT_WINDOW_HEIGHT) + 2);
  176.     break;
  177.   case 's':
  178.     glutReshapeWindow(
  179.       glutGet(GLUT_WINDOW_WIDTH) - 2, glutGet(GLUT_WINDOW_HEIGHT) - 2);
  180.     break;
  181.   case 'u':
  182.     glutPopWindow();
  183.     break;
  184.   case 'd':
  185.     glutPushWindow();
  186.     break;
  187.   case 'e':
  188.     glutEstablishOverlay();
  189.     transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  190.     glClearIndex(transP);
  191.     glutSetColor((transP + 1) % 2, 0.0, 0.25, 0.0);
  192.     glIndexi((transP + 1) % 2);
  193.     break;
  194.   case 'c':
  195.     if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  196.       glutUseLayer(GLUT_OVERLAY);
  197.       glutCopyColormap(main_w);
  198.     }
  199.     break;
  200.   case 'r':
  201.     glutRemoveOverlay();
  202.     break;
  203.   case ' ':
  204.     printf("overlay possible: %d\n", glutLayerGet(GLUT_OVERLAY_POSSIBLE));
  205.     printf("layer in  use: %d\n", glutLayerGet(GLUT_LAYER_IN_USE));
  206.     printf("has overlay: %d\n", glutLayerGet(GLUT_HAS_OVERLAY));
  207.     printf("transparent index: %d\n", glutLayerGet(GLUT_TRANSPARENT_INDEX));
  208.     break;
  209.   }
  210. }
  211.  
  212. void
  213. vis(int state)
  214. {
  215.   if (state == GLUT_VISIBLE)
  216.     printf("visible %d\n", glutGetWindow());
  217.   else
  218.     printf("NOT visible %d\n", glutGetWindow());
  219. }
  220.  
  221. void
  222. entry(int state)
  223. {
  224.   if (state == GLUT_LEFT)
  225.     printf("LEFT %d\n", glutGetWindow());
  226.   else
  227.     printf("entered %d\n", glutGetWindow());
  228. }
  229.  
  230. void
  231. motion(int x, int y)
  232. {
  233.   printf("motion x=%x y=%d\n", x, y);
  234. }
  235.  
  236. void
  237. mouse(int b, int s, int x, int y)
  238. {
  239.   printf("b=%d  s=%d  x=%d y=%d\n", b, s, x, y);
  240. }
  241.  
  242. void
  243. display2(void)
  244. {
  245.   glutUseLayer(GLUT_NORMAL);
  246.   glClear(GL_COLOR_BUFFER_BIT);
  247.   glFlush();
  248.  
  249.   if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  250.     glutUseLayer(GLUT_OVERLAY);
  251.     glClear(GL_COLOR_BUFFER_BIT);
  252.     glBegin(GL_POLYGON);
  253.     glVertex2f(.2, .28);
  254.     glVertex2f(.5, .58);
  255.     glVertex2f(.2, .58);
  256.     glEnd();
  257.     glFlush();
  258.   }
  259. }
  260.  
  261. void
  262. dial(int dial, int value)
  263. {
  264.   printf("dial %d %d (%d)\n", dial, value, glutGetWindow());
  265. }
  266.  
  267. void
  268. box(int button, int state)
  269. {
  270.   printf("box %d %d (%d)\n", button, state, glutGetWindow());
  271. }
  272.  
  273. void
  274. main_menu(int option)
  275. {
  276.   switch (option) {
  277.   case 1:
  278.     if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  279.       independent = 1;
  280.       glutOverlayDisplayFunc(overlay_display);
  281.     }
  282.     break;
  283.   case 2:
  284.     if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  285.       independent = 0;
  286.       glutOverlayDisplayFunc(NULL);
  287.     }
  288.     break;
  289.   case 666:
  290.     exit(0);
  291.     break;
  292.   }
  293. }
  294.  
  295. void
  296. s2_menu(int option)
  297. {
  298.   int transP;
  299.  
  300.   switch (option) {
  301.   case 1:
  302.     glutRemoveOverlay();
  303.     break;
  304.   case 2:
  305.     glutEstablishOverlay();
  306.     transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  307.     glClearIndex(transP);
  308.     glutSetColor((transP + 1) % 2, 0.0, 0.25, 0.0);
  309.     glIndexi((transP + 1) % 2);
  310.     break;
  311.   case 666:
  312.     exit(0);
  313.     break;
  314.   }
  315. }
  316.  
  317. int
  318. main(int argc, char **argv)
  319. {
  320.   glutInit(&argc, argv);
  321.  
  322.   glutInitDisplayMode(GLUT_RGB);
  323.   glutInitWindowSize(210, 210);
  324.  
  325.   main_w = glutCreateWindow("overlay test");
  326.   glutDisplayFunc(display);
  327.   glutReshapeFunc(reshape);
  328.   glClearColor(1.0, 0.0, 1.0, 1.0);
  329.  
  330.   glutKeyboardFunc(key);
  331.   glutVisibilityFunc(vis);
  332.   glutEntryFunc(entry);
  333.   glutSpecialFunc(special);
  334.  
  335.   glutMotionFunc(motion);
  336.   glutMouseFunc(mouse);
  337.  
  338.   glutCreateMenu(main_menu);
  339.   glutAddMenuEntry("Dual display callbacks", 1);
  340.   glutAddMenuEntry("Single display callbacks", 2);
  341.   glutAddMenuEntry("Quit", 666);
  342.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  343.  
  344.   hidden_w = glutCreateSubWindow(main_w, 10, 10, 100, 90);
  345.   /* hidden_w is completely obscured by its own s1 subwindow.
  346.      While display, entry and visibility callbacks are 
  347.      registered, they will never be called. */
  348.   glutDisplayFunc(hidden_display);
  349.   glutEntryFunc(entry);
  350.   glutVisibilityFunc(vis);
  351.  
  352.   s1 = glutCreateSubWindow(hidden_w, 0, 0, 100, 90);
  353.   glClearColor(0.0, 0.0, 1.0, 1.0);
  354.   glutDisplayFunc(display2);
  355. #if 0
  356.   glutKeyboardFunc(key2);
  357. #endif
  358.   glutVisibilityFunc(vis);
  359.   glutEntryFunc(entry);
  360.  
  361.   s2 = glutCreateSubWindow(main_w, 35, 35, 100, 90);
  362.   glClearColor(0.5, 0.0, 0.5, 1.0);
  363.   glutDisplayFunc(display2);
  364. #if 1
  365.   glutKeyboardFunc(key2);
  366. #endif
  367.   glutVisibilityFunc(vis);
  368.   glutEntryFunc(entry);
  369.  
  370. #if 1
  371.   glutCreateMenu(s2_menu);
  372.   glutAddMenuEntry("Remove overlay", 1);
  373.   glutAddMenuEntry("Establish overlay", 2);
  374.   glutAddMenuEntry("Quit", 666);
  375.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  376. #endif
  377.  
  378.   glutInitDisplayMode(GLUT_INDEX);
  379.  
  380. #if 1
  381.   glutSetWindow(main_w);
  382.   glutDialsFunc(dial);
  383.   glutButtonBoxFunc(box);
  384. #endif
  385.  
  386.   glutMainLoop();
  387.   return 0;             /* ANSI C requires main to return int. */
  388. }
  389.