Merge branch '7.8'
authorBrian Paul <brianp@vmware.com>
Wed, 28 Apr 2010 13:21:25 +0000 (07:21 -0600)
committerBrian Paul <brianp@vmware.com>
Wed, 28 Apr 2010 13:21:25 +0000 (07:21 -0600)
Conflicts:

src/glx/dri2_glx.c
src/glx/glx_pbuffer.c

1  2 
src/glx/dri2_glx.c
src/glx/dri_common.c
src/glx/drisw_glx.c
src/glx/glx_pbuffer.c
src/glx/glxclient.h
src/glx/glxcmds.c

diff --combined src/glx/dri2_glx.c
index 73d11f14a14cb2a92b9efadf9d16ace2e25ec8ba,1c344489c0cc6a88ac70a018a76fcd179206973b..6058c721da7a8efe6cb201a578b0f918d92a226b
@@@ -30,7 -30,7 +30,7 @@@
   *   Kristian Høgsberg (krh@redhat.com)
   */
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
  
  #include <X11/Xlib.h>
  #include <X11/extensions/Xfixes.h>
  #include "xf86drm.h"
  #include "dri2.h"
  #include "dri_common.h"
 -#include "../../mesa/drivers/dri/common/dri_util.h"
 +
 +/* From xmlpool/options.h, user exposed so should be stable */
 +#define DRI_CONF_VBLANK_NEVER 0
 +#define DRI_CONF_VBLANK_DEF_INTERVAL_0 1
 +#define DRI_CONF_VBLANK_DEF_INTERVAL_1 2
 +#define DRI_CONF_VBLANK_ALWAYS_SYNC 3
  
  #undef DRI2_MINOR
  #define DRI2_MINOR 1
@@@ -182,7 -177,6 +182,7 @@@ dri2CreateDrawable(__GLXscreenConfigs 
     __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes;
     __GLXdisplayPrivate *dpyPriv;
     __GLXDRIdisplayPrivate *pdp;
 +   GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
  
     pdraw = Xmalloc(sizeof(*pdraw));
     if (!pdraw)
     pdraw->base.drawable = drawable;
     pdraw->base.psc = psc;
     pdraw->bufferCount = 0;
 -   pdraw->swap_interval = 1;
 +   pdraw->swap_interval = 1; /* default may be overridden below */
     pdraw->have_back = 0;
  
 +   if (psc->config)
 +      psc->config->configQueryi(psc->__driScreen, "vblank_mode", &vblank_mode);
 +
 +   switch (vblank_mode) {
 +   case DRI_CONF_VBLANK_NEVER:
 +   case DRI_CONF_VBLANK_DEF_INTERVAL_0:
 +      pdraw->swap_interval = 0;
 +      break;
 +   case DRI_CONF_VBLANK_DEF_INTERVAL_1:
 +   case DRI_CONF_VBLANK_ALWAYS_SYNC:
 +   default:
 +      pdraw->swap_interval = 1;
 +      break;
 +   }
 +
     DRI2CreateDrawable(psc->dpy, xDrawable);
  
     dpyPriv = __glXInitialize(psc->dpy);
@@@ -498,23 -477,7 +498,23 @@@ dri2GetBuffersWithFormat(__DRIdrawable 
  static void
  dri2SetSwapInterval(__GLXDRIdrawable *pdraw, int interval)
  {
 +   __GLXscreenConfigs *psc = pdraw->psc;
     __GLXDRIdrawablePrivate *priv =  (__GLXDRIdrawablePrivate *) pdraw;
 +   GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
 +
 +   if (psc->config)
 +      psc->config->configQueryi(psc->__driScreen, "vblank_mode", &vblank_mode);
 +
 +   switch (vblank_mode) {
 +   case DRI_CONF_VBLANK_NEVER:
 +      return;
 +   case DRI_CONF_VBLANK_ALWAYS_SYNC:
 +      if (interval <= 0)
 +       return;
 +      break;
 +   default:
 +      break;
 +   }
  
     DRI2SwapInterval(priv->base.psc->dpy, pdraw->xDrawable, interval);
     priv->swap_interval = interval;
diff --combined src/glx/dri_common.c
index dbc6082313bef50b7333240a8ccc68206655514a,d6ce681d70e6b933b307ccfbb973e323cae1de53..429fc6d89126d91cf495e713134d390bb79f12ed
@@@ -33,7 -33,7 +33,7 @@@
   *   Kristian Høgsberg (krh@redhat.com)
   */
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
  
  #include <unistd.h>
  #include <dlfcn.h>
@@@ -403,11 -403,6 +403,11 @@@ dri2BindExtensions(__GLXscreenConfigs *
         /* internal driver extension, no GL extension exposed */
        }
  #endif
 +
 +#ifdef __DRI2_CONFIG_QUERY
 +      if ((strcmp(extensions[i]->name, __DRI2_CONFIG_QUERY) == 0))
 +       psc->config = (__DRI2configQueryExtension *) extensions[i];
 +#endif
     }
  }
  
diff --combined src/glx/drisw_glx.c
index 786faff81c1733651f27f3adc06f1d8f027d10ed,d8027cc96d5d3e02dde3903f6556047381f6105b..cdb1d9f4dc3ea0a4243eb98fcace7644cd3a8e28
@@@ -21,7 -21,7 +21,7 @@@
   * SOFTWARE.
   */
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
  
  #include <X11/Xlib.h>
  #include "glxclient.h"
@@@ -53,8 -53,13 +53,8 @@@ struct __GLXDRIdrawablePrivateRe
  
     XVisualInfo *visinfo;
     XImage *ximage;
 -   int bpp;
  };
  
 -/**
 - * swrast loader functions
 - */
 -
  static Bool
  XCreateDrawable(__GLXDRIdrawablePrivate * pdp,
                  Display * dpy, XID drawable, int visualid)
     XChangeGC(dpy, pdp->swapgc, GCFunction, &gcvalues);
     XChangeGC(dpy, pdp->swapgc, GCGraphicsExposures, &gcvalues);
  
 -   /* create XImage  */
 +   /* visual */
     visTemp.screen = DefaultScreen(dpy);
     visTemp.visualid = visualid;
     visMask = (VisualScreenMask | VisualIDMask);
     pdp->visinfo = XGetVisualInfo(dpy, visMask, &visTemp, &num_visuals);
  
 -   pdp->ximage = XCreateImage(dpy, pdp->visinfo->visual, pdp->visinfo->depth, ZPixmap, 0,       /* format, offset */
 -                              NULL,     /* data */
 -                              0, 0,     /* size */
 -                              32,       /* bitmap_pad */
 -                              0);       /* bytes_per_line */
 -
 -   /* get the true number of bits per pixel */
 -   pdp->bpp = pdp->ximage->bits_per_pixel;
 +   /* create XImage */
 +   pdp->ximage = XCreateImage(dpy,
 +                              pdp->visinfo->visual,
 +                              pdp->visinfo->depth,
 +                              ZPixmap, 0,             /* format, offset */
 +                              NULL,                   /* data */
 +                              0, 0,                   /* width, height */
 +                              32,                     /* bitmap_pad */
 +                              0);                     /* bytes_per_line */
  
     return True;
  }
