git.oblomov.eu Git - wine/blob - dlls/winemac.drv/opengl.c

   1 /*
   2  * Mac driver OpenGL support
   3  *
   4  * Copyright 2012 Alexandre Julliard
   5  * Copyright 2012, 2013 Ken Thomases for CodeWeavers Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include "macdrv.h"
  26
  27 #include "winuser.h"
  28 #include "winternl.h"
  29 #include "wine/library.h"
  30 #include "wine/debug.h"
  31 #include "wine/wgl.h"
  32 #include "wine/wgl_driver.h"
  33 #include "wine/wglext.h"
  34
  35 #define __gl_h_
  36 #define __gltypes_h_
  37 #include <OpenGL/OpenGL.h>
  38 #include <OpenGL/glu.h>
  39 #include <OpenGL/CGLRenderers.h>
  40 #include <dlfcn.h>
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
  43
  44
  45 struct gl_info {
  46     char *glVersion;
  47     char *glExtensions;
  48
  49     char wglExtensions[4096];
  50
  51     GLint max_viewport_dims[2];
  52 };
  53
  54 static struct gl_info gl_info;
  55
  56
  57 struct wgl_context
  58 {
  59     HDC                     hdc;
  60     int                     format;
  61     macdrv_opengl_context   context;
  62     CGLContextObj           cglcontext;
  63     macdrv_view             draw_view;
  64     struct wgl_pbuffer     *draw_pbuffer;
  65     macdrv_view             read_view;
  66     struct wgl_pbuffer     *read_pbuffer;
  67     BOOL                    has_been_current;
  68     BOOL                    sharing;
  69 };
  70
  71
  72 struct wgl_pbuffer
  73 {
  74     CGLPBufferObj   pbuffer;
  75     int             format;
  76     BOOL            no_texture;
  77     int             max_level;
  78     GLint           level;
  79     GLenum          face;
  80 };
  81
  82 static CFMutableDictionaryRef dc_pbuffers;
  83
  84 static CRITICAL_SECTION dc_pbuffers_section;
  85 static CRITICAL_SECTION_DEBUG dc_pbuffers_section_debug =
  86 {
  87     0, 0, &dc_pbuffers_section,
  88     { &dc_pbuffers_section_debug.ProcessLocksList, &dc_pbuffers_section_debug.ProcessLocksList },
  89       0, 0, { (DWORD_PTR)(__FILE__ ": dc_pbuffers_section") }
  90 };
  91 static CRITICAL_SECTION dc_pbuffers_section = { &dc_pbuffers_section_debug, -1, 0, 0, 0, 0 };
  92
  93
  94 static struct opengl_funcs opengl_funcs;
  95
  96 #define USE_GL_FUNC(name) #name,
  97 static const char *opengl_func_names[] = { ALL_WGL_FUNCS };
  98 #undef USE_GL_FUNC
  99
 100
 101 static void (*pglCopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y,
 102                                  GLsizei width);
 103 static void (*pglCopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
 104 static void (*pglReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height,
 105                              GLenum format, GLenum type, void *pixels);
 106 static void (*pglViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
 107
 108
 109 struct color_mode {
 110     GLint   mode;
 111     int     bits_per_pixel;
 112     GLint   color_bits; /* including alpha_bits */
 113     int     red_bits, red_shift;
 114     int     green_bits, green_shift;
 115     int     blue_bits, blue_shift;
 116     GLint   alpha_bits, alpha_shift;
 117     BOOL    is_float;
 118     int     color_ordering;
 119 };
 120
 121 /* The value of "color_ordering" is somewhat arbitrary.  It incorporates some
 122    observations of the behavior of Windows systems, but also subjective judgments
 123    about what color formats are more "normal" than others.
 124
 125    On at least some Windows systems, integer color formats are listed before
 126    floating-point formats.  Within the integer formats, higher color bits were
 127    usually listed before lower color bits, while for floating-point formats it
 128    was the reverse.  However, that leads D3D to select 64-bit integer formats in
 129    preference to 32-bit formats when the latter would be sufficient.  It seems
 130    that a 32-bit format is much more likely to be normally used in that case.
 131
 132    Also, there are certain odd color formats supported on the Mac which seem like
 133    they would be less appropriate than more common ones.  For instance, the color
 134    formats with alpha in a separate byte (e.g. kCGLRGB888A8Bit with R8G8B8 in one
 135    32-bit value and A8 in a separate 8-bit value) and the formats with 10-bit RGB
 136    components.
 137
 138    For two color formats which differ only in whether or not they have alpha bits,
 139    we use the same ordering.  pixel_format_comparator() gives alpha bits a
 140    different weight than color formats.
 141  */
 142 static const struct color_mode color_modes[] = {
 143     { kCGLRGB444Bit,        16,     12,     4,  8,      4,  4,      4,  0,      0,  0,  FALSE,  5 },
 144     { kCGLARGB4444Bit,      16,     16,     4,  8,      4,  4,      4,  0,      4,  12, FALSE,  5 },
 145     { kCGLRGB444A8Bit,      24,     20,     4,  8,      4,  4,      4,  0,      8,  16, FALSE,  10 },
 146     { kCGLRGB555Bit,        16,     15,     5,  10,     5,  5,      5,  0,      0,  0,  FALSE,  4 },
 147     { kCGLARGB1555Bit,      16,     16,     5,  10,     5,  5,      5,  0,      1,  15, FALSE,  4 },
 148     { kCGLRGB555A8Bit,      24,     23,     5,  10,     5,  5,      5,  0,      8,  16, FALSE,  9 },
 149     { kCGLRGB565Bit,        16,     16,     5,  11,     6,  5,      5,  0,      0,  0,  FALSE,  3 },
 150     { kCGLRGB565A8Bit,      24,     24,     5,  11,     6,  5,      5,  0,      8,  16, FALSE,  8 },
 151     { kCGLRGB888Bit,        32,     24,     8,  16,     8,  8,      8,  0,      0,  0,  FALSE,  0 },
 152     { kCGLARGB8888Bit,      32,     32,     8,  16,     8,  8,      8,  0,      8,  24, FALSE,  0 },
 153     { kCGLRGB888A8Bit,      40,     32,     8,  16,     8,  8,      8,  0,      8,  32, FALSE,  7 },
 154     { kCGLRGB101010Bit,     32,     30,     10, 20,     10, 10,     10, 0,      0,  0,  FALSE,  6 },
 155     { kCGLARGB2101010Bit,   32,     32,     10, 20,     10, 10,     10, 0,      2,  30, FALSE,  6 },
 156     { kCGLRGB101010_A8Bit,  40,     38,     10, 20,     10, 10,     10, 0,      8,  32, FALSE,  11 },
 157     { kCGLRGB121212Bit,     48,     36,     12, 24,     12, 12,     12, 0,      0,  0,  FALSE,  2 },
 158     { kCGLARGB12121212Bit,  48,     48,     12, 24,     12, 12,     12, 0,      12, 36, FALSE,  2 },
 159     { kCGLRGB161616Bit,     64,     48,     16, 48,     16, 32,     16, 16,     0,  0,  FALSE,  1 },
 160     { kCGLRGBA16161616Bit,  64,     64,     16, 48,     16, 32,     16, 16,     16, 0,  FALSE,  1 },
 161     { kCGLRGBFloat64Bit,    64,     48,     16, 32,     16, 16,     16, 0,      0,  0,  TRUE,   12 },
 162     { kCGLRGBAFloat64Bit,   64,     64,     16, 48,     16, 32,     16, 16,     16, 0,  TRUE,   12 },
 163     { kCGLRGBFloat128Bit,   128,    96,     32, 96,     32, 64,     32, 32,     0,  0,  TRUE,   13 },
 164     { kCGLRGBAFloat128Bit,  128,    128,    32, 96,     32, 64,     32, 32,     32, 0,  TRUE,   13 },
 165     { kCGLRGBFloat256Bit,   256,    192,    64, 192,    64, 128,    64, 64,     0,  0,  TRUE,   14 },
 166     { kCGLRGBAFloat256Bit,  256,    256,    64, 192,    64, 128,    64, 64,     64, 0,  TRUE,   15 },
 167 };
 168
 169
 170 static const struct {
 171     GLint   mode;
 172     int     bits;
 173 } depth_stencil_modes[] = {
 174     { kCGL0Bit,     0 },
 175     { kCGL1Bit,     1 },
 176     { kCGL2Bit,     2 },
 177     { kCGL3Bit,     3 },
 178     { kCGL4Bit,     4 },
 179     { kCGL5Bit,     5 },
 180     { kCGL6Bit,     6 },
 181     { kCGL8Bit,     8 },
 182     { kCGL10Bit,    10 },
 183     { kCGL12Bit,    12 },
 184     { kCGL16Bit,    16 },
 185     { kCGL24Bit,    24 },
 186     { kCGL32Bit,    32 },
 187     { kCGL48Bit,    48 },
 188     { kCGL64Bit,    64 },
 189     { kCGL96Bit,    96 },
 190     { kCGL128Bit,   128 },
 191 };
 192
 193
 194 typedef struct {
 195     GLint   renderer_id;
 196     GLint   buffer_modes;
 197     GLint   color_modes;
 198     GLint   accum_modes;
 199     GLint   depth_modes;
 200     GLint   stencil_modes;
 201     GLint   max_aux_buffers;
 202     GLint   max_sample_buffers;
 203     GLint   max_samples;
 204     BOOL    offscreen;
 205     BOOL    accelerated;
 206     BOOL    backing_store;
 207     BOOL    window;
 208     BOOL    online;
 209 } renderer_properties;
 210
 211
 212 typedef struct {
 213     unsigned int window:1;
 214     unsigned int pbuffer:1;
 215     unsigned int accelerated:1;
 216     unsigned int color_mode:5; /* index into color_modes table */
 217     unsigned int aux_buffers:3;
 218     unsigned int depth_bits:8;
 219     unsigned int stencil_bits:8;
 220     unsigned int accum_mode:5; /* 1 + index into color_modes table (0 means no accum buffer) */
 221     unsigned int double_buffer:1;
 222     unsigned int stereo:1;
 223     unsigned int sample_buffers:1;
 224     unsigned int samples:5;
 225     unsigned int backing_store:1;
 226 } pixel_format;
 227
 228
 229 typedef union
 230 {
 231     pixel_format    format;
 232     UInt64          code;
 233 } pixel_format_or_code;
 234
 235
 236 static pixel_format *pixel_formats;
 237 static int nb_formats, nb_displayable_formats;
 238
 239
 240 static void *opengl_handle;
 241
 242
 243 static BOOL get_renderer_property(CGLRendererInfoObj renderer_info, GLint renderer_index,
 244                                   CGLRendererProperty property, GLint *value)
 245 {
 246     CGLError err = CGLDescribeRenderer(renderer_info, renderer_index, property, value);
 247     if (err != kCGLNoError)
 248         WARN("CGLDescribeRenderer failed for property %d: %d %s\n", property, err, CGLErrorString(err));
 249     return (err == kCGLNoError);
 250 }
 251
 252
 253 static void get_renderer_properties(CGLRendererInfoObj renderer_info, int renderer_index, renderer_properties* properties)
 254 {
 255     GLint value;
 256
 257     memset(properties, 0, sizeof(*properties));
 258
 259     if (get_renderer_property(renderer_info, renderer_index, kCGLRPRendererID, &value))
 260         properties->renderer_id = value & kCGLRendererIDMatchingMask;
 261
 262     if (get_renderer_property(renderer_info, renderer_index, kCGLRPBufferModes, &value))
 263         properties->buffer_modes = value;
 264
 265     if (get_renderer_property(renderer_info, renderer_index, kCGLRPColorModes, &value))
 266         properties->color_modes = value;
 267
 268     if (get_renderer_property(renderer_info, renderer_index, kCGLRPAccumModes, &value))
 269         properties->accum_modes = value;
 270
 271     if (get_renderer_property(renderer_info, renderer_index, kCGLRPDepthModes, &value))
 272         properties->depth_modes = value;
 273
 274     if (get_renderer_property(renderer_info, renderer_index, kCGLRPStencilModes, &value))
 275         properties->stencil_modes = value;
 276
 277     if (get_renderer_property(renderer_info, renderer_index, kCGLRPMaxAuxBuffers, &value))
 278         properties->max_aux_buffers = value;
 279
 280     if (get_renderer_property(renderer_info, renderer_index, kCGLRPMaxSampleBuffers, &value))
 281         properties->max_sample_buffers = value;
 282
 283     if (get_renderer_property(renderer_info, renderer_index, kCGLRPMaxSamples, &value))
 284         properties->max_samples = value;
 285
 286     if (get_renderer_property(renderer_info, renderer_index, kCGLRPOffScreen, &value))
 287         properties->offscreen = (value != 0);
 288
 289     if (get_renderer_property(renderer_info, renderer_index, kCGLRPAccelerated, &value))
 290         properties->accelerated = (value != 0);
 291
 292     if (get_renderer_property(renderer_info, renderer_index, kCGLRPBackingStore, &value))
 293         properties->backing_store = (value != 0);
 294
 295     if (get_renderer_property(renderer_info, renderer_index, kCGLRPWindow, &value))
 296         properties->window = (value != 0);
 297
 298     if (get_renderer_property(renderer_info, renderer_index, kCGLRPOnline, &value))
 299         properties->online = (value != 0);
 300 }
 301
 302
 303 static void dump_renderer(const renderer_properties* renderer)
 304 {
 305     int i;
 306
 307     TRACE("Renderer ID: 0x%08x\n", renderer->renderer_id);
 308     TRACE("Buffer modes:\n");
 309     TRACE("    Monoscopic:    %s\n", (renderer->buffer_modes & kCGLMonoscopicBit) ? "YES" : "NO");
 310     TRACE("    Stereoscopic:  %s\n", (renderer->buffer_modes & kCGLStereoscopicBit) ? "YES" : "NO");
 311     TRACE("    Single buffer: %s\n", (renderer->buffer_modes & kCGLSingleBufferBit) ? "YES" : "NO");
 312     TRACE("    Double buffer: %s\n", (renderer->buffer_modes & kCGLDoubleBufferBit) ? "YES" : "NO");
 313
 314     TRACE("Color buffer modes:\n");
 315     for (i = 0; i < sizeof(color_modes)/sizeof(color_modes[0]); i++)
 316     {
 317         if (renderer->color_modes & color_modes[i].mode)
 318         {
 319             TRACE("    Color size %d, Alpha size %d", color_modes[i].color_bits, color_modes[i].alpha_bits);
 320             if (color_modes[i].is_float)
 321                 TRACE(", Float");
 322             TRACE("\n");
 323         }
 324     }
 325
 326     TRACE("Accumulation buffer sizes: { ");
 327     for (i = 0; i < sizeof(color_modes)/sizeof(color_modes[0]); i++)
 328     {
 329         if (renderer->accum_modes & color_modes[i].mode)
 330             TRACE("%d, ", color_modes[i].color_bits);
 331     }
 332     TRACE("}\n");
 333
 334     TRACE("Depth buffer sizes: { ");
 335     for (i = 0; i < sizeof(depth_stencil_modes)/sizeof(depth_stencil_modes[0]); i++)
 336     {
 337         if (renderer->depth_modes & depth_stencil_modes[i].mode)
 338             TRACE("%d, ", depth_stencil_modes[i].bits);
 339     }
 340     TRACE("}\n");
 341
 342     TRACE("Stencil buffer sizes: { ");
 343     for (i = 0; i < sizeof(depth_stencil_modes)/sizeof(depth_stencil_modes[0]); i++)
 344     {
 345         if (renderer->stencil_modes & depth_stencil_modes[i].mode)
 346             TRACE("%d, ", depth_stencil_modes[i].bits);
 347     }
 348     TRACE("}\n");
 349
 350     TRACE("Max. Auxiliary Buffers: %d\n", renderer->max_aux_buffers);
 351     TRACE("Max. Sample Buffers: %d\n", renderer->max_sample_buffers);
 352     TRACE("Max. Samples: %d\n", renderer->max_samples);
 353     TRACE("Offscreen: %s\n", renderer->offscreen ? "YES" : "NO");
 354     TRACE("Accelerated: %s\n", renderer->accelerated ? "YES" : "NO");
 355     TRACE("Backing store: %s\n", renderer->backing_store ? "YES" : "NO");
 356     TRACE("Window: %s\n", renderer->window ? "YES" : "NO");
 357     TRACE("Online: %s\n", renderer->online ? "YES" : "NO");
 358 }
 359
 360
 361 static inline UInt64 code_for_pixel_format(const pixel_format* format)
 362 {
 363     pixel_format_or_code pfc;
 364
 365     pfc.code = 0;
 366     pfc.format = *format;
 367     return pfc.code;
 368 }
 369
 370
 371 static inline pixel_format pixel_format_for_code(UInt64 code)
 372 {
 373     pixel_format_or_code pfc;
 374
 375     pfc.code = code;
 376     return pfc.format;
 377 }
 378
 379
 380 static const char *debugstr_pf(const pixel_format *pf)
 381 {
 382     return wine_dbg_sprintf("w/p/a %u/%u/%u col %u%s/%u dp/stn/ac/ax/b/db/str %u/%u/%u/%u/%u/%u/%u samp %u/%u %017llx",
 383                             pf->window,
 384                             pf->pbuffer,
 385                             pf->accelerated,
 386                             color_modes[pf->color_mode].color_bits,
 387                             (color_modes[pf->color_mode].is_float ? "f" : ""),
 388                             color_modes[pf->color_mode].alpha_bits,
 389                             pf->depth_bits,
 390                             pf->stencil_bits,
 391                             pf->accum_mode ? color_modes[pf->accum_mode - 1].color_bits : 0,
 392                             pf->aux_buffers,
 393                             pf->backing_store,
 394                             pf->double_buffer,
 395                             pf->stereo,
 396                             pf->sample_buffers,
 397                             pf->samples,
 398                             code_for_pixel_format(pf));
 399 }
 400
 401
 402 static unsigned int best_color_mode(GLint modes, GLint color_size, GLint alpha_size, GLint color_float)
 403 {
 404     int best = -1;
 405     int i;
 406
 407     for (i = 0; i < sizeof(color_modes)/sizeof(color_modes[0]); i++)
 408     {
 409         if ((modes & color_modes[i].mode) &&
 410             color_modes[i].color_bits >= color_size &&
 411             color_modes[i].alpha_bits >= alpha_size &&
 412             !color_modes[i].is_float == !color_float)
 413         {
 414             if (best < 0) /* no existing best choice */
 415                 best = i;
 416             else if (color_modes[i].color_bits == color_size &&
 417                      color_modes[i].alpha_bits == alpha_size) /* candidate is exact match */
 418             {
 419                 /* prefer it over a best which isn't exact or which has a higher bpp */
 420                 if (color_modes[best].color_bits != color_size ||
 421                     color_modes[best].alpha_bits != alpha_size ||
 422                     color_modes[i].bits_per_pixel < color_modes[best].bits_per_pixel)
 423                     best = i;
 424             }
 425             else if (color_modes[i].color_bits < color_modes[best].color_bits ||
 426                      (color_modes[i].color_bits == color_modes[best].color_bits &&
 427                       color_modes[i].alpha_bits < color_modes[best].alpha_bits)) /* prefer closer */
 428                 best = i;
 429         }
 430     }
 431
 432     if (best < 0)
 433     {
 434         /* Couldn't find a match.  Return first one that renderer supports. */
 435         for (i = 0; i < sizeof(color_modes)/sizeof(color_modes[0]); i++)
 436         {
 437             if (modes & color_modes[i].mode)
 438                 return i;
 439         }
 440     }
 441
 442     return best;
 443 }
 444
 445
 446 static unsigned int best_accum_mode(GLint modes, GLint accum_size)
 447 {
 448     int best = -1;
 449     int i;
 450
 451     for (i = 0; i < sizeof(color_modes)/sizeof(color_modes[0]); i++)
 452     {
 453         if ((modes & color_modes[i].mode) && color_modes[i].color_bits >= accum_size)
 454         {
 455             /* Prefer the fewest color bits, then prefer more alpha bits, then
 456                prefer more bits per pixel. */
 457             if (best < 0)
 458                 best = i;
 459             else if (color_modes[i].color_bits < color_modes[best].color_bits)
 460                 best = i;
 461             else if (color_modes[i].color_bits == color_modes[best].color_bits)
 462             {
 463                 if (color_modes[i].alpha_bits > color_modes[best].alpha_bits)
 464                     best = i;
 465                 else if (color_modes[i].alpha_bits == color_modes[best].alpha_bits &&
 466                          color_modes[i].bits_per_pixel > color_modes[best].bits_per_pixel)
 467                     best = i;
 468             }
 469         }
 470     }
 471
 472     if (best < 0)
 473     {
 474         /* Couldn't find a match.  Return last one that renderer supports. */
 475         for (i = sizeof(color_modes)/sizeof(color_modes[0]) - 1; i >= 0; i--)
 476         {
 477             if (modes & color_modes[i].mode)
 478                 return i;
 479         }
 480     }
 481
 482     return best;
 483 }
 484
 485
 486 static void enum_renderer_pixel_formats(renderer_properties renderer, CFMutableArrayRef pixel_format_array,
 487                                         CFMutableSetRef pixel_format_set)
 488 {
 489     CGLPixelFormatAttribute attribs[64] = {
 490         kCGLPFAMinimumPolicy,
 491         kCGLPFAClosestPolicy,
 492         kCGLPFARendererID, renderer.renderer_id,
 493         kCGLPFASingleRenderer,
 494     };
 495     int n = 5, n_stack[16], n_stack_idx = -1;
 496     unsigned int tried_pixel_formats = 0, failed_pixel_formats = 0, dupe_pixel_formats = 0,
 497                  new_pixel_formats = 0;
 498     pixel_format request;
 499     unsigned int double_buffer;
 500     unsigned int accelerated = renderer.accelerated;
 501
 502     if (accelerated)
 503     {
 504         attribs[n++] = kCGLPFAAccelerated;
 505         attribs[n++] = kCGLPFANoRecovery;
 506     }
 507
 508     n_stack[++n_stack_idx] = n;
 509     for (double_buffer = 0; double_buffer <= 1; double_buffer++)
 510     {
 511         unsigned int aux;
 512
 513         n = n_stack[n_stack_idx];
 514
 515         if ((!double_buffer && !(renderer.buffer_modes & kCGLSingleBufferBit)) ||
 516             (double_buffer && !(renderer.buffer_modes & kCGLDoubleBufferBit)))
 517             continue;
 518
 519         if (double_buffer)
 520             attribs[n++] = kCGLPFADoubleBuffer;
 521         memset(&request, 0, sizeof(request));
 522         request.accelerated = accelerated;
 523         request.double_buffer = double_buffer;
 524
 525         /* Don't bother with in-between aux buffers values: either 0 or max. */
 526         n_stack[++n_stack_idx] = n;
 527         for (aux = 0; aux <= renderer.max_aux_buffers; aux += renderer.max_aux_buffers)
 528         {
 529             unsigned int color_mode;
 530
 531             n = n_stack[n_stack_idx];
 532
 533             attribs[n++] = kCGLPFAAuxBuffers;
 534             attribs[n++] = aux;
 535             request.aux_buffers = aux;
 536
 537             n_stack[++n_stack_idx] = n;
 538             for (color_mode = 0; color_mode < sizeof(color_modes)/sizeof(color_modes[0]); color_mode++)
 539             {
 540                 unsigned int depth_mode;
 541
 542                 n = n_stack[n_stack_idx];
 543
 544                 if (!(renderer.color_modes & color_modes[color_mode].mode))
 545                     continue;
 546
 547                 attribs[n++] = kCGLPFAColorSize;
 548                 attribs[n++] = color_modes[color_mode].color_bits;
 549                 attribs[n++] = kCGLPFAAlphaSize;
 550                 attribs[n++] = color_modes[color_mode].alpha_bits;
 551                 if (color_modes[color_mode].is_float)
 552                     attribs[n++] = kCGLPFAColorFloat;
 553                 request.color_mode = color_mode;
 554
 555                 n_stack[++n_stack_idx] = n;
 556                 for (depth_mode = 0; depth_mode < sizeof(depth_stencil_modes)/sizeof(depth_stencil_modes[0]); depth_mode++)
 557                 {
 558                     unsigned int stencil_mode;
 559
 560                     n = n_stack[n_stack_idx];
 561
 562                     if (!(renderer.depth_modes & depth_stencil_modes[depth_mode].mode))
 563                         continue;
 564
 565                     attribs[n++] = kCGLPFADepthSize;
 566                     attribs[n++] = depth_stencil_modes[depth_mode].bits;
 567                     request.depth_bits = depth_stencil_modes[depth_mode].bits;
 568
 569                     n_stack[++n_stack_idx] = n;
 570                     for (stencil_mode = 0; stencil_mode < sizeof(depth_stencil_modes)/sizeof(depth_stencil_modes[0]); stencil_mode++)
 571                     {
 572                         unsigned int stereo;
 573
 574                         n = n_stack[n_stack_idx];
 575
 576                         if (!(renderer.stencil_modes & depth_stencil_modes[stencil_mode].mode))
 577                             continue;
 578                         if (accelerated && depth_stencil_modes[depth_mode].bits != 24 && stencil_mode > 0)
 579                             continue;
 580
 581                         attribs[n++] = kCGLPFAStencilSize;
 582                         attribs[n++] = depth_stencil_modes[stencil_mode].bits;
 583                         request.stencil_bits = depth_stencil_modes[stencil_mode].bits;
 584
 585                         /* FIXME: Could trim search space a bit here depending on GPU.
 586                                   For ATI Radeon HD 4850, kCGLRGBA16161616Bit implies stereo-capable. */
 587                         n_stack[++n_stack_idx] = n;
 588                         for (stereo = 0; stereo <= 1; stereo++)
 589                         {
 590                             int accum_mode;
 591
 592                             n = n_stack[n_stack_idx];
 593
 594                             if ((!stereo && !(renderer.buffer_modes & kCGLMonoscopicBit)) ||
 595                                 (stereo && !(renderer.buffer_modes & kCGLStereoscopicBit)))
 596                                 continue;
 597
 598                             if (stereo)
 599                                 attribs[n++] = kCGLPFAStereo;
 600                             request.stereo = stereo;
 601
 602                             /* Starts at -1 for a 0 accum size */
 603                             n_stack[++n_stack_idx] = n;
 604                             for (accum_mode = -1; accum_mode < (int)(sizeof(color_modes)/sizeof(color_modes[0])); accum_mode++)
 605                             {
 606                                 unsigned int target_pass;
 607
 608                                 n = n_stack[n_stack_idx];
 609
 610                                 if (accum_mode >= 0)
 611                                 {
 612                                     if (!(renderer.accum_modes & color_modes[accum_mode].mode))
 613                                         continue;
 614
 615                                     attribs[n++] = kCGLPFAAccumSize;
 616                                     attribs[n++] = color_modes[accum_mode].color_bits;
 617                                     request.accum_mode = accum_mode + 1;
 618                                 }
 619                                 else
 620                                     request.accum_mode = 0;
 621
 622                                 /* Targets to request are:
 623                                         accelerated: window OR window + pbuffer
 624                                         software: window + pbuffer */
 625                                 n_stack[++n_stack_idx] = n;
 626                                 for (target_pass = 0; target_pass <= accelerated; target_pass++)
 627                                 {
 628                                     unsigned int samples, max_samples;
 629
 630                                     n = n_stack[n_stack_idx];
 631
 632                                     attribs[n++] = kCGLPFAWindow;
 633                                     request.window = 1;
 634
 635                                     if (!accelerated || target_pass > 0)
 636                                     {
 637                                         attribs[n++] = kCGLPFAPBuffer;
 638                                         request.pbuffer = 1;
 639                                     }
 640                                     else
 641                                         request.pbuffer = 0;
 642
 643                                     /* FIXME: Could trim search space a bit here depending on GPU.
 644                                               For Nvidia GeForce 8800 GT, limited to 4 samples for color_bits >= 128.
 645                                               For ATI Radeon HD 4850, can't multi-sample for color_bits >= 64 or pbuffer. */
 646                                     n_stack[++n_stack_idx] = n;
 647                                     max_samples = renderer.max_sample_buffers ? max(1, renderer.max_samples) : 1;
 648                                     for (samples = 1; samples <= max_samples; samples *= 2)
 649                                     {
 650                                         unsigned int backing_store, min_backing_store, max_backing_store;
 651
 652                                         n = n_stack[n_stack_idx];
 653
 654                                         if (samples > 1)
 655                                         {
 656                                             attribs[n++] = kCGLPFASampleBuffers;
 657                                             attribs[n++] = renderer.max_sample_buffers;
 658                                             attribs[n++] = kCGLPFASamples;
 659                                             attribs[n++] = samples;
 660                                             request.sample_buffers = renderer.max_sample_buffers;
 661                                             request.samples = samples;
 662                                         }
 663                                         else
 664                                             request.sample_buffers = request.samples = 0;
 665
 666                                         if (renderer.backing_store && double_buffer)
 667                                         {
 668                                             /* The software renderer seems to always preserve the backing store, whether
 669                                                we ask for it or not.  So don't bother not asking for it. */
 670                                             min_backing_store = accelerated ? 0 : 1;
 671                                             max_backing_store = 1;
 672                                         }
 673                                         else
 674                                             min_backing_store = max_backing_store = 0;
 675                                         n_stack[++n_stack_idx] = n;
 676                                         for (backing_store = min_backing_store; backing_store <= max_backing_store; backing_store++)
 677                                         {
 678                                             CGLPixelFormatObj pix;
 679                                             GLint virtualScreens;
 680                                             CGLError err;
 681
 682                                             n = n_stack[n_stack_idx];
 683
 684                                             if (backing_store)
 685                                                 attribs[n++] = kCGLPFABackingStore;
 686                                             request.backing_store = backing_store;
 687
 688                                             attribs[n] = 0;
 689
 690                                             err = CGLChoosePixelFormat(attribs, &pix, &virtualScreens);
 691                                             if (err == kCGLNoError && pix)
 692                                             {
 693                                                 pixel_format pf;
 694                                                 GLint value, color_size, alpha_size, color_float;
 695                                                 UInt64 pf_code;
 696                                                 CFNumberRef code_object;
 697                                                 BOOL dupe;
 698
 699                                                 memset(&pf, 0, sizeof(pf));
 700
 701                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAAccelerated, &value) == kCGLNoError)
 702                                                     pf.accelerated = value;
 703                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAAuxBuffers, &value) == kCGLNoError)
 704                                                     pf.aux_buffers = value;
 705                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFADepthSize, &value) == kCGLNoError)
 706                                                     pf.depth_bits = value;
 707                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFADoubleBuffer, &value) == kCGLNoError)
 708                                                     pf.double_buffer = value;
 709                                                 if (pf.double_buffer &&
 710                                                     CGLDescribePixelFormat(pix, 0, kCGLPFABackingStore, &value) == kCGLNoError)
 711                                                     pf.backing_store = value;
 712                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAPBuffer, &value) == kCGLNoError)
 713                                                     pf.pbuffer = value;
 714                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFASampleBuffers, &value) == kCGLNoError)
 715                                                     pf.sample_buffers = value;
 716                                                 if (pf.sample_buffers &&
 717                                                     CGLDescribePixelFormat(pix, 0, kCGLPFASamples, &value) == kCGLNoError)
 718                                                     pf.samples = value;
 719                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAStencilSize, &value) == kCGLNoError)
 720                                                     pf.stencil_bits = value;
 721                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAStereo, &value) == kCGLNoError)
 722                                                     pf.stereo = value;
 723                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAWindow, &value) == kCGLNoError)
 724                                                     pf.window = value;
 725
 726                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAColorSize, &color_size) != kCGLNoError)
 727                                                     color_size = 0;
 728                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAAlphaSize, &alpha_size) != kCGLNoError)
 729                                                     alpha_size = 0;
 730                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAColorFloat, &color_float) != kCGLNoError)
 731                                                     color_float = 0;
 732                                                 pf.color_mode = best_color_mode(renderer.color_modes, color_size, alpha_size, color_float);
 733
 734                                                 if (CGLDescribePixelFormat(pix, 0, kCGLPFAAccumSize, &value) == kCGLNoError && value)
 735                                                     pf.accum_mode = best_accum_mode(renderer.accum_modes, value) + 1;
 736
 737                                                 CGLReleasePixelFormat(pix);
 738
 739                                                 pf_code = code_for_pixel_format(&pf);
 740
 741                                                 code_object = CFNumberCreate(NULL, kCFNumberSInt64Type, &pf_code);
 742                                                 if ((dupe = CFSetContainsValue(pixel_format_set, code_object)))
 743                                                     dupe_pixel_formats++;
 744                                                 else
 745                                                 {
 746                                                     CFSetAddValue(pixel_format_set, code_object);
 747                                                     CFArrayAppendValue(pixel_format_array, code_object);
 748                                                     new_pixel_formats++;
 749                                                 }
 750                                                 CFRelease(code_object);
 751
 752                                                 if (pf_code == code_for_pixel_format(&request))
 753                                                     TRACE("%s%s\n", debugstr_pf(&pf), dupe ? " (duplicate)" : "");
 754                                                 else
 755                                                 {
 756                                                     TRACE("%s remapped from %s%s\n", debugstr_pf(&pf), debugstr_pf(&request),
 757                                                           dupe ? " (duplicate)" : "");
 758                                                 }
 759                                             }
 760                                             else
 761                                             {
 762                                                 failed_pixel_formats++;
 763                                                 TRACE("%s failed request err %d %s\n", debugstr_pf(&request), err, err ? CGLErrorString(err) : "");
 764                                             }
 765
 766                                             tried_pixel_formats++;
 767                                         }
 768
 769                                         n_stack_idx--;
 770                                     }
 771
 772                                     n_stack_idx--;
 773                                 }
 774
 775                                 n_stack_idx--;
 776                             }
 777
 778                             n_stack_idx--;
 779                         }
 780
 781                         n_stack_idx--;
 782                     }
 783
 784                     n_stack_idx--;
 785                 }
 786
 787                 n_stack_idx--;
 788             }
 789
 790             n_stack_idx--;
 791         }
 792
 793         n_stack_idx--;
 794     }
 795
 796     n_stack_idx--;
 797
 798     TRACE("Number of pixel format attribute combinations: %u\n", tried_pixel_formats);
 799     TRACE(" Number which failed to choose a pixel format: %u\n", failed_pixel_formats);
 800     TRACE("   Number which chose redundant pixel formats: %u\n", dupe_pixel_formats);
 801     TRACE("Number of new pixel formats for this renderer: %u\n", new_pixel_formats);
 802 }
 803
 804
 805 /* The docs for WGL_ARB_pixel_format say:
 806     Indices are assigned to pixel formats in the following order:
 807     1. Accelerated pixel formats that are displayable
 808     2. Accelerated pixel formats that are displayable and which have
 809        extended attributes
 810     3. Generic pixel formats
 811     4. Accelerated pixel formats that are non displayable
 812  */
 813 static int pixel_format_category(pixel_format pf)
 814 {
 815     /* non-displayable */
 816     if (!pf.window)
 817         return 4;
 818
 819     /* non-accelerated a.k.a. software a.k.a. generic */
 820     if (!pf.accelerated)
 821         return 3;
 822
 823     /* extended attributes that can't be represented in PIXELFORMATDESCRIPTOR */
 824     if (color_modes[pf.color_mode].is_float)
 825         return 2;
 826
 827     /* accelerated, displayable, no extended attributes */
 828     return 1;
 829 }
 830
 831
 832 static CFComparisonResult pixel_format_comparator(const void *val1, const void *val2, void *context)
 833 {
 834     CFNumberRef number1 = val1;
 835     CFNumberRef number2 = val2;
 836     UInt64 code1, code2;
 837     pixel_format pf1, pf2;
 838     int category1, category2;
 839
 840     CFNumberGetValue(number1, kCFNumberLongLongType, &code1);
 841     CFNumberGetValue(number2, kCFNumberLongLongType, &code2);
 842     pf1 = pixel_format_for_code(code1);
 843     pf2 = pixel_format_for_code(code2);
 844     category1 = pixel_format_category(pf1);
 845     category2 = pixel_format_category(pf2);
 846
 847     if (category1 < category2)
 848         return kCFCompareLessThan;
 849     if (category1 > category2)
 850         return kCFCompareGreaterThan;
 851
 852     /* Within a category, sort the "best" formats toward the front since that's
 853        what wglChoosePixelFormatARB() has to do.  The ordering implemented here
 854        matches at least one Windows 7 machine's behavior.
 855      */
 856     /* Accelerated before unaccelerated. */
 857     if (pf1.accelerated && !pf2.accelerated)
 858         return kCFCompareLessThan;
 859     if (!pf1.accelerated && pf2.accelerated)
 860         return kCFCompareGreaterThan;
 861
 862     /* Explicit color mode ordering. */
 863     if (color_modes[pf1.color_mode].color_ordering < color_modes[pf2.color_mode].color_ordering)
 864         return kCFCompareLessThan;
 865     if (color_modes[pf1.color_mode].color_ordering > color_modes[pf2.color_mode].color_ordering)
 866         return kCFCompareGreaterThan;
 867
 868     /* Non-pbuffer-capable before pbuffer-capable. */
 869     if (!pf1.pbuffer && pf2.pbuffer)
 870         return kCFCompareLessThan;
 871     if (pf1.pbuffer && !pf2.pbuffer)
 872         return kCFCompareGreaterThan;
 873
 874     /* Fewer samples before more samples. */
 875     if (pf1.samples < pf2.samples)
 876         return kCFCompareLessThan;
 877     if (pf1.samples > pf2.samples)
 878         return kCFCompareGreaterThan;
 879
 880     /* Monoscopic before stereoscopic.  (This is a guess.) */
 881     if (!pf1.stereo && pf2.stereo)
 882         return kCFCompareLessThan;
 883     if (pf1.stereo && !pf2.stereo)
 884         return kCFCompareGreaterThan;
 885
 886     /* Single buffered before double buffered. */
 887     if (!pf1.double_buffer && pf2.double_buffer)
 888         return kCFCompareLessThan;
 889     if (pf1.double_buffer && !pf2.double_buffer)
 890         return kCFCompareGreaterThan;
 891
 892     /* Possibly-optimized double buffering before backing-store-preserving
 893        double buffering. */
 894     if (!pf1.backing_store && pf2.backing_store)
 895         return kCFCompareLessThan;
 896     if (pf1.backing_store && !pf2.backing_store)
 897         return kCFCompareGreaterThan;
 898
 899     /* Bigger depth buffer before smaller depth buffer. */
 900     if (pf1.depth_bits > pf2.depth_bits)
 901         return kCFCompareLessThan;
 902     if (pf1.depth_bits < pf2.depth_bits)
 903         return kCFCompareGreaterThan;
 904
 905     /* Smaller stencil buffer before bigger stencil buffer. */
 906     if (pf1.stencil_bits < pf2.stencil_bits)
 907         return kCFCompareLessThan;
 908     if (pf1.stencil_bits > pf2.stencil_bits)
 909         return kCFCompareGreaterThan;
 910
 911     /* Smaller alpha bits before larger alpha bits. */
 912     if (color_modes[pf1.color_mode].alpha_bits < color_modes[pf2.color_mode].alpha_bits)
 913         return kCFCompareLessThan;
 914     if (color_modes[pf1.color_mode].alpha_bits > color_modes[pf2.color_mode].alpha_bits)
 915         return kCFCompareGreaterThan;
 916
 917     /* Smaller accum buffer before larger accum buffer.  (This is a guess.) */
 918     if (pf1.accum_mode)
 919     {
 920         if (pf2.accum_mode)
 921         {
 922             if (color_modes[pf1.accum_mode - 1].color_bits - color_modes[pf1.accum_mode - 1].alpha_bits <
 923                 color_modes[pf2.accum_mode - 1].color_bits - color_modes[pf2.accum_mode - 1].alpha_bits)
 924                 return kCFCompareLessThan;
 925             if (color_modes[pf1.accum_mode - 1].color_bits - color_modes[pf1.accum_mode - 1].alpha_bits >
 926                 color_modes[pf2.accum_mode - 1].color_bits - color_modes[pf2.accum_mode - 1].alpha_bits)
 927                 return kCFCompareGreaterThan;
 928
 929             if (color_modes[pf1.accum_mode - 1].bits_per_pixel < color_modes[pf2.accum_mode - 1].bits_per_pixel)
 930                 return kCFCompareLessThan;
 931             if (color_modes[pf1.accum_mode - 1].bits_per_pixel > color_modes[pf2.accum_mode - 1].bits_per_pixel)
 932                 return kCFCompareGreaterThan;
 933
 934             if (color_modes[pf1.accum_mode - 1].alpha_bits < color_modes[pf2.accum_mode - 1].alpha_bits)
 935                 return kCFCompareLessThan;
 936             if (color_modes[pf1.accum_mode - 1].alpha_bits > color_modes[pf2.accum_mode - 1].alpha_bits)
 937                 return kCFCompareGreaterThan;
 938         }
 939         else
 940             return kCFCompareGreaterThan;
 941     }
 942     else if (pf2.accum_mode)
 943         return kCFCompareLessThan;
 944
 945     /* Fewer auxiliary buffers before more auxiliary buffers.  (This is a guess.) */
 946     if (pf1.aux_buffers < pf2.aux_buffers)
 947         return kCFCompareLessThan;
 948     if (pf1.aux_buffers > pf2.aux_buffers)
 949         return kCFCompareGreaterThan;
 950
 951     /* If we get here, arbitrarily sort based on code. */
 952     if (code1 < code2)
 953         return kCFCompareLessThan;
 954     if (code1 > code2)
 955         return kCFCompareGreaterThan;
 956     return kCFCompareEqualTo;
 957 }
 958
 959
 960 static BOOL init_pixel_formats(void)
 961 {
 962     BOOL ret = FALSE;
 963     CGLRendererInfoObj renderer_info;
 964     GLint rendererCount;
 965     CGLError err;
 966     CFMutableSetRef pixel_format_set;
 967     CFMutableArrayRef pixel_format_array;
 968     int i;
 969     CFRange range;
 970
 971     TRACE("()\n");
 972
 973     assert(sizeof(((pixel_format_or_code*)0)->format) <= sizeof(((pixel_format_or_code*)0)->code));
 974
 975     err = CGLQueryRendererInfo(CGDisplayIDToOpenGLDisplayMask(CGMainDisplayID()), &renderer_info, &rendererCount);
 976     if (err)
 977     {
 978         WARN("CGLQueryRendererInfo failed (%d) %s\n", err, CGLErrorString(err));
 979         return FALSE;
 980     }
 981
 982     pixel_format_set = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
 983     if (!pixel_format_set)
 984     {
 985         WARN("CFSetCreateMutable failed\n");
 986         CGLDestroyRendererInfo(renderer_info);
 987         return FALSE;
 988     }
 989
 990     pixel_format_array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 991     if (!pixel_format_array)
 992     {
 993         WARN("CFArrayCreateMutable failed\n");
 994         CFRelease(pixel_format_set);
 995         CGLDestroyRendererInfo(renderer_info);
 996         return FALSE;
 997     }
 998
 999     for (i = 0; i < rendererCount; i++)
1000     {
1001         renderer_properties renderer;
1002
1003         get_renderer_properties(renderer_info, i, &renderer);
1004         if (TRACE_ON(wgl))
1005         {
1006             TRACE("renderer_properties %d:\n", i);
1007             dump_renderer(&renderer);
1008         }
1009
1010         enum_renderer_pixel_formats(renderer, pixel_format_array, pixel_format_set);
1011     }
1012
1013     CFRelease(pixel_format_set);
1014     CGLDestroyRendererInfo(renderer_info);
1015
1016     range = CFRangeMake(0, CFArrayGetCount(pixel_format_array));
1017     if (range.length)
1018     {
1019         pixel_formats = HeapAlloc(GetProcessHeap(), 0, range.length * sizeof(*pixel_formats));
1020         if (pixel_formats)
1021         {
1022             CFArraySortValues(pixel_format_array, range, pixel_format_comparator, NULL);
1023             for (i = 0; i < range.length; i++)
1024             {
1025                 CFNumberRef number = CFArrayGetValueAtIndex(pixel_format_array, i);
1026                 UInt64 code;
1027
1028                 CFNumberGetValue(number, kCFNumberLongLongType, &code);
1029                 pixel_formats[i] = pixel_format_for_code(code);
1030                 if (pixel_formats[i].window)
1031                     nb_displayable_formats++;
1032             }
1033
1034             nb_formats = range.length;
1035             TRACE("Total number of unique pixel formats: %d\n", nb_formats);
1036             ret = TRUE;
1037         }
1038         else
1039             WARN("failed to allocate pixel format list\n");
1040     }
1041     else
1042         WARN("got no pixel formats\n");
1043
1044     CFRelease(pixel_format_array);
1045     return ret;
1046 }
1047
1048
1049 static inline BOOL is_valid_pixel_format(int format)
1050 {
1051     return format > 0 && format <= nb_formats;
1052 }
1053
1054
1055 static inline BOOL is_displayable_pixel_format(int format)
1056 {
1057     return format > 0 && format <= nb_displayable_formats;
1058 }
1059
1060
1061 static const pixel_format *get_pixel_format(int format, BOOL allow_nondisplayable)
1062 {
1063     /* Check if the pixel format is valid. Note that it is legal to pass an invalid
1064      * format in case of probing the number of pixel formats.
1065      */
1066     if (is_valid_pixel_format(format) && (is_displayable_pixel_format(format) || allow_nondisplayable))
1067     {
1068         TRACE("Returning format %d\n", format);
1069         return &pixel_formats[format - 1];
1070     }
1071     return NULL;
1072 }
1073
1074
1075 static BOOL init_gl_info(void)
1076 {
1077     CGDirectDisplayID display = CGMainDisplayID();
1078     CGOpenGLDisplayMask displayMask = CGDisplayIDToOpenGLDisplayMask(display);
1079     CGLPixelFormatAttribute attribs[] = {
1080         kCGLPFADisplayMask, displayMask,
1081         0
1082     };
1083     CGLPixelFormatObj pix;
1084     GLint virtualScreens;
1085     CGLError err;
1086     CGLContextObj context;
1087     CGLContextObj old_context = CGLGetCurrentContext();
1088     const char *str;
1089
1090     err = CGLChoosePixelFormat(attribs, &pix, &virtualScreens);
1091     if (err != kCGLNoError || !pix)
1092     {
1093         WARN("CGLChoosePixelFormat() failed with error %d %s\n", err, CGLErrorString(err));
1094         return FALSE;
1095     }
1096
1097     err = CGLCreateContext(pix, NULL, &context);
1098     CGLReleasePixelFormat(pix);
1099     if (err != kCGLNoError || !context)
1100     {
1101         WARN("CGLCreateContext() failed with error %d %s\n", err, CGLErrorString(err));
1102         return FALSE;
1103     }
1104
1105     err = CGLSetCurrentContext(context);
1106     if (err != kCGLNoError)
1107     {
1108         WARN("CGLSetCurrentContext() failed with error %d %s\n", err, CGLErrorString(err));
1109         CGLReleaseContext(context);
1110         return FALSE;
1111     }
1112
1113     str = (const char*)opengl_funcs.gl.p_glGetString(GL_VERSION);
1114     gl_info.glVersion = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
1115     strcpy(gl_info.glVersion, str);
1116     str = (const char*)opengl_funcs.gl.p_glGetString(GL_EXTENSIONS);
1117     gl_info.glExtensions = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
1118     strcpy(gl_info.glExtensions, str);
1119
1120     opengl_funcs.gl.p_glGetIntegerv(GL_MAX_VIEWPORT_DIMS, gl_info.max_viewport_dims);
1121
1122     TRACE("GL version   : %s\n", gl_info.glVersion);
1123     TRACE("GL renderer  : %s\n", opengl_funcs.gl.p_glGetString(GL_RENDERER));
1124
1125     CGLSetCurrentContext(old_context);
1126     CGLReleaseContext(context);
1127
1128     return TRUE;
1129 }
1130
1131
1132 static BOOL get_gl_view_window_rect(struct macdrv_win_data *data, macdrv_window *window, RECT *rect)
1133 {
1134     BOOL ret = TRUE;
1135     *rect = data->client_rect;
1136
1137     if (data->cocoa_window)
1138     {
1139         if (window)
1140             *window = data->cocoa_window;
1141         OffsetRect(rect, -data->whole_rect.left, -data->whole_rect.top);
1142     }
1143     else
1144     {
1145         HWND top = GetAncestor(data->hwnd, GA_ROOT);
1146         HWND parent = GetAncestor(data->hwnd, GA_PARENT);
1147         struct macdrv_win_data *top_data = get_win_data(top);
1148
1149         if (top_data && top_data->cocoa_window)
1150         {
1151             if (window)
1152                 *window = top_data->cocoa_window;
1153             MapWindowPoints(parent, 0, (POINT*)rect, 2);
1154             OffsetRect(rect, -top_data->whole_rect.left, -top_data->whole_rect.top);
1155         }
1156         else
1157             ret = FALSE;
1158
1159         release_win_data(top_data);
1160     }
1161
1162     return ret;
1163 }
1164
1165
1166 /***********************************************************************
1167  *              set_win_format
1168  */
1169 static BOOL set_win_format(struct macdrv_win_data *data, int format)
1170 {
1171     macdrv_window cocoa_window;
1172
1173     TRACE("hwnd %p format %d\n", data->hwnd, format);
1174
1175     if (!get_gl_view_window_rect(data, &cocoa_window, &data->gl_rect))
1176     {
1177         ERR("no top-level parent with Cocoa window in this process\n");
1178         return FALSE;
1179     }
1180
1181     if (data->gl_view) macdrv_dispose_view(data->gl_view);
1182     data->gl_view = macdrv_create_view(cocoa_window, cgrect_from_rect(data->gl_rect));
1183
1184     if (!data->gl_view)
1185     {
1186         WARN("failed to create GL view for window %p rect %s\n", cocoa_window, wine_dbgstr_rect(&data->gl_rect));
1187         return FALSE;
1188     }
1189
1190     TRACE("created GL view %p in window %p at %s\n", data->gl_view, cocoa_window,
1191           wine_dbgstr_rect(&data->gl_rect));
1192
1193     data->pixel_format = format;
1194
1195     return TRUE;
1196 }
1197
1198
1199 /**********************************************************************
1200  *              set_pixel_format
1201  *
1202  * Implementation of wglSetPixelFormat and wglSetPixelFormatWINE.
1203  */
1204 static BOOL set_pixel_format(HDC hdc, int fmt, BOOL allow_reset)
1205 {
1206     struct macdrv_win_data *data;
1207     const pixel_format *pf;
1208     HWND hwnd = WindowFromDC(hdc);
1209     BOOL ret = FALSE;
1210
1211     TRACE("hdc %p format %d\n", hdc, fmt);
1212
1213     if (!hwnd || hwnd == GetDesktopWindow())
1214     {
1215         WARN("not a proper window DC %p/%p\n", hdc, hwnd);
1216         return FALSE;
1217     }
1218
1219     if (!(data = get_win_data(hwnd)))
1220     {
1221         FIXME("DC for window %p of other process: not implemented\n", hwnd);
1222         return FALSE;
1223     }
1224
1225     if (!allow_reset && data->pixel_format)  /* cannot change it if already set */
1226     {
1227         ret = (data->pixel_format == fmt);
1228         goto done;
1229     }
1230
1231     /* Check if fmt is in our list of supported formats to see if it is supported. */
1232     pf = get_pixel_format(fmt, FALSE /* non-displayable */);
1233     if (!pf)
1234     {
1235         ERR("Invalid pixel format: %d\n", fmt);
1236         goto done;
1237     }
1238
1239     if (!pf->window)
1240     {
1241         WARN("Pixel format %d is not compatible for window rendering\n", fmt);
1242         goto done;
1243     }
1244
1245     if (!set_win_format(data, fmt))
1246     {
1247         WARN("Couldn't set format of the window, returning failure\n");
1248         goto done;
1249     }
1250
1251     TRACE("pixel format:\n");
1252     TRACE("           window: %u\n", (unsigned int)pf->window);
1253     TRACE("          pBuffer: %u\n", (unsigned int)pf->pbuffer);
1254     TRACE("      accelerated: %u\n", (unsigned int)pf->accelerated);
1255     TRACE("       color bits: %u%s\n", (unsigned int)color_modes[pf->color_mode].color_bits, (color_modes[pf->color_mode].is_float ? " float" : ""));
1256     TRACE("       alpha bits: %u\n", (unsigned int)color_modes[pf->color_mode].alpha_bits);
1257     TRACE("      aux buffers: %u\n", (unsigned int)pf->aux_buffers);
1258     TRACE("       depth bits: %u\n", (unsigned int)pf->depth_bits);
1259     TRACE("     stencil bits: %u\n", (unsigned int)pf->stencil_bits);
1260     TRACE("       accum bits: %u\n", (unsigned int)pf->accum_mode ? color_modes[pf->accum_mode - 1].color_bits : 0);
1261     TRACE("    double_buffer: %u\n", (unsigned int)pf->double_buffer);
1262     TRACE("           stereo: %u\n", (unsigned int)pf->stereo);
1263     TRACE("   sample_buffers: %u\n", (unsigned int)pf->sample_buffers);
1264     TRACE("          samples: %u\n", (unsigned int)pf->samples);
1265     TRACE("    backing_store: %u\n", (unsigned int)pf->backing_store);
1266     ret = TRUE;
1267
1268 done:
1269     release_win_data(data);
1270     if (ret) __wine_set_pixel_format(hwnd, fmt);
1271     return ret;
1272 }
1273
1274
1275 /**********************************************************************
1276  *              set_gl_view_parent
1277  */
1278 void set_gl_view_parent(HWND hwnd, HWND parent)
1279 {
1280     struct macdrv_win_data *data;
1281
1282     if (!(data = get_win_data(hwnd))) return;
1283
1284     if (data->gl_view)
1285     {
1286         macdrv_window cocoa_window;
1287
1288         TRACE("moving GL view %p to parent %p\n", data->gl_view, parent);
1289
1290         if (!get_gl_view_window_rect(data, &cocoa_window, &data->gl_rect))
1291         {
1292             ERR("no top-level parent with Cocoa window in this process\n");
1293             macdrv_dispose_view(data->gl_view);
1294             data->gl_view = NULL;
1295             release_win_data(data);
1296             __wine_set_pixel_format( hwnd, 0 );
1297             return;
1298         }
1299
1300         macdrv_set_view_window_and_frame(data->gl_view, cocoa_window, cgrect_from_rect(data->gl_rect));
1301     }
1302
1303     release_win_data(data);
1304 }
1305
1306
1307 /**********************************************************************
1308  *              make_context_current
1309  */
1310 static void make_context_current(struct wgl_context *context, BOOL read)
1311 {
1312     macdrv_view view;
1313     struct wgl_pbuffer *pbuffer;
1314
1315     if (read)
1316     {
1317         view = context->read_view;
1318         pbuffer = context->read_pbuffer;
1319     }
1320     else
1321     {
1322         view = context->draw_view;
1323         pbuffer = context->draw_pbuffer;
1324     }
1325
1326     if (view || !pbuffer)
1327         macdrv_make_context_current(context->context, view);
1328     else
1329     {
1330         CGLSetPBuffer(context->cglcontext, pbuffer->pbuffer, pbuffer->face,
1331                       pbuffer->level, 0);
1332         CGLSetCurrentContext(context->cglcontext);
1333     }
1334 }
1335
1336
1337 /**********************************************************************
1338  *              macdrv_glCopyColorTable
1339  *
1340  * Hook into glCopyColorTable as part of the implementation of
1341  * wglMakeContextCurrentARB.  If the context has a separate readable,
1342  * temporarily make that current, do glCopyColorTable, and then set it
1343  * back to the drawable.  This is modeled after what Mesa GLX's Apple
1344  * implementation does.
1345  */
1346 static void macdrv_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y,
1347                                     GLsizei width)
1348 {
1349     struct wgl_context *context = NtCurrentTeb()->glContext;
1350
1351     if (context->read_view || context->read_pbuffer)
1352         make_context_current(context, TRUE);
1353
1354     pglCopyColorTable(target, internalformat, x, y, width);
1355
1356     if (context->read_view || context->read_pbuffer)
1357         make_context_current(context, FALSE);
1358 }
1359
1360
1361 /**********************************************************************
1362  *              macdrv_glCopyPixels
1363  *
1364  * Hook into glCopyPixels as part of the implementation of
1365  * wglMakeContextCurrentARB.  If the context has a separate readable,
1366  * temporarily make that current, do glCopyPixels, and then set it back
1367  * to the drawable.  This is modeled after what Mesa GLX's Apple
1368  * implementation does.
1369  */
1370 static void macdrv_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
1371 {
1372     struct wgl_context *context = NtCurrentTeb()->glContext;
1373
1374     if (context->read_view || context->read_pbuffer)
1375         make_context_current(context, TRUE);
1376
1377     pglCopyPixels(x, y, width, height, type);
1378
1379     if (context->read_view || context->read_pbuffer)
1380         make_context_current(context, FALSE);
1381 }
1382
1383
1384 /**********************************************************************
1385  *              macdrv_glReadPixels
1386  *
1387  * Hook into glReadPixels as part of the implementation of
1388  * wglMakeContextCurrentARB.  If the context has a separate readable,
1389  * temporarily make that current, do glReadPixels, and then set it back
1390  * to the drawable.  This is modeled after what Mesa GLX's Apple
1391  * implementation does.
1392  */
1393 static void macdrv_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
1394                                 GLenum format, GLenum type, void *pixels)
1395 {
1396     struct wgl_context *context = NtCurrentTeb()->glContext;
1397
1398     if (context->read_view || context->read_pbuffer)
1399         make_context_current(context, TRUE);
1400
1401     pglReadPixels(x, y, width, height, format, type, pixels);
1402
1403     if (context->read_view || context->read_pbuffer)
1404         make_context_current(context, FALSE);
1405 }
1406
1407
1408 /**********************************************************************
1409  *              macdrv_glViewport
1410  *
1411  * Hook into glViewport as an opportunity to update the OpenGL context
1412  * if necessary.  This is modeled after what Mesa GLX's Apple
1413  * implementation does.
1414  */
1415 static void macdrv_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
1416 {
1417     struct wgl_context *context = NtCurrentTeb()->glContext;
1418
1419     macdrv_update_opengl_context(context->context);
1420     pglViewport(x, y, width, height);
1421 }
1422
1423
1424 /***********************************************************************
1425  *              macdrv_wglBindTexImageARB
1426  *
1427  * WGL_ARB_render_texture: wglBindTexImageARB
1428  */
1429 static BOOL macdrv_wglBindTexImageARB(struct wgl_pbuffer *pbuffer, int iBuffer)
1430 {
1431     struct wgl_context *context = NtCurrentTeb()->glContext;
1432     GLenum source;
1433     CGLError err;
1434
1435     TRACE("pbuffer %p iBuffer 0x%x\n", pbuffer, iBuffer);
1436
1437     if (pbuffer->no_texture)
1438     {
1439         SetLastError(ERROR_INVALID_OPERATION);
1440         return GL_FALSE;
1441     }
1442
1443     if (!context->draw_view && context->draw_pbuffer == pbuffer)
1444         opengl_funcs.gl.p_glFlush();
1445
1446     switch (iBuffer)
1447     {
1448         case WGL_FRONT_LEFT_ARB:
1449             if (pixel_formats[pbuffer->format].stereo)
1450                 source = GL_FRONT_LEFT;
1451             else
1452                 source = GL_FRONT;
1453             break;
1454         case WGL_FRONT_RIGHT_ARB:
1455             source = GL_FRONT_RIGHT;
1456             break;
1457         case WGL_BACK_LEFT_ARB:
1458             if (pixel_formats[pbuffer->format].stereo)
1459                 source = GL_BACK_LEFT;
1460             else
1461                 source = GL_BACK;
1462             break;
1463         case WGL_BACK_RIGHT_ARB:
1464             source = GL_BACK_RIGHT;
1465             break;
1466         case WGL_AUX0_ARB: source = GL_AUX0; break;
1467         case WGL_AUX1_ARB: source = GL_AUX1; break;
1468         case WGL_AUX2_ARB: source = GL_AUX2; break;
1469         case WGL_AUX3_ARB: source = GL_AUX3; break;
1470
1471         case WGL_AUX4_ARB:
1472         case WGL_AUX5_ARB:
1473         case WGL_AUX6_ARB:
1474         case WGL_AUX7_ARB:
1475         case WGL_AUX8_ARB:
1476         case WGL_AUX9_ARB:
1477             FIXME("unsupported source buffer 0x%x\n", iBuffer);
1478             SetLastError(ERROR_INVALID_DATA);
1479             return GL_FALSE;
1480
1481         default:
1482             WARN("unknown source buffer 0x%x\n", iBuffer);
1483             SetLastError(ERROR_INVALID_DATA);
1484             return GL_FALSE;
1485     }
1486
1487     err = CGLTexImagePBuffer(context->cglcontext, pbuffer->pbuffer, source);
1488     if (err != kCGLNoError)
1489     {
1490         WARN("CGLTexImagePBuffer failed with err %d %s\n", err, CGLErrorString(err));
1491         SetLastError(ERROR_INVALID_OPERATION);
1492         return GL_FALSE;
1493     }
1494
1495     return GL_TRUE;
1496 }
1497
1498
1499 /***********************************************************************
1500  *              macdrv_wglChoosePixelFormatARB
1501  *
1502  * WGL_ARB_pixel_format: wglChoosePixelFormatARB
1503  */
1504 static BOOL macdrv_wglChoosePixelFormatARB(HDC hdc, const int *piAttribIList,
1505                                            const FLOAT *pfAttribFList, UINT nMaxFormats,
1506                                            int *piFormats, UINT *nNumFormats)
1507 {
1508     pixel_format pf, valid;
1509     const int *iptr;
1510     int color_bits, red_bits, green_bits, blue_bits, alpha_bits;
1511     int accum_bits, accum_red_bits, accum_green_bits, accum_blue_bits, accum_alpha_bits;
1512     int float_color;
1513     BOOL srgb;
1514     int i, found = 0;
1515
1516     TRACE("hdc %p piAttribIList %p pfAttribFList %p nMaxFormats %u piFormats %p nNumFormats %p\n",
1517           hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
1518     if (pfAttribFList)
1519         FIXME("unused pfAttribFList\n");
1520
1521     memset(&pf, 0, sizeof(pf));
1522     memset(&valid, 0, sizeof(valid));
1523     color_bits = red_bits = green_bits = blue_bits = alpha_bits = 0;
1524     accum_bits = accum_red_bits = accum_green_bits = accum_blue_bits = accum_alpha_bits = 0;
1525     float_color = -1;
1526     srgb = FALSE;
1527
1528     for (iptr = piAttribIList; iptr && *iptr; iptr += 2)
1529     {
1530         int attr = iptr[0];
1531         int value = iptr[1];
1532
1533         switch (attr)
1534         {
1535             case WGL_DRAW_TO_WINDOW_ARB:
1536                 if (valid.window && (!pf.window != !value)) goto cant_match;
1537                 pf.window = (value != 0);
1538                 valid.window = 1;
1539                 break;
1540
1541             case WGL_DRAW_TO_BITMAP_ARB:
1542                 goto cant_match;
1543
1544             case WGL_ACCELERATION_ARB:
1545                 if (value == WGL_FULL_ACCELERATION_ARB)
1546                     value = 1;
1547                 else if (value == WGL_NO_ACCELERATION_ARB)
1548                     value = 0;
1549                 else
1550                     goto cant_match;
1551                 if (valid.accelerated && pf.accelerated != value) goto cant_match;
1552                 pf.accelerated = value;
1553                 valid.accelerated = 1;
1554                 break;
1555
1556             case WGL_NEED_PALETTE_ARB:
1557             case WGL_NEED_SYSTEM_PALETTE_ARB:
1558             case WGL_SWAP_LAYER_BUFFERS_ARB:
1559                 if (value) goto cant_match;
1560                 break;
1561
1562             case WGL_SWAP_METHOD_ARB:
1563                 if (value == WGL_SWAP_COPY_ARB)
1564                     value = 1;
1565                 else if (value == WGL_SWAP_UNDEFINED_ARB)
1566                     value = 0;
1567                 else
1568                     goto cant_match;
1569                 if (valid.backing_store && pf.backing_store != value) goto cant_match;
1570                 if (valid.double_buffer && !pf.double_buffer && value) goto cant_match;
1571                 pf.backing_store = value;
1572                 valid.backing_store = 1;
1573                 break;
1574
1575             case WGL_NUMBER_OVERLAYS_ARB:
1576             case WGL_NUMBER_UNDERLAYS_ARB:
1577                 if (value) goto cant_match;
1578                 break;
1579
1580             case WGL_SHARE_DEPTH_ARB:
1581             case WGL_SHARE_STENCIL_ARB:
1582             case WGL_SHARE_ACCUM_ARB:
1583                 /* no effect */
1584                 break;
1585
1586             case WGL_SUPPORT_GDI_ARB:
1587                 if (value) goto cant_match;
1588                 break;
1589
1590             case WGL_SUPPORT_OPENGL_ARB:
1591                 if (!value) goto cant_match;
1592                 break;
1593
1594             case WGL_DOUBLE_BUFFER_ARB:
1595                 if (valid.double_buffer && (!pf.double_buffer != !value)) goto cant_match;
1596                 pf.double_buffer = (value != 0);
1597                 valid.double_buffer = 1;
1598                 if (valid.backing_store && pf.backing_store && !pf.double_buffer) goto cant_match;
1599                 break;
1600
1601             case WGL_STEREO_ARB:
1602                 if (valid.stereo && (!pf.stereo != !value)) goto cant_match;
1603                 pf.stereo = (value != 0);
1604                 valid.stereo = 1;
1605                 break;
1606
1607             case WGL_PIXEL_TYPE_ARB:
1608                 if (value == WGL_TYPE_RGBA_FLOAT_ARB)
1609                     value = 1;
1610                 else if (value == WGL_TYPE_RGBA_ARB)
1611                     value = 0;
1612                 else
1613                 {
1614                     /* Mac contexts don't support rendering to unsigned floating
1615                        point formats, even if GL_EXT_packed_float is supported.
1616                        So, WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT is not supported. */
1617                     goto cant_match;
1618                 }
1619                 if (float_color != -1 && float_color != value) goto cant_match;
1620                 if (srgb && value) goto cant_match;
1621                 float_color = value;
1622                 break;
1623
1624             case WGL_COLOR_BITS_ARB:
1625                 if (color_bits < value) color_bits = value;
1626                 break;
1627
1628             case WGL_RED_BITS_ARB:
1629                 if (srgb && value > 8) goto cant_match;
1630                 if (red_bits < value) red_bits = value;
1631                 break;
1632
1633             case WGL_GREEN_BITS_ARB:
1634                 if (srgb && value > 8) goto cant_match;
1635                 if (green_bits < value) green_bits = value;
1636                 break;
1637
1638             case WGL_BLUE_BITS_ARB:
1639                 if (srgb && value > 8) goto cant_match;
1640                 if (blue_bits < value) blue_bits = value;
1641                 break;
1642
1643             case WGL_ALPHA_BITS_ARB:
1644                 if (alpha_bits < value) alpha_bits = value;
1645                 break;
1646
1647             case WGL_ACCUM_BITS_ARB:
1648                 if (accum_bits < value) accum_bits = value;
1649                 break;
1650
1651             case WGL_ACCUM_RED_BITS_ARB:
1652                 if (accum_red_bits < value) accum_red_bits = value;
1653                 break;
1654
1655             case WGL_ACCUM_GREEN_BITS_ARB:
1656                 if (accum_green_bits < value) accum_green_bits = value;
1657                 break;
1658
1659             case WGL_ACCUM_BLUE_BITS_ARB:
1660                 if (accum_blue_bits < value) accum_blue_bits = value;
1661                 break;
1662
1663             case WGL_ACCUM_ALPHA_BITS_ARB:
1664                 if (accum_alpha_bits < value) accum_alpha_bits = value;
1665                 break;
1666
1667             case WGL_DEPTH_BITS_ARB:
1668                 if (value > 255) goto cant_match;
1669                 if (pf.depth_bits < value) pf.depth_bits = value;
1670                 break;
1671
1672             case WGL_STENCIL_BITS_ARB:
1673                 if (value > 255) goto cant_match;
1674                 if (pf.stencil_bits < value) pf.stencil_bits = value;
1675                 break;
1676
1677             case WGL_AUX_BUFFERS_ARB:
1678                 if (value > 7) goto cant_match;
1679                 if (pf.aux_buffers < value) pf.aux_buffers = value;
1680                 break;
1681
1682             case WGL_SAMPLE_BUFFERS_ARB:
1683                 if (value > 1) goto cant_match;
1684                 if (pf.sample_buffers < value) pf.sample_buffers = value;
1685                 break;
1686
1687             case WGL_SAMPLES_ARB:
1688                 if (value > 31) goto cant_match;
1689                 if (pf.samples < value) pf.samples = value;
1690                 break;
1691
1692             case WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB: /* a.k.a. WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT */
1693                 /* sRGB is only supported for 8-bit integer color components */
1694                 if (float_color >= 1 || red_bits > 8 || green_bits > 8 || blue_bits > 8)
1695                     goto cant_match;
1696                 srgb = TRUE;
1697                 break;
1698
1699             case WGL_NUMBER_PIXEL_FORMATS_ARB:
1700             case WGL_RED_SHIFT_ARB:
1701             case WGL_GREEN_SHIFT_ARB:
1702             case WGL_BLUE_SHIFT_ARB:
1703             case WGL_ALPHA_SHIFT_ARB:
1704             case WGL_TRANSPARENT_ARB:
1705             case WGL_TRANSPARENT_RED_VALUE_ARB:
1706             case WGL_TRANSPARENT_GREEN_VALUE_ARB:
1707             case WGL_TRANSPARENT_BLUE_VALUE_ARB:
1708             case WGL_TRANSPARENT_ALPHA_VALUE_ARB:
1709             case WGL_TRANSPARENT_INDEX_VALUE_ARB:
1710                 /* ignored */
1711                 break;
1712
1713             case WGL_DRAW_TO_PBUFFER_ARB:
1714             case WGL_BIND_TO_TEXTURE_RGB_ARB:
1715             case WGL_BIND_TO_TEXTURE_RGBA_ARB:
1716             case WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV:
1717             case WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV:
1718                 if (valid.pbuffer && (!pf.pbuffer != !value)) goto cant_match;
1719                 pf.pbuffer = (value != 0);
1720                 valid.pbuffer = 1;
1721                 if ((attr == WGL_BIND_TO_TEXTURE_RGBA_ARB || attr == WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV) &&
1722                     !alpha_bits)
1723                     alpha_bits = 1;
1724                 break;
1725
1726             default:
1727                 WARN("invalid attribute %x\n", iptr[0]);
1728                 return GL_FALSE;
1729         }
1730     }
1731
1732     for (i = 0; i < nb_formats && found < nMaxFormats; i++)
1733     {
1734         const struct color_mode *mode;
1735
1736         if (valid.window && pixel_formats[i].window != pf.window) continue;
1737         if (valid.pbuffer && pixel_formats[i].pbuffer != pf.pbuffer) continue;
1738         if (valid.accelerated && pixel_formats[i].accelerated != pf.accelerated) continue;
1739         if (valid.double_buffer && pixel_formats[i].double_buffer != pf.double_buffer) continue;
1740         if (valid.stereo && pixel_formats[i].stereo != pf.stereo) continue;
1741         if (valid.backing_store && pixel_formats[i].backing_store != pf.backing_store) continue;
1742
1743         if (pixel_formats[i].aux_buffers < pf.aux_buffers) continue;
1744         if (pixel_formats[i].depth_bits < pf.depth_bits) continue;
1745         if (pixel_formats[i].stencil_bits < pf.stencil_bits) continue;
1746         if (pixel_formats[i].sample_buffers < pf.sample_buffers) continue;
1747         if (pixel_formats[i].samples < pf.samples) continue;
1748
1749         mode = &color_modes[pixel_formats[i].color_mode];
1750         /* If the mode doesn't have alpha, check requested color bits against
1751            bits per pixel instead of the mode's color bits.  On Windows, color
1752            bits sometimes exceeds r+g+b (e.g. it's 32 for an R8G8B8A0 pixel format).
1753            If an app depends on that and requests WGL_COLOR_BITS_ARB == 32 and
1754            expects that to match such a pixel format, we need to accommodate that. */
1755         if (mode->alpha_bits)
1756         {
1757             if (mode->color_bits < color_bits)
1758                 continue;
1759         }
1760         else
1761         {
1762             if (mode->bits_per_pixel < color_bits)
1763                 continue;
1764         }
1765         if (mode->red_bits < red_bits || mode->green_bits < green_bits ||
1766             mode->blue_bits < blue_bits || mode->alpha_bits < alpha_bits)
1767             continue;
1768         if (float_color != -1 && (!mode->is_float != !float_color)) continue;
1769         if (srgb && (mode->red_bits != 8 || mode->green_bits != 8 || mode->blue_bits != 8 || mode->is_float))
1770             continue;
1771
1772         if (pixel_formats[i].accum_mode)
1773         {
1774             mode = &color_modes[pixel_formats[i].accum_mode - 1];
1775             if (mode->color_bits < accum_bits || mode->red_bits < accum_red_bits ||
1776                 mode->green_bits < accum_green_bits || mode->blue_bits < accum_blue_bits ||
1777                 mode->alpha_bits < accum_alpha_bits)
1778                 continue;
1779         }
1780         else if (accum_bits || accum_red_bits || accum_green_bits || accum_blue_bits || accum_alpha_bits)
1781             continue;
1782
1783         piFormats[found++] = i;
1784     }
1785
1786 cant_match:
1787     *nNumFormats = found;
1788
1789     return TRUE;
1790 }
1791
1792
1793 /**********************************************************************
1794  *              macdrv_wglCreatePbufferARB
1795  *
1796  * WGL_ARB_pbuffer: wglCreatePbufferARB
1797  */
1798 static struct wgl_pbuffer *macdrv_wglCreatePbufferARB(HDC hdc, int iPixelFormat, int iWidth, int iHeight,
1799                                                       const int *piAttribList)
1800 {
1801     struct wgl_pbuffer* pbuffer;
1802     GLenum target = 0;
1803     GLenum internalFormat = 0;
1804     CGLError err;
1805
1806     TRACE("hdc %p iPixelFormat %d iWidth %d iHeight %d piAttribList %p\n",
1807           hdc, iPixelFormat, iWidth, iHeight, piAttribList);
1808
1809     if (!is_valid_pixel_format(iPixelFormat) || !pixel_formats[iPixelFormat].pbuffer)
1810     {
1811         WARN("invalid pixel format %d\n", iPixelFormat);
1812         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1813         return NULL;
1814     }
1815
1816     pbuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pbuffer));
1817     pbuffer->format = iPixelFormat;
1818
1819     for ( ; piAttribList && *piAttribList; piAttribList += 2)
1820     {
1821         int attr = piAttribList[0];
1822         int value = piAttribList[1];
1823
1824         switch (attr)
1825         {
1826             case WGL_PBUFFER_LARGEST_ARB:
1827                 FIXME("WGL_PBUFFER_LARGEST_ARB: %d; ignoring\n", value);
1828                 break;
1829
1830             case WGL_TEXTURE_FORMAT_ARB:
1831                 switch (value)
1832                 {
1833                     case WGL_TEXTURE_RGBA_ARB:
1834                         TRACE("WGL_TEXTURE_FORMAT_ARB: WGL_TEXTURE_RGBA_ARB\n");
1835                         internalFormat = GL_RGBA;
1836                         break;
1837                     case WGL_TEXTURE_RGB_ARB:
1838                         TRACE("WGL_TEXTURE_FORMAT_ARB: WGL_TEXTURE_RGB_ARB\n");
1839                         internalFormat = GL_RGB;
1840                         break;
1841                     case WGL_NO_TEXTURE_ARB:
1842                         TRACE("WGL_TEXTURE_FORMAT_ARB: WGL_NO_TEXTURE_ARB\n");
1843                         internalFormat = 0;
1844                         break;
1845                     default:
1846                         WARN("unknown WGL_TEXTURE_FORMAT_ARB value 0x%x\n", value);
1847                         SetLastError(ERROR_INVALID_DATA);
1848                         goto done;
1849                 }
1850                 break;
1851
1852             case WGL_TEXTURE_TARGET_ARB:
1853                 pbuffer->face = 0;
1854                 switch (value)
1855                 {
1856                     case WGL_NO_TEXTURE_ARB:
1857                         TRACE("WGL_TEXTURE_TARGET_ARB: WGL_NO_TEXTURE_ARB\n");
1858                         target = 0;
1859                         break;
1860                     case WGL_TEXTURE_CUBE_MAP_ARB:
1861                         TRACE("WGL_TEXTURE_TARGET_ARB: WGL_TEXTURE_CUBE_MAP_ARB\n");
1862                         target = GL_TEXTURE_CUBE_MAP;
1863                         pbuffer->face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
1864                         break;
1865                     case WGL_TEXTURE_1D_ARB:
1866                         FIXME("WGL_TEXTURE_TARGET_ARB: WGL_TEXTURE_1D_ARB; not supported\n");
1867                         SetLastError(ERROR_NO_SYSTEM_RESOURCES);
1868                         goto done;
1869                     case WGL_TEXTURE_2D_ARB:
1870                         TRACE("WGL_TEXTURE_TARGET_ARB: WGL_TEXTURE_2D_ARB\n");
1871                         target = GL_TEXTURE_2D;
1872                         break;
1873                     case WGL_TEXTURE_RECTANGLE_NV:
1874                         TRACE("WGL_TEXTURE_TARGET_ARB: WGL_TEXTURE_RECTANGLE_NV\n");
1875                         target = GL_TEXTURE_RECTANGLE;
1876                         break;
1877                     default:
1878                         WARN("unknown WGL_TEXTURE_TARGET_ARB value 0x%x\n", value);
1879                         SetLastError(ERROR_INVALID_DATA);
1880                         goto done;
1881                 }
1882                 break;
1883
1884             case WGL_MIPMAP_TEXTURE_ARB:
1885                 TRACE("WGL_MIPMAP_TEXTURE_ARB: %d\n", value);
1886                 pbuffer->max_level = 0;
1887                 if (value)
1888                 {
1889                     int size = min(iWidth, iHeight) / 2;
1890                     while (size)
1891                     {
1892                         pbuffer->max_level++;
1893                         size /= 2;
1894                     }
1895                 }
1896                 break;
1897
1898             default:
1899                 WARN("unknown attribute 0x%x\n", attr);
1900                 SetLastError(ERROR_INVALID_DATA);
1901                 goto done;
1902         }
1903     }
1904
1905     if (!target || !internalFormat)
1906     {
1907         pbuffer->no_texture = TRUE;
1908         /* no actual way to turn off ability to texture; use most permissive target */
1909         target = GL_TEXTURE_RECTANGLE;
1910         internalFormat = GL_RGB;
1911     }
1912
1913     err = CGLCreatePBuffer(iWidth, iHeight, target, internalFormat, pbuffer->max_level, &pbuffer->pbuffer);
1914     if (err != kCGLNoError)
1915     {
1916         WARN("CGLCreatePBuffer failed; err %d %s\n", err, CGLErrorString(err));
1917         pbuffer->pbuffer = NULL;
1918         if (err == kCGLBadAlloc)
1919             SetLastError(ERROR_NO_SYSTEM_RESOURCES);
1920         else
1921             SetLastError(ERROR_INVALID_DATA);
1922     }
1923
1924 done:
1925     if (!pbuffer->pbuffer)
1926     {
1927         HeapFree(GetProcessHeap(), 0, pbuffer);
1928         return NULL;
1929     }
1930
1931     TRACE(" -> %p\n", pbuffer);
1932     return pbuffer;
1933 }
1934
1935
1936 /**********************************************************************
1937  *              macdrv_wglDestroyPbufferARB
1938  *
1939  * WGL_ARB_pbuffer: wglDestroyPbufferARB
1940  */
1941 static BOOL macdrv_wglDestroyPbufferARB(struct wgl_pbuffer *pbuffer)
1942 {
1943     TRACE("pbuffer %p\n", pbuffer);
1944     if (pbuffer && pbuffer->pbuffer)
1945         CGLReleasePBuffer(pbuffer->pbuffer);
1946     HeapFree(GetProcessHeap(), 0, pbuffer);
1947     return GL_TRUE;
1948 }
1949
1950
1951 /**********************************************************************
1952  *              macdrv_wglGetExtensionsStringARB
1953  *
1954  * WGL_ARB_extensions_string: wglGetExtensionsStringARB
1955  */
1956 static const GLubyte *macdrv_wglGetExtensionsStringARB(HDC hdc)
1957 {
1958     /* FIXME: Since we're given an HDC, this should be device-specific.  I.e.
1959               this can be specific to the CGL renderer like we're supposed to do. */
1960     TRACE("returning \"%s\"\n", gl_info.wglExtensions);
1961     return (const GLubyte*)gl_info.wglExtensions;
1962 }
1963
1964
1965 /**********************************************************************
1966  *              macdrv_wglGetExtensionsStringEXT
1967  *
1968  * WGL_EXT_extensions_string: wglGetExtensionsStringEXT
1969  */
1970 static const GLubyte *macdrv_wglGetExtensionsStringEXT(void)
1971 {
1972     TRACE("returning \"%s\"\n", gl_info.wglExtensions);
1973     return (const GLubyte*)gl_info.wglExtensions;
1974 }
1975
1976
1977 /**********************************************************************
1978  *              macdrv_wglGetPbufferDCARB
1979  *
1980  * WGL_ARB_pbuffer: wglGetPbufferDCARB
1981  */
1982 static HDC macdrv_wglGetPbufferDCARB(struct wgl_pbuffer *pbuffer)
1983 {
1984     HDC hdc;
1985     struct wgl_pbuffer *prev;
1986
1987     hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
1988     if (!hdc) return 0;
1989
1990     EnterCriticalSection(&dc_pbuffers_section);
1991     prev = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, hdc);
1992     if (prev)
1993     {
1994         CGLReleasePBuffer(prev->pbuffer);
1995         HeapFree(GetProcessHeap(), 0, prev);
1996     }
1997     CFDictionarySetValue(dc_pbuffers, hdc, pbuffer);
1998     LeaveCriticalSection(&dc_pbuffers_section);
1999
2000     TRACE("pbuffer %p -> hdc %p\n", pbuffer, hdc);
2001     return hdc;
2002 }
2003
2004
2005 /**********************************************************************
2006  *              macdrv_wglGetPixelFormatAttribivARB
2007  *
2008  * WGL_ARB_pixel_format: wglGetPixelFormatAttribivARB
2009  */
2010 static BOOL macdrv_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelFormat, int iLayerPlane,
2011                                                 UINT nAttributes, const int *piAttributes, int *piValues)
2012 {
2013     const pixel_format *pf;
2014     UINT i;
2015
2016     TRACE("hdc %p iPixelFormat %d iLayerPlane %d nAttributes %u piAttributes %p piValues %p\n",
2017           hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
2018
2019     if (!nAttributes) return GL_TRUE;
2020
2021     if (nAttributes == 1 && piAttributes[0] == WGL_NUMBER_PIXEL_FORMATS_ARB)
2022     {
2023         piValues[0] = nb_formats;
2024         return GL_TRUE;
2025     }
2026
2027     pf = get_pixel_format(iPixelFormat, TRUE /* non-displayable */);
2028     if (!pf)
2029     {
2030         WARN("invalid pixel format %d\n", iPixelFormat);
2031         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2032         return GL_FALSE;
2033     }
2034
2035     for (i = 0; i < nAttributes; ++i)
2036     {
2037         switch (piAttributes[i])
2038         {
2039             case WGL_NUMBER_PIXEL_FORMATS_ARB:
2040                 piValues[i] = nb_formats;
2041                 break;
2042
2043             case WGL_DRAW_TO_WINDOW_ARB:
2044                 piValues[i] = pf->window ? GL_TRUE : GL_FALSE;
2045                 break;
2046
2047             case WGL_DRAW_TO_BITMAP_ARB:
2048                 piValues[i] = GL_FALSE;
2049                 break;
2050
2051             case WGL_ACCELERATION_ARB:
2052                 if (iLayerPlane) goto invalid_layer;
2053                 if (pf->accelerated)
2054                     piValues[i] = WGL_FULL_ACCELERATION_ARB;
2055                 else
2056                     piValues[i] = WGL_NO_ACCELERATION_ARB;
2057                 break;
2058
2059             case WGL_NEED_PALETTE_ARB:
2060             case WGL_NEED_SYSTEM_PALETTE_ARB:
2061             case WGL_SWAP_LAYER_BUFFERS_ARB:
2062                 piValues[i] = GL_FALSE;
2063                 break;
2064
2065             case WGL_SWAP_METHOD_ARB:
2066                 if (pf->double_buffer && pf->backing_store)
2067                     piValues[i] = WGL_SWAP_COPY_ARB;
2068                 else
2069                     piValues[i] = WGL_SWAP_UNDEFINED_ARB;
2070                 break;
2071
2072             case WGL_NUMBER_OVERLAYS_ARB:
2073             case WGL_NUMBER_UNDERLAYS_ARB:
2074                 piValues[i] = 0;
2075                 break;
2076
2077             case WGL_TRANSPARENT_ARB:
2078                 if (iLayerPlane) goto invalid_layer;
2079                 piValues[i] = GL_FALSE;
2080                 break;
2081
2082             case WGL_TRANSPARENT_RED_VALUE_ARB:
2083             case WGL_TRANSPARENT_GREEN_VALUE_ARB:
2084             case WGL_TRANSPARENT_BLUE_VALUE_ARB:
2085             case WGL_TRANSPARENT_ALPHA_VALUE_ARB:
2086             case WGL_TRANSPARENT_INDEX_VALUE_ARB:
2087                 if (iLayerPlane) goto invalid_layer;
2088                 piValues[i] = 0;
2089                 break;
2090
2091             case WGL_SHARE_DEPTH_ARB:
2092             case WGL_SHARE_STENCIL_ARB:
2093             case WGL_SHARE_ACCUM_ARB:
2094                 if (iLayerPlane) goto invalid_layer;
2095                 piValues[i] = GL_TRUE;
2096                 break;
2097
2098             case WGL_SUPPORT_GDI_ARB:
2099                 if (iLayerPlane) goto invalid_layer;
2100                 piValues[i] = GL_FALSE;
2101                 break;
2102
2103             case WGL_SUPPORT_OPENGL_ARB:
2104                 if (iLayerPlane) goto invalid_layer;
2105                 piValues[i] = GL_TRUE;
2106                 break;
2107
2108             case WGL_DOUBLE_BUFFER_ARB:
2109                 if (iLayerPlane) goto invalid_layer;
2110                 piValues[i] = pf->double_buffer ? GL_TRUE : GL_FALSE;
2111                 break;
2112
2113             case WGL_STEREO_ARB:
2114                 if (iLayerPlane) goto invalid_layer;
2115                 piValues[i] = pf->stereo ? GL_TRUE : GL_FALSE;
2116                 break;
2117
2118             case WGL_PIXEL_TYPE_ARB:
2119                 if (iLayerPlane) goto invalid_layer;
2120                 if (color_modes[pf->color_mode].is_float)
2121                     piValues[i] = WGL_TYPE_RGBA_FLOAT_ARB;
2122                 else
2123                     piValues[i] = WGL_TYPE_RGBA_ARB;
2124                 /* WGL_EXT_pixel_format_packed_float may be supported, which should in theory
2125                    make another pixel type available: WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT.
2126                    However, Mac contexts don't support rendering to unsigned floating-point
2127                    formats, even when GL_EXT_packed_float is supported. */
2128                 break;
2129
2130             case WGL_COLOR_BITS_ARB:
2131                 if (iLayerPlane) goto invalid_layer;
2132                 /* If the mode doesn't have alpha, return bits per pixel instead
2133                    of color bits.  On Windows, color bits sometimes exceeds r+g+b
2134                    (e.g. it's 32 for an R8G8B8A0 pixel format).  If an app depends
2135                    on that and expects that WGL_COLOR_BITS_ARB >= 32 for such a
2136                    pixel format, we need to accommodate that. */
2137                 if (color_modes[pf->color_mode].alpha_bits)
2138                     piValues[i] = color_modes[pf->color_mode].color_bits;
2139                 else
2140                     piValues[i] = color_modes[pf->color_mode].bits_per_pixel;
2141                 break;
2142
2143             case WGL_RED_BITS_ARB:
2144                 if (iLayerPlane) goto invalid_layer;
2145                 piValues[i] = color_modes[pf->color_mode].red_bits;
2146                 break;
2147
2148             case WGL_RED_SHIFT_ARB:
2149                 if (iLayerPlane) goto invalid_layer;
2150                 piValues[i] = color_modes[pf->color_mode].red_shift;
2151                 break;
2152
2153             case WGL_GREEN_BITS_ARB:
2154                 if (iLayerPlane) goto invalid_layer;
2155                 piValues[i] = color_modes[pf->color_mode].green_bits;
2156                 break;
2157
2158             case WGL_GREEN_SHIFT_ARB:
2159                 if (iLayerPlane) goto invalid_layer;
2160                 piValues[i] = color_modes[pf->color_mode].green_shift;
2161                 break;
2162
2163             case WGL_BLUE_BITS_ARB:
2164                 if (iLayerPlane) goto invalid_layer;
2165                 piValues[i] = color_modes[pf->color_mode].blue_bits;
2166                 break;
2167
2168             case WGL_BLUE_SHIFT_ARB:
2169                 if (iLayerPlane) goto invalid_layer;
2170                 piValues[i] = color_modes[pf->color_mode].blue_shift;
2171                 break;
2172
2173             case WGL_ALPHA_BITS_ARB:
2174                 if (iLayerPlane) goto invalid_layer;
2175                 piValues[i] = color_modes[pf->color_mode].alpha_bits;
2176                 break;
2177
2178             case WGL_ALPHA_SHIFT_ARB:
2179                 if (iLayerPlane) goto invalid_layer;
2180                 piValues[i] = color_modes[pf->color_mode].alpha_shift;
2181                 break;
2182
2183             case WGL_ACCUM_BITS_ARB:
2184                 if (iLayerPlane) goto invalid_layer;
2185                 if (pf->accum_mode)
2186                     piValues[i] = color_modes[pf->accum_mode - 1].color_bits;
2187                 else
2188                     piValues[i] = 0;
2189                 break;
2190
2191             case WGL_ACCUM_RED_BITS_ARB:
2192                 if (iLayerPlane) goto invalid_layer;
2193                 if (pf->accum_mode)
2194                     piValues[i] = color_modes[pf->accum_mode - 1].red_bits;
2195                 else
2196                     piValues[i] = 0;
2197                 break;
2198
2199             case WGL_ACCUM_GREEN_BITS_ARB:
2200                 if (iLayerPlane) goto invalid_layer;
2201                 if (pf->accum_mode)
2202                     piValues[i] = color_modes[pf->accum_mode - 1].green_bits;
2203                 else
2204                     piValues[i] = 0;
2205                 break;
2206
2207             case WGL_ACCUM_BLUE_BITS_ARB:
2208                 if (iLayerPlane) goto invalid_layer;
2209                 if (pf->accum_mode)
2210                     piValues[i] = color_modes[pf->accum_mode - 1].blue_bits;
2211                 else
2212                     piValues[i] = 0;
2213                 break;
2214
2215             case WGL_ACCUM_ALPHA_BITS_ARB:
2216                 if (iLayerPlane) goto invalid_layer;
2217                 if (pf->accum_mode)
2218                     piValues[i] = color_modes[pf->accum_mode - 1].alpha_bits;
2219                 else
2220                     piValues[i] = 0;
2221                 break;
2222
2223             case WGL_DEPTH_BITS_ARB:
2224                 if (iLayerPlane) goto invalid_layer;
2225                 piValues[i] = pf->depth_bits;
2226                 break;
2227
2228             case WGL_STENCIL_BITS_ARB:
2229                 if (iLayerPlane) goto invalid_layer;
2230                 piValues[i] = pf->stencil_bits;
2231                 break;
2232
2233             case WGL_AUX_BUFFERS_ARB:
2234                 if (iLayerPlane) goto invalid_layer;
2235                 piValues[i] = pf->aux_buffers;
2236                 break;
2237
2238             case WGL_SAMPLE_BUFFERS_ARB:
2239                 if (iLayerPlane) goto invalid_layer;
2240                 piValues[i] = pf->sample_buffers;
2241                 break;
2242
2243             case WGL_SAMPLES_ARB:
2244                 if (iLayerPlane) goto invalid_layer;
2245                 piValues[i] = pf->samples;
2246                 break;
2247
2248             case WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB: /* a.k.a. WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT */
2249                 if (iLayerPlane) goto invalid_layer;
2250                 /* sRGB is only supported for 8-bit integer color components */
2251                 if (color_modes[pf->color_mode].red_bits == 8 &&
2252                     color_modes[pf->color_mode].green_bits == 8 &&
2253                     color_modes[pf->color_mode].blue_bits == 8 &&
2254                     !color_modes[pf->color_mode].is_float)
2255                     piValues[i] = GL_TRUE;
2256                 else
2257                     piValues[i] = GL_FALSE;
2258                 break;
2259
2260             case WGL_DRAW_TO_PBUFFER_ARB:
2261             case WGL_BIND_TO_TEXTURE_RGB_ARB:
2262             case WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV:
2263                 piValues[i] = pf->pbuffer ? GL_TRUE : GL_FALSE;
2264                 break;
2265
2266             case WGL_BIND_TO_TEXTURE_RGBA_ARB:
2267             case WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV:
2268                 piValues[i] = (pf->pbuffer && color_modes[pf->color_mode].alpha_bits) ? GL_TRUE : GL_FALSE;
2269                 break;
2270
2271             case WGL_MAX_PBUFFER_WIDTH_ARB:
2272                 piValues[i] = gl_info.max_viewport_dims[0];
2273                 break;
2274
2275             case WGL_MAX_PBUFFER_HEIGHT_ARB:
2276                 piValues[i] = gl_info.max_viewport_dims[1];
2277                 break;
2278
2279             case WGL_MAX_PBUFFER_PIXELS_ARB:
2280                 piValues[i] = gl_info.max_viewport_dims[0] * gl_info.max_viewport_dims[1];
2281                 break;
2282
2283             default:
2284                 WARN("invalid attribute %x\n", piAttributes[i]);
2285                 return GL_FALSE;
2286         }
2287
2288         TRACE("piAttributes[%d] (%x) -> %x\n", i, piAttributes[i], piValues[i]);
2289     }
2290
2291     return GL_TRUE;
2292
2293 invalid_layer:
2294     FIXME("unsupported iLayerPlane %d\n", iLayerPlane);
2295     return GL_FALSE;
2296 }
2297
2298
2299 /**********************************************************************
2300  *              macdrv_wglGetPixelFormatAttribfvARB
2301  *
2302  * WGL_ARB_pixel_format: wglGetPixelFormatAttribfvARB
2303  */
2304 static BOOL macdrv_wglGetPixelFormatAttribfvARB(HDC hdc, int iPixelFormat, int iLayerPlane,
2305                                                 UINT nAttributes, const int *piAttributes, FLOAT *pfValues)
2306 {
2307     int *attr;
2308     int ret;
2309
2310     TRACE("hdc %p iPixelFormat %d iLayerPlane %d nAttributes %u piAttributes %p pfValues %p\n",
2311           hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
2312
2313     /* Allocate a temporary array to store integer values */
2314     attr = HeapAlloc(GetProcessHeap(), 0, nAttributes * sizeof(int));
2315     if (!attr)
2316     {
2317         ERR("couldn't allocate %d array\n", nAttributes);
2318         return GL_FALSE;
2319     }
2320
2321     /* Piggy-back on wglGetPixelFormatAttribivARB */
2322     ret = macdrv_wglGetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, attr);
2323     if (ret)
2324     {
2325         UINT i;
2326
2327         /* Convert integer values to float. Should also check for attributes
2328            that can give decimal values here */
2329         for (i = 0; i < nAttributes; i++)
2330             pfValues[i] = attr[i];
2331     }
2332
2333     HeapFree(GetProcessHeap(), 0, attr);
2334     return ret;
2335 }
2336
2337
2338 /**********************************************************************
2339  *              macdrv_wglGetSwapIntervalEXT
2340  *
2341  * WGL_EXT_swap_control: wglGetSwapIntervalEXT
2342  */
2343 static int macdrv_wglGetSwapIntervalEXT(void)
2344 {
2345     struct wgl_context *context = NtCurrentTeb()->glContext;
2346     long value;
2347     CGLError err;
2348
2349     TRACE("\n");
2350
2351     err = CGLGetParameter(context->cglcontext, kCGLCPSwapInterval, (GLint*)&value);
2352     if (err != kCGLNoError)
2353     {
2354         WARN("CGLGetParameter(kCGLCPSwapInterval) failed; error %d %s\n",
2355              err, CGLErrorString(err));
2356         value = 1;
2357     }
2358
2359     return value;
2360 }
2361
2362
2363 /***********************************************************************
2364  *              macdrv_wglMakeContextCurrentARB
2365  *
2366  * WGL_ARB_make_current_read: wglMakeContextCurrentARB
2367  *
2368  * This is not supported directly by OpenGL on the Mac.  We emulate it
2369  * by hooking into glReadPixels, glCopyPixels, and glCopyColorTable to
2370  * temporarily swap the drawable.  This follows the technique used in
2371  * the implementation of Mesa GLX for Apple.
2372  */
2373 static BOOL macdrv_wglMakeContextCurrentARB(HDC draw_hdc, HDC read_hdc, struct wgl_context *context)
2374 {
2375     struct macdrv_win_data *data;
2376     HWND hwnd;
2377
2378     TRACE("draw_hdc %p read_hdc %p context %p/%p/%p\n", draw_hdc, read_hdc, context,
2379           (context ? context->context : NULL), (context ? context->cglcontext : NULL));
2380
2381     if (!context)
2382     {
2383         macdrv_make_context_current(NULL, NULL);
2384         NtCurrentTeb()->glContext = NULL;
2385         return TRUE;
2386     }
2387
2388     if ((hwnd = WindowFromDC(draw_hdc)))
2389     {
2390         if (!(data = get_win_data(hwnd)))
2391         {
2392             FIXME("draw DC for window %p of other process: not implemented\n", hwnd);
2393             return FALSE;
2394         }
2395
2396         if (!data->pixel_format)
2397         {
2398             WARN("no pixel format set\n");
2399             release_win_data(data);
2400             SetLastError(ERROR_INVALID_HANDLE);
2401             return FALSE;
2402         }
2403         if (context->format != data->pixel_format)
2404         {
2405             WARN("mismatched pixel format draw_hdc %p %u context %p %u\n", draw_hdc, data->pixel_format, context, context->format);
2406             release_win_data(data);
2407             SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2408             return FALSE;
2409         }
2410
2411         context->draw_view = data->gl_view;
2412         context->draw_pbuffer = NULL;
2413         release_win_data(data);
2414     }
2415     else
2416     {
2417         struct wgl_pbuffer *pbuffer;
2418
2419         EnterCriticalSection(&dc_pbuffers_section);
2420         pbuffer = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, draw_hdc);
2421         if (pbuffer)
2422         {
2423             if (context->format != pbuffer->format)
2424             {
2425                 WARN("mismatched pixel format draw_hdc %p %u context %p %u\n", draw_hdc, pbuffer->format, context, context->format);
2426                 LeaveCriticalSection(&dc_pbuffers_section);
2427                 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2428                 return FALSE;
2429             }
2430         }
2431         else
2432         {
2433             WARN("no window or pbuffer for DC\n");
2434             LeaveCriticalSection(&dc_pbuffers_section);
2435             SetLastError(ERROR_INVALID_HANDLE);
2436             return FALSE;
2437         }
2438
2439         context->draw_view = NULL;
2440         context->draw_pbuffer = pbuffer;
2441         LeaveCriticalSection(&dc_pbuffers_section);
2442     }
2443
2444     context->read_view = NULL;
2445     context->read_pbuffer = NULL;
2446     if (read_hdc && read_hdc != draw_hdc)
2447     {
2448         if ((hwnd = WindowFromDC(read_hdc)))
2449         {
2450             if ((data = get_win_data(hwnd)))
2451             {
2452                 if (data->gl_view != context->draw_view)
2453                     context->read_view = data->gl_view;
2454                 release_win_data(data);
2455             }
2456         }
2457         else
2458         {
2459             EnterCriticalSection(&dc_pbuffers_section);
2460             context->read_pbuffer = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, read_hdc);
2461             LeaveCriticalSection(&dc_pbuffers_section);
2462         }
2463     }
2464
2465     TRACE("making context current with draw_view %p draw_pbuffer %p read_view %p read_pbuffer %p format %u\n",
2466           context->draw_view, context->draw_pbuffer, context->read_view, context->read_pbuffer, context->format);
2467
2468     make_context_current(context, FALSE);
2469     context->has_been_current = TRUE;
2470     NtCurrentTeb()->glContext = context;
2471
2472     return TRUE;
2473 }
2474
2475
2476 /**********************************************************************
2477  *              macdrv_wglQueryPbufferARB
2478  *
2479  * WGL_ARB_pbuffer: wglQueryPbufferARB
2480  */
2481 static BOOL macdrv_wglQueryPbufferARB(struct wgl_pbuffer *pbuffer, int iAttribute, int *piValue)
2482 {
2483     CGLError err;
2484     GLsizei width;
2485     GLsizei height;
2486     GLenum target;
2487     GLenum internalFormat;
2488     GLint mipmap;
2489
2490     TRACE("pbuffer %p iAttribute 0x%x piValue %p\n", pbuffer, iAttribute, piValue);
2491
2492     err = CGLDescribePBuffer(pbuffer->pbuffer, &width, &height, &target, &internalFormat, &mipmap);
2493     if (err != kCGLNoError)
2494     {
2495         WARN("CGLDescribePBuffer failed; error %d %s\n", err, CGLErrorString(err));
2496         SetLastError(ERROR_INVALID_HANDLE);
2497         return GL_FALSE;
2498     }
2499
2500     switch (iAttribute)
2501     {
2502         case WGL_PBUFFER_WIDTH_ARB:
2503             *piValue = width;
2504             break;
2505         case WGL_PBUFFER_HEIGHT_ARB:
2506             *piValue = height;
2507             break;
2508         case WGL_PBUFFER_LOST_ARB:
2509             /* Mac PBuffers can't be lost */
2510             *piValue = GL_FALSE;
2511             break;
2512         case WGL_TEXTURE_FORMAT_ARB:
2513             if (pbuffer->no_texture)
2514                 *piValue = WGL_NO_TEXTURE_ARB;
2515             else switch (internalFormat)
2516             {
2517                 case GL_RGBA:
2518                     *piValue = WGL_TEXTURE_RGBA_ARB;
2519                     break;
2520                 case GL_RGB:
2521                 default:
2522                     *piValue = WGL_TEXTURE_RGB_ARB;
2523                     break;
2524             }
2525             break;
2526         case WGL_TEXTURE_TARGET_ARB:
2527             if (pbuffer->no_texture)
2528                 *piValue = WGL_NO_TEXTURE_ARB;
2529             else switch (target)
2530             {
2531                 case GL_TEXTURE_CUBE_MAP:
2532                     *piValue = WGL_TEXTURE_CUBE_MAP_ARB;
2533                     break;
2534                 case GL_TEXTURE_2D:
2535                     *piValue = WGL_TEXTURE_2D_ARB;
2536                     break;
2537                 case GL_TEXTURE_RECTANGLE:
2538                 default:
2539                     *piValue = WGL_TEXTURE_RECTANGLE_NV;
2540                     break;
2541             }
2542             break;
2543         case WGL_MIPMAP_TEXTURE_ARB:
2544             *piValue = (pbuffer->max_level > 0);
2545             break;
2546         case WGL_MIPMAP_LEVEL_ARB:
2547             *piValue = pbuffer->level;
2548             break;
2549         case WGL_CUBE_MAP_FACE_ARB:
2550             switch (pbuffer->face)
2551             {
2552                 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
2553                 default:
2554                     *piValue = WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB;
2555                     break;
2556                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
2557                     *piValue = WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB;
2558                     break;
2559                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
2560                     *piValue = WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB;
2561                     break;
2562                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
2563                     *piValue = WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB;
2564                     break;
2565                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
2566                     *piValue = WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB;
2567                     break;
2568                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
2569                     *piValue = WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB;
2570                     break;
2571             }
2572             break;
2573         default:
2574             WARN("invalid attribute 0x%x\n", iAttribute);
2575             SetLastError(ERROR_INVALID_DATA);
2576             return GL_FALSE;
2577     }
2578
2579     return GL_TRUE;
2580 }
2581
2582
2583 /**********************************************************************
2584  *              macdrv_wglReleasePbufferDCARB
2585  *
2586  * WGL_ARB_pbuffer: wglReleasePbufferDCARB
2587  */
2588 static int macdrv_wglReleasePbufferDCARB(struct wgl_pbuffer *pbuffer, HDC hdc)
2589 {
2590     struct wgl_pbuffer *prev;
2591
2592     TRACE("pbuffer %p hdc %p\n", pbuffer, hdc);
2593
2594     EnterCriticalSection(&dc_pbuffers_section);
2595
2596     prev = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, hdc);
2597     if (prev)
2598     {
2599         if (prev != pbuffer)
2600             FIXME("hdc %p isn't associated with pbuffer %p\n", hdc, pbuffer);
2601         CGLReleasePBuffer(prev->pbuffer);
2602         HeapFree(GetProcessHeap(), 0, prev);
2603         CFDictionaryRemoveValue(dc_pbuffers, hdc);
2604     }
2605     else hdc = 0;
2606
2607     LeaveCriticalSection(&dc_pbuffers_section);
2608
2609     return hdc && DeleteDC(hdc);
2610 }
2611
2612
2613 /**********************************************************************
2614  *              macdrv_wglReleaseTexImageARB
2615  *
2616  * WGL_ARB_render_texture: wglReleaseTexImageARB
2617  */
2618 static BOOL macdrv_wglReleaseTexImageARB(struct wgl_pbuffer *pbuffer, int iBuffer)
2619 {
2620     struct wgl_context *context = NtCurrentTeb()->glContext;
2621     CGLError err;
2622
2623     TRACE("pbuffer %p iBuffer 0x%x; stub!\n", pbuffer, iBuffer);
2624
2625     if (pbuffer->no_texture)
2626     {
2627         SetLastError(ERROR_INVALID_OPERATION);
2628         return GL_FALSE;
2629     }
2630
2631     err = CGLTexImagePBuffer(context->cglcontext, pbuffer->pbuffer, GL_NONE);
2632     if (err != kCGLNoError)
2633     {
2634         WARN("CGLTexImagePBuffer failed with err %d %s\n", err, CGLErrorString(err));
2635         SetLastError(ERROR_INVALID_OPERATION);
2636         return GL_FALSE;
2637     }
2638
2639     return GL_TRUE;
2640 }
2641
2642
2643 /**********************************************************************
2644  *              macdrv_wglSetPbufferAttribARB
2645  *
2646  * WGL_ARB_render_texture: wglSetPbufferAttribARB
2647  */
2648 static BOOL macdrv_wglSetPbufferAttribARB(struct wgl_pbuffer *pbuffer, const int *piAttribList)
2649 {
2650     struct wgl_context *context = NtCurrentTeb()->glContext;
2651
2652     TRACE("pbuffer %p piAttribList %p\n", pbuffer, piAttribList);
2653
2654     for ( ; piAttribList && *piAttribList; piAttribList += 2)
2655     {
2656         int attr = piAttribList[0];
2657         int value = piAttribList[1];
2658         switch (attr)
2659         {
2660             case WGL_MIPMAP_LEVEL_ARB:
2661                 TRACE("WGL_MIPMAP_LEVEL_ARB: %d\n", value);
2662                 pbuffer->level = value;
2663                 break;
2664             case WGL_CUBE_MAP_FACE_ARB:
2665                 switch (value)
2666                 {
2667                     case WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
2668                         TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB\n");
2669                         pbuffer->face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
2670                         break;
2671                     case WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
2672                         TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB\n");
2673                         pbuffer->face = GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
2674                         break;
2675                     case WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
2676                         TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB\n");
2677                         pbuffer->face = GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
2678                         break;
2679                     case WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
2680                         TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB\n");
2681                         pbuffer->face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
2682                         break;
2683                     case WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
2684                         TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB\n");
2685                         pbuffer->face = GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
2686                         break;
2687                     case WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
2688                         TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB\n");
2689                         pbuffer->face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
2690                         break;
2691                     default:
2692                         WARN("unknown WGL_CUBE_MAP_FACE_ARB value 0x%x\n", value);
2693                         SetLastError(ERROR_INVALID_DATA);
2694                         return GL_FALSE;
2695                 }
2696                 break;
2697             default:
2698                 WARN("invalide attribute 0x%x\n", attr);
2699                 SetLastError(ERROR_INVALID_DATA);
2700                 return GL_FALSE;
2701         }
2702     }
2703
2704     if (context && context->draw_pbuffer == pbuffer)
2705         make_context_current(context, FALSE);
2706
2707     return GL_TRUE;
2708 }
2709
2710
2711 /**********************************************************************
2712  *              macdrv_wglSetPixelFormatWINE
2713  *
2714  * WGL_WINE_pixel_format_passthrough: wglSetPixelFormatWINE
2715  */
2716 static BOOL macdrv_wglSetPixelFormatWINE(HDC hdc, int fmt)
2717 {
2718     return set_pixel_format(hdc, fmt, TRUE);
2719 }
2720
2721
2722 /**********************************************************************
2723  *              macdrv_wglSwapIntervalEXT
2724  *
2725  * WGL_EXT_swap_control: wglSwapIntervalEXT
2726  */
2727 static BOOL macdrv_wglSwapIntervalEXT(int interval)
2728 {
2729     struct wgl_context *context = NtCurrentTeb()->glContext;
2730     long value;
2731     CGLError err;
2732
2733     TRACE("interval %d\n", interval);
2734
2735     if (interval < 0)
2736     {
2737         SetLastError(ERROR_INVALID_DATA);
2738         return FALSE;
2739     }
2740
2741     if (interval > 1)
2742         interval = 1;
2743
2744     value = interval;
2745     err = CGLSetParameter(context->cglcontext, kCGLCPSwapInterval, (GLint*)&value);
2746     if (err != kCGLNoError)
2747     {
2748         WARN("CGLSetParameter(kCGLCPSwapInterval) failed; error %d %s\n",
2749              err, CGLErrorString(err));
2750         SetLastError(ERROR_GEN_FAILURE);
2751         return FALSE;
2752     }
2753
2754     return TRUE;
2755 }
2756
2757
2758 static void register_extension(const char *ext)
2759 {
2760     if (gl_info.wglExtensions[0])
2761         strcat(gl_info.wglExtensions, " ");
2762     strcat(gl_info.wglExtensions, ext);
2763
2764     TRACE("'%s'\n", ext);
2765 }
2766
2767 static void load_extensions(void)
2768 {
2769     /*
2770      * ARB Extensions
2771      */
2772     register_extension("WGL_ARB_extensions_string");
2773     opengl_funcs.ext.p_wglGetExtensionsStringARB = macdrv_wglGetExtensionsStringARB;
2774
2775     register_extension("WGL_ARB_make_current_read");
2776     opengl_funcs.ext.p_wglGetCurrentReadDCARB   = (void *)1;  /* never called */
2777     opengl_funcs.ext.p_wglMakeContextCurrentARB = macdrv_wglMakeContextCurrentARB;
2778
2779     register_extension("WGL_ARB_pixel_format");
2780     opengl_funcs.ext.p_wglChoosePixelFormatARB      = macdrv_wglChoosePixelFormatARB;
2781     opengl_funcs.ext.p_wglGetPixelFormatAttribfvARB = macdrv_wglGetPixelFormatAttribfvARB;
2782     opengl_funcs.ext.p_wglGetPixelFormatAttribivARB = macdrv_wglGetPixelFormatAttribivARB;
2783
2784     if (gluCheckExtension((GLubyte*)"GL_ARB_color_buffer_float", (GLubyte*)gl_info.glExtensions))
2785     {
2786         register_extension("WGL_ARB_pixel_format_float");
2787         register_extension("WGL_ATI_pixel_format_float");
2788     }
2789
2790     if (gluCheckExtension((GLubyte*)"GL_ARB_multisample", (GLubyte*)gl_info.glExtensions))
2791         register_extension("WGL_ARB_multisample");
2792
2793     if (gluCheckExtension((GLubyte*)"GL_ARB_framebuffer_sRGB", (GLubyte*)gl_info.glExtensions))
2794         register_extension("WGL_ARB_framebuffer_sRGB");
2795
2796     if (gluCheckExtension((GLubyte*)"GL_APPLE_pixel_buffer", (GLubyte*)gl_info.glExtensions))
2797     {
2798         register_extension("WGL_ARB_pbuffer");
2799         opengl_funcs.ext.p_wglCreatePbufferARB    = macdrv_wglCreatePbufferARB;
2800         opengl_funcs.ext.p_wglDestroyPbufferARB   = macdrv_wglDestroyPbufferARB;
2801         opengl_funcs.ext.p_wglGetPbufferDCARB     = macdrv_wglGetPbufferDCARB;
2802         opengl_funcs.ext.p_wglQueryPbufferARB     = macdrv_wglQueryPbufferARB;
2803         opengl_funcs.ext.p_wglReleasePbufferDCARB = macdrv_wglReleasePbufferDCARB;
2804
2805         register_extension("WGL_ARB_render_texture");
2806         opengl_funcs.ext.p_wglBindTexImageARB       = macdrv_wglBindTexImageARB;
2807         opengl_funcs.ext.p_wglReleaseTexImageARB    = macdrv_wglReleaseTexImageARB;
2808         opengl_funcs.ext.p_wglSetPbufferAttribARB   = macdrv_wglSetPbufferAttribARB;
2809
2810         if (gluCheckExtension((GLubyte*)"GL_ARB_texture_rectangle", (GLubyte*)gl_info.glExtensions) ||
2811             gluCheckExtension((GLubyte*)"GL_EXT_texture_rectangle", (GLubyte*)gl_info.glExtensions))
2812             register_extension("WGL_NV_render_texture_rectangle");
2813     }
2814
2815     /* TODO:
2816         WGL_ARB_create_context: wglCreateContextAttribsARB
2817         WGL_ARB_create_context_profile
2818      */
2819
2820     /*
2821      * EXT Extensions
2822      */
2823     register_extension("WGL_EXT_extensions_string");
2824     opengl_funcs.ext.p_wglGetExtensionsStringEXT = macdrv_wglGetExtensionsStringEXT;
2825
2826     register_extension("WGL_EXT_swap_control");
2827     opengl_funcs.ext.p_wglSwapIntervalEXT = macdrv_wglSwapIntervalEXT;
2828     opengl_funcs.ext.p_wglGetSwapIntervalEXT = macdrv_wglGetSwapIntervalEXT;
2829
2830     /* Presumably identical to [W]GL_ARB_framebuffer_sRGB, above, but clients may
2831        check for either, so register them separately. */
2832     if (gluCheckExtension((GLubyte*)"GL_EXT_framebuffer_sRGB", (GLubyte*)gl_info.glExtensions))
2833         register_extension("WGL_EXT_framebuffer_sRGB");
2834
2835     if (gluCheckExtension((GLubyte*)"GL_EXT_packed_float", (GLubyte*)gl_info.glExtensions))
2836         register_extension("WGL_EXT_pixel_format_packed_float");
2837
2838     /*
2839      * WINE-specific WGL Extensions
2840      */
2841
2842     /* In WineD3D we need the ability to set the pixel format more than once (e.g. after a device reset).
2843      * The default wglSetPixelFormat doesn't allow this, so add our own which allows it.
2844      */
2845     register_extension("WGL_WINE_pixel_format_passthrough");
2846     opengl_funcs.ext.p_wglSetPixelFormatWINE = macdrv_wglSetPixelFormatWINE;
2847 }
2848
2849
2850 static BOOL init_opengl(void)
2851 {
2852     static int init_done;
2853     unsigned int i;
2854     char buffer[200];
2855
2856     if (init_done) return (opengl_handle != NULL);
2857     init_done = 1;
2858
2859     TRACE("()\n");
2860
2861     dc_pbuffers = CFDictionaryCreateMutable(NULL, 0, NULL, NULL);
2862     if (!dc_pbuffers)
2863     {
2864         WARN("CFDictionaryCreateMutable failed\n");
2865         return FALSE;
2866     }
2867
2868     opengl_handle = wine_dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY|RTLD_LOCAL|RTLD_NOLOAD, buffer, sizeof(buffer));
2869     if (!opengl_handle)
2870     {
2871         ERR("Failed to load OpenGL: %s\n", buffer);
2872         ERR("OpenGL support is disabled.\n");
2873         return FALSE;
2874     }
2875
2876     for (i = 0; i < sizeof(opengl_func_names)/sizeof(opengl_func_names[0]); i++)
2877     {
2878         if (!(((void **)&opengl_funcs.gl)[i] = wine_dlsym(opengl_handle, opengl_func_names[i], NULL, 0)))
2879         {
2880             ERR("%s not found in OpenGL, disabling.\n", opengl_func_names[i]);
2881             goto failed;
2882         }
2883     }
2884
2885     /* redirect some standard OpenGL functions */
2886 #define REDIRECT(func) \
2887     do { p##func = opengl_funcs.gl.p_##func; opengl_funcs.gl.p_##func = macdrv_##func; } while(0)
2888     REDIRECT(glCopyPixels);
2889     REDIRECT(glReadPixels);
2890     REDIRECT(glViewport);
2891 #undef REDIRECT
2892
2893     /* redirect some OpenGL extension functions */
2894 #define REDIRECT(func) \
2895     do { if (opengl_funcs.ext.p_##func) { p##func = opengl_funcs.ext.p_##func; opengl_funcs.ext.p_##func = macdrv_##func; } } while(0)
2896     REDIRECT(glCopyColorTable);
2897 #undef REDIRECT
2898
2899     if (!init_gl_info())
2900         goto failed;
2901
2902     load_extensions();
2903     if (!init_pixel_formats())
2904         goto failed;
2905
2906     return TRUE;
2907
2908 failed:
2909     wine_dlclose(opengl_handle, NULL, 0);
2910     opengl_handle = NULL;
2911     return FALSE;
2912 }
2913
2914
2915 /***********************************************************************
2916  *              sync_gl_view
2917  *
2918  * Synchronize the Mac GL view position with the Windows child window
2919  * position.
2920  */
2921 void sync_gl_view(struct macdrv_win_data *data)
2922 {
2923     RECT rect;
2924
2925     TRACE("hwnd %p gl_view %p\n", data->hwnd, data->gl_view);
2926
2927     if (!data->gl_view) return;
2928
2929     if (get_gl_view_window_rect(data, NULL, &rect) && memcmp(&data->gl_rect, &rect, sizeof(rect)))
2930     {
2931         TRACE("Setting GL view %p frame to %s\n", data->gl_view, wine_dbgstr_rect(&rect));
2932         macdrv_set_view_window_and_frame(data->gl_view, NULL, cgrect_from_rect(rect));
2933         data->gl_rect = rect;
2934     }
2935 }
2936
2937
2938 static int get_dc_pixel_format(HDC hdc)
2939 {
2940     int format;
2941     HWND hwnd;
2942
2943     if ((hwnd = WindowFromDC(hdc)))
2944     {
2945         struct macdrv_win_data *data;
2946
2947         if (!(data = get_win_data(hwnd)))
2948         {
2949             FIXME("DC for window %p of other process: not implemented\n", hwnd);
2950             return 0;
2951         }
2952
2953         format = data->pixel_format;
2954         release_win_data(data);
2955     }
2956     else
2957     {
2958         struct wgl_pbuffer *pbuffer;
2959
2960         EnterCriticalSection(&dc_pbuffers_section);
2961         pbuffer = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, hdc);
2962         if (pbuffer)
2963             format = pbuffer->format;
2964         else
2965         {
2966             WARN("no window or pbuffer for DC %p\n", hdc);
2967             format = 0;
2968         }
2969         LeaveCriticalSection(&dc_pbuffers_section);
2970     }
2971
2972     return format;
2973 }
2974
2975
2976 /**********************************************************************
2977  *              create_context
2978  */
2979 static BOOL create_context(struct wgl_context *context, CGLContextObj share)
2980 {
2981     const pixel_format *pf;
2982     CGLPixelFormatAttribute attribs[64];
2983     int n = 0;
2984     CGLPixelFormatObj pix;
2985     GLint virtualScreens;
2986     CGLError err;
2987     long swap_interval;
2988
2989     pf = get_pixel_format(context->format, TRUE /* non-displayable */);
2990     if (!pf)
2991     {
2992         ERR("Invalid pixel format %d, expect problems!\n", context->format);
2993         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2994         return FALSE;
2995     }
2996
2997     attribs[n++] = kCGLPFAMinimumPolicy;
2998     attribs[n++] = kCGLPFAClosestPolicy;
2999
3000     if (pf->accelerated)
3001     {
3002         attribs[n++] = kCGLPFAAccelerated;
3003         attribs[n++] = kCGLPFANoRecovery;
3004     }
3005     else
3006     {
3007         attribs[n++] = kCGLPFARendererID;
3008         attribs[n++] = kCGLRendererGenericFloatID;
3009     }
3010
3011     if (pf->double_buffer)
3012         attribs[n++] = kCGLPFADoubleBuffer;
3013
3014     attribs[n++] = kCGLPFAAuxBuffers;
3015     attribs[n++] = pf->aux_buffers;
3016
3017     attribs[n++] = kCGLPFAColorSize;
3018     attribs[n++] = color_modes[pf->color_mode].color_bits;
3019     attribs[n++] = kCGLPFAAlphaSize;
3020     attribs[n++] = color_modes[pf->color_mode].alpha_bits;
3021     if (color_modes[pf->color_mode].is_float)
3022         attribs[n++] = kCGLPFAColorFloat;
3023
3024     attribs[n++] = kCGLPFADepthSize;
3025     attribs[n++] = pf->depth_bits;
3026
3027     attribs[n++] = kCGLPFAStencilSize;
3028     attribs[n++] = pf->stencil_bits;
3029
3030     if (pf->stereo)
3031         attribs[n++] = kCGLPFAStereo;
3032
3033     if (pf->accum_mode)
3034     {
3035         attribs[n++] = kCGLPFAAccumSize;
3036         attribs[n++] = color_modes[pf->accum_mode - 1].color_bits;
3037     }
3038
3039     if (pf->window)
3040         attribs[n++] = kCGLPFAWindow;
3041     if (pf->pbuffer)
3042         attribs[n++] = kCGLPFAPBuffer;
3043
3044     if (pf->sample_buffers && pf->samples)
3045     {
3046         attribs[n++] = kCGLPFASampleBuffers;
3047         attribs[n++] = pf->sample_buffers;
3048         attribs[n++] = kCGLPFASamples;
3049         attribs[n++] = pf->samples;
3050     }
3051
3052     if (pf->backing_store)
3053         attribs[n++] = kCGLPFABackingStore;
3054
3055     attribs[n] = 0;
3056
3057     err = CGLChoosePixelFormat(attribs, &pix, &virtualScreens);
3058     if (err != kCGLNoError || !pix)
3059     {
3060         WARN("CGLChoosePixelFormat() failed with error %d %s\n", err, CGLErrorString(err));
3061         return FALSE;
3062     }
3063
3064     err = CGLCreateContext(pix, share, &context->cglcontext);
3065     CGLReleasePixelFormat(pix);
3066     if (err != kCGLNoError || !context->cglcontext)
3067     {
3068         context->cglcontext = NULL;
3069         WARN("CGLCreateContext() failed with error %d %s\n", err, CGLErrorString(err));
3070         return FALSE;
3071     }
3072
3073     /* According to the WGL_EXT_swap_control docs, the default swap interval for
3074        a context is 1.  CGL contexts default to 0, so we need to set it. */
3075     swap_interval = 1;
3076     err = CGLSetParameter(context->cglcontext, kCGLCPSwapInterval, (GLint*)&swap_interval);
3077     if (err != kCGLNoError)
3078         WARN("CGLSetParameter(kCGLCPSwapInterval) failed with error %d %s; leaving un-vsynced\n", err, CGLErrorString(err));
3079
3080     context->context = macdrv_create_opengl_context(context->cglcontext);
3081     CGLReleaseContext(context->cglcontext);
3082     if (!context->context)
3083     {
3084         WARN("macdrv_create_opengl_context() failed\n");
3085         return FALSE;
3086     }
3087
3088     TRACE("created context %p/%p/%p\n", context, context->context, context->cglcontext);
3089
3090     return TRUE;
3091 }
3092
3093
3094 /**********************************************************************
3095  *              macdrv_wglDescribePixelFormat
3096  */
3097 int macdrv_wglDescribePixelFormat(HDC hdc, int fmt, UINT size, PIXELFORMATDESCRIPTOR *descr)
3098 {
3099     int ret = nb_formats;
3100     const pixel_format *pf;
3101     const struct color_mode *mode;
3102
3103     TRACE("hdc %p fmt %d size %u descr %p\n", hdc, fmt, size, descr);
3104
3105     if (fmt <= 0 || fmt > ret) return ret;
3106     if (size < sizeof(*descr)) return 0;
3107
3108     pf = &pixel_formats[fmt - 1];
3109
3110     memset(descr, 0, sizeof(*descr));
3111     descr->nSize            = sizeof(*descr);
3112     descr->nVersion         = 1;
3113
3114     descr->dwFlags          = PFD_SUPPORT_OPENGL;
3115     if (pf->window)         descr->dwFlags |= PFD_DRAW_TO_WINDOW;
3116     if (!pf->accelerated)   descr->dwFlags |= PFD_GENERIC_FORMAT;
3117     if (pf->double_buffer)  descr->dwFlags |= PFD_DOUBLEBUFFER;
3118     if (pf->stereo)         descr->dwFlags |= PFD_STEREO;
3119     if (pf->backing_store)  descr->dwFlags |= PFD_SWAP_COPY;
3120
3121     descr->iPixelType       = PFD_TYPE_RGBA;
3122
3123     mode = &color_modes[pf->color_mode];
3124     /* If the mode doesn't have alpha, return bits per pixel instead of color bits.
3125        On Windows, color bits sometimes exceeds r+g+b (e.g. it's 32 for an
3126        R8G8B8A0 pixel format).  If an app depends on that and expects that
3127        cColorBits >= 32 for such a pixel format, we need to accommodate that. */
3128     if (mode->alpha_bits)
3129         descr->cColorBits   = mode->color_bits;
3130     else
3131         descr->cColorBits   = mode->bits_per_pixel;
3132     descr->cRedBits         = mode->red_bits;
3133     descr->cRedShift        = mode->red_shift;
3134     descr->cGreenBits       = mode->green_bits;
3135     descr->cGreenShift      = mode->green_shift;
3136     descr->cBlueBits        = mode->blue_bits;
3137     descr->cBlueShift       = mode->blue_shift;
3138     descr->cAlphaBits       = mode->alpha_bits;
3139     descr->cAlphaShift      = mode->alpha_shift;
3140
3141     if (pf->accum_mode)
3142     {
3143         mode = &color_modes[pf->accum_mode - 1];
3144         descr->cAccumBits       = mode->color_bits;
3145         descr->cAccumRedBits    = mode->red_bits;
3146         descr->cAccumGreenBits  = mode->green_bits;
3147         descr->cAccumBlueBits   = mode->blue_bits;
3148         descr->cAccumAlphaBits  = mode->alpha_bits;
3149     }
3150
3151     descr->cDepthBits       = pf->depth_bits;
3152     descr->cStencilBits     = pf->stencil_bits;
3153     descr->cAuxBuffers      = pf->aux_buffers;
3154     descr->iLayerType       = PFD_MAIN_PLANE;
3155     return ret;
3156 }
3157
3158 /***********************************************************************
3159  *              macdrv_wglCopyContext
3160  */
3161 static BOOL macdrv_wglCopyContext(struct wgl_context *src, struct wgl_context *dst, UINT mask)
3162 {
3163     CGLError err;
3164
3165     TRACE("src %p dst %p mask %x\n", src, dst, mask);
3166
3167     err = CGLCopyContext(src->cglcontext, dst->cglcontext, mask);
3168     if (err != kCGLNoError)
3169         WARN("CGLCopyContext() failed with err %d %s\n", err, CGLErrorString(err));
3170     return (err == kCGLNoError);
3171 }
3172
3173 /***********************************************************************
3174  *              macdrv_wglCreateContext
3175  */
3176 static struct wgl_context *macdrv_wglCreateContext(HDC hdc)
3177 {
3178     int format;
3179     struct wgl_context *context;
3180
3181     TRACE("hdc %p\n", hdc);
3182
3183     format = get_dc_pixel_format(hdc);
3184
3185     if (!is_valid_pixel_format(format))
3186     {
3187         ERR("Invalid pixel format %d, expect problems!\n", format);
3188         SetLastError(ERROR_INVALID_PIXEL_FORMAT);
3189         return NULL;
3190     }
3191
3192     if (!(context = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*context)))) return NULL;
3193
3194     context->format = format;
3195     if (!create_context(context, NULL))
3196     {
3197         HeapFree(GetProcessHeap(), 0, context);
3198         return NULL;
3199     }
3200
3201     return context;
3202 }
3203
3204 /***********************************************************************
3205  *              macdrv_wglDeleteContext
3206  */
3207 static void macdrv_wglDeleteContext(struct wgl_context *context)
3208 {
3209     TRACE("deleting context %p/%p/%p\n", context, context->context, context->cglcontext);
3210     macdrv_dispose_opengl_context(context->context);
3211     HeapFree(GetProcessHeap(), 0, context);
3212 }
3213
3214 /***********************************************************************
3215  *              macdrv_wglGetPixelFormat
3216  */
3217 static int macdrv_wglGetPixelFormat(HDC hdc)
3218 {
3219     int format;
3220
3221     format = get_dc_pixel_format(hdc);
3222
3223     if (!is_valid_pixel_format(format))  /* not set yet */
3224         format = 0;
3225     else if (!is_displayable_pixel_format(format))
3226     {
3227         /* Non-displayable formats can't be used with traditional WGL calls.
3228          * As has been verified on Windows GetPixelFormat doesn't fail but returns pixel format 1. */
3229         format = 1;
3230     }
3231
3232     TRACE(" hdc %p -> %d\n", hdc, format);
3233     return format;
3234 }
3235
3236 /***********************************************************************
3237  *              macdrv_wglGetProcAddress
3238  */
3239 static PROC macdrv_wglGetProcAddress(const char *proc)
3240 {
3241     void *ret;
3242
3243     if (!strncmp(proc, "wgl", 3)) return NULL;
3244     ret = wine_dlsym(opengl_handle, proc, NULL, 0);
3245     if (ret)
3246     {
3247         if (TRACE_ON(wgl))
3248         {
3249             Dl_info info;
3250             if (dladdr(ret, &info))
3251                 TRACE("%s -> %s from %s\n", proc, info.dli_sname, info.dli_fname);
3252             else
3253                 TRACE("%s -> %p (no library info)\n", proc, ret);
3254         }
3255     }
3256     else
3257         WARN("failed to find proc %s\n", debugstr_a(proc));
3258     return ret;
3259 }
3260
3261 /***********************************************************************
3262  *              macdrv_wglMakeCurrent
3263  */
3264 static BOOL macdrv_wglMakeCurrent(HDC hdc, struct wgl_context *context)
3265 {
3266     TRACE("hdc %p context %p/%p/%p\n", hdc, context, (context ? context->context : NULL),
3267           (context ? context->cglcontext : NULL));
3268
3269     return macdrv_wglMakeContextCurrentARB(hdc, hdc, context);
3270 }
3271
3272 /**********************************************************************
3273  *              macdrv_wglSetPixelFormat
3274  */
3275 static BOOL macdrv_wglSetPixelFormat(HDC hdc, int fmt, const PIXELFORMATDESCRIPTOR *descr)
3276 {
3277     return set_pixel_format(hdc, fmt, FALSE);
3278 }
3279
3280 /***********************************************************************
3281  *              macdrv_wglShareLists
3282  */
3283 static BOOL macdrv_wglShareLists(struct wgl_context *org, struct wgl_context *dest)
3284 {
3285     macdrv_opengl_context saved_context;
3286     CGLContextObj saved_cglcontext;
3287
3288     TRACE("org %p dest %p\n", org, dest);
3289
3290     /* Sharing of display lists works differently in Mac OpenGL and WGL.  In Mac OpenGL it is done
3291      * at context creation time but in case of WGL it is done using wglShareLists.
3292      *
3293      * The approach is to create a Mac OpenGL context in wglCreateContext / wglCreateContextAttribsARB
3294      * and when a program requests sharing we recreate the destination context if it hasn't been made
3295      * current or when it hasn't shared display lists before.
3296      */
3297
3298     if (dest->has_been_current)
3299     {
3300         WARN("could not share display lists, the destination context has been current already\n");
3301         return FALSE;
3302     }
3303     else if (dest->sharing)
3304     {
3305         WARN("could not share display lists because dest has already shared lists before\n");
3306         return FALSE;
3307     }
3308
3309     /* Re-create the Mac context and share display lists */
3310     saved_context = dest->context;
3311     saved_cglcontext = dest->cglcontext;
3312     dest->context = NULL;
3313     dest->cglcontext = NULL;
3314     if (!create_context(dest, org->cglcontext))
3315     {
3316         dest->context = saved_context;
3317         dest->cglcontext = saved_cglcontext;
3318         return FALSE;
3319     }
3320
3321     /* Implicitly disposes of saved_cglcontext. */
3322     macdrv_dispose_opengl_context(saved_context);
3323
3324     TRACE("re-created OpenGL context %p/%p/%p sharing lists with context %p/%p/%p\n",
3325           dest, dest->context, dest->cglcontext, org, org->context, org->cglcontext);
3326
3327     org->sharing = TRUE;
3328     dest->sharing = TRUE;
3329
3330     return TRUE;
3331 }
3332
3333 /**********************************************************************
3334  *              macdrv_wglSwapBuffers
3335  */
3336 static BOOL macdrv_wglSwapBuffers(HDC hdc)
3337 {
3338     struct wgl_context *context = NtCurrentTeb()->glContext;
3339
3340     TRACE("hdc %p context %p/%p/%p\n", hdc, context, (context ? context->context : NULL),
3341           (context ? context->cglcontext : NULL));
3342
3343     if (!context)
3344     {
3345         SetLastError(ERROR_INVALID_HANDLE);
3346         return FALSE;
3347     }
3348
3349     macdrv_flush_opengl_context(context->context);
3350     return TRUE;
3351 }
3352
3353 static struct opengl_funcs opengl_funcs =
3354 {
3355     {
3356         macdrv_wglCopyContext,          /* p_wglCopyContext */
3357         macdrv_wglCreateContext,        /* p_wglCreateContext */
3358         macdrv_wglDeleteContext,        /* p_wglDeleteContext */
3359         macdrv_wglDescribePixelFormat,  /* p_wglDescribePixelFormat */
3360         macdrv_wglGetPixelFormat,       /* p_wglGetPixelFormat */
3361         macdrv_wglGetProcAddress,       /* p_wglGetProcAddress */
3362         macdrv_wglMakeCurrent,          /* p_wglMakeCurrent */
3363         macdrv_wglSetPixelFormat,       /* p_wglSetPixelFormat */
3364         macdrv_wglShareLists,           /* p_wglShareLists */
3365         macdrv_wglSwapBuffers,          /* p_wglSwapBuffers */
3366     }
3367 };
3368
3369 /**********************************************************************
3370  *              macdrv_wine_get_wgl_driver
3371  */
3372 struct opengl_funcs *macdrv_wine_get_wgl_driver(PHYSDEV dev, UINT version)
3373 {
3374     if (version != WINE_WGL_DRIVER_VERSION)
3375     {
3376         ERR("version mismatch, opengl32 wants %u but macdrv has %u\n", version, WINE_WGL_DRIVER_VERSION);
3377         return NULL;
3378     }
3379
3380     if (!init_opengl()) return (void *)-1;
3381
3382     return &opengl_funcs;
3383 }