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