@@@ -103,14 -107,9 +103,14 @@@ XDestroyDrawable(__GLXDRIdrawablePrivat
     XFreeGC(dpy, pdp->swapgc);
  }
  
 +/**
 + * swrast loader functions
 + */
 +
  static void
  swrastGetDrawableInfo(__DRIdrawable * draw,
 -                      int *x, int *y, int *w, int *h, void *loaderPrivate)
 +                      int *x, int *y, int *w, int *h,
 +                      void *loaderPrivate)
  {
     __GLXDRIdrawablePrivate *pdp = loaderPrivate;
     __GLXDRIdrawable *pdraw = &(pdp->base);
  
     Window root;
     Status stat;
 -   unsigned int bw, depth;
 +   unsigned uw, uh, bw, depth;
  
     drawable = pdraw->xDrawable;
  
     stat = XGetGeometry(dpy, drawable, &root,
 -                       x, y, (unsigned int *) w, (unsigned int *) h,
 -                       &bw, &depth);
 +                       x, y, &uw, &uh, &bw, &depth);
 +   *w = uw;
 +   *h = uh;
  }
  
 +/**
 + * Align renderbuffer pitch.
 + *
 + * This should be chosen by the driver and the loader (libGL, xserver/glx)
 + * should use the driver provided pitch.
 + *
 + * It seems that the xorg loader (that is the xserver loading swrast_dri for
 + * indirect rendering, not client-side libGL) requires that the pitch is
 + * exactly the image width padded to 32 bits. XXX
 + *
 + * The above restriction can probably be overcome by using ScratchPixmap and
 + * CopyArea in the xserver, similar to ShmPutImage, and setting the width of
 + * the scratch pixmap to 'pitch / cpp'.
 + */
  static inline int
 -bytes_per_line(int w, int bpp, unsigned mul)
 +bytes_per_line(unsigned pitch_bits, unsigned mul)
  {
     unsigned mask = mul - 1;
  
 -   return ((w * bpp + mask) & ~mask) / 8;
 +   return ((pitch_bits + mask) & ~mask) / 8;
  }
  
  static void
  swrastPutImage(__DRIdrawable * draw, int op,
 -               int x, int y, int w, int h, char *data, void *loaderPrivate)
 +               int x, int y, int w, int h,
 +               char *data, void *loaderPrivate)
  {
     __GLXDRIdrawablePrivate *pdp = loaderPrivate;
     __GLXDRIdrawable *pdraw = &(pdp->base);
     ximage->data = data;
     ximage->width = w;
     ximage->height = h;
 -   ximage->bytes_per_line = bytes_per_line(w, pdp->bpp, 32);
 +   ximage->bytes_per_line = bytes_per_line(w * ximage->bits_per_pixel, 32);
  
     XPutImage(dpy, drawable, gc, ximage, 0, 0, x, y, w, h);
  
  }
  
  static void
 -swrastGetImage(__DRIdrawable * draw,
 -               int x, int y, int w, int h, char *data, void *loaderPrivate)
 +swrastGetImage(__DRIdrawable * read,
 +               int x, int y, int w, int h,
 +               char *data, void *loaderPrivate)
  {
 -   __GLXDRIdrawablePrivate *pdp = loaderPrivate;
 -   __GLXDRIdrawable *pdraw = &(pdp->base);
 -   Display *dpy = pdraw->psc->dpy;
 -   Drawable drawable;
 +   __GLXDRIdrawablePrivate *prp = loaderPrivate;
 +   __GLXDRIdrawable *pread = &(prp->base);
 +   Display *dpy = pread->psc->dpy;
 +   Drawable readable;
     XImage *ximage;
  
 -   drawable = pdraw->xDrawable;
 +   readable = pread->xDrawable;
  
 -   ximage = pdp->ximage;
 +   ximage = prp->ximage;
     ximage->data = data;
     ximage->width = w;
     ximage->height = h;
 -   ximage->bytes_per_line = bytes_per_line(w, pdp->bpp, 32);
 +   ximage->bytes_per_line = bytes_per_line(w * ximage->bits_per_pixel, 32);
  
 -   XGetSubImage(dpy, drawable, x, y, w, h, ~0L, ZPixmap, ximage, 0, 0);
 +   XGetSubImage(dpy, readable, x, y, w, h, ~0L, ZPixmap, ximage, 0, 0);
  
     ximage->data = NULL;
  }
@@@ -352,17 -334,10 +352,17 @@@ driCreateDrawable(__GLXscreenConfigs * 
     return pdraw;
  }
  
 -static void
 -driSwapBuffers(__GLXDRIdrawable * pdraw)
 +static int64_t
 +driSwapBuffers(__GLXDRIdrawable * pdraw,
 +               int64_t target_msc, int64_t divisor, int64_t remainder)
  {
 +   (void) target_msc;
 +   (void) divisor;
 +   (void) remainder;
 +
     (*pdraw->psc->core->swapBuffers) (pdraw->driDrawable);
 +
 +   return 0;
  }
  
  static void
@@@ -375,20 -350,6 +375,20 @@@ driDestroyScreen(__GLXscreenConfigs * p
        dlclose(psc->driver);
  }
  
 +static void *
 +driOpenSwrast(void)
 +{
 +   void *driver = NULL;
 +
 +   if (driver == NULL)
 +      driver = driOpenDriver("swrast");
 +
 +   if (driver == NULL)
 +      driver = driOpenDriver("swrastg");
 +
 +   return driver;
 +}
 +
  static __GLXDRIscreen *
  driCreateScreen(__GLXscreenConfigs * psc, int screen,
                  __GLXdisplayPrivate * priv)
     __GLXDRIscreen *psp;
     const __DRIconfig **driver_configs;
     const __DRIextension **extensions;
 -   const char *driverName = "swrast";
     int i;
  
     psp = Xcalloc(1, sizeof *psp);
     if (psp == NULL)
        return NULL;
  
 -   psc->driver = driOpenDriver(driverName);
 +   psc->driver = driOpenSwrast();
     if (psc->driver == NULL)
        goto handle_error;
  
diff --combined src/glx/glx_pbuffer.c
index 2098cc6a52d241c27df03fd0c671f007f036ae62,6c34cda1543c02ba7ab0a42704e6ab19d7664714..b8d0f21bf0620a9387d1dfe13944251744319c1f
  #include <string.h>
  #include "glxextensions.h"
  
