?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dwrite: Check for allocation failures of glyph buffers.
[wine.git] / dlls / winemac.drv / opengl.c
blob9f02e93d376967adf144812a3cbf1b18d4568259
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 "winnt.h"
30 #include "wine/debug.h"
31 #include "wine/wgl.h"
32 #include "wine/wgl_driver.h"
33
34 #define GL_SILENCE_DEPRECATION
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 *glExtensions;
47
48 char wglExtensions[4096];
49
50 GLint max_viewport_dims[2];
51
52 unsigned int max_major, max_minor;
53 };
54
55 static struct gl_info gl_info;
56
57
58 struct wgl_context
59 {
60 struct list entry;
61 int format;
62 GLint renderer_id;
63 macdrv_opengl_context context;
64 CGLContextObj cglcontext;
65 HWND draw_hwnd;
66 macdrv_view draw_view;
67 RECT draw_rect;
68 struct wgl_pbuffer *draw_pbuffer;
69 macdrv_view read_view;
70 RECT read_rect;
71 struct wgl_pbuffer *read_pbuffer;
72 BOOL has_been_current;
73 BOOL sharing;
74 LONG update_swap_interval;
75 LONG view_moved;
76 DWORD last_flush_time;
77 UINT major;
78 };
79
80 static struct list context_list = LIST_INIT(context_list);
81
82 static CRITICAL_SECTION context_section;
83 static CRITICAL_SECTION_DEBUG critsect_debug =
84 {
85 0, 0, &context_section,
86 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
87 0, 0, { (DWORD_PTR)(__FILE__ ": context_section") }
88 };
89 static CRITICAL_SECTION context_section = { &critsect_debug, -1, 0, 0, 0, 0 };
90
91
92 struct wgl_pbuffer
93 {
94 CGLPBufferObj pbuffer;
95 int format;
96 BOOL no_texture;
97 int max_level;
98 GLint level;
99 GLenum face;
100 };
101
102 static CFMutableDictionaryRef dc_pbuffers;
103
104 static CRITICAL_SECTION dc_pbuffers_section;
105 static CRITICAL_SECTION_DEBUG dc_pbuffers_section_debug =
106 {
107 0, 0, &dc_pbuffers_section,
108 { &dc_pbuffers_section_debug.ProcessLocksList, &dc_pbuffers_section_debug.ProcessLocksList },
109 0, 0, { (DWORD_PTR)(__FILE__ ": dc_pbuffers_section") }
110 };
111 static CRITICAL_SECTION dc_pbuffers_section = { &dc_pbuffers_section_debug, -1, 0, 0, 0, 0 };
112
113
114 static struct opengl_funcs opengl_funcs;
115
116 #define USE_GL_FUNC(name) #name,
117 static const char *opengl_func_names[] = { ALL_WGL_FUNCS };
118 #undef USE_GL_FUNC
119
120
121 static void (*pglCopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y,
122 GLsizei width);
123 static void (*pglCopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
124 static void (*pglFinish)(void);
125 static void (*pglFlush)(void);
126 static void (*pglFlushRenderAPPLE)(void);
127 static const GLubyte *(*pglGetString)(GLenum name);
128 static void (*pglReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height,
129 GLenum format, GLenum type, void *pixels);
130 static void (*pglViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
131
132
133 struct color_mode {
134 GLint mode;
135 int bits_per_pixel;
136 GLint color_bits; /* including alpha_bits */
137 int red_bits, red_shift;
138 int green_bits, green_shift;
139 int blue_bits, blue_shift;
140 GLint alpha_bits, alpha_shift;
141 BOOL is_float;
142 int color_ordering;
143 };
144
145 /* The value of "color_ordering" is somewhat arbitrary. It incorporates some
146 observations of the behavior of Windows systems, but also subjective judgments
147 about what color formats are more "normal" than others.
148
149 On at least some Windows systems, integer color formats are listed before
150 floating-point formats. Within the integer formats, higher color bits were
151 usually listed before lower color bits, while for floating-point formats it
152 was the reverse. However, that leads D3D to select 64-bit integer formats in
153 preference to 32-bit formats when the latter would be sufficient. It seems
154 that a 32-bit format is much more likely to be normally used in that case.
155
156 Also, there are certain odd color formats supported on the Mac which seem like
157 they would be less appropriate than more common ones. For instance, the color
158 formats with alpha in a separate byte (e.g. kCGLRGB888A8Bit with R8G8B8 in one
159 32-bit value and A8 in a separate 8-bit value) and the formats with 10-bit RGB
160 components.
161
162 For two color formats which differ only in whether or not they have alpha bits,
163 we use the same ordering. pixel_format_comparator() gives alpha bits a
164 different weight than color formats.
165 */
166 static const struct color_mode color_modes[] = {
167 { kCGLRGB444Bit, 16, 12, 4, 8, 4, 4, 4, 0, 0, 0, FALSE, 5 },
168 { kCGLARGB4444Bit, 16, 16, 4, 8, 4, 4, 4, 0, 4, 12, FALSE, 5 },
169 { kCGLRGB444A8Bit, 24, 20, 4, 8, 4, 4, 4, 0, 8, 16, FALSE, 10 },
170 { kCGLRGB555Bit, 16, 15, 5, 10, 5, 5, 5, 0, 0, 0, FALSE, 4 },
171 { kCGLARGB1555Bit, 16, 16, 5, 10, 5, 5, 5, 0, 1, 15, FALSE, 4 },
172 { kCGLRGB555A8Bit, 24, 23, 5, 10, 5, 5, 5, 0, 8, 16, FALSE, 9 },
173 { kCGLRGB565Bit, 16, 16, 5, 11, 6, 5, 5, 0, 0, 0, FALSE, 3 },
174 { kCGLRGB565A8Bit, 24, 24, 5, 11, 6, 5, 5, 0, 8, 16, FALSE, 8 },
175 { kCGLRGB888Bit, 32, 24, 8, 16, 8, 8, 8, 0, 0, 0, FALSE, 0 },
176 { kCGLARGB8888Bit, 32, 32, 8, 16, 8, 8, 8, 0, 8, 24, FALSE, 0 },
177 { kCGLRGB888A8Bit, 40, 32, 8, 16, 8, 8, 8, 0, 8, 32, FALSE, 7 },
178 { kCGLRGB101010Bit, 32, 30, 10, 20, 10, 10, 10, 0, 0, 0, FALSE, 6 },
179 { kCGLARGB2101010Bit, 32, 32, 10, 20, 10, 10, 10, 0, 2, 30, FALSE, 6 },
180 { kCGLRGB101010_A8Bit, 40, 38, 10, 20, 10, 10, 10, 0, 8, 32, FALSE, 11 },
181 { kCGLRGB121212Bit, 48, 36, 12, 24, 12, 12, 12, 0, 0, 0, FALSE, 2 },
182 { kCGLARGB12121212Bit, 48, 48, 12, 24, 12, 12, 12, 0, 12, 36, FALSE, 2 },
183 { kCGLRGB161616Bit, 64, 48, 16, 48, 16, 32, 16, 16, 0, 0, FALSE, 1 },
184 { kCGLRGBA16161616Bit, 64, 64, 16, 48, 16, 32, 16, 16, 16, 0, FALSE, 1 },
185 { kCGLRGBFloat64Bit, 64, 48, 16, 32, 16, 16, 16, 0, 0, 0, TRUE, 12 },
186 { kCGLRGBAFloat64Bit, 64, 64, 16, 48, 16, 32, 16, 16, 16, 0, TRUE, 12 },
187 { kCGLRGBFloat128Bit, 128, 96, 32, 96, 32, 64, 32, 32, 0, 0, TRUE, 13 },
188 { kCGLRGBAFloat128Bit, 128, 128, 32, 96, 32, 64, 32, 32, 32, 0, TRUE, 13 },
189 { kCGLRGBFloat256Bit, 256, 192, 64, 192, 64, 128, 64, 64, 0, 0, TRUE, 14 },
190 { kCGLRGBAFloat256Bit, 256, 256, 64, 192, 64, 128, 64, 64, 64, 0, TRUE, 15 },
191 };
192
193
194 static const struct {
195 GLint mode;
196 int bits;
197 } depth_stencil_modes[] = {
198 { kCGL0Bit, 0 },
199 { kCGL1Bit, 1 },
200 { kCGL2Bit, 2 },
201 { kCGL3Bit, 3 },
202 { kCGL4Bit, 4 },
203 { kCGL5Bit, 5 },
204 { kCGL6Bit, 6 },
205 { kCGL8Bit, 8 },
206 { kCGL10Bit, 10 },
207 { kCGL12Bit, 12 },
208 { kCGL16Bit, 16 },
209 { kCGL24Bit, 24 },
210 { kCGL32Bit, 32 },
211 { kCGL48Bit, 48 },
212 { kCGL64Bit, 64 },
213 { kCGL96Bit, 96 },
214 { kCGL128Bit, 128 },
215 };
216
217
218 typedef struct {
219 GLint renderer_id;
220 GLint buffer_modes;
221 GLint color_modes;
222 GLint accum_modes;
223 GLint depth_modes;
224 GLint stencil_modes;
225 GLint max_aux_buffers;
226 GLint max_sample_buffers;
227 GLint max_samples;
228 BOOL offscreen;
229 BOOL accelerated;
230 BOOL backing_store;
231 BOOL window;
232 BOOL online;
233 } renderer_properties;
234
235
236 typedef struct {
237 unsigned int window:1;
238 unsigned int pbuffer:1;
239 unsigned int accelerated:1;
240 unsigned int color_mode:5; /* index into color_modes table */
241 unsigned int aux_buffers:3;
242 unsigned int depth_bits:8;
243 unsigned int stencil_bits:8;
244 unsigned int accum_mode:5; /* 1 + index into color_modes table (0 means no accum buffer) */
245 unsigned int double_buffer:1;
246 unsigned int stereo:1;
247 unsigned int sample_buffers:1;
248 unsigned int samples:5;
249 unsigned int backing_store:1;
250 } pixel_format;
251
252
253 typedef union
254 {
255 pixel_format format;
256 UInt64 code;
257 } pixel_format_or_code;
258 C_ASSERT(sizeof(((pixel_format_or_code*)0)->format) <= sizeof(((pixel_format_or_code*)0)->code));
259
260
261 static pixel_format *pixel_formats;
262 static int nb_formats, nb_displayable_formats;
263
264
265 static void *opengl_handle;
266
267
268 static const char* debugstr_attrib(int attrib, int value)
269 {
270 static const struct {
271 int attrib;
272 const char *name;
273 } attrib_names[] = {
274 #define ATTRIB(a) { a, #a }
275 ATTRIB(WGL_ACCELERATION_ARB),
276 ATTRIB(WGL_ACCUM_ALPHA_BITS_ARB),
277 ATTRIB(WGL_ACCUM_BITS_ARB),
278 ATTRIB(WGL_ACCUM_BLUE_BITS_ARB),
279 ATTRIB(WGL_ACCUM_GREEN_BITS_ARB),
280 ATTRIB(WGL_ACCUM_RED_BITS_ARB),
281 ATTRIB(WGL_ALPHA_BITS_ARB),
282 ATTRIB(WGL_ALPHA_SHIFT_ARB),
283 ATTRIB(WGL_AUX_BUFFERS_ARB),
284 ATTRIB(WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV),
285 ATTRIB(WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV),
286 ATTRIB(WGL_BIND_TO_TEXTURE_RGB_ARB),
287 ATTRIB(WGL_BIND_TO_TEXTURE_RGBA_ARB),
288 ATTRIB(WGL_BLUE_BITS_ARB),
289 ATTRIB(WGL_BLUE_SHIFT_ARB),
290 ATTRIB(WGL_COLOR_BITS_ARB),
291 ATTRIB(WGL_DEPTH_BITS_ARB),
292 ATTRIB(WGL_DOUBLE_BUFFER_ARB),
293 ATTRIB(WGL_DRAW_TO_BITMAP_ARB),
294 ATTRIB(WGL_DRAW_TO_PBUFFER_ARB),
295 ATTRIB(WGL_DRAW_TO_WINDOW_ARB),
296 ATTRIB(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB),
297 ATTRIB(WGL_GREEN_BITS_ARB),
298 ATTRIB(WGL_GREEN_SHIFT_ARB),
299 ATTRIB(WGL_NEED_PALETTE_ARB),
300 ATTRIB(WGL_NEED_SYSTEM_PALETTE_ARB),
301 ATTRIB(WGL_NUMBER_OVERLAYS_ARB),
302 ATTRIB(WGL_NUMBER_PIXEL_FORMATS_ARB),
303 ATTRIB(WGL_NUMBER_UNDERLAYS_ARB),
304 ATTRIB(WGL_PIXEL_TYPE_ARB),
305 ATTRIB(WGL_RED_BITS_ARB),
306 ATTRIB(WGL_RED_SHIFT_ARB),
307 ATTRIB(WGL_RENDERER_ID_WINE),
308 ATTRIB(WGL_SAMPLE_BUFFERS_ARB),
309 ATTRIB(WGL_SAMPLES_ARB),
310 ATTRIB(WGL_SHARE_ACCUM_ARB),
311 ATTRIB(WGL_SHARE_DEPTH_ARB),
312 ATTRIB(WGL_SHARE_STENCIL_ARB),
313 ATTRIB(WGL_STENCIL_BITS_ARB),
314 ATTRIB(WGL_STEREO_ARB),
315 ATTRIB(WGL_SUPPORT_GDI_ARB),
316 ATTRIB(WGL_SUPPORT_OPENGL_ARB),
317 ATTRIB(WGL_SWAP_LAYER_BUFFERS_ARB),
318 ATTRIB(WGL_SWAP_METHOD_ARB),
319 ATTRIB(WGL_TRANSPARENT_ALPHA_VALUE_ARB),
320 ATTRIB(WGL_TRANSPARENT_ARB),
321 ATTRIB(WGL_TRANSPARENT_BLUE_VALUE_ARB),
322 ATTRIB(WGL_TRANSPARENT_GREEN_VALUE_ARB),
323 ATTRIB(WGL_TRANSPARENT_INDEX_VALUE_ARB),
324 ATTRIB(WGL_TRANSPARENT_RED_VALUE_ARB),
325 #undef ATTRIB
326 };
327 int i;
328 const char *attrib_name = NULL;
329 const char *value_name = NULL;
330
331 for (i = 0; i < ARRAY_SIZE(attrib_names); i++)
332 {
333 if (attrib_names[i].attrib == attrib)
334 {
335 attrib_name = attrib_names[i].name;
336 break;
337 }
338 }
339
340 if (!attrib_name)
341 attrib_name = wine_dbg_sprintf("Attrib 0x%04x", attrib);
342
343 switch (attrib)
344 {
345 case WGL_ACCELERATION_ARB:
346 switch (value)
347 {
348 case WGL_FULL_ACCELERATION_ARB: value_name = "WGL_FULL_ACCELERATION_ARB"; break;
349 case WGL_GENERIC_ACCELERATION_ARB: value_name = "WGL_GENERIC_ACCELERATION_ARB"; break;
350 case WGL_NO_ACCELERATION_ARB: value_name = "WGL_NO_ACCELERATION_ARB"; break;
351 }
352 break;
353 case WGL_PIXEL_TYPE_ARB:
354 switch (value)
355 {
356 case WGL_TYPE_COLORINDEX_ARB: value_name = "WGL_TYPE_COLORINDEX_ARB"; break;
357 case WGL_TYPE_RGBA_ARB: value_name = "WGL_TYPE_RGBA_ARB"; break;
358 case WGL_TYPE_RGBA_FLOAT_ARB: value_name = "WGL_TYPE_RGBA_FLOAT_ARB"; break;
359 case WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT: value_name = "WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT"; break;
360 }
361 break;
362 case WGL_SWAP_METHOD_ARB:
363 switch (value)
364 {
365 case WGL_SWAP_COPY_ARB: value_name = "WGL_SWAP_COPY_ARB"; break;
366 case WGL_SWAP_EXCHANGE_ARB: value_name = "WGL_SWAP_EXCHANGE_ARB"; break;
367 case WGL_SWAP_UNDEFINED_ARB: value_name = "WGL_SWAP_UNDEFINED_ARB"; break;
368 }
369 break;
370 }
371
372 if (!value_name)
373 value_name = wine_dbg_sprintf("%d / 0x%04x", value, value);
374
375 return wine_dbg_sprintf("%40s: %s", attrib_name, value_name);
376 }
377
378
379 /**********************************************************************
380 * active_displays_mask
381 */
382 static CGOpenGLDisplayMask active_displays_mask(void)
383 {
384 CGError err;
385 CGDirectDisplayID displays[32];
386 uint32_t count, i;
387 CGOpenGLDisplayMask mask;
388
389 err = CGGetActiveDisplayList(ARRAY_SIZE(displays), displays, &count);
390 if (err != kCGErrorSuccess)
391 {
392 displays[0] = CGMainDisplayID();
393 count = 1;
394 }
395
396 mask = 0;
397 for (i = 0; i < count; i++)
398 mask |= CGDisplayIDToOpenGLDisplayMask(displays[i]);
399
400 return mask;
401 }
402
403
404 static BOOL get_renderer_property(CGLRendererInfoObj renderer_info, GLint renderer_index,
405 CGLRendererProperty property, GLint *value)
406 {
407 CGLError err = CGLDescribeRenderer(renderer_info, renderer_index, property, value);
408 if (err != kCGLNoError)
409 WARN("CGLDescribeRenderer failed for property %d: %d %s\n", property, err, CGLErrorString(err));
410 return (err == kCGLNoError);
411 }
412
413
414 static void get_renderer_properties(CGLRendererInfoObj renderer_info, int renderer_index, renderer_properties* properties)
415 {
416 GLint value;
417
418 memset(properties, 0, sizeof(*properties));
419
420 if (get_renderer_property(renderer_info, renderer_index, kCGLRPRendererID, &value))
421 properties->renderer_id = value & kCGLRendererIDMatchingMask;
422
423 if (get_renderer_property(renderer_info, renderer_index, kCGLRPBufferModes, &value))
424 properties->buffer_modes = value;
425
426 if (get_renderer_property(renderer_info, renderer_index, kCGLRPColorModes, &value))
427 properties->color_modes = value;
428
429 if (get_renderer_property(renderer_info, renderer_index, kCGLRPAccumModes, &value))
430 properties->accum_modes = value;
431
432 if (get_renderer_property(renderer_info, renderer_index, kCGLRPDepthModes, &value))
433 properties->depth_modes = value;
434
435 if (get_renderer_property(renderer_info, renderer_index, kCGLRPStencilModes, &value))
436 properties->stencil_modes = value;
437
438 if (get_renderer_property(renderer_info, renderer_index, kCGLRPMaxAuxBuffers, &value))
439 properties->max_aux_buffers = value;
440
441 if (get_renderer_property(renderer_info, renderer_index, kCGLRPMaxSampleBuffers, &value))
442 properties->max_sample_buffers = value;
443
444 if (get_renderer_property(renderer_info, renderer_index, kCGLRPMaxSamples, &value))
445 properties->max_samples = value;
446
447 if (get_renderer_property(renderer_info, renderer_index, kCGLRPOffScreen, &value))
448 properties->offscreen = (value != 0);
449
450 if (get_renderer_property(renderer_info, renderer_index, kCGLRPAccelerated, &value))
451 properties->accelerated = (value != 0);
452
453 if (get_renderer_property(renderer_info, renderer_index, kCGLRPBackingStore, &value))
454 properties->backing_store = (value != 0);
455
456 if (get_renderer_property(renderer_info, renderer_index, kCGLRPWindow, &value))
457 properties->window = (value != 0);
458
459 if (get_renderer_property(renderer_info, renderer_index, kCGLRPOnline, &value))
460 properties->online = (value != 0);
461 }
462
463
464 static void dump_renderer(const renderer_properties* renderer)
465 {
466 int i;
467
468 TRACE("Renderer ID: 0x%08x\n", renderer->renderer_id);
469 TRACE("Buffer modes:\n");
470 TRACE(" Monoscopic: %s\n", (renderer->buffer_modes & kCGLMonoscopicBit) ? "YES" : "NO");
471 TRACE(" Stereoscopic: %s\n", (renderer->buffer_modes & kCGLStereoscopicBit) ? "YES" : "NO");
472 TRACE(" Single buffer: %s\n", (renderer->buffer_modes & kCGLSingleBufferBit) ? "YES" : "NO");
473 TRACE(" Double buffer: %s\n", (renderer->buffer_modes & kCGLDoubleBufferBit) ? "YES" : "NO");
474
475 TRACE("Color buffer modes:\n");
476 for (i = 0; i < ARRAY_SIZE(color_modes); i++)
477 {
478 if (renderer->color_modes & color_modes[i].mode)
479 {
480 TRACE(" Color size %d, Alpha size %d", color_modes[i].color_bits, color_modes[i].alpha_bits);
481 if (color_modes[i].is_float)
482 TRACE(", Float");
483 TRACE("\n");
484 }
485 }
486
487 TRACE("Accumulation buffer sizes: { ");
488 for (i = 0; i < ARRAY_SIZE(color_modes); i++)
489 {
490 if (renderer->accum_modes & color_modes[i].mode)
491 TRACE("%d, ", color_modes[i].color_bits);
492 }
493 TRACE("}\n");
494
495 TRACE("Depth buffer sizes: { ");
496 for (i = 0; i < ARRAY_SIZE(depth_stencil_modes); i++)
497 {
498 if (renderer->depth_modes & depth_stencil_modes[i].mode)
499 TRACE("%d, ", depth_stencil_modes[i].bits);
500 }
501 TRACE("}\n");
502
503 TRACE("Stencil buffer sizes: { ");
504 for (i = 0; i < ARRAY_SIZE(depth_stencil_modes); i++)
505 {
506 if (renderer->stencil_modes & depth_stencil_modes[i].mode)
507 TRACE("%d, ", depth_stencil_modes[i].bits);
508 }
509 TRACE("}\n");
510
511 TRACE("Max. Auxiliary Buffers: %d\n", renderer->max_aux_buffers);
512 TRACE("Max. Sample Buffers: %d\n", renderer->max_sample_buffers);
513 TRACE("Max. Samples: %d\n", renderer->max_samples);
514 TRACE("Offscreen: %s\n", renderer->offscreen ? "YES" : "NO");
515 TRACE("Accelerated: %s\n", renderer->accelerated ? "YES" : "NO");
516 TRACE("Backing store: %s\n", renderer->backing_store ? "YES" : "NO");
517 TRACE("Window: %s\n", renderer->window ? "YES" : "NO");
518 TRACE("Online: %s\n", renderer->online ? "YES" : "NO");
519 }
520
521
522 static inline UInt64 code_for_pixel_format(const pixel_format* format)
523 {
524 pixel_format_or_code pfc;
525
526 pfc.code = 0;
527 pfc.format = *format;
528 return pfc.code;
529 }
530
531
532 static inline pixel_format pixel_format_for_code(UInt64 code)
533 {
534 pixel_format_or_code pfc;
535
536 pfc.code = code;
537 return pfc.format;
538 }
539
540
541 static const char *debugstr_pf(const pixel_format *pf)
542 {
543 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",
544 pf->window,
545 pf->pbuffer,
546 pf->accelerated,
547 color_modes[pf->color_mode].color_bits,
548 (color_modes[pf->color_mode].is_float ? "f" : ""),
549 color_modes[pf->color_mode].alpha_bits,
550 pf->depth_bits,
551 pf->stencil_bits,
552 pf->accum_mode ? color_modes[pf->accum_mode - 1].color_bits : 0,
553 pf->aux_buffers,
554 pf->backing_store,
555 pf->double_buffer,
556 pf->stereo,
557 pf->sample_buffers,
558 pf->samples,
559 code_for_pixel_format(pf));
560 }
561
562
563 static unsigned int best_color_mode(GLint modes, GLint color_size, GLint alpha_size, GLint color_float)
564 {
565 int best = -1;
566 int i;
567
568 for (i = 0; i < ARRAY_SIZE(color_modes); i++)
569 {
570 if ((modes & color_modes[i].mode) &&
571 color_modes[i].color_bits >= color_size &&
572 color_modes[i].alpha_bits >= alpha_size &&
573 !color_modes[i].is_float == !color_float)
574 {
575 if (best < 0) /* no existing best choice */
576 best = i;
577 else if (color_modes[i].color_bits == color_size &&
578 color_modes[i].alpha_bits == alpha_size) /* candidate is exact match */
579 {
580 /* prefer it over a best which isn't exact or which has a higher bpp */
581 if (color_modes[best].color_bits != color_size ||
582 color_modes[best].alpha_bits != alpha_size ||
583 color_modes[i].bits_per_pixel < color_modes[best].bits_per_pixel)
584 best = i;
585 }
586 else if (color_modes[i].color_bits < color_modes[best].color_bits ||
587 (color_modes[i].color_bits == color_modes[best].color_bits &&
588 color_modes[i].alpha_bits < color_modes[best].alpha_bits)) /* prefer closer */
589 best = i;
590 }
591 }
592
593 if (best < 0)
594 {
595 /* Couldn't find a match. Return first one that renderer supports. */
596 for (i = 0; i < ARRAY_SIZE(color_modes); i++)
597 {
598 if (modes & color_modes[i].mode)
599 return i;
600 }
601 }
602
603 return best;
604 }
605
606
607 static unsigned int best_accum_mode(GLint modes, GLint accum_size)
608 {
609 int best = -1;
610 int i;
611
612 for (i = 0; i < ARRAY_SIZE(color_modes); i++)
613 {
614 if ((modes & color_modes[i].mode) && color_modes[i].color_bits >= accum_size)
615 {
616 /* Prefer the fewest color bits, then prefer more alpha bits, then
617 prefer more bits per pixel. */
618 if (best < 0)
619 best = i;
620 else if (color_modes[i].color_bits < color_modes[best].color_bits)
621 best = i;
622 else if (color_modes[i].color_bits == color_modes[best].color_bits)
623 {
624 if (color_modes[i].alpha_bits > color_modes[best].alpha_bits)
625 best = i;
626 else if (color_modes[i].alpha_bits == color_modes[best].alpha_bits &&
627 color_modes[i].bits_per_pixel > color_modes[best].bits_per_pixel)
628 best = i;
629 }
630 }
631 }
632
633 if (best < 0)
634 {
635 /* Couldn't find a match. Return last one that renderer supports. */
636 for (i = ARRAY_SIZE(color_modes) - 1; i >= 0; i--)
637 {
638 if (modes & color_modes[i].mode)
639 return i;
640 }
641 }
642
643 return best;
644 }
645
646
647 static void enum_renderer_pixel_formats(renderer_properties renderer, CFMutableArrayRef pixel_format_array,
648 CFMutableSetRef pixel_format_set)
649 {
650 CGLPixelFormatAttribute attribs[64] = {
651 kCGLPFAMinimumPolicy,
652 kCGLPFAClosestPolicy,
653 kCGLPFARendererID, renderer.renderer_id,
654 kCGLPFASingleRenderer,
655 };
656 int n = 5, n_stack[16], n_stack_idx = -1;
657 unsigned int tried_pixel_formats = 0, failed_pixel_formats = 0, dupe_pixel_formats = 0,
658 new_pixel_formats = 0;
659 pixel_format request;
660 unsigned int double_buffer;
661 unsigned int accelerated = renderer.accelerated;
662
663 if (accelerated)
664 {
665 attribs[n++] = kCGLPFAAccelerated;
666 attribs[n++] = kCGLPFANoRecovery;
667 }
668 else if (!allow_software_rendering)
669 {
670 TRACE("ignoring software renderer because AllowSoftwareRendering is off\n");
671 return;
672 }
673
674 n_stack[++n_stack_idx] = n;
675 for (double_buffer = 0; double_buffer <= 1; double_buffer++)
676 {
677 unsigned int aux;
678
679 n = n_stack[n_stack_idx];
680
681 if ((!double_buffer && !(renderer.buffer_modes & kCGLSingleBufferBit)) ||
682 (double_buffer && !(renderer.buffer_modes & kCGLDoubleBufferBit)))
683 continue;
684
685 if (double_buffer)
686 attribs[n++] = kCGLPFADoubleBuffer;
687 memset(&request, 0, sizeof(request));
688 request.accelerated = accelerated;
689 request.double_buffer = double_buffer;
690
691 /* Don't bother with in-between aux buffers values: either 0 or max. */
692 n_stack[++n_stack_idx] = n;
693 for (aux = 0; aux <= renderer.max_aux_buffers; aux += renderer.max_aux_buffers)
694 {
695 unsigned int color_mode;
696
697 n = n_stack[n_stack_idx];
698
699 attribs[n++] = kCGLPFAAuxBuffers;
700 attribs[n++] = aux;
701 request.aux_buffers = aux;
702
703 n_stack[++n_stack_idx] = n;
704 for (color_mode = 0; color_mode < ARRAY_SIZE(color_modes); color_mode++)
705 {
706 unsigned int depth_mode;
707
708 n = n_stack[n_stack_idx];
709
710 if (!(renderer.color_modes & color_modes[color_mode].mode))
711 continue;
712
713 attribs[n++] = kCGLPFAColorSize;
714 attribs[n++] = color_modes[color_mode].color_bits;
715 attribs[n++] = kCGLPFAAlphaSize;
716 attribs[n++] = color_modes[color_mode].alpha_bits;
717 if (color_modes[color_mode].is_float)
718 attribs[n++] = kCGLPFAColorFloat;
719 request.color_mode = color_mode;
720
721 n_stack[++n_stack_idx] = n;
722 for (depth_mode = 0; depth_mode < ARRAY_SIZE(depth_stencil_modes); depth_mode++)
723 {
724 unsigned int stencil_mode;
725
726 n = n_stack[n_stack_idx];
727
728 if (!(renderer.depth_modes & depth_stencil_modes[depth_mode].mode))
729 continue;
730
731 attribs[n++] = kCGLPFADepthSize;
732 attribs[n++] = depth_stencil_modes[depth_mode].bits;
733 request.depth_bits = depth_stencil_modes[depth_mode].bits;
734
735 n_stack[++n_stack_idx] = n;
736 for (stencil_mode = 0; stencil_mode < ARRAY_SIZE(depth_stencil_modes); stencil_mode++)
737 {
738 unsigned int stereo;
739
740 n = n_stack[n_stack_idx];
741
742 if (!(renderer.stencil_modes & depth_stencil_modes[stencil_mode].mode))
743 continue;
744 if (accelerated && depth_stencil_modes[depth_mode].bits != 24 &&
745 depth_stencil_modes[depth_mode].bits != 32 && stencil_mode > 0)
746 continue;
747
748 attribs[n++] = kCGLPFAStencilSize;
749 attribs[n++] = depth_stencil_modes[stencil_mode].bits;
750 request.stencil_bits = depth_stencil_modes[stencil_mode].bits;
751
752 /* FIXME: Could trim search space a bit here depending on GPU.
753 For ATI Radeon HD 4850, kCGLRGBA16161616Bit implies stereo-capable. */
754 n_stack[++n_stack_idx] = n;
755 for (stereo = 0; stereo <= 1; stereo++)
756 {
757 int accum_mode;
758
759 n = n_stack[n_stack_idx];
760
761 if ((!stereo && !(renderer.buffer_modes & kCGLMonoscopicBit)) ||
762 (stereo && !(renderer.buffer_modes & kCGLStereoscopicBit)))
763 continue;
764
765 if (stereo)
766 attribs[n++] = kCGLPFAStereo;
767 request.stereo = stereo;
768
769 /* Starts at -1 for a 0 accum size */
770 n_stack[++n_stack_idx] = n;
771 for (accum_mode = -1; accum_mode < (int) ARRAY_SIZE(color_modes); accum_mode++)
772 {
773 unsigned int target_pass;
774
775 n = n_stack[n_stack_idx];
776
777 if (accum_mode >= 0)
778 {
779 if (!(renderer.accum_modes & color_modes[accum_mode].mode))
780 continue;
781
782 attribs[n++] = kCGLPFAAccumSize;
783 attribs[n++] = color_modes[accum_mode].color_bits;
784 request.accum_mode = accum_mode + 1;
785 }
786 else
787 request.accum_mode = 0;
788
789 /* Targets to request are:
790 accelerated: window OR window + pbuffer
791 software: window + pbuffer */
792 n_stack[++n_stack_idx] = n;
793 for (target_pass = 0; target_pass <= accelerated; target_pass++)
794 {
795 unsigned int samples, max_samples;
796
797 n = n_stack[n_stack_idx];
798
799 attribs[n++] = kCGLPFAWindow;
800 request.window = 1;
801
802 if (!accelerated || target_pass > 0)
803 {
804 attribs[n++] = kCGLPFAPBuffer;
805 request.pbuffer = 1;
806 }
807 else
808 request.pbuffer = 0;
809
810 /* FIXME: Could trim search space a bit here depending on GPU.
811 For Nvidia GeForce 8800 GT, limited to 4 samples for color_bits >= 128.
812 For ATI Radeon HD 4850, can't multi-sample for color_bits >= 64 or pbuffer. */
813 n_stack[++n_stack_idx] = n;
814 max_samples = renderer.max_sample_buffers ? max(1, renderer.max_samples) : 1;
815 for (samples = 1; samples <= max_samples; samples *= 2)
816 {
817 unsigned int backing_store, min_backing_store, max_backing_store;
818
819 n = n_stack[n_stack_idx];
820
821 if (samples > 1)
822 {
823 attribs[n++] = kCGLPFASampleBuffers;
824 attribs[n++] = renderer.max_sample_buffers;
825 attribs[n++] = kCGLPFASamples;
826 attribs[n++] = samples;
827 request.sample_buffers = renderer.max_sample_buffers;
828 request.samples = samples;
829 }
830 else
831 request.sample_buffers = request.samples = 0;
832
833 if (renderer.backing_store && double_buffer)
834 {
835 /* The software renderer seems to always preserve the backing store, whether
836 we ask for it or not. So don't bother not asking for it. */
837 min_backing_store = accelerated ? 0 : 1;
838 max_backing_store = 1;
839 }
840 else
841 min_backing_store = max_backing_store = 0;
842 n_stack[++n_stack_idx] = n;
843 for (backing_store = min_backing_store; backing_store <= max_backing_store; backing_store++)
844 {
845 CGLPixelFormatObj pix;
846 GLint virtualScreens;
847 CGLError err;
848
849 n = n_stack[n_stack_idx];
850
851 if (backing_store)
852 attribs[n++] = kCGLPFABackingStore;
853 request.backing_store = backing_store;
854
855 attribs[n] = 0;
856
857 err = CGLChoosePixelFormat(attribs, &pix, &virtualScreens);
858 if (err == kCGLNoError && pix)
859 {
860 pixel_format pf;
861 GLint value, color_size, alpha_size, color_float;
862 UInt64 pf_code;
863 CFNumberRef code_object;
864 BOOL dupe;
865
866 memset(&pf, 0, sizeof(pf));
867
868 if (CGLDescribePixelFormat(pix, 0, kCGLPFAAccelerated, &value) == kCGLNoError)
869 pf.accelerated = value;
870 if (CGLDescribePixelFormat(pix, 0, kCGLPFAAuxBuffers, &value) == kCGLNoError)
871 pf.aux_buffers = value;
872 if (CGLDescribePixelFormat(pix, 0, kCGLPFADepthSize, &value) == kCGLNoError)
873 pf.depth_bits = value;
874 if (CGLDescribePixelFormat(pix, 0, kCGLPFADoubleBuffer, &value) == kCGLNoError)
875 pf.double_buffer = value;
876 if (pf.double_buffer &&
877 CGLDescribePixelFormat(pix, 0, kCGLPFABackingStore, &value) == kCGLNoError)
878 pf.backing_store = value;
879 if (CGLDescribePixelFormat(pix, 0, kCGLPFAPBuffer, &value) == kCGLNoError)
880 pf.pbuffer = value;
881 if (CGLDescribePixelFormat(pix, 0, kCGLPFASampleBuffers, &value) == kCGLNoError)
882 pf.sample_buffers = value;
883 if (pf.sample_buffers &&
884 CGLDescribePixelFormat(pix, 0, kCGLPFASamples, &value) == kCGLNoError)
885 pf.samples = value;
886 if (CGLDescribePixelFormat(pix, 0, kCGLPFAStencilSize, &value) == kCGLNoError)
887 pf.stencil_bits = value;
888 if (CGLDescribePixelFormat(pix, 0, kCGLPFAStereo, &value) == kCGLNoError)
889 pf.stereo = value;
890 if (CGLDescribePixelFormat(pix, 0, kCGLPFAWindow, &value) == kCGLNoError)
891 pf.window = value;
892
893 if (CGLDescribePixelFormat(pix, 0, kCGLPFAColorSize, &color_size) != kCGLNoError)
894 color_size = 0;
895 if (CGLDescribePixelFormat(pix, 0, kCGLPFAAlphaSize, &alpha_size) != kCGLNoError)
896 alpha_size = 0;
897 if (CGLDescribePixelFormat(pix, 0, kCGLPFAColorFloat, &color_float) != kCGLNoError)
898 color_float = 0;
899 pf.color_mode = best_color_mode(renderer.color_modes, color_size, alpha_size, color_float);
900
901 if (CGLDescribePixelFormat(pix, 0, kCGLPFAAccumSize, &value) == kCGLNoError && value)
902 pf.accum_mode = best_accum_mode(renderer.accum_modes, value) + 1;
903
904 CGLReleasePixelFormat(pix);
905
906 pf_code = code_for_pixel_format(&pf);
907
908 code_object = CFNumberCreate(NULL, kCFNumberSInt64Type, &pf_code);
909 if ((dupe = CFSetContainsValue(pixel_format_set, code_object)))
910 dupe_pixel_formats++;
911 else
912 {
913 CFSetAddValue(pixel_format_set, code_object);
914 CFArrayAppendValue(pixel_format_array, code_object);
915 new_pixel_formats++;
916 }
917 CFRelease(code_object);
918
919 if (pf_code == code_for_pixel_format(&request))
920 TRACE("%s%s\n", debugstr_pf(&pf), dupe ? " (duplicate)" : "");
921 else
922 {
923 TRACE("%s remapped from %s%s\n", debugstr_pf(&pf), debugstr_pf(&request),
924 dupe ? " (duplicate)" : "");
925 }
926 }
927 else
928 {
929 failed_pixel_formats++;
930 TRACE("%s failed request err %d %s\n", debugstr_pf(&request), err, err ? CGLErrorString(err) : "");
931 }
932
933 tried_pixel_formats++;
934 }
935
936 n_stack_idx--;
937 }
938
939 n_stack_idx--;
940 }
941
942 n_stack_idx--;
943 }
944
945 n_stack_idx--;
946 }
947
948 n_stack_idx--;
949 }
950
951 n_stack_idx--;
952 }
953
954 n_stack_idx--;
955 }
956
957 n_stack_idx--;
958 }
959
960 n_stack_idx--;
961 }
962
963 n_stack_idx--;
964
965 TRACE("Number of pixel format attribute combinations: %u\n", tried_pixel_formats);
966 TRACE(" Number which failed to choose a pixel format: %u\n", failed_pixel_formats);
967 TRACE(" Number which chose redundant pixel formats: %u\n", dupe_pixel_formats);
968 TRACE("Number of new pixel formats for this renderer: %u\n", new_pixel_formats);
969 }
970
971
972 /* The docs for WGL_ARB_pixel_format say:
973 Indices are assigned to pixel formats in the following order:
974 1. Accelerated pixel formats that are displayable
975 2. Accelerated pixel formats that are displayable and which have
976 extended attributes
977 3. Generic pixel formats
978 4. Accelerated pixel formats that are non displayable
979 */
980 static int pixel_format_category(pixel_format pf)
981 {
982 /* non-displayable */
983 if (!pf.window)
984 return 4;
985
986 /* non-accelerated a.k.a. software a.k.a. generic */
987 if (!pf.accelerated)
988 return 3;
989
990 /* extended attributes that can't be represented in PIXELFORMATDESCRIPTOR */
991 if (color_modes[pf.color_mode].is_float)
992 return 2;
993
994 /* accelerated, displayable, no extended attributes */
995 return 1;
996 }
997
998
999 static CFComparisonResult pixel_format_comparator(const void *val1, const void *val2, void *context)
1000 {
1001 CFNumberRef number1 = val1;
1002 CFNumberRef number2 = val2;
1003 UInt64 code1, code2;
1004 pixel_format pf1, pf2;
1005 int category1, category2;
1006
1007 CFNumberGetValue(number1, kCFNumberLongLongType, &code1);
1008 CFNumberGetValue(number2, kCFNumberLongLongType, &code2);
1009 pf1 = pixel_format_for_code(code1);
1010 pf2 = pixel_format_for_code(code2);
1011 category1 = pixel_format_category(pf1);
1012 category2 = pixel_format_category(pf2);
1013
1014 if (category1 < category2)
1015 return kCFCompareLessThan;
1016 if (category1 > category2)
1017 return kCFCompareGreaterThan;
1018
1019 /* Within a category, sort the "best" formats toward the front since that's
1020 what wglChoosePixelFormatARB() has to do. The ordering implemented here
1021 matches at least one Windows 7 machine's behavior.
1022 */
1023 /* Accelerated before unaccelerated. */
1024 if (pf1.accelerated && !pf2.accelerated)
1025 return kCFCompareLessThan;
1026 if (!pf1.accelerated && pf2.accelerated)
1027 return kCFCompareGreaterThan;
1028
1029 /* Explicit color mode ordering. */
1030 if (color_modes[pf1.color_mode].color_ordering < color_modes[pf2.color_mode].color_ordering)
1031 return kCFCompareLessThan;
1032 if (color_modes[pf1.color_mode].color_ordering > color_modes[pf2.color_mode].color_ordering)
1033 return kCFCompareGreaterThan;
1034
1035 /* Non-pbuffer-capable before pbuffer-capable. */
1036 if (!pf1.pbuffer && pf2.pbuffer)
1037 return kCFCompareLessThan;
1038 if (pf1.pbuffer && !pf2.pbuffer)
1039 return kCFCompareGreaterThan;
1040
1041 /* Fewer samples before more samples. */
1042 if (pf1.samples < pf2.samples)
1043 return kCFCompareLessThan;
1044 if (pf1.samples > pf2.samples)
1045 return kCFCompareGreaterThan;
1046
1047 /* Monoscopic before stereoscopic. (This is a guess.) */
1048 if (!pf1.stereo && pf2.stereo)
1049 return kCFCompareLessThan;
1050 if (pf1.stereo && !pf2.stereo)
1051 return kCFCompareGreaterThan;
1052
1053 /* Single buffered before double buffered. */
1054 if (!pf1.double_buffer && pf2.double_buffer)
1055 return kCFCompareLessThan;
1056 if (pf1.double_buffer && !pf2.double_buffer)
1057 return kCFCompareGreaterThan;
1058
1059 /* Possibly-optimized double buffering before backing-store-preserving
1060 double buffering. */
1061 if (!pf1.backing_store && pf2.backing_store)
1062 return kCFCompareLessThan;
1063 if (pf1.backing_store && !pf2.backing_store)
1064 return kCFCompareGreaterThan;
1065
1066 /* Bigger depth buffer before smaller depth buffer. */
1067 if (pf1.depth_bits > pf2.depth_bits)
1068 return kCFCompareLessThan;
1069 if (pf1.depth_bits < pf2.depth_bits)
1070 return kCFCompareGreaterThan;
1071
1072 /* Smaller stencil buffer before bigger stencil buffer. */
1073 if (pf1.stencil_bits < pf2.stencil_bits)
1074 return kCFCompareLessThan;
1075 if (pf1.stencil_bits > pf2.stencil_bits)
1076 return kCFCompareGreaterThan;
1077
1078 /* Smaller alpha bits before larger alpha bits. */
1079 if (color_modes[pf1.color_mode].alpha_bits < color_modes[pf2.color_mode].alpha_bits)
1080 return kCFCompareLessThan;
1081 if (color_modes[pf1.color_mode].alpha_bits > color_modes[pf2.color_mode].alpha_bits)
1082 return kCFCompareGreaterThan;
1083
1084 /* Smaller accum buffer before larger accum buffer. (This is a guess.) */
1085 if (pf1.accum_mode)
1086 {
1087 if (pf2.accum_mode)
1088 {
1089 if (color_modes[pf1.accum_mode - 1].color_bits - color_modes[pf1.accum_mode - 1].alpha_bits <
1090 color_modes[pf2.accum_mode - 1].color_bits - color_modes[pf2.accum_mode - 1].alpha_bits)
1091 return kCFCompareLessThan;
1092 if (color_modes[pf1.accum_mode - 1].color_bits - color_modes[pf1.accum_mode - 1].alpha_bits >
1093 color_modes[pf2.accum_mode - 1].color_bits - color_modes[pf2.accum_mode - 1].alpha_bits)
1094 return kCFCompareGreaterThan;
1095
1096 if (color_modes[pf1.accum_mode - 1].bits_per_pixel < color_modes[pf2.accum_mode - 1].bits_per_pixel)
1097 return kCFCompareLessThan;
1098 if (color_modes[pf1.accum_mode - 1].bits_per_pixel > color_modes[pf2.accum_mode - 1].bits_per_pixel)
1099 return kCFCompareGreaterThan;
1100
1101 if (color_modes[pf1.accum_mode - 1].alpha_bits < color_modes[pf2.accum_mode - 1].alpha_bits)
1102 return kCFCompareLessThan;
1103 if (color_modes[pf1.accum_mode - 1].alpha_bits > color_modes[pf2.accum_mode - 1].alpha_bits)
1104 return kCFCompareGreaterThan;
1105 }
1106 else
1107 return kCFCompareGreaterThan;
1108 }
1109 else if (pf2.accum_mode)
1110 return kCFCompareLessThan;
1111
1112 /* Fewer auxiliary buffers before more auxiliary buffers. (This is a guess.) */
1113 if (pf1.aux_buffers < pf2.aux_buffers)
1114 return kCFCompareLessThan;
1115 if (pf1.aux_buffers > pf2.aux_buffers)
1116 return kCFCompareGreaterThan;
1117
1118 /* If we get here, arbitrarily sort based on code. */
1119 if (code1 < code2)
1120 return kCFCompareLessThan;
1121 if (code1 > code2)
1122 return kCFCompareGreaterThan;
1123 return kCFCompareEqualTo;
1124 }
1125
1126
1127 static BOOL init_pixel_formats(void)
1128 {
1129 BOOL ret = FALSE;
1130 CGLRendererInfoObj renderer_info;
1131 GLint rendererCount;
1132 CGLError err;
1133 CFMutableSetRef pixel_format_set;
1134 CFMutableArrayRef pixel_format_array;
1135 int i;
1136 CFRange range;
1137
1138 TRACE("()\n");
1139
1140 err = CGLQueryRendererInfo(CGDisplayIDToOpenGLDisplayMask(CGMainDisplayID()), &renderer_info, &rendererCount);
1141 if (err)
1142 {
1143 WARN("CGLQueryRendererInfo failed (%d) %s\n", err, CGLErrorString(err));
1144 return FALSE;
1145 }
1146
1147 pixel_format_set = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
1148 if (!pixel_format_set)
1149 {
1150 WARN("CFSetCreateMutable failed\n");
1151 CGLDestroyRendererInfo(renderer_info);
1152 return FALSE;
1153 }
1154
1155 pixel_format_array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
1156 if (!pixel_format_array)
1157 {
1158 WARN("CFArrayCreateMutable failed\n");
1159 CFRelease(pixel_format_set);
1160 CGLDestroyRendererInfo(renderer_info);
1161 return FALSE;
1162 }
1163
1164 for (i = 0; i < rendererCount; i++)
1165 {
1166 renderer_properties renderer;
1167
1168 get_renderer_properties(renderer_info, i, &renderer);
1169 if (TRACE_ON(wgl))
1170 {
1171 TRACE("renderer_properties %d:\n", i);
1172 dump_renderer(&renderer);
1173 }
1174
1175 enum_renderer_pixel_formats(renderer, pixel_format_array, pixel_format_set);
1176 }
1177
1178 CFRelease(pixel_format_set);
1179 CGLDestroyRendererInfo(renderer_info);
1180
1181 range = CFRangeMake(0, CFArrayGetCount(pixel_format_array));
1182 if (range.length)
1183 {
1184 pixel_formats = HeapAlloc(GetProcessHeap(), 0, range.length * sizeof(*pixel_formats));
1185 if (pixel_formats)
1186 {
1187 CFArraySortValues(pixel_format_array, range, pixel_format_comparator, NULL);
1188 for (i = 0; i < range.length; i++)
1189 {
1190 CFNumberRef number = CFArrayGetValueAtIndex(pixel_format_array, i);
1191 UInt64 code;
1192
1193 CFNumberGetValue(number, kCFNumberLongLongType, &code);
1194 pixel_formats[i] = pixel_format_for_code(code);
1195 if (pixel_formats[i].window)
1196 nb_displayable_formats++;
1197 }
1198
1199 nb_formats = range.length;
1200 TRACE("Total number of unique pixel formats: %d\n", nb_formats);
1201 ret = TRUE;
1202 }
1203 else
1204 WARN("failed to allocate pixel format list\n");
1205 }
1206 else
1207 WARN("got no pixel formats\n");
1208
1209 CFRelease(pixel_format_array);
1210 return ret;
1211 }
1212
1213
1214 static inline BOOL is_valid_pixel_format(int format)
1215 {
1216 return format > 0 && format <= nb_formats;
1217 }
1218
1219
1220 static inline BOOL is_displayable_pixel_format(int format)
1221 {
1222 return format > 0 && format <= nb_displayable_formats;
1223 }
1224
1225
1226 static const pixel_format *get_pixel_format(int format, BOOL allow_nondisplayable)
1227 {
1228 /* Check if the pixel format is valid. Note that it is legal to pass an invalid
1229 * format in case of probing the number of pixel formats.
1230 */
1231 if (is_valid_pixel_format(format) && (is_displayable_pixel_format(format) || allow_nondisplayable))
1232 {
1233 TRACE("Returning format %d\n", format);
1234 return &pixel_formats[format - 1];
1235 }
1236 return NULL;
1237 }
1238
1239
1240 static BOOL init_gl_info(void)
1241 {
1242 static const char legacy_extensions[] = " WGL_EXT_extensions_string";
1243 static const char legacy_ext_swap_control[] = " WGL_EXT_swap_control";
1244
1245 CGDirectDisplayID display = CGMainDisplayID();
1246 CGOpenGLDisplayMask displayMask = CGDisplayIDToOpenGLDisplayMask(display);
1247 CGLPixelFormatAttribute attribs[] = {
1248 kCGLPFADisplayMask, displayMask,
1249 0
1250 };
1251 #if defined(MAC_OS_X_VERSION_10_7) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
1252 CGLPixelFormatAttribute core_attribs[] =
1253 {
1254 kCGLPFADisplayMask, displayMask,
1255 kCGLPFAAccelerated,
1256 kCGLPFAOpenGLProfile, (CGLPixelFormatAttribute)kCGLOGLPVersion_3_2_Core,
1257 0
1258 };
1259 #endif
1260 CGLPixelFormatObj pix;
1261 GLint virtualScreens;
1262 CGLError err;
1263 CGLContextObj context;
1264 CGLContextObj old_context = CGLGetCurrentContext();
1265 const char *str;
1266 size_t length;
1267
1268 err = CGLChoosePixelFormat(attribs, &pix, &virtualScreens);
1269 if (err != kCGLNoError || !pix)
1270 {
1271 WARN("CGLChoosePixelFormat() failed with error %d %s\n", err, CGLErrorString(err));
1272 return FALSE;
1273 }
1274
1275 err = CGLCreateContext(pix, NULL, &context);
1276 CGLReleasePixelFormat(pix);
1277 if (err != kCGLNoError || !context)
1278 {
1279 WARN("CGLCreateContext() failed with error %d %s\n", err, CGLErrorString(err));
1280 return FALSE;
1281 }
1282
1283 err = CGLSetCurrentContext(context);
1284 if (err != kCGLNoError)
1285 {
1286 WARN("CGLSetCurrentContext() failed with error %d %s\n", err, CGLErrorString(err));
1287 CGLReleaseContext(context);
1288 return FALSE;
1289 }
1290
1291 str = (const char*)opengl_funcs.gl.p_glGetString(GL_EXTENSIONS);
1292 length = strlen(str) + sizeof(legacy_extensions);
1293 if (allow_vsync)
1294 length += strlen(legacy_ext_swap_control);
1295 gl_info.glExtensions = HeapAlloc(GetProcessHeap(), 0, length);
1296 strcpy(gl_info.glExtensions, str);
1297 strcat(gl_info.glExtensions, legacy_extensions);
1298 if (allow_vsync)
1299 strcat(gl_info.glExtensions, legacy_ext_swap_control);
1300
1301 opengl_funcs.gl.p_glGetIntegerv(GL_MAX_VIEWPORT_DIMS, gl_info.max_viewport_dims);
1302
1303 str = (const char*)opengl_funcs.gl.p_glGetString(GL_VERSION);
1304 sscanf(str, "%u.%u", &gl_info.max_major, &gl_info.max_minor);
1305 TRACE("GL version : %s\n", str);
1306 TRACE("GL renderer : %s\n", opengl_funcs.gl.p_glGetString(GL_RENDERER));
1307
1308 CGLSetCurrentContext(old_context);
1309 CGLReleaseContext(context);
1310
1311 #if defined(MAC_OS_X_VERSION_10_7) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
1312 err = CGLChoosePixelFormat(core_attribs, &pix, &virtualScreens);
1313 if (err != kCGLNoError || !pix)
1314 {
1315 WARN("CGLChoosePixelFormat() for a core context failed with error %d %s\n",
1316 err, CGLErrorString(err));
1317 return TRUE;
1318 }
1319
1320 err = CGLCreateContext(pix, NULL, &context);
1321 CGLReleasePixelFormat(pix);
1322 if (err != kCGLNoError || !context)
1323 {
1324 WARN("CGLCreateContext() for a core context failed with error %d %s\n",
1325 err, CGLErrorString(err));
1326 return TRUE;
1327 }
1328
1329 err = CGLSetCurrentContext(context);
1330 if (err != kCGLNoError)
1331 {
1332 WARN("CGLSetCurrentContext() for a core context failed with error %d %s\n",
1333 err, CGLErrorString(err));
1334 CGLReleaseContext(context);
1335 return TRUE;
1336 }
1337
1338 str = (const char*)opengl_funcs.gl.p_glGetString(GL_VERSION);
1339 TRACE("Core context GL version: %s\n", str);
1340 sscanf(str, "%u.%u", &gl_info.max_major, &gl_info.max_minor);
1341 CGLSetCurrentContext(old_context);
1342 CGLReleaseContext(context);
1343 #endif
1344
1345 return TRUE;
1346 }
1347
1348
1349 static int get_dc_pixel_format(HDC hdc)
1350 {
1351 int format;
1352 HWND hwnd;
1353
1354 if ((hwnd = WindowFromDC(hdc)))
1355 {
1356 struct macdrv_win_data *data;
1357
1358 if (!(data = get_win_data(hwnd)))
1359 {
1360 FIXME("DC for window %p of other process: not implemented\n", hwnd);
1361 return 0;
1362 }
1363
1364 format = data->pixel_format;
1365 release_win_data(data);
1366 }
1367 else
1368 {
1369 struct wgl_pbuffer *pbuffer;
1370
1371 EnterCriticalSection(&dc_pbuffers_section);
1372 pbuffer = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, hdc);
1373 if (pbuffer)
1374 format = pbuffer->format;
1375 else
1376 {
1377 WARN("no window or pbuffer for DC %p\n", hdc);
1378 format = 0;
1379 }
1380 LeaveCriticalSection(&dc_pbuffers_section);
1381 }
1382
1383 return format;
1384 }
1385
1386
1387 /**********************************************************************
1388 * create_context
1389 */
1390 static BOOL create_context(struct wgl_context *context, CGLContextObj share, unsigned int major)
1391 {
1392 const pixel_format *pf;
1393 CGLPixelFormatAttribute attribs[64];
1394 int n = 0;
1395 CGLPixelFormatObj pix;
1396 GLint virtualScreens;
1397 CGLError err;
1398 BOOL core = major >= 3;
1399
1400 #if !defined(MAC_OS_X_VERSION_10_7) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
1401 if (core)
1402 {
1403 WARN("OS X version >= 10.7 is required to be able to create core contexts\n");
1404 return FALSE;
1405 }
1406 #endif
1407
1408 pf = get_pixel_format(context->format, TRUE /* non-displayable */);
1409 if (!pf)
1410 {
1411 ERR("Invalid pixel format %d, expect problems!\n", context->format);
1412 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1413 return FALSE;
1414 }
1415
1416 attribs[n++] = kCGLPFAMinimumPolicy;
1417 attribs[n++] = kCGLPFAClosestPolicy;
1418
1419 if (context->renderer_id)
1420 {
1421 attribs[n++] = kCGLPFARendererID;
1422 attribs[n++] = context->renderer_id;
1423 attribs[n++] = kCGLPFASingleRenderer;
1424 attribs[n++] = kCGLPFANoRecovery;
1425 }
1426
1427 if (pf->accelerated)
1428 {
1429 attribs[n++] = kCGLPFAAccelerated;
1430 attribs[n++] = kCGLPFANoRecovery;
1431 }
1432 else
1433 {
1434 attribs[n++] = kCGLPFARendererID;
1435 attribs[n++] = kCGLRendererGenericFloatID;
1436 }
1437
1438 if (pf->double_buffer)
1439 attribs[n++] = kCGLPFADoubleBuffer;
1440
1441 if (!core)
1442 {
1443 attribs[n++] = kCGLPFAAuxBuffers;
1444 attribs[n++] = pf->aux_buffers;
1445 }
1446
1447 attribs[n++] = kCGLPFAColorSize;
1448 attribs[n++] = color_modes[pf->color_mode].color_bits;
1449 attribs[n++] = kCGLPFAAlphaSize;
1450 attribs[n++] = color_modes[pf->color_mode].alpha_bits;
1451 if (color_modes[pf->color_mode].is_float)
1452 attribs[n++] = kCGLPFAColorFloat;
1453
1454 attribs[n++] = kCGLPFADepthSize;
1455 attribs[n++] = pf->depth_bits;
1456
1457 attribs[n++] = kCGLPFAStencilSize;
1458 attribs[n++] = pf->stencil_bits;
1459
1460 if (pf->stereo)
1461 attribs[n++] = kCGLPFAStereo;
1462
1463 if (pf->accum_mode && !core)
1464 {
1465 attribs[n++] = kCGLPFAAccumSize;
1466 attribs[n++] = color_modes[pf->accum_mode - 1].color_bits;
1467 }
1468
1469 if (pf->pbuffer && !core)
1470 attribs[n++] = kCGLPFAPBuffer;
1471
1472 if (pf->sample_buffers && pf->samples)
1473 {
1474 attribs[n++] = kCGLPFASampleBuffers;
1475 attribs[n++] = pf->sample_buffers;
1476 attribs[n++] = kCGLPFASamples;
1477 attribs[n++] = pf->samples;
1478 }
1479
1480 if (pf->backing_store)
1481 attribs[n++] = kCGLPFABackingStore;
1482
1483 #if defined(MAC_OS_X_VERSION_10_7) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
1484 if (core)
1485 {
1486 attribs[n++] = kCGLPFAOpenGLProfile;
1487 #if defined(MAC_OS_X_VERSION_10_9) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9
1488 if (major == 3)
1489 attribs[n++] = (int)kCGLOGLPVersion_GL3_Core;
1490 else
1491 attribs[n++] = (int)kCGLOGLPVersion_GL4_Core;
1492 #else
1493 attribs[n++] = (int)kCGLOGLPVersion_3_2_Core;
1494 #endif
1495 }
1496 #endif
1497
1498 attribs[n] = 0;
1499
1500 err = CGLChoosePixelFormat(attribs, &pix, &virtualScreens);
1501 if (err != kCGLNoError || !pix)
1502 {
1503 WARN("CGLChoosePixelFormat() failed with error %d %s\n", err, CGLErrorString(err));
1504 SetLastError(ERROR_INVALID_OPERATION);
1505 return FALSE;
1506 }
1507
1508 err = CGLCreateContext(pix, share, &context->cglcontext);
1509 CGLReleasePixelFormat(pix);
1510 if (err != kCGLNoError || !context->cglcontext)
1511 {
1512 context->cglcontext = NULL;
1513 WARN("CGLCreateContext() failed with error %d %s\n", err, CGLErrorString(err));
1514 SetLastError(ERROR_INVALID_OPERATION);
1515 return FALSE;
1516 }
1517
1518 if (gl_surface_mode == GL_SURFACE_IN_FRONT_TRANSPARENT)
1519 {
1520 GLint opacity = 0;
1521 err = CGLSetParameter(context->cglcontext, kCGLCPSurfaceOpacity, &opacity);
1522 if (err != kCGLNoError)
1523 WARN("CGLSetParameter(kCGLCPSurfaceOpacity) failed with error %d %s; leaving opaque\n", err, CGLErrorString(err));
1524 }
1525 else if (gl_surface_mode == GL_SURFACE_BEHIND)
1526 {
1527 GLint order = -1;
1528 err = CGLSetParameter(context->cglcontext, kCGLCPSurfaceOrder, &order);
1529 if (err != kCGLNoError)
1530 WARN("CGLSetParameter(kCGLCPSurfaceOrder) failed with error %d %s; leaving in front\n", err, CGLErrorString(err));
1531 }
1532
1533 context->context = macdrv_create_opengl_context(context->cglcontext);
1534 CGLReleaseContext(context->cglcontext);
1535 if (!context->context)
1536 {
1537 WARN("macdrv_create_opengl_context() failed\n");
1538 SetLastError(ERROR_INVALID_OPERATION);
1539 return FALSE;
1540 }
1541 context->major = major;
1542
1543 InterlockedExchange(&context->update_swap_interval, TRUE);
1544
1545 TRACE("created context %p/%p/%p\n", context, context->context, context->cglcontext);
1546
1547 return TRUE;
1548 }
1549
1550
1551 /**********************************************************************
1552 * set_pixel_format
1553 *
1554 * Implementation of wglSetPixelFormat and wglSetPixelFormatWINE.
1555 */
1556 static BOOL set_pixel_format(HDC hdc, int fmt, BOOL allow_reset)
1557 {
1558 struct macdrv_win_data *data;
1559 const pixel_format *pf;
1560 HWND hwnd = WindowFromDC(hdc);
1561 BOOL ret = FALSE;
1562
1563 TRACE("hdc %p format %d\n", hdc, fmt);
1564
1565 if (!hwnd || hwnd == GetDesktopWindow())
1566 {
1567 WARN("not a proper window DC %p/%p\n", hdc, hwnd);
1568 return FALSE;
1569 }
1570
1571 if (!(data = get_win_data(hwnd)))
1572 {
1573 FIXME("DC for window %p of other process: not implemented\n", hwnd);
1574 return FALSE;
1575 }
1576
1577 if (!allow_reset && data->pixel_format) /* cannot change it if already set */
1578 {
1579 ret = (data->pixel_format == fmt);
1580 goto done;
1581 }
1582
1583 /* Check if fmt is in our list of supported formats to see if it is supported. */
1584 pf = get_pixel_format(fmt, FALSE /* non-displayable */);
1585 if (!pf)
1586 {
1587 ERR("Invalid pixel format: %d\n", fmt);
1588 goto done;
1589 }
1590
1591 if (!pf->window)
1592 {
1593 WARN("Pixel format %d is not compatible for window rendering\n", fmt);
1594 goto done;
1595 }
1596
1597 data->pixel_format = fmt;
1598
1599 TRACE("pixel format:\n");
1600 TRACE(" window: %u\n", (unsigned int)pf->window);
1601 TRACE(" pBuffer: %u\n", (unsigned int)pf->pbuffer);
1602 TRACE(" accelerated: %u\n", (unsigned int)pf->accelerated);
1603 TRACE(" color bits: %u%s\n", (unsigned int)color_modes[pf->color_mode].color_bits, (color_modes[pf->color_mode].is_float ? " float" : ""));
1604 TRACE(" alpha bits: %u\n", (unsigned int)color_modes[pf->color_mode].alpha_bits);
1605 TRACE(" aux buffers: %u\n", (unsigned int)pf->aux_buffers);
1606 TRACE(" depth bits: %u\n", (unsigned int)pf->depth_bits);
1607 TRACE(" stencil bits: %u\n", (unsigned int)pf->stencil_bits);
1608 TRACE(" accum bits: %u\n", (unsigned int)pf->accum_mode ? color_modes[pf->accum_mode - 1].color_bits : 0);
1609 TRACE(" double_buffer: %u\n", (unsigned int)pf->double_buffer);
1610 TRACE(" stereo: %u\n", (unsigned int)pf->stereo);
1611 TRACE(" sample_buffers: %u\n", (unsigned int)pf->sample_buffers);
1612 TRACE(" samples: %u\n", (unsigned int)pf->samples);
1613 TRACE(" backing_store: %u\n", (unsigned int)pf->backing_store);
1614 ret = TRUE;
1615
1616 done:
1617 release_win_data(data);
1618 if (ret && gl_surface_mode == GL_SURFACE_BEHIND) __wine_set_pixel_format(hwnd, fmt);
1619 return ret;
1620 }
1621
1622
1623 /**********************************************************************
1624 * mark_contexts_for_moved_view
1625 */
1626 static void mark_contexts_for_moved_view(macdrv_view view)
1627 {
1628 struct wgl_context *context;
1629
1630 EnterCriticalSection(&context_section);
1631 LIST_FOR_EACH_ENTRY(context, &context_list, struct wgl_context, entry)
1632 {
1633 if (context->draw_view == view)
1634 InterlockedExchange(&context->view_moved, TRUE);
1635 }
1636 LeaveCriticalSection(&context_section);
1637 }
1638
1639
1640 /**********************************************************************
1641 * sync_context_rect
1642 */
1643 static BOOL sync_context_rect(struct wgl_context *context)
1644 {
1645 BOOL ret = FALSE;
1646 if (InterlockedCompareExchange(&context->view_moved, FALSE, TRUE))
1647 {
1648 struct macdrv_win_data *data = get_win_data(context->draw_hwnd);
1649
1650 if (data && data->client_cocoa_view == context->draw_view)
1651 {
1652 RECT rect = data->client_rect;
1653 OffsetRect(&rect, -data->whole_rect.left, -data->whole_rect.top);
1654 if (!EqualRect(&context->draw_rect, &rect))
1655 {
1656 context->draw_rect = rect;
1657 ret = TRUE;
1658 }
1659 }
1660 release_win_data(data);
1661 }
1662 return ret;
1663 }
1664
1665
1666 /**********************************************************************
1667 * make_context_current
1668 */
1669 static void make_context_current(struct wgl_context *context, BOOL read)
1670 {
1671 macdrv_view view;
1672 RECT view_rect;
1673 struct wgl_pbuffer *pbuffer;
1674
1675 if (read)
1676 {
1677 view = context->read_view;
1678 view_rect = context->read_rect;
1679 pbuffer = context->read_pbuffer;
1680 }
1681 else
1682 {
1683 sync_context_rect(context);
1684
1685 view = context->draw_view;
1686 view_rect = context->draw_rect;
1687 pbuffer = context->draw_pbuffer;
1688 }
1689
1690 if (view || !pbuffer)
1691 macdrv_make_context_current(context->context, view, cgrect_from_rect(view_rect));
1692 else
1693 {
1694 GLint enabled;
1695
1696 if (CGLIsEnabled(context->cglcontext, kCGLCESurfaceBackingSize, &enabled) == kCGLNoError && enabled)
1697 CGLDisable(context->cglcontext, kCGLCESurfaceBackingSize);
1698 CGLSetPBuffer(context->cglcontext, pbuffer->pbuffer, pbuffer->face,
1699 pbuffer->level, 0);
1700 CGLSetCurrentContext(context->cglcontext);
1701 }
1702 }
1703
1704
1705 /**********************************************************************
1706 * sync_context
1707 */
1708 static void sync_context(struct wgl_context *context)
1709 {
1710 if (sync_context_rect(context))
1711 make_context_current(context, FALSE);
1712 }
1713
1714
1715 /**********************************************************************
1716 * set_swap_interval
1717 */
1718 static BOOL set_swap_interval(struct wgl_context *context, long interval)
1719 {
1720 CGLError err;
1721
1722 /* In theory, for single-buffered contexts, there's no such thing as a swap
1723 so the swap interval shouldn't matter. But OS X will synchronize flushes
1724 of single-buffered contexts if the interval is set to non-zero. */
1725 if (interval && !pixel_formats[context->format - 1].double_buffer)
1726 interval = 0;
1727
1728 err = CGLSetParameter(context->cglcontext, kCGLCPSwapInterval, (GLint*)&interval);
1729 if (err != kCGLNoError)
1730 WARN("CGLSetParameter(kCGLCPSwapInterval) failed; error %d %s\n", err, CGLErrorString(err));
1731
1732 return err == kCGLNoError;
1733 }
1734
1735
1736 /**********************************************************************
1737 * sync_swap_interval
1738 */
1739 static void sync_swap_interval(struct wgl_context *context)
1740 {
1741 if (InterlockedCompareExchange(&context->update_swap_interval, FALSE, TRUE))
1742 {
1743 int interval;
1744
1745 if (!allow_vsync)
1746 interval = 0;
1747 else if (context->draw_hwnd)
1748 {
1749 struct macdrv_win_data *data = get_win_data(context->draw_hwnd);
1750 if (data)
1751 {
1752 interval = data->swap_interval;
1753 release_win_data(data);
1754 }
1755 else /* window was destroyed? */
1756 interval = 1;
1757 }
1758 else /* pbuffer */
1759 interval = 0;
1760
1761 set_swap_interval(context, interval);
1762 }
1763 }
1764
1765
1766 /**********************************************************************
1767 * get_iokit_display_property
1768 */
1769 static BOOL get_iokit_display_property(CGLRendererInfoObj renderer_info, GLint renderer, CFStringRef property, GLuint* value)
1770 {
1771 GLint accelerated;
1772 GLint display_mask;
1773 int i;
1774
1775 if (!get_renderer_property(renderer_info, renderer, kCGLRPAccelerated, &accelerated) || !accelerated)
1776 {
1777 TRACE("assuming unaccelerated renderers don't have IOKit properties\n");
1778 return FALSE;
1779 }
1780
1781 if (!get_renderer_property(renderer_info, renderer, kCGLRPDisplayMask, &display_mask))
1782 {
1783 WARN("failed to get kCGLRPDisplayMask\n");
1784 return FALSE;
1785 }
1786
1787 for (i = 0; i < sizeof(GLint) * 8; i++)
1788 {
1789 GLint this_display_mask = (GLint)(1U << i);
1790 if (this_display_mask & display_mask)
1791 {
1792 CGDirectDisplayID display_id = CGOpenGLDisplayMaskToDisplayID(this_display_mask);
1793 io_service_t service;
1794 CFDataRef data;
1795 uint32_t prop_value;
1796
1797 if (!display_id)
1798 continue;
1799 service = CGDisplayIOServicePort(display_id);
1800 if (!service)
1801 {
1802 WARN("CGDisplayIOServicePort(%u) failed\n", display_id);
1803 continue;
1804 }
1805
1806 data = IORegistryEntrySearchCFProperty(service, kIOServicePlane, property, NULL,
1807 kIORegistryIterateRecursively | kIORegistryIterateParents);
1808 if (!data)
1809 {
1810 WARN("IORegistryEntrySearchCFProperty(%s) failed for display %u\n", debugstr_cf(property), display_id);
1811 continue;
1812 }
1813 if (CFGetTypeID(data) != CFDataGetTypeID())
1814 {
1815 WARN("property %s is not a data object: %s\n", debugstr_cf(property), debugstr_cf(data));
1816 CFRelease(data);
1817 continue;
1818 }
1819 if (CFDataGetLength(data) != sizeof(prop_value))
1820 {
1821 WARN("%s data for display %u has unexpected length %llu\n", debugstr_cf(property), display_id,
1822 (unsigned long long)CFDataGetLength(data));
1823 CFRelease(data);
1824 continue;
1825 }
1826
1827 CFDataGetBytes(data, CFRangeMake(0, sizeof(prop_value)), (UInt8*)&prop_value);
1828 CFRelease(data);
1829 *value = prop_value;
1830 return TRUE;
1831 }
1832 }
1833
1834 return FALSE;
1835 }
1836
1837
1838 /**********************************************************************
1839 * create_pixel_format_for_renderer
1840 *
1841 * Helper for macdrv_wglQueryRendererIntegerWINE(). Caller is
1842 * responsible for releasing the pixel format object.
1843 */
1844 static CGLPixelFormatObj create_pixel_format_for_renderer(CGLRendererInfoObj renderer_info, GLint renderer, BOOL core)
1845 {
1846 GLint renderer_id;
1847 CGLPixelFormatAttribute attrs[] = {
1848 kCGLPFARendererID, 0,
1849 kCGLPFASingleRenderer,
1850 0, 0, /* reserve spots for kCGLPFAOpenGLProfile, kCGLOGLPVersion_3_2_Core */
1851 0
1852 };
1853 CGError err;
1854 CGLPixelFormatObj pixel_format;
1855 GLint virtual_screens;
1856
1857 if (core)
1858 {
1859 #if defined(MAC_OS_X_VERSION_10_7) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
1860 attrs[3] = kCGLPFAOpenGLProfile;
1861 attrs[4] = (CGLPixelFormatAttribute)kCGLOGLPVersion_3_2_Core;
1862 #else
1863 return NULL;
1864 #endif
1865 }
1866
1867 if (!get_renderer_property(renderer_info, renderer, kCGLRPRendererID, &renderer_id))
1868 return NULL;
1869
1870 attrs[1] = renderer_id;
1871 err = CGLChoosePixelFormat(attrs, &pixel_format, &virtual_screens);
1872 if (err != kCGLNoError)
1873 pixel_format = NULL;
1874 return pixel_format;
1875 }
1876
1877
1878 /**********************************************************************
1879 * map_renderer_index
1880 *
1881 * We can't create pixel formats for all renderers listed. For example,
1882 * in a dual-GPU system, the integrated GPU is typically unavailable
1883 * when the discrete GPU is active.
1884 *
1885 * This function conceptually creates a list of "good" renderers from the
1886 * list of all renderers. It treats the input "renderer" parameter as an
1887 * index into that list of good renderers and returns the corresponding
1888 * index into the list of all renderers.
1889 */
1890 static GLint map_renderer_index(CGLRendererInfoObj renderer_info, GLint renderer_count, GLint renderer)
1891 {
1892 GLint good_count, i;
1893
1894 good_count = 0;
1895 for (i = 0; i < renderer_count; i++)
1896 {
1897 CGLPixelFormatObj pix = create_pixel_format_for_renderer(renderer_info, i, FALSE);
1898 if (pix)
1899 {
1900 CGLReleasePixelFormat(pix);
1901 good_count++;
1902 if (good_count > renderer)
1903 break;
1904 }
1905 else
1906 TRACE("skipping bad renderer %d\n", i);
1907 }
1908
1909 TRACE("mapped requested renderer %d to index %d\n", renderer, i);
1910 return i;
1911 }
1912
1913
1914 /**********************************************************************
1915 * get_gl_string
1916 */
1917 static const char* get_gl_string(CGLPixelFormatObj pixel_format, GLenum name)
1918 {
1919 const char* ret = NULL;
1920 CGLContextObj context, old_context;
1921 CGLError err;
1922
1923 err = CGLCreateContext(pixel_format, NULL, &context);
1924 if (err == kCGLNoError && context)
1925 {
1926 old_context = CGLGetCurrentContext();
1927 err = CGLSetCurrentContext(context);
1928 if (err == kCGLNoError)
1929 {
1930 ret = (const char*)opengl_funcs.gl.p_glGetString(name);
1931 CGLSetCurrentContext(old_context);
1932 }
1933 else
1934 WARN("CGLSetCurrentContext failed: %d %s\n", err, CGLErrorString(err));
1935 CGLReleaseContext(context);
1936 }
1937 else
1938 WARN("CGLCreateContext failed: %d %s\n", err, CGLErrorString(err));
1939
1940 return ret;
1941 }
1942
1943
1944 /**********************************************************************
1945 * get_fallback_renderer_version
1946 */
1947 static void get_fallback_renderer_version(GLuint *value)
1948 {
1949 BOOL got_it = FALSE;
1950 CFURLRef url = CFURLCreateWithFileSystemPath(NULL, CFSTR("/System/Library/Frameworks/OpenGL.framework"),
1951 kCFURLPOSIXPathStyle, TRUE);
1952 if (url)
1953 {
1954 CFBundleRef bundle = CFBundleCreate(NULL, url);
1955 CFRelease(url);
1956 if (bundle)
1957 {
1958 CFStringRef version = CFBundleGetValueForInfoDictionaryKey(bundle, kCFBundleVersionKey);
1959 if (version && CFGetTypeID(version) == CFStringGetTypeID())
1960 {
1961 size_t len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(version), kCFStringEncodingUTF8);
1962 char* buf = HeapAlloc(GetProcessHeap(), 0, len);
1963 if (buf && CFStringGetCString(version, buf, len, kCFStringEncodingUTF8))
1964 {
1965 unsigned int major, minor, bugfix;
1966 int count = sscanf(buf, "%u.%u.%u", &major, &minor, &bugfix);
1967 if (count >= 2)
1968 {
1969 value[0] = major;
1970 value[1] = minor;
1971 if (count == 3)
1972 value[2] = bugfix;
1973 else
1974 value[2] = 0;
1975 got_it = TRUE;
1976 }
1977 }
1978 HeapFree(GetProcessHeap(), 0, buf);
1979 }
1980 CFRelease(bundle);
1981 }
1982 }
1983
1984 if (!got_it)
1985 {
1986 /* Use the version of the OpenGL framework from OS X 10.6, which is the
1987 earliest version that the Mac driver supports. */
1988 value[0] = 1;
1989 value[1] = 6;
1990 value[2] = 14;
1991 }
1992 }
1993
1994
1995 /**********************************************************************
1996 * parse_renderer_version
1997 *
1998 * Get the renderer version from the OpenGL version string. Assumes
1999 * the string is of the form
2000 * <GL major>.<GL minor>[.<GL bugfix>] <vendor>-<major>.<minor>[.<bugfix>]
2001 * where major, minor, and bugfix are what we're interested in. This
2002 * form for the vendor specific information is not generally applicable,
2003 * but seems reliable on OS X.
2004 */
2005 static BOOL parse_renderer_version(const char* version, GLuint *value)
2006 {
2007 const char* p = strchr(version, ' ');
2008 int count;
2009 unsigned int major, minor, bugfix;
2010
2011 if (p) p = strchr(p + 1, '-');
2012 if (!p) return FALSE;
2013
2014 count = sscanf(p + 1, "%u.%u.%u", &major, &minor, &bugfix);
2015 if (count < 2)
2016 return FALSE;
2017
2018 value[0] = major;
2019 value[1] = minor;
2020 if (count == 3)
2021 value[2] = bugfix;
2022 else
2023 value[2] = 0;
2024
2025 return TRUE;
2026 }
2027
2028
2029 /**********************************************************************
2030 * query_renderer_integer
2031 */
2032 static BOOL query_renderer_integer(CGLRendererInfoObj renderer_info, GLint renderer, GLenum attribute, GLuint *value)
2033 {
2034 BOOL ret = FALSE;
2035 CGLError err;
2036
2037 if (TRACE_ON(wgl))
2038 {
2039 GLint renderer_id;
2040 if (!get_renderer_property(renderer_info, renderer, kCGLRPRendererID, &renderer_id))
2041 renderer_id = 0;
2042 TRACE("renderer %d (ID 0x%08x) attribute 0x%04x value %p\n", renderer, renderer_id, attribute, value);
2043 }
2044
2045 switch (attribute)
2046 {
2047 case WGL_RENDERER_ACCELERATED_WINE:
2048 if (!get_renderer_property(renderer_info, renderer, kCGLRPAccelerated, (GLint*)value))
2049 break;
2050 *value = !!*value;
2051 ret = TRUE;
2052 TRACE("WGL_RENDERER_ACCELERATED_WINE -> %u\n", *value);
2053 break;
2054
2055 case WGL_RENDERER_DEVICE_ID_WINE:
2056 ret = get_iokit_display_property(renderer_info, renderer, CFSTR("device-id"), value);
2057 if (!ret)
2058 {
2059 *value = 0xffffffff;
2060 ret = TRUE;
2061 }
2062 TRACE("WGL_RENDERER_DEVICE_ID_WINE -> 0x%04x\n", *value);
2063 break;
2064
2065 case WGL_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_WINE:
2066 case WGL_RENDERER_OPENGL_CORE_PROFILE_VERSION_WINE:
2067 {
2068 BOOL core = (attribute == WGL_RENDERER_OPENGL_CORE_PROFILE_VERSION_WINE);
2069 CGLPixelFormatObj pixel_format = create_pixel_format_for_renderer(renderer_info, renderer, core);
2070
2071 if (pixel_format)
2072 {
2073 const char* version = get_gl_string(pixel_format, GL_VERSION);
2074
2075 CGLReleasePixelFormat(pixel_format);
2076 if (version)
2077 {
2078 unsigned int major, minor;
2079
2080 if (sscanf(version, "%u.%u", &major, &minor) == 2)
2081 {
2082 value[0] = major;
2083 value[1] = minor;
2084 ret = TRUE;
2085 }
2086 }
2087 }
2088
2089 if (!ret)
2090 {
2091 value[0] = value[1] = 0;
2092 ret = TRUE;
2093 }
2094 TRACE("%s -> %u.%u\n", core ? "WGL_RENDERER_OPENGL_CORE_PROFILE_VERSION_WINE" :
2095 "WGL_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_WINE", value[0], value[1]);
2096 break;
2097 }
2098
2099 case WGL_RENDERER_PREFERRED_PROFILE_WINE:
2100 {
2101 CGLPixelFormatObj pixel_format = create_pixel_format_for_renderer(renderer_info, renderer, TRUE);
2102
2103 if (pixel_format)
2104 {
2105 CGLReleasePixelFormat(pixel_format);
2106 *value = WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
2107 TRACE("WGL_RENDERER_PREFERRED_PROFILE_WINE -> WGL_CONTEXT_CORE_PROFILE_BIT_ARB (0x%04x)\n", *value);
2108 }
2109 else
2110 {
2111 *value = WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
2112 TRACE("WGL_RENDERER_PREFERRED_PROFILE_WINE -> WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB (0x%04x)\n", *value);
2113 }
2114 ret = TRUE;
2115 break;
2116 }
2117
2118 case WGL_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_WINE:
2119 /* FIXME: no API to query this */
2120 *value = 0;
2121 ret = TRUE;
2122 TRACE("WGL_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_WINE -> %u\n", *value);
2123 break;
2124
2125 case WGL_RENDERER_VENDOR_ID_WINE:
2126 ret = get_iokit_display_property(renderer_info, renderer, CFSTR("vendor-id"), value);
2127 if (!ret)
2128 {
2129 *value = 0xffffffff;
2130 ret = TRUE;
2131 }
2132 TRACE("WGL_RENDERER_VENDOR_ID_WINE -> 0x%04x\n", *value);
2133 break;
2134
2135 case WGL_RENDERER_VERSION_WINE:
2136 {
2137 CGLPixelFormatObj pixel_format = create_pixel_format_for_renderer(renderer_info, renderer, TRUE);
2138
2139 if (!pixel_format)
2140 pixel_format = create_pixel_format_for_renderer(renderer_info, renderer, FALSE);
2141 if (pixel_format)
2142 {
2143 const char* version = get_gl_string(pixel_format, GL_VERSION);
2144
2145 CGLReleasePixelFormat(pixel_format);
2146 if (version)
2147 ret = parse_renderer_version(version, value);
2148 }
2149
2150 if (!ret)
2151 {
2152 get_fallback_renderer_version(value);
2153 ret = TRUE;
2154 }
2155 TRACE("WGL_RENDERER_VERSION_WINE -> %u.%u.%u\n", value[0], value[1], value[2]);
2156 break;
2157 }
2158
2159 case WGL_RENDERER_VIDEO_MEMORY_WINE:
2160 #if defined(MAC_OS_X_VERSION_10_7) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
2161 err = CGLDescribeRenderer(renderer_info, renderer, kCGLRPVideoMemoryMegabytes, (GLint*)value);
2162 if (err != kCGLNoError && err != kCGLBadProperty)
2163 WARN("CGLDescribeRenderer(kCGLRPVideoMemoryMegabytes) failed: %d %s\n", err, CGLErrorString(err));
2164 if (err != kCGLNoError)
2165 #endif
2166 {
2167 if (get_renderer_property(renderer_info, renderer, kCGLRPVideoMemory, (GLint*)value))
2168 *value /= 1024 * 1024;
2169 else
2170 *value = 0;
2171 }
2172 ret = TRUE;
2173 TRACE("WGL_RENDERER_VIDEO_MEMORY_WINE -> %uMB\n", *value);
2174 break;
2175
2176 default:
2177 FIXME("unrecognized attribute 0x%04x\n", attribute);
2178 break;
2179 }
2180
2181 return ret;
2182 }
2183
2184
2185 /**********************************************************************
2186 * macdrv_glCopyColorTable
2187 *
2188 * Hook into glCopyColorTable as part of the implementation of
2189 * wglMakeContextCurrentARB. If the context has a separate readable,
2190 * temporarily make that current, do glCopyColorTable, and then set it
2191 * back to the drawable. This is modeled after what Mesa GLX's Apple
2192 * implementation does.
2193 */
2194 static void macdrv_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y,
2195 GLsizei width)
2196 {
2197 struct wgl_context *context = NtCurrentTeb()->glContext;
2198
2199 if (context->read_view || context->read_pbuffer)
2200 make_context_current(context, TRUE);
2201
2202 pglCopyColorTable(target, internalformat, x, y, width);
2203
2204 if (context->read_view || context->read_pbuffer)
2205 make_context_current(context, FALSE);
2206 }
2207
2208
2209 /**********************************************************************
2210 * macdrv_glCopyPixels
2211 *
2212 * Hook into glCopyPixels as part of the implementation of
2213 * wglMakeContextCurrentARB. If the context has a separate readable,
2214 * temporarily make that current, do glCopyPixels, and then set it back
2215 * to the drawable. This is modeled after what Mesa GLX's Apple
2216 * implementation does.
2217 */
2218 static void macdrv_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
2219 {
2220 struct wgl_context *context = NtCurrentTeb()->glContext;
2221
2222 if (context->read_view || context->read_pbuffer)
2223 make_context_current(context, TRUE);
2224
2225 pglCopyPixels(x, y, width, height, type);
2226
2227 if (context->read_view || context->read_pbuffer)
2228 make_context_current(context, FALSE);
2229 }
2230
2231
2232 /**********************************************************************
2233 * macdrv_glFinish
2234 */
2235 static void macdrv_glFinish(void)
2236 {
2237 struct wgl_context *context = NtCurrentTeb()->glContext;
2238
2239 sync_swap_interval(context);
2240 sync_context(context);
2241 pglFinish();
2242 }
2243
2244
2245 /**********************************************************************
2246 * macdrv_glFlush
2247 */
2248 static void macdrv_glFlush(void)
2249 {
2250 struct wgl_context *context = NtCurrentTeb()->glContext;
2251
2252 sync_swap_interval(context);
2253 sync_context(context);
2254
2255 if (skip_single_buffer_flushes)
2256 {
2257 const pixel_format *pf = &pixel_formats[context->format - 1];
2258 DWORD now = GetTickCount();
2259
2260 TRACE("double buffer %d last flush time %d now %d\n", (int)pf->double_buffer,
2261 context->last_flush_time, now);
2262 if (pglFlushRenderAPPLE && !pf->double_buffer && (now - context->last_flush_time) < 17)
2263 {
2264 TRACE("calling glFlushRenderAPPLE()\n");
2265 pglFlushRenderAPPLE();
2266 return;
2267 }
2268 else
2269 {
2270 TRACE("calling glFlush()\n");
2271 context->last_flush_time = now;
2272 }
2273 }
2274
2275 pglFlush();
2276 }
2277
2278
2279 /**********************************************************************
2280 * macdrv_glGetString
2281 *
2282 * Hook into glGetString in order to return some legacy WGL extensions
2283 * that couldn't be advertised via the standard
2284 * WGL_ARB_extensions_string mechanism. Some programs, especially
2285 * older ones, expect to find certain older extensions, such as
2286 * WGL_EXT_extensions_string itself, in the standard GL extensions
2287 * string, and won't query any other WGL extensions unless they find
2288 * that particular extension there.
2289 */
2290 static const GLubyte *macdrv_glGetString(GLenum name)
2291 {
2292 if (name == GL_EXTENSIONS && gl_info.glExtensions)
2293 return (const GLubyte *)gl_info.glExtensions;
2294 else
2295 return pglGetString(name);
2296 }
2297
2298
2299 /**********************************************************************
2300 * macdrv_glReadPixels
2301 *
2302 * Hook into glReadPixels as part of the implementation of
2303 * wglMakeContextCurrentARB. If the context has a separate readable,
2304 * temporarily make that current, do glReadPixels, and then set it back
2305 * to the drawable. This is modeled after what Mesa GLX's Apple
2306 * implementation does.
2307 */
2308 static void macdrv_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
2309 GLenum format, GLenum type, void *pixels)
2310 {
2311 struct wgl_context *context = NtCurrentTeb()->glContext;
2312
2313 if (context->read_view || context->read_pbuffer)
2314 make_context_current(context, TRUE);
2315
2316 pglReadPixels(x, y, width, height, format, type, pixels);
2317
2318 if (context->read_view || context->read_pbuffer)
2319 make_context_current(context, FALSE);
2320 }
2321
2322
2323 /**********************************************************************
2324 * macdrv_glViewport
2325 *
2326 * Hook into glViewport as an opportunity to update the OpenGL context
2327 * if necessary. This is modeled after what Mesa GLX's Apple
2328 * implementation does.
2329 */
2330 static void macdrv_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
2331 {
2332 struct wgl_context *context = NtCurrentTeb()->glContext;
2333
2334 sync_context(context);
2335 macdrv_update_opengl_context(context->context);
2336 pglViewport(x, y, width, height);
2337 }
2338
2339
2340 /***********************************************************************
2341 * macdrv_wglBindTexImageARB
2342 *
2343 * WGL_ARB_render_texture: wglBindTexImageARB
2344 */
2345 static BOOL macdrv_wglBindTexImageARB(struct wgl_pbuffer *pbuffer, int iBuffer)
2346 {
2347 struct wgl_context *context = NtCurrentTeb()->glContext;
2348 GLenum source;
2349 CGLError err;
2350
2351 TRACE("pbuffer %p iBuffer 0x%x\n", pbuffer, iBuffer);
2352
2353 if (pbuffer->no_texture)
2354 {
2355 SetLastError(ERROR_INVALID_OPERATION);
2356 return GL_FALSE;
2357 }
2358
2359 if (!context->draw_view && context->draw_pbuffer == pbuffer)
2360 opengl_funcs.gl.p_glFlush();
2361
2362 switch (iBuffer)
2363 {
2364 case WGL_FRONT_LEFT_ARB:
2365 if (pixel_formats[pbuffer->format - 1].stereo)
2366 source = GL_FRONT_LEFT;
2367 else
2368 source = GL_FRONT;
2369 break;
2370 case WGL_FRONT_RIGHT_ARB:
2371 source = GL_FRONT_RIGHT;
2372 break;
2373 case WGL_BACK_LEFT_ARB:
2374 if (pixel_formats[pbuffer->format - 1].stereo)
2375 source = GL_BACK_LEFT;
2376 else
2377 source = GL_BACK;
2378 break;
2379 case WGL_BACK_RIGHT_ARB:
2380 source = GL_BACK_RIGHT;
2381 break;
2382 case WGL_AUX0_ARB: source = GL_AUX0; break;
2383 case WGL_AUX1_ARB: source = GL_AUX1; break;
2384 case WGL_AUX2_ARB: source = GL_AUX2; break;
2385 case WGL_AUX3_ARB: source = GL_AUX3; break;
2386
2387 case WGL_AUX4_ARB:
2388 case WGL_AUX5_ARB:
2389 case WGL_AUX6_ARB:
2390 case WGL_AUX7_ARB:
2391 case WGL_AUX8_ARB:
2392 case WGL_AUX9_ARB:
2393 FIXME("unsupported source buffer 0x%x\n", iBuffer);
2394 SetLastError(ERROR_INVALID_DATA);
2395 return GL_FALSE;
2396
2397 default:
2398 WARN("unknown source buffer 0x%x\n", iBuffer);
2399 SetLastError(ERROR_INVALID_DATA);
2400 return GL_FALSE;
2401 }
2402
2403 err = CGLTexImagePBuffer(context->cglcontext, pbuffer->pbuffer, source);
2404 if (err != kCGLNoError)
2405 {
2406 WARN("CGLTexImagePBuffer failed with err %d %s\n", err, CGLErrorString(err));
2407 SetLastError(ERROR_INVALID_OPERATION);
2408 return GL_FALSE;
2409 }
2410
2411 return GL_TRUE;
2412 }
2413
2414
2415 /***********************************************************************
2416 * macdrv_wglChoosePixelFormatARB
2417 *
2418 * WGL_ARB_pixel_format: wglChoosePixelFormatARB
2419 */
2420 static BOOL macdrv_wglChoosePixelFormatARB(HDC hdc, const int *piAttribIList,
2421 const FLOAT *pfAttribFList, UINT nMaxFormats,
2422 int *piFormats, UINT *nNumFormats)
2423 {
2424 pixel_format pf, valid;
2425 const int *iptr;
2426 int color_bits, red_bits, green_bits, blue_bits, alpha_bits;
2427 int accum_bits, accum_red_bits, accum_green_bits, accum_blue_bits, accum_alpha_bits;
2428 int float_color;
2429 BOOL srgb;
2430 int i, found = 0;
2431
2432 TRACE("hdc %p piAttribIList %p pfAttribFList %p nMaxFormats %u piFormats %p nNumFormats %p\n",
2433 hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
2434 if (pfAttribFList)
2435 FIXME("unused pfAttribFList\n");
2436
2437 memset(&pf, 0, sizeof(pf));
2438 memset(&valid, 0, sizeof(valid));
2439 color_bits = red_bits = green_bits = blue_bits = alpha_bits = 0;
2440 accum_bits = accum_red_bits = accum_green_bits = accum_blue_bits = accum_alpha_bits = 0;
2441 float_color = -1;
2442 srgb = FALSE;
2443
2444 for (iptr = piAttribIList; iptr && *iptr; iptr += 2)
2445 {
2446 int attr = iptr[0];
2447 int value = iptr[1];
2448
2449 TRACE("%s\n", debugstr_attrib(attr, value));
2450
2451 switch (attr)
2452 {
2453 case WGL_DRAW_TO_WINDOW_ARB:
2454 if (valid.window && (!pf.window != !value)) goto cant_match;
2455 pf.window = (value != 0);
2456 valid.window = 1;
2457 break;
2458
2459 case WGL_DRAW_TO_BITMAP_ARB:
2460 goto cant_match;
2461
2462 case WGL_ACCELERATION_ARB:
2463 if (value == WGL_FULL_ACCELERATION_ARB)
2464 value = 1;
2465 else if (value == WGL_NO_ACCELERATION_ARB)
2466 value = 0;
2467 else
2468 goto cant_match;
2469 if (valid.accelerated && pf.accelerated != value) goto cant_match;
2470 pf.accelerated = value;
2471 valid.accelerated = 1;
2472 break;
2473
2474 case WGL_NEED_PALETTE_ARB:
2475 case WGL_NEED_SYSTEM_PALETTE_ARB:
2476 case WGL_SWAP_LAYER_BUFFERS_ARB:
2477 if (value) goto cant_match;
2478 break;
2479
2480 case WGL_SWAP_METHOD_ARB:
2481 if (value == WGL_SWAP_COPY_ARB)
2482 value = 1;
2483 else if (value == WGL_SWAP_UNDEFINED_ARB)
2484 value = 0;
2485 else
2486 goto cant_match;
2487 if (valid.backing_store && pf.backing_store != value) goto cant_match;
2488 if (valid.double_buffer && !pf.double_buffer && value) goto cant_match;
2489 pf.backing_store = value;
2490 valid.backing_store = 1;
2491 break;
2492
2493 case WGL_NUMBER_OVERLAYS_ARB:
2494 case WGL_NUMBER_UNDERLAYS_ARB:
2495 if (value) goto cant_match;
2496 break;
2497
2498 case WGL_SHARE_DEPTH_ARB:
2499 case WGL_SHARE_STENCIL_ARB:
2500 case WGL_SHARE_ACCUM_ARB:
2501 /* no effect */
2502 break;
2503
2504 case WGL_SUPPORT_GDI_ARB:
2505 if (value) goto cant_match;
2506 break;
2507
2508 case WGL_SUPPORT_OPENGL_ARB:
2509 if (!value) goto cant_match;
2510 break;
2511
2512 case WGL_DOUBLE_BUFFER_ARB:
2513 if (valid.double_buffer && (!pf.double_buffer != !value)) goto cant_match;
2514 pf.double_buffer = (value != 0);
2515 valid.double_buffer = 1;
2516 if (valid.backing_store && pf.backing_store && !pf.double_buffer) goto cant_match;
2517 break;
2518
2519 case WGL_STEREO_ARB:
2520 if (valid.stereo && (!pf.stereo != !value)) goto cant_match;
2521 pf.stereo = (value != 0);
2522 valid.stereo = 1;
2523 break;
2524
2525 case WGL_PIXEL_TYPE_ARB:
2526 if (value == WGL_TYPE_RGBA_FLOAT_ARB)
2527 value = 1;
2528 else if (value == WGL_TYPE_RGBA_ARB)
2529 value = 0;
2530 else
2531 {
2532 /* Mac contexts don't support rendering to unsigned floating
2533 point formats, even if GL_EXT_packed_float is supported.
2534 So, WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT is not supported. */
2535 goto cant_match;
2536 }
2537 if (float_color != -1 && float_color != value) goto cant_match;
2538 if (srgb && value) goto cant_match;
2539 float_color = value;
2540 break;
2541
2542 case WGL_COLOR_BITS_ARB:
2543 if (color_bits < value) color_bits = value;
2544 break;
2545
2546 case WGL_RED_BITS_ARB:
2547 if (srgb && value > 8) goto cant_match;
2548 if (red_bits < value) red_bits = value;
2549 break;
2550
2551 case WGL_GREEN_BITS_ARB:
2552 if (srgb && value > 8) goto cant_match;
2553 if (green_bits < value) green_bits = value;
2554 break;
2555
2556 case WGL_BLUE_BITS_ARB:
2557 if (srgb && value > 8) goto cant_match;
2558 if (blue_bits < value) blue_bits = value;
2559 break;
2560
2561 case WGL_ALPHA_BITS_ARB:
2562 if (alpha_bits < value) alpha_bits = value;
2563 break;
2564
2565 case WGL_ACCUM_BITS_ARB:
2566 if (accum_bits < value) accum_bits = value;
2567 break;
2568
2569 case WGL_ACCUM_RED_BITS_ARB:
2570 if (accum_red_bits < value) accum_red_bits = value;
2571 break;
2572
2573 case WGL_ACCUM_GREEN_BITS_ARB:
2574 if (accum_green_bits < value) accum_green_bits = value;
2575 break;
2576
2577 case WGL_ACCUM_BLUE_BITS_ARB:
2578 if (accum_blue_bits < value) accum_blue_bits = value;
2579 break;
2580
2581 case WGL_ACCUM_ALPHA_BITS_ARB:
2582 if (accum_alpha_bits < value) accum_alpha_bits = value;
2583 break;
2584
2585 case WGL_DEPTH_BITS_ARB:
2586 if (value > 255) goto cant_match;
2587 if (pf.depth_bits < value) pf.depth_bits = value;
2588 break;
2589
2590 case WGL_STENCIL_BITS_ARB:
2591 if (value > 255) goto cant_match;
2592 if (pf.stencil_bits < value) pf.stencil_bits = value;
2593 break;
2594
2595 case WGL_AUX_BUFFERS_ARB:
2596 if (value > 7) goto cant_match;
2597 if (pf.aux_buffers < value) pf.aux_buffers = value;
2598 break;
2599
2600 case WGL_SAMPLE_BUFFERS_ARB:
2601 if (value > 1) goto cant_match;
2602 if (pf.sample_buffers < value) pf.sample_buffers = value;
2603 break;
2604
2605 case WGL_SAMPLES_ARB:
2606 if (value > 31) goto cant_match;
2607 if (pf.samples < value) pf.samples = value;
2608 break;
2609
2610 case WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB: /* a.k.a. WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT */
2611 /* sRGB is only supported for 8-bit integer color components */
2612 if (float_color >= 1 || red_bits > 8 || green_bits > 8 || blue_bits > 8)
2613 goto cant_match;
2614 srgb = TRUE;
2615 break;
2616
2617 case WGL_NUMBER_PIXEL_FORMATS_ARB:
2618 case WGL_RED_SHIFT_ARB:
2619 case WGL_GREEN_SHIFT_ARB:
2620 case WGL_BLUE_SHIFT_ARB:
2621 case WGL_ALPHA_SHIFT_ARB:
2622 case WGL_TRANSPARENT_ARB:
2623 case WGL_TRANSPARENT_RED_VALUE_ARB:
2624 case WGL_TRANSPARENT_GREEN_VALUE_ARB:
2625 case WGL_TRANSPARENT_BLUE_VALUE_ARB:
2626 case WGL_TRANSPARENT_ALPHA_VALUE_ARB:
2627 case WGL_TRANSPARENT_INDEX_VALUE_ARB:
2628 /* ignored */
2629 break;
2630
2631 case WGL_DRAW_TO_PBUFFER_ARB:
2632 case WGL_BIND_TO_TEXTURE_RGB_ARB:
2633 case WGL_BIND_TO_TEXTURE_RGBA_ARB:
2634 case WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV:
2635 case WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV:
2636 if (valid.pbuffer && (!pf.pbuffer != !value)) goto cant_match;
2637 pf.pbuffer = (value != 0);
2638 valid.pbuffer = 1;
2639 if ((attr == WGL_BIND_TO_TEXTURE_RGBA_ARB || attr == WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV) &&
2640 !alpha_bits)
2641 alpha_bits = 1;
2642 break;
2643
2644 default:
2645 WARN("invalid attribute %s\n", debugstr_attrib(attr, value));
2646 return GL_FALSE;
2647 }
2648 }
2649
2650 TRACE("required: w/p/a %s/%s/%s col/r/g/b/a %d%s/%d/%d/%d/%d srgb %d ac %d/%d/%d/%d/%d dp/stn/ax/b/db/str %u/%u/%u/%s/%s/%s samp %u/%u\n",
2651 valid.window ? (pf.window ? "1" : "0") : "?",
2652 valid.pbuffer ? (pf.pbuffer ? "1" : "0") : "?",
2653 valid.accelerated ? (pf.accelerated ? "1" : "0") : "?",
2654 color_bits,
2655 float_color == -1 ? "?" : float_color ? "f" : "",
2656 red_bits,
2657 green_bits,
2658 blue_bits,
2659 alpha_bits,
2660 (int)srgb,
2661 accum_bits,
2662 accum_red_bits,
2663 accum_green_bits,
2664 accum_blue_bits,
2665 accum_alpha_bits,
2666 pf.depth_bits,
2667 pf.stencil_bits,
2668 pf.aux_buffers,
2669 valid.backing_store ? (pf.backing_store ? "1" : "0") : "?",
2670 valid.double_buffer ? (pf.double_buffer ? "1" : "0") : "?",
2671 valid.stereo ? (pf.stereo ? "1" : "0") : "?",
2672 pf.sample_buffers,
2673 pf.samples);
2674
2675 for (i = 0; i < nb_formats && found < nMaxFormats; i++)
2676 {
2677 const struct color_mode *mode;
2678
2679 if (valid.window && pixel_formats[i].window != pf.window) continue;
2680 if (valid.pbuffer && pixel_formats[i].pbuffer != pf.pbuffer) continue;
2681 if (valid.accelerated && pixel_formats[i].accelerated != pf.accelerated) continue;
2682 if (valid.double_buffer && pixel_formats[i].double_buffer != pf.double_buffer) continue;
2683 if (valid.stereo && pixel_formats[i].stereo != pf.stereo) continue;
2684 if (valid.backing_store && pixel_formats[i].backing_store != pf.backing_store) continue;
2685
2686 if (pixel_formats[i].aux_buffers < pf.aux_buffers) continue;
2687 if (pixel_formats[i].depth_bits < pf.depth_bits) continue;
2688 if (pixel_formats[i].stencil_bits < pf.stencil_bits) continue;
2689 if (pixel_formats[i].sample_buffers < pf.sample_buffers) continue;
2690 if (pixel_formats[i].samples < pf.samples) continue;
2691
2692 mode = &color_modes[pixel_formats[i].color_mode];
2693 /* If the mode doesn't have alpha, check requested color bits against
2694 bits per pixel instead of the mode's color bits. On Windows, color
2695 bits sometimes exceeds r+g+b (e.g. it's 32 for an R8G8B8A0 pixel format).
2696 If an app depends on that and requests WGL_COLOR_BITS_ARB == 32 and
2697 expects that to match such a pixel format, we need to accommodate that. */
2698 if (mode->alpha_bits)
2699 {
2700 if (mode->color_bits < color_bits)
2701 continue;
2702 }
2703 else
2704 {
2705 if (mode->bits_per_pixel < color_bits)
2706 continue;
2707 }
2708 if (mode->red_bits < red_bits || mode->green_bits < green_bits ||
2709 mode->blue_bits < blue_bits || mode->alpha_bits < alpha_bits)
2710 continue;
2711 if (float_color != -1 && (!mode->is_float != !float_color)) continue;
2712 if (srgb && (mode->red_bits != 8 || mode->green_bits != 8 || mode->blue_bits != 8 || mode->is_float))
2713 continue;
2714
2715 if (pixel_formats[i].accum_mode)
2716 {
2717 mode = &color_modes[pixel_formats[i].accum_mode - 1];
2718 if (mode->color_bits < accum_bits || mode->red_bits < accum_red_bits ||
2719 mode->green_bits < accum_green_bits || mode->blue_bits < accum_blue_bits ||
2720 mode->alpha_bits < accum_alpha_bits)
2721 continue;
2722 }
2723 else if (accum_bits || accum_red_bits || accum_green_bits || accum_blue_bits || accum_alpha_bits)
2724 continue;
2725
2726 piFormats[found++] = i + 1;
2727 TRACE("match: pixel format %d %s\n", i + 1, debugstr_pf(&pixel_formats[i]));
2728 }
2729
2730 cant_match:
2731 *nNumFormats = found;
2732
2733 return TRUE;
2734 }
2735
2736
2737 /***********************************************************************
2738 * macdrv_wglCreateContextAttribsARB
2739 *
2740 * WGL_ARB_create_context: wglCreateContextAttribsARB
2741 */
2742 static struct wgl_context *macdrv_wglCreateContextAttribsARB(HDC hdc,
2743 struct wgl_context *share_context,
2744 const int *attrib_list)
2745 {
2746 int format;
2747 struct wgl_context *context;
2748 const int *iptr;
2749 int major = 1, minor = 0, profile = WGL_CONTEXT_CORE_PROFILE_BIT_ARB, flags = 0;
2750 BOOL core = FALSE;
2751 GLint renderer_id = 0;
2752
2753 TRACE("hdc %p, share_context %p, attrib_list %p\n", hdc, share_context, attrib_list);
2754
2755 format = get_dc_pixel_format(hdc);
2756
2757 if (!is_valid_pixel_format(format))
2758 {
2759 ERR("Invalid pixel format %d, expect problems!\n", format);
2760 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2761 return NULL;
2762 }
2763
2764 for (iptr = attrib_list; iptr && *iptr; iptr += 2)
2765 {
2766 int attr = iptr[0];
2767 int value = iptr[1];
2768
2769 TRACE("%s\n", debugstr_attrib(attr, value));
2770
2771 switch (attr)
2772 {
2773 case WGL_CONTEXT_MAJOR_VERSION_ARB:
2774 major = value;
2775 break;
2776
2777 case WGL_CONTEXT_MINOR_VERSION_ARB:
2778 minor = value;
2779 break;
2780
2781 case WGL_CONTEXT_LAYER_PLANE_ARB:
2782 WARN("WGL_CONTEXT_LAYER_PLANE_ARB attribute ignored\n");
2783 break;
2784
2785 case WGL_CONTEXT_FLAGS_ARB:
2786 flags = value;
2787 if (flags & ~WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB)
2788 WARN("WGL_CONTEXT_FLAGS_ARB attributes %#x ignored\n",
2789 flags & ~WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB);
2790 break;
2791
2792 case WGL_CONTEXT_PROFILE_MASK_ARB:
2793 if (value != WGL_CONTEXT_CORE_PROFILE_BIT_ARB &&
2794 value != WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB)
2795 {
2796 WARN("WGL_CONTEXT_PROFILE_MASK_ARB bits %#x invalid\n", value);
2797 SetLastError(ERROR_INVALID_PROFILE_ARB);
2798 return NULL;
2799 }
2800 profile = value;
2801 break;
2802
2803 case WGL_RENDERER_ID_WINE:
2804 {
2805 CGLError err;
2806 CGLRendererInfoObj renderer_info;
2807 GLint renderer_count, temp;
2808
2809 err = CGLQueryRendererInfo(active_displays_mask(), &renderer_info, &renderer_count);
2810 if (err != kCGLNoError)
2811 {
2812 WARN("CGLQueryRendererInfo failed: %d %s\n", err, CGLErrorString(err));
2813 SetLastError(ERROR_GEN_FAILURE);
2814 return NULL;
2815 }
2816
2817 value = map_renderer_index(renderer_info, renderer_count, value);
2818
2819 if (value >= renderer_count)
2820 {
2821 WARN("WGL_RENDERER_ID_WINE renderer %d exceeds count (%d)\n", value, renderer_count);
2822 CGLDestroyRendererInfo(renderer_info);
2823 SetLastError(ERROR_INVALID_PARAMETER);
2824 return NULL;
2825 }
2826
2827 if (!get_renderer_property(renderer_info, value, kCGLRPRendererID, &temp))
2828 {
2829 WARN("WGL_RENDERER_ID_WINE failed to get ID of renderer %d\n", value);
2830 CGLDestroyRendererInfo(renderer_info);
2831 SetLastError(ERROR_GEN_FAILURE);
2832 return NULL;
2833 }
2834
2835 CGLDestroyRendererInfo(renderer_info);
2836
2837 if (renderer_id && temp != renderer_id)
2838 {
2839 WARN("WGL_RENDERER_ID_WINE requested two different renderers (0x%08x vs. 0x%08x)\n", renderer_id, temp);
2840 SetLastError(ERROR_INVALID_PARAMETER);
2841 return NULL;
2842 }
2843 renderer_id = temp;
2844 break;
2845 }
2846
2847 default:
2848 WARN("Unknown attribute %s.\n", debugstr_attrib(attr, value));
2849 SetLastError(ERROR_INVALID_PARAMETER);
2850 return NULL;
2851 }
2852 }
2853
2854 if ((major == 3 && (minor == 2 || minor == 3)) ||
2855 (major == 4 && (minor == 0 || minor == 1)))
2856 {
2857 if (!(flags & WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB))
2858 {
2859 WARN("OS X only supports forward-compatible 3.2+ contexts\n");
2860 SetLastError(ERROR_INVALID_VERSION_ARB);
2861 return NULL;
2862 }
2863 if (profile != WGL_CONTEXT_CORE_PROFILE_BIT_ARB)
2864 {
2865 WARN("Compatibility profiles for GL version >= 3.2 not supported\n");
2866 SetLastError(ERROR_INVALID_PROFILE_ARB);
2867 return NULL;
2868 }
2869 if (major > gl_info.max_major ||
2870 (major == gl_info.max_major && minor > gl_info.max_minor))
2871 {
2872 WARN("This GL implementation does not support the requested GL version %u.%u\n",
2873 major, minor);
2874 SetLastError(ERROR_INVALID_PROFILE_ARB);
2875 return NULL;
2876 }
2877 core = TRUE;
2878 }
2879 else if (major >= 3)
2880 {
2881 WARN("Profile version %u.%u not supported\n", major, minor);
2882 SetLastError(ERROR_INVALID_VERSION_ARB);
2883 return NULL;
2884 }
2885 else if (major < 1 || (major == 1 && (minor < 0 || minor > 5)) ||
2886 (major == 2 && (minor < 0 || minor > 1)))
2887 {
2888 WARN("Invalid GL version requested\n");
2889 SetLastError(ERROR_INVALID_VERSION_ARB);
2890 return NULL;
2891 }
2892 if (!core && flags & WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB)
2893 {
2894 WARN("Forward compatible context requested for GL version < 3\n");
2895 SetLastError(ERROR_INVALID_VERSION_ARB);
2896 return NULL;
2897 }
2898
2899 if (!(context = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*context)))) return NULL;
2900
2901 context->format = format;
2902 context->renderer_id = renderer_id;
2903 if (!create_context(context, share_context ? share_context->cglcontext : NULL, major))
2904 {
2905 HeapFree(GetProcessHeap(), 0, context);
2906 return NULL;
2907 }
2908
2909 EnterCriticalSection(&context_section);
2910 list_add_tail(&context_list, &context->entry);
2911 LeaveCriticalSection(&context_section);
2912
2913 return context;
2914 }
2915
2916
2917 /**********************************************************************
2918 * macdrv_wglCreatePbufferARB
2919 *
2920 * WGL_ARB_pbuffer: wglCreatePbufferARB
2921 */
2922 static struct wgl_pbuffer *macdrv_wglCreatePbufferARB(HDC hdc, int iPixelFormat, int iWidth, int iHeight,
2923 const int *piAttribList)
2924 {
2925 struct wgl_pbuffer* pbuffer;
2926 GLenum target = 0;
2927 GLenum internalFormat = 0;
2928 CGLError err;
2929
2930 TRACE("hdc %p iPixelFormat %d iWidth %d iHeight %d piAttribList %p\n",
2931 hdc, iPixelFormat, iWidth, iHeight, piAttribList);
2932
2933 if (!is_valid_pixel_format(iPixelFormat) || !pixel_formats[iPixelFormat - 1].pbuffer)
2934 {
2935 WARN("invalid pixel format %d\n", iPixelFormat);
2936 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2937 return NULL;
2938 }
2939
2940 pbuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pbuffer));
2941 pbuffer->format = iPixelFormat;
2942
2943 for ( ; piAttribList && *piAttribList; piAttribList += 2)
2944 {
2945 int attr = piAttribList[0];
2946 int value = piAttribList[1];
2947
2948 switch (attr)
2949 {
2950 case WGL_PBUFFER_LARGEST_ARB:
2951 FIXME("WGL_PBUFFER_LARGEST_ARB: %d; ignoring\n", value);
2952 break;
2953
2954 case WGL_TEXTURE_FORMAT_ARB:
2955 switch (value)
2956 {
2957 case WGL_TEXTURE_RGBA_ARB:
2958 TRACE("WGL_TEXTURE_FORMAT_ARB: WGL_TEXTURE_RGBA_ARB\n");
2959 internalFormat = GL_RGBA;
2960 break;
2961 case WGL_TEXTURE_RGB_ARB:
2962 TRACE("WGL_TEXTURE_FORMAT_ARB: WGL_TEXTURE_RGB_ARB\n");
2963 internalFormat = GL_RGB;
2964 break;
2965 case WGL_NO_TEXTURE_ARB:
2966 TRACE("WGL_TEXTURE_FORMAT_ARB: WGL_NO_TEXTURE_ARB\n");
2967 internalFormat = 0;
2968 break;
2969 default:
2970 WARN("unknown WGL_TEXTURE_FORMAT_ARB value 0x%x\n", value);
2971 SetLastError(ERROR_INVALID_DATA);
2972 goto done;
2973 }
2974 break;
2975
2976 case WGL_TEXTURE_TARGET_ARB:
2977 pbuffer->face = 0;
2978 switch (value)
2979 {
2980 case WGL_NO_TEXTURE_ARB:
2981 TRACE("WGL_TEXTURE_TARGET_ARB: WGL_NO_TEXTURE_ARB\n");
2982 target = 0;
2983 break;
2984 case WGL_TEXTURE_CUBE_MAP_ARB:
2985 TRACE("WGL_TEXTURE_TARGET_ARB: WGL_TEXTURE_CUBE_MAP_ARB\n");
2986 target = GL_TEXTURE_CUBE_MAP;
2987 pbuffer->face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
2988 break;
2989 case WGL_TEXTURE_1D_ARB:
2990 FIXME("WGL_TEXTURE_TARGET_ARB: WGL_TEXTURE_1D_ARB; not supported\n");
2991 SetLastError(ERROR_NO_SYSTEM_RESOURCES);
2992 goto done;
2993 case WGL_TEXTURE_2D_ARB:
2994 TRACE("WGL_TEXTURE_TARGET_ARB: WGL_TEXTURE_2D_ARB\n");
2995 target = GL_TEXTURE_2D;
2996 break;
2997 case WGL_TEXTURE_RECTANGLE_NV:
2998 TRACE("WGL_TEXTURE_TARGET_ARB: WGL_TEXTURE_RECTANGLE_NV\n");
2999 target = GL_TEXTURE_RECTANGLE;
3000 break;
3001 default:
3002 WARN("unknown WGL_TEXTURE_TARGET_ARB value 0x%x\n", value);
3003 SetLastError(ERROR_INVALID_DATA);
3004 goto done;
3005 }
3006 break;
3007
3008 case WGL_MIPMAP_TEXTURE_ARB:
3009 TRACE("WGL_MIPMAP_TEXTURE_ARB: %d\n", value);
3010 pbuffer->max_level = 0;
3011 if (value)
3012 {
3013 int size = min(iWidth, iHeight) / 2;
3014 while (size)
3015 {
3016 pbuffer->max_level++;
3017 size /= 2;
3018 }
3019 }
3020 break;
3021
3022 default:
3023 WARN("unknown attribute 0x%x\n", attr);
3024 SetLastError(ERROR_INVALID_DATA);
3025 goto done;
3026 }
3027 }
3028
3029 if (!target || !internalFormat)
3030 {
3031 pbuffer->no_texture = TRUE;
3032 /* no actual way to turn off ability to texture; use most permissive target */
3033 target = GL_TEXTURE_RECTANGLE;
3034 internalFormat = GL_RGB;
3035 }
3036
3037 err = CGLCreatePBuffer(iWidth, iHeight, target, internalFormat, pbuffer->max_level, &pbuffer->pbuffer);
3038 if (err != kCGLNoError)
3039 {
3040 WARN("CGLCreatePBuffer failed; err %d %s\n", err, CGLErrorString(err));
3041 pbuffer->pbuffer = NULL;
3042 if (err == kCGLBadAlloc)
3043 SetLastError(ERROR_NO_SYSTEM_RESOURCES);
3044 else
3045 SetLastError(ERROR_INVALID_DATA);
3046 }
3047
3048 done:
3049 if (!pbuffer->pbuffer)
3050 {
3051 HeapFree(GetProcessHeap(), 0, pbuffer);
3052 return NULL;
3053 }
3054
3055 TRACE(" -> %p\n", pbuffer);
3056 return pbuffer;
3057 }
3058
3059
3060 /**********************************************************************
3061 * macdrv_wglDestroyPbufferARB
3062 *
3063 * WGL_ARB_pbuffer: wglDestroyPbufferARB
3064 */
3065 static BOOL macdrv_wglDestroyPbufferARB(struct wgl_pbuffer *pbuffer)
3066 {
3067 TRACE("pbuffer %p\n", pbuffer);
3068 if (pbuffer && pbuffer->pbuffer)
3069 CGLReleasePBuffer(pbuffer->pbuffer);
3070 HeapFree(GetProcessHeap(), 0, pbuffer);
3071 return GL_TRUE;
3072 }
3073
3074
3075 /**********************************************************************
3076 * macdrv_wglGetExtensionsStringARB
3077 *
3078 * WGL_ARB_extensions_string: wglGetExtensionsStringARB
3079 */
3080 static const char *macdrv_wglGetExtensionsStringARB(HDC hdc)
3081 {
3082 /* FIXME: Since we're given an HDC, this should be device-specific. I.e.
3083 this can be specific to the CGL renderer like we're supposed to do. */
3084 TRACE("returning \"%s\"\n", gl_info.wglExtensions);
3085 return gl_info.wglExtensions;
3086 }
3087
3088
3089 /**********************************************************************
3090 * macdrv_wglGetExtensionsStringEXT
3091 *
3092 * WGL_EXT_extensions_string: wglGetExtensionsStringEXT
3093 */
3094 static const char *macdrv_wglGetExtensionsStringEXT(void)
3095 {
3096 TRACE("returning \"%s\"\n", gl_info.wglExtensions);
3097 return gl_info.wglExtensions;
3098 }
3099
3100
3101 /**********************************************************************
3102 * macdrv_wglGetPbufferDCARB
3103 *
3104 * WGL_ARB_pbuffer: wglGetPbufferDCARB
3105 */
3106 static HDC macdrv_wglGetPbufferDCARB(struct wgl_pbuffer *pbuffer)
3107 {
3108 HDC hdc;
3109 struct wgl_pbuffer *prev;
3110
3111 hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
3112 if (!hdc) return 0;
3113
3114 EnterCriticalSection(&dc_pbuffers_section);
3115 prev = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, hdc);
3116 if (prev)
3117 {
3118 CGLReleasePBuffer(prev->pbuffer);
3119 HeapFree(GetProcessHeap(), 0, prev);
3120 }
3121 CFDictionarySetValue(dc_pbuffers, hdc, pbuffer);
3122 LeaveCriticalSection(&dc_pbuffers_section);
3123
3124 TRACE("pbuffer %p -> hdc %p\n", pbuffer, hdc);
3125 return hdc;
3126 }
3127
3128
3129 /**********************************************************************
3130 * macdrv_wglGetPixelFormatAttribivARB
3131 *
3132 * WGL_ARB_pixel_format: wglGetPixelFormatAttribivARB
3133 */
3134 static BOOL macdrv_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelFormat, int iLayerPlane,
3135 UINT nAttributes, const int *piAttributes, int *piValues)
3136 {
3137 const pixel_format *pf;
3138 UINT i;
3139
3140 TRACE("hdc %p iPixelFormat %d iLayerPlane %d nAttributes %u piAttributes %p piValues %p\n",
3141 hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
3142
3143 if (!nAttributes) return GL_TRUE;
3144
3145 if (nAttributes == 1 && piAttributes[0] == WGL_NUMBER_PIXEL_FORMATS_ARB)
3146 {
3147 piValues[0] = nb_formats;
3148 TRACE("%s\n", debugstr_attrib(piAttributes[0], piValues[0]));
3149 return GL_TRUE;
3150 }
3151
3152 pf = get_pixel_format(iPixelFormat, TRUE /* non-displayable */);
3153 if (!pf)
3154 {
3155 WARN("invalid pixel format %d\n", iPixelFormat);
3156 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
3157 return GL_FALSE;
3158 }
3159
3160 for (i = 0; i < nAttributes; ++i)
3161 {
3162 switch (piAttributes[i])
3163 {
3164 case WGL_NUMBER_PIXEL_FORMATS_ARB:
3165 piValues[i] = nb_formats;
3166 break;
3167
3168 case WGL_DRAW_TO_WINDOW_ARB:
3169 piValues[i] = pf->window ? GL_TRUE : GL_FALSE;
3170 break;
3171
3172 case WGL_DRAW_TO_BITMAP_ARB:
3173 piValues[i] = GL_FALSE;
3174 break;
3175
3176 case WGL_ACCELERATION_ARB:
3177 if (iLayerPlane) goto invalid_layer;
3178 if (pf->accelerated)
3179 piValues[i] = WGL_FULL_ACCELERATION_ARB;
3180 else
3181 piValues[i] = WGL_NO_ACCELERATION_ARB;
3182 break;
3183
3184 case WGL_NEED_PALETTE_ARB:
3185 case WGL_NEED_SYSTEM_PALETTE_ARB:
3186 case WGL_SWAP_LAYER_BUFFERS_ARB:
3187 piValues[i] = GL_FALSE;
3188 break;
3189
3190 case WGL_SWAP_METHOD_ARB:
3191 if (pf->double_buffer && pf->backing_store)
3192 piValues[i] = WGL_SWAP_COPY_ARB;
3193 else
3194 piValues[i] = WGL_SWAP_UNDEFINED_ARB;
3195 break;
3196
3197 case WGL_NUMBER_OVERLAYS_ARB:
3198 case WGL_NUMBER_UNDERLAYS_ARB:
3199 piValues[i] = 0;
3200 break;
3201
3202 case WGL_TRANSPARENT_ARB:
3203 if (iLayerPlane) goto invalid_layer;
3204 piValues[i] = GL_FALSE;
3205 break;
3206
3207 case WGL_TRANSPARENT_RED_VALUE_ARB:
3208 case WGL_TRANSPARENT_GREEN_VALUE_ARB:
3209 case WGL_TRANSPARENT_BLUE_VALUE_ARB:
3210 case WGL_TRANSPARENT_ALPHA_VALUE_ARB:
3211 case WGL_TRANSPARENT_INDEX_VALUE_ARB:
3212 if (iLayerPlane) goto invalid_layer;
3213 piValues[i] = 0;
3214 break;
3215
3216 case WGL_SHARE_DEPTH_ARB:
3217 case WGL_SHARE_STENCIL_ARB:
3218 case WGL_SHARE_ACCUM_ARB:
3219 if (iLayerPlane) goto invalid_layer;
3220 piValues[i] = GL_TRUE;
3221 break;
3222
3223 case WGL_SUPPORT_GDI_ARB:
3224 if (iLayerPlane) goto invalid_layer;
3225 piValues[i] = GL_FALSE;
3226 break;
3227
3228 case WGL_SUPPORT_OPENGL_ARB:
3229 if (iLayerPlane) goto invalid_layer;
3230 piValues[i] = GL_TRUE;
3231 break;
3232
3233 case WGL_DOUBLE_BUFFER_ARB:
3234 if (iLayerPlane) goto invalid_layer;
3235 piValues[i] = pf->double_buffer ? GL_TRUE : GL_FALSE;
3236 break;
3237
3238 case WGL_STEREO_ARB:
3239 if (iLayerPlane) goto invalid_layer;
3240 piValues[i] = pf->stereo ? GL_TRUE : GL_FALSE;
3241 break;
3242
3243 case WGL_PIXEL_TYPE_ARB:
3244 if (iLayerPlane) goto invalid_layer;
3245 if (color_modes[pf->color_mode].is_float)
3246 piValues[i] = WGL_TYPE_RGBA_FLOAT_ARB;
3247 else
3248 piValues[i] = WGL_TYPE_RGBA_ARB;
3249 /* WGL_EXT_pixel_format_packed_float may be supported, which should in theory
3250 make another pixel type available: WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT.
3251 However, Mac contexts don't support rendering to unsigned floating-point
3252 formats, even when GL_EXT_packed_float is supported. */
3253 break;
3254
3255 case WGL_COLOR_BITS_ARB:
3256 if (iLayerPlane) goto invalid_layer;
3257 /* If the mode doesn't have alpha, return bits per pixel instead
3258 of color bits. On Windows, color bits sometimes exceeds r+g+b
3259 (e.g. it's 32 for an R8G8B8A0 pixel format). If an app depends
3260 on that and expects that WGL_COLOR_BITS_ARB >= 32 for such a
3261 pixel format, we need to accommodate that. */
3262 if (color_modes[pf->color_mode].alpha_bits)
3263 piValues[i] = color_modes[pf->color_mode].color_bits;
3264 else
3265 piValues[i] = color_modes[pf->color_mode].bits_per_pixel;
3266 break;
3267
3268 case WGL_RED_BITS_ARB:
3269 if (iLayerPlane) goto invalid_layer;
3270 piValues[i] = color_modes[pf->color_mode].red_bits;
3271 break;
3272
3273 case WGL_RED_SHIFT_ARB:
3274 if (iLayerPlane) goto invalid_layer;
3275 piValues[i] = color_modes[pf->color_mode].red_shift;
3276 break;
3277
3278 case WGL_GREEN_BITS_ARB:
3279 if (iLayerPlane) goto invalid_layer;
3280 piValues[i] = color_modes[pf->color_mode].green_bits;
3281 break;
3282
3283 case WGL_GREEN_SHIFT_ARB:
3284 if (iLayerPlane) goto invalid_layer;
3285 piValues[i] = color_modes[pf->color_mode].green_shift;
3286 break;
3287
3288 case WGL_BLUE_BITS_ARB:
3289 if (iLayerPlane) goto invalid_layer;
3290 piValues[i] = color_modes[pf->color_mode].blue_bits;
3291 break;
3292
3293 case WGL_BLUE_SHIFT_ARB:
3294 if (iLayerPlane) goto invalid_layer;
3295 piValues[i] = color_modes[pf->color_mode].blue_shift;
3296 break;
3297
3298 case WGL_ALPHA_BITS_ARB:
3299 if (iLayerPlane) goto invalid_layer;
3300 piValues[i] = color_modes[pf->color_mode].alpha_bits;
3301 break;
3302
3303 case WGL_ALPHA_SHIFT_ARB:
3304 if (iLayerPlane) goto invalid_layer;
3305 piValues[i] = color_modes[pf->color_mode].alpha_shift;
3306 break;
3307
3308 case WGL_ACCUM_BITS_ARB:
3309 if (iLayerPlane) goto invalid_layer;
3310 if (pf->accum_mode)
3311 piValues[i] = color_modes[pf->accum_mode - 1].color_bits;
3312 else
3313 piValues[i] = 0;
3314 break;
3315
3316 case WGL_ACCUM_RED_BITS_ARB:
3317 if (iLayerPlane) goto invalid_layer;
3318 if (pf->accum_mode)
3319 piValues[i] = color_modes[pf->accum_mode - 1].red_bits;
3320 else
3321 piValues[i] = 0;
3322 break;
3323
3324 case WGL_ACCUM_GREEN_BITS_ARB:
3325 if (iLayerPlane) goto invalid_layer;
3326 if (pf->accum_mode)
3327 piValues[i] = color_modes[pf->accum_mode - 1].green_bits;
3328 else
3329 piValues[i] = 0;
3330 break;
3331
3332 case WGL_ACCUM_BLUE_BITS_ARB:
3333 if (iLayerPlane) goto invalid_layer;
3334 if (pf->accum_mode)
3335 piValues[i] = color_modes[pf->accum_mode - 1].blue_bits;
3336 else
3337 piValues[i] = 0;
3338 break;
3339
3340 case WGL_ACCUM_ALPHA_BITS_ARB:
3341 if (iLayerPlane) goto invalid_layer;
3342 if (pf->accum_mode)
3343 piValues[i] = color_modes[pf->accum_mode - 1].alpha_bits;
3344 else
3345 piValues[i] = 0;
3346 break;
3347
3348 case WGL_DEPTH_BITS_ARB:
3349 if (iLayerPlane) goto invalid_layer;
3350 piValues[i] = pf->depth_bits;
3351 break;
3352
3353 case WGL_STENCIL_BITS_ARB:
3354 if (iLayerPlane) goto invalid_layer;
3355 piValues[i] = pf->stencil_bits;
3356 break;
3357
3358 case WGL_AUX_BUFFERS_ARB:
3359 if (iLayerPlane) goto invalid_layer;
3360 piValues[i] = pf->aux_buffers;
3361 break;
3362
3363 case WGL_SAMPLE_BUFFERS_ARB:
3364 if (iLayerPlane) goto invalid_layer;
3365 piValues[i] = pf->sample_buffers;
3366 break;
3367
3368 case WGL_SAMPLES_ARB:
3369 if (iLayerPlane) goto invalid_layer;
3370 piValues[i] = pf->samples;
3371 break;
3372
3373 case WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB: /* a.k.a. WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT */
3374 if (iLayerPlane) goto invalid_layer;
3375 /* sRGB is only supported for 8-bit integer color components */
3376 if (color_modes[pf->color_mode].red_bits == 8 &&
3377 color_modes[pf->color_mode].green_bits == 8 &&
3378 color_modes[pf->color_mode].blue_bits == 8 &&
3379 !color_modes[pf->color_mode].is_float)
3380 piValues[i] = GL_TRUE;
3381 else
3382 piValues[i] = GL_FALSE;
3383 break;
3384
3385 case WGL_DRAW_TO_PBUFFER_ARB:
3386 case WGL_BIND_TO_TEXTURE_RGB_ARB:
3387 case WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV:
3388 piValues[i] = pf->pbuffer ? GL_TRUE : GL_FALSE;
3389 break;
3390
3391 case WGL_BIND_TO_TEXTURE_RGBA_ARB:
3392 case WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV:
3393 piValues[i] = (pf->pbuffer && color_modes[pf->color_mode].alpha_bits) ? GL_TRUE : GL_FALSE;
3394 break;
3395
3396 case WGL_MAX_PBUFFER_WIDTH_ARB:
3397 piValues[i] = gl_info.max_viewport_dims[0];
3398 break;
3399
3400 case WGL_MAX_PBUFFER_HEIGHT_ARB:
3401 piValues[i] = gl_info.max_viewport_dims[1];
3402 break;
3403
3404 case WGL_MAX_PBUFFER_PIXELS_ARB:
3405 piValues[i] = gl_info.max_viewport_dims[0] * gl_info.max_viewport_dims[1];
3406 break;
3407
3408 default:
3409 WARN("invalid attribute %x\n", piAttributes[i]);
3410 return GL_FALSE;
3411 }
3412
3413 TRACE("%s\n", debugstr_attrib(piAttributes[i], piValues[i]));
3414 }
3415
3416 return GL_TRUE;
3417
3418 invalid_layer:
3419 FIXME("unsupported iLayerPlane %d\n", iLayerPlane);
3420 return GL_FALSE;
3421 }
3422
3423
3424 /**********************************************************************
3425 * macdrv_wglGetPixelFormatAttribfvARB
3426 *
3427 * WGL_ARB_pixel_format: wglGetPixelFormatAttribfvARB
3428 */
3429 static BOOL macdrv_wglGetPixelFormatAttribfvARB(HDC hdc, int iPixelFormat, int iLayerPlane,
3430 UINT nAttributes, const int *piAttributes, FLOAT *pfValues)
3431 {
3432 int *attr;
3433 int ret;
3434
3435 TRACE("hdc %p iPixelFormat %d iLayerPlane %d nAttributes %u piAttributes %p pfValues %p\n",
3436 hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
3437
3438 /* Allocate a temporary array to store integer values */
3439 attr = HeapAlloc(GetProcessHeap(), 0, nAttributes * sizeof(int));
3440 if (!attr)
3441 {
3442 ERR("couldn't allocate %d array\n", nAttributes);
3443 return GL_FALSE;
3444 }
3445
3446 /* Piggy-back on wglGetPixelFormatAttribivARB */
3447 ret = macdrv_wglGetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, attr);
3448 if (ret)
3449 {
3450 UINT i;
3451
3452 /* Convert integer values to float. Should also check for attributes
3453 that can give decimal values here */
3454 for (i = 0; i < nAttributes; i++)
3455 pfValues[i] = attr[i];
3456 }
3457
3458 HeapFree(GetProcessHeap(), 0, attr);
3459 return ret;
3460 }
3461
3462
3463 /**********************************************************************
3464 * macdrv_wglGetSwapIntervalEXT
3465 *
3466 * WGL_EXT_swap_control: wglGetSwapIntervalEXT
3467 */
3468 static int macdrv_wglGetSwapIntervalEXT(void)
3469 {
3470 struct wgl_context *context = NtCurrentTeb()->glContext;
3471 struct macdrv_win_data *data;
3472 long value;
3473 CGLError err;
3474
3475 TRACE("\n");
3476
3477 if ((data = get_win_data(context->draw_hwnd)))
3478 {
3479 value = data->swap_interval;
3480 release_win_data(data);
3481
3482 if (InterlockedCompareExchange(&context->update_swap_interval, FALSE, TRUE))
3483 set_swap_interval(context, allow_vsync ? value : 0);
3484 }
3485 else
3486 {
3487 err = CGLGetParameter(context->cglcontext, kCGLCPSwapInterval, (GLint*)&value);
3488 if (err != kCGLNoError)
3489 {
3490 WARN("CGLGetParameter(kCGLCPSwapInterval) failed; error %d %s\n",
3491 err, CGLErrorString(err));
3492 value = 1;
3493 }
3494 }
3495
3496 return value;
3497 }
3498
3499
3500 /***********************************************************************
3501 * macdrv_wglMakeContextCurrentARB
3502 *
3503 * WGL_ARB_make_current_read: wglMakeContextCurrentARB
3504 *
3505 * This is not supported directly by OpenGL on the Mac. We emulate it
3506 * by hooking into glReadPixels, glCopyPixels, and glCopyColorTable to
3507 * temporarily swap the drawable. This follows the technique used in
3508 * the implementation of Mesa GLX for Apple.
3509 */
3510 static BOOL macdrv_wglMakeContextCurrentARB(HDC draw_hdc, HDC read_hdc, struct wgl_context *context)
3511 {
3512 struct macdrv_win_data *data;
3513 HWND hwnd;
3514
3515 TRACE("draw_hdc %p read_hdc %p context %p/%p/%p\n", draw_hdc, read_hdc, context,
3516 (context ? context->context : NULL), (context ? context->cglcontext : NULL));
3517
3518 if (!context)
3519 {
3520 macdrv_make_context_current(NULL, NULL, CGRectNull);
3521 NtCurrentTeb()->glContext = NULL;
3522 return TRUE;
3523 }
3524
3525 if ((hwnd = WindowFromDC(draw_hdc)))
3526 {
3527 if (!(data = get_win_data(hwnd)))
3528 {
3529 FIXME("draw DC for window %p of other process: not implemented\n", hwnd);
3530 return FALSE;
3531 }
3532
3533 if (!data->pixel_format)
3534 {
3535 WARN("no pixel format set\n");
3536 release_win_data(data);
3537 SetLastError(ERROR_INVALID_HANDLE);
3538 return FALSE;
3539 }
3540 if (context->format != data->pixel_format)
3541 {
3542 WARN("mismatched pixel format draw_hdc %p %u context %p %u\n", draw_hdc, data->pixel_format, context, context->format);
3543 release_win_data(data);
3544 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
3545 return FALSE;
3546 }
3547
3548 if (InterlockedCompareExchange(&context->update_swap_interval, FALSE, TRUE) || hwnd != context->draw_hwnd)
3549 set_swap_interval(context, allow_vsync ? data->swap_interval : 0);
3550
3551 context->draw_hwnd = hwnd;
3552 context->draw_view = data->client_cocoa_view;
3553 context->draw_rect = data->client_rect;
3554 OffsetRect(&context->draw_rect, -data->whole_rect.left, -data->whole_rect.top);
3555 context->draw_pbuffer = NULL;
3556 release_win_data(data);
3557 }
3558 else
3559 {
3560 struct wgl_pbuffer *pbuffer;
3561
3562 EnterCriticalSection(&dc_pbuffers_section);
3563 pbuffer = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, draw_hdc);
3564 if (pbuffer)
3565 {
3566 if (context->format != pbuffer->format)
3567 {
3568 WARN("mismatched pixel format draw_hdc %p %u context %p %u\n", draw_hdc, pbuffer->format, context, context->format);
3569 LeaveCriticalSection(&dc_pbuffers_section);
3570 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
3571 return FALSE;
3572 }
3573
3574 if (InterlockedCompareExchange(&context->update_swap_interval, FALSE, TRUE) || pbuffer != context->draw_pbuffer)
3575 set_swap_interval(context, 0);
3576 }
3577 else
3578 {
3579 WARN("no window or pbuffer for DC\n");
3580 LeaveCriticalSection(&dc_pbuffers_section);
3581 SetLastError(ERROR_INVALID_HANDLE);
3582 return FALSE;
3583 }
3584
3585 context->draw_hwnd = NULL;
3586 context->draw_view = NULL;
3587 context->draw_pbuffer = pbuffer;
3588 LeaveCriticalSection(&dc_pbuffers_section);
3589 }
3590
3591 context->read_view = NULL;
3592 context->read_pbuffer = NULL;
3593 if (read_hdc && read_hdc != draw_hdc)
3594 {
3595 if ((hwnd = WindowFromDC(read_hdc)))
3596 {
3597 if ((data = get_win_data(hwnd)))
3598 {
3599 if (data->client_cocoa_view != context->draw_view)
3600 {
3601 context->read_view = data->client_cocoa_view;
3602 context->read_rect = data->client_rect;
3603 OffsetRect(&context->read_rect, -data->whole_rect.left, -data->whole_rect.top);
3604 }
3605 release_win_data(data);
3606 }
3607 }
3608 else
3609 {
3610 EnterCriticalSection(&dc_pbuffers_section);
3611 context->read_pbuffer = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, read_hdc);
3612 LeaveCriticalSection(&dc_pbuffers_section);
3613 }
3614 }
3615
3616 TRACE("making context current with draw_view %p %s draw_pbuffer %p read_view %p %s read_pbuffer %p format %u\n",
3617 context->draw_view, wine_dbgstr_rect(&context->draw_rect), context->draw_pbuffer,
3618 context->read_view, wine_dbgstr_rect(&context->read_rect), context->read_pbuffer, context->format);
3619
3620 make_context_current(context, FALSE);
3621 context->has_been_current = TRUE;
3622 NtCurrentTeb()->glContext = context;
3623
3624 return TRUE;
3625 }
3626
3627
3628 /**********************************************************************
3629 * macdrv_wglQueryCurrentRendererIntegerWINE
3630 *
3631 * WGL_WINE_query_renderer: wglQueryCurrentRendererIntegerWINE
3632 */
3633 static BOOL macdrv_wglQueryCurrentRendererIntegerWINE(GLenum attribute, GLuint *value)
3634 {
3635 BOOL ret = FALSE;
3636 struct wgl_context *context = NtCurrentTeb()->glContext;
3637 CGLPixelFormatObj pixel_format;
3638 CGLError err;
3639 GLint virtual_screen;
3640 GLint display_mask;
3641 GLint pf_renderer_id;
3642 CGLRendererInfoObj renderer_info;
3643 GLint renderer_count;
3644 GLint renderer;
3645
3646 TRACE("context %p/%p/%p attribute 0x%04x value %p\n", context, (context ? context->context : NULL),
3647 (context ? context->cglcontext : NULL), attribute, value);
3648
3649 if (attribute == WGL_RENDERER_VERSION_WINE)
3650 {
3651 if (!parse_renderer_version((const char*)opengl_funcs.gl.p_glGetString(GL_VERSION), value))
3652 get_fallback_renderer_version(value);
3653 TRACE("WGL_RENDERER_VERSION_WINE -> %u.%u.%u\n", value[0], value[1], value[2]);
3654 return TRUE;
3655 }
3656
3657 pixel_format = CGLGetPixelFormat(context->cglcontext);
3658 err = CGLGetVirtualScreen(context->cglcontext, &virtual_screen);
3659 if (err != kCGLNoError)
3660 {
3661 WARN("CGLGetVirtualScreen failed: %d %s\n", err, CGLErrorString(err));
3662 return FALSE;
3663 }
3664
3665 err = CGLDescribePixelFormat(pixel_format, virtual_screen, kCGLPFADisplayMask, &display_mask);
3666 if (err != kCGLNoError)
3667 {
3668 WARN("CGLDescribePixelFormat(kCGLPFADisplayMask) failed: %d %s\n", err, CGLErrorString(err));
3669 return FALSE;
3670 }
3671
3672 err = CGLDescribePixelFormat(pixel_format, virtual_screen, kCGLPFARendererID, &pf_renderer_id);
3673 if (err != kCGLNoError)
3674 {
3675 WARN("CGLDescribePixelFormat(kCGLPFARendererID) failed: %d %s\n", err, CGLErrorString(err));
3676 return FALSE;
3677 }
3678
3679 err = CGLQueryRendererInfo(display_mask, &renderer_info, &renderer_count);
3680 if (err != kCGLNoError)
3681 {
3682 WARN("CGLQueryRendererInfo failed: %d %s\n", err, CGLErrorString(err));
3683 return FALSE;
3684 }
3685
3686 for (renderer = 0; renderer < renderer_count; renderer++)
3687 {
3688 GLint renderer_id;
3689
3690 if (!get_renderer_property(renderer_info, renderer, kCGLRPRendererID, &renderer_id))
3691 continue;
3692
3693 if (renderer_id == pf_renderer_id)
3694 {
3695 ret = query_renderer_integer(renderer_info, renderer, attribute, value);
3696 break;
3697 }
3698 }
3699
3700 if (renderer >= renderer_count)
3701 ERR("failed to find renderer ID 0x%08x for display mask 0x%08x\n", pf_renderer_id, display_mask);
3702
3703 CGLDestroyRendererInfo(renderer_info);
3704 return ret;
3705 }
3706
3707
3708 /**********************************************************************
3709 * macdrv_wglQueryCurrentRendererStringWINE
3710 *
3711 * WGL_WINE_query_renderer: wglQueryCurrentRendererStringWINE
3712 */
3713 static const char *macdrv_wglQueryCurrentRendererStringWINE(GLenum attribute)
3714 {
3715 const char* ret = NULL;
3716 struct wgl_context *context = NtCurrentTeb()->glContext;
3717
3718 TRACE("context %p/%p/%p attribute 0x%04x\n", context, (context ? context->context : NULL),
3719 (context ? context->cglcontext : NULL), attribute);
3720
3721 switch (attribute)
3722 {
3723 case WGL_RENDERER_DEVICE_ID_WINE:
3724 {
3725 ret = (const char*)opengl_funcs.gl.p_glGetString(GL_RENDERER);
3726 TRACE("WGL_RENDERER_DEVICE_ID_WINE -> %s\n", debugstr_a(ret));
3727 break;
3728 }
3729
3730 case WGL_RENDERER_VENDOR_ID_WINE:
3731 {
3732 ret = (const char*)opengl_funcs.gl.p_glGetString(GL_VENDOR);
3733 TRACE("WGL_RENDERER_VENDOR_ID_WINE -> %s\n", debugstr_a(ret));
3734 break;
3735 }
3736
3737 default:
3738 FIXME("unrecognized attribute 0x%04x\n", attribute);
3739 break;
3740 }
3741
3742 return ret;
3743 }
3744
3745
3746 /**********************************************************************
3747 * macdrv_wglQueryPbufferARB
3748 *
3749 * WGL_ARB_pbuffer: wglQueryPbufferARB
3750 */
3751 static BOOL macdrv_wglQueryPbufferARB(struct wgl_pbuffer *pbuffer, int iAttribute, int *piValue)
3752 {
3753 CGLError err;
3754 GLsizei width;
3755 GLsizei height;
3756 GLenum target;
3757 GLenum internalFormat;
3758 GLint mipmap;
3759
3760 TRACE("pbuffer %p iAttribute 0x%x piValue %p\n", pbuffer, iAttribute, piValue);
3761
3762 err = CGLDescribePBuffer(pbuffer->pbuffer, &width, &height, &target, &internalFormat, &mipmap);
3763 if (err != kCGLNoError)
3764 {
3765 WARN("CGLDescribePBuffer failed; error %d %s\n", err, CGLErrorString(err));
3766 SetLastError(ERROR_INVALID_HANDLE);
3767 return GL_FALSE;
3768 }
3769
3770 switch (iAttribute)
3771 {
3772 case WGL_PBUFFER_WIDTH_ARB:
3773 *piValue = width;
3774 break;
3775 case WGL_PBUFFER_HEIGHT_ARB:
3776 *piValue = height;
3777 break;
3778 case WGL_PBUFFER_LOST_ARB:
3779 /* Mac PBuffers can't be lost */
3780 *piValue = GL_FALSE;
3781 break;
3782 case WGL_TEXTURE_FORMAT_ARB:
3783 if (pbuffer->no_texture)
3784 *piValue = WGL_NO_TEXTURE_ARB;
3785 else switch (internalFormat)
3786 {
3787 case GL_RGBA:
3788 *piValue = WGL_TEXTURE_RGBA_ARB;
3789 break;
3790 case GL_RGB:
3791 default:
3792 *piValue = WGL_TEXTURE_RGB_ARB;
3793 break;
3794 }
3795 break;
3796 case WGL_TEXTURE_TARGET_ARB:
3797 if (pbuffer->no_texture)
3798 *piValue = WGL_NO_TEXTURE_ARB;
3799 else switch (target)
3800 {
3801 case GL_TEXTURE_CUBE_MAP:
3802 *piValue = WGL_TEXTURE_CUBE_MAP_ARB;
3803 break;
3804 case GL_TEXTURE_2D:
3805 *piValue = WGL_TEXTURE_2D_ARB;
3806 break;
3807 case GL_TEXTURE_RECTANGLE:
3808 default:
3809 *piValue = WGL_TEXTURE_RECTANGLE_NV;
3810 break;
3811 }
3812 break;
3813 case WGL_MIPMAP_TEXTURE_ARB:
3814 *piValue = (pbuffer->max_level > 0);
3815 break;
3816 case WGL_MIPMAP_LEVEL_ARB:
3817 *piValue = pbuffer->level;
3818 break;
3819 case WGL_CUBE_MAP_FACE_ARB:
3820 switch (pbuffer->face)
3821 {
3822 case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
3823 default:
3824 *piValue = WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB;
3825 break;
3826 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
3827 *piValue = WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB;
3828 break;
3829 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
3830 *piValue = WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB;
3831 break;
3832 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
3833 *piValue = WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB;
3834 break;
3835 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
3836 *piValue = WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB;
3837 break;
3838 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
3839 *piValue = WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB;
3840 break;
3841 }
3842 break;
3843 default:
3844 WARN("invalid attribute 0x%x\n", iAttribute);
3845 SetLastError(ERROR_INVALID_DATA);
3846 return GL_FALSE;
3847 }
3848
3849 return GL_TRUE;
3850 }
3851
3852
3853 /**********************************************************************
3854 * macdrv_wglQueryRendererIntegerWINE
3855 *
3856 * WGL_WINE_query_renderer: wglQueryRendererIntegerWINE
3857 */
3858 static BOOL macdrv_wglQueryRendererIntegerWINE(HDC dc, GLint renderer, GLenum attribute, GLuint *value)
3859 {
3860 BOOL ret = FALSE;
3861 CGLRendererInfoObj renderer_info;
3862 GLint renderer_count;
3863 CGLError err;
3864
3865 TRACE("dc %p renderer %d attribute 0x%04x value %p\n", dc, renderer, attribute, value);
3866
3867 err = CGLQueryRendererInfo(active_displays_mask(), &renderer_info, &renderer_count);
3868 if (err != kCGLNoError)
3869 {
3870 WARN("CGLQueryRendererInfo failed: %d %s\n", err, CGLErrorString(err));
3871 return FALSE;
3872 }
3873
3874 renderer = map_renderer_index(renderer_info, renderer_count, renderer);
3875
3876 if (renderer < renderer_count)
3877 ret = query_renderer_integer(renderer_info, renderer, attribute, value);
3878 else
3879 TRACE("requested information for renderer %d exceeding count %d\n", renderer, renderer_count);
3880
3881 CGLDestroyRendererInfo(renderer_info);
3882 return ret;
3883 }
3884
3885
3886 /**********************************************************************
3887 * macdrv_wglQueryRendererStringWINE
3888 *
3889 * WGL_WINE_query_renderer: wglQueryRendererStringWINE
3890 */
3891 static const char *macdrv_wglQueryRendererStringWINE(HDC dc, GLint renderer, GLenum attribute)
3892 {
3893 const char* ret = NULL;
3894 CGLRendererInfoObj renderer_info;
3895 GLint renderer_count;
3896 CGLError err;
3897
3898 TRACE("dc %p renderer %d attribute 0x%04x\n", dc, renderer, attribute);
3899
3900 err = CGLQueryRendererInfo(active_displays_mask(), &renderer_info, &renderer_count);
3901 if (err != kCGLNoError)
3902 {
3903 WARN("CGLQueryRendererInfo failed: %d %s\n", err, CGLErrorString(err));
3904 return FALSE;
3905 }
3906
3907 renderer = map_renderer_index(renderer_info, renderer_count, renderer);
3908
3909 if (renderer >= renderer_count)
3910 {
3911 TRACE("requested information for renderer %d exceeding count %d\n", renderer, renderer_count);
3912 goto done;
3913 }
3914
3915 switch (attribute)
3916 {
3917 case WGL_RENDERER_DEVICE_ID_WINE:
3918 case WGL_RENDERER_VENDOR_ID_WINE:
3919 {
3920 BOOL device = (attribute == WGL_RENDERER_DEVICE_ID_WINE);
3921 CGLPixelFormatObj pixel_format = create_pixel_format_for_renderer(renderer_info, renderer, TRUE);
3922
3923 if (!pixel_format)
3924 pixel_format = create_pixel_format_for_renderer(renderer_info, renderer, FALSE);
3925 if (pixel_format)
3926 {
3927 ret = get_gl_string(pixel_format, device ? GL_RENDERER : GL_VENDOR);
3928 CGLReleasePixelFormat(pixel_format);
3929 }
3930
3931 TRACE("%s -> %s\n", device ? "WGL_RENDERER_DEVICE_ID_WINE" : "WGL_RENDERER_VENDOR_ID_WINE", debugstr_a(ret));
3932 break;
3933 }
3934
3935 default:
3936 FIXME("unrecognized attribute 0x%04x\n", attribute);
3937 break;
3938 }
3939
3940 done:
3941 CGLDestroyRendererInfo(renderer_info);
3942 return ret;
3943 }
3944
3945
3946 /**********************************************************************
3947 * macdrv_wglReleasePbufferDCARB
3948 *
3949 * WGL_ARB_pbuffer: wglReleasePbufferDCARB
3950 */
3951 static int macdrv_wglReleasePbufferDCARB(struct wgl_pbuffer *pbuffer, HDC hdc)
3952 {
3953 struct wgl_pbuffer *prev;
3954
3955 TRACE("pbuffer %p hdc %p\n", pbuffer, hdc);
3956
3957 EnterCriticalSection(&dc_pbuffers_section);
3958
3959 prev = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, hdc);
3960 if (prev)
3961 {
3962 if (prev != pbuffer)
3963 FIXME("hdc %p isn't associated with pbuffer %p\n", hdc, pbuffer);
3964 CGLReleasePBuffer(prev->pbuffer);
3965 HeapFree(GetProcessHeap(), 0, prev);
3966 CFDictionaryRemoveValue(dc_pbuffers, hdc);
3967 }
3968 else hdc = 0;
3969
3970 LeaveCriticalSection(&dc_pbuffers_section);
3971
3972 return hdc && DeleteDC(hdc);
3973 }
3974
3975
3976 /**********************************************************************
3977 * macdrv_wglReleaseTexImageARB
3978 *
3979 * WGL_ARB_render_texture: wglReleaseTexImageARB
3980 */
3981 static BOOL macdrv_wglReleaseTexImageARB(struct wgl_pbuffer *pbuffer, int iBuffer)
3982 {
3983 struct wgl_context *context = NtCurrentTeb()->glContext;
3984 CGLError err;
3985
3986 TRACE("pbuffer %p iBuffer 0x%x; stub!\n", pbuffer, iBuffer);
3987
3988 if (pbuffer->no_texture)
3989 {
3990 SetLastError(ERROR_INVALID_OPERATION);
3991 return GL_FALSE;
3992 }
3993
3994 err = CGLTexImagePBuffer(context->cglcontext, pbuffer->pbuffer, GL_NONE);
3995 if (err != kCGLNoError)
3996 {
3997 WARN("CGLTexImagePBuffer failed with err %d %s\n", err, CGLErrorString(err));
3998 SetLastError(ERROR_INVALID_OPERATION);
3999 return GL_FALSE;
4000 }
4001
4002 return GL_TRUE;
4003 }
4004
4005
4006 /**********************************************************************
4007 * macdrv_wglSetPbufferAttribARB
4008 *
4009 * WGL_ARB_render_texture: wglSetPbufferAttribARB
4010 */
4011 static BOOL macdrv_wglSetPbufferAttribARB(struct wgl_pbuffer *pbuffer, const int *piAttribList)
4012 {
4013 struct wgl_context *context = NtCurrentTeb()->glContext;
4014
4015 TRACE("pbuffer %p piAttribList %p\n", pbuffer, piAttribList);
4016
4017 for ( ; piAttribList && *piAttribList; piAttribList += 2)
4018 {
4019 int attr = piAttribList[0];
4020 int value = piAttribList[1];
4021 switch (attr)
4022 {
4023 case WGL_MIPMAP_LEVEL_ARB:
4024 TRACE("WGL_MIPMAP_LEVEL_ARB: %d\n", value);
4025 pbuffer->level = value;
4026 break;
4027 case WGL_CUBE_MAP_FACE_ARB:
4028 switch (value)
4029 {
4030 case WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
4031 TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB\n");
4032 pbuffer->face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
4033 break;
4034 case WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
4035 TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB\n");
4036 pbuffer->face = GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
4037 break;
4038 case WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
4039 TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB\n");
4040 pbuffer->face = GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
4041 break;
4042 case WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
4043 TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB\n");
4044 pbuffer->face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
4045 break;
4046 case WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
4047 TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB\n");
4048 pbuffer->face = GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
4049 break;
4050 case WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
4051 TRACE("WGL_CUBE_MAP_FACE_ARB: WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB\n");
4052 pbuffer->face = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
4053 break;
4054 default:
4055 WARN("unknown WGL_CUBE_MAP_FACE_ARB value 0x%x\n", value);
4056 SetLastError(ERROR_INVALID_DATA);
4057 return GL_FALSE;
4058 }
4059 break;
4060 default:
4061 WARN("invalid attribute 0x%x\n", attr);
4062 SetLastError(ERROR_INVALID_DATA);
4063 return GL_FALSE;
4064 }
4065 }
4066
4067 if (context && context->draw_pbuffer == pbuffer)
4068 make_context_current(context, FALSE);
4069
4070 return GL_TRUE;
4071 }
4072
4073
4074 /**********************************************************************
4075 * macdrv_wglSetPixelFormatWINE
4076 *
4077 * WGL_WINE_pixel_format_passthrough: wglSetPixelFormatWINE
4078 */
4079 static BOOL macdrv_wglSetPixelFormatWINE(HDC hdc, int fmt)
4080 {
4081 return set_pixel_format(hdc, fmt, TRUE);
4082 }
4083
4084
4085 /**********************************************************************
4086 * macdrv_wglSwapIntervalEXT
4087 *
4088 * WGL_EXT_swap_control: wglSwapIntervalEXT
4089 */
4090 static BOOL macdrv_wglSwapIntervalEXT(int interval)
4091 {
4092 struct wgl_context *context = NtCurrentTeb()->glContext;
4093 BOOL changed = FALSE;
4094
4095 TRACE("interval %d\n", interval);
4096
4097 if (interval < 0)
4098 {
4099 SetLastError(ERROR_INVALID_DATA);
4100 return FALSE;
4101 }
4102 if (interval > 1)
4103 interval = 1;
4104
4105 if (context->draw_hwnd)
4106 {
4107 struct macdrv_win_data *data = get_win_data(context->draw_hwnd);
4108 if (data)
4109 {
4110 changed = data->swap_interval != interval;
4111 if (changed)
4112 data->swap_interval = interval;
4113 release_win_data(data);
4114 }
4115 }
4116 else /* pbuffer */
4117 interval = 0;
4118
4119 if (!allow_vsync)
4120 interval = 0;
4121
4122 InterlockedExchange(&context->update_swap_interval, FALSE);
4123 if (!set_swap_interval(context, interval))
4124 {
4125 SetLastError(ERROR_GEN_FAILURE);
4126 return FALSE;
4127 }
4128
4129 if (changed)
4130 {
4131 struct wgl_context *ctx;
4132
4133 EnterCriticalSection(&context_section);
4134 LIST_FOR_EACH_ENTRY(ctx, &context_list, struct wgl_context, entry)
4135 {
4136 if (ctx != context && ctx->draw_hwnd == context->draw_hwnd)
4137 InterlockedExchange(&context->update_swap_interval, TRUE);
4138 }
4139 LeaveCriticalSection(&context_section);
4140 }
4141
4142 return TRUE;
4143 }
4144
4145
4146 static void register_extension(const char *ext)
4147 {
4148 if (gl_info.wglExtensions[0])
4149 strcat(gl_info.wglExtensions, " ");
4150 strcat(gl_info.wglExtensions, ext);
4151
4152 TRACE("'%s'\n", ext);
4153 }
4154
4155 static void load_extensions(void)
4156 {
4157 /*
4158 * ARB Extensions
4159 */
4160 register_extension("WGL_ARB_extensions_string");
4161 opengl_funcs.ext.p_wglGetExtensionsStringARB = macdrv_wglGetExtensionsStringARB;
4162
4163 register_extension("WGL_ARB_make_current_read");
4164 opengl_funcs.ext.p_wglGetCurrentReadDCARB = (void *)1; /* never called */
4165 opengl_funcs.ext.p_wglMakeContextCurrentARB = macdrv_wglMakeContextCurrentARB;
4166
4167 register_extension("WGL_ARB_pixel_format");
4168 opengl_funcs.ext.p_wglChoosePixelFormatARB = macdrv_wglChoosePixelFormatARB;
4169 opengl_funcs.ext.p_wglGetPixelFormatAttribfvARB = macdrv_wglGetPixelFormatAttribfvARB;
4170 opengl_funcs.ext.p_wglGetPixelFormatAttribivARB = macdrv_wglGetPixelFormatAttribivARB;
4171
4172 if (gluCheckExtension((GLubyte*)"GL_ARB_color_buffer_float", (GLubyte*)gl_info.glExtensions))
4173 {
4174 register_extension("WGL_ARB_pixel_format_float");
4175 register_extension("WGL_ATI_pixel_format_float");
4176 }
4177
4178 if (gluCheckExtension((GLubyte*)"GL_ARB_multisample", (GLubyte*)gl_info.glExtensions))
4179 register_extension("WGL_ARB_multisample");
4180
4181 if (gluCheckExtension((GLubyte*)"GL_ARB_framebuffer_sRGB", (GLubyte*)gl_info.glExtensions))
4182 register_extension("WGL_ARB_framebuffer_sRGB");
4183
4184 if (gluCheckExtension((GLubyte*)"GL_APPLE_pixel_buffer", (GLubyte*)gl_info.glExtensions))
4185 {
4186 register_extension("WGL_ARB_pbuffer");
4187 opengl_funcs.ext.p_wglCreatePbufferARB = macdrv_wglCreatePbufferARB;
4188 opengl_funcs.ext.p_wglDestroyPbufferARB = macdrv_wglDestroyPbufferARB;
4189 opengl_funcs.ext.p_wglGetPbufferDCARB = macdrv_wglGetPbufferDCARB;
4190 opengl_funcs.ext.p_wglQueryPbufferARB = macdrv_wglQueryPbufferARB;
4191 opengl_funcs.ext.p_wglReleasePbufferDCARB = macdrv_wglReleasePbufferDCARB;
4192
4193 register_extension("WGL_ARB_render_texture");
4194 opengl_funcs.ext.p_wglBindTexImageARB = macdrv_wglBindTexImageARB;
4195 opengl_funcs.ext.p_wglReleaseTexImageARB = macdrv_wglReleaseTexImageARB;
4196 opengl_funcs.ext.p_wglSetPbufferAttribARB = macdrv_wglSetPbufferAttribARB;
4197
4198 if (gluCheckExtension((GLubyte*)"GL_ARB_texture_rectangle", (GLubyte*)gl_info.glExtensions) ||
4199 gluCheckExtension((GLubyte*)"GL_EXT_texture_rectangle", (GLubyte*)gl_info.glExtensions))
4200 register_extension("WGL_NV_render_texture_rectangle");
4201 }
4202
4203 register_extension("WGL_ARB_create_context");
4204 register_extension("WGL_ARB_create_context_profile");
4205 opengl_funcs.ext.p_wglCreateContextAttribsARB = macdrv_wglCreateContextAttribsARB;
4206
4207 /*
4208 * EXT Extensions
4209 */
4210 register_extension("WGL_EXT_extensions_string");
4211 opengl_funcs.ext.p_wglGetExtensionsStringEXT = macdrv_wglGetExtensionsStringEXT;
4212
4213 if (allow_vsync)
4214 {
4215 register_extension("WGL_EXT_swap_control");
4216 opengl_funcs.ext.p_wglSwapIntervalEXT = macdrv_wglSwapIntervalEXT;
4217 opengl_funcs.ext.p_wglGetSwapIntervalEXT = macdrv_wglGetSwapIntervalEXT;
4218 }
4219
4220 /* Presumably identical to [W]GL_ARB_framebuffer_sRGB, above, but clients may
4221 check for either, so register them separately. */
4222 if (gluCheckExtension((GLubyte*)"GL_EXT_framebuffer_sRGB", (GLubyte*)gl_info.glExtensions))
4223 register_extension("WGL_EXT_framebuffer_sRGB");
4224
4225 if (gluCheckExtension((GLubyte*)"GL_EXT_packed_float", (GLubyte*)gl_info.glExtensions))
4226 register_extension("WGL_EXT_pixel_format_packed_float");
4227
4228 /*
4229 * WINE-specific WGL Extensions
4230 */
4231
4232 /* In WineD3D we need the ability to set the pixel format more than once (e.g. after a device reset).
4233 * The default wglSetPixelFormat doesn't allow this, so add our own which allows it.
4234 */
4235 register_extension("WGL_WINE_pixel_format_passthrough");
4236 opengl_funcs.ext.p_wglSetPixelFormatWINE = macdrv_wglSetPixelFormatWINE;
4237
4238 register_extension("WGL_WINE_query_renderer");
4239 opengl_funcs.ext.p_wglQueryCurrentRendererIntegerWINE = macdrv_wglQueryCurrentRendererIntegerWINE;
4240 opengl_funcs.ext.p_wglQueryCurrentRendererStringWINE = macdrv_wglQueryCurrentRendererStringWINE;
4241 opengl_funcs.ext.p_wglQueryRendererIntegerWINE = macdrv_wglQueryRendererIntegerWINE;
4242 opengl_funcs.ext.p_wglQueryRendererStringWINE = macdrv_wglQueryRendererStringWINE;
4243 }
4244
4245
4246 static BOOL CALLBACK init_opengl(INIT_ONCE *init_once, void *context, void **param)
4247 {
4248 static BOOL init_done = FALSE;
4249 unsigned int i;
4250
4251 if (init_done) return (opengl_handle != NULL);
4252 init_done = TRUE;
4253
4254 TRACE("()\n");
4255
4256 dc_pbuffers = CFDictionaryCreateMutable(NULL, 0, NULL, NULL);
4257 if (!dc_pbuffers)
4258 {
4259 WARN("CFDictionaryCreateMutable failed\n");
4260 return FALSE;
4261 }
4262
4263 opengl_handle = dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY|RTLD_LOCAL|RTLD_NOLOAD);
4264 if (!opengl_handle)
4265 {
4266 ERR("Failed to load OpenGL: %s\n", dlerror());
4267 ERR("OpenGL support is disabled.\n");
4268 return FALSE;
4269 }
4270
4271 for (i = 0; i < ARRAY_SIZE(opengl_func_names); i++)
4272 {
4273 if (!(((void **)&opengl_funcs.gl)[i] = dlsym(opengl_handle, opengl_func_names[i])))
4274 {
4275 ERR("%s not found in OpenGL, disabling.\n", opengl_func_names[i]);
4276 goto failed;
4277 }
4278 }
4279
4280 if (!init_gl_info())
4281 goto failed;
4282
4283 /* redirect some standard OpenGL functions */
4284 #define REDIRECT(func) \
4285 do { p##func = opengl_funcs.gl.p_##func; opengl_funcs.gl.p_##func = macdrv_##func; } while(0)
4286 REDIRECT(glCopyPixels);
4287 REDIRECT(glGetString);
4288 REDIRECT(glReadPixels);
4289 REDIRECT(glViewport);
4290 if (skip_single_buffer_flushes || allow_vsync)
4291 REDIRECT(glFlush);
4292 if (allow_vsync)
4293 REDIRECT(glFinish);
4294 #undef REDIRECT
4295
4296 /* redirect some OpenGL extension functions */
4297 #define REDIRECT(func) \
4298 do { if ((p##func = dlsym(opengl_handle, #func))) { opengl_funcs.ext.p_##func = macdrv_##func; } } while(0)
4299 REDIRECT(glCopyColorTable);
4300 #undef REDIRECT
4301
4302 if (gluCheckExtension((GLubyte*)"GL_APPLE_flush_render", (GLubyte*)gl_info.glExtensions))
4303 pglFlushRenderAPPLE = dlsym(opengl_handle, "glFlushRenderAPPLE");
4304
4305 load_extensions();
4306 if (!init_pixel_formats())
4307 goto failed;
4308
4309 return TRUE;
4310
4311 failed:
4312 dlclose(opengl_handle);
4313 opengl_handle = NULL;
4314 return FALSE;
4315 }
4316
4317
4318 /***********************************************************************
4319 * sync_gl_view
4320 *
4321 * Synchronize the Mac GL view position with the Windows child window
4322 * position.
4323 */
4324 void sync_gl_view(struct macdrv_win_data* data, const RECT* old_whole_rect, const RECT* old_client_rect)
4325 {
4326 if (data->client_cocoa_view && data->pixel_format)
4327 {
4328 RECT old = *old_client_rect, new = data->client_rect;
4329
4330 OffsetRect(&old, -old_whole_rect->left, -old_whole_rect->top);
4331 OffsetRect(&new, -data->whole_rect.left, -data->whole_rect.top);
4332 if (!EqualRect(&old, &new))
4333 {
4334 TRACE("GL view %p changed position; marking contexts\n", data->client_cocoa_view);
4335 mark_contexts_for_moved_view(data->client_cocoa_view);
4336 }
4337 }
4338 }
4339
4340
4341 /**********************************************************************
4342 * macdrv_wglDescribePixelFormat
4343 */
4344 static int WINAPI macdrv_wglDescribePixelFormat(HDC hdc, int fmt, UINT size, PIXELFORMATDESCRIPTOR *descr)
4345 {
4346 const pixel_format *pf;
4347 const struct color_mode *mode;
4348
4349 TRACE("hdc %p fmt %d size %u descr %p\n", hdc, fmt, size, descr);
4350
4351 if (!descr) return nb_displayable_formats;
4352 if (size < sizeof(*descr)) return 0;
4353
4354 if (!(pf = get_pixel_format(fmt, FALSE)))
4355 return 0;
4356
4357 memset(descr, 0, sizeof(*descr));
4358 descr->nSize = sizeof(*descr);
4359 descr->nVersion = 1;
4360
4361 descr->dwFlags = PFD_SUPPORT_OPENGL;
4362 if (pf->window) descr->dwFlags |= PFD_DRAW_TO_WINDOW;
4363 if (!pf->accelerated) descr->dwFlags |= PFD_GENERIC_FORMAT;
4364 if (pf->double_buffer) descr->dwFlags |= PFD_DOUBLEBUFFER;
4365 if (pf->stereo) descr->dwFlags |= PFD_STEREO;
4366 if (pf->backing_store) descr->dwFlags |= PFD_SWAP_COPY;
4367
4368 descr->iPixelType = PFD_TYPE_RGBA;
4369
4370 mode = &color_modes[pf->color_mode];
4371 /* If the mode doesn't have alpha, return bits per pixel instead of color bits.
4372 On Windows, color bits sometimes exceeds r+g+b (e.g. it's 32 for an
4373 R8G8B8A0 pixel format). If an app depends on that and expects that
4374 cColorBits >= 32 for such a pixel format, we need to accommodate that. */
4375 if (mode->alpha_bits)
4376 descr->cColorBits = mode->color_bits;
4377 else
4378 descr->cColorBits = mode->bits_per_pixel;
4379 descr->cRedBits = mode->red_bits;
4380 descr->cRedShift = mode->red_shift;
4381 descr->cGreenBits = mode->green_bits;
4382 descr->cGreenShift = mode->green_shift;
4383 descr->cBlueBits = mode->blue_bits;
4384 descr->cBlueShift = mode->blue_shift;
4385 descr->cAlphaBits = mode->alpha_bits;
4386 descr->cAlphaShift = mode->alpha_shift;
4387
4388 if (pf->accum_mode)
4389 {
4390 mode = &color_modes[pf->accum_mode - 1];
4391 descr->cAccumBits = mode->color_bits;
4392 descr->cAccumRedBits = mode->red_bits;
4393 descr->cAccumGreenBits = mode->green_bits;
4394 descr->cAccumBlueBits = mode->blue_bits;
4395 descr->cAccumAlphaBits = mode->alpha_bits;
4396 }
4397
4398 descr->cDepthBits = pf->depth_bits;
4399 descr->cStencilBits = pf->stencil_bits;
4400 descr->cAuxBuffers = pf->aux_buffers;
4401 descr->iLayerType = PFD_MAIN_PLANE;
4402
4403 TRACE("%s\n", debugstr_pf(pf));
4404 return nb_displayable_formats;
4405 }
4406
4407 /***********************************************************************
4408 * macdrv_wglCopyContext
4409 */
4410 static BOOL WINAPI macdrv_wglCopyContext(struct wgl_context *src, struct wgl_context *dst, UINT mask)
4411 {
4412 CGLError err;
4413
4414 TRACE("src %p dst %p mask %x\n", src, dst, mask);
4415
4416 err = CGLCopyContext(src->cglcontext, dst->cglcontext, mask);
4417 if (err != kCGLNoError)
4418 WARN("CGLCopyContext() failed with err %d %s\n", err, CGLErrorString(err));
4419 return (err == kCGLNoError);
4420 }
4421
4422 /***********************************************************************
4423 * macdrv_wglCreateContext
4424 */
4425 static struct wgl_context * WINAPI macdrv_wglCreateContext(HDC hdc)
4426 {
4427 struct wgl_context *context;
4428
4429 TRACE("hdc %p\n", hdc);
4430
4431 context = macdrv_wglCreateContextAttribsARB(hdc, NULL, NULL);
4432
4433 return context;
4434 }
4435
4436 /***********************************************************************
4437 * macdrv_wglDeleteContext
4438 */
4439 static BOOL WINAPI macdrv_wglDeleteContext(struct wgl_context *context)
4440 {
4441 TRACE("deleting context %p/%p/%p\n", context, context->context, context->cglcontext);
4442
4443 EnterCriticalSection(&context_section);
4444 list_remove(&context->entry);
4445 LeaveCriticalSection(&context_section);
4446
4447 macdrv_dispose_opengl_context(context->context);
4448 return HeapFree(GetProcessHeap(), 0, context);
4449 }
4450
4451 /***********************************************************************
4452 * macdrv_wglGetPixelFormat
4453 */
4454 static int WINAPI macdrv_wglGetPixelFormat(HDC hdc)
4455 {
4456 int format;
4457
4458 format = get_dc_pixel_format(hdc);
4459
4460 if (!is_valid_pixel_format(format)) /* not set yet */
4461 format = 0;
4462 else if (!is_displayable_pixel_format(format))
4463 {
4464 /* Non-displayable formats can't be used with traditional WGL calls.
4465 * As has been verified on Windows GetPixelFormat doesn't fail but returns pixel format 1. */
4466 format = 1;
4467 }
4468
4469 TRACE(" hdc %p -> %d\n", hdc, format);
4470 return format;
4471 }
4472
4473 /***********************************************************************
4474 * macdrv_wglGetProcAddress
4475 */
4476 static PROC WINAPI macdrv_wglGetProcAddress(const char *proc)
4477 {
4478 void *ret;
4479
4480 if (!strncmp(proc, "wgl", 3)) return NULL;
4481 ret = dlsym(opengl_handle, proc);
4482 if (ret)
4483 {
4484 if (TRACE_ON(wgl))
4485 {
4486 Dl_info info;
4487 if (dladdr(ret, &info))
4488 TRACE("%s -> %s from %s\n", proc, info.dli_sname, info.dli_fname);
4489 else
4490 TRACE("%s -> %p (no library info)\n", proc, ret);
4491 }
4492 }
4493 else
4494 WARN("failed to find proc %s\n", debugstr_a(proc));
4495 return ret;
4496 }
4497
4498 /***********************************************************************
4499 * macdrv_wglMakeCurrent
4500 */
4501 static BOOL WINAPI macdrv_wglMakeCurrent(HDC hdc, struct wgl_context *context)
4502 {
4503 TRACE("hdc %p context %p/%p/%p\n", hdc, context, (context ? context->context : NULL),
4504 (context ? context->cglcontext : NULL));
4505
4506 return macdrv_wglMakeContextCurrentARB(hdc, hdc, context);
4507 }
4508
4509 /**********************************************************************
4510 * macdrv_wglSetPixelFormat
4511 */
4512 static BOOL WINAPI macdrv_wglSetPixelFormat(HDC hdc, int fmt, const PIXELFORMATDESCRIPTOR *descr)
4513 {
4514 return set_pixel_format(hdc, fmt, FALSE);
4515 }
4516
4517 /***********************************************************************
4518 * macdrv_wglShareLists
4519 */
4520 static BOOL WINAPI macdrv_wglShareLists(struct wgl_context *org, struct wgl_context *dest)
4521 {
4522 macdrv_opengl_context saved_context;
4523 CGLContextObj saved_cglcontext;
4524
4525 TRACE("org %p dest %p\n", org, dest);
4526
4527 /* Sharing of display lists works differently in Mac OpenGL and WGL. In Mac OpenGL it is done
4528 * at context creation time but in case of WGL it is done using wglShareLists.
4529 *
4530 * The approach is to create a Mac OpenGL context in wglCreateContext / wglCreateContextAttribsARB
4531 * and when a program requests sharing we recreate the destination context if it hasn't been made
4532 * current or when it hasn't shared display lists before.
4533 */
4534
4535 if (dest->has_been_current)
4536 {
4537 WARN("could not share display lists, the destination context has been current already\n");
4538 return FALSE;
4539 }
4540 else if (dest->sharing)
4541 {
4542 WARN("could not share display lists because dest has already shared lists before\n");
4543 return FALSE;
4544 }
4545
4546 /* Re-create the Mac context and share display lists */
4547 saved_context = dest->context;
4548 saved_cglcontext = dest->cglcontext;
4549 dest->context = NULL;
4550 dest->cglcontext = NULL;
4551 if (!create_context(dest, org->cglcontext, dest->major))
4552 {
4553 dest->context = saved_context;
4554 dest->cglcontext = saved_cglcontext;
4555 return FALSE;
4556 }
4557
4558 /* Implicitly disposes of saved_cglcontext. */
4559 macdrv_dispose_opengl_context(saved_context);
4560
4561 TRACE("re-created OpenGL context %p/%p/%p sharing lists with context %p/%p/%p\n",
4562 dest, dest->context, dest->cglcontext, org, org->context, org->cglcontext);
4563
4564 org->sharing = TRUE;
4565 dest->sharing = TRUE;
4566
4567 return TRUE;
4568 }
4569
4570 /**********************************************************************
4571 * macdrv_wglSwapBuffers
4572 */
4573 static BOOL WINAPI macdrv_wglSwapBuffers(HDC hdc)
4574 {
4575 struct wgl_context *context = NtCurrentTeb()->glContext;
4576 BOOL match = FALSE;
4577 HWND hwnd;
4578
4579 TRACE("hdc %p context %p/%p/%p\n", hdc, context, (context ? context->context : NULL),
4580 (context ? context->cglcontext : NULL));
4581
4582 if (context)
4583 {
4584 sync_swap_interval(context);
4585 sync_context(context);
4586 }
4587
4588 if ((hwnd = WindowFromDC(hdc)))
4589 {
4590 struct macdrv_win_data *data;
4591
4592 if (!(data = get_win_data(hwnd)))
4593 {
4594 SetLastError(ERROR_INVALID_HANDLE);
4595 return FALSE;
4596 }
4597
4598 if (context && context->draw_view == data->client_cocoa_view)
4599 match = TRUE;
4600
4601 release_win_data(data);
4602 }
4603 else
4604 {
4605 struct wgl_pbuffer *pbuffer;
4606
4607 EnterCriticalSection(&dc_pbuffers_section);
4608 pbuffer = (struct wgl_pbuffer*)CFDictionaryGetValue(dc_pbuffers, hdc);
4609 LeaveCriticalSection(&dc_pbuffers_section);
4610
4611 if (!pbuffer)
4612 {
4613 SetLastError(ERROR_INVALID_HANDLE);
4614 return FALSE;
4615 }
4616
4617 if (context && context->draw_pbuffer == pbuffer)
4618 match = TRUE;
4619 }
4620
4621 if (match)
4622 macdrv_flush_opengl_context(context->context);
4623 else
4624 {
4625 FIXME("current context %p doesn't match hdc %p; can't swap\n", context, hdc);
4626
4627 /* If there is a current context, then wglSwapBuffers should do an implicit
4628 glFlush(). That would be taken care of by macdrv_flush_opengl_context()
4629 in the other branch, but we have to do it explicitly here. */
4630 if (context)
4631 pglFlush();
4632 }
4633
4634 return TRUE;
4635 }
4636
4637 static struct opengl_funcs opengl_funcs =
4638 {
4639 {
4640 macdrv_wglCopyContext, /* p_wglCopyContext */
4641 macdrv_wglCreateContext, /* p_wglCreateContext */
4642 macdrv_wglDeleteContext, /* p_wglDeleteContext */
4643 macdrv_wglDescribePixelFormat, /* p_wglDescribePixelFormat */
4644 macdrv_wglGetPixelFormat, /* p_wglGetPixelFormat */
4645 macdrv_wglGetProcAddress, /* p_wglGetProcAddress */
4646 macdrv_wglMakeCurrent, /* p_wglMakeCurrent */
4647 macdrv_wglSetPixelFormat, /* p_wglSetPixelFormat */
4648 macdrv_wglShareLists, /* p_wglShareLists */
4649 macdrv_wglSwapBuffers, /* p_wglSwapBuffers */
4650 }
4651 };
4652
4653 /**********************************************************************
4654 * macdrv_wine_get_wgl_driver
4655 */
4656 struct opengl_funcs * CDECL macdrv_wine_get_wgl_driver(PHYSDEV dev, UINT version)
4657 {
4658 static INIT_ONCE opengl_init = INIT_ONCE_STATIC_INIT;
4659
4660 if (version != WINE_WGL_DRIVER_VERSION)
4661 {
4662 ERR("version mismatch, opengl32 wants %u but macdrv has %u\n", version, WINE_WGL_DRIVER_VERSION);
4663 return NULL;
4664 }
4665
4666 if (!InitOnceExecuteOnce(&opengl_init, init_opengl, NULL, NULL)) return (void *)-1;
4667
4668 return &opengl_funcs;
4669 }
Windows API implementation