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