+ #ifdef GLX_USE_APPLEGL
+ #include <pthread.h>
+ #include "apple_glx_drawable.h"
+ #include "glx_error.h"
+ #endif
  #define WARN_ONCE_GLX_1_3(a, b) {             \
                static int warned=1;            \
                if(warned) {                    \
   * Emit a warning when clients use GLX 1.3 functions on pre-1.3 systems.
   */
  static void
- warn_GLX_1_3(Display *dpy, const char *function_name)
+ warn_GLX_1_3(Display * dpy, const char *function_name)
  {
     __GLXdisplayPrivate *priv = __glXInitialize(dpy);
  
     if (priv->minorVersion < 3) {
-       fprintf(stderr, 
-             "WARNING: Application calling GLX 1.3 function \"%s\" "
-             "when GLX 1.3 is not supported!  This is an application bug!\n",
-             function_name);
+       fprintf(stderr,
+               "WARNING: Application calling GLX 1.3 function \"%s\" "
+               "when GLX 1.3 is not supported!  This is an application bug!\n",
+               function_name);
     }
  }
  
+ #ifndef GLX_USE_APPLEGL
  /**
   * Change a drawable's attribute.
   *
@@@ -127,6 -133,64 +133,6 @@@ ChangeDrawableAttribute(Display * dpy, 
  }
  
  
 -/**
 - * Destroy a pbuffer.
 - *
 - * This function is used to implement \c glXDestroyPbuffer and
 - * \c glXDestroyGLXPbufferSGIX.
 - *
 - * \note
 - * This function dynamically determines whether to use the SGIX_pbuffer
 - * version of the protocol or the GLX 1.3 version of the protocol.
 - *
 - * \todo
 - * This function needs to be modified to work with direct-rendering drivers.
 - */
 -static void
 -DestroyPbuffer(Display * dpy, GLXDrawable drawable)
 -{
 -   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
 -   CARD8 opcode;
 -
 -   if ((dpy == NULL) || (drawable == 0)) {
 -      return;
 -   }
 -
 -   opcode = __glXSetupForCommand(dpy);
 -   if (!opcode)
 -      return;
 -
 -   LockDisplay(dpy);
 -
 -   if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
 -      xGLXDestroyPbufferReq *req;
 -
 -      GetReq(GLXDestroyPbuffer, req);
 -      req->reqType = opcode;
 -      req->glxCode = X_GLXDestroyPbuffer;
 -      req->pbuffer = (GLXPbuffer) drawable;
 -   }
 -   else {
 -      xGLXVendorPrivateWithReplyReq *vpreq;
 -      CARD32 *data;
 -
 -      GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq);
 -      data = (CARD32 *) (vpreq + 1);
 -
 -      data[0] = (CARD32) drawable;
 -
 -      vpreq->reqType = opcode;
 -      vpreq->glxCode = X_GLXVendorPrivateWithReply;
 -      vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX;
 -   }
 -
 -   UnlockDisplay(dpy);
 -   SyncHandle();
 -
 -   return;
 -}
 -
 -
  #ifdef GLX_DIRECT_RENDERING
  static GLenum
  determineTextureTarget(const int *attribs, int numAttribs)
     return target;
  }
  
 -
  static GLenum
  determineTextureFormat(const int *attribs, int numAttribs)
  {
  
     return 0;
  }
 +
 +static void
 +CreateDRIDrawable(Display *dpy, const __GLcontextModes *fbconfig,
 +                XID drawable, XID glxdrawable,
 +                const int *attrib_list, size_t num_attribs)
 +{
 +   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
 +   __GLXDRIdrawable *pdraw;
 +   __GLXscreenConfigs *psc;
 +
 +   psc = &priv->screenConfigs[fbconfig->screen];
 +   if (psc->driScreen == NULL)
 +      return;
 +
 +   pdraw = psc->driScreen->createDrawable(psc, drawable,
 +                                        glxdrawable, fbconfig);
 +   if (pdraw == NULL) {
 +      fprintf(stderr, "failed to create drawable\n");
 +      return;
 +   }
 +
 +   if (__glxHashInsert(psc->drawHash, glxdrawable, pdraw)) {
 +      (*pdraw->destroyDrawable) (pdraw);
 +      return; /* FIXME: Check what we're supposed to do here... */
 +   }
 +
 +   pdraw->textureTarget = determineTextureTarget(attrib_list, num_attribs);
 +   pdraw->textureFormat = determineTextureFormat(attrib_list, num_attribs);
 +}
 +
 +static void
 +DestroyDRIDrawable(Display *dpy, GLXDrawable drawable, int destroy_xdrawable)
 +{
 +   int screen;
 +   __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
 +   __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
 +   __GLXscreenConfigs *psc = &priv->screenConfigs[screen];
 +
 +   if (pdraw != NULL) {
 +      if (destroy_xdrawable)
 +         XFreePixmap(psc->dpy, pdraw->xDrawable);
 +      (*pdraw->destroyDrawable) (pdraw);
 +      __glxHashDelete(psc->drawHash, drawable);
 +   }
 +}
 +
 +#else
 +
 +static void
 +CreateDRIDrawable(Display *dpy, const __GLcontextModes * fbconfig,
 +                XID drawable, XID glxdrawable,
 +                const int *attrib_list, size_t num_attribs)
 +{
 +}
 +
 +static void
 +DestroyDRIDrawable(Display *dpy, GLXDrawable drawable, int destroy_xdrawable)
 +{
 +}
 +
  #endif
  
  /**
@@@ -320,7 -325,7 +326,7 @@@ GetDrawableAttribute(Display * dpy, GLX
              }
           }
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
           {
              __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
  
@@@ -386,7 -391,34 +392,7 @@@ CreateDrawable(Display * dpy, const __G
     UnlockDisplay(dpy);
     SyncHandle();
  
 -#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 -   do {
 -      /* FIXME: Maybe delay __DRIdrawable creation until the drawable
 -       * is actually bound to a context... */
 -
 -      __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
 -      __GLXDRIdrawable *pdraw;
 -      __GLXscreenConfigs *psc;
 -
 -      psc = &priv->screenConfigs[fbconfig->screen];
 -      if (psc->driScreen == NULL)
 -         break;
 -      pdraw = psc->driScreen->createDrawable(psc, drawable,
 -                                             req->glxwindow, fbconfig);
 -      if (pdraw == NULL) {
 -         fprintf(stderr, "failed to create drawable\n");
 -         break;
 -      }
 -
 -      if (__glxHashInsert(psc->drawHash, req->glxwindow, pdraw)) {
 -         (*pdraw->destroyDrawable) (pdraw);
 -         return None;           /* FIXME: Check what we're supposed to do here... */
 -      }
 -
 -      pdraw->textureTarget = determineTextureTarget(attrib_list, i);
 -      pdraw->textureFormat = determineTextureFormat(attrib_list, i);
 -   } while (0);
 -#endif
 +   CreateDRIDrawable(dpy, fbconfig, drawable, req->glxwindow, attrib_list, i);
  
     return (GLXDrawable) req->glxwindow;
  }
  
  /**
   * Destroy a non-pbuffer GLX drawable.
 - *
 - * \todo
 - * This function needs to be modified to work with direct-rendering drivers.
   */
  static void
  DestroyDrawable(Display * dpy, GLXDrawable drawable, CARD32 glxCode)
     UnlockDisplay(dpy);
     SyncHandle();
  
 -#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
 -   {
 -      int screen;
 -      __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
 -      __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
 -      __GLXscreenConfigs *psc = &priv->screenConfigs[screen];
 -
 -      if (pdraw != NULL) {
 -         (*pdraw->destroyDrawable) (pdraw);
 -         __glxHashDelete(psc->drawHash, drawable);
 -      }
 -   }
 -#endif
 +   DestroyDRIDrawable(dpy, drawable, GL_FALSE);
  
     return;
  }
