开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
win32_glx.c
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：7k
源码类别：

GIS编程

开发平台：

Visual C++

win32_glx.c：源码内容
  2. /* Copyright (c) Nate Robins, 1997. */
  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. */
  8. #include "glutint.h"
  10. /* global current HDC */
  11. extern HDC XHDC;
  13. GLXContext
  14. glXCreateContext(Display * display, XVisualInfo * visinfo,
  15.   GLXContext share, Bool direct)
  16. {
  17.   /* KLUDGE: GLX really expects a display pointer to be passed
  18.      in as the first parameter, but Win32 needs an HDC instead,
  19.      so BE SURE that the global XHDC is set before calling this
  20.      routine. */
  21.   HGLRC context;
  23.   context = wglCreateContext(XHDC);
  25. #if 0
  26.   /* XXX GLUT doesn't support it now, so don't worry about display list
  27.      and texture object sharing. */
  28.   if (share) {
  29.     wglShareLists(share, context);
  30.   }
  31. #endif
  33.   /* Since direct rendering is implicit, the direct flag is
  34.      ignored. */
  36.   return context;
  37. }
  39. int
  40. glXGetConfig(Display * display, XVisualInfo * visual, int attrib, int *value)
  41. {
  42.   if (!visual)
  43.     return GLX_BAD_VISUAL;
  45.   switch (attrib) {
  46.   case GLX_USE_GL:
  47.     if ((visual->dwFlags & PFD_SUPPORT_OPENGL ) && (visual->dwFlags & PFD_DRAW_TO_WINDOW)) {
  48.       /* XXX Brad's Matrix Millenium II has problems creating
  49.          color index windows in 24-bit mode (lead to GDI crash)
  50.          and 32-bit mode (lead to black window).  The cColorBits
  51.          filed of the PIXELFORMATDESCRIPTOR returned claims to
  52.          have 24 and 32 bits respectively of color indices. 2^24
  53.          and 2^32 are ridiculously huge writable colormaps.
  54.          Assume that if we get back a color index
  55.          PIXELFORMATDESCRIPTOR with 24 or more bits, the
  56.          PIXELFORMATDESCRIPTOR doesn't really work and skip it.
  57.          -mjk */
  58.       if (visual->iPixelType == PFD_TYPE_COLORINDEX
  59.         && visual->cColorBits >= 24) {
  60.         *value = 0;
  61.       } else {
  62. *value = 1;
  63.       }
  64.     } else {
  65.       *value = 0;
  66.     }
  67.     break;
  68.   case GLX_BUFFER_SIZE:
  69.     /* KLUDGE: if we're RGBA, return the number of bits/pixel,
  70.        otherwise, return 8 (we guessed at 256 colors in CI
  71.        mode). */
  72.     if (visual->iPixelType == PFD_TYPE_RGBA)
  73.       *value = visual->cColorBits;
  74.     else
  75.       *value = 8;
  76.     break;
  77.   case GLX_LEVEL:
  78.     /* The bReserved flag of the pfd contains the
  79.        overlay/underlay info. */
  80.     *value = visual->bReserved;
  81.     break;
  82.   case GLX_RGBA:
  83.     *value = visual->iPixelType == PFD_TYPE_RGBA;
  84.     break;
  85.   case GLX_DOUBLEBUFFER:
  86.     *value = visual->dwFlags & PFD_DOUBLEBUFFER;
  87.     break;
  88.   case GLX_STEREO:
  89.     *value = visual->dwFlags & PFD_STEREO;
  90.     break;
  91.   case GLX_AUX_BUFFERS:
  92.     *value = visual->cAuxBuffers;
  93.     break;
  94.   case GLX_RED_SIZE:
  95.     *value = visual->cRedBits;
  96.     break;
  97.   case GLX_GREEN_SIZE:
  98.     *value = visual->cGreenBits;
  99.     break;
  100.   case GLX_BLUE_SIZE:
  101.     *value = visual->cBlueBits;
  102.     break;
  103.   case GLX_ALPHA_SIZE:
  104.     *value = visual->cAlphaBits;
  105.     break;
  106.   case GLX_DEPTH_SIZE:
  107.     *value = visual->cDepthBits;
  108.     break;
  109.   case GLX_STENCIL_SIZE:
  110.     *value = visual->cStencilBits;
  111.     break;
  112.   case GLX_ACCUM_RED_SIZE:
  113.     *value = visual->cAccumRedBits;
  114.     break;
  115.   case GLX_ACCUM_GREEN_SIZE:
  116.     *value = visual->cAccumGreenBits;
  117.     break;
  118.   case GLX_ACCUM_BLUE_SIZE:
  119.     *value = visual->cAccumBlueBits;
  120.     break;
  121.   case GLX_ACCUM_ALPHA_SIZE:
  122.     *value = visual->cAccumAlphaBits;
  123.     break;
  124.   default:
  125.     return GLX_BAD_ATTRIB;
  126.   }
  127.   return 0;
  128. }
  130. XVisualInfo *
  131. glXChooseVisual(Display * display, int screen, int *attribList)
  132. {
  133.   /* KLUDGE: since we need the HDC, MAKE SURE to set XHDC
  134.      before calling this routine. */
  136.   int *p = attribList;
  137.   int pf;
  138.   PIXELFORMATDESCRIPTOR pfd;
  139.   PIXELFORMATDESCRIPTOR *match = NULL;
  140.   int stereo = 0;
  142.   /* Avoid seg-faults. */
  143.   if (!p)
  144.     return NULL;
  146.   memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
  147.   pfd.nSize = (sizeof(PIXELFORMATDESCRIPTOR));
  148.   pfd.nVersion = 1;
  150.   /* Defaults. */
  151.   pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
  152.   pfd.iPixelType = PFD_TYPE_COLORINDEX;
  153.   pfd.cColorBits = 32;
  154.   pfd.cDepthBits = 0;
  156.   while (*p) {
  157.     switch (*p) {
  158.     case GLX_USE_GL:
  159.       pfd.dwFlags |= PFD_SUPPORT_OPENGL;
  160.       break;
  161.     case GLX_BUFFER_SIZE:
  162.       pfd.cColorBits = *(++p);
  163.       break;
  164.     case GLX_LEVEL:
  165.       /* the bReserved flag of the pfd contains the
  166.          overlay/underlay info. */
  167.       pfd.bReserved = *(++p);
  168.       break;
  169.     case GLX_RGBA:
  170.       pfd.iPixelType = PFD_TYPE_RGBA;
  171.       break;
  172.     case GLX_DOUBLEBUFFER:
  173.       pfd.dwFlags |= PFD_DOUBLEBUFFER;
  174.       break;
  175.     case GLX_STEREO:
  176.       stereo = 1;
  177.       pfd.dwFlags |= PFD_STEREO;
  178.       break;
  179.     case GLX_AUX_BUFFERS:
  180.       pfd.cAuxBuffers = *(++p);
  181.       break;
  182.     case GLX_RED_SIZE:
  183.       pfd.cRedBits = 8; /* Try to get the maximum. */
  184.       ++p;
  185.       break;
  186.     case GLX_GREEN_SIZE:
  187.       pfd.cGreenBits = 8;
  188.       ++p;
  189.       break;
  190.     case GLX_BLUE_SIZE:
  191.       pfd.cBlueBits = 8;
  192.       ++p;
  193.       break;
  194.     case GLX_ALPHA_SIZE:
  195.       pfd.cAlphaBits = 8;
  196.       ++p;
  197.       break;
  198.     case GLX_DEPTH_SIZE:
  199.       pfd.cDepthBits = 32;
  200.       ++p;
  201.       break;
  202.     case GLX_STENCIL_SIZE:
  203.       pfd.cStencilBits = *(++p);
  204.       break;
  205.     case GLX_ACCUM_RED_SIZE:
  206.     case GLX_ACCUM_GREEN_SIZE:
  207.     case GLX_ACCUM_BLUE_SIZE:
  208.     case GLX_ACCUM_ALPHA_SIZE:
  209.       /* I believe that WGL only used the cAccumRedBits,
  210.  cAccumBlueBits, cAccumGreenBits, and cAccumAlphaBits fields
  211.  when returning info about the accumulation buffer precision.
  212.  Only cAccumBits is used for requesting an accumulation
  213.  buffer. */
  214.       pfd.cAccumBits = 1;
  215.       ++p;
  216.       break;
  217.     }
  218.     ++p;
  219.   }
  221.   /* Let Win32 choose one for us. */
  222.   pf = ChoosePixelFormat(XHDC, &pfd);
  223.   if (pf > 0) {
  224.     match = (PIXELFORMATDESCRIPTOR *) malloc(sizeof(PIXELFORMATDESCRIPTOR));
  225.     DescribePixelFormat(XHDC, pf, sizeof(PIXELFORMATDESCRIPTOR), match);
  227.     /* ChoosePixelFormat is dumb in that it will return a pixel
  228.        format that doesn't have stereo even if it was requested
  229.        so we need to make sure that if stereo was selected, we
  230.        got it. */
  231.     if (stereo) {
  232.       if (!(match->dwFlags & PFD_STEREO)) {
  233.         free(match);
  234. return NULL;
  235.       }
  236.     }
  237.     /* XXX Brad's Matrix Millenium II has problems creating
  238.        color index windows in 24-bit mode (lead to GDI crash)
  239.        and 32-bit mode (lead to black window).  The cColorBits
  240.        filed of the PIXELFORMATDESCRIPTOR returned claims to
  241.        have 24 and 32 bits respectively of color indices. 2^24
  242.        and 2^32 are ridiculously huge writable colormaps.
  243.        Assume that if we get back a color index
  244.        PIXELFORMATDESCRIPTOR with 24 or more bits, the
  245.        PIXELFORMATDESCRIPTOR doesn't really work and skip it.
  246.        -mjk */
  247.     if (match->iPixelType == PFD_TYPE_COLORINDEX
  248.       && match->cColorBits >= 24) {
  249.       free(match);
  250.       return NULL;
  251.     }
  252.   }
  253.   return match;
  254. }