Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2008 VMware, Inc.
  4.  * All Rights Reserved.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the
  8.  * "Software"), to deal in the Software without restriction, including
  9.  * without limitation the rights to use, copy, modify, merge, publish,
  10.  * distribute, sub license, and/or sell copies of the Software, and to
  11.  * permit persons to whom the Software is furnished to do so, subject to
  12.  * the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice (including the
  15.  * next paragraph) shall be included in all copies or substantial portions
  16.  * of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21.  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22.  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24.  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  *
  26.  **************************************************************************/
  27.  
  28. #include <windows.h>
  29.  
  30. #define WGL_WGLEXT_PROTOTYPES
  31.  
  32. #include <GL/gl.h>
  33. #include <GL/wglext.h>
  34.  
  35. #include "pipe/p_compiler.h"
  36. #include "pipe/p_context.h"
  37. #include "pipe/p_state.h"
  38. #include "util/u_memory.h"
  39. #include "util/u_atomic.h"
  40. #include "state_tracker/st_api.h"
  41. #include "hud/hud_context.h"
  42.  
  43. #include "stw_icd.h"
  44. #include "stw_device.h"
  45. #include "stw_winsys.h"
  46. #include "stw_framebuffer.h"
  47. #include "stw_pixelformat.h"
  48. #include "stw_context.h"
  49. #include "stw_tls.h"
  50.  
  51.  
  52. struct stw_context *
  53. stw_current_context(void)
  54. {
  55.    struct st_context_iface *st;
  56.  
  57.    st = (stw_dev) ? stw_dev->stapi->get_current(stw_dev->stapi) : NULL;
  58.  
  59.    return (struct stw_context *) ((st) ? st->st_manager_private : NULL);
  60. }
  61.  
  62. BOOL APIENTRY
  63. DrvCopyContext(
  64.    DHGLRC dhrcSource,
  65.    DHGLRC dhrcDest,
  66.    UINT fuMask )
  67. {
  68.    struct stw_context *src;
  69.    struct stw_context *dst;
  70.    BOOL ret = FALSE;
  71.  
  72.    if (!stw_dev)
  73.       return FALSE;
  74.  
  75.    pipe_mutex_lock( stw_dev->ctx_mutex );
  76.    
  77.    src = stw_lookup_context_locked( dhrcSource );
  78.    dst = stw_lookup_context_locked( dhrcDest );
  79.  
  80.    if (src && dst) {
  81.       /* FIXME */
  82.       assert(0);
  83.       (void) src;
  84.       (void) dst;
  85.       (void) fuMask;
  86.    }
  87.  
  88.    pipe_mutex_unlock( stw_dev->ctx_mutex );
  89.    
  90.    return ret;
  91. }
  92.  
  93. BOOL APIENTRY
  94. DrvShareLists(
  95.    DHGLRC dhglrc1,
  96.    DHGLRC dhglrc2 )
  97. {
  98.    struct stw_context *ctx1;
  99.    struct stw_context *ctx2;
  100.    BOOL ret = FALSE;
  101.  
  102.    if (!stw_dev)
  103.       return FALSE;
  104.  
  105.    pipe_mutex_lock( stw_dev->ctx_mutex );
  106.    
  107.    ctx1 = stw_lookup_context_locked( dhglrc1 );
  108.    ctx2 = stw_lookup_context_locked( dhglrc2 );
  109.  
  110.    if (ctx1 && ctx2 && ctx2->st->share)
  111.       ret = ctx2->st->share(ctx2->st, ctx1->st);
  112.  
  113.    pipe_mutex_unlock( stw_dev->ctx_mutex );
  114.    
  115.    return ret;
  116. }
  117.  
  118. DHGLRC APIENTRY
  119. DrvCreateContext(
  120.    HDC hdc )
  121. {
  122.    return DrvCreateLayerContext( hdc, 0 );
  123. }
  124.  
  125. DHGLRC APIENTRY
  126. DrvCreateLayerContext(
  127.    HDC hdc,
  128.    INT iLayerPlane )
  129. {
  130.    return stw_create_context_attribs(hdc, iLayerPlane, 0, 1, 0, 0,
  131.                                      WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
  132.                                      0);
  133. }
  134.  
  135.  
  136. /**
  137.  * Called via DrvCreateContext(), DrvCreateLayerContext() and
  138.  * wglCreateContextAttribsARB() to actually create a rendering context.
  139.  * \param handle  the desired DHGLRC handle to use for the context, or zero
  140.  *                if a new handle should be allocated.
  141.  * \return the handle for the new context or zero if there was a problem.
  142.  */
  143. DHGLRC
  144. stw_create_context_attribs(HDC hdc, INT iLayerPlane, DHGLRC hShareContext,
  145.                            int majorVersion, int minorVersion,
  146.                            int contextFlags, int profileMask,
  147.                            DHGLRC handle)
  148. {
  149.    int iPixelFormat;
  150.    struct stw_framebuffer *fb;
  151.    const struct stw_pixelformat_info *pfi;
  152.    struct st_context_attribs attribs;
  153.    struct stw_context *ctx = NULL;
  154.    struct stw_context *shareCtx = NULL;
  155.    enum st_context_error ctx_err = 0;
  156.  
  157.    if (!stw_dev)
  158.       return 0;
  159.  
  160.    if (iLayerPlane != 0)
  161.       return 0;
  162.  
  163.    iPixelFormat = GetPixelFormat(hdc);
  164.    if(!iPixelFormat)
  165.       return 0;
  166.  
  167.    /*
  168.     * GDI only knows about displayable pixel formats, so determine the pixel
  169.     * format from the framebuffer.
  170.     *
  171.     * TODO: Remove the GetPixelFormat() above, and stop relying on GDI.
  172.     */
  173.    fb = stw_framebuffer_from_hdc( hdc );
  174.    if (fb) {
  175.       assert(iPixelFormat == fb->iDisplayablePixelFormat);
  176.       iPixelFormat = fb->iPixelFormat;
  177.       stw_framebuffer_release(fb);
  178.    }
  179.  
  180.    pfi = stw_pixelformat_get_info( iPixelFormat );
  181.  
  182.    if (hShareContext != 0) {
  183.       pipe_mutex_lock( stw_dev->ctx_mutex );
  184.       shareCtx = stw_lookup_context_locked( hShareContext );
  185.       pipe_mutex_unlock( stw_dev->ctx_mutex );
  186.    }
  187.  
  188.    ctx = CALLOC_STRUCT( stw_context );
  189.    if (ctx == NULL)
  190.       goto no_ctx;
  191.  
  192.    ctx->hdc = hdc;
  193.    ctx->iPixelFormat = iPixelFormat;
  194.  
  195.    memset(&attribs, 0, sizeof(attribs));
  196.    attribs.visual = pfi->stvis;
  197.    attribs.major = majorVersion;
  198.    attribs.minor = minorVersion;
  199.    if (contextFlags & WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB)
  200.       attribs.flags |= ST_CONTEXT_FLAG_FORWARD_COMPATIBLE;
  201.    if (contextFlags & WGL_CONTEXT_DEBUG_BIT_ARB)
  202.       attribs.flags |= ST_CONTEXT_FLAG_DEBUG;
  203.  
  204.    switch (profileMask) {
  205.    case WGL_CONTEXT_CORE_PROFILE_BIT_ARB:
  206.       /* There are no profiles before OpenGL 3.2.  The
  207.        * WGL_ARB_create_context_profile spec says:
  208.        *
  209.        *     "If the requested OpenGL version is less than 3.2,
  210.        *     WGL_CONTEXT_PROFILE_MASK_ARB is ignored and the functionality
  211.        *     of the context is determined solely by the requested version."
  212.        */
  213.       if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 2)) {
  214.          attribs.profile = ST_PROFILE_OPENGL_CORE;
  215.          break;
  216.       }
  217.       /* fall-through */
  218.    case WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB:
  219.       /*
  220.        * The spec also says:
  221.        *
  222.        *     "If version 3.1 is requested, the context returned may implement
  223.        *     any of the following versions:
  224.        *
  225.        *       * Version 3.1. The GL_ARB_compatibility extension may or may not
  226.        *         be implemented, as determined by the implementation.
  227.        *       * The core profile of version 3.2 or greater."
  228.        *
  229.        * and because Mesa doesn't support GL_ARB_compatibility, the only chance to
  230.        * honour a 3.1 context is through core profile.
  231.        */
  232.       if (majorVersion == 3 && minorVersion == 1) {
  233.          attribs.profile = ST_PROFILE_OPENGL_CORE;
  234.       } else {
  235.          attribs.profile = ST_PROFILE_DEFAULT;
  236.       }
  237.       break;
  238.    case WGL_CONTEXT_ES_PROFILE_BIT_EXT:
  239.       if (majorVersion >= 2) {
  240.          attribs.profile = ST_PROFILE_OPENGL_ES2;
  241.       } else {
  242.          attribs.profile = ST_PROFILE_OPENGL_ES1;
  243.       }
  244.       break;
  245.    default:
  246.       assert(0);
  247.       goto no_st_ctx;
  248.    }
  249.  
  250.    ctx->st = stw_dev->stapi->create_context(stw_dev->stapi,
  251.          stw_dev->smapi, &attribs, &ctx_err, shareCtx ? shareCtx->st : NULL);
  252.    if (ctx->st == NULL)
  253.       goto no_st_ctx;
  254.  
  255.    ctx->st->st_manager_private = (void *) ctx;
  256.  
  257.    if (ctx->st->cso_context) {
  258.       ctx->hud = hud_create(ctx->st->pipe, ctx->st->cso_context);
  259.    }
  260.  
  261.    pipe_mutex_lock( stw_dev->ctx_mutex );
  262.    if (handle) {
  263.       /* We're replacing the context data for this handle. See the
  264.        * wglCreateContextAttribsARB() function.
  265.        */
  266.       struct stw_context *old_ctx =
  267.          stw_lookup_context_locked((unsigned) handle);
  268.       if (old_ctx) {
  269.          /* free the old context data associated with this handle */
  270.          if (old_ctx->hud) {
  271.             hud_destroy(old_ctx->hud);
  272.          }
  273.          ctx->st->destroy(old_ctx->st);
  274.          FREE(old_ctx);
  275.       }
  276.  
  277.       /* replace table entry */
  278.       handle_table_set(stw_dev->ctx_table, (unsigned) handle, ctx);
  279.    }
  280.    else {
  281.       /* create new table entry */
  282.       handle = (DHGLRC) handle_table_add(stw_dev->ctx_table, ctx);
  283.    }
  284.  
  285.    ctx->dhglrc = handle;
  286.  
  287.    pipe_mutex_unlock( stw_dev->ctx_mutex );
  288.    if (!ctx->dhglrc)
  289.       goto no_hglrc;
  290.  
  291.    return ctx->dhglrc;
  292.  
  293. no_hglrc:
  294.    if (ctx->hud) {
  295.       hud_destroy(ctx->hud);
  296.    }
  297.    ctx->st->destroy(ctx->st);
  298. no_st_ctx:
  299.    FREE(ctx);
  300. no_ctx:
  301.    return 0;
  302. }
  303.  
  304. BOOL APIENTRY
  305. DrvDeleteContext(
  306.    DHGLRC dhglrc )
  307. {
  308.    struct stw_context *ctx ;
  309.    BOOL ret = FALSE;
  310.    
  311.    if (!stw_dev)
  312.       return FALSE;
  313.  
  314.    pipe_mutex_lock( stw_dev->ctx_mutex );
  315.    ctx = stw_lookup_context_locked(dhglrc);
  316.    handle_table_remove(stw_dev->ctx_table, dhglrc);
  317.    pipe_mutex_unlock( stw_dev->ctx_mutex );
  318.  
  319.    if (ctx) {
  320.       struct stw_context *curctx = stw_current_context();
  321.      
  322.       /* Unbind current if deleting current context. */
  323.       if (curctx == ctx)
  324.          stw_dev->stapi->make_current(stw_dev->stapi, NULL, NULL, NULL);
  325.  
  326.       if (ctx->hud) {
  327.          hud_destroy(ctx->hud);
  328.       }
  329.  
  330.       ctx->st->destroy(ctx->st);
  331.       FREE(ctx);
  332.  
  333.       ret = TRUE;
  334.    }
  335.  
  336.    return ret;
  337. }
  338.  
  339. BOOL APIENTRY
  340. DrvReleaseContext(
  341.    DHGLRC dhglrc )
  342. {
  343.    struct stw_context *ctx;
  344.  
  345.    if (!stw_dev)
  346.       return FALSE;
  347.  
  348.    pipe_mutex_lock( stw_dev->ctx_mutex );
  349.    ctx = stw_lookup_context_locked( dhglrc );
  350.    pipe_mutex_unlock( stw_dev->ctx_mutex );
  351.  
  352.    if (!ctx)
  353.       return FALSE;
  354.    
  355.    /* The expectation is that ctx is the same context which is
  356.     * current for this thread.  We should check that and return False
  357.     * if not the case.
  358.     */
  359.    if (ctx != stw_current_context())
  360.       return FALSE;
  361.  
  362.    if (stw_make_current( NULL, 0 ) == FALSE)
  363.       return FALSE;
  364.  
  365.    return TRUE;
  366. }
  367.  
  368.  
  369. DHGLRC
  370. stw_get_current_context( void )
  371. {
  372.    struct stw_context *ctx;
  373.  
  374.    ctx = stw_current_context();
  375.    if(!ctx)
  376.       return 0;
  377.    
  378.    return ctx->dhglrc;
  379. }
  380.  
  381. HDC
  382. stw_get_current_dc( void )
  383. {
  384.    struct stw_context *ctx;
  385.  
  386.    ctx = stw_current_context();
  387.    if(!ctx)
  388.       return NULL;
  389.    
  390.    return ctx->hdc;
  391. }
  392.  
  393. BOOL
  394. stw_make_current(
  395.    HDC hdc,
  396.    DHGLRC dhglrc )
  397. {
  398.    struct stw_context *curctx = NULL;
  399.    struct stw_context *ctx = NULL;
  400.    struct stw_framebuffer *fb = NULL;
  401.    BOOL ret = FALSE;
  402.  
  403.    if (!stw_dev)
  404.       return FALSE;
  405.  
  406.    curctx = stw_current_context();
  407.    if (curctx != NULL) {
  408.       if (curctx->dhglrc == dhglrc) {
  409.          if (curctx->hdc == hdc) {
  410.             /* Return if already current. */
  411.             return TRUE;
  412.          }
  413.       } else {
  414.          curctx->st->flush(curctx->st, ST_FLUSH_FRONT, NULL);
  415.       }
  416.    }
  417.  
  418.    if (dhglrc) {
  419.       pipe_mutex_lock( stw_dev->ctx_mutex );
  420.       ctx = stw_lookup_context_locked( dhglrc );
  421.       pipe_mutex_unlock( stw_dev->ctx_mutex );
  422.       if (!ctx) {
  423.          goto fail;
  424.       }
  425.  
  426.       fb = stw_framebuffer_from_hdc( hdc );
  427.       if (fb) {
  428.          stw_framebuffer_update(fb);
  429.       }
  430.       else {
  431.          /* Applications should call SetPixelFormat before creating a context,
  432.           * but not all do, and the opengl32 runtime seems to use a default pixel
  433.           * format in some cases, so we must create a framebuffer for those here
  434.           */
  435.          int iPixelFormat = GetPixelFormat(hdc);
  436.          if (iPixelFormat)
  437.             fb = stw_framebuffer_create( hdc, iPixelFormat );
  438.          if (!fb)
  439.             goto fail;
  440.       }
  441.    
  442.       if (fb->iPixelFormat != ctx->iPixelFormat) {
  443.          SetLastError(ERROR_INVALID_PIXEL_FORMAT);
  444.          goto fail;
  445.       }
  446.  
  447.       /* Bind the new framebuffer */
  448.       ctx->hdc = hdc;
  449.  
  450.       ret = stw_dev->stapi->make_current(stw_dev->stapi, ctx->st,
  451.                                          fb->stfb, fb->stfb);
  452.       stw_framebuffer_reference(&ctx->current_framebuffer, fb);
  453.    } else {
  454.       ret = stw_dev->stapi->make_current(stw_dev->stapi, NULL, NULL, NULL);
  455.    }
  456.    
  457. fail:
  458.  
  459.    if (fb) {
  460.       stw_framebuffer_release(fb);
  461.    }
  462.  
  463.    /* On failure, make the thread's current rendering context not current
  464.     * before returning */
  465.    if (!ret) {
  466.       stw_dev->stapi->make_current(stw_dev->stapi, NULL, NULL, NULL);
  467.       ctx = NULL;
  468.    }
  469.  
  470.    /* Unreference the previous framebuffer if any. It must be done after
  471.     * make_current, as it can be referenced inside.
  472.     */
  473.    if (curctx && curctx != ctx) {
  474.       stw_framebuffer_reference(&curctx->current_framebuffer, NULL);
  475.    }
  476.  
  477.    return ret;
  478. }
  479.  
  480. /**
  481.  * Flush the current context if it is bound to the framebuffer.
  482.  */
  483. void
  484. stw_flush_current_locked( struct stw_framebuffer *fb )
  485. {
  486.    struct stw_context *ctx = stw_current_context();
  487.  
  488.    if (ctx && ctx->current_framebuffer == fb) {
  489.       ctx->st->flush(ctx->st, ST_FLUSH_FRONT, NULL);
  490.    }
  491. }
  492.  
  493. /**
  494.  * Notify the current context that the framebuffer has become invalid.
  495.  */
  496. void
  497. stw_notify_current_locked( struct stw_framebuffer *fb )
  498. {
  499.    p_atomic_inc(&fb->stfb->stamp);
  500. }
  501.  
  502. /**
  503.  * Although WGL allows different dispatch entrypoints per context
  504.  */
  505. static const GLCLTPROCTABLE cpt =
  506. {
  507.    OPENGL_VERSION_110_ENTRIES,
  508.    {
  509.       &glNewList,
  510.       &glEndList,
  511.       &glCallList,
  512.       &glCallLists,
  513.       &glDeleteLists,
  514.       &glGenLists,
  515.       &glListBase,
  516.       &glBegin,
  517.       &glBitmap,
  518.       &glColor3b,
  519.       &glColor3bv,
  520.       &glColor3d,
  521.       &glColor3dv,
  522.       &glColor3f,
  523.       &glColor3fv,
  524.       &glColor3i,
  525.       &glColor3iv,
  526.       &glColor3s,
  527.       &glColor3sv,
  528.       &glColor3ub,
  529.       &glColor3ubv,
  530.       &glColor3ui,
  531.       &glColor3uiv,
  532.       &glColor3us,
  533.       &glColor3usv,
  534.       &glColor4b,
  535.       &glColor4bv,
  536.       &glColor4d,
  537.       &glColor4dv,
  538.       &glColor4f,
  539.       &glColor4fv,
  540.       &glColor4i,
  541.       &glColor4iv,
  542.       &glColor4s,
  543.       &glColor4sv,
  544.       &glColor4ub,
  545.       &glColor4ubv,
  546.       &glColor4ui,
  547.       &glColor4uiv,
  548.       &glColor4us,
  549.       &glColor4usv,
  550.       &glEdgeFlag,
  551.       &glEdgeFlagv,
  552.       &glEnd,
  553.       &glIndexd,
  554.       &glIndexdv,
  555.       &glIndexf,
  556.       &glIndexfv,
  557.       &glIndexi,
  558.       &glIndexiv,
  559.       &glIndexs,
  560.       &glIndexsv,
  561.       &glNormal3b,
  562.       &glNormal3bv,
  563.       &glNormal3d,
  564.       &glNormal3dv,
  565.       &glNormal3f,
  566.       &glNormal3fv,
  567.       &glNormal3i,
  568.       &glNormal3iv,
  569.       &glNormal3s,
  570.       &glNormal3sv,
  571.       &glRasterPos2d,
  572.       &glRasterPos2dv,
  573.       &glRasterPos2f,
  574.       &glRasterPos2fv,
  575.       &glRasterPos2i,
  576.       &glRasterPos2iv,
  577.       &glRasterPos2s,
  578.       &glRasterPos2sv,
  579.       &glRasterPos3d,
  580.       &glRasterPos3dv,
  581.       &glRasterPos3f,
  582.       &glRasterPos3fv,
  583.       &glRasterPos3i,
  584.       &glRasterPos3iv,
  585.       &glRasterPos3s,
  586.       &glRasterPos3sv,
  587.       &glRasterPos4d,
  588.       &glRasterPos4dv,
  589.       &glRasterPos4f,
  590.       &glRasterPos4fv,
  591.       &glRasterPos4i,
  592.       &glRasterPos4iv,
  593.       &glRasterPos4s,
  594.       &glRasterPos4sv,
  595.       &glRectd,
  596.       &glRectdv,
  597.       &glRectf,
  598.       &glRectfv,
  599.       &glRecti,
  600.       &glRectiv,
  601.       &glRects,
  602.       &glRectsv,
  603.       &glTexCoord1d,
  604.       &glTexCoord1dv,
  605.       &glTexCoord1f,
  606.       &glTexCoord1fv,
  607.       &glTexCoord1i,
  608.       &glTexCoord1iv,
  609.       &glTexCoord1s,
  610.       &glTexCoord1sv,
  611.       &glTexCoord2d,
  612.       &glTexCoord2dv,
  613.       &glTexCoord2f,
  614.       &glTexCoord2fv,
  615.       &glTexCoord2i,
  616.       &glTexCoord2iv,
  617.       &glTexCoord2s,
  618.       &glTexCoord2sv,
  619.       &glTexCoord3d,
  620.       &glTexCoord3dv,
  621.       &glTexCoord3f,
  622.       &glTexCoord3fv,
  623.       &glTexCoord3i,
  624.       &glTexCoord3iv,
  625.       &glTexCoord3s,
  626.       &glTexCoord3sv,
  627.       &glTexCoord4d,
  628.       &glTexCoord4dv,
  629.       &glTexCoord4f,
  630.       &glTexCoord4fv,
  631.       &glTexCoord4i,
  632.       &glTexCoord4iv,
  633.       &glTexCoord4s,
  634.       &glTexCoord4sv,
  635.       &glVertex2d,
  636.       &glVertex2dv,
  637.       &glVertex2f,
  638.       &glVertex2fv,
  639.       &glVertex2i,
  640.       &glVertex2iv,
  641.       &glVertex2s,
  642.       &glVertex2sv,
  643.       &glVertex3d,
  644.       &glVertex3dv,
  645.       &glVertex3f,
  646.       &glVertex3fv,
  647.       &glVertex3i,
  648.       &glVertex3iv,
  649.       &glVertex3s,
  650.       &glVertex3sv,
  651.       &glVertex4d,
  652.       &glVertex4dv,
  653.       &glVertex4f,
  654.       &glVertex4fv,
  655.       &glVertex4i,
  656.       &glVertex4iv,
  657.       &glVertex4s,
  658.       &glVertex4sv,
  659.       &glClipPlane,
  660.       &glColorMaterial,
  661.       &glCullFace,
  662.       &glFogf,
  663.       &glFogfv,
  664.       &glFogi,
  665.       &glFogiv,
  666.       &glFrontFace,
  667.       &glHint,
  668.       &glLightf,
  669.       &glLightfv,
  670.       &glLighti,
  671.       &glLightiv,
  672.       &glLightModelf,
  673.       &glLightModelfv,
  674.       &glLightModeli,
  675.       &glLightModeliv,
  676.       &glLineStipple,
  677.       &glLineWidth,
  678.       &glMaterialf,
  679.       &glMaterialfv,
  680.       &glMateriali,
  681.       &glMaterialiv,
  682.       &glPointSize,
  683.       &glPolygonMode,
  684.       &glPolygonStipple,
  685.       &glScissor,
  686.       &glShadeModel,
  687.       &glTexParameterf,
  688.       &glTexParameterfv,
  689.       &glTexParameteri,
  690.       &glTexParameteriv,
  691.       &glTexImage1D,
  692.       &glTexImage2D,
  693.       &glTexEnvf,
  694.       &glTexEnvfv,
  695.       &glTexEnvi,
  696.       &glTexEnviv,
  697.       &glTexGend,
  698.       &glTexGendv,
  699.       &glTexGenf,
  700.       &glTexGenfv,
  701.       &glTexGeni,
  702.       &glTexGeniv,
  703.       &glFeedbackBuffer,
  704.       &glSelectBuffer,
  705.       &glRenderMode,
  706.       &glInitNames,
  707.       &glLoadName,
  708.       &glPassThrough,
  709.       &glPopName,
  710.       &glPushName,
  711.       &glDrawBuffer,
  712.       &glClear,
  713.       &glClearAccum,
  714.       &glClearIndex,
  715.       &glClearColor,
  716.       &glClearStencil,
  717.       &glClearDepth,
  718.       &glStencilMask,
  719.       &glColorMask,
  720.       &glDepthMask,
  721.       &glIndexMask,
  722.       &glAccum,
  723.       &glDisable,
  724.       &glEnable,
  725.       &glFinish,
  726.       &glFlush,
  727.       &glPopAttrib,
  728.       &glPushAttrib,
  729.       &glMap1d,
  730.       &glMap1f,
  731.       &glMap2d,
  732.       &glMap2f,
  733.       &glMapGrid1d,
  734.       &glMapGrid1f,
  735.       &glMapGrid2d,
  736.       &glMapGrid2f,
  737.       &glEvalCoord1d,
  738.       &glEvalCoord1dv,
  739.       &glEvalCoord1f,
  740.       &glEvalCoord1fv,
  741.       &glEvalCoord2d,
  742.       &glEvalCoord2dv,
  743.       &glEvalCoord2f,
  744.       &glEvalCoord2fv,
  745.       &glEvalMesh1,
  746.       &glEvalPoint1,
  747.       &glEvalMesh2,
  748.       &glEvalPoint2,
  749.       &glAlphaFunc,
  750.       &glBlendFunc,
  751.       &glLogicOp,
  752.       &glStencilFunc,
  753.       &glStencilOp,
  754.       &glDepthFunc,
  755.       &glPixelZoom,
  756.       &glPixelTransferf,
  757.       &glPixelTransferi,
  758.       &glPixelStoref,
  759.       &glPixelStorei,
  760.       &glPixelMapfv,
  761.       &glPixelMapuiv,
  762.       &glPixelMapusv,
  763.       &glReadBuffer,
  764.       &glCopyPixels,
  765.       &glReadPixels,
  766.       &glDrawPixels,
  767.       &glGetBooleanv,
  768.       &glGetClipPlane,
  769.       &glGetDoublev,
  770.       &glGetError,
  771.       &glGetFloatv,
  772.       &glGetIntegerv,
  773.       &glGetLightfv,
  774.       &glGetLightiv,
  775.       &glGetMapdv,
  776.       &glGetMapfv,
  777.       &glGetMapiv,
  778.       &glGetMaterialfv,
  779.       &glGetMaterialiv,
  780.       &glGetPixelMapfv,
  781.       &glGetPixelMapuiv,
  782.       &glGetPixelMapusv,
  783.       &glGetPolygonStipple,
  784.       &glGetString,
  785.       &glGetTexEnvfv,
  786.       &glGetTexEnviv,
  787.       &glGetTexGendv,
  788.       &glGetTexGenfv,
  789.       &glGetTexGeniv,
  790.       &glGetTexImage,
  791.       &glGetTexParameterfv,
  792.       &glGetTexParameteriv,
  793.       &glGetTexLevelParameterfv,
  794.       &glGetTexLevelParameteriv,
  795.       &glIsEnabled,
  796.       &glIsList,
  797.       &glDepthRange,
  798.       &glFrustum,
  799.       &glLoadIdentity,
  800.       &glLoadMatrixf,
  801.       &glLoadMatrixd,
  802.       &glMatrixMode,
  803.       &glMultMatrixf,
  804.       &glMultMatrixd,
  805.       &glOrtho,
  806.       &glPopMatrix,
  807.       &glPushMatrix,
  808.       &glRotated,
  809.       &glRotatef,
  810.       &glScaled,
  811.       &glScalef,
  812.       &glTranslated,
  813.       &glTranslatef,
  814.       &glViewport,
  815.       &glArrayElement,
  816.       &glBindTexture,
  817.       &glColorPointer,
  818.       &glDisableClientState,
  819.       &glDrawArrays,
  820.       &glDrawElements,
  821.       &glEdgeFlagPointer,
  822.       &glEnableClientState,
  823.       &glIndexPointer,
  824.       &glIndexub,
  825.       &glIndexubv,
  826.       &glInterleavedArrays,
  827.       &glNormalPointer,
  828.       &glPolygonOffset,
  829.       &glTexCoordPointer,
  830.       &glVertexPointer,
  831.       &glAreTexturesResident,
  832.       &glCopyTexImage1D,
  833.       &glCopyTexImage2D,
  834.       &glCopyTexSubImage1D,
  835.       &glCopyTexSubImage2D,
  836.       &glDeleteTextures,
  837.       &glGenTextures,
  838.       &glGetPointerv,
  839.       &glIsTexture,
  840.       &glPrioritizeTextures,
  841.       &glTexSubImage1D,
  842.       &glTexSubImage2D,
  843.       &glPopClientAttrib,
  844.       &glPushClientAttrib
  845.    }
  846. };
  847.  
  848. PGLCLTPROCTABLE APIENTRY
  849. DrvSetContext(
  850.    HDC hdc,
  851.    DHGLRC dhglrc,
  852.    PFN_SETPROCTABLE pfnSetProcTable )
  853. {
  854.    PGLCLTPROCTABLE r = (PGLCLTPROCTABLE)&cpt;
  855.  
  856.    if (!stw_make_current( hdc, dhglrc ))
  857.       r = NULL;
  858.  
  859.    return r;
  860. }
  861.