@@@ -449,7 -496,6 +455,7 @@@ CreatePbuffer(Display * dpy, const __GL
     CARD32 *data;
     CARD8 opcode;
     unsigned int i;
 +   Pixmap pixmap;
  
     i = 0;
     if (attrib_list) {
     UnlockDisplay(dpy);
     SyncHandle();
  
 +   pixmap = XCreatePixmap(dpy, RootWindow(dpy, fbconfig->screen),
 +                        width, height, fbconfig->rgbBits);
 +
 +   CreateDRIDrawable(dpy, fbconfig, pixmap, id, attrib_list, i);
 +
     return id;
  }
  
 +/**
 + * Destroy a pbuffer.
 + *
 + * This function is used to implement \c glXDestroyPbuffer and
 + * \c glXDestroyGLXPbufferSGIX.
 + *
 + * \note
 + * This function dynamically determines whether to use the SGIX_pbuffer
 + * version of the protocol or the GLX 1.3 version of the protocol.
 + */
 +static void
 +DestroyPbuffer(Display * dpy, GLXDrawable drawable)
 +{
 +   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
 +   CARD8 opcode;
 +
 +   if ((dpy == NULL) || (drawable == 0)) {
 +      return;
 +   }
 +
 +   opcode = __glXSetupForCommand(dpy);
 +   if (!opcode)
 +      return;
 +
 +   LockDisplay(dpy);
 +
 +   if ((priv->majorVersion > 1) || (priv->minorVersion >= 3)) {
 +      xGLXDestroyPbufferReq *req;
 +
 +      GetReq(GLXDestroyPbuffer, req);
 +      req->reqType = opcode;
 +      req->glxCode = X_GLXDestroyPbuffer;
 +      req->pbuffer = (GLXPbuffer) drawable;
 +   }
 +   else {
 +      xGLXVendorPrivateWithReplyReq *vpreq;
 +      CARD32 *data;
 +
 +      GetReqExtra(GLXVendorPrivateWithReply, 4, vpreq);
 +      data = (CARD32 *) (vpreq + 1);
 +
 +      data[0] = (CARD32) drawable;
 +
 +      vpreq->reqType = opcode;
 +      vpreq->glxCode = X_GLXVendorPrivateWithReply;
 +      vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX;
 +   }
 +
 +   UnlockDisplay(dpy);
 +   SyncHandle();
 +
 +   DestroyDRIDrawable(dpy, drawable, GL_TRUE);
 +
 +   return;
 +}
 +
  /**
   * Create a new pbuffer.
   */
@@@ -586,6 -571,7 +592,7 @@@ glXCreateGLXPbufferSGIX(Display * dpy, 
                                           attrib_list, GL_FALSE);
  }
  
