home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / mesa / src-glut / win32_glx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-31  |  8.0 KB  |  305 lines

  1.  
  2. /* Copyright (c) Nate Robins, 1997. */
  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.  
  9. #include <stdio.h>
  10. #include "win32_glx.h"
  11.  
  12. /* global current HDC */
  13. extern HDC XHDC;
  14.  
  15. void
  16. glXDestroyContext(Display* display, GLXContext context)
  17. {
  18.   /* nothing magic about this */
  19.   wglDeleteContext(context);
  20. }
  21.  
  22. GLXContext
  23. glXCreateContext(Display* display, XVisualInfo* visinfo,
  24.          GLXContext share, Bool direct)
  25. {
  26.   /* KLUDGE: GLX really expects a display pointer to be passed in as
  27.      the first parameter, but Win32 needs an HDC instead, so BE SURE
  28.      that the global XHDC is set before calling this routine. */
  29.  
  30.   HGLRC context;
  31.  
  32. //   printf("glXCreateContext(0x%x, 0x%x, 0x%x, %d)\n", display, visinfo, 
  33. //      share, direct);
  34. //   printf("context = 0x%x, XHDC = 0x%x\n", context, XHDC);
  35.  
  36.   context = wglCreateContext(XHDC);
  37.  
  38.  
  39.   if (share)
  40.     wglShareLists(share, context);
  41.  
  42.   /* since direct rendering is implicit, the direct flag is
  43.      ignored. */
  44.  
  45.   return context;
  46. }
  47.  
  48. Bool
  49. glXIsDirect(Display* display, GLXContext context)
  50. {
  51.   /* Win32 is ALWAYS direct rendering.  There is no notion of indirect
  52.      rendering in Win32, therefore always return True. */
  53.   return True;
  54. }
  55.  
  56. void
  57. glXSwapBuffers(Display* display, Window window)
  58. {
  59.   /* not too much magic here - it is another function call layer,
  60.      though...eliminating it would be faster. */
  61.   //  printf("glXSwapBuffers(0x%x, 0x%x)\n", display, window);
  62.  
  63.   SwapBuffers(GetDC(window));
  64. }
  65.  
  66. Bool
  67. glXMakeCurrent(Display* display, Window window, GLXContext context)
  68. {
  69.   //  printf("glXMakeCurrent(0x%x, 0x%x, 0x%x)\n", display, window, context);
  70.   return wglMakeCurrent(GetDC(window), context);
  71. }
  72.  
  73. int
  74. glXGetConfig(Display* display, XVisualInfo* visual, int attrib, int* value)
  75. {
  76.   if (!visual)
  77.     return GLX_BAD_VISUAL;
  78.  
  79.   switch (attrib) {
  80.   case GLX_USE_GL:
  81.     *value = visual->dwFlags & PFD_SUPPORT_OPENGL;
  82.     break;
  83.   case GLX_BUFFER_SIZE:
  84.     /* KLUDGE: if we're RGBA, return the number of bits/pixel,
  85.        otherwise, return 8 (we guessed at 256 colors in CI mode). */
  86.     if (visual->iPixelType == PFD_TYPE_RGBA)
  87.       *value = visual->cColorBits;
  88.     else
  89.       *value = 8;
  90.     break;
  91.   case GLX_LEVEL:
  92.     /* the bReserved flag of the pfd contains the overlay/underlay
  93.        info. */
  94.     *value = visual->bReserved;
  95.     break;
  96.   case GLX_RGBA:
  97.     *value = visual->iPixelType == PFD_TYPE_RGBA;
  98.     break;
  99.   case GLX_DOUBLEBUFFER:
  100.     *value = visual->dwFlags & PFD_DOUBLEBUFFER;
  101.     break;
  102.   case GLX_STEREO:
  103.     *value = visual->dwFlags & PFD_STEREO;
  104.     break;
  105.   case GLX_AUX_BUFFERS:
  106.     *value = visual->cAuxBuffers;
  107.     break;
  108.   case GLX_RED_SIZE:
  109.     *value = visual->cRedBits;
  110.     break;
  111.   case GLX_GREEN_SIZE:
  112.     *value = visual->cGreenBits;
  113.     break;
  114.   case GLX_BLUE_SIZE:
  115.     *value = visual->cBlueBits;
  116.     break;
  117.   case GLX_ALPHA_SIZE:
  118.     *value = visual->cAlphaBits;
  119.     break;
  120.   case GLX_DEPTH_SIZE:
  121.     *value = visual->cDepthBits;
  122.     break;
  123.   case GLX_STENCIL_SIZE:
  124.     *value = visual->cStencilBits;
  125.     break;
  126.   case GLX_ACCUM_RED_SIZE:
  127.     *value = visual->cAccumRedBits;
  128.     break;
  129.   case GLX_ACCUM_GREEN_SIZE:
  130.     *value = visual->cAccumGreenBits;
  131.     break;
  132.   case GLX_ACCUM_BLUE_SIZE:
  133.     *value = visual->cAccumBlueBits;
  134.     break;
  135.   case GLX_ACCUM_ALPHA_SIZE:
  136.     *value = visual->cAccumAlphaBits;
  137.     break;
  138.   default:
  139.     return GLX_BAD_ATTRIB;
  140.   }
  141.  
  142.   return 0;
  143. }
  144.  
  145. XVisualInfo*
  146. glXChooseVisual(Display* display, int screen, int* attribList)
  147. {
  148.   /* KLUDGE: since we need the HDC, MAKE SURE to set XHDC before
  149.      calling this routine. */
  150.  
  151.   int* p = attribList;
  152.   int pf;
  153.   PIXELFORMATDESCRIPTOR pfd;
  154.   PIXELFORMATDESCRIPTOR* match = NULL;
  155.   int stereo = 0;
  156.  
  157.   /* avoid seg-faults */
  158.   if (!p)
  159.     return NULL;
  160.  
  161.   memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
  162.   pfd.nSize = (sizeof(PIXELFORMATDESCRIPTOR));
  163.   pfd.nVersion = 1;
  164.  
  165.   /* defaults */
  166.   pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
  167.   pfd.iPixelType = PFD_TYPE_COLORINDEX;
  168.   pfd.cColorBits = 32;
  169.   pfd.cDepthBits = 1;
  170.  
  171.   while(*p) {
  172.     switch(*p) {
  173.     case GLX_USE_GL:
  174.       pfd.dwFlags |= PFD_SUPPORT_OPENGL;
  175.       break;
  176.     case GLX_BUFFER_SIZE:
  177.       pfd.cColorBits = *(++p);
  178.       break;
  179.     case GLX_LEVEL:
  180.       /* the bReserved flag of the pfd contains the overlay/underlay
  181.      info. */
  182.       pfd.bReserved = *(++p);
  183.       break;
  184.     case GLX_RGBA:
  185.       pfd.iPixelType = PFD_TYPE_RGBA;
  186.       break;
  187.     case GLX_DOUBLEBUFFER:
  188.       pfd.dwFlags |= PFD_DOUBLEBUFFER;
  189.       break;
  190.     case GLX_STEREO:
  191.       stereo = 1;
  192.       pfd.dwFlags |= PFD_STEREO;
  193.       break;
  194.     case GLX_AUX_BUFFERS:
  195.       pfd.cAuxBuffers = *(++p);
  196.       break;
  197.     case GLX_RED_SIZE:
  198.       pfd.cRedBits = 8;            /* try to get the maximum */
  199.       ++p;
  200.       break;
  201.     case GLX_GREEN_SIZE:
  202.       pfd.cGreenBits = 8;
  203.       ++p;
  204.       break;
  205.     case GLX_BLUE_SIZE:
  206.       pfd.cBlueBits = 8;
  207.       ++p;
  208.       break;
  209.     case GLX_ALPHA_SIZE:
  210.       pfd.cAlphaBits = 8;
  211.       ++p;
  212.       break;
  213.     case GLX_DEPTH_SIZE:
  214.       pfd.cDepthBits = 32;
  215.       ++p;
  216.       break;
  217.     case GLX_STENCIL_SIZE:
  218.       pfd.cStencilBits = *(++p);
  219.       break;
  220.     case GLX_ACCUM_RED_SIZE:
  221.       pfd.cAccumRedBits = *(++p);
  222.       break;
  223.     case GLX_ACCUM_GREEN_SIZE:
  224.       pfd.cAccumGreenBits = *(++p);
  225.       break;
  226.     case GLX_ACCUM_BLUE_SIZE:
  227.       pfd.cAccumBlueBits = *(++p);
  228.       break;
  229.     case GLX_ACCUM_ALPHA_SIZE:
  230.       pfd.cAccumAlphaBits = *(++p);
  231.       break;
  232.     }
  233.     ++p;
  234.   }
  235.  
  236. //   printf("wanted:\n");
  237. //   glXPrintPixelFormat(0, &pfd);
  238. //   printf("got:\n");
  239.  
  240.   /* let Win32 choose one for us */
  241.   pf = ChoosePixelFormat(XHDC, &pfd);
  242.   if (pf > 0) {
  243.     match = (PIXELFORMATDESCRIPTOR*)malloc(sizeof(PIXELFORMATDESCRIPTOR));
  244.     DescribePixelFormat(XHDC, pf, sizeof(PIXELFORMATDESCRIPTOR), match);
  245. //     glXPrintPixelFormat(pf, match);
  246.  
  247.     /* ChoosePixelFormat is dumb in that it will return a pixel format
  248.        that doesn't have stereo even if it was requested...so we need
  249.        to make sure that if stereo was selected, we got it. */
  250.     if (stereo) {
  251.       if (!(match->dwFlags & PFD_STEREO)) {
  252.     free(match);
  253.     match = NULL;
  254.       }
  255.     }
  256.   }
  257.  
  258.   return match;
  259. }
  260.  
  261. void
  262. glXPrintPixelFormat(int pf, PIXELFORMATDESCRIPTOR* pfd)
  263. {
  264.   printf("   visual  x  bf lv rg d st  r  g  b a  ax dp st accum buffs  ms \n");
  265.   printf(" id dep cl sp sz l  ci b ro sz sz sz sz bf th cl  r  g  b  a ns b\n");
  266.   printf("-----------------------------------------------------------------\n");
  267.  
  268.   printf("0x%02x ", pf);
  269.   printf("%2d ", pfd->cColorBits);
  270.   if(pfd->dwFlags & PFD_DRAW_TO_WINDOW)      printf("wn ");
  271.   else if(pfd->dwFlags & PFD_DRAW_TO_BITMAP) printf("bm ");
  272.   else printf(".  ");
  273.   printf(" . "); // x sp = transparent ???
  274.   printf("%2d ", pfd->cColorBits);
  275.   //    if(pfd->iLayerType) printf(" %d ", pfd->iLayerType);  // bReserved --v
  276.   if(pfd->bReserved) printf(" %d ", pfd->bReserved);
  277.   else printf(" . "); 
  278.   printf(" %c ", pfd->iPixelType == PFD_TYPE_RGBA ? 'r' : 'c');
  279.   printf("%c ", pfd->dwFlags & PFD_DOUBLEBUFFER ? 'y' : '.');
  280.   printf(" %c ", pfd->dwFlags & PFD_STEREO ? 'y' : '.');
  281.   if(pfd->cRedBits)        printf("%2d ", pfd->cRedBits);
  282.   else printf(" . ");
  283.   if(pfd->cGreenBits)      printf("%2d ", pfd->cGreenBits);
  284.   else printf(" . ");
  285.   if(pfd->cBlueBits)       printf("%2d ", pfd->cBlueBits);
  286.   else printf(" . ");
  287.   if(pfd->cAlphaBits)      printf("%2d ", pfd->cAlphaBits);
  288.   else printf(" . ");
  289.   if(pfd->cAuxBuffers)     printf("%2d ", pfd->cAuxBuffers);
  290.   else printf(" . ");
  291.   if(pfd->cDepthBits)      printf("%2d ", pfd->cDepthBits);
  292.   else printf(" . ");
  293.   if(pfd->cStencilBits)    printf("%2d ", pfd->cStencilBits);
  294.   else printf(" . ");
  295.   if(pfd->cAccumRedBits)   printf("%2d ", pfd->cAccumRedBits);
  296.   else printf(" . ");
  297.   if(pfd->cAccumGreenBits) printf("%2d ", pfd->cAccumGreenBits);
  298.   else printf(" . ");
  299.   if(pfd->cAccumBlueBits)  printf("%2d ", pfd->cAccumBlueBits);
  300.   else printf(" . ");
  301.   if(pfd->cAccumAlphaBits) printf("%2d ", pfd->cAccumAlphaBits);
  302.   else printf(" . ");
  303.   printf(" . .\n");  // multisample stuff
  304. }
  305.