?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmscript: Merge the IClassFactory implementations.
[wine/testsucceed.git] / dlls / wined3d / context.c
blobfbfb84372139bc3b73a5f24881a78a11620cca66
1 /*
2 * Context and render target management in wined3d
3 *
4 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
5 * Copyright 2009-2011 Henri Verbeet for CodeWeavers
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 <stdio.h>
24 #ifdef HAVE_FLOAT_H
25 # include <float.h>
26 #endif
27 #include "wined3d_private.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
30
31 static DWORD wined3d_context_tls_idx;
32
33 /* FBO helper functions */
34
35 /* GL locking is done by the caller */
36 void context_bind_fbo(struct wined3d_context *context, GLenum target, GLuint *fbo)
37 {
38 const struct wined3d_gl_info *gl_info = context->gl_info;
39 GLuint f;
40
41 if (!fbo)
42 {
43 f = 0;
44 }
45 else
46 {
47 if (!*fbo)
48 {
49 gl_info->fbo_ops.glGenFramebuffers(1, fbo);
50 checkGLcall("glGenFramebuffers()");
51 TRACE("Created FBO %u.\n", *fbo);
52 }
53 f = *fbo;
54 }
55
56 switch (target)
57 {
58 case GL_READ_FRAMEBUFFER:
59 if (context->fbo_read_binding == f) return;
60 context->fbo_read_binding = f;
61 break;
62
63 case GL_DRAW_FRAMEBUFFER:
64 if (context->fbo_draw_binding == f) return;
65 context->fbo_draw_binding = f;
66 break;
67
68 case GL_FRAMEBUFFER:
69 if (context->fbo_read_binding == f
70 && context->fbo_draw_binding == f) return;
71 context->fbo_read_binding = f;
72 context->fbo_draw_binding = f;
73 break;
74
75 default:
76 FIXME("Unhandled target %#x.\n", target);
77 break;
78 }
79
80 gl_info->fbo_ops.glBindFramebuffer(target, f);
81 checkGLcall("glBindFramebuffer()");
82 }
83
84 /* GL locking is done by the caller */
85 static void context_clean_fbo_attachments(const struct wined3d_gl_info *gl_info, GLenum target)
86 {
87 unsigned int i;
88
89 for (i = 0; i < gl_info->limits.buffers; ++i)
90 {
91 gl_info->fbo_ops.glFramebufferTexture2D(target, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, 0, 0);
92 checkGLcall("glFramebufferTexture2D()");
93 }
94 gl_info->fbo_ops.glFramebufferTexture2D(target, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
95 checkGLcall("glFramebufferTexture2D()");
96
97 gl_info->fbo_ops.glFramebufferTexture2D(target, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
98 checkGLcall("glFramebufferTexture2D()");
99 }
100
101 /* GL locking is done by the caller */
102 static void context_destroy_fbo(struct wined3d_context *context, GLuint *fbo)
103 {
104 const struct wined3d_gl_info *gl_info = context->gl_info;
105
106 context_bind_fbo(context, GL_FRAMEBUFFER, fbo);
107 context_clean_fbo_attachments(gl_info, GL_FRAMEBUFFER);
108 context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
109
110 gl_info->fbo_ops.glDeleteFramebuffers(1, fbo);
111 checkGLcall("glDeleteFramebuffers()");
112 }
113
114 /* GL locking is done by the caller */
115 void context_attach_depth_stencil_fbo(const struct wined3d_context *context,
116 GLenum fbo_target, struct wined3d_surface *depth_stencil, BOOL use_render_buffer)
117 {
118 const struct wined3d_gl_info *gl_info = context->gl_info;
119
120 TRACE("Attach depth stencil %p\n", depth_stencil);
121
122 if (depth_stencil)
123 {
124 DWORD format_flags = depth_stencil->resource.format->flags;
125
126 if (use_render_buffer && depth_stencil->current_renderbuffer)
127 {
128 if (format_flags & WINED3DFMT_FLAG_DEPTH)
129 {
130 gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_DEPTH_ATTACHMENT,
131 GL_RENDERBUFFER, depth_stencil->current_renderbuffer->id);
132 checkGLcall("glFramebufferRenderbuffer()");
133 }
134
135 if (format_flags & WINED3DFMT_FLAG_STENCIL)
136 {
137 gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_STENCIL_ATTACHMENT,
138 GL_RENDERBUFFER, depth_stencil->current_renderbuffer->id);
139 checkGLcall("glFramebufferRenderbuffer()");
140 }
141 }
142 else
143 {
144 surface_prepare_texture(depth_stencil, gl_info, FALSE);
145
146 if (format_flags & WINED3DFMT_FLAG_DEPTH)
147 {
148 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_DEPTH_ATTACHMENT,
149 depth_stencil->texture_target, depth_stencil->texture_name,
150 depth_stencil->texture_level);
151 checkGLcall("glFramebufferTexture2D()");
152 }
153
154 if (format_flags & WINED3DFMT_FLAG_STENCIL)
155 {
156 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_STENCIL_ATTACHMENT,
157 depth_stencil->texture_target, depth_stencil->texture_name,
158 depth_stencil->texture_level);
159 checkGLcall("glFramebufferTexture2D()");
160 }
161 }
162
163 if (!(format_flags & WINED3DFMT_FLAG_DEPTH))
164 {
165 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
166 checkGLcall("glFramebufferTexture2D()");
167 }
168
169 if (!(format_flags & WINED3DFMT_FLAG_STENCIL))
170 {
171 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
172 checkGLcall("glFramebufferTexture2D()");
173 }
174 }
175 else
176 {
177 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
178 checkGLcall("glFramebufferTexture2D()");
179
180 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
181 checkGLcall("glFramebufferTexture2D()");
182 }
183 }
184
185 /* GL locking is done by the caller */
186 static void context_attach_surface_fbo(const struct wined3d_context *context,
187 GLenum fbo_target, DWORD idx, struct wined3d_surface *surface, DWORD location)
188 {
189 const struct wined3d_gl_info *gl_info = context->gl_info;
190
191 TRACE("Attach surface %p to %u\n", surface, idx);
192
193 if (surface && surface->resource.format->id != WINED3DFMT_NULL)
194 {
195 BOOL srgb;
196
197 switch (location)
198 {
199 case SFLAG_INTEXTURE:
200 case SFLAG_INSRGBTEX:
201 srgb = location == SFLAG_INSRGBTEX;
202 surface_prepare_texture(surface, gl_info, srgb);
203 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_COLOR_ATTACHMENT0 + idx,
204 surface->texture_target, surface_get_texture_name(surface, gl_info, srgb),
205 surface->texture_level);
206 break;
207
208 default:
209 ERR("Unsupported location %s (%#x).\n", debug_surflocation(location), location);
210 break;
211 }
212 checkGLcall("glFramebufferTexture2D()");
213 }
214 else
215 {
216 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_COLOR_ATTACHMENT0 + idx, GL_TEXTURE_2D, 0, 0);
217 checkGLcall("glFramebufferTexture2D()");
218 }
219 }
220
221 /* GL locking is done by the caller */
222 void context_check_fbo_status(const struct wined3d_context *context, GLenum target)
223 {
224 const struct wined3d_gl_info *gl_info = context->gl_info;
225 GLenum status;
226
227 if (!FIXME_ON(d3d)) return;
228
229 status = gl_info->fbo_ops.glCheckFramebufferStatus(target);
230 if (status == GL_FRAMEBUFFER_COMPLETE)
231 {
232 TRACE("FBO complete\n");
233 }
234 else
235 {
236 const struct wined3d_surface *attachment;
237 unsigned int i;
238
239 FIXME("FBO status %s (%#x)\n", debug_fbostatus(status), status);
240
241 if (!context->current_fbo)
242 {
243 ERR("FBO 0 is incomplete, driver bug?\n");
244 return;
245 }
246
247 FIXME("\tLocation %s (%#x).\n", debug_surflocation(context->current_fbo->location),
248 context->current_fbo->location);
249
250 /* Dump the FBO attachments */
251 for (i = 0; i < gl_info->limits.buffers; ++i)
252 {
253 attachment = context->current_fbo->render_targets[i];
254 if (attachment)
255 {
256 FIXME("\tColor attachment %d: (%p) %s %ux%u\n",
257 i, attachment, debug_d3dformat(attachment->resource.format->id),
258 attachment->pow2Width, attachment->pow2Height);
259 }
260 }
261 attachment = context->current_fbo->depth_stencil;
262 if (attachment)
263 {
264 FIXME("\tDepth attachment: (%p) %s %ux%u\n",
265 attachment, debug_d3dformat(attachment->resource.format->id),
266 attachment->pow2Width, attachment->pow2Height);
267 }
268 }
269 }
270
271 static struct fbo_entry *context_create_fbo_entry(const struct wined3d_context *context,
272 struct wined3d_surface **render_targets, struct wined3d_surface *depth_stencil, DWORD location)
273 {
274 const struct wined3d_gl_info *gl_info = context->gl_info;
275 struct fbo_entry *entry;
276
277 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
278 entry->render_targets = HeapAlloc(GetProcessHeap(), 0, gl_info->limits.buffers * sizeof(*entry->render_targets));
279 memcpy(entry->render_targets, render_targets, gl_info->limits.buffers * sizeof(*entry->render_targets));
280 entry->depth_stencil = depth_stencil;
281 entry->location = location;
282 entry->attached = FALSE;
283 entry->id = 0;
284
285 return entry;
286 }
287
288 /* GL locking is done by the caller */
289 static void context_reuse_fbo_entry(struct wined3d_context *context, GLenum target,
290 struct wined3d_surface **render_targets, struct wined3d_surface *depth_stencil,
291 DWORD location, struct fbo_entry *entry)
292 {
293 const struct wined3d_gl_info *gl_info = context->gl_info;
294
295 context_bind_fbo(context, target, &entry->id);
296 context_clean_fbo_attachments(gl_info, target);
297
298 memcpy(entry->render_targets, render_targets, gl_info->limits.buffers * sizeof(*entry->render_targets));
299 entry->depth_stencil = depth_stencil;
300 entry->location = location;
301 entry->attached = FALSE;
302 }
303
304 /* GL locking is done by the caller */
305 static void context_destroy_fbo_entry(struct wined3d_context *context, struct fbo_entry *entry)
306 {
307 if (entry->id)
308 {
309 TRACE("Destroy FBO %d\n", entry->id);
310 context_destroy_fbo(context, &entry->id);
311 }
312 --context->fbo_entry_count;
313 list_remove(&entry->entry);
314 HeapFree(GetProcessHeap(), 0, entry->render_targets);
315 HeapFree(GetProcessHeap(), 0, entry);
316 }
317
318
319 /* GL locking is done by the caller */
320 static struct fbo_entry *context_find_fbo_entry(struct wined3d_context *context, GLenum target,
321 struct wined3d_surface **render_targets, struct wined3d_surface *depth_stencil, DWORD location)
322 {
323 const struct wined3d_gl_info *gl_info = context->gl_info;
324 struct fbo_entry *entry;
325
326 if (depth_stencil && render_targets && render_targets[0])
327 {
328 if (depth_stencil->resource.width < render_targets[0]->resource.width ||
329 depth_stencil->resource.height < render_targets[0]->resource.height)
330 {
331 WARN("Depth stencil is smaller than the primary color buffer, disabling\n");
332 depth_stencil = NULL;
333 }
334 }
335
336 LIST_FOR_EACH_ENTRY(entry, &context->fbo_list, struct fbo_entry, entry)
337 {
338 if (!memcmp(entry->render_targets,
339 render_targets, gl_info->limits.buffers * sizeof(*entry->render_targets))
340 && entry->depth_stencil == depth_stencil && entry->location == location)
341 {
342 list_remove(&entry->entry);
343 list_add_head(&context->fbo_list, &entry->entry);
344 return entry;
345 }
346 }
347
348 if (context->fbo_entry_count < WINED3D_MAX_FBO_ENTRIES)
349 {
350 entry = context_create_fbo_entry(context, render_targets, depth_stencil, location);
351 list_add_head(&context->fbo_list, &entry->entry);
352 ++context->fbo_entry_count;
353 }
354 else
355 {
356 entry = LIST_ENTRY(list_tail(&context->fbo_list), struct fbo_entry, entry);
357 context_reuse_fbo_entry(context, target, render_targets, depth_stencil, location, entry);
358 list_remove(&entry->entry);
359 list_add_head(&context->fbo_list, &entry->entry);
360 }
361
362 return entry;
363 }
364
365 /* GL locking is done by the caller */
366 static void context_apply_fbo_entry(struct wined3d_context *context, GLenum target, struct fbo_entry *entry)
367 {
368 const struct wined3d_gl_info *gl_info = context->gl_info;
369 unsigned int i;
370
371 context_bind_fbo(context, target, &entry->id);
372
373 if (entry->attached) return;
374
375 /* Apply render targets */
376 for (i = 0; i < gl_info->limits.buffers; ++i)
377 {
378 context_attach_surface_fbo(context, target, i, entry->render_targets[i], entry->location);
379 }
380
381 /* Apply depth targets */
382 if (entry->depth_stencil)
383 surface_set_compatible_renderbuffer(entry->depth_stencil, entry->render_targets[0]);
384 context_attach_depth_stencil_fbo(context, target, entry->depth_stencil, TRUE);
385
386 entry->attached = TRUE;
387 }
388
389 /* GL locking is done by the caller */
390 static void context_apply_fbo_state(struct wined3d_context *context, GLenum target,
391 struct wined3d_surface **render_targets, struct wined3d_surface *depth_stencil, DWORD location)
392 {
393 struct fbo_entry *entry, *entry2;
394
395 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_destroy_list, struct fbo_entry, entry)
396 {
397 context_destroy_fbo_entry(context, entry);
398 }
399
400 if (context->rebind_fbo)
401 {
402 context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
403 context->rebind_fbo = FALSE;
404 }
405
406 if (render_targets)
407 {
408 context->current_fbo = context_find_fbo_entry(context, target, render_targets, depth_stencil, location);
409 context_apply_fbo_entry(context, target, context->current_fbo);
410 }
411 else
412 {
413 context->current_fbo = NULL;
414 context_bind_fbo(context, target, NULL);
415 }
416 }
417
418 /* GL locking is done by the caller */
419 void context_apply_fbo_state_blit(struct wined3d_context *context, GLenum target,
420 struct wined3d_surface *render_target, struct wined3d_surface *depth_stencil, DWORD location)
421 {
422 if (location != SFLAG_INDRAWABLE || surface_is_offscreen(render_target))
423 {
424 UINT clear_size = (context->gl_info->limits.buffers - 1) * sizeof(*context->blit_targets);
425 context->blit_targets[0] = render_target;
426 if (clear_size) memset(&context->blit_targets[1], 0, clear_size);
427 context_apply_fbo_state(context, target, context->blit_targets, depth_stencil, location);
428 }
429 else
430 {
431 context_apply_fbo_state(context, target, NULL, NULL, location);
432 }
433 }
434
435 /* Context activation is done by the caller. */
436 void context_alloc_occlusion_query(struct wined3d_context *context, struct wined3d_occlusion_query *query)
437 {
438 const struct wined3d_gl_info *gl_info = context->gl_info;
439
440 if (context->free_occlusion_query_count)
441 {
442 query->id = context->free_occlusion_queries[--context->free_occlusion_query_count];
443 }
444 else
445 {
446 if (gl_info->supported[ARB_OCCLUSION_QUERY])
447 {
448 ENTER_GL();
449 GL_EXTCALL(glGenQueriesARB(1, &query->id));
450 checkGLcall("glGenQueriesARB");
451 LEAVE_GL();
452
453 TRACE("Allocated occlusion query %u in context %p.\n", query->id, context);
454 }
455 else
456 {
457 WARN("Occlusion queries not supported, not allocating query id.\n");
458 query->id = 0;
459 }
460 }
461
462 query->context = context;
463 list_add_head(&context->occlusion_queries, &query->entry);
464 }
465
466 void context_free_occlusion_query(struct wined3d_occlusion_query *query)
467 {
468 struct wined3d_context *context = query->context;
469
470 list_remove(&query->entry);
471 query->context = NULL;
472
473 if (context->free_occlusion_query_count >= context->free_occlusion_query_size - 1)
474 {
475 UINT new_size = context->free_occlusion_query_size << 1;
476 GLuint *new_data = HeapReAlloc(GetProcessHeap(), 0, context->free_occlusion_queries,
477 new_size * sizeof(*context->free_occlusion_queries));
478
479 if (!new_data)
480 {
481 ERR("Failed to grow free list, leaking query %u in context %p.\n", query->id, context);
482 return;
483 }
484
485 context->free_occlusion_query_size = new_size;
486 context->free_occlusion_queries = new_data;
487 }
488
489 context->free_occlusion_queries[context->free_occlusion_query_count++] = query->id;
490 }
491
492 /* Context activation is done by the caller. */
493 void context_alloc_event_query(struct wined3d_context *context, struct wined3d_event_query *query)
494 {
495 const struct wined3d_gl_info *gl_info = context->gl_info;
496
497 if (context->free_event_query_count)
498 {
499 query->object = context->free_event_queries[--context->free_event_query_count];
500 }
501 else
502 {
503 if (gl_info->supported[ARB_SYNC])
504 {
505 /* Using ARB_sync, not much to do here. */
506 query->object.sync = NULL;
507 TRACE("Allocated event query %p in context %p.\n", query->object.sync, context);
508 }
509 else if (gl_info->supported[APPLE_FENCE])
510 {
511 ENTER_GL();
512 GL_EXTCALL(glGenFencesAPPLE(1, &query->object.id));
513 checkGLcall("glGenFencesAPPLE");
514 LEAVE_GL();
515
516 TRACE("Allocated event query %u in context %p.\n", query->object.id, context);
517 }
518 else if(gl_info->supported[NV_FENCE])
519 {
520 ENTER_GL();
521 GL_EXTCALL(glGenFencesNV(1, &query->object.id));
522 checkGLcall("glGenFencesNV");
523 LEAVE_GL();
524
525 TRACE("Allocated event query %u in context %p.\n", query->object.id, context);
526 }
527 else
528 {
529 WARN("Event queries not supported, not allocating query id.\n");
530 query->object.id = 0;
531 }
532 }
533
534 query->context = context;
535 list_add_head(&context->event_queries, &query->entry);
536 }
537
538 void context_free_event_query(struct wined3d_event_query *query)
539 {
540 struct wined3d_context *context = query->context;
541
542 list_remove(&query->entry);
543 query->context = NULL;
544
545 if (context->free_event_query_count >= context->free_event_query_size - 1)
546 {
547 UINT new_size = context->free_event_query_size << 1;
548 union wined3d_gl_query_object *new_data = HeapReAlloc(GetProcessHeap(), 0, context->free_event_queries,
549 new_size * sizeof(*context->free_event_queries));
550
551 if (!new_data)
552 {
553 ERR("Failed to grow free list, leaking query %u in context %p.\n", query->object.id, context);
554 return;
555 }
556
557 context->free_event_query_size = new_size;
558 context->free_event_queries = new_data;
559 }
560
561 context->free_event_queries[context->free_event_query_count++] = query->object;
562 }
563
564 typedef void (context_fbo_entry_func_t)(struct wined3d_context *context, struct fbo_entry *entry);
565
566 static void context_enum_surface_fbo_entries(const struct wined3d_device *device,
567 const struct wined3d_surface *surface, context_fbo_entry_func_t *callback)
568 {
569 UINT i;
570
571 for (i = 0; i < device->context_count; ++i)
572 {
573 struct wined3d_context *context = device->contexts[i];
574 const struct wined3d_gl_info *gl_info = context->gl_info;
575 struct fbo_entry *entry, *entry2;
576
577 if (context->current_rt == surface) context->current_rt = NULL;
578
579 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_list, struct fbo_entry, entry)
580 {
581 UINT j;
582
583 if (entry->depth_stencil == surface)
584 {
585 callback(context, entry);
586 continue;
587 }
588
589 for (j = 0; j < gl_info->limits.buffers; ++j)
590 {
591 if (entry->render_targets[j] == surface)
592 {
593 callback(context, entry);
594 break;
595 }
596 }
597 }
598 }
599 }
600
601 static void context_queue_fbo_entry_destruction(struct wined3d_context *context, struct fbo_entry *entry)
602 {
603 list_remove(&entry->entry);
604 list_add_head(&context->fbo_destroy_list, &entry->entry);
605 }
606
607 void context_resource_released(const struct wined3d_device *device,
608 struct wined3d_resource *resource, WINED3DRESOURCETYPE type)
609 {
610 if (!device->d3d_initialized) return;
611
612 switch (type)
613 {
614 case WINED3DRTYPE_SURFACE:
615 context_enum_surface_fbo_entries(device, surface_from_resource(resource),
616 context_queue_fbo_entry_destruction);
617 break;
618
619 default:
620 break;
621 }
622 }
623
624 static void context_detach_fbo_entry(struct wined3d_context *context, struct fbo_entry *entry)
625 {
626 entry->attached = FALSE;
627 }
628
629 void context_resource_unloaded(const struct wined3d_device *device,
630 struct wined3d_resource *resource, WINED3DRESOURCETYPE type)
631 {
632 switch (type)
633 {
634 case WINED3DRTYPE_SURFACE:
635 context_enum_surface_fbo_entries(device, surface_from_resource(resource),
636 context_detach_fbo_entry);
637 break;
638
639 default:
640 break;
641 }
642 }
643
644 void context_surface_update(struct wined3d_context *context, const struct wined3d_surface *surface)
645 {
646 const struct wined3d_gl_info *gl_info = context->gl_info;
647 struct fbo_entry *entry = context->current_fbo;
648 unsigned int i;
649
650 if (!entry || context->rebind_fbo) return;
651
652 for (i = 0; i < gl_info->limits.buffers; ++i)
653 {
654 if (surface == entry->render_targets[i])
655 {
656 TRACE("Updated surface %p is bound as color attachment %u to the current FBO.\n", surface, i);
657 context->rebind_fbo = TRUE;
658 return;
659 }
660 }
661
662 if (surface == entry->depth_stencil)
663 {
664 TRACE("Updated surface %p is bound as depth attachment to the current FBO.\n", surface);
665 context->rebind_fbo = TRUE;
666 }
667 }
668
669 static BOOL context_set_pixel_format(const struct wined3d_gl_info *gl_info, HDC dc, int format)
670 {
671 int current = GetPixelFormat(dc);
672
673 if (current == format) return TRUE;
674
675 if (!current)
676 {
677 if (!SetPixelFormat(dc, format, NULL))
678 {
679 ERR("Failed to set pixel format %d on device context %p, last error %#x.\n",
680 format, dc, GetLastError());
681 return FALSE;
682 }
683 return TRUE;
684 }
685
686 /* By default WGL doesn't allow pixel format adjustments but we need it
687 * here. For this reason there's a Wine specific wglSetPixelFormat()
688 * which allows us to set the pixel format multiple times. Only use it
689 * when really needed. */
690 if (gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH])
691 {
692 if (!GL_EXTCALL(wglSetPixelFormatWINE(dc, format, NULL)))
693 {
694 ERR("wglSetPixelFormatWINE failed to set pixel format %d on device context %p.\n",
695 format, dc);
696 return FALSE;
697 }
698 return TRUE;
699 }
700
701 /* OpenGL doesn't allow pixel format adjustments. Print an error and
702 * continue using the old format. There's a big chance that the old
703 * format works although with a performance hit and perhaps rendering
704 * errors. */
705 ERR("Unable to set pixel format %d on device context %p. Already using format %d.\n",
706 format, dc, current);
707 return TRUE;
708 }
709
710 static BOOL context_set_gl_context(struct wined3d_context *ctx)
711 {
712 struct wined3d_swapchain *swapchain = ctx->swapchain;
713
714 if (!pwglMakeCurrent(ctx->hdc, ctx->glCtx))
715 {
716 HDC dc;
717
718 WARN("Failed to make GL context %p current on device context %p, last error %#x.\n",
719 ctx->glCtx, ctx->hdc, GetLastError());
720 ctx->valid = 0;
721 WARN("Trying fallback to the backup window.\n");
722
723 if (!(dc = swapchain_get_backup_dc(swapchain)))
724 {
725 context_set_current(NULL);
726 return FALSE;
727 }
728
729 if (!context_set_pixel_format(ctx->gl_info, dc, ctx->pixel_format))
730 {
731 ERR("Failed to set pixel format %d on device context %p.\n",
732 ctx->pixel_format, dc);
733 context_set_current(NULL);
734 return FALSE;
735 }
736
737 if (!pwglMakeCurrent(dc, ctx->glCtx))
738 {
739 ERR("Fallback to backup window (dc %p) failed too, last error %#x.\n",
740 dc, GetLastError());
741 context_set_current(NULL);
742 return FALSE;
743 }
744 }
745 return TRUE;
746 }
747
748 static void context_restore_gl_context(HDC dc, HGLRC gl_ctx)
749 {
750 if (!pwglMakeCurrent(dc, gl_ctx))
751 {
752 ERR("Failed to restore GL context %p on device context %p, last error %#x.\n",
753 gl_ctx, dc, GetLastError());
754 context_set_current(NULL);
755 }
756 }
757
758 static void context_update_window(struct wined3d_context *context)
759 {
760 if (context->win_handle == context->swapchain->win_handle)
761 return;
762
763 TRACE("Updating context %p window from %p to %p.\n",
764 context, context->win_handle, context->swapchain->win_handle);
765
766 if (context->valid)
767 {
768 /* You'd figure ReleaseDC() would fail if the DC doesn't match the
769 * window. However, that's not what actually happens, and there are
770 * user32 tests that confirm ReleaseDC() with the wrong window is
771 * supposed to succeed. So explicitly check that the DC belongs to
772 * the window, since we want to avoid releasing a DC that belongs to
773 * some other window if the original window was already destroyed. */
774 if (WindowFromDC(context->hdc) != context->win_handle)
775 {
776 WARN("DC %p does not belong to window %p.\n",
777 context->hdc, context->win_handle);
778 }
779 else if (!ReleaseDC(context->win_handle, context->hdc))
780 {
781 ERR("Failed to release device context %p, last error %#x.\n",
782 context->hdc, GetLastError());
783 }
784 }
785 else context->valid = 1;
786
787 context->win_handle = context->swapchain->win_handle;
788
789 if (!(context->hdc = GetDC(context->win_handle)))
790 {
791 ERR("Failed to get a device context for window %p.\n", context->win_handle);
792 goto err;
793 }
794
795 if (!context_set_pixel_format(context->gl_info, context->hdc, context->pixel_format))
796 {
797 ERR("Failed to set pixel format %d on device context %p.\n",
798 context->pixel_format, context->hdc);
799 goto err;
800 }
801
802 context_set_gl_context(context);
803
804 return;
805
806 err:
807 context->valid = 0;
808 }
809
810 /* Do not call while under the GL lock. */
811 static void context_destroy_gl_resources(struct wined3d_context *context)
812 {
813 const struct wined3d_gl_info *gl_info = context->gl_info;
814 struct wined3d_occlusion_query *occlusion_query;
815 struct wined3d_event_query *event_query;
816 struct fbo_entry *entry, *entry2;
817 HGLRC restore_ctx;
818 HDC restore_dc;
819 unsigned int i;
820
821 restore_ctx = pwglGetCurrentContext();
822 restore_dc = pwglGetCurrentDC();
823
824 context_update_window(context);
825 if (context->valid && restore_ctx != context->glCtx)
826 context_set_gl_context(context);
827 else restore_ctx = NULL;
828
829 ENTER_GL();
830
831 LIST_FOR_EACH_ENTRY(occlusion_query, &context->occlusion_queries, struct wined3d_occlusion_query, entry)
832 {
833 if (context->valid && gl_info->supported[ARB_OCCLUSION_QUERY])
834 GL_EXTCALL(glDeleteQueriesARB(1, &occlusion_query->id));
835 occlusion_query->context = NULL;
836 }
837
838 LIST_FOR_EACH_ENTRY(event_query, &context->event_queries, struct wined3d_event_query, entry)
839 {
840 if (context->valid)
841 {
842 if (gl_info->supported[ARB_SYNC])
843 {
844 if (event_query->object.sync) GL_EXTCALL(glDeleteSync(event_query->object.sync));
845 }
846 else if (gl_info->supported[APPLE_FENCE]) GL_EXTCALL(glDeleteFencesAPPLE(1, &event_query->object.id));
847 else if (gl_info->supported[NV_FENCE]) GL_EXTCALL(glDeleteFencesNV(1, &event_query->object.id));
848 }
849 event_query->context = NULL;
850 }
851
852 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_destroy_list, struct fbo_entry, entry)
853 {
854 if (!context->valid) entry->id = 0;
855 context_destroy_fbo_entry(context, entry);
856 }
857
858 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_list, struct fbo_entry, entry)
859 {
860 if (!context->valid) entry->id = 0;
861 context_destroy_fbo_entry(context, entry);
862 }
863
864 if (context->valid)
865 {
866 if (context->dst_fbo)
867 {
868 TRACE("Destroy dst FBO %d\n", context->dst_fbo);
869 context_destroy_fbo(context, &context->dst_fbo);
870 }
871 if (context->dummy_arbfp_prog)
872 {
873 GL_EXTCALL(glDeleteProgramsARB(1, &context->dummy_arbfp_prog));
874 }
875
876 if (gl_info->supported[ARB_OCCLUSION_QUERY])
877 GL_EXTCALL(glDeleteQueriesARB(context->free_occlusion_query_count, context->free_occlusion_queries));
878
879 if (gl_info->supported[ARB_SYNC])
880 {
881 for (i = 0; i < context->free_event_query_count; ++i)
882 {
883 GL_EXTCALL(glDeleteSync(context->free_event_queries[i].sync));
884 }
885 }
886 else if (gl_info->supported[APPLE_FENCE])
887 {
888 for (i = 0; i < context->free_event_query_count; ++i)
889 {
890 GL_EXTCALL(glDeleteFencesAPPLE(1, &context->free_event_queries[i].id));
891 }
892 }
893 else if (gl_info->supported[NV_FENCE])
894 {
895 for (i = 0; i < context->free_event_query_count; ++i)
896 {
897 GL_EXTCALL(glDeleteFencesNV(1, &context->free_event_queries[i].id));
898 }
899 }
900
901 checkGLcall("context cleanup");
902 }
903
904 LEAVE_GL();
905
906 HeapFree(GetProcessHeap(), 0, context->free_occlusion_queries);
907 HeapFree(GetProcessHeap(), 0, context->free_event_queries);
908
909 if (restore_ctx)
910 {
911 context_restore_gl_context(restore_dc, restore_ctx);
912 }
913 else if (pwglGetCurrentContext() && !pwglMakeCurrent(NULL, NULL))
914 {
915 ERR("Failed to disable GL context.\n");
916 }
917
918 ReleaseDC(context->win_handle, context->hdc);
919
920 if (!pwglDeleteContext(context->glCtx))
921 {
922 DWORD err = GetLastError();
923 ERR("wglDeleteContext(%p) failed, last error %#x.\n", context->glCtx, err);
924 }
925 }
926
927 DWORD context_get_tls_idx(void)
928 {
929 return wined3d_context_tls_idx;
930 }
931
932 void context_set_tls_idx(DWORD idx)
933 {
934 wined3d_context_tls_idx = idx;
935 }
936
937 struct wined3d_context *context_get_current(void)
938 {
939 return TlsGetValue(wined3d_context_tls_idx);
940 }
941
942 /* Do not call while under the GL lock. */
943 BOOL context_set_current(struct wined3d_context *ctx)
944 {
945 struct wined3d_context *old = context_get_current();
946
947 if (old == ctx)
948 {
949 TRACE("Already using D3D context %p.\n", ctx);
950 return TRUE;
951 }
952
953 if (old)
954 {
955 if (old->destroyed)
956 {
957 TRACE("Switching away from destroyed context %p.\n", old);
958 context_destroy_gl_resources(old);
959 HeapFree(GetProcessHeap(), 0, old);
960 }
961 else
962 {
963 old->current = 0;
964 }
965 }
966
967 if (ctx)
968 {
969 if (!ctx->valid)
970 {
971 ERR("Trying to make invalid context %p current\n", ctx);
972 return FALSE;
973 }
974
975 TRACE("Switching to D3D context %p, GL context %p, device context %p.\n", ctx, ctx->glCtx, ctx->hdc);
976 if (!context_set_gl_context(ctx))
977 return FALSE;
978 ctx->current = 1;
979 }
980 else if(pwglGetCurrentContext())
981 {
982 TRACE("Clearing current D3D context.\n");
983 if (!pwglMakeCurrent(NULL, NULL))
984 {
985 DWORD err = GetLastError();
986 ERR("Failed to clear current GL context, last error %#x.\n", err);
987 TlsSetValue(wined3d_context_tls_idx, NULL);
988 return FALSE;
989 }
990 }
991
992 return TlsSetValue(wined3d_context_tls_idx, ctx);
993 }
994
995 void context_release(struct wined3d_context *context)
996 {
997 TRACE("Releasing context %p, level %u.\n", context, context->level);
998
999 if (WARN_ON(d3d))
1000 {
1001 if (!context->level)
1002 WARN("Context %p is not active.\n", context);
1003 else if (context != context_get_current())
1004 WARN("Context %p is not the current context.\n", context);
1005 }
1006
1007 if (!--context->level && context->restore_ctx)
1008 {
1009 TRACE("Restoring GL context %p on device context %p.\n", context->restore_ctx, context->restore_dc);
1010 context_restore_gl_context(context->restore_dc, context->restore_ctx);
1011 context->restore_ctx = NULL;
1012 context->restore_dc = NULL;
1013 }
1014 }
1015
1016 static void context_enter(struct wined3d_context *context)
1017 {
1018 TRACE("Entering context %p, level %u.\n", context, context->level + 1);
1019
1020 if (!context->level++)
1021 {
1022 const struct wined3d_context *current_context = context_get_current();
1023 HGLRC current_gl = pwglGetCurrentContext();
1024
1025 if (current_gl && (!current_context || current_context->glCtx != current_gl))
1026 {
1027 TRACE("Another GL context (%p on device context %p) is already current.\n",
1028 current_gl, pwglGetCurrentDC());
1029 context->restore_ctx = current_gl;
1030 context->restore_dc = pwglGetCurrentDC();
1031 }
1032 }
1033 }
1034
1035 void context_invalidate_state(struct wined3d_context *context, DWORD state)
1036 {
1037 DWORD rep = context->state_table[state].representative;
1038 DWORD idx;
1039 BYTE shift;
1040
1041 if (isStateDirty(context, rep)) return;
1042
1043 context->dirtyArray[context->numDirtyEntries++] = rep;
1044 idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
1045 shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
1046 context->isStateDirty[idx] |= (1 << shift);
1047 }
1048
1049 /* This function takes care of WineD3D pixel format selection. */
1050 static int WineD3D_ChoosePixelFormat(struct wined3d_device *device, HDC hdc,
1051 const struct wined3d_format *color_format, const struct wined3d_format *ds_format,
1052 BOOL auxBuffers, int numSamples, BOOL findCompatible)
1053 {
1054 int iPixelFormat=0;
1055 unsigned int matchtry;
1056 BYTE redBits, greenBits, blueBits, alphaBits, colorBits;
1057 BYTE depthBits=0, stencilBits=0;
1058
1059 static const struct
1060 {
1061 BOOL require_aux;
1062 BOOL exact_alpha;
1063 BOOL exact_color;
1064 }
1065 matches[] =
1066 {
1067 /* First, try without alpha match buffers. MacOS supports aux buffers only
1068 * on A8R8G8B8, and we prefer better offscreen rendering over an alpha match.
1069 * Then try without aux buffers - this is the most common cause for not
1070 * finding a pixel format. Also some drivers(the open source ones)
1071 * only offer 32 bit ARB pixel formats. First try without an exact alpha
1072 * match, then try without an exact alpha and color match.
1073 */
1074 { TRUE, TRUE, TRUE },
1075 { TRUE, FALSE, TRUE },
1076 { FALSE, TRUE, TRUE },
1077 { FALSE, FALSE, TRUE },
1078 { TRUE, FALSE, FALSE },
1079 { FALSE, FALSE, FALSE },
1080 };
1081
1082 int i = 0;
1083 int nCfgs = device->adapter->nCfgs;
1084
1085 TRACE("ColorFormat=%s, DepthStencilFormat=%s, auxBuffers=%d, numSamples=%d, findCompatible=%d\n",
1086 debug_d3dformat(color_format->id), debug_d3dformat(ds_format->id),
1087 auxBuffers, numSamples, findCompatible);
1088
1089 if (!getColorBits(color_format, &redBits, &greenBits, &blueBits, &alphaBits, &colorBits))
1090 {
1091 ERR("Unable to get color bits for format %s (%#x)!\n",
1092 debug_d3dformat(color_format->id), color_format->id);
1093 return 0;
1094 }
1095
1096 getDepthStencilBits(ds_format, &depthBits, &stencilBits);
1097
1098 for (matchtry = 0; matchtry < (sizeof(matches) / sizeof(*matches)) && !iPixelFormat; ++matchtry)
1099 {
1100 for (i = 0; i < nCfgs; ++i)
1101 {
1102 const struct wined3d_pixel_format *cfg = &device->adapter->cfgs[i];
1103 BOOL exactDepthMatch = TRUE;
1104
1105 /* For now only accept RGBA formats. Perhaps some day we will
1106 * allow floating point formats for pbuffers. */
1107 if(cfg->iPixelType != WGL_TYPE_RGBA_ARB)
1108 continue;
1109
1110 /* In window mode we need a window drawable format and double buffering. */
1111 if(!(cfg->windowDrawable && cfg->doubleBuffer))
1112 continue;
1113
1114 /* We like to have aux buffers in backbuffer mode */
1115 if(auxBuffers && !cfg->auxBuffers && matches[matchtry].require_aux)
1116 continue;
1117
1118 if(matches[matchtry].exact_color) {
1119 if(cfg->redSize != redBits)
1120 continue;
1121 if(cfg->greenSize != greenBits)
1122 continue;
1123 if(cfg->blueSize != blueBits)
1124 continue;
1125 } else {
1126 if(cfg->redSize < redBits)
1127 continue;
1128 if(cfg->greenSize < greenBits)
1129 continue;
1130 if(cfg->blueSize < blueBits)
1131 continue;
1132 }
1133 if(matches[matchtry].exact_alpha) {
1134 if(cfg->alphaSize != alphaBits)
1135 continue;
1136 } else {
1137 if(cfg->alphaSize < alphaBits)
1138 continue;
1139 }
1140
1141 /* We try to locate a format which matches our requirements exactly. In case of
1142 * depth it is no problem to emulate 16-bit using e.g. 24-bit, so accept that. */
1143 if(cfg->depthSize < depthBits)
1144 continue;
1145 else if(cfg->depthSize > depthBits)
1146 exactDepthMatch = FALSE;
1147
1148 /* In all cases make sure the number of stencil bits matches our requirements
1149 * even when we don't need stencil because it could affect performance EXCEPT
1150 * on cards which don't offer depth formats without stencil like the i915 drivers
1151 * on Linux. */
1152 if (stencilBits != cfg->stencilSize
1153 && !(device->adapter->brokenStencil && stencilBits <= cfg->stencilSize))
1154 continue;
1155
1156 /* Check multisampling support */
1157 if(cfg->numSamples != numSamples)
1158 continue;
1159
1160 /* When we have passed all the checks then we have found a format which matches our
1161 * requirements. Note that we only check for a limit number of capabilities right now,
1162 * so there can easily be a dozen of pixel formats which appear to be the 'same' but
1163 * can still differ in things like multisampling, stereo, SRGB and other flags.
1164 */
1165
1166 /* Exit the loop as we have found a format :) */
1167 if(exactDepthMatch) {
1168 iPixelFormat = cfg->iPixelFormat;
1169 break;
1170 } else if(!iPixelFormat) {
1171 /* In the end we might end up with a format which doesn't exactly match our depth
1172 * requirements. Accept the first format we found because formats with higher iPixelFormat
1173 * values tend to have more extended capabilities (e.g. multisampling) which we don't need. */
1174 iPixelFormat = cfg->iPixelFormat;
1175 }
1176 }
1177 }
1178
1179 /* When findCompatible is set and no suitable format was found, let ChoosePixelFormat choose a pixel format in order not to crash. */
1180 if(!iPixelFormat && !findCompatible) {
1181 ERR("Can't find a suitable iPixelFormat\n");
1182 return FALSE;
1183 } else if(!iPixelFormat) {
1184 PIXELFORMATDESCRIPTOR pfd;
1185
1186 TRACE("Falling back to ChoosePixelFormat as we weren't able to find an exactly matching pixel format\n");
1187 /* PixelFormat selection */
1188 ZeroMemory(&pfd, sizeof(pfd));
1189 pfd.nSize = sizeof(pfd);
1190 pfd.nVersion = 1;
1191 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW;/*PFD_GENERIC_ACCELERATED*/
1192 pfd.iPixelType = PFD_TYPE_RGBA;
1193 pfd.cAlphaBits = alphaBits;
1194 pfd.cColorBits = colorBits;
1195 pfd.cDepthBits = depthBits;
1196 pfd.cStencilBits = stencilBits;
1197 pfd.iLayerType = PFD_MAIN_PLANE;
1198
1199 iPixelFormat = ChoosePixelFormat(hdc, &pfd);
1200 if(!iPixelFormat) {
1201 /* If this happens something is very wrong as ChoosePixelFormat barely fails */
1202 ERR("Can't find a suitable iPixelFormat\n");
1203 return FALSE;
1204 }
1205 }
1206
1207 TRACE("Found iPixelFormat=%d for ColorFormat=%s, DepthStencilFormat=%s\n",
1208 iPixelFormat, debug_d3dformat(color_format->id), debug_d3dformat(ds_format->id));
1209 return iPixelFormat;
1210 }
1211
1212 static inline DWORD context_generate_rt_mask(GLenum buffer)
1213 {
1214 /* Should take care of all the GL_FRONT/GL_BACK/GL_AUXi/GL_NONE... cases */
1215 return buffer ? (1 << 31) | buffer : 0;
1216 }
1217
1218 static inline DWORD context_generate_rt_mask_from_surface(const struct wined3d_surface *target)
1219 {
1220 return (1 << 31) | surface_get_gl_buffer(target);
1221 }
1222
1223 /* Do not call while under the GL lock. */
1224 struct wined3d_context *context_create(struct wined3d_swapchain *swapchain,
1225 struct wined3d_surface *target, const struct wined3d_format *ds_format)
1226 {
1227 struct wined3d_device *device = swapchain->device;
1228 const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1229 const struct wined3d_format *color_format;
1230 struct wined3d_context *ret;
1231 PIXELFORMATDESCRIPTOR pfd;
1232 BOOL auxBuffers = FALSE;
1233 int numSamples = 0;
1234 int pixel_format;
1235 unsigned int s;
1236 int swap_interval;
1237 DWORD state;
1238 HGLRC ctx;
1239 HDC hdc;
1240
1241 TRACE("swapchain %p, target %p, window %p.\n", swapchain, target, swapchain->win_handle);
1242
1243 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
1244 if (!ret)
1245 {
1246 ERR("Failed to allocate context memory.\n");
1247 return NULL;
1248 }
1249
1250 if (!(hdc = GetDC(swapchain->win_handle)))
1251 {
1252 WARN("Failed to retireve device context, trying swapchain backup.\n");
1253
1254 if (!(hdc = swapchain_get_backup_dc(swapchain)))
1255 {
1256 ERR("Failed to retrieve a device context.\n");
1257 goto out;
1258 }
1259 }
1260
1261 color_format = target->resource.format;
1262
1263 /* In case of ORM_BACKBUFFER, make sure to request an alpha component for
1264 * X4R4G4B4/X8R8G8B8 as we might need it for the backbuffer. */
1265 if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
1266 {
1267 auxBuffers = TRUE;
1268
1269 if (color_format->id == WINED3DFMT_B4G4R4X4_UNORM)
1270 color_format = wined3d_get_format(gl_info, WINED3DFMT_B4G4R4A4_UNORM);
1271 else if (color_format->id == WINED3DFMT_B8G8R8X8_UNORM)
1272 color_format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
1273 }
1274
1275 /* DirectDraw supports 8bit paletted render targets and these are used by
1276 * old games like StarCraft and C&C. Most modern hardware doesn't support
1277 * 8bit natively so we perform some form of 8bit -> 32bit conversion. The
1278 * conversion (ab)uses the alpha component for storing the palette index.
1279 * For this reason we require a format with 8bit alpha, so request
1280 * A8R8G8B8. */
1281 if (color_format->id == WINED3DFMT_P8_UINT)
1282 color_format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
1283
1284 /* D3D only allows multisampling when SwapEffect is set to WINED3DSWAPEFFECT_DISCARD. */
1285 if (swapchain->presentParms.MultiSampleType && (swapchain->presentParms.SwapEffect == WINED3DSWAPEFFECT_DISCARD))
1286 {
1287 if (!gl_info->supported[ARB_MULTISAMPLE])
1288 WARN("The application is requesting multisampling without support.\n");
1289 else
1290 {
1291 TRACE("Requesting multisample type %#x.\n", swapchain->presentParms.MultiSampleType);
1292 numSamples = swapchain->presentParms.MultiSampleType;
1293 }
1294 }
1295
1296 /* Try to find a pixel format which matches our requirements. */
1297 pixel_format = WineD3D_ChoosePixelFormat(device, hdc, color_format, ds_format,
1298 auxBuffers, numSamples, FALSE /* findCompatible */);
1299
1300 /* Try to locate a compatible format if we weren't able to find anything. */
1301 if (!pixel_format)
1302 {
1303 TRACE("Trying to locate a compatible pixel format because an exact match failed.\n");
1304 pixel_format = WineD3D_ChoosePixelFormat(device, hdc, color_format, ds_format,
1305 auxBuffers, 0 /* numSamples */, TRUE /* findCompatible */);
1306 }
1307
1308 /* If we still don't have a pixel format, something is very wrong as ChoosePixelFormat barely fails */
1309 if (!pixel_format)
1310 {
1311 ERR("Can't find a suitable pixel format.\n");
1312 goto out;
1313 }
1314
1315 DescribePixelFormat(hdc, pixel_format, sizeof(pfd), &pfd);
1316 if (!context_set_pixel_format(gl_info, hdc, pixel_format))
1317 {
1318 ERR("Failed to set pixel format %d on device context %p.\n", pixel_format, hdc);
1319 goto out;
1320 }
1321
1322 ctx = pwglCreateContext(hdc);
1323 if (device->context_count)
1324 {
1325 if (!pwglShareLists(device->contexts[0]->glCtx, ctx))
1326 {
1327 DWORD err = GetLastError();
1328 ERR("wglShareLists(%p, %p) failed, last error %#x.\n",
1329 device->contexts[0]->glCtx, ctx, err);
1330 }
1331 }
1332
1333 if(!ctx) {
1334 ERR("Failed to create a WGL context\n");
1335 goto out;
1336 }
1337
1338 if (!device_context_add(device, ret))
1339 {
1340 ERR("Failed to add the newly created context to the context list\n");
1341 if (!pwglDeleteContext(ctx))
1342 {
1343 DWORD err = GetLastError();
1344 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx, err);
1345 }
1346 goto out;
1347 }
1348
1349 ret->gl_info = gl_info;
1350 ret->state_table = device->StateTable;
1351
1352 /* Mark all states dirty to force a proper initialization of the states
1353 * on the first use of the context. */
1354 for (state = 0; state <= STATE_HIGHEST; ++state)
1355 {
1356 if (ret->state_table[state].representative)
1357 context_invalidate_state(ret, state);
1358 }
1359
1360 ret->swapchain = swapchain;
1361 ret->current_rt = target;
1362 ret->tid = GetCurrentThreadId();
1363
1364 ret->render_offscreen = surface_is_offscreen(target);
1365 ret->draw_buffers_mask = context_generate_rt_mask(GL_BACK);
1366 ret->valid = 1;
1367
1368 ret->glCtx = ctx;
1369 ret->win_handle = swapchain->win_handle;
1370 ret->hdc = hdc;
1371 ret->pixel_format = pixel_format;
1372
1373 if (device->shader_backend->shader_dirtifyable_constants())
1374 {
1375 /* Create the dirty constants array and initialize them to dirty */
1376 ret->vshader_const_dirty = HeapAlloc(GetProcessHeap(), 0,
1377 sizeof(*ret->vshader_const_dirty) * device->d3d_vshader_constantF);
1378 ret->pshader_const_dirty = HeapAlloc(GetProcessHeap(), 0,
1379 sizeof(*ret->pshader_const_dirty) * device->d3d_pshader_constantF);
1380 memset(ret->vshader_const_dirty, 1,
1381 sizeof(*ret->vshader_const_dirty) * device->d3d_vshader_constantF);
1382 memset(ret->pshader_const_dirty, 1,
1383 sizeof(*ret->pshader_const_dirty) * device->d3d_pshader_constantF);
1384 }
1385
1386 ret->blit_targets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1387 gl_info->limits.buffers * sizeof(*ret->blit_targets));
1388 if (!ret->blit_targets) goto out;
1389
1390 ret->draw_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1391 gl_info->limits.buffers * sizeof(*ret->draw_buffers));
1392 if (!ret->draw_buffers) goto out;
1393
1394 ret->free_occlusion_query_size = 4;
1395 ret->free_occlusion_queries = HeapAlloc(GetProcessHeap(), 0,
1396 ret->free_occlusion_query_size * sizeof(*ret->free_occlusion_queries));
1397 if (!ret->free_occlusion_queries) goto out;
1398
1399 list_init(&ret->occlusion_queries);
1400
1401 ret->free_event_query_size = 4;
1402 ret->free_event_queries = HeapAlloc(GetProcessHeap(), 0,
1403 ret->free_event_query_size * sizeof(*ret->free_event_queries));
1404 if (!ret->free_event_queries) goto out;
1405
1406 list_init(&ret->event_queries);
1407
1408 TRACE("Successfully created new context %p\n", ret);
1409
1410 list_init(&ret->fbo_list);
1411 list_init(&ret->fbo_destroy_list);
1412
1413 context_enter(ret);
1414
1415 /* Set up the context defaults */
1416 if (!context_set_current(ret))
1417 {
1418 ERR("Cannot activate context to set up defaults\n");
1419 context_release(ret);
1420 goto out;
1421 }
1422
1423 switch (swapchain->presentParms.PresentationInterval)
1424 {
1425 case WINED3DPRESENT_INTERVAL_IMMEDIATE:
1426 swap_interval = 0;
1427 break;
1428 case WINED3DPRESENT_INTERVAL_DEFAULT:
1429 case WINED3DPRESENT_INTERVAL_ONE:
1430 swap_interval = 1;
1431 break;
1432 case WINED3DPRESENT_INTERVAL_TWO:
1433 swap_interval = 2;
1434 break;
1435 case WINED3DPRESENT_INTERVAL_THREE:
1436 swap_interval = 3;
1437 break;
1438 case WINED3DPRESENT_INTERVAL_FOUR:
1439 swap_interval = 4;
1440 break;
1441 default:
1442 FIXME("Unknown presentation interval %08x\n", swapchain->presentParms.PresentationInterval);
1443 swap_interval = 1;
1444 }
1445
1446 if (gl_info->supported[WGL_EXT_SWAP_CONTROL])
1447 {
1448 if (!GL_EXTCALL(wglSwapIntervalEXT(swap_interval)))
1449 ERR("wglSwapIntervalEXT failed to set swap interval %d for context %p, last error %#x\n",
1450 swap_interval, ret, GetLastError());
1451 }
1452
1453 ENTER_GL();
1454
1455 glGetIntegerv(GL_AUX_BUFFERS, &ret->aux_buffers);
1456
1457 TRACE("Setting up the screen\n");
1458 /* Clear the screen */
1459 glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
1460 checkGLcall("glClearColor");
1461 glClearIndex(0);
1462 glClearDepth(1);
1463 glClearStencil(0xffff);
1464
1465 checkGLcall("glClear");
1466
1467 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
1468 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
1469
1470 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
1471 checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
1472
1473 glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
1474 checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
1475
1476 glPixelStorei(GL_PACK_ALIGNMENT, device->surface_alignment);
1477 checkGLcall("glPixelStorei(GL_PACK_ALIGNMENT, device->surface_alignment);");
1478 glPixelStorei(GL_UNPACK_ALIGNMENT, device->surface_alignment);
1479 checkGLcall("glPixelStorei(GL_UNPACK_ALIGNMENT, device->surface_alignment);");
1480
1481 if (gl_info->supported[APPLE_CLIENT_STORAGE])
1482 {
1483 /* Most textures will use client storage if supported. Exceptions are non-native power of 2 textures
1484 * and textures in DIB sections(due to the memory protection).
1485 */
1486 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
1487 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
1488 }
1489 if (gl_info->supported[ARB_VERTEX_BLEND])
1490 {
1491 /* Direct3D always uses n-1 weights for n world matrices and uses 1 - sum for the last one
1492 * this is equal to GL_WEIGHT_SUM_UNITY_ARB. Enabling it doesn't do anything unless
1493 * GL_VERTEX_BLEND_ARB isn't enabled too
1494 */
1495 glEnable(GL_WEIGHT_SUM_UNITY_ARB);
1496 checkGLcall("glEnable(GL_WEIGHT_SUM_UNITY_ARB)");
1497 }
1498 if (gl_info->supported[NV_TEXTURE_SHADER2])
1499 {
1500 /* Set up the previous texture input for all shader units. This applies to bump mapping, and in d3d
1501 * the previous texture where to source the offset from is always unit - 1.
1502 */
1503 for (s = 1; s < gl_info->limits.textures; ++s)
1504 {
1505 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + s));
1506 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + s - 1);
1507 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, ...");
1508 }
1509 }
1510 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
1511 {
1512 /* MacOS(radeon X1600 at least, but most likely others too) refuses to draw if GLSL and ARBFP are
1513 * enabled, but the currently bound arbfp program is 0. Enabling ARBFP with prog 0 is invalid, but
1514 * GLSL should bypass this. This causes problems in programs that never use the fixed function pipeline,
1515 * because the ARBFP extension is enabled by the ARBFP pipeline at context creation, but no program
1516 * is ever assigned.
1517 *
1518 * So make sure a program is assigned to each context. The first real ARBFP use will set a different
1519 * program and the dummy program is destroyed when the context is destroyed.
1520 */
1521 const char *dummy_program =
1522 "!!ARBfp1.0\n"
1523 "MOV result.color, fragment.color.primary;\n"
1524 "END\n";
1525 GL_EXTCALL(glGenProgramsARB(1, &ret->dummy_arbfp_prog));
1526 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ret->dummy_arbfp_prog));
1527 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(dummy_program), dummy_program));
1528 }
1529
1530 for (s = 0; s < gl_info->limits.point_sprite_units; ++s)
1531 {
1532 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + s));
1533 glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
1534 checkGLcall("glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE)");
1535 }
1536
1537 if (gl_info->supported[ARB_PROVOKING_VERTEX])
1538 {
1539 GL_EXTCALL(glProvokingVertex(GL_FIRST_VERTEX_CONVENTION));
1540 }
1541 else if (gl_info->supported[EXT_PROVOKING_VERTEX])
1542 {
1543 GL_EXTCALL(glProvokingVertexEXT(GL_FIRST_VERTEX_CONVENTION_EXT));
1544 }
1545 device->frag_pipe->enable_extension(TRUE);
1546
1547 LEAVE_GL();
1548
1549 TRACE("Created context %p.\n", ret);
1550
1551 return ret;
1552
1553 out:
1554 HeapFree(GetProcessHeap(), 0, ret->free_event_queries);
1555 HeapFree(GetProcessHeap(), 0, ret->free_occlusion_queries);
1556 HeapFree(GetProcessHeap(), 0, ret->draw_buffers);
1557 HeapFree(GetProcessHeap(), 0, ret->blit_targets);
1558 HeapFree(GetProcessHeap(), 0, ret->pshader_const_dirty);
1559 HeapFree(GetProcessHeap(), 0, ret->vshader_const_dirty);
1560 HeapFree(GetProcessHeap(), 0, ret);
1561 return NULL;
1562 }
1563
1564 /* Do not call while under the GL lock. */
1565 void context_destroy(struct wined3d_device *device, struct wined3d_context *context)
1566 {
1567 BOOL destroy;
1568
1569 TRACE("Destroying ctx %p\n", context);
1570
1571 if (context->tid == GetCurrentThreadId() || !context->current)
1572 {
1573 context_destroy_gl_resources(context);
1574 TlsSetValue(wined3d_context_tls_idx, NULL);
1575 destroy = TRUE;
1576 }
1577 else
1578 {
1579 context->destroyed = 1;
1580 destroy = FALSE;
1581 }
1582
1583 HeapFree(GetProcessHeap(), 0, context->draw_buffers);
1584 HeapFree(GetProcessHeap(), 0, context->blit_targets);
1585 HeapFree(GetProcessHeap(), 0, context->vshader_const_dirty);
1586 HeapFree(GetProcessHeap(), 0, context->pshader_const_dirty);
1587 device_context_remove(device, context);
1588 if (destroy) HeapFree(GetProcessHeap(), 0, context);
1589 }
1590
1591 /* GL locking is done by the caller */
1592 static inline void set_blit_dimension(UINT width, UINT height) {
1593 glMatrixMode(GL_PROJECTION);
1594 checkGLcall("glMatrixMode(GL_PROJECTION)");
1595 glLoadIdentity();
1596 checkGLcall("glLoadIdentity()");
1597 glOrtho(0, width, 0, height, 0.0, -1.0);
1598 checkGLcall("glOrtho");
1599 glViewport(0, 0, width, height);
1600 checkGLcall("glViewport");
1601 }
1602
1603 /*****************************************************************************
1604 * SetupForBlit
1605 *
1606 * Sets up a context for DirectDraw blitting.
1607 * All texture units are disabled, texture unit 0 is set as current unit
1608 * fog, lighting, blending, alpha test, z test, scissor test, culling disabled
1609 * color writing enabled for all channels
1610 * register combiners disabled, shaders disabled
1611 * world matrix is set to identity, texture matrix 0 too
1612 * projection matrix is setup for drawing screen coordinates
1613 *
1614 * Params:
1615 * This: Device to activate the context for
1616 * context: Context to setup
1617 *
1618 *****************************************************************************/
1619 /* Context activation is done by the caller. */
1620 static void SetupForBlit(struct wined3d_device *device, struct wined3d_context *context)
1621 {
1622 int i;
1623 const struct wined3d_gl_info *gl_info = context->gl_info;
1624 UINT width = context->current_rt->resource.width;
1625 UINT height = context->current_rt->resource.height;
1626 DWORD sampler;
1627
1628 TRACE("Setting up context %p for blitting\n", context);
1629 if(context->last_was_blit) {
1630 if(context->blit_w != width || context->blit_h != height) {
1631 ENTER_GL();
1632 set_blit_dimension(width, height);
1633 LEAVE_GL();
1634 context->blit_w = width; context->blit_h = height;
1635 /* No need to dirtify here, the states are still dirtified because they weren't
1636 * applied since the last SetupForBlit call. Otherwise last_was_blit would not
1637 * be set
1638 */
1639 }
1640 TRACE("Context is already set up for blitting, nothing to do\n");
1641 return;
1642 }
1643 context->last_was_blit = TRUE;
1644
1645 /* TODO: Use a display list */
1646
1647 /* Disable shaders */
1648 ENTER_GL();
1649 device->shader_backend->shader_select(context, FALSE, FALSE);
1650 LEAVE_GL();
1651
1652 context_invalidate_state(context, STATE_VSHADER);
1653 context_invalidate_state(context, STATE_PIXELSHADER);
1654
1655 /* Call ENTER_GL() once for all gl calls below. In theory we should not call
1656 * helper functions in between gl calls. This function is full of context_invalidate_state
1657 * which can safely be called from here, we only lock once instead locking/unlocking
1658 * after each GL call.
1659 */
1660 ENTER_GL();
1661
1662 /* Disable all textures. The caller can then bind a texture it wants to blit
1663 * from
1664 *
1665 * The blitting code uses (for now) the fixed function pipeline, so make sure to reset all fixed
1666 * function texture unit. No need to care for higher samplers
1667 */
1668 for (i = gl_info->limits.textures - 1; i > 0 ; --i)
1669 {
1670 sampler = device->rev_tex_unit_map[i];
1671 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
1672 checkGLcall("glActiveTextureARB");
1673
1674 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
1675 {
1676 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1677 checkGLcall("glDisable GL_TEXTURE_CUBE_MAP_ARB");
1678 }
1679 glDisable(GL_TEXTURE_3D);
1680 checkGLcall("glDisable GL_TEXTURE_3D");
1681 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
1682 {
1683 glDisable(GL_TEXTURE_RECTANGLE_ARB);
1684 checkGLcall("glDisable GL_TEXTURE_RECTANGLE_ARB");
1685 }
1686 glDisable(GL_TEXTURE_2D);
1687 checkGLcall("glDisable GL_TEXTURE_2D");
1688
1689 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1690 checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);");
1691
1692 if (sampler != WINED3D_UNMAPPED_STAGE)
1693 {
1694 if (sampler < MAX_TEXTURES)
1695 context_invalidate_state(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP));
1696 context_invalidate_state(context, STATE_SAMPLER(sampler));
1697 }
1698 }
1699 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
1700 checkGLcall("glActiveTextureARB");
1701
1702 sampler = device->rev_tex_unit_map[0];
1703
1704 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
1705 {
1706 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1707 checkGLcall("glDisable GL_TEXTURE_CUBE_MAP_ARB");
1708 }
1709 glDisable(GL_TEXTURE_3D);
1710 checkGLcall("glDisable GL_TEXTURE_3D");
1711 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
1712 {
1713 glDisable(GL_TEXTURE_RECTANGLE_ARB);
1714 checkGLcall("glDisable GL_TEXTURE_RECTANGLE_ARB");
1715 }
1716 glDisable(GL_TEXTURE_2D);
1717 checkGLcall("glDisable GL_TEXTURE_2D");
1718
1719 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1720
1721 glMatrixMode(GL_TEXTURE);
1722 checkGLcall("glMatrixMode(GL_TEXTURE)");
1723 glLoadIdentity();
1724 checkGLcall("glLoadIdentity()");
1725
1726 if (gl_info->supported[EXT_TEXTURE_LOD_BIAS])
1727 {
1728 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
1729 GL_TEXTURE_LOD_BIAS_EXT,
1730 0.0f);
1731 checkGLcall("glTexEnvf GL_TEXTURE_LOD_BIAS_EXT ...");
1732 }
1733
1734 if (sampler != WINED3D_UNMAPPED_STAGE)
1735 {
1736 if (sampler < MAX_TEXTURES)
1737 {
1738 context_invalidate_state(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + sampler));
1739 context_invalidate_state(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP));
1740 }
1741 context_invalidate_state(context, STATE_SAMPLER(sampler));
1742 }
1743
1744 /* Other misc states */
1745 glDisable(GL_ALPHA_TEST);
1746 checkGLcall("glDisable(GL_ALPHA_TEST)");
1747 context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHATESTENABLE));
1748 glDisable(GL_LIGHTING);
1749 checkGLcall("glDisable GL_LIGHTING");
1750 context_invalidate_state(context, STATE_RENDER(WINED3DRS_LIGHTING));
1751 glDisable(GL_DEPTH_TEST);
1752 checkGLcall("glDisable GL_DEPTH_TEST");
1753 context_invalidate_state(context, STATE_RENDER(WINED3DRS_ZENABLE));
1754 glDisableWINE(GL_FOG);
1755 checkGLcall("glDisable GL_FOG");
1756 context_invalidate_state(context, STATE_RENDER(WINED3DRS_FOGENABLE));
1757 glDisable(GL_BLEND);
1758 checkGLcall("glDisable GL_BLEND");
1759 context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
1760 glDisable(GL_CULL_FACE);
1761 checkGLcall("glDisable GL_CULL_FACE");
1762 context_invalidate_state(context, STATE_RENDER(WINED3DRS_CULLMODE));
1763 glDisable(GL_STENCIL_TEST);
1764 checkGLcall("glDisable GL_STENCIL_TEST");
1765 context_invalidate_state(context, STATE_RENDER(WINED3DRS_STENCILENABLE));
1766 glDisable(GL_SCISSOR_TEST);
1767 checkGLcall("glDisable GL_SCISSOR_TEST");
1768 context_invalidate_state(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
1769 if (gl_info->supported[ARB_POINT_SPRITE])
1770 {
1771 glDisable(GL_POINT_SPRITE_ARB);
1772 checkGLcall("glDisable GL_POINT_SPRITE_ARB");
1773 context_invalidate_state(context, STATE_RENDER(WINED3DRS_POINTSPRITEENABLE));
1774 }
1775 glColorMask(GL_TRUE, GL_TRUE,GL_TRUE,GL_TRUE);
1776 checkGLcall("glColorMask");
1777 context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
1778 context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
1779 context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
1780 context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
1781 if (gl_info->supported[EXT_SECONDARY_COLOR])
1782 {
1783 glDisable(GL_COLOR_SUM_EXT);
1784 context_invalidate_state(context, STATE_RENDER(WINED3DRS_SPECULARENABLE));
1785 checkGLcall("glDisable(GL_COLOR_SUM_EXT)");
1786 }
1787
1788 /* Setup transforms */
1789 glMatrixMode(GL_MODELVIEW);
1790 checkGLcall("glMatrixMode(GL_MODELVIEW)");
1791 glLoadIdentity();
1792 checkGLcall("glLoadIdentity()");
1793 context_invalidate_state(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)));
1794
1795 context->last_was_rhw = TRUE;
1796 context_invalidate_state(context, STATE_VDECL); /* because of last_was_rhw = TRUE */
1797
1798 glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)");
1799 glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)");
1800 glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)");
1801 glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)");
1802 glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)");
1803 glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)");
1804 context_invalidate_state(context, STATE_RENDER(WINED3DRS_CLIPPING));
1805
1806 set_blit_dimension(width, height);
1807 device->frag_pipe->enable_extension(FALSE);
1808
1809 LEAVE_GL();
1810
1811 context->blit_w = width; context->blit_h = height;
1812 context_invalidate_state(context, STATE_VIEWPORT);
1813 context_invalidate_state(context, STATE_TRANSFORM(WINED3DTS_PROJECTION));
1814 }
1815
1816 /* Do not call while under the GL lock. */
1817 static struct wined3d_context *FindContext(const struct wined3d_device *device, const struct wined3d_surface *target)
1818 {
1819 struct wined3d_context *current_context = context_get_current();
1820 struct wined3d_context *context;
1821
1822 if (current_context && current_context->destroyed) current_context = NULL;
1823
1824 if (!target)
1825 {
1826 if (current_context
1827 && current_context->current_rt
1828 && current_context->swapchain->device == device)
1829 {
1830 target = current_context->current_rt;
1831 }
1832 else
1833 {
1834 struct wined3d_swapchain *swapchain = device->swapchains[0];
1835 if (swapchain->back_buffers) target = swapchain->back_buffers[0];
1836 else target = swapchain->front_buffer;
1837 }
1838 }
1839
1840 if (current_context && current_context->current_rt == target)
1841 {
1842 context_update_window(current_context);
1843 return current_context;
1844 }
1845
1846 if (target->container.type == WINED3D_CONTAINER_SWAPCHAIN)
1847 {
1848 TRACE("Rendering onscreen\n");
1849
1850 context = swapchain_get_context(target->container.u.swapchain);
1851 }
1852 else
1853 {
1854 TRACE("Rendering offscreen\n");
1855
1856 /* Stay with the current context if possible. Otherwise use the
1857 * context for the primary swapchain. */
1858 if (current_context && current_context->swapchain->device == device)
1859 context = current_context;
1860 else
1861 context = swapchain_get_context(device->swapchains[0]);
1862 }
1863
1864 context_update_window(context);
1865
1866 return context;
1867 }
1868
1869 static inline BOOL is_rt_mask_onscreen(DWORD rt_mask)
1870 {
1871 return rt_mask & (1 << 31);
1872 }
1873
1874 static inline GLenum draw_buffer_from_rt_mask(DWORD rt_mask)
1875 {
1876 return rt_mask & ~(1 << 31);
1877 }
1878
1879 /* Context activation and GL locking are done by the caller. */
1880 static void context_apply_draw_buffers(struct wined3d_context *context, DWORD rt_mask)
1881 {
1882 if (!rt_mask)
1883 {
1884 glDrawBuffer(GL_NONE);
1885 checkGLcall("glDrawBuffer()");
1886 }
1887 else if (is_rt_mask_onscreen(rt_mask))
1888 {
1889 glDrawBuffer(draw_buffer_from_rt_mask(rt_mask));
1890 checkGLcall("glDrawBuffer()");
1891 }
1892 else
1893 {
1894 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
1895 {
1896 const struct wined3d_gl_info *gl_info = context->gl_info;
1897 unsigned int i = 0;
1898
1899 while (rt_mask)
1900 {
1901 if (rt_mask & 1)
1902 context->draw_buffers[i] = GL_COLOR_ATTACHMENT0 + i;
1903 else
1904 context->draw_buffers[i] = GL_NONE;
1905
1906 rt_mask >>= 1;
1907 ++i;
1908 }
1909
1910 if (gl_info->supported[ARB_DRAW_BUFFERS])
1911 {
1912 GL_EXTCALL(glDrawBuffersARB(i, context->draw_buffers));
1913 checkGLcall("glDrawBuffers()");
1914 }
1915 else
1916 {
1917 glDrawBuffer(context->draw_buffers[0]);
1918 checkGLcall("glDrawBuffer()");
1919 }
1920 }
1921 else
1922 {
1923 ERR("Unexpected draw buffers mask with backbuffer ORM.\n");
1924 }
1925 }
1926 }
1927
1928 /* GL locking is done by the caller. */
1929 void context_set_draw_buffer(struct wined3d_context *context, GLenum buffer)
1930 {
1931 glDrawBuffer(buffer);
1932 checkGLcall("glDrawBuffer()");
1933 context->draw_buffers_mask = context_generate_rt_mask(buffer);
1934 }
1935
1936 static void context_set_render_offscreen(struct wined3d_context *context, BOOL offscreen)
1937 {
1938 if (context->render_offscreen == offscreen) return;
1939
1940 context_invalidate_state(context, STATE_POINTSPRITECOORDORIGIN);
1941 context_invalidate_state(context, STATE_TRANSFORM(WINED3DTS_PROJECTION));
1942 context_invalidate_state(context, STATE_VIEWPORT);
1943 context_invalidate_state(context, STATE_SCISSORRECT);
1944 context_invalidate_state(context, STATE_FRONTFACE);
1945 context->render_offscreen = offscreen;
1946 }
1947
1948 static BOOL match_depth_stencil_format(const struct wined3d_format *existing,
1949 const struct wined3d_format *required)
1950 {
1951 BYTE existing_depth, existing_stencil, required_depth, required_stencil;
1952
1953 if (existing == required) return TRUE;
1954 if ((existing->flags & WINED3DFMT_FLAG_FLOAT) != (required->flags & WINED3DFMT_FLAG_FLOAT)) return FALSE;
1955
1956 getDepthStencilBits(existing, &existing_depth, &existing_stencil);
1957 getDepthStencilBits(required, &required_depth, &required_stencil);
1958
1959 if(existing_depth < required_depth) return FALSE;
1960 /* If stencil bits are used the exact amount is required - otherwise wrapping
1961 * won't work correctly */
1962 if(required_stencil && required_stencil != existing_stencil) return FALSE;
1963 return TRUE;
1964 }
1965
1966 /* The caller provides a context */
1967 static void context_validate_onscreen_formats(struct wined3d_context *context,
1968 const struct wined3d_surface *depth_stencil)
1969 {
1970 /* Onscreen surfaces are always in a swapchain */
1971 struct wined3d_swapchain *swapchain = context->current_rt->container.u.swapchain;
1972
1973 if (context->render_offscreen || !depth_stencil) return;
1974 if (match_depth_stencil_format(swapchain->ds_format, depth_stencil->resource.format)) return;
1975
1976 /* TODO: If the requested format would satisfy the needs of the existing one(reverse match),
1977 * or no onscreen depth buffer was created, the OpenGL drawable could be changed to the new
1978 * format. */
1979 WARN("Depth stencil format is not supported by WGL, rendering the backbuffer in an FBO\n");
1980
1981 /* The currently active context is the necessary context to access the swapchain's onscreen buffers */
1982 surface_load_location(context->current_rt, SFLAG_INTEXTURE, NULL);
1983 swapchain->render_to_fbo = TRUE;
1984 context_set_render_offscreen(context, TRUE);
1985 }
1986
1987 static DWORD context_generate_rt_mask_no_fbo(const struct wined3d_device *device, const struct wined3d_surface *rt)
1988 {
1989 if (!rt || rt->resource.format->id == WINED3DFMT_NULL)
1990 return 0;
1991 else if (rt->container.type == WINED3D_CONTAINER_SWAPCHAIN)
1992 return context_generate_rt_mask_from_surface(rt);
1993 else
1994 return context_generate_rt_mask(device->offscreenBuffer);
1995 }
1996
1997 /* Context activation is done by the caller. */
1998 void context_apply_blit_state(struct wined3d_context *context, struct wined3d_device *device)
1999 {
2000 DWORD rt_mask;
2001
2002 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2003 {
2004 context_validate_onscreen_formats(context, NULL);
2005
2006 if (context->render_offscreen)
2007 {
2008 surface_internal_preload(context->current_rt, SRGB_RGB);
2009
2010 ENTER_GL();
2011 context_apply_fbo_state_blit(context, GL_FRAMEBUFFER, context->current_rt, NULL, SFLAG_INTEXTURE);
2012 LEAVE_GL();
2013 if (context->current_rt && context->current_rt->resource.format->id != WINED3DFMT_NULL)
2014 rt_mask = 1;
2015 else
2016 rt_mask = 0;
2017 }
2018 else
2019 {
2020 ENTER_GL();
2021 context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
2022 LEAVE_GL();
2023 rt_mask = context_generate_rt_mask_from_surface(context->current_rt);
2024 }
2025 }
2026 else
2027 {
2028 rt_mask = context_generate_rt_mask_no_fbo(device, context->current_rt);
2029 }
2030
2031 ENTER_GL();
2032 if (rt_mask != context->draw_buffers_mask)
2033 {
2034 context_apply_draw_buffers(context, rt_mask);
2035 context->draw_buffers_mask = rt_mask;
2036 }
2037
2038 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2039 {
2040 context_check_fbo_status(context, GL_FRAMEBUFFER);
2041 }
2042 LEAVE_GL();
2043
2044 SetupForBlit(device, context);
2045 context_invalidate_state(context, STATE_FRAMEBUFFER);
2046 }
2047
2048 static BOOL context_validate_rt_config(UINT rt_count,
2049 struct wined3d_surface * const *rts, const struct wined3d_surface *ds)
2050 {
2051 unsigned int i;
2052
2053 if (ds) return TRUE;
2054
2055 for (i = 0; i < rt_count; ++i)
2056 {
2057 if (rts[i] && rts[i]->resource.format->id != WINED3DFMT_NULL)
2058 return TRUE;
2059 }
2060
2061 WARN("Invalid render target config, need at least one attachment.\n");
2062 return FALSE;
2063 }
2064
2065 /* Context activation is done by the caller. */
2066 BOOL context_apply_clear_state(struct wined3d_context *context, struct wined3d_device *device,
2067 UINT rt_count, const struct wined3d_fb_state *fb)
2068 {
2069 DWORD rt_mask = 0;
2070 UINT i;
2071 struct wined3d_surface **rts = fb->render_targets;
2072
2073 if (isStateDirty(context, STATE_FRAMEBUFFER) || fb != &device->fb
2074 || rt_count != context->gl_info->limits.buffers)
2075 {
2076 if (!context_validate_rt_config(rt_count, rts, fb->depth_stencil))
2077 return FALSE;
2078
2079 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2080 {
2081 context_validate_onscreen_formats(context, fb->depth_stencil);
2082
2083 ENTER_GL();
2084
2085 if (!rt_count || surface_is_offscreen(rts[0]))
2086 {
2087 for (i = 0; i < rt_count; ++i)
2088 {
2089 context->blit_targets[i] = rts[i];
2090 if (rts[i] && rts[i]->resource.format->id != WINED3DFMT_NULL)
2091 rt_mask |= (1 << i);
2092 }
2093 while (i < context->gl_info->limits.buffers)
2094 {
2095 context->blit_targets[i] = NULL;
2096 ++i;
2097 }
2098 context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets, fb->depth_stencil, SFLAG_INTEXTURE);
2099 glReadBuffer(GL_NONE);
2100 checkGLcall("glReadBuffer");
2101 }
2102 else
2103 {
2104 context_apply_fbo_state(context, GL_FRAMEBUFFER, NULL, NULL, SFLAG_INDRAWABLE);
2105 rt_mask = context_generate_rt_mask_from_surface(rts[0]);
2106 }
2107
2108 LEAVE_GL();
2109
2110 /* If the framebuffer is not the device's fb the device's fb has to be reapplied
2111 * next draw. Otherwise we could mark the framebuffer state clean here, once the
2112 * state management allows this */
2113 context_invalidate_state(context, STATE_FRAMEBUFFER);
2114 }
2115 else
2116 {
2117 rt_mask = context_generate_rt_mask_no_fbo(device, rts[0]);
2118 }
2119 }
2120 else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO
2121 && (!rt_count || surface_is_offscreen(rts[0])))
2122 {
2123 for (i = 0; i < rt_count; ++i)
2124 {
2125 if (rts[i] && rts[i]->resource.format->id != WINED3DFMT_NULL) rt_mask |= (1 << i);
2126 }
2127 }
2128 else
2129 {
2130 rt_mask = context_generate_rt_mask_no_fbo(device, rts[0]);
2131 }
2132
2133 ENTER_GL();
2134 if (rt_mask != context->draw_buffers_mask)
2135 {
2136 context_apply_draw_buffers(context, rt_mask);
2137 context->draw_buffers_mask = rt_mask;
2138 context_invalidate_state(context, STATE_FRAMEBUFFER);
2139 }
2140
2141 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2142 {
2143 context_check_fbo_status(context, GL_FRAMEBUFFER);
2144 }
2145
2146 if (context->last_was_blit)
2147 {
2148 device->frag_pipe->enable_extension(TRUE);
2149 context->last_was_blit = FALSE;
2150 }
2151
2152 /* Blending and clearing should be orthogonal, but tests on the nvidia
2153 * driver show that disabling blending when clearing improves the clearing
2154 * performance incredibly. */
2155 glDisable(GL_BLEND);
2156 glEnable(GL_SCISSOR_TEST);
2157 checkGLcall("glEnable GL_SCISSOR_TEST");
2158 LEAVE_GL();
2159
2160 context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
2161 context_invalidate_state(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
2162 context_invalidate_state(context, STATE_SCISSORRECT);
2163
2164 return TRUE;
2165 }
2166
2167 static DWORD find_draw_buffers_mask(const struct wined3d_context *context, const struct wined3d_device *device)
2168 {
2169 const struct wined3d_state *state = &device->stateBlock->state;
2170 struct wined3d_surface **rts = state->fb->render_targets;
2171 struct wined3d_shader *ps = state->pixel_shader;
2172 DWORD rt_mask, rt_mask_bits;
2173 unsigned int i;
2174
2175 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return context_generate_rt_mask_no_fbo(device, rts[0]);
2176 else if (!context->render_offscreen) return context_generate_rt_mask_from_surface(rts[0]);
2177
2178 rt_mask = ps ? ps->reg_maps.rt_mask : 1;
2179 rt_mask &= device->valid_rt_mask;
2180 rt_mask_bits = rt_mask;
2181 i = 0;
2182 while (rt_mask_bits)
2183 {
2184 rt_mask_bits &= ~(1 << i);
2185 if (!rts[i] || rts[i]->resource.format->id == WINED3DFMT_NULL)
2186 rt_mask &= ~(1 << i);
2187
2188 i++;
2189 }
2190
2191 return rt_mask;
2192 }
2193
2194 /* GL locking and context activation are done by the caller */
2195 void context_state_fb(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
2196 {
2197 const struct wined3d_device *device = context->swapchain->device;
2198 const struct wined3d_fb_state *fb = state->fb;
2199 DWORD rt_mask = find_draw_buffers_mask(context, device);
2200
2201 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2202 {
2203 if (!context->render_offscreen)
2204 {
2205 context_apply_fbo_state(context, GL_FRAMEBUFFER, NULL, NULL, SFLAG_INDRAWABLE);
2206 }
2207 else
2208 {
2209 context_apply_fbo_state(context, GL_FRAMEBUFFER, fb->render_targets, fb->depth_stencil, SFLAG_INTEXTURE);
2210 glReadBuffer(GL_NONE);
2211 checkGLcall("glReadBuffer");
2212 }
2213 }
2214
2215 if (context->draw_buffers_mask != rt_mask)
2216 {
2217 context_apply_draw_buffers(context, rt_mask);
2218 context->draw_buffers_mask = rt_mask;
2219 }
2220 }
2221
2222 /* GL locking and context activation are done by the caller */
2223 void context_state_drawbuf(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
2224 {
2225 const struct wined3d_device *device = context->swapchain->device;
2226 DWORD rt_mask;
2227
2228 if (isStateDirty(context, STATE_FRAMEBUFFER)) return;
2229
2230 rt_mask = find_draw_buffers_mask(context, device);
2231 if (context->draw_buffers_mask != rt_mask)
2232 {
2233 context_apply_draw_buffers(context, rt_mask);
2234 context->draw_buffers_mask = rt_mask;
2235 }
2236 }
2237
2238 /* Context activation is done by the caller. */
2239 BOOL context_apply_draw_state(struct wined3d_context *context, struct wined3d_device *device)
2240 {
2241 const struct wined3d_state *state = &device->stateBlock->state;
2242 const struct StateEntry *state_table = context->state_table;
2243 const struct wined3d_fb_state *fb = state->fb;
2244 unsigned int i;
2245
2246 if (!context_validate_rt_config(context->gl_info->limits.buffers,
2247 fb->render_targets, fb->depth_stencil))
2248 return FALSE;
2249
2250 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && isStateDirty(context, STATE_FRAMEBUFFER))
2251 {
2252 context_validate_onscreen_formats(context, fb->depth_stencil);
2253 }
2254
2255 /* Preload resources before FBO setup. Texture preload in particular may
2256 * result in changes to the current FBO, due to using e.g. FBO blits for
2257 * updating a resource location. */
2258 device_update_tex_unit_map(device);
2259 device_preload_textures(device);
2260 if (isStateDirty(context, STATE_VDECL) || isStateDirty(context, STATE_STREAMSRC))
2261 device_update_stream_info(device, context->gl_info);
2262
2263 ENTER_GL();
2264 if (context->last_was_blit)
2265 {
2266 device->frag_pipe->enable_extension(TRUE);
2267 }
2268
2269 for (i = 0; i < context->numDirtyEntries; ++i)
2270 {
2271 DWORD rep = context->dirtyArray[i];
2272 DWORD idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
2273 BYTE shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
2274 context->isStateDirty[idx] &= ~(1 << shift);
2275 state_table[rep].apply(context, state, rep);
2276 }
2277
2278 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2279 {
2280 context_check_fbo_status(context, GL_FRAMEBUFFER);
2281 }
2282
2283 LEAVE_GL();
2284 context->numDirtyEntries = 0; /* This makes the whole list clean */
2285 context->last_was_blit = FALSE;
2286
2287 return TRUE;
2288 }
2289
2290 static void context_setup_target(struct wined3d_device *device,
2291 struct wined3d_context *context, struct wined3d_surface *target)
2292 {
2293 BOOL old_render_offscreen = context->render_offscreen, render_offscreen;
2294
2295 if (!target) return;
2296 render_offscreen = surface_is_offscreen(target);
2297 if (context->current_rt == target && render_offscreen == old_render_offscreen) return;
2298
2299 /* To compensate the lack of format switching with some offscreen rendering methods and on onscreen buffers
2300 * the alpha blend state changes with different render target formats. */
2301 if (!context->current_rt)
2302 {
2303 context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
2304 }
2305 else
2306 {
2307 const struct wined3d_format *old = context->current_rt->resource.format;
2308 const struct wined3d_format *new = target->resource.format;
2309
2310 if (old->id != new->id)
2311 {
2312 /* Disable blending when the alpha mask has changed and when a format doesn't support blending. */
2313 if ((old->alpha_mask && !new->alpha_mask) || (!old->alpha_mask && new->alpha_mask)
2314 || !(new->flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING))
2315 context_invalidate_state(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
2316
2317 /* Update sRGB writing when switching between formats that do/do not support sRGB writing */
2318 if ((old->flags & WINED3DFMT_FLAG_SRGB_WRITE) != (new->flags & WINED3DFMT_FLAG_SRGB_WRITE))
2319 context_invalidate_state(context, STATE_RENDER(WINED3DRS_SRGBWRITEENABLE));
2320 }
2321
2322 /* When switching away from an offscreen render target, and we're not
2323 * using FBOs, we have to read the drawable into the texture. This is
2324 * done via PreLoad (and SFLAG_INDRAWABLE set on the surface). There
2325 * are some things that need care though. PreLoad needs a GL context,
2326 * and FindContext is called before the context is activated. It also
2327 * has to be called with the old rendertarget active, otherwise a
2328 * wrong drawable is read. */
2329 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
2330 && old_render_offscreen && context->current_rt != target)
2331 {
2332 /* Read the back buffer of the old drawable into the destination texture. */
2333 if (context->current_rt->texture_name_srgb)
2334 surface_internal_preload(context->current_rt, SRGB_SRGB);
2335 surface_internal_preload(context->current_rt, SRGB_RGB);
2336 surface_modify_location(context->current_rt, SFLAG_INDRAWABLE, FALSE);
2337 }
2338 }
2339
2340 context->current_rt = target;
2341 context_set_render_offscreen(context, render_offscreen);
2342 }
2343
2344 /* Do not call while under the GL lock. */
2345 struct wined3d_context *context_acquire(struct wined3d_device *device, struct wined3d_surface *target)
2346 {
2347 struct wined3d_context *current_context = context_get_current();
2348 struct wined3d_context *context;
2349
2350 TRACE("device %p, target %p.\n", device, target);
2351
2352 context = FindContext(device, target);
2353 context_setup_target(device, context, target);
2354 context_enter(context);
2355 if (!context->valid) return context;
2356
2357 if (context != current_context)
2358 {
2359 if (!context_set_current(context))
2360 {
2361 ERR("Failed to activate the new context.\n");
2362 }
2363 else
2364 {
2365 ENTER_GL();
2366 device->frag_pipe->enable_extension(!context->last_was_blit);
2367 LEAVE_GL();
2368 }
2369
2370 if (context->vshader_const_dirty)
2371 {
2372 memset(context->vshader_const_dirty, 1,
2373 sizeof(*context->vshader_const_dirty) * device->d3d_vshader_constantF);
2374 device->highest_dirty_vs_const = device->d3d_vshader_constantF;
2375 }
2376 if (context->pshader_const_dirty)
2377 {
2378 memset(context->pshader_const_dirty, 1,
2379 sizeof(*context->pshader_const_dirty) * device->d3d_pshader_constantF);
2380 device->highest_dirty_ps_const = device->d3d_pshader_constantF;
2381 }
2382 }
2383 else if (context->restore_ctx)
2384 {
2385 context_set_gl_context(context);
2386 }
2387
2388 return context;
2389 }
Quick hack tree for wine patches julliard doesn't want to commit