+ #endif /* GLX_USE_APPLEGL */
  
  /**
   * Create a new pbuffer.
@@@ -594,12 -580,57 +601,57 @@@ PUBLIC GLXPbuffe
  glXCreatePbuffer(Display * dpy, GLXFBConfig config, const int *attrib_list)
  {
     int i, width, height;
+ #ifdef GLX_USE_APPLEGL
+    GLXPbuffer result;
+    int errorcode;
+ #endif
  
     width = 0;
     height = 0;
  
     WARN_ONCE_GLX_1_3(dpy, __func__);
  
+ #ifdef GLX_USE_APPLEGL
+    for (i = 0; attrib_list[i]; ++i) {
+       switch (attrib_list[i]) {
+       case GLX_PBUFFER_WIDTH:
+          width = attrib_list[i + 1];
+          ++i;
+          break;
+       case GLX_PBUFFER_HEIGHT:
+          height = attrib_list[i + 1];
+          ++i;
+          break;
+       case GLX_LARGEST_PBUFFER:
+          /* This is a hint we should probably handle, but how? */
+          ++i;
+          break;
+       case GLX_PRESERVED_CONTENTS:
+          /* The contents are always preserved with AppleSGLX with CGL. */
+          ++i;
+          break;
+       default:
+          return None;
+       }
+    }
+    if (apple_glx_pbuffer_create(dpy, config, width, height, &errorcode,
+                                 &result)) {
+       /* 
+        * apple_glx_pbuffer_create only sets the errorcode to core X11
+        * errors. 
+        */
+       __glXSendError(dpy, errorcode, 0, X_GLXCreatePbuffer, true);
+       return None;
+    }
+    return result;
+ #else
     for (i = 0; attrib_list[i * 2]; i++) {
        switch (attrib_list[i * 2]) {
        case GLX_PBUFFER_WIDTH:
  
     return (GLXPbuffer) CreatePbuffer(dpy, (__GLcontextModes *) config,
                                       width, height, attrib_list, GL_TRUE);
+ #endif
  }
  
  
  PUBLIC void
  glXDestroyPbuffer(Display * dpy, GLXPbuffer pbuf)
  {
+ #ifdef GLX_USE_APPLEGL
+    if (apple_glx_pbuffer_destroy(dpy, pbuf)) {
+       __glXSendError(dpy, GLXBadPbuffer, pbuf, X_GLXDestroyPbuffer, false);
+    }
+ #else
     DestroyPbuffer(dpy, pbuf);
+ #endif
  }
  
  
@@@ -634,10 -672,47 +693,47 @@@ glXQueryDrawable(Display * dpy, GLXDraw
                   int attribute, unsigned int *value)
  {
     WARN_ONCE_GLX_1_3(dpy, __func__);
+ #ifdef GLX_USE_APPLEGL
+    Window root;
+    int x, y;
+    unsigned int width, height, bd, depth;
+    if (apple_glx_pixmap_query(drawable, attribute, value))
+       return;                   /*done */
+    if (apple_glx_pbuffer_query(drawable, attribute, value))
+       return;                   /*done */
+    /*
+     * The OpenGL spec states that we should report GLXBadDrawable if
+     * the drawable is invalid, however doing so would require that we
+     * use XSetErrorHandler(), which is known to not be thread safe.
+     * If we use a round-trip call to validate the drawable, there could
+     * be a race, so instead we just opt in favor of letting the
+     * XGetGeometry request fail with a GetGeometry request X error 
+     * rather than GLXBadDrawable, in what is hoped to be a rare
+     * case of an invalid drawable.  In practice most and possibly all
+     * X11 apps using GLX shouldn't notice a difference.
+     */
+    if (XGetGeometry
+        (dpy, drawable, &root, &x, &y, &width, &height, &bd, &depth)) {
+       switch (attribute) {
+       case GLX_WIDTH:
+          *value = width;
+          break;
+       case GLX_HEIGHT:
+          *value = height;
+          break;
+       }
+    }
+ #else
     GetDrawableAttribute(dpy, drawable, attribute, value);
+ #endif
  }
  
  
+ #ifndef GLX_USE_APPLEGL
  /**
   * Query an attribute of a pbuffer.
   */
@@@ -647,7 -722,7 +743,7 @@@ glXQueryGLXPbufferSGIX(Display * dpy, G
  {
     return GetDrawableAttribute(dpy, drawable, attribute, value);
  }
+ #endif
  
  /**
   * Select the event mask for a drawable.
  PUBLIC void
  glXSelectEvent(Display * dpy, GLXDrawable drawable, unsigned long mask)
  {
+ #ifdef GLX_USE_APPLEGL
+    XWindowAttributes xwattr;
+    if (apple_glx_pbuffer_set_event_mask(drawable, mask))
+       return;                   /*done */
+    /* 
+     * The spec allows a window, but currently there are no valid
+     * events for a window, so do nothing.
+     */
+    if (XGetWindowAttributes(dpy, drawable, &xwattr))
+       return;                   /*done */
+    /* The drawable seems to be invalid.  Report an error. */
+    __glXSendError(dpy, GLXBadDrawable, drawable,
+                   X_GLXChangeDrawableAttributes, false);
+ #else
     CARD32 attribs[2];
  
     attribs[0] = (CARD32) GLX_EVENT_MASK;
     attribs[1] = (CARD32) mask;
  
     ChangeDrawableAttribute(dpy, drawable, attribs, 1);
+ #endif
  }
  
  
  PUBLIC void
  glXGetSelectedEvent(Display * dpy, GLXDrawable drawable, unsigned long *mask)
  {
+ #ifdef GLX_USE_APPLEGL
+    XWindowAttributes xwattr;
+    if (apple_glx_pbuffer_get_event_mask(drawable, mask))
+       return;                   /*done */
+    /* 
+     * The spec allows a window, but currently there are no valid
+     * events for a window, so do nothing, but set the mask to 0.
+     */
+    if (XGetWindowAttributes(dpy, drawable, &xwattr)) {
+       /* The window is valid, so set the mask to 0. */
+       *mask = 0;
+       return;                   /*done */
+    }
+    /* The drawable seems to be invalid.  Report an error. */
+    __glXSendError(dpy, GLXBadDrawable, drawable, X_GLXGetDrawableAttributes,
+                   true);
+ #else
     unsigned int value;
  
  
  
     GetDrawableAttribute(dpy, drawable, GLX_EVENT_MASK_SGIX, &value);
     *mask = value;
+ #endif
  }
  
  
@@@ -689,8 -803,17 +824,17 @@@ glXCreatePixmap(Display * dpy, GLXFBCon
  {
     WARN_ONCE_GLX_1_3(dpy, __func__);
  
+ #ifdef GLX_USE_APPLEGL
+    const __GLcontextModes *modes = (const __GLcontextModes *) config;
+    if (apple_glx_pixmap_create(dpy, modes->screen, pixmap, modes))
+       return None;
+    return pixmap;
+ #else
     return CreateDrawable(dpy, (__GLcontextModes *) config,
                           (Drawable) pixmap, attrib_list, X_GLXCreatePixmap);
+ #endif
  }
  
  
@@@ -699,9 -822,33 +843,33 @@@ glXCreateWindow(Display * dpy, GLXFBCon
                  const int *attrib_list)
  {
     WARN_ONCE_GLX_1_3(dpy, __func__);
+ #ifdef GLX_USE_APPLEGL
+    XWindowAttributes xwattr;
+    XVisualInfo *visinfo;
+    (void) attrib_list;          /*unused according to GLX 1.4 */
+    XGetWindowAttributes(dpy, win, &xwattr);
  
+    visinfo = glXGetVisualFromFBConfig(dpy, config);
+    if (NULL == visinfo) {
+       __glXSendError(dpy, GLXBadFBConfig, 0, X_GLXCreateWindow, false);
+       return None;
+    }
+    if (visinfo->visualid != XVisualIDFromVisual(xwattr.visual)) {
+       __glXSendError(dpy, BadMatch, 0, X_GLXCreateWindow, true);
+       return None;
+    }
+    XFree(visinfo);
+    return win;
+ #else
     return CreateDrawable(dpy, (__GLcontextModes *) config,
                           (Drawable) win, attrib_list, X_GLXCreateWindow);
+ #endif
  }
  
  
@@@ -709,8 -856,12 +877,12 @@@ PUBLIC voi
  glXDestroyPixmap(Display * dpy, GLXPixmap pixmap)
  {
     WARN_ONCE_GLX_1_3(dpy, __func__);
+ #ifdef GLX_USE_APPLEGL
+    if (apple_glx_pixmap_destroy(dpy, pixmap))
+       __glXSendError(dpy, GLXBadPixmap, pixmap, X_GLXDestroyPixmap, false);
+ #else
     DestroyDrawable(dpy, (GLXDrawable) pixmap, X_GLXDestroyPixmap);
+ #endif
  }
  
  
@@@ -718,11 -869,12 +890,12 @@@ PUBLIC voi
  glXDestroyWindow(Display * dpy, GLXWindow win)
  {
     WARN_ONCE_GLX_1_3(dpy, __func__);
+ #ifndef GLX_USE_APPLEGL
     DestroyDrawable(dpy, (GLXDrawable) win, X_GLXDestroyWindow);
+ #endif
  }
  
+ #ifndef GLX_USE_APPLEGL
  PUBLIC
  GLX_ALIAS_VOID(glXDestroyGLXPbufferSGIX,
                 (Display * dpy, GLXPbufferSGIX pbuf),
@@@ -738,4 -890,4 +911,4 @@@ GLX_ALIAS_VOID(glXGetSelectedEventSGIX
                 (Display * dpy, GLXDrawable drawable,
                  unsigned long *mask), (dpy, drawable, mask),
                 glXGetSelectedEvent)
+ #endif
diff --combined src/glx/glxclient.h
index e4b2c63f775c83995f68187b7aacd489d16d5e29,958e1526c94ea6c3ea20814ca961fd9f5252e6a4..57d254ea9873f54fe3ecae6e5ef0cb979d7c6735
@@@ -97,8 -97,13 +97,13 @@@ typedef struct _glapi_table __GLapi
  #define containerOf(ptr, type, member)              \
      (type *)( (char *)ptr - offsetof(type,member) )
  
- #include <GL/internal/dri_interface.h>
+ extern void DRI_glXUseXFont(Font font, int first, int count, int listbase);
+ #endif
  
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
+ #include <GL/internal/dri_interface.h>
  
  /**
   * Display dependent methods.  This structure is initialized during the
@@@ -185,8 -190,6 +190,6 @@@ extern __GLXDRIdisplay *dri2CreateDispl
  extern void dri2InvalidateBuffers(Display *dpy, XID drawable);
  
  
- extern void DRI_glXUseXFont(Font font, int first, int count, int listbase);
  /*
  ** Functions to obtain driver configuration information from a direct
  ** rendering client application
@@@ -405,8 -408,13 +408,13 @@@ struct __GLXcontextRe
     const __GLcontextModes *mode;
  
  #ifdef GLX_DIRECT_RENDERING
+ #ifdef GLX_USE_APPLEGL
+    void *driContext;
+    Bool do_destroy;
+ #else
     __GLXDRIcontext *driContext;
     __DRIcontext *__driContext;
+ #endif
  #endif
  
      /**
@@@ -503,7 -511,7 +511,7 @@@ struct __GLXscreenConfigsRe
       */
     char *effectiveGLXexts;
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
      /**
       * Per screen direct rendering interface functions and data.
       */
     const __DRI2flushExtension *f;
  #endif
  
 +#ifdef __DRI2_CONFIG_QUERY
 +   const __DRI2configQueryExtension *config;
 +#endif
 +
  #endif
  
      /**
@@@ -618,7 -622,7 +626,7 @@@ struct __GLXdisplayPrivateRe
       */
     __GLXscreenConfigs *screenConfigs;
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
      /**
       * Per display direct rendering interface functions and data.
       */
@@@ -796,7 -800,7 +804,7 @@@ extern GLboolean __glXGetMscRateOML(Dis
                                      int32_t * numerator,
                                      int32_t * denominator);
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
  GLboolean
  __driGetMscRateOML(__DRIdrawable * draw,
                     int32_t * numerator, int32_t * denominator, void *private);
diff --combined src/glx/glxcmds.c
index e256a078f196e394bdb5b4833d4752454420c15a,e74ae3472e526ffbaeb8a5a304a7523386afb5eb..be9d6f29c01e6770dcccfe08eca27d73d355b67e
  #include "glcontextmodes.h"
  
  #ifdef GLX_DIRECT_RENDERING
+ #ifdef GLX_USE_APPLEGL
+ #include "apple_glx_context.h"
+ #include "apple_glx.h"
+ #include "glx_error.h"
+ #define GC_IS_DIRECT(gc) ((gc)->isDirect)
+ #else
  #include <sys/time.h>
  #include <X11/extensions/xf86vmode.h>
  #include "xf86dri.h"
  #define GC_IS_DIRECT(gc) ((gc)->driContext != NULL)
+ #endif
  #else
  #define GC_IS_DIRECT(gc) (0)
  #endif
@@@ -59,7 -66,7 +66,7 @@@ static const char __glXGLXClientVersion
  
  /****************************************************************************/
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
  
  static Bool windowExistsFlag;
  static int
@@@ -344,6 -351,12 +351,12 @@@ AllocateGLXContext(Display * dpy
        bufSize = __GLX_MAX_RENDER_CMD_SIZE;
     }
     gc->maxSmallRenderCommandSize = bufSize;
+    
+ #ifdef GLX_USE_APPLEGL
+    gc->driContext = NULL;
+    gc->do_destroy = False;   
+ #endif
     return gc;
  }
  
@@@ -366,9 -379,14 +379,14 @@@ CreateContext(Display * dpy, int generi
  {
     GLXContext gc;
  #ifdef GLX_DIRECT_RENDERING
+ #ifdef GLX_USE_APPLEGL
+    int errorcode;
+    bool x11error;
+ #else
     __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
  #endif
+ #endif
+     
     if (dpy == NULL)
        return NULL;
  
     if (!gc)
        return NULL;
  
+ #ifndef GLX_USE_APPLEGL  /* TODO: darwin indirect */
  #ifdef GLX_DIRECT_RENDERING
     if (allowDirect && psc->driScreen) {
        gc->driContext = psc->driScreen->createContext(psc, fbconfig, gc,
  
     UnlockDisplay(dpy);
     SyncHandle();
+ #endif
  
     gc->imported = GL_FALSE;
     gc->renderType = renderType;
  
+    /* TODO: darwin: Integrate with above to do indirect */
+ #ifdef GLX_USE_APPLEGL
+    if(apple_glx_create_context(&gc->driContext, dpy, screen, fbconfig, 
+                                shareList ? shareList->driContext : NULL,
+                                &errorcode, &x11error)) {
+       __glXSendError(dpy, errorcode, 0, X_GLXCreateContext, x11error);
+       __glXFreeContext(gc);
+       return NULL;
+    }
+    
+    gc->currentContextTag = -1;
+    gc->mode = fbconfig;
+    gc->isDirect = allowDirect;
+ #endif
     return gc;
  }
  
@@@ -469,7 -504,7 +504,7 @@@ glXCreateContext(Display * dpy, XVisual
     const __GLcontextModes *mode = NULL;
     int renderType = 0;
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) || defined(GLX_USE_APPLEGL)
     __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, vis->screen);
  
     mode = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
@@@ -517,6 -552,7 +552,7 @@@ __glXFreeContext(__GLXcontext * gc
  static void
  DestroyContext(Display * dpy, GLXContext gc)
  {
+ #ifndef GLX_USE_APPLEGL /* TODO: darwin: indirect */
     xGLXDestroyContextReq *req;
     GLXContextID xid;
     CARD8 opcode;
        return;
     }
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     /* Destroy the direct rendering context */
     if (gc->driContext) {
        (*gc->driContext->destroyContext) (gc->driContext, gc->psc, dpy);
  #endif
  
     __glXFreeVertexArrayState(gc);
+ #else
+    __glXLock();
+ #endif /* GLX_USE_APPLEGL */   
  
     if (gc->currentDpy) {
+ #ifdef GLX_USE_APPLEGL
+       /* 
+        * Set the Bool that indicates that we should destroy this GLX context
+        * when the context is no longer current.
+        */
+       gc->do_destroy = True;
+ #endif
        /* Have to free later cuz it's in use now */
        __glXUnlock();
     }
     else {
        /* Destroy the handle if not current to anybody */
        __glXUnlock();
+ #ifdef GLX_USE_APPLEGL
+       if(gc->driContext)
+          apple_glx_destroy_context(&gc->driContext, dpy);
+ #endif
        __glXFreeContext(gc);
     }
+ #ifndef GLX_USE_APPLEGL
     if (!imported) {
        /*
         ** This dpy also created the server side part of the context.
        UnlockDisplay(dpy);
        SyncHandle();
     }
+ #endif
  }
  
  PUBLIC void
@@@ -630,7 -681,9 +681,9 @@@ glXQueryExtension(Display * dpy, int *e
  PUBLIC void
  glXWaitGL(void)
  {
+ #ifndef GLX_USE_APPLEGL
     xGLXWaitGLReq *req;
+ #endif
     GLXContext gc = __glXGetCurrentContext();
     Display *dpy = gc->currentDpy;
  
  
     /* Flush any pending commands out */
     __glXFlushRenderBuffer(gc, gc->pc);
- #ifdef GLX_DIRECT_RENDERING
+ #ifdef GLX_USE_APPLEGL
+    glFinish();
+ #else
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     if (gc->driContext) {
        int screen;
        __GLXDRIdrawable *pdraw =
     req->contextTag = gc->currentContextTag;
     UnlockDisplay(dpy);
     SyncHandle();
+ #endif /* GLX_USE_APPLEGL */
  }
  
  /*
  PUBLIC void
  glXWaitX(void)
  {
+ #ifndef GLX_USE_APPLEGL
     xGLXWaitXReq *req;
+ #endif
     GLXContext gc = __glXGetCurrentContext();
     Display *dpy = gc->currentDpy;
  
     /* Flush any pending commands out */
     __glXFlushRenderBuffer(gc, gc->pc);
  
- #ifdef GLX_DIRECT_RENDERING
+ #ifdef GLX_USE_APPLEGL
+    apple_glx_waitx(dpy, gc->driContext);
+ #else
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     if (gc->driContext) {
        int screen;
        __GLXDRIdrawable *pdraw =
     req->contextTag = gc->currentContextTag;
     UnlockDisplay(dpy);
     SyncHandle();
+ #endif /* GLX_USE_APPLEGL */
  }
  
  PUBLIC void
  glXUseXFont(Font font, int first, int count, int listBase)
  {
+ #ifndef GLX_USE_APPLEGL
     xGLXUseXFontReq *req;
+ #endif
     GLXContext gc = __glXGetCurrentContext();
     Display *dpy = gc->currentDpy;
  
  
     /* Flush any pending commands out */
     (void) __glXFlushRenderBuffer(gc, gc->pc);
- #ifdef GLX_DIRECT_RENDERING
+ #ifdef GLX_USE_APPLEGL
+    DRI_glXUseXFont(font, first, count, listBase); 
+ #else
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     if (gc->driContext) {
        DRI_glXUseXFont(font, first, count, listBase);
        return;
     req->listBase = listBase;
     UnlockDisplay(dpy);
     SyncHandle();
+ #endif /* GLX_USE_APPLEGL */
  }
  
  /************************************************************************/
@@@ -756,6 -823,17 +823,17 @@@ PUBLIC voi
  glXCopyContext(Display * dpy, GLXContext source,
                 GLXContext dest, unsigned long mask)
  {
+ #ifdef GLX_USE_APPLEGL
+    GLXContext gc = __glXGetCurrentContext();
+    int errorcode;
+    bool x11error;
+    if(apple_glx_copy_context(gc->driContext, source->driContext, dest->driContext,
+                              mask, &errorcode, &x11error)) {
+       __glXSendError(dpy, errorcode, 0, X_GLXCopyContext, x11error);
+    }
+    
+ #else
     xGLXCopyContextReq *req;
     GLXContext gc = __glXGetCurrentContext();
     GLXContextTag tag;
        return;
     }
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     if (gc->driContext) {
        /* NOT_DONE: This does not work yet */
     }
     req->contextTag = tag;
     UnlockDisplay(dpy);
     SyncHandle();
+ #endif /* GLX_USE_APPLEGL */
  }
  
  
  static Bool
  __glXIsDirect(Display * dpy, GLXContextID contextID)
  {
+ #ifndef GLX_USE_APPLEGL /* TODO: apple indirect */
+    return GC_IS_DIRECT(gc);
+ #else
  #if !defined(USE_XCB)
     xGLXIsDirectReq *req;
     xGLXIsDirectReply reply;
  
     return reply.isDirect;
  #endif /* USE_XCB */
+ #endif /* GLX_USE_APPLEGL */
  }
  
  /**
@@@ -866,6 -949,18 +949,18 @@@ glXIsDirect(Display * dpy, GLXContext g
  PUBLIC GLXPixmap
  glXCreateGLXPixmap(Display * dpy, XVisualInfo * vis, Pixmap pixmap)
  {
+ #ifdef GLX_USE_APPLEGL
+    int screen = vis->screen;
+    __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
+    const __GLcontextModes *modes;
+    modes = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
+    
+    if(apple_glx_pixmap_create(dpy, vis->screen, pixmap, modes))
+       return None;
+    
+    return pixmap;
+ #else
     xGLXCreateGLXPixmapReq *req;
     GLXPixmap xid;
     CARD8 opcode;
     UnlockDisplay(dpy);
     SyncHandle();
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     do {
        /* FIXME: Maybe delay __DRIdrawable creation until the drawable
         * is actually bound to a context... */
  #endif
  
     return xid;
+ #endif
  }
  
  /*
  PUBLIC void
  glXDestroyGLXPixmap(Display * dpy, GLXPixmap glxpixmap)
  {
+ #ifdef GLX_USE_APPLEGL
+    if(apple_glx_pixmap_destroy(dpy, glxpixmap))
+       __glXSendError(dpy, GLXBadPixmap, glxpixmap, X_GLXDestroyPixmap, false);
+ #else
     xGLXDestroyGLXPixmapReq *req;
     CARD8 opcode;
  
     UnlockDisplay(dpy);
     SyncHandle();
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     {
        int screen;
        __GLXdisplayPrivate *const priv = __glXInitialize(dpy);
        }
     }
  #endif
+ #endif /* GLX_USE_APPLEGL */
  }
  
  PUBLIC void
  glXSwapBuffers(Display * dpy, GLXDrawable drawable)
  {
+ #ifdef GLX_USE_APPLEGL
+    GLXContext gc = glXGetCurrentContext();
+    if(gc && apple_glx_is_current_drawable(dpy, gc->driContext, drawable)) {
+       apple_glx_swap_buffers(gc->driContext);
+    } else {
+       __glXSendError(dpy, GLXBadCurrentWindow, 0, X_GLXSwapBuffers, false);
+    }
+ #else
     GLXContext gc;
     GLXContextTag tag;
     CARD8 opcode;
     xGLXSwapBuffersReq *req;
  #endif
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
  
     if (pdraw != NULL) {
     SyncHandle();
     XFlush(dpy);
  #endif /* USE_XCB */
+ #endif /* GLX_USE_APPLEGL */
  }
  
  
@@@ -1440,6 -1550,12 +1550,12 @@@ glXChooseVisual(Display * dpy, int scre
        }
     }
  
+ #ifdef GLX_USE_APPLEGL
+    if(visualList && getenv("LIBGL_DUMP_VISUALID")) {
+       printf("visualid 0x%lx\n", visualList[0].visualid);
+    }
+ #endif
     return visualList;
  }
  
@@@ -1462,7 -1578,7 +1578,7 @@@ glXQueryExtensionsString(Display * dpy
        }
  
        __glXCalculateUsableExtensions(psc,
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
                                       (psc->driScreen != NULL),
  #else
                                       GL_FALSE,
@@@ -1573,6 -1689,7 +1689,7 @@@ PUBLI
  GLX_ALIAS(Display *, glXGetCurrentDisplayEXT, (void), (),
            glXGetCurrentDisplay)
  
+ #ifndef GLX_USE_APPLEGL
  /**
   * Used internally by libGL to send \c xGLXQueryContextinfoExtReq requests
   * to the X-server.
@@@ -1684,13 -1801,16 +1801,16 @@@ static int __glXQueryContextInfo(Displa
     return retval;
  }
  
+ #endif
  PUBLIC int
  glXQueryContext(Display * dpy, GLXContext ctx, int attribute, int *value)
  {
+ #ifndef GLX_USE_APPLEGL
     int retVal;
  
     /* get the information from the server if we don't have it already */
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     if (!ctx->driContext && (ctx->mode == NULL)) {
  #else
     if (ctx->mode == NULL) {
        if (Success != retVal)
           return retVal;
     }
+ #endif
     switch (attribute) {
-    case GLX_SHARE_CONTEXT_EXT:
+ #ifndef GLX_USE_APPLEGL
+       case GLX_SHARE_CONTEXT_EXT:
        *value = (int) (ctx->share_xid);
        break;
     case GLX_VISUAL_ID_EXT:
        *value = ctx->mode ? ctx->mode->visualID : None;
        break;
+ #endif
     case GLX_SCREEN:
        *value = (int) (ctx->screen);
        break;
@@@ -1734,6 -1858,9 +1858,9 @@@ PUBLIC GLXContextID glXGetContextIDEXT(
  PUBLIC GLXContext
  glXImportContextEXT(Display * dpy, GLXContextID contextID)
  {
+ #ifdef GLX_USE_APPLEGL
+    return NULL;
+ #else
     GLXContext ctx;
  
     if (contextID == None) {
        }
     }
     return ctx;
+ #endif
  }
  
  PUBLIC void
@@@ -1881,7 -2009,7 +2009,7 @@@ glXGetVisualFromFBConfig(Display * dpy
     return XGetVisualInfo(dpy, VisualIDMask, &visualTemplate, &count);
  }
  
+ #ifndef GLX_USE_APPLEGL
  /*
  ** GLX_SGI_swap_control
  */
@@@ -2236,6 -2364,7 +2364,7 @@@ __glXWaitVideoSyncSGI(int divisor, int 
     return GLX_BAD_CONTEXT;
  }
  
+ #endif /* GLX_USE_APPLEGL */
  
  /*
  ** GLX_SGIX_fbconfig
@@@ -2262,17 -2391,24 +2391,24 @@@ glXCreateGLXPixmapWithConfigSGIX(Displa
                                   GLXFBConfigSGIX config,
                                   Pixmap pixmap)
  {
+ #ifndef GLX_USE_APPLEGL
     xGLXVendorPrivateWithReplyReq *vpreq;
     xGLXCreateGLXPixmapWithConfigSGIXReq *req;
     GLXPixmap xid = None;
     CARD8 opcode;
-    const __GLcontextModes *const fbconfig = (__GLcontextModes *) config;
     __GLXscreenConfigs *psc;
+ #endif
+    const __GLcontextModes *const fbconfig = (__GLcontextModes *) config;
  
  
     if ((dpy == NULL) || (config == NULL)) {
        return None;
     }
+ #ifdef GLX_USE_APPLEGL
+    if(apple_glx_pixmap_create(dpy, fbconfig->screen, pixmap, fbconfig))
+       return None;
+    return pixmap;
+ #else
  
     psc = GetGLXScreenConfigs(dpy, fbconfig->screen);
     if ((psc != NULL)
     }
  
     return xid;
+ #endif
  }
  
  PUBLIC GLXContext
@@@ -2345,7 -2482,7 +2482,7 @@@ glXGetFBConfigFromVisualSGIX(Display * 
     return NULL;
  }
  
+ #ifndef GLX_USE_APPLEGL
  /*
  ** GLX_SGIX_swap_group
  */
@@@ -2420,7 -2557,7 +2557,7 @@@ __glXGetSyncValuesOML(Display * dpy, GL
     return False;
  }
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
  _X_HIDDEN GLboolean
  __driGetMscRateOML(__DRIdrawable * draw,
                     int32_t * numerator, int32_t * denominator, void *private)
@@@ -2556,9 -2693,6 +2693,9 @@@ __glXSwapBuffersMscOML(Display * dpy, G
     if (divisor > 0 && remainder >= divisor)
        return -1;
  
 +   if (target_msc == 0 && divisor == 0 && remainder == 0)
 +      remainder = 1;
 +
  #ifdef __DRI_SWAP_BUFFER_COUNTER
     if (psc->counters != NULL)
        return (*psc->sbc->swapBuffersMSC)(pdraw->driDrawable, target_msc,
@@@ -2876,7 -3010,7 +3013,7 @@@ __glXBindTexImageEXT(Display * dpy
           i++;
     }
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     if (gc->driContext) {
        __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL);
  
@@@ -2966,6 -3100,8 +3103,8 @@@ __glXReleaseTexImageEXT(Display * dpy, 
  
  /*@}*/
  
+ #endif /* GLX_USE_APPLEGL */
  /**
   * \c strdup is actually not a standard ANSI C or POSIX routine.
   * Irix will not define it if ANSI mode is in effect.
@@@ -3043,6 -3179,7 +3182,7 @@@ static const struct name_address_pair G
     GLX_FUNCTION(glXQueryDrawable),
     GLX_FUNCTION(glXSelectEvent),
  
+ #ifndef GLX_USE_APPLEGL
     /*** GLX_SGI_swap_control ***/
     GLX_FUNCTION2(glXSwapIntervalSGI, __glXSwapIntervalSGI),
  
     GLX_FUNCTION2(glXGetCurrentDisplayEXT, glXGetCurrentDisplay),
     GLX_FUNCTION(glXImportContextEXT),
     GLX_FUNCTION2(glXQueryContextInfoEXT, glXQueryContext),
+ #endif
  
     /*** GLX_SGIX_fbconfig ***/
     GLX_FUNCTION2(glXGetFBConfigAttribSGIX, glXGetFBConfigAttrib),
     GLX_FUNCTION2(glXGetVisualFromFBConfigSGIX, glXGetVisualFromFBConfig),
     GLX_FUNCTION(glXGetFBConfigFromVisualSGIX),
  
+ #ifndef GLX_USE_APPLEGL
     /*** GLX_SGIX_pbuffer ***/
     GLX_FUNCTION(glXCreateGLXPbufferSGIX),
     GLX_FUNCTION(glXDestroyGLXPbufferSGIX),
     GLX_FUNCTION2(glXEndFrameTrackingMESA, __glXEndFrameTrackingMESA),
     GLX_FUNCTION2(glXGetFrameUsageMESA, __glXGetFrameUsageMESA),
     GLX_FUNCTION2(glXQueryFrameTrackingMESA, __glXQueryFrameTrackingMESA),
+ #endif
  
     /*** GLX_ARB_get_proc_address ***/
     GLX_FUNCTION(glXGetProcAddressARB),
     /*** GLX 1.4 ***/
     GLX_FUNCTION2(glXGetProcAddress, glXGetProcAddressARB),
  
+ #ifndef GLX_USE_APPLEGL
     /*** GLX_OML_sync_control ***/
     GLX_FUNCTION2(glXWaitForSbcOML, __glXWaitForSbcOML),
     GLX_FUNCTION2(glXWaitForMscOML, __glXWaitForMscOML),
     /*** GLX_EXT_texture_from_pixmap ***/
     GLX_FUNCTION2(glXBindTexImageEXT, __glXBindTexImageEXT),
     GLX_FUNCTION2(glXReleaseTexImageEXT, __glXReleaseTexImageEXT),
+ #endif
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
     /*** DRI configuration ***/
     GLX_FUNCTION(glXGetScreenDriver),
     GLX_FUNCTION(glXGetDriverConfig),
     {NULL, NULL}                 /* end of list */
  };
  
+ #ifndef GLX_USE_APPLEGL
  static const GLvoid *
  get_glx_proc_address(const char *funcName)
  {
  
     return NULL;
  }
+ #endif
  
  /**
   * Get the address of a named GL function.  This is the pre-GLX 1.4 name for
@@@ -3170,13 -3312,15 +3315,15 @@@ PUBLIC void (*glXGetProcAddressARB(cons
      * DRI based drivers from searching the core GL function table for
      * internal API functions.
      */
+ #ifdef GLX_USE_APPLEGL
+    f = (gl_function) apple_glx_get_proc_address(procName);
+ #else
     f = (gl_function) get_glx_proc_address((const char *) procName);
     if ((f == NULL) && (procName[0] == 'g') && (procName[1] == 'l')
         && (procName[2] != 'X')) {
        f = (gl_function) _glapi_get_proc_address((const char *) procName);
     }
+ #endif
     return f;
  }
  
@@@ -3199,7 -3343,7 +3346,7 @@@ PUBLIC void (*glXGetProcAddress(const G
  #endif /* __GNUC__ */
  
  
- #ifdef GLX_DIRECT_RENDERING
+ #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
  /**
   * Get the unadjusted system time (UST).  Currently, the UST is measured in
   * microseconds since Epoc.  The actual resolution of the UST may vary from