?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Get rid of the redundant "device" parameter to context_destroy().
[wine.git] / dlls / wined3d / context.c
blob501558613319ec0d6db07d2640a4fc24a8986b0d
1 /*
2 * Context and render target management in wined3d
3 *
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2002-2004 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
8 * Copyright 2006, 2008 Henri Verbeet
9 * Copyright 2007-2011, 2013 Stefan Dösinger for CodeWeavers
10 * Copyright 2009-2011 Henri Verbeet for CodeWeavers
11 *
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27 #include "config.h"
28 #include "wine/port.h"
29
30 #include <stdio.h>
31 #ifdef HAVE_FLOAT_H
32 # include <float.h>
33 #endif
34
35 #include "wined3d_private.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
38 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
39 WINE_DECLARE_DEBUG_CHANNEL(d3d_synchronous);
40
41 #define WINED3D_MAX_FBO_ENTRIES 64
42 #define WINED3D_ALL_LAYERS (~0u)
43
44 static DWORD wined3d_context_tls_idx;
45
46 /* FBO helper functions */
47
48 /* Context activation is done by the caller. */
49 static void context_bind_fbo(struct wined3d_context *context, GLenum target, GLuint fbo)
50 {
51 const struct wined3d_gl_info *gl_info = context->gl_info;
52
53 switch (target)
54 {
55 case GL_READ_FRAMEBUFFER:
56 if (context->fbo_read_binding == fbo) return;
57 context->fbo_read_binding = fbo;
58 break;
59
60 case GL_DRAW_FRAMEBUFFER:
61 if (context->fbo_draw_binding == fbo) return;
62 context->fbo_draw_binding = fbo;
63 break;
64
65 case GL_FRAMEBUFFER:
66 if (context->fbo_read_binding == fbo
67 && context->fbo_draw_binding == fbo) return;
68 context->fbo_read_binding = fbo;
69 context->fbo_draw_binding = fbo;
70 break;
71
72 default:
73 FIXME("Unhandled target %#x.\n", target);
74 break;
75 }
76
77 gl_info->fbo_ops.glBindFramebuffer(target, fbo);
78 checkGLcall("glBindFramebuffer()");
79 }
80
81 /* Context activation is done by the caller. */
82 static void context_clean_fbo_attachments(const struct wined3d_gl_info *gl_info, GLenum target)
83 {
84 unsigned int i;
85
86 for (i = 0; i < gl_info->limits.buffers; ++i)
87 {
88 gl_info->fbo_ops.glFramebufferTexture2D(target, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, 0, 0);
89 checkGLcall("glFramebufferTexture2D()");
90 }
91 gl_info->fbo_ops.glFramebufferTexture2D(target, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
92 checkGLcall("glFramebufferTexture2D()");
93
94 gl_info->fbo_ops.glFramebufferTexture2D(target, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
95 checkGLcall("glFramebufferTexture2D()");
96 }
97
98 /* Context activation is done by the caller. */
99 static void context_destroy_fbo(struct wined3d_context *context, GLuint fbo)
100 {
101 const struct wined3d_gl_info *gl_info = context->gl_info;
102
103 context_bind_fbo(context, GL_FRAMEBUFFER, fbo);
104 context_clean_fbo_attachments(gl_info, GL_FRAMEBUFFER);
105 context_bind_fbo(context, GL_FRAMEBUFFER, 0);
106
107 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
108 checkGLcall("glDeleteFramebuffers()");
109 }
110
111 static void context_attach_depth_stencil_rb(const struct wined3d_gl_info *gl_info,
112 GLenum fbo_target, DWORD flags, GLuint rb)
113 {
114 if (flags & WINED3D_FBO_ENTRY_FLAG_DEPTH)
115 {
116 gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb);
117 checkGLcall("glFramebufferRenderbuffer()");
118 }
119
120 if (flags & WINED3D_FBO_ENTRY_FLAG_STENCIL)
121 {
122 gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rb);
123 checkGLcall("glFramebufferRenderbuffer()");
124 }
125 }
126
127 static void context_attach_gl_texture_fbo(struct wined3d_context *context,
128 GLenum fbo_target, GLenum attachment, const struct wined3d_fbo_resource *resource)
129 {
130 const struct wined3d_gl_info *gl_info = context->gl_info;
131
132 if (!resource)
133 {
134 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, attachment, GL_TEXTURE_2D, 0, 0);
135 }
136 else if (resource->layer == WINED3D_ALL_LAYERS)
137 {
138 if (!gl_info->fbo_ops.glFramebufferTexture)
139 {
140 FIXME("OpenGL implementation doesn't support glFramebufferTexture().\n");
141 return;
142 }
143
144 gl_info->fbo_ops.glFramebufferTexture(fbo_target, attachment,
145 resource->object, resource->level);
146 }
147 else if (resource->target == GL_TEXTURE_1D_ARRAY || resource->target == GL_TEXTURE_2D_ARRAY
148 || resource->target == GL_TEXTURE_3D)
149 {
150 if (!gl_info->fbo_ops.glFramebufferTextureLayer)
151 {
152 FIXME("OpenGL implementation doesn't support glFramebufferTextureLayer().\n");
153 return;
154 }
155
156 gl_info->fbo_ops.glFramebufferTextureLayer(fbo_target, attachment,
157 resource->object, resource->level, resource->layer);
158 }
159 else if (resource->target == GL_TEXTURE_1D)
160 {
161 gl_info->fbo_ops.glFramebufferTexture1D(fbo_target, attachment,
162 resource->target, resource->object, resource->level);
163 }
164 else
165 {
166 gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, attachment,
167 resource->target, resource->object, resource->level);
168 }
169 checkGLcall("attach texture to fbo");
170 }
171
172 /* Context activation is done by the caller. */
173 static void context_attach_depth_stencil_fbo(struct wined3d_context *context,
174 GLenum fbo_target, const struct wined3d_fbo_resource *resource, BOOL rb_namespace,
175 DWORD flags)
176 {
177 const struct wined3d_gl_info *gl_info = context->gl_info;
178
179 if (resource->object)
180 {
181 TRACE("Attach depth stencil %u.\n", resource->object);
182
183 if (rb_namespace)
184 {
185 context_attach_depth_stencil_rb(gl_info, fbo_target,
186 flags, resource->object);
187 }
188 else
189 {
190 if (flags & WINED3D_FBO_ENTRY_FLAG_DEPTH)
191 context_attach_gl_texture_fbo(context, fbo_target, GL_DEPTH_ATTACHMENT, resource);
192
193 if (flags & WINED3D_FBO_ENTRY_FLAG_STENCIL)
194 context_attach_gl_texture_fbo(context, fbo_target, GL_STENCIL_ATTACHMENT, resource);
195 }
196
197 if (!(flags & WINED3D_FBO_ENTRY_FLAG_DEPTH))
198 context_attach_gl_texture_fbo(context, fbo_target, GL_DEPTH_ATTACHMENT, NULL);
199
200 if (!(flags & WINED3D_FBO_ENTRY_FLAG_STENCIL))
201 context_attach_gl_texture_fbo(context, fbo_target, GL_STENCIL_ATTACHMENT, NULL);
202 }
203 else
204 {
205 TRACE("Attach depth stencil 0.\n");
206
207 context_attach_gl_texture_fbo(context, fbo_target, GL_DEPTH_ATTACHMENT, NULL);
208 context_attach_gl_texture_fbo(context, fbo_target, GL_STENCIL_ATTACHMENT, NULL);
209 }
210 }
211
212 /* Context activation is done by the caller. */
213 static void context_attach_surface_fbo(struct wined3d_context *context,
214 GLenum fbo_target, DWORD idx, const struct wined3d_fbo_resource *resource, BOOL rb_namespace)
215 {
216 const struct wined3d_gl_info *gl_info = context->gl_info;
217
218 TRACE("Attach GL object %u to %u.\n", resource->object, idx);
219
220 if (resource->object)
221 {
222 if (rb_namespace)
223 {
224 gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_COLOR_ATTACHMENT0 + idx,
225 GL_RENDERBUFFER, resource->object);
226 checkGLcall("glFramebufferRenderbuffer()");
227 }
228 else
229 {
230 context_attach_gl_texture_fbo(context, fbo_target, GL_COLOR_ATTACHMENT0 + idx, resource);
231 }
232 }
233 else
234 {
235 context_attach_gl_texture_fbo(context, fbo_target, GL_COLOR_ATTACHMENT0 + idx, NULL);
236 }
237 }
238
239 static void context_dump_fbo_attachment(const struct wined3d_gl_info *gl_info, GLenum target,
240 GLenum attachment)
241 {
242 static const struct
243 {
244 GLenum target;
245 GLenum binding;
246 const char *str;
247 enum wined3d_gl_extension extension;
248 }
249 texture_type[] =
250 {
251 {GL_TEXTURE_1D, GL_TEXTURE_BINDING_1D, "1d", WINED3D_GL_EXT_NONE},
252 {GL_TEXTURE_1D_ARRAY, GL_TEXTURE_BINDING_1D_ARRAY, "1d-array", EXT_TEXTURE_ARRAY},
253 {GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D, "2d", WINED3D_GL_EXT_NONE},
254 {GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_BINDING_RECTANGLE_ARB, "rectangle", ARB_TEXTURE_RECTANGLE},
255 {GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BINDING_2D_ARRAY, "2d-array" , EXT_TEXTURE_ARRAY},
256 {GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BINDING_CUBE_MAP, "cube", ARB_TEXTURE_CUBE_MAP},
257 {GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BINDING_2D_MULTISAMPLE, "2d-ms", ARB_TEXTURE_MULTISAMPLE},
258 {GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, "2d-array-ms", ARB_TEXTURE_MULTISAMPLE},
259 };
260
261 GLint type, name, samples, width, height, old_texture, level, face, fmt, tex_target;
262 const char *tex_type_str;
263 unsigned int i;
264
265 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv(target, attachment,
266 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &name);
267 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv(target, attachment,
268 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &type);
269
270 if (type == GL_RENDERBUFFER)
271 {
272 gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, name);
273 gl_info->fbo_ops.glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, &width);
274 gl_info->fbo_ops.glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, &height);
275 if (gl_info->limits.samples > 1)
276 gl_info->fbo_ops.glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples);
277 else
278 samples = 1;
279 gl_info->fbo_ops.glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_INTERNAL_FORMAT, &fmt);
280 FIXME(" %s: renderbuffer %d, %dx%d, %d samples, format %#x.\n",
281 debug_fboattachment(attachment), name, width, height, samples, fmt);
282 }
283 else if (type == GL_TEXTURE)
284 {
285 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv(target, attachment,
286 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, &level);
287 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv(target, attachment,
288 GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE, &face);
289
290 if (gl_info->gl_ops.ext.p_glGetTextureParameteriv)
291 {
292 GL_EXTCALL(glGetTextureParameteriv(name, GL_TEXTURE_TARGET, &tex_target));
293
294 for (i = 0; i < ARRAY_SIZE(texture_type); ++i)
295 {
296 if (texture_type[i].target == tex_target)
297 {
298 tex_type_str = texture_type[i].str;
299 break;
300 }
301 }
302 if (i == ARRAY_SIZE(texture_type))
303 tex_type_str = wine_dbg_sprintf("%#x", tex_target);
304 }
305 else if (face)
306 {
307 gl_info->gl_ops.gl.p_glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &old_texture);
308 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP, name);
309
310 tex_target = GL_TEXTURE_CUBE_MAP;
311 tex_type_str = "cube";
312 }
313 else
314 {
315 tex_type_str = NULL;
316
317 for (i = 0; i < ARRAY_SIZE(texture_type); ++i)
318 {
319 if (!gl_info->supported[texture_type[i].extension])
320 continue;
321
322 gl_info->gl_ops.gl.p_glGetIntegerv(texture_type[i].binding, &old_texture);
323 while (gl_info->gl_ops.gl.p_glGetError());
324
325 gl_info->gl_ops.gl.p_glBindTexture(texture_type[i].target, name);
326 if (!gl_info->gl_ops.gl.p_glGetError())
327 {
328 tex_target = texture_type[i].target;
329 tex_type_str = texture_type[i].str;
330 break;
331 }
332 gl_info->gl_ops.gl.p_glBindTexture(texture_type[i].target, old_texture);
333 }
334
335 if (!tex_type_str)
336 {
337 FIXME("Cannot find type of texture %d.\n", name);
338 return;
339 }
340 }
341
342 if (gl_info->gl_ops.ext.p_glGetTextureParameteriv)
343 {
344 GL_EXTCALL(glGetTextureLevelParameteriv(name, level, GL_TEXTURE_INTERNAL_FORMAT, &fmt));
345 GL_EXTCALL(glGetTextureLevelParameteriv(name, level, GL_TEXTURE_WIDTH, &width));
346 GL_EXTCALL(glGetTextureLevelParameteriv(name, level, GL_TEXTURE_HEIGHT, &height));
347 GL_EXTCALL(glGetTextureLevelParameteriv(name, level, GL_TEXTURE_SAMPLES, &samples));
348 }
349 else
350 {
351 gl_info->gl_ops.gl.p_glGetTexLevelParameteriv(tex_target, level, GL_TEXTURE_INTERNAL_FORMAT, &fmt);
352 gl_info->gl_ops.gl.p_glGetTexLevelParameteriv(tex_target, level, GL_TEXTURE_WIDTH, &width);
353 gl_info->gl_ops.gl.p_glGetTexLevelParameteriv(tex_target, level, GL_TEXTURE_HEIGHT, &height);
354 if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
355 gl_info->gl_ops.gl.p_glGetTexLevelParameteriv(tex_target, level, GL_TEXTURE_SAMPLES, &samples);
356 else
357 samples = 1;
358
359 gl_info->gl_ops.gl.p_glBindTexture(tex_target, old_texture);
360 }
361
362 FIXME(" %s: %s texture %d, %dx%d, %d samples, format %#x.\n",
363 debug_fboattachment(attachment), tex_type_str, name, width, height, samples, fmt);
364 }
365 else if (type == GL_NONE)
366 {
367 FIXME(" %s: NONE.\n", debug_fboattachment(attachment));
368 }
369 else
370 {
371 ERR(" %s: Unknown attachment %#x.\n", debug_fboattachment(attachment), type);
372 }
373
374 checkGLcall("dump FBO attachment");
375 }
376
377 /* Context activation is done by the caller. */
378 void context_check_fbo_status(const struct wined3d_context *context, GLenum target)
379 {
380 const struct wined3d_gl_info *gl_info = context->gl_info;
381 GLenum status;
382
383 if (!FIXME_ON(d3d))
384 return;
385
386 status = gl_info->fbo_ops.glCheckFramebufferStatus(target);
387 if (status == GL_FRAMEBUFFER_COMPLETE)
388 {
389 TRACE("FBO complete.\n");
390 }
391 else
392 {
393 unsigned int i;
394
395 FIXME("FBO status %s (%#x).\n", debug_fbostatus(status), status);
396
397 if (!context->current_fbo)
398 {
399 ERR("FBO 0 is incomplete, driver bug?\n");
400 return;
401 }
402
403 context_dump_fbo_attachment(gl_info, target, GL_DEPTH_ATTACHMENT);
404 context_dump_fbo_attachment(gl_info, target, GL_STENCIL_ATTACHMENT);
405
406 for (i = 0; i < gl_info->limits.buffers; ++i)
407 context_dump_fbo_attachment(gl_info, target, GL_COLOR_ATTACHMENT0 + i);
408 }
409 }
410
411 static inline DWORD context_generate_rt_mask(GLenum buffer)
412 {
413 /* Should take care of all the GL_FRONT/GL_BACK/GL_AUXi/GL_NONE... cases */
414 return buffer ? (1u << 31) | buffer : 0;
415 }
416
417 static inline DWORD context_generate_rt_mask_from_resource(struct wined3d_resource *resource)
418 {
419 if (resource->type != WINED3D_RTYPE_TEXTURE_2D)
420 {
421 FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type));
422 return 0;
423 }
424
425 return (1u << 31) | wined3d_texture_get_gl_buffer(texture_from_resource(resource));
426 }
427
428 static inline void context_set_fbo_key_for_render_target(const struct wined3d_context *context,
429 struct wined3d_fbo_entry_key *key, unsigned int idx, const struct wined3d_rendertarget_info *render_target,
430 DWORD location)
431 {
432 unsigned int sub_resource_idx = render_target->sub_resource_idx;
433 struct wined3d_resource *resource = render_target->resource;
434 struct wined3d_texture_gl *texture_gl;
435
436 if (!resource || resource->format->id == WINED3DFMT_NULL || resource->type == WINED3D_RTYPE_BUFFER)
437 {
438 if (resource && resource->type == WINED3D_RTYPE_BUFFER)
439 FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type));
440 key->objects[idx].object = 0;
441 key->objects[idx].target = 0;
442 key->objects[idx].level = key->objects[idx].layer = 0;
443 return;
444 }
445
446 if (render_target->gl_view.name)
447 {
448 key->objects[idx].object = render_target->gl_view.name;
449 key->objects[idx].target = render_target->gl_view.target;
450 key->objects[idx].level = 0;
451 key->objects[idx].layer = WINED3D_ALL_LAYERS;
452 return;
453 }
454
455 texture_gl = wined3d_texture_gl(wined3d_texture_from_resource(resource));
456 if (texture_gl->current_renderbuffer)
457 {
458 key->objects[idx].object = texture_gl->current_renderbuffer->id;
459 key->objects[idx].target = 0;
460 key->objects[idx].level = key->objects[idx].layer = 0;
461 key->rb_namespace |= 1 << idx;
462 return;
463 }
464
465 key->objects[idx].target = wined3d_texture_gl_get_sub_resource_target(texture_gl, sub_resource_idx);
466 key->objects[idx].level = sub_resource_idx % texture_gl->t.level_count;
467 key->objects[idx].layer = sub_resource_idx / texture_gl->t.level_count;
468
469 if (render_target->layer_count != 1)
470 key->objects[idx].layer = WINED3D_ALL_LAYERS;
471
472 switch (location)
473 {
474 case WINED3D_LOCATION_TEXTURE_RGB:
475 key->objects[idx].object = wined3d_texture_gl_get_texture_name(texture_gl, context, FALSE);
476 break;
477
478 case WINED3D_LOCATION_TEXTURE_SRGB:
479 key->objects[idx].object = wined3d_texture_gl_get_texture_name(texture_gl, context, TRUE);
480 break;
481
482 case WINED3D_LOCATION_RB_MULTISAMPLE:
483 key->objects[idx].object = texture_gl->rb_multisample;
484 key->objects[idx].target = 0;
485 key->objects[idx].level = key->objects[idx].layer = 0;
486 key->rb_namespace |= 1 << idx;
487 break;
488
489 case WINED3D_LOCATION_RB_RESOLVED:
490 key->objects[idx].object = texture_gl->rb_resolved;
491 key->objects[idx].target = 0;
492 key->objects[idx].level = key->objects[idx].layer = 0;
493 key->rb_namespace |= 1 << idx;
494 break;
495 }
496 }
497
498 static void context_generate_fbo_key(const struct wined3d_context *context,
499 struct wined3d_fbo_entry_key *key, const struct wined3d_rendertarget_info *render_targets,
500 const struct wined3d_rendertarget_info *depth_stencil, DWORD color_location, DWORD ds_location)
501 {
502 unsigned int buffers = context->gl_info->limits.buffers;
503 unsigned int i;
504
505 key->rb_namespace = 0;
506 context_set_fbo_key_for_render_target(context, key, 0, depth_stencil, ds_location);
507
508 for (i = 0; i < buffers; ++i)
509 context_set_fbo_key_for_render_target(context, key, i + 1, &render_targets[i], color_location);
510
511 memset(&key->objects[buffers + 1], 0, (ARRAY_SIZE(key->objects) - buffers - 1) * sizeof(*key->objects));
512 }
513
514 static struct fbo_entry *context_create_fbo_entry(const struct wined3d_context *context,
515 const struct wined3d_rendertarget_info *render_targets, const struct wined3d_rendertarget_info *depth_stencil,
516 DWORD color_location, DWORD ds_location)
517 {
518 const struct wined3d_gl_info *gl_info = context->gl_info;
519 struct fbo_entry *entry;
520
521 entry = heap_alloc(sizeof(*entry));
522 context_generate_fbo_key(context, &entry->key, render_targets, depth_stencil, color_location, ds_location);
523 entry->flags = 0;
524 if (depth_stencil->resource)
525 {
526 if (depth_stencil->resource->format_flags & WINED3DFMT_FLAG_DEPTH)
527 entry->flags |= WINED3D_FBO_ENTRY_FLAG_DEPTH;
528 if (depth_stencil->resource->format_flags & WINED3DFMT_FLAG_STENCIL)
529 entry->flags |= WINED3D_FBO_ENTRY_FLAG_STENCIL;
530 }
531 entry->rt_mask = context_generate_rt_mask(GL_COLOR_ATTACHMENT0);
532 gl_info->fbo_ops.glGenFramebuffers(1, &entry->id);
533 checkGLcall("glGenFramebuffers()");
534 TRACE("Created FBO %u.\n", entry->id);
535
536 return entry;
537 }
538
539 /* Context activation is done by the caller. */
540 static void context_reuse_fbo_entry(struct wined3d_context *context, GLenum target,
541 const struct wined3d_rendertarget_info *render_targets, const struct wined3d_rendertarget_info *depth_stencil,
542 DWORD color_location, DWORD ds_location, struct fbo_entry *entry)
543 {
544 const struct wined3d_gl_info *gl_info = context->gl_info;
545
546 context_bind_fbo(context, target, entry->id);
547 context_clean_fbo_attachments(gl_info, target);
548
549 context_generate_fbo_key(context, &entry->key, render_targets, depth_stencil, color_location, ds_location);
550 entry->flags = 0;
551 if (depth_stencil->resource)
552 {
553 if (depth_stencil->resource->format_flags & WINED3DFMT_FLAG_DEPTH)
554 entry->flags |= WINED3D_FBO_ENTRY_FLAG_DEPTH;
555 if (depth_stencil->resource->format_flags & WINED3DFMT_FLAG_STENCIL)
556 entry->flags |= WINED3D_FBO_ENTRY_FLAG_STENCIL;
557 }
558 }
559
560 /* Context activation is done by the caller. */
561 static void context_destroy_fbo_entry(struct wined3d_context *context, struct fbo_entry *entry)
562 {
563 if (entry->id)
564 {
565 TRACE("Destroy FBO %u.\n", entry->id);
566 context_destroy_fbo(context, entry->id);
567 }
568 --context->fbo_entry_count;
569 list_remove(&entry->entry);
570 heap_free(entry);
571 }
572
573 /* Context activation is done by the caller. */
574 static struct fbo_entry *context_find_fbo_entry(struct wined3d_context *context, GLenum target,
575 const struct wined3d_rendertarget_info *render_targets, const struct wined3d_rendertarget_info *depth_stencil,
576 DWORD color_location, DWORD ds_location)
577 {
578 static const struct wined3d_rendertarget_info ds_null = {{0}};
579 const struct wined3d_gl_info *gl_info = context->gl_info;
580 struct wined3d_texture *rt_texture, *ds_texture;
581 struct wined3d_fbo_entry_key fbo_key;
582 unsigned int i, ds_level, rt_level;
583 struct fbo_entry *entry;
584
585 if (depth_stencil->resource && depth_stencil->resource->type != WINED3D_RTYPE_BUFFER
586 && render_targets[0].resource && render_targets[0].resource->type != WINED3D_RTYPE_BUFFER)
587 {
588 rt_texture = wined3d_texture_from_resource(render_targets[0].resource);
589 rt_level = render_targets[0].sub_resource_idx % rt_texture->level_count;
590 ds_texture = wined3d_texture_from_resource(depth_stencil->resource);
591 ds_level = depth_stencil->sub_resource_idx % ds_texture->level_count;
592
593 if (wined3d_texture_get_level_width(ds_texture, ds_level)
594 < wined3d_texture_get_level_width(rt_texture, rt_level)
595 || wined3d_texture_get_level_height(ds_texture, ds_level)
596 < wined3d_texture_get_level_height(rt_texture, rt_level))
597 {
598 WARN("Depth stencil is smaller than the primary color buffer, disabling.\n");
599 depth_stencil = &ds_null;
600 }
601 else if (ds_texture->resource.multisample_type != rt_texture->resource.multisample_type
602 || (ds_texture->resource.multisample_type
603 && ds_texture->resource.multisample_quality != rt_texture->resource.multisample_quality))
604 {
605 WARN("Color multisample type %u and quality %u, depth stencil has %u and %u, disabling ds buffer.\n",
606 rt_texture->resource.multisample_type, rt_texture->resource.multisample_quality,
607 ds_texture->resource.multisample_type, ds_texture->resource.multisample_quality);
608 depth_stencil = &ds_null;
609 }
610 else if (depth_stencil->resource->type == WINED3D_RTYPE_TEXTURE_2D)
611 {
612 wined3d_texture_gl_set_compatible_renderbuffer(wined3d_texture_gl(ds_texture),
613 context, ds_level, &render_targets[0]);
614 }
615 }
616
617 context_generate_fbo_key(context, &fbo_key, render_targets, depth_stencil, color_location, ds_location);
618
619 if (TRACE_ON(d3d))
620 {
621 struct wined3d_resource *resource;
622 unsigned int width, height;
623 const char *resource_type;
624
625 TRACE("Dumping FBO attachments:\n");
626 for (i = 0; i < gl_info->limits.buffers; ++i)
627 {
628 if ((resource = render_targets[i].resource))
629 {
630 if (resource->type == WINED3D_RTYPE_BUFFER)
631 {
632 width = resource->size;
633 height = 1;
634 resource_type = "buffer";
635 }
636 else
637 {
638 rt_texture = wined3d_texture_from_resource(resource);
639 rt_level = render_targets[i].sub_resource_idx % rt_texture->level_count;
640 width = wined3d_texture_get_level_pow2_width(rt_texture, rt_level);
641 height = wined3d_texture_get_level_pow2_height(rt_texture, rt_level);
642 resource_type = "texture";
643 }
644
645 TRACE(" Color attachment %u: %p, %u format %s, %s %u, %ux%u, %u samples.\n",
646 i, resource, render_targets[i].sub_resource_idx, debug_d3dformat(resource->format->id),
647 fbo_key.rb_namespace & (1 << (i + 1)) ? "renderbuffer" : resource_type,
648 fbo_key.objects[i + 1].object, width, height, resource->multisample_type);
649 }
650 }
651 if ((resource = depth_stencil->resource))
652 {
653 if (resource->type == WINED3D_RTYPE_BUFFER)
654 {
655 width = resource->size;
656 height = 1;
657 resource_type = "buffer";
658 }
659 else
660 {
661 ds_texture = wined3d_texture_from_resource(resource);
662 ds_level = depth_stencil->sub_resource_idx % ds_texture->level_count;
663 width = wined3d_texture_get_level_pow2_width(ds_texture, ds_level);
664 height = wined3d_texture_get_level_pow2_height(ds_texture, ds_level);
665 resource_type = "texture";
666 }
667
668 TRACE(" Depth attachment: %p, %u format %s, %s %u, %ux%u, %u samples.\n",
669 resource, depth_stencil->sub_resource_idx, debug_d3dformat(resource->format->id),
670 fbo_key.rb_namespace & (1 << 0) ? "renderbuffer" : resource_type,
671 fbo_key.objects[0].object, width, height, resource->multisample_type);
672 }
673 }
674
675 LIST_FOR_EACH_ENTRY(entry, &context->fbo_list, struct fbo_entry, entry)
676 {
677 if (memcmp(&fbo_key, &entry->key, sizeof(fbo_key)))
678 continue;
679
680 list_remove(&entry->entry);
681 list_add_head(&context->fbo_list, &entry->entry);
682 return entry;
683 }
684
685 if (context->fbo_entry_count < WINED3D_MAX_FBO_ENTRIES)
686 {
687 entry = context_create_fbo_entry(context, render_targets, depth_stencil, color_location, ds_location);
688 list_add_head(&context->fbo_list, &entry->entry);
689 ++context->fbo_entry_count;
690 }
691 else
692 {
693 entry = LIST_ENTRY(list_tail(&context->fbo_list), struct fbo_entry, entry);
694 context_reuse_fbo_entry(context, target, render_targets, depth_stencil, color_location, ds_location, entry);
695 list_remove(&entry->entry);
696 list_add_head(&context->fbo_list, &entry->entry);
697 }
698
699 return entry;
700 }
701
702 /* Context activation is done by the caller. */
703 static void context_apply_fbo_entry(struct wined3d_context *context, GLenum target, struct fbo_entry *entry)
704 {
705 const struct wined3d_gl_info *gl_info = context->gl_info;
706 GLuint read_binding, draw_binding;
707 unsigned int i;
708
709 if (entry->flags & WINED3D_FBO_ENTRY_FLAG_ATTACHED)
710 {
711 context_bind_fbo(context, target, entry->id);
712 return;
713 }
714
715 read_binding = context->fbo_read_binding;
716 draw_binding = context->fbo_draw_binding;
717 context_bind_fbo(context, GL_FRAMEBUFFER, entry->id);
718
719 if (gl_info->supported[ARB_FRAMEBUFFER_NO_ATTACHMENTS])
720 {
721 GL_EXTCALL(glFramebufferParameteri(GL_FRAMEBUFFER,
722 GL_FRAMEBUFFER_DEFAULT_WIDTH, gl_info->limits.framebuffer_width));
723 GL_EXTCALL(glFramebufferParameteri(GL_FRAMEBUFFER,
724 GL_FRAMEBUFFER_DEFAULT_HEIGHT, gl_info->limits.framebuffer_height));
725 GL_EXTCALL(glFramebufferParameteri(GL_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_LAYERS, 1));
726 GL_EXTCALL(glFramebufferParameteri(GL_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_SAMPLES, 1));
727 }
728
729 /* Apply render targets */
730 for (i = 0; i < gl_info->limits.buffers; ++i)
731 {
732 context_attach_surface_fbo(context, target, i, &entry->key.objects[i + 1],
733 entry->key.rb_namespace & (1 << (i + 1)));
734 }
735
736 context_attach_depth_stencil_fbo(context, target, &entry->key.objects[0],
737 entry->key.rb_namespace & 0x1, entry->flags);
738
739 /* Set valid read and draw buffer bindings to satisfy pedantic pre-ES2_compatibility
740 * GL contexts requirements. */
741 gl_info->gl_ops.gl.p_glReadBuffer(GL_NONE);
742 context_set_draw_buffer(context, GL_NONE);
743 if (target != GL_FRAMEBUFFER)
744 {
745 if (target == GL_READ_FRAMEBUFFER)
746 context_bind_fbo(context, GL_DRAW_FRAMEBUFFER, draw_binding);
747 else
748 context_bind_fbo(context, GL_READ_FRAMEBUFFER, read_binding);
749 }
750
751 entry->flags |= WINED3D_FBO_ENTRY_FLAG_ATTACHED;
752 }
753
754 /* Context activation is done by the caller. */
755 static void context_apply_fbo_state(struct wined3d_context *context, GLenum target,
756 const struct wined3d_rendertarget_info *render_targets,
757 const struct wined3d_rendertarget_info *depth_stencil, DWORD color_location, DWORD ds_location)
758 {
759 struct fbo_entry *entry, *entry2;
760
761 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_destroy_list, struct fbo_entry, entry)
762 {
763 context_destroy_fbo_entry(context, entry);
764 }
765
766 if (context->rebind_fbo)
767 {
768 context_bind_fbo(context, GL_FRAMEBUFFER, 0);
769 context->rebind_fbo = FALSE;
770 }
771
772 if (color_location == WINED3D_LOCATION_DRAWABLE)
773 {
774 context->current_fbo = NULL;
775 context_bind_fbo(context, target, 0);
776 }
777 else
778 {
779 context->current_fbo = context_find_fbo_entry(context, target,
780 render_targets, depth_stencil, color_location, ds_location);
781 context_apply_fbo_entry(context, target, context->current_fbo);
782 }
783 }
784
785 /* Context activation is done by the caller. */
786 void context_apply_fbo_state_blit(struct wined3d_context *context, GLenum target,
787 struct wined3d_resource *rt, unsigned int rt_sub_resource_idx,
788 struct wined3d_resource *ds, unsigned int ds_sub_resource_idx, DWORD location)
789 {
790 struct wined3d_rendertarget_info ds_info = {{0}};
791
792 memset(context->blit_targets, 0, sizeof(context->blit_targets));
793 if (rt)
794 {
795 context->blit_targets[0].resource = rt;
796 context->blit_targets[0].sub_resource_idx = rt_sub_resource_idx;
797 context->blit_targets[0].layer_count = 1;
798 }
799
800 if (ds)
801 {
802 ds_info.resource = ds;
803 ds_info.sub_resource_idx = ds_sub_resource_idx;
804 ds_info.layer_count = 1;
805 }
806
807 context_apply_fbo_state(context, target, context->blit_targets, &ds_info, location, location);
808 }
809
810 /* Context activation is done by the caller. */
811 void context_alloc_occlusion_query(struct wined3d_context *context, struct wined3d_occlusion_query *query)
812 {
813 const struct wined3d_gl_info *gl_info = context->gl_info;
814
815 if (context->free_occlusion_query_count)
816 {
817 query->id = context->free_occlusion_queries[--context->free_occlusion_query_count];
818 }
819 else
820 {
821 if (gl_info->supported[ARB_OCCLUSION_QUERY])
822 {
823 GL_EXTCALL(glGenQueries(1, &query->id));
824 checkGLcall("glGenQueries");
825
826 TRACE("Allocated occlusion query %u in context %p.\n", query->id, context);
827 }
828 else
829 {
830 WARN("Occlusion queries not supported, not allocating query id.\n");
831 query->id = 0;
832 }
833 }
834
835 query->context = context;
836 list_add_head(&context->occlusion_queries, &query->entry);
837 }
838
839 void context_free_occlusion_query(struct wined3d_occlusion_query *query)
840 {
841 struct wined3d_context *context = query->context;
842
843 list_remove(&query->entry);
844 query->context = NULL;
845
846 if (!wined3d_array_reserve((void **)&context->free_occlusion_queries,
847 &context->free_occlusion_query_size, context->free_occlusion_query_count + 1,
848 sizeof(*context->free_occlusion_queries)))
849 {
850 ERR("Failed to grow free list, leaking query %u in context %p.\n", query->id, context);
851 return;
852 }
853
854 context->free_occlusion_queries[context->free_occlusion_query_count++] = query->id;
855 }
856
857 /* Context activation is done by the caller. */
858 void context_alloc_fence(struct wined3d_context *context, struct wined3d_fence *fence)
859 {
860 const struct wined3d_gl_info *gl_info = context->gl_info;
861
862 if (context->free_fence_count)
863 {
864 fence->object = context->free_fences[--context->free_fence_count];
865 }
866 else
867 {
868 if (gl_info->supported[ARB_SYNC])
869 {
870 /* Using ARB_sync, not much to do here. */
871 fence->object.sync = NULL;
872 TRACE("Allocated sync object in context %p.\n", context);
873 }
874 else if (gl_info->supported[APPLE_FENCE])
875 {
876 GL_EXTCALL(glGenFencesAPPLE(1, &fence->object.id));
877 checkGLcall("glGenFencesAPPLE");
878
879 TRACE("Allocated fence %u in context %p.\n", fence->object.id, context);
880 }
881 else if(gl_info->supported[NV_FENCE])
882 {
883 GL_EXTCALL(glGenFencesNV(1, &fence->object.id));
884 checkGLcall("glGenFencesNV");
885
886 TRACE("Allocated fence %u in context %p.\n", fence->object.id, context);
887 }
888 else
889 {
890 WARN("Fences not supported, not allocating fence.\n");
891 fence->object.id = 0;
892 }
893 }
894
895 fence->context = context;
896 list_add_head(&context->fences, &fence->entry);
897 }
898
899 void context_free_fence(struct wined3d_fence *fence)
900 {
901 struct wined3d_context *context = fence->context;
902
903 list_remove(&fence->entry);
904 fence->context = NULL;
905
906 if (!wined3d_array_reserve((void **)&context->free_fences,
907 &context->free_fence_size, context->free_fence_count + 1,
908 sizeof(*context->free_fences)))
909 {
910 ERR("Failed to grow free list, leaking fence %u in context %p.\n", fence->object.id, context);
911 return;
912 }
913
914 context->free_fences[context->free_fence_count++] = fence->object;
915 }
916
917 /* Context activation is done by the caller. */
918 void context_alloc_timestamp_query(struct wined3d_context *context, struct wined3d_timestamp_query *query)
919 {
920 const struct wined3d_gl_info *gl_info = context->gl_info;
921
922 if (context->free_timestamp_query_count)
923 {
924 query->id = context->free_timestamp_queries[--context->free_timestamp_query_count];
925 }
926 else
927 {
928 GL_EXTCALL(glGenQueries(1, &query->id));
929 checkGLcall("glGenQueries");
930
931 TRACE("Allocated timestamp query %u in context %p.\n", query->id, context);
932 }
933
934 query->context = context;
935 list_add_head(&context->timestamp_queries, &query->entry);
936 }
937
938 void context_free_timestamp_query(struct wined3d_timestamp_query *query)
939 {
940 struct wined3d_context *context = query->context;
941
942 list_remove(&query->entry);
943 query->context = NULL;
944
945 if (!wined3d_array_reserve((void **)&context->free_timestamp_queries,
946 &context->free_timestamp_query_size, context->free_timestamp_query_count + 1,
947 sizeof(*context->free_timestamp_queries)))
948 {
949 ERR("Failed to grow free list, leaking query %u in context %p.\n", query->id, context);
950 return;
951 }
952
953 context->free_timestamp_queries[context->free_timestamp_query_count++] = query->id;
954 }
955
956 void context_alloc_so_statistics_query(struct wined3d_context *context,
957 struct wined3d_so_statistics_query *query)
958 {
959 const struct wined3d_gl_info *gl_info = context->gl_info;
960
961 if (context->free_so_statistics_query_count)
962 {
963 query->u = context->free_so_statistics_queries[--context->free_so_statistics_query_count];
964 }
965 else
966 {
967 GL_EXTCALL(glGenQueries(ARRAY_SIZE(query->u.id), query->u.id));
968 checkGLcall("glGenQueries");
969
970 TRACE("Allocated SO statistics queries %u, %u in context %p.\n",
971 query->u.id[0], query->u.id[1], context);
972 }
973
974 query->context = context;
975 list_add_head(&context->so_statistics_queries, &query->entry);
976 }
977
978 void context_free_so_statistics_query(struct wined3d_so_statistics_query *query)
979 {
980 struct wined3d_context *context = query->context;
981
982 list_remove(&query->entry);
983 query->context = NULL;
984
985 if (!wined3d_array_reserve((void **)&context->free_so_statistics_queries,
986 &context->free_so_statistics_query_size, context->free_so_statistics_query_count + 1,
987 sizeof(*context->free_so_statistics_queries)))
988 {
989 ERR("Failed to grow free list, leaking GL queries %u, %u in context %p.\n",
990 query->u.id[0], query->u.id[1], context);
991 return;
992 }
993
994 context->free_so_statistics_queries[context->free_so_statistics_query_count++] = query->u;
995 }
996
997 void context_alloc_pipeline_statistics_query(struct wined3d_context *context,
998 struct wined3d_pipeline_statistics_query *query)
999 {
1000 const struct wined3d_gl_info *gl_info = context->gl_info;
1001
1002 if (context->free_pipeline_statistics_query_count)
1003 {
1004 query->u = context->free_pipeline_statistics_queries[--context->free_pipeline_statistics_query_count];
1005 }
1006 else
1007 {
1008 GL_EXTCALL(glGenQueries(ARRAY_SIZE(query->u.id), query->u.id));
1009 checkGLcall("glGenQueries");
1010 }
1011
1012 query->context = context;
1013 list_add_head(&context->pipeline_statistics_queries, &query->entry);
1014 }
1015
1016 void context_free_pipeline_statistics_query(struct wined3d_pipeline_statistics_query *query)
1017 {
1018 struct wined3d_context *context = query->context;
1019
1020 list_remove(&query->entry);
1021 query->context = NULL;
1022
1023 if (!wined3d_array_reserve((void **)&context->free_pipeline_statistics_queries,
1024 &context->free_pipeline_statistics_query_size, context->free_pipeline_statistics_query_count + 1,
1025 sizeof(*context->free_pipeline_statistics_queries)))
1026 {
1027 ERR("Failed to grow free list, leaking GL queries in context %p.\n", context);
1028 return;
1029 }
1030
1031 context->free_pipeline_statistics_queries[context->free_pipeline_statistics_query_count++] = query->u;
1032 }
1033
1034 typedef void (context_fbo_entry_func_t)(struct wined3d_context *context, struct fbo_entry *entry);
1035
1036 static void context_enum_fbo_entries(const struct wined3d_device *device,
1037 GLuint name, BOOL rb_namespace, context_fbo_entry_func_t *callback)
1038 {
1039 unsigned int i, j;
1040
1041 for (i = 0; i < device->context_count; ++i)
1042 {
1043 struct wined3d_context *context = device->contexts[i];
1044 const struct wined3d_gl_info *gl_info = context->gl_info;
1045 struct fbo_entry *entry, *entry2;
1046
1047 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_list, struct fbo_entry, entry)
1048 {
1049 for (j = 0; j < gl_info->limits.buffers + 1; ++j)
1050 {
1051 if (entry->key.objects[j].object == name
1052 && !(entry->key.rb_namespace & (1 << j)) == !rb_namespace)
1053 {
1054 callback(context, entry);
1055 break;
1056 }
1057 }
1058 }
1059 }
1060 }
1061
1062 static void context_queue_fbo_entry_destruction(struct wined3d_context *context, struct fbo_entry *entry)
1063 {
1064 list_remove(&entry->entry);
1065 list_add_head(&context->fbo_destroy_list, &entry->entry);
1066 }
1067
1068 void context_resource_released(const struct wined3d_device *device, struct wined3d_resource *resource)
1069 {
1070 unsigned int i;
1071
1072 if (!device->d3d_initialized)
1073 return;
1074
1075 for (i = 0; i < device->context_count; ++i)
1076 {
1077 struct wined3d_context *context = device->contexts[i];
1078
1079 if (&context->current_rt.texture->resource == resource)
1080 {
1081 context->current_rt.texture = NULL;
1082 context->current_rt.sub_resource_idx = 0;
1083 }
1084 }
1085 }
1086
1087 void context_gl_resource_released(struct wined3d_device *device,
1088 GLuint name, BOOL rb_namespace)
1089 {
1090 context_enum_fbo_entries(device, name, rb_namespace, context_queue_fbo_entry_destruction);
1091 }
1092
1093 void context_texture_update(struct wined3d_context *context, const struct wined3d_texture_gl *texture_gl)
1094 {
1095 const struct wined3d_gl_info *gl_info = context->gl_info;
1096 struct fbo_entry *entry = context->current_fbo;
1097 unsigned int i;
1098
1099 if (!entry || context->rebind_fbo) return;
1100
1101 for (i = 0; i < gl_info->limits.buffers + 1; ++i)
1102 {
1103 if (texture_gl->texture_rgb.name == entry->key.objects[i].object
1104 || texture_gl->texture_srgb.name == entry->key.objects[i].object)
1105 {
1106 TRACE("Updated texture %p is bound as attachment %u to the current FBO.\n", texture_gl, i);
1107 context->rebind_fbo = TRUE;
1108 return;
1109 }
1110 }
1111 }
1112
1113 static BOOL context_restore_pixel_format(struct wined3d_context *ctx)
1114 {
1115 const struct wined3d_gl_info *gl_info = ctx->gl_info;
1116 BOOL ret = FALSE;
1117
1118 if (ctx->restore_pf && IsWindow(ctx->restore_pf_win))
1119 {
1120 if (ctx->gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH])
1121 {
1122 HDC dc = GetDCEx(ctx->restore_pf_win, 0, DCX_USESTYLE | DCX_CACHE);
1123 if (dc)
1124 {
1125 if (!(ret = GL_EXTCALL(wglSetPixelFormatWINE(dc, ctx->restore_pf))))
1126 {
1127 ERR("wglSetPixelFormatWINE failed to restore pixel format %d on window %p.\n",
1128 ctx->restore_pf, ctx->restore_pf_win);
1129 }
1130 ReleaseDC(ctx->restore_pf_win, dc);
1131 }
1132 }
1133 else
1134 {
1135 ERR("can't restore pixel format %d on window %p\n", ctx->restore_pf, ctx->restore_pf_win);
1136 }
1137 }
1138
1139 ctx->restore_pf = 0;
1140 ctx->restore_pf_win = NULL;
1141 return ret;
1142 }
1143
1144 static BOOL context_set_pixel_format(struct wined3d_context *context)
1145 {
1146 const struct wined3d_gl_info *gl_info = context->gl_info;
1147 BOOL private = context->hdc_is_private;
1148 int format = context->pixel_format;
1149 HDC dc = context->hdc;
1150 int current;
1151
1152 if (private && context->hdc_has_format)
1153 return TRUE;
1154
1155 if (!private && WindowFromDC(dc) != context->win_handle)
1156 return FALSE;
1157
1158 current = gl_info->gl_ops.wgl.p_wglGetPixelFormat(dc);
1159 if (current == format) goto success;
1160
1161 if (!current)
1162 {
1163 if (!SetPixelFormat(dc, format, NULL))
1164 {
1165 /* This may also happen if the dc belongs to a destroyed window. */
1166 WARN("Failed to set pixel format %d on device context %p, last error %#x.\n",
1167 format, dc, GetLastError());
1168 return FALSE;
1169 }
1170
1171 context->restore_pf = 0;
1172 context->restore_pf_win = private ? NULL : WindowFromDC(dc);
1173 goto success;
1174 }
1175
1176 /* By default WGL doesn't allow pixel format adjustments but we need it
1177 * here. For this reason there's a Wine specific wglSetPixelFormat()
1178 * which allows us to set the pixel format multiple times. Only use it
1179 * when really needed. */
1180 if (gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH])
1181 {
1182 HWND win;
1183
1184 if (!GL_EXTCALL(wglSetPixelFormatWINE(dc, format)))
1185 {
1186 ERR("wglSetPixelFormatWINE failed to set pixel format %d on device context %p.\n",
1187 format, dc);
1188 return FALSE;
1189 }
1190
1191 win = private ? NULL : WindowFromDC(dc);
1192 if (win != context->restore_pf_win)
1193 {
1194 context_restore_pixel_format(context);
1195
1196 context->restore_pf = private ? 0 : current;
1197 context->restore_pf_win = win;
1198 }
1199
1200 goto success;
1201 }
1202
1203 /* OpenGL doesn't allow pixel format adjustments. Print an error and
1204 * continue using the old format. There's a big chance that the old
1205 * format works although with a performance hit and perhaps rendering
1206 * errors. */
1207 ERR("Unable to set pixel format %d on device context %p. Already using format %d.\n",
1208 format, dc, current);
1209 return TRUE;
1210
1211 success:
1212 if (private)
1213 context->hdc_has_format = TRUE;
1214 return TRUE;
1215 }
1216
1217 static BOOL context_set_gl_context(struct wined3d_context *ctx)
1218 {
1219 struct wined3d_swapchain *swapchain = ctx->swapchain;
1220 BOOL backup = FALSE;
1221
1222 if (!context_set_pixel_format(ctx))
1223 {
1224 WARN("Failed to set pixel format %d on device context %p.\n",
1225 ctx->pixel_format, ctx->hdc);
1226 backup = TRUE;
1227 }
1228
1229 if (backup || !wglMakeCurrent(ctx->hdc, ctx->glCtx))
1230 {
1231 WARN("Failed to make GL context %p current on device context %p, last error %#x.\n",
1232 ctx->glCtx, ctx->hdc, GetLastError());
1233 ctx->valid = 0;
1234 WARN("Trying fallback to the backup window.\n");
1235
1236 /* FIXME: If the context is destroyed it's no longer associated with
1237 * a swapchain, so we can't use the swapchain to get a backup dc. To
1238 * make this work windowless contexts would need to be handled by the
1239 * device. */
1240 if (ctx->destroyed || !swapchain)
1241 {
1242 FIXME("Unable to get backup dc for destroyed context %p.\n", ctx);
1243 context_set_current(NULL);
1244 return FALSE;
1245 }
1246
1247 if (!(ctx->hdc = swapchain_get_backup_dc(swapchain)))
1248 {
1249 context_set_current(NULL);
1250 return FALSE;
1251 }
1252
1253 ctx->hdc_is_private = TRUE;
1254 ctx->hdc_has_format = FALSE;
1255
1256 if (!context_set_pixel_format(ctx))
1257 {
1258 ERR("Failed to set pixel format %d on device context %p.\n",
1259 ctx->pixel_format, ctx->hdc);
1260 context_set_current(NULL);
1261 return FALSE;
1262 }
1263
1264 if (!wglMakeCurrent(ctx->hdc, ctx->glCtx))
1265 {
1266 ERR("Fallback to backup window (dc %p) failed too, last error %#x.\n",
1267 ctx->hdc, GetLastError());
1268 context_set_current(NULL);
1269 return FALSE;
1270 }
1271
1272 ctx->valid = 1;
1273 }
1274 ctx->needs_set = 0;
1275 return TRUE;
1276 }
1277
1278 static void context_restore_gl_context(const struct wined3d_gl_info *gl_info, HDC dc, HGLRC gl_ctx)
1279 {
1280 if (!wglMakeCurrent(dc, gl_ctx))
1281 {
1282 ERR("Failed to restore GL context %p on device context %p, last error %#x.\n",
1283 gl_ctx, dc, GetLastError());
1284 context_set_current(NULL);
1285 }
1286 }
1287
1288 static void context_update_window(struct wined3d_context *context)
1289 {
1290 if (!context->swapchain)
1291 return;
1292
1293 if (context->win_handle == context->swapchain->win_handle)
1294 return;
1295
1296 TRACE("Updating context %p window from %p to %p.\n",
1297 context, context->win_handle, context->swapchain->win_handle);
1298
1299 if (context->hdc)
1300 wined3d_release_dc(context->win_handle, context->hdc);
1301
1302 context->win_handle = context->swapchain->win_handle;
1303 context->hdc_is_private = FALSE;
1304 context->hdc_has_format = FALSE;
1305 context->needs_set = 1;
1306 context->valid = 1;
1307
1308 if (!(context->hdc = GetDCEx(context->win_handle, 0, DCX_USESTYLE | DCX_CACHE)))
1309 {
1310 ERR("Failed to get a device context for window %p.\n", context->win_handle);
1311 context->valid = 0;
1312 }
1313 }
1314
1315 static void context_destroy_gl_resources(struct wined3d_context *context)
1316 {
1317 struct wined3d_pipeline_statistics_query *pipeline_statistics_query;
1318 const struct wined3d_gl_info *gl_info = context->gl_info;
1319 struct wined3d_so_statistics_query *so_statistics_query;
1320 struct wined3d_timestamp_query *timestamp_query;
1321 struct wined3d_occlusion_query *occlusion_query;
1322 struct fbo_entry *entry, *entry2;
1323 struct wined3d_fence *fence;
1324 HGLRC restore_ctx;
1325 HDC restore_dc;
1326 unsigned int i;
1327
1328 restore_ctx = wglGetCurrentContext();
1329 restore_dc = wglGetCurrentDC();
1330
1331 if (restore_ctx == context->glCtx)
1332 restore_ctx = NULL;
1333 else if (context->valid)
1334 context_set_gl_context(context);
1335
1336 LIST_FOR_EACH_ENTRY(so_statistics_query, &context->so_statistics_queries,
1337 struct wined3d_so_statistics_query, entry)
1338 {
1339 if (context->valid)
1340 GL_EXTCALL(glDeleteQueries(ARRAY_SIZE(so_statistics_query->u.id), so_statistics_query->u.id));
1341 so_statistics_query->context = NULL;
1342 }
1343
1344 LIST_FOR_EACH_ENTRY(pipeline_statistics_query, &context->pipeline_statistics_queries,
1345 struct wined3d_pipeline_statistics_query, entry)
1346 {
1347 if (context->valid)
1348 GL_EXTCALL(glDeleteQueries(ARRAY_SIZE(pipeline_statistics_query->u.id), pipeline_statistics_query->u.id));
1349 pipeline_statistics_query->context = NULL;
1350 }
1351
1352 LIST_FOR_EACH_ENTRY(timestamp_query, &context->timestamp_queries, struct wined3d_timestamp_query, entry)
1353 {
1354 if (context->valid)
1355 GL_EXTCALL(glDeleteQueries(1, &timestamp_query->id));
1356 timestamp_query->context = NULL;
1357 }
1358
1359 LIST_FOR_EACH_ENTRY(occlusion_query, &context->occlusion_queries, struct wined3d_occlusion_query, entry)
1360 {
1361 if (context->valid && gl_info->supported[ARB_OCCLUSION_QUERY])
1362 GL_EXTCALL(glDeleteQueries(1, &occlusion_query->id));
1363 occlusion_query->context = NULL;
1364 }
1365
1366 LIST_FOR_EACH_ENTRY(fence, &context->fences, struct wined3d_fence, entry)
1367 {
1368 if (context->valid)
1369 {
1370 if (gl_info->supported[ARB_SYNC])
1371 {
1372 if (fence->object.sync)
1373 GL_EXTCALL(glDeleteSync(fence->object.sync));
1374 }
1375 else if (gl_info->supported[APPLE_FENCE])
1376 {
1377 GL_EXTCALL(glDeleteFencesAPPLE(1, &fence->object.id));
1378 }
1379 else if (gl_info->supported[NV_FENCE])
1380 {
1381 GL_EXTCALL(glDeleteFencesNV(1, &fence->object.id));
1382 }
1383 }
1384 fence->context = NULL;
1385 }
1386
1387 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_destroy_list, struct fbo_entry, entry)
1388 {
1389 if (!context->valid) entry->id = 0;
1390 context_destroy_fbo_entry(context, entry);
1391 }
1392
1393 LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_list, struct fbo_entry, entry)
1394 {
1395 if (!context->valid) entry->id = 0;
1396 context_destroy_fbo_entry(context, entry);
1397 }
1398
1399 if (context->valid)
1400 {
1401 if (context->dummy_arbfp_prog)
1402 {
1403 GL_EXTCALL(glDeleteProgramsARB(1, &context->dummy_arbfp_prog));
1404 }
1405
1406 if (gl_info->supported[WINED3D_GL_PRIMITIVE_QUERY])
1407 {
1408 for (i = 0; i < context->free_so_statistics_query_count; ++i)
1409 {
1410 union wined3d_gl_so_statistics_query *q = &context->free_so_statistics_queries[i];
1411 GL_EXTCALL(glDeleteQueries(ARRAY_SIZE(q->id), q->id));
1412 }
1413 }
1414
1415 if (gl_info->supported[ARB_PIPELINE_STATISTICS_QUERY])
1416 {
1417 for (i = 0; i < context->free_pipeline_statistics_query_count; ++i)
1418 {
1419 union wined3d_gl_pipeline_statistics_query *q = &context->free_pipeline_statistics_queries[i];
1420 GL_EXTCALL(glDeleteQueries(ARRAY_SIZE(q->id), q->id));
1421 }
1422 }
1423
1424 if (gl_info->supported[ARB_TIMER_QUERY])
1425 GL_EXTCALL(glDeleteQueries(context->free_timestamp_query_count, context->free_timestamp_queries));
1426
1427 if (gl_info->supported[ARB_OCCLUSION_QUERY])
1428 GL_EXTCALL(glDeleteQueries(context->free_occlusion_query_count, context->free_occlusion_queries));
1429
1430 if (gl_info->supported[ARB_SYNC])
1431 {
1432 for (i = 0; i < context->free_fence_count; ++i)
1433 {
1434 GL_EXTCALL(glDeleteSync(context->free_fences[i].sync));
1435 }
1436 }
1437 else if (gl_info->supported[APPLE_FENCE])
1438 {
1439 for (i = 0; i < context->free_fence_count; ++i)
1440 {
1441 GL_EXTCALL(glDeleteFencesAPPLE(1, &context->free_fences[i].id));
1442 }
1443 }
1444 else if (gl_info->supported[NV_FENCE])
1445 {
1446 for (i = 0; i < context->free_fence_count; ++i)
1447 {
1448 GL_EXTCALL(glDeleteFencesNV(1, &context->free_fences[i].id));
1449 }
1450 }
1451
1452 if (context->blit_vbo)
1453 GL_EXTCALL(glDeleteBuffers(1, &context->blit_vbo));
1454
1455 checkGLcall("context cleanup");
1456 }
1457
1458 heap_free(context->free_so_statistics_queries);
1459 heap_free(context->free_pipeline_statistics_queries);
1460 heap_free(context->free_timestamp_queries);
1461 heap_free(context->free_occlusion_queries);
1462 heap_free(context->free_fences);
1463
1464 context_restore_pixel_format(context);
1465 if (restore_ctx)
1466 {
1467 context_restore_gl_context(gl_info, restore_dc, restore_ctx);
1468 }
1469 else if (wglGetCurrentContext() && !wglMakeCurrent(NULL, NULL))
1470 {
1471 ERR("Failed to disable GL context.\n");
1472 }
1473
1474 wined3d_release_dc(context->win_handle, context->hdc);
1475
1476 if (!wglDeleteContext(context->glCtx))
1477 {
1478 DWORD err = GetLastError();
1479 ERR("wglDeleteContext(%p) failed, last error %#x.\n", context->glCtx, err);
1480 }
1481 }
1482
1483 DWORD context_get_tls_idx(void)
1484 {
1485 return wined3d_context_tls_idx;
1486 }
1487
1488 void context_set_tls_idx(DWORD idx)
1489 {
1490 wined3d_context_tls_idx = idx;
1491 }
1492
1493 struct wined3d_context *context_get_current(void)
1494 {
1495 return TlsGetValue(wined3d_context_tls_idx);
1496 }
1497
1498 BOOL context_set_current(struct wined3d_context *ctx)
1499 {
1500 struct wined3d_context *old = context_get_current();
1501
1502 if (old == ctx)
1503 {
1504 TRACE("Already using D3D context %p.\n", ctx);
1505 return TRUE;
1506 }
1507
1508 if (old)
1509 {
1510 if (old->destroyed)
1511 {
1512 TRACE("Switching away from destroyed context %p.\n", old);
1513 context_destroy_gl_resources(old);
1514 heap_free((void *)old->gl_info);
1515 heap_free(old);
1516 }
1517 else
1518 {
1519 if (wglGetCurrentContext())
1520 {
1521 const struct wined3d_gl_info *gl_info = old->gl_info;
1522 TRACE("Flushing context %p before switching to %p.\n", old, ctx);
1523 gl_info->gl_ops.gl.p_glFlush();
1524 }
1525 old->current = 0;
1526 }
1527 }
1528
1529 if (ctx)
1530 {
1531 if (!ctx->valid)
1532 {
1533 ERR("Trying to make invalid context %p current\n", ctx);
1534 return FALSE;
1535 }
1536
1537 TRACE("Switching to D3D context %p, GL context %p, device context %p.\n", ctx, ctx->glCtx, ctx->hdc);
1538 if (!context_set_gl_context(ctx))
1539 return FALSE;
1540 ctx->current = 1;
1541 }
1542 else if (wglGetCurrentContext())
1543 {
1544 TRACE("Clearing current D3D context.\n");
1545 if (!wglMakeCurrent(NULL, NULL))
1546 {
1547 DWORD err = GetLastError();
1548 ERR("Failed to clear current GL context, last error %#x.\n", err);
1549 TlsSetValue(wined3d_context_tls_idx, NULL);
1550 return FALSE;
1551 }
1552 }
1553
1554 return TlsSetValue(wined3d_context_tls_idx, ctx);
1555 }
1556
1557 void context_release(struct wined3d_context *context)
1558 {
1559 TRACE("Releasing context %p, level %u.\n", context, context->level);
1560
1561 if (WARN_ON(d3d))
1562 {
1563 if (!context->level)
1564 WARN("Context %p is not active.\n", context);
1565 else if (context != context_get_current())
1566 WARN("Context %p is not the current context.\n", context);
1567 }
1568
1569 if (!--context->level)
1570 {
1571 if (context_restore_pixel_format(context))
1572 context->needs_set = 1;
1573 if (context->restore_ctx)
1574 {
1575 TRACE("Restoring GL context %p on device context %p.\n", context->restore_ctx, context->restore_dc);
1576 context_restore_gl_context(context->gl_info, context->restore_dc, context->restore_ctx);
1577 context->restore_ctx = NULL;
1578 context->restore_dc = NULL;
1579 }
1580
1581 if (context->destroy_delayed)
1582 {
1583 TRACE("Destroying context %p.\n", context);
1584 wined3d_context_destroy(context);
1585 }
1586 }
1587 }
1588
1589 /* This is used when a context for render target A is active, but a separate context is
1590 * needed to access the WGL framebuffer for render target B. Re-acquire a context for rt
1591 * A to avoid breaking caller code. */
1592 void context_restore(struct wined3d_context *context, struct wined3d_texture *texture, unsigned int sub_resource_idx)
1593 {
1594 if (context->current_rt.texture != texture || context->current_rt.sub_resource_idx != sub_resource_idx)
1595 {
1596 context_release(context);
1597 context = context_acquire(texture->resource.device, texture, sub_resource_idx);
1598 }
1599
1600 context_release(context);
1601 }
1602
1603 static void context_enter(struct wined3d_context *context)
1604 {
1605 TRACE("Entering context %p, level %u.\n", context, context->level + 1);
1606
1607 if (!context->level++)
1608 {
1609 const struct wined3d_context *current_context = context_get_current();
1610 HGLRC current_gl = wglGetCurrentContext();
1611
1612 if (current_gl && (!current_context || current_context->glCtx != current_gl))
1613 {
1614 TRACE("Another GL context (%p on device context %p) is already current.\n",
1615 current_gl, wglGetCurrentDC());
1616 context->restore_ctx = current_gl;
1617 context->restore_dc = wglGetCurrentDC();
1618 context->needs_set = 1;
1619 }
1620 else if (!context->needs_set && !(context->hdc_is_private && context->hdc_has_format)
1621 && context->pixel_format != context->gl_info->gl_ops.wgl.p_wglGetPixelFormat(context->hdc))
1622 context->needs_set = 1;
1623 }
1624 }
1625
1626 void context_invalidate_compute_state(struct wined3d_context *context, DWORD state_id)
1627 {
1628 DWORD representative = context->state_table[state_id].representative - STATE_COMPUTE_OFFSET;
1629 unsigned int index, shift;
1630
1631 index = representative / (sizeof(*context->dirty_compute_states) * CHAR_BIT);
1632 shift = representative & (sizeof(*context->dirty_compute_states) * CHAR_BIT - 1);
1633 context->dirty_compute_states[index] |= (1u << shift);
1634 }
1635
1636 void context_invalidate_state(struct wined3d_context *context, DWORD state)
1637 {
1638 DWORD rep = context->state_table[state].representative;
1639 DWORD idx;
1640 BYTE shift;
1641
1642 if (isStateDirty(context, rep)) return;
1643
1644 context->dirtyArray[context->numDirtyEntries++] = rep;
1645 idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
1646 shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
1647 context->isStateDirty[idx] |= (1u << shift);
1648 }
1649
1650 /* This function takes care of wined3d pixel format selection. */
1651 static int context_choose_pixel_format(const struct wined3d_device *device, HDC hdc,
1652 const struct wined3d_format *color_format, const struct wined3d_format *ds_format,
1653 BOOL auxBuffers)
1654 {
1655 unsigned int cfg_count = wined3d_adapter_gl(device->adapter)->pixel_format_count;
1656 unsigned int current_value;
1657 PIXELFORMATDESCRIPTOR pfd;
1658 int iPixelFormat = 0;
1659 unsigned int i;
1660
1661 TRACE("device %p, dc %p, color_format %s, ds_format %s, aux_buffers %#x.\n",
1662 device, hdc, debug_d3dformat(color_format->id), debug_d3dformat(ds_format->id),
1663 auxBuffers);
1664
1665 current_value = 0;
1666 for (i = 0; i < cfg_count; ++i)
1667 {
1668 const struct wined3d_pixel_format *cfg = &wined3d_adapter_gl(device->adapter)->pixel_formats[i];
1669 unsigned int value;
1670
1671 /* For now only accept RGBA formats. Perhaps some day we will
1672 * allow floating point formats for pbuffers. */
1673 if (cfg->iPixelType != WGL_TYPE_RGBA_ARB)
1674 continue;
1675 /* In window mode we need a window drawable format and double buffering. */
1676 if (!(cfg->windowDrawable && cfg->doubleBuffer))
1677 continue;
1678 if (cfg->redSize < color_format->red_size)
1679 continue;
1680 if (cfg->greenSize < color_format->green_size)
1681 continue;
1682 if (cfg->blueSize < color_format->blue_size)
1683 continue;
1684 if (cfg->alphaSize < color_format->alpha_size)
1685 continue;
1686 if (cfg->depthSize < ds_format->depth_size)
1687 continue;
1688 if (ds_format->stencil_size && cfg->stencilSize != ds_format->stencil_size)
1689 continue;
1690 /* Check multisampling support. */
1691 if (cfg->numSamples)
1692 continue;
1693
1694 value = 1;
1695 /* We try to locate a format which matches our requirements exactly. In case of
1696 * depth it is no problem to emulate 16-bit using e.g. 24-bit, so accept that. */
1697 if (cfg->depthSize == ds_format->depth_size)
1698 value += 1;
1699 if (cfg->stencilSize == ds_format->stencil_size)
1700 value += 2;
1701 if (cfg->alphaSize == color_format->alpha_size)
1702 value += 4;
1703 /* We like to have aux buffers in backbuffer mode */
1704 if (auxBuffers && cfg->auxBuffers)
1705 value += 8;
1706 if (cfg->redSize == color_format->red_size
1707 && cfg->greenSize == color_format->green_size
1708 && cfg->blueSize == color_format->blue_size)
1709 value += 16;
1710
1711 if (value > current_value)
1712 {
1713 iPixelFormat = cfg->iPixelFormat;
1714 current_value = value;
1715 }
1716 }
1717
1718 if (!iPixelFormat)
1719 {
1720 ERR("Trying to locate a compatible pixel format because an exact match failed.\n");
1721
1722 memset(&pfd, 0, sizeof(pfd));
1723 pfd.nSize = sizeof(pfd);
1724 pfd.nVersion = 1;
1725 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW;/*PFD_GENERIC_ACCELERATED*/
1726 pfd.iPixelType = PFD_TYPE_RGBA;
1727 pfd.cAlphaBits = color_format->alpha_size;
1728 pfd.cColorBits = color_format->red_size + color_format->green_size
1729 + color_format->blue_size + color_format->alpha_size;
1730 pfd.cDepthBits = ds_format->depth_size;
1731 pfd.cStencilBits = ds_format->stencil_size;
1732 pfd.iLayerType = PFD_MAIN_PLANE;
1733
1734 if (!(iPixelFormat = ChoosePixelFormat(hdc, &pfd)))
1735 {
1736 /* Something is very wrong as ChoosePixelFormat() barely fails. */
1737 ERR("Can't find a suitable pixel format.\n");
1738 return 0;
1739 }
1740 }
1741
1742 TRACE("Found iPixelFormat=%d for ColorFormat=%s, DepthStencilFormat=%s.\n",
1743 iPixelFormat, debug_d3dformat(color_format->id), debug_d3dformat(ds_format->id));
1744 return iPixelFormat;
1745 }
1746
1747 /* Context activation is done by the caller. */
1748 void context_bind_dummy_textures(const struct wined3d_context *context)
1749 {
1750 const struct wined3d_dummy_textures *textures = &wined3d_device_gl(context->device)->dummy_textures;
1751 const struct wined3d_gl_info *gl_info = context->gl_info;
1752 unsigned int i;
1753
1754 for (i = 0; i < gl_info->limits.combined_samplers; ++i)
1755 {
1756 GL_EXTCALL(glActiveTexture(GL_TEXTURE0 + i));
1757
1758 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D, textures->tex_1d);
1759 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, textures->tex_2d);
1760
1761 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
1762 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_RECTANGLE_ARB, textures->tex_rect);
1763
1764 if (gl_info->supported[EXT_TEXTURE3D])
1765 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_3D, textures->tex_3d);
1766
1767 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
1768 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP, textures->tex_cube);
1769
1770 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP_ARRAY])
1771 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures->tex_cube_array);
1772
1773 if (gl_info->supported[EXT_TEXTURE_ARRAY])
1774 {
1775 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D_ARRAY, textures->tex_1d_array);
1776 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_ARRAY, textures->tex_2d_array);
1777 }
1778
1779 if (gl_info->supported[ARB_TEXTURE_BUFFER_OBJECT])
1780 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_BUFFER, textures->tex_buffer);
1781
1782 if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
1783 {
1784 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textures->tex_2d_ms);
1785 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, textures->tex_2d_ms_array);
1786 }
1787 }
1788
1789 checkGLcall("bind dummy textures");
1790 }
1791
1792 void wined3d_check_gl_call(const struct wined3d_gl_info *gl_info,
1793 const char *file, unsigned int line, const char *name)
1794 {
1795 GLint err;
1796
1797 if (gl_info->supported[ARB_DEBUG_OUTPUT] || (err = gl_info->gl_ops.gl.p_glGetError()) == GL_NO_ERROR)
1798 {
1799 TRACE("%s call ok %s / %u.\n", name, file, line);
1800 return;
1801 }
1802
1803 do
1804 {
1805 ERR(">>>>>>> %s (%#x) from %s @ %s / %u.\n",
1806 debug_glerror(err), err, name, file,line);
1807 err = gl_info->gl_ops.gl.p_glGetError();
1808 } while (err != GL_NO_ERROR);
1809 }
1810
1811 static BOOL context_debug_output_enabled(const struct wined3d_gl_info *gl_info)
1812 {
1813 return gl_info->supported[ARB_DEBUG_OUTPUT]
1814 && (ERR_ON(d3d) || FIXME_ON(d3d) || WARN_ON(d3d_perf));
1815 }
1816
1817 static void WINE_GLAPI wined3d_debug_callback(GLenum source, GLenum type, GLuint id,
1818 GLenum severity, GLsizei length, const char *message, void *ctx)
1819 {
1820 switch (type)
1821 {
1822 case GL_DEBUG_TYPE_ERROR_ARB:
1823 ERR("%p: %s.\n", ctx, debugstr_an(message, length));
1824 break;
1825
1826 case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
1827 case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
1828 case GL_DEBUG_TYPE_PORTABILITY_ARB:
1829 FIXME("%p: %s.\n", ctx, debugstr_an(message, length));
1830 break;
1831
1832 case GL_DEBUG_TYPE_PERFORMANCE_ARB:
1833 WARN_(d3d_perf)("%p: %s.\n", ctx, debugstr_an(message, length));
1834 break;
1835
1836 default:
1837 FIXME("ctx %p, type %#x: %s.\n", ctx, type, debugstr_an(message, length));
1838 break;
1839 }
1840 }
1841
1842 HGLRC context_create_wgl_attribs(const struct wined3d_gl_info *gl_info, HDC hdc, HGLRC share_ctx)
1843 {
1844 HGLRC ctx;
1845 unsigned int ctx_attrib_idx = 0;
1846 GLint ctx_attribs[7], ctx_flags = 0;
1847
1848 if (context_debug_output_enabled(gl_info))
1849 ctx_flags = WGL_CONTEXT_DEBUG_BIT_ARB;
1850 ctx_attribs[ctx_attrib_idx++] = WGL_CONTEXT_MAJOR_VERSION_ARB;
1851 ctx_attribs[ctx_attrib_idx++] = gl_info->selected_gl_version >> 16;
1852 ctx_attribs[ctx_attrib_idx++] = WGL_CONTEXT_MINOR_VERSION_ARB;
1853 ctx_attribs[ctx_attrib_idx++] = gl_info->selected_gl_version & 0xffff;
1854 if (ctx_flags)
1855 {
1856 ctx_attribs[ctx_attrib_idx++] = WGL_CONTEXT_FLAGS_ARB;
1857 ctx_attribs[ctx_attrib_idx++] = ctx_flags;
1858 }
1859 ctx_attribs[ctx_attrib_idx] = 0;
1860
1861 if (!(ctx = gl_info->p_wglCreateContextAttribsARB(hdc, share_ctx, ctx_attribs)))
1862 {
1863 if (gl_info->selected_gl_version >= MAKEDWORD_VERSION(3, 2))
1864 {
1865 if (ctx_flags)
1866 {
1867 ctx_flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
1868 ctx_attribs[ctx_attrib_idx - 1] = ctx_flags;
1869 }
1870 else
1871 {
1872 ctx_flags = WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
1873 ctx_attribs[ctx_attrib_idx++] = WGL_CONTEXT_FLAGS_ARB;
1874 ctx_attribs[ctx_attrib_idx++] = ctx_flags;
1875 ctx_attribs[ctx_attrib_idx] = 0;
1876 }
1877 if (!(ctx = gl_info->p_wglCreateContextAttribsARB(hdc, share_ctx, ctx_attribs)))
1878 WARN("Failed to create a WGL context with wglCreateContextAttribsARB, last error %#x.\n",
1879 GetLastError());
1880 }
1881 }
1882 return ctx;
1883 }
1884
1885 struct wined3d_context *context_create(struct wined3d_swapchain *swapchain,
1886 struct wined3d_texture *target, const struct wined3d_format *ds_format)
1887 {
1888 struct wined3d_device *device = swapchain->device;
1889 struct wined3d_context *context;
1890 DWORD state;
1891
1892 TRACE("swapchain %p, target %p, window %p.\n", swapchain, target, swapchain->win_handle);
1893
1894 wined3d_from_cs(device->cs);
1895
1896 if (!(context = heap_alloc_zero(sizeof(*context))))
1897 return NULL;
1898
1899 list_init(&context->timestamp_queries);
1900 list_init(&context->occlusion_queries);
1901 list_init(&context->fences);
1902 list_init(&context->so_statistics_queries);
1903 list_init(&context->pipeline_statistics_queries);
1904
1905 list_init(&context->fbo_list);
1906 list_init(&context->fbo_destroy_list);
1907
1908 if (!device->shader_backend->shader_allocate_context_data(context))
1909 {
1910 ERR("Failed to allocate shader backend context data.\n");
1911 goto out;
1912 }
1913 if (!device->adapter->fragment_pipe->allocate_context_data(context))
1914 {
1915 ERR("Failed to allocate fragment pipeline context data.\n");
1916 goto out;
1917 }
1918
1919 if (!(context->hdc = GetDCEx(swapchain->win_handle, 0, DCX_USESTYLE | DCX_CACHE)))
1920 {
1921 WARN("Failed to retrieve device context, trying swapchain backup.\n");
1922
1923 if ((context->hdc = swapchain_get_backup_dc(swapchain)))
1924 context->hdc_is_private = TRUE;
1925 else
1926 {
1927 ERR("Failed to retrieve a device context.\n");
1928 goto out;
1929 }
1930 }
1931
1932 if (!device_context_add(device, context))
1933 {
1934 ERR("Failed to add the newly created context to the context list\n");
1935 goto out;
1936 }
1937
1938 context->win_handle = swapchain->win_handle;
1939 context->gl_info = &device->adapter->gl_info;
1940 context->d3d_info = &device->adapter->d3d_info;
1941 context->state_table = device->state_table;
1942
1943 /* Mark all states dirty to force a proper initialization of the states on
1944 * the first use of the context. Compute states do not need initialization. */
1945 for (state = 0; state <= STATE_HIGHEST; ++state)
1946 {
1947 if (context->state_table[state].representative && !STATE_IS_COMPUTE(state))
1948 context_invalidate_state(context, state);
1949 }
1950
1951 context->device = device;
1952 context->swapchain = swapchain;
1953 context->current_rt.texture = target;
1954 context->current_rt.sub_resource_idx = 0;
1955 context->tid = GetCurrentThreadId();
1956
1957 if (!(device->adapter->adapter_ops->adapter_create_context(context, target, ds_format)))
1958 {
1959 device_context_remove(device, context);
1960 goto out;
1961 }
1962
1963 device->shader_backend->shader_init_context_state(context);
1964 context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL)
1965 | (1u << WINED3D_SHADER_TYPE_VERTEX)
1966 | (1u << WINED3D_SHADER_TYPE_GEOMETRY)
1967 | (1u << WINED3D_SHADER_TYPE_HULL)
1968 | (1u << WINED3D_SHADER_TYPE_DOMAIN)
1969 | (1u << WINED3D_SHADER_TYPE_COMPUTE);
1970
1971 TRACE("Created context %p.\n", context);
1972
1973 return context;
1974
1975 out:
1976 if (context->hdc)
1977 wined3d_release_dc(swapchain->win_handle, context->hdc);
1978 device->shader_backend->shader_free_context_data(context);
1979 device->adapter->fragment_pipe->free_context_data(context);
1980 heap_free(context);
1981 return NULL;
1982 }
1983
1984 BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context,
1985 struct wined3d_texture *target, const struct wined3d_format *ds_format)
1986 {
1987 struct wined3d_device *device = context->device;
1988 const struct wined3d_format *color_format;
1989 const struct wined3d_d3d_info *d3d_info;
1990 const struct wined3d_gl_info *gl_info;
1991 unsigned int target_bind_flags;
1992 BOOL aux_buffers = FALSE;
1993 HGLRC ctx, share_ctx;
1994 unsigned int i;
1995
1996 gl_info = context->gl_info;
1997 d3d_info = context->d3d_info;
1998
1999 for (i = 0; i < ARRAY_SIZE(context->tex_unit_map); ++i)
2000 context->tex_unit_map[i] = WINED3D_UNMAPPED_STAGE;
2001 for (i = 0; i < ARRAY_SIZE(context->rev_tex_unit_map); ++i)
2002 context->rev_tex_unit_map[i] = WINED3D_UNMAPPED_STAGE;
2003 if (gl_info->limits.graphics_samplers >= WINED3D_MAX_COMBINED_SAMPLERS)
2004 {
2005 /* Initialize the texture unit mapping to a 1:1 mapping. */
2006 unsigned int base, count;
2007
2008 wined3d_gl_limits_get_texture_unit_range(&gl_info->limits, WINED3D_SHADER_TYPE_PIXEL, &base, &count);
2009 if (base + WINED3D_MAX_FRAGMENT_SAMPLERS > ARRAY_SIZE(context->rev_tex_unit_map))
2010 {
2011 ERR("Unexpected texture unit base index %u.\n", base);
2012 return FALSE;
2013 }
2014 for (i = 0; i < min(count, WINED3D_MAX_FRAGMENT_SAMPLERS); ++i)
2015 {
2016 context->tex_unit_map[i] = base + i;
2017 context->rev_tex_unit_map[base + i] = i;
2018 }
2019
2020 wined3d_gl_limits_get_texture_unit_range(&gl_info->limits, WINED3D_SHADER_TYPE_VERTEX, &base, &count);
2021 if (base + WINED3D_MAX_VERTEX_SAMPLERS > ARRAY_SIZE(context->rev_tex_unit_map))
2022 {
2023 ERR("Unexpected texture unit base index %u.\n", base);
2024 return FALSE;
2025 }
2026 for (i = 0; i < min(count, WINED3D_MAX_VERTEX_SAMPLERS); ++i)
2027 {
2028 context->tex_unit_map[WINED3D_MAX_FRAGMENT_SAMPLERS + i] = base + i;
2029 context->rev_tex_unit_map[base + i] = WINED3D_MAX_FRAGMENT_SAMPLERS + i;
2030 }
2031 }
2032
2033 if (!(context->texture_type = heap_calloc(gl_info->limits.combined_samplers,
2034 sizeof(*context->texture_type))))
2035 return FALSE;
2036
2037 color_format = target->resource.format;
2038 target_bind_flags = target->resource.bind_flags;
2039
2040 /* In case of ORM_BACKBUFFER, make sure to request an alpha component for
2041 * X4R4G4B4/X8R8G8B8 as we might need it for the backbuffer. */
2042 if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
2043 {
2044 aux_buffers = TRUE;
2045
2046 if (color_format->id == WINED3DFMT_B4G4R4X4_UNORM)
2047 color_format = wined3d_get_format(device->adapter, WINED3DFMT_B4G4R4A4_UNORM, target_bind_flags);
2048 else if (color_format->id == WINED3DFMT_B8G8R8X8_UNORM)
2049 color_format = wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, target_bind_flags);
2050 }
2051
2052 /* DirectDraw supports 8bit paletted render targets and these are used by
2053 * old games like StarCraft and C&C. Most modern hardware doesn't support
2054 * 8bit natively so we perform some form of 8bit -> 32bit conversion. The
2055 * conversion (ab)uses the alpha component for storing the palette index.
2056 * For this reason we require a format with 8bit alpha, so request
2057 * A8R8G8B8. */
2058 if (color_format->id == WINED3DFMT_P8_UINT)
2059 color_format = wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, target_bind_flags);
2060
2061 /* When using FBOs for off-screen rendering, we only use the drawable for
2062 * presentation blits, and don't do any rendering to it. That means we
2063 * don't need depth or stencil buffers, and can mostly ignore the render
2064 * target format. This wouldn't necessarily be quite correct for 10bpc
2065 * display modes, but we don't currently support those.
2066 * Using the same format regardless of the color/depth/stencil targets
2067 * makes it much less likely that different wined3d instances will set
2068 * conflicting pixel formats. */
2069 if (wined3d_settings.offscreen_rendering_mode != ORM_BACKBUFFER)
2070 {
2071 color_format = wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, target_bind_flags);
2072 ds_format = wined3d_get_format(device->adapter, WINED3DFMT_UNKNOWN, WINED3D_BIND_DEPTH_STENCIL);
2073 }
2074
2075 /* Try to find a pixel format which matches our requirements. */
2076 if (!(context->pixel_format = context_choose_pixel_format(device,
2077 context->hdc, color_format, ds_format, aux_buffers)))
2078 return FALSE;
2079
2080 context_enter(context);
2081
2082 if (!context_set_pixel_format(context))
2083 {
2084 ERR("Failed to set pixel format %d on device context %p.\n", context->pixel_format, context->hdc);
2085 context_release(context);
2086 heap_free(context->texture_type);
2087 return FALSE;
2088 }
2089
2090 share_ctx = device->context_count ? device->contexts[0]->glCtx : NULL;
2091 if (gl_info->p_wglCreateContextAttribsARB)
2092 {
2093 if (!(ctx = context_create_wgl_attribs(gl_info, context->hdc, share_ctx)))
2094 {
2095 context_release(context);
2096 heap_free(context->texture_type);
2097 return FALSE;
2098 }
2099 }
2100 else
2101 {
2102 if (!(ctx = wglCreateContext(context->hdc)))
2103 {
2104 ERR("Failed to create a WGL context.\n");
2105 context_release(context);
2106 heap_free(context->texture_type);
2107 return FALSE;
2108 }
2109
2110 if (share_ctx && !wglShareLists(share_ctx, ctx))
2111 {
2112 ERR("wglShareLists(%p, %p) failed, last error %#x.\n", share_ctx, ctx, GetLastError());
2113 context_release(context);
2114 if (!wglDeleteContext(ctx))
2115 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx, GetLastError());
2116 heap_free(context->texture_type);
2117 return FALSE;
2118 }
2119 }
2120
2121 context->render_offscreen = wined3d_resource_is_offscreen(&target->resource);
2122 context->draw_buffers_mask = context_generate_rt_mask(GL_BACK);
2123 context->valid = 1;
2124
2125 context->glCtx = ctx;
2126 context->hdc_has_format = TRUE;
2127 context->needs_set = 1;
2128
2129 /* Set up the context defaults */
2130 if (!context_set_current(context))
2131 {
2132 ERR("Cannot activate context to set up defaults.\n");
2133 context_release(context);
2134 if (!wglDeleteContext(ctx))
2135 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx, GetLastError());
2136 heap_free(context->texture_type);
2137 return FALSE;
2138 }
2139
2140 if (context_debug_output_enabled(gl_info))
2141 {
2142 GL_EXTCALL(glDebugMessageCallback(wined3d_debug_callback, context));
2143 if (TRACE_ON(d3d_synchronous))
2144 gl_info->gl_ops.gl.p_glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
2145 GL_EXTCALL(glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_FALSE));
2146 if (ERR_ON(d3d))
2147 {
2148 GL_EXTCALL(glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_ERROR,
2149 GL_DONT_CARE, 0, NULL, GL_TRUE));
2150 }
2151 if (FIXME_ON(d3d))
2152 {
2153 GL_EXTCALL(glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR,
2154 GL_DONT_CARE, 0, NULL, GL_TRUE));
2155 GL_EXTCALL(glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR,
2156 GL_DONT_CARE, 0, NULL, GL_TRUE));
2157 GL_EXTCALL(glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_PORTABILITY,
2158 GL_DONT_CARE, 0, NULL, GL_TRUE));
2159 }
2160 if (WARN_ON(d3d_perf))
2161 {
2162 GL_EXTCALL(glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_PERFORMANCE,
2163 GL_DONT_CARE, 0, NULL, GL_TRUE));
2164 }
2165 }
2166
2167 if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
2168 gl_info->gl_ops.gl.p_glGetIntegerv(GL_AUX_BUFFERS, &context->aux_buffers);
2169
2170 TRACE("Setting up the screen\n");
2171
2172 if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
2173 {
2174 gl_info->gl_ops.gl.p_glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
2175 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
2176
2177 gl_info->gl_ops.gl.p_glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
2178 checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
2179
2180 gl_info->gl_ops.gl.p_glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
2181 checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
2182 }
2183 else
2184 {
2185 GLuint vao;
2186
2187 GL_EXTCALL(glGenVertexArrays(1, &vao));
2188 GL_EXTCALL(glBindVertexArray(vao));
2189 checkGLcall("creating VAO");
2190 }
2191
2192 gl_info->gl_ops.gl.p_glPixelStorei(GL_PACK_ALIGNMENT, device->surface_alignment);
2193 checkGLcall("glPixelStorei(GL_PACK_ALIGNMENT, device->surface_alignment);");
2194 gl_info->gl_ops.gl.p_glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
2195 checkGLcall("glPixelStorei(GL_UNPACK_ALIGNMENT, 1);");
2196
2197 if (gl_info->supported[NV_TEXTURE_SHADER2])
2198 {
2199 /* Set up the previous texture input for all shader units. This applies to bump mapping, and in d3d
2200 * the previous texture where to source the offset from is always unit - 1.
2201 */
2202 for (i = 1; i < gl_info->limits.textures; ++i)
2203 {
2204 context_active_texture(context, gl_info, i);
2205 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_SHADER_NV,
2206 GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + i - 1);
2207 checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, ...");
2208 }
2209 }
2210 if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2211 {
2212 /* MacOS(radeon X1600 at least, but most likely others too) refuses to draw if GLSL and ARBFP are
2213 * enabled, but the currently bound arbfp program is 0. Enabling ARBFP with prog 0 is invalid, but
2214 * GLSL should bypass this. This causes problems in programs that never use the fixed function pipeline,
2215 * because the ARBFP extension is enabled by the ARBFP pipeline at context creation, but no program
2216 * is ever assigned.
2217 *
2218 * So make sure a program is assigned to each context. The first real ARBFP use will set a different
2219 * program and the dummy program is destroyed when the context is destroyed.
2220 */
2221 static const char dummy_program[] =
2222 "!!ARBfp1.0\n"
2223 "MOV result.color, fragment.color.primary;\n"
2224 "END\n";
2225 GL_EXTCALL(glGenProgramsARB(1, &context->dummy_arbfp_prog));
2226 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, context->dummy_arbfp_prog));
2227 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB,
2228 GL_PROGRAM_FORMAT_ASCII_ARB, strlen(dummy_program), dummy_program));
2229 }
2230
2231 if (gl_info->supported[ARB_POINT_SPRITE])
2232 {
2233 for (i = 0; i < gl_info->limits.textures; ++i)
2234 {
2235 context_active_texture(context, gl_info, i);
2236 gl_info->gl_ops.gl.p_glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
2237 checkGLcall("glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE)");
2238 }
2239 }
2240
2241 if (gl_info->supported[ARB_PROVOKING_VERTEX])
2242 {
2243 GL_EXTCALL(glProvokingVertex(GL_FIRST_VERTEX_CONVENTION));
2244 }
2245 else if (gl_info->supported[EXT_PROVOKING_VERTEX])
2246 {
2247 GL_EXTCALL(glProvokingVertexEXT(GL_FIRST_VERTEX_CONVENTION_EXT));
2248 }
2249 if (!(d3d_info->wined3d_creation_flags & WINED3D_NO_PRIMITIVE_RESTART))
2250 {
2251 if (gl_info->supported[ARB_ES3_COMPATIBILITY])
2252 {
2253 gl_info->gl_ops.gl.p_glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
2254 checkGLcall("enable GL_PRIMITIVE_RESTART_FIXED_INDEX");
2255 }
2256 else
2257 {
2258 FIXME("OpenGL implementation does not support GL_PRIMITIVE_RESTART_FIXED_INDEX.\n");
2259 }
2260 }
2261 if (!(d3d_info->wined3d_creation_flags & WINED3D_LEGACY_CUBEMAP_FILTERING)
2262 && gl_info->supported[ARB_SEAMLESS_CUBE_MAP])
2263 {
2264 gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
2265 checkGLcall("enable seamless cube map filtering");
2266 }
2267 if (gl_info->supported[ARB_CLIP_CONTROL])
2268 GL_EXTCALL(glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT));
2269
2270 /* If this happens to be the first context for the device, dummy textures
2271 * are not created yet. In that case, they will be created (and bound) by
2272 * create_dummy_textures right after this context is initialized. */
2273 if (wined3d_device_gl(device)->dummy_textures.tex_2d)
2274 context_bind_dummy_textures(context);
2275
2276 /* Initialise all rectangles to avoid resetting unused ones later. */
2277 gl_info->gl_ops.gl.p_glScissor(0, 0, 0, 0);
2278 checkGLcall("glScissor");
2279
2280 return TRUE;
2281 }
2282
2283 void wined3d_context_destroy(struct wined3d_context *context)
2284 {
2285 struct wined3d_device *device = context->device;
2286 BOOL destroy;
2287
2288 TRACE("Destroying ctx %p\n", context);
2289
2290 wined3d_from_cs(device->cs);
2291
2292 /* We delay destroying a context when it is active. The context_release()
2293 * function invokes wined3d_context_destroy() again while leaving the last
2294 * level. */
2295 if (context->level)
2296 {
2297 TRACE("Delaying destruction of context %p.\n", context);
2298 context->destroy_delayed = 1;
2299 /* FIXME: Get rid of a pointer to swapchain from wined3d_context. */
2300 context->swapchain = NULL;
2301 return;
2302 }
2303
2304 if (context->tid == GetCurrentThreadId() || !context->current)
2305 {
2306 context_destroy_gl_resources(context);
2307 TlsSetValue(wined3d_context_tls_idx, NULL);
2308 destroy = TRUE;
2309 }
2310 else
2311 {
2312 /* Make a copy of gl_info for context_destroy_gl_resources use, the one
2313 in wined3d_adapter may go away in the meantime */
2314 struct wined3d_gl_info *gl_info = heap_alloc(sizeof(*gl_info));
2315 *gl_info = *context->gl_info;
2316 context->gl_info = gl_info;
2317 context->destroyed = 1;
2318 destroy = FALSE;
2319 }
2320
2321 device->shader_backend->shader_free_context_data(context);
2322 device->adapter->fragment_pipe->free_context_data(context);
2323 heap_free(context->texture_type);
2324 device_context_remove(device, context);
2325 if (destroy)
2326 heap_free(context);
2327 }
2328
2329 const DWORD *context_get_tex_unit_mapping(const struct wined3d_context *context,
2330 const struct wined3d_shader_version *shader_version, unsigned int *base, unsigned int *count)
2331 {
2332 const struct wined3d_gl_info *gl_info = context->gl_info;
2333
2334 if (!shader_version)
2335 {
2336 *base = 0;
2337 *count = WINED3D_MAX_TEXTURES;
2338 return context->tex_unit_map;
2339 }
2340
2341 if (shader_version->major >= 4)
2342 {
2343 wined3d_gl_limits_get_texture_unit_range(&gl_info->limits, shader_version->type, base, count);
2344 return NULL;
2345 }
2346
2347 switch (shader_version->type)
2348 {
2349 case WINED3D_SHADER_TYPE_PIXEL:
2350 *base = 0;
2351 *count = WINED3D_MAX_FRAGMENT_SAMPLERS;
2352 break;
2353 case WINED3D_SHADER_TYPE_VERTEX:
2354 *base = WINED3D_MAX_FRAGMENT_SAMPLERS;
2355 *count = WINED3D_MAX_VERTEX_SAMPLERS;
2356 break;
2357 default:
2358 ERR("Unhandled shader type %#x.\n", shader_version->type);
2359 *base = 0;
2360 *count = 0;
2361 }
2362
2363 return context->tex_unit_map;
2364 }
2365
2366 static void context_get_rt_size(const struct wined3d_context *context, SIZE *size)
2367 {
2368 const struct wined3d_texture *rt = context->current_rt.texture;
2369 unsigned int level;
2370
2371 if (rt->swapchain)
2372 {
2373 RECT window_size;
2374
2375 GetClientRect(context->win_handle, &window_size);
2376 size->cx = window_size.right - window_size.left;
2377 size->cy = window_size.bottom - window_size.top;
2378
2379 return;
2380 }
2381
2382 level = context->current_rt.sub_resource_idx % rt->level_count;
2383 size->cx = wined3d_texture_get_level_width(rt, level);
2384 size->cy = wined3d_texture_get_level_height(rt, level);
2385 }
2386
2387 void context_enable_clip_distances(struct wined3d_context *context, unsigned int enable_mask)
2388 {
2389 const struct wined3d_gl_info *gl_info = context->gl_info;
2390 unsigned int clip_distance_count = gl_info->limits.user_clip_distances;
2391 unsigned int i, disable_mask, current_mask;
2392
2393 disable_mask = ~enable_mask;
2394 enable_mask &= (1u << clip_distance_count) - 1;
2395 disable_mask &= (1u << clip_distance_count) - 1;
2396 current_mask = context->clip_distance_mask;
2397 context->clip_distance_mask = enable_mask;
2398
2399 enable_mask &= ~current_mask;
2400 while (enable_mask)
2401 {
2402 i = wined3d_bit_scan(&enable_mask);
2403 gl_info->gl_ops.gl.p_glEnable(GL_CLIP_DISTANCE0 + i);
2404 }
2405 disable_mask &= current_mask;
2406 while (disable_mask)
2407 {
2408 i = wined3d_bit_scan(&disable_mask);
2409 gl_info->gl_ops.gl.p_glDisable(GL_CLIP_DISTANCE0 + i);
2410 }
2411 checkGLcall("toggle clip distances");
2412 }
2413
2414 static inline BOOL is_rt_mask_onscreen(DWORD rt_mask)
2415 {
2416 return rt_mask & (1u << 31);
2417 }
2418
2419 static inline GLenum draw_buffer_from_rt_mask(DWORD rt_mask)
2420 {
2421 return rt_mask & ~(1u << 31);
2422 }
2423
2424 /* Context activation is done by the caller. */
2425 static void context_apply_draw_buffers(struct wined3d_context *context, DWORD rt_mask)
2426 {
2427 const struct wined3d_gl_info *gl_info = context->gl_info;
2428 GLenum draw_buffers[MAX_RENDER_TARGET_VIEWS];
2429
2430 if (!rt_mask)
2431 {
2432 gl_info->gl_ops.gl.p_glDrawBuffer(GL_NONE);
2433 }
2434 else if (is_rt_mask_onscreen(rt_mask))
2435 {
2436 gl_info->gl_ops.gl.p_glDrawBuffer(draw_buffer_from_rt_mask(rt_mask));
2437 }
2438 else
2439 {
2440 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2441 {
2442 unsigned int i = 0;
2443
2444 while (rt_mask)
2445 {
2446 if (rt_mask & 1)
2447 draw_buffers[i] = GL_COLOR_ATTACHMENT0 + i;
2448 else
2449 draw_buffers[i] = GL_NONE;
2450
2451 rt_mask >>= 1;
2452 ++i;
2453 }
2454
2455 if (gl_info->supported[ARB_DRAW_BUFFERS])
2456 {
2457 GL_EXTCALL(glDrawBuffers(i, draw_buffers));
2458 }
2459 else
2460 {
2461 gl_info->gl_ops.gl.p_glDrawBuffer(draw_buffers[0]);
2462 }
2463 }
2464 else
2465 {
2466 ERR("Unexpected draw buffers mask with backbuffer ORM.\n");
2467 }
2468 }
2469
2470 checkGLcall("apply draw buffers");
2471 }
2472
2473 /* Context activation is done by the caller. */
2474 void context_set_draw_buffer(struct wined3d_context *context, GLenum buffer)
2475 {
2476 const struct wined3d_gl_info *gl_info = context->gl_info;
2477 DWORD *current_mask = context->current_fbo ? &context->current_fbo->rt_mask : &context->draw_buffers_mask;
2478 DWORD new_mask = context_generate_rt_mask(buffer);
2479
2480 if (new_mask == *current_mask)
2481 return;
2482
2483 gl_info->gl_ops.gl.p_glDrawBuffer(buffer);
2484 checkGLcall("glDrawBuffer()");
2485
2486 *current_mask = new_mask;
2487 }
2488
2489 /* Context activation is done by the caller. */
2490 void context_active_texture(struct wined3d_context *context, const struct wined3d_gl_info *gl_info, unsigned int unit)
2491 {
2492 GL_EXTCALL(glActiveTexture(GL_TEXTURE0 + unit));
2493 checkGLcall("glActiveTexture");
2494 context->active_texture = unit;
2495 }
2496
2497 void context_bind_bo(struct wined3d_context *context, GLenum binding, GLuint name)
2498 {
2499 const struct wined3d_gl_info *gl_info = context->gl_info;
2500
2501 if (binding == GL_ELEMENT_ARRAY_BUFFER)
2502 context_invalidate_state(context, STATE_INDEXBUFFER);
2503
2504 GL_EXTCALL(glBindBuffer(binding, name));
2505 }
2506
2507 void context_bind_texture(struct wined3d_context *context, GLenum target, GLuint name)
2508 {
2509 const struct wined3d_dummy_textures *textures = &wined3d_device_gl(context->device)->dummy_textures;
2510 const struct wined3d_gl_info *gl_info = context->gl_info;
2511 DWORD unit = context->active_texture;
2512 DWORD old_texture_type = context->texture_type[unit];
2513
2514 if (name)
2515 {
2516 gl_info->gl_ops.gl.p_glBindTexture(target, name);
2517 }
2518 else
2519 {
2520 target = GL_NONE;
2521 }
2522
2523 if (old_texture_type != target)
2524 {
2525 switch (old_texture_type)
2526 {
2527 case GL_NONE:
2528 /* nothing to do */
2529 break;
2530 case GL_TEXTURE_1D:
2531 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D, textures->tex_1d);
2532 break;
2533 case GL_TEXTURE_1D_ARRAY:
2534 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_1D_ARRAY, textures->tex_1d_array);
2535 break;
2536 case GL_TEXTURE_2D:
2537 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, textures->tex_2d);
2538 break;
2539 case GL_TEXTURE_2D_ARRAY:
2540 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_ARRAY, textures->tex_2d_array);
2541 break;
2542 case GL_TEXTURE_RECTANGLE_ARB:
2543 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_RECTANGLE_ARB, textures->tex_rect);
2544 break;
2545 case GL_TEXTURE_CUBE_MAP:
2546 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP, textures->tex_cube);
2547 break;
2548 case GL_TEXTURE_CUBE_MAP_ARRAY:
2549 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, textures->tex_cube_array);
2550 break;
2551 case GL_TEXTURE_3D:
2552 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_3D, textures->tex_3d);
2553 break;
2554 case GL_TEXTURE_BUFFER:
2555 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_BUFFER, textures->tex_buffer);
2556 break;
2557 case GL_TEXTURE_2D_MULTISAMPLE:
2558 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textures->tex_2d_ms);
2559 break;
2560 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
2561 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, textures->tex_2d_ms_array);
2562 break;
2563 default:
2564 ERR("Unexpected texture target %#x.\n", old_texture_type);
2565 }
2566
2567 context->texture_type[unit] = target;
2568 }
2569
2570 checkGLcall("bind texture");
2571 }
2572
2573 void *context_map_bo_address(struct wined3d_context *context,
2574 const struct wined3d_bo_address *data, size_t size, GLenum binding, DWORD flags)
2575 {
2576 const struct wined3d_gl_info *gl_info;
2577 BYTE *memory;
2578
2579 if (!data->buffer_object)
2580 return data->addr;
2581
2582 gl_info = context->gl_info;
2583 context_bind_bo(context, binding, data->buffer_object);
2584
2585 if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
2586 {
2587 GLbitfield map_flags = wined3d_resource_gl_map_flags(flags) & ~GL_MAP_FLUSH_EXPLICIT_BIT;
2588 memory = GL_EXTCALL(glMapBufferRange(binding, (INT_PTR)data->addr, size, map_flags));
2589 }
2590 else
2591 {
2592 memory = GL_EXTCALL(glMapBuffer(binding, wined3d_resource_gl_legacy_map_flags(flags)));
2593 memory += (INT_PTR)data->addr;
2594 }
2595
2596 context_bind_bo(context, binding, 0);
2597 checkGLcall("Map buffer object");
2598
2599 return memory;
2600 }
2601
2602 void context_unmap_bo_address(struct wined3d_context *context,
2603 const struct wined3d_bo_address *data, GLenum binding)
2604 {
2605 const struct wined3d_gl_info *gl_info;
2606
2607 if (!data->buffer_object)
2608 return;
2609
2610 gl_info = context->gl_info;
2611 context_bind_bo(context, binding, data->buffer_object);
2612 GL_EXTCALL(glUnmapBuffer(binding));
2613 context_bind_bo(context, binding, 0);
2614 checkGLcall("Unmap buffer object");
2615 }
2616
2617 void context_copy_bo_address(struct wined3d_context *context,
2618 const struct wined3d_bo_address *dst, GLenum dst_binding,
2619 const struct wined3d_bo_address *src, GLenum src_binding, size_t size)
2620 {
2621 const struct wined3d_gl_info *gl_info;
2622 BYTE *dst_ptr, *src_ptr;
2623
2624 gl_info = context->gl_info;
2625
2626 if (dst->buffer_object && src->buffer_object)
2627 {
2628 if (gl_info->supported[ARB_COPY_BUFFER])
2629 {
2630 GL_EXTCALL(glBindBuffer(GL_COPY_READ_BUFFER, src->buffer_object));
2631 GL_EXTCALL(glBindBuffer(GL_COPY_WRITE_BUFFER, dst->buffer_object));
2632 GL_EXTCALL(glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER,
2633 (GLintptr)src->addr, (GLintptr)dst->addr, size));
2634 checkGLcall("direct buffer copy");
2635 }
2636 else
2637 {
2638 src_ptr = context_map_bo_address(context, src, size, src_binding, WINED3D_MAP_READ);
2639 dst_ptr = context_map_bo_address(context, dst, size, dst_binding, WINED3D_MAP_WRITE);
2640
2641 memcpy(dst_ptr, src_ptr, size);
2642
2643 context_unmap_bo_address(context, dst, dst_binding);
2644 context_unmap_bo_address(context, src, src_binding);
2645 }
2646 }
2647 else if (!dst->buffer_object && src->buffer_object)
2648 {
2649 context_bind_bo(context, src_binding, src->buffer_object);
2650 GL_EXTCALL(glGetBufferSubData(src_binding, (GLintptr)src->addr, size, dst->addr));
2651 checkGLcall("buffer download");
2652 }
2653 else if (dst->buffer_object && !src->buffer_object)
2654 {
2655 context_bind_bo(context, dst_binding, dst->buffer_object);
2656 GL_EXTCALL(glBufferSubData(dst_binding, (GLintptr)dst->addr, size, src->addr));
2657 checkGLcall("buffer upload");
2658 }
2659 else
2660 {
2661 memcpy(dst->addr, src->addr, size);
2662 }
2663 }
2664
2665 static void context_set_render_offscreen(struct wined3d_context *context, BOOL offscreen)
2666 {
2667 if (context->render_offscreen == offscreen)
2668 return;
2669
2670 context_invalidate_state(context, STATE_VIEWPORT);
2671 context_invalidate_state(context, STATE_SCISSORRECT);
2672 if (!context->gl_info->supported[ARB_CLIP_CONTROL])
2673 {
2674 context_invalidate_state(context, STATE_RASTERIZER);
2675 context_invalidate_state(context, STATE_POINTSPRITECOORDORIGIN);
2676 context_invalidate_state(context, STATE_TRANSFORM(WINED3D_TS_PROJECTION));
2677 }
2678 context_invalidate_state(context, STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN));
2679 if (context->gl_info->supported[ARB_FRAGMENT_COORD_CONVENTIONS])
2680 context_invalidate_state(context, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL));
2681 context->render_offscreen = offscreen;
2682 }
2683
2684 static BOOL match_depth_stencil_format(const struct wined3d_format *existing,
2685 const struct wined3d_format *required)
2686 {
2687 if (existing == required)
2688 return TRUE;
2689 if ((existing->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT)
2690 != (required->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT))
2691 return FALSE;
2692 if (existing->depth_size < required->depth_size)
2693 return FALSE;
2694 /* If stencil bits are used the exact amount is required - otherwise
2695 * wrapping won't work correctly. */
2696 if (required->stencil_size && required->stencil_size != existing->stencil_size)
2697 return FALSE;
2698 return TRUE;
2699 }
2700
2701 /* Context activation is done by the caller. */
2702 static void context_validate_onscreen_formats(struct wined3d_context *context,
2703 const struct wined3d_rendertarget_view *depth_stencil)
2704 {
2705 /* Onscreen surfaces are always in a swapchain */
2706 struct wined3d_swapchain *swapchain = context->current_rt.texture->swapchain;
2707
2708 if (context->render_offscreen || !depth_stencil) return;
2709 if (match_depth_stencil_format(swapchain->ds_format, depth_stencil->format)) return;
2710
2711 /* TODO: If the requested format would satisfy the needs of the existing one(reverse match),
2712 * or no onscreen depth buffer was created, the OpenGL drawable could be changed to the new
2713 * format. */
2714 WARN("Depth stencil format is not supported by WGL, rendering the backbuffer in an FBO\n");
2715
2716 /* The currently active context is the necessary context to access the swapchain's onscreen buffers */
2717 if (!(wined3d_texture_load_location(context->current_rt.texture, context->current_rt.sub_resource_idx,
2718 context, WINED3D_LOCATION_TEXTURE_RGB)))
2719 ERR("Failed to load location.\n");
2720 swapchain->render_to_fbo = TRUE;
2721 swapchain_update_draw_bindings(swapchain);
2722 context_set_render_offscreen(context, TRUE);
2723 }
2724
2725 GLenum context_get_offscreen_gl_buffer(const struct wined3d_context *context)
2726 {
2727 switch (wined3d_settings.offscreen_rendering_mode)
2728 {
2729 case ORM_FBO:
2730 return GL_COLOR_ATTACHMENT0;
2731
2732 case ORM_BACKBUFFER:
2733 return context->aux_buffers > 0 ? GL_AUX0 : GL_BACK;
2734
2735 default:
2736 FIXME("Unhandled offscreen rendering mode %#x.\n", wined3d_settings.offscreen_rendering_mode);
2737 return GL_BACK;
2738 }
2739 }
2740
2741 static DWORD context_generate_rt_mask_no_fbo(const struct wined3d_context *context, struct wined3d_resource *rt)
2742 {
2743 if (!rt || rt->format->id == WINED3DFMT_NULL)
2744 return 0;
2745 else if (rt->type != WINED3D_RTYPE_BUFFER && texture_from_resource(rt)->swapchain)
2746 return context_generate_rt_mask_from_resource(rt);
2747 else
2748 return context_generate_rt_mask(context_get_offscreen_gl_buffer(context));
2749 }
2750
2751 /* Context activation is done by the caller. */
2752 void context_apply_blit_state(struct wined3d_context *context, const struct wined3d_device *device)
2753 {
2754 const struct wined3d_gl_info *gl_info = context->gl_info;
2755 struct wined3d_texture *rt = context->current_rt.texture;
2756 DWORD rt_mask, *cur_mask;
2757 unsigned int sampler;
2758 SIZE rt_size;
2759
2760 TRACE("Setting up context %p for blitting.\n", context);
2761
2762 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2763 {
2764 if (context->render_offscreen)
2765 {
2766 wined3d_texture_load(rt, context, FALSE);
2767
2768 context_apply_fbo_state_blit(context, GL_FRAMEBUFFER, &rt->resource,
2769 context->current_rt.sub_resource_idx, NULL, 0, rt->resource.draw_binding);
2770 if (rt->resource.format->id != WINED3DFMT_NULL)
2771 rt_mask = 1;
2772 else
2773 rt_mask = 0;
2774 }
2775 else
2776 {
2777 context->current_fbo = NULL;
2778 context_bind_fbo(context, GL_FRAMEBUFFER, 0);
2779 rt_mask = context_generate_rt_mask_from_resource(&rt->resource);
2780 }
2781 }
2782 else
2783 {
2784 rt_mask = context_generate_rt_mask_no_fbo(context, &rt->resource);
2785 }
2786
2787 cur_mask = context->current_fbo ? &context->current_fbo->rt_mask : &context->draw_buffers_mask;
2788
2789 if (rt_mask != *cur_mask)
2790 {
2791 context_apply_draw_buffers(context, rt_mask);
2792 *cur_mask = rt_mask;
2793 }
2794
2795 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2796 {
2797 context_check_fbo_status(context, GL_FRAMEBUFFER);
2798 }
2799 context_invalidate_state(context, STATE_FRAMEBUFFER);
2800
2801 context_get_rt_size(context, &rt_size);
2802
2803 if (context->last_was_blit)
2804 {
2805 if (context->blit_w != rt_size.cx || context->blit_h != rt_size.cy)
2806 {
2807 gl_info->gl_ops.gl.p_glViewport(0, 0, rt_size.cx, rt_size.cy);
2808 context->viewport_count = WINED3D_MAX_VIEWPORTS;
2809 context->blit_w = rt_size.cx;
2810 context->blit_h = rt_size.cy;
2811 /* No need to dirtify here, the states are still dirtified because
2812 * they weren't applied since the last context_apply_blit_state()
2813 * call. */
2814 }
2815 checkGLcall("blit state application");
2816 TRACE("Context is already set up for blitting, nothing to do.\n");
2817 return;
2818 }
2819 context->last_was_blit = TRUE;
2820
2821 if (gl_info->supported[ARB_SAMPLER_OBJECTS])
2822 GL_EXTCALL(glBindSampler(0, 0));
2823 context_active_texture(context, gl_info, 0);
2824
2825 sampler = context->rev_tex_unit_map[0];
2826 if (sampler != WINED3D_UNMAPPED_STAGE)
2827 {
2828 if (sampler < WINED3D_MAX_TEXTURES)
2829 {
2830 context_invalidate_state(context, STATE_TRANSFORM(WINED3D_TS_TEXTURE0 + sampler));
2831 context_invalidate_state(context, STATE_TEXTURESTAGE(sampler, WINED3D_TSS_COLOR_OP));
2832 }
2833 context_invalidate_state(context, STATE_SAMPLER(sampler));
2834 }
2835 context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
2836 context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
2837
2838 if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
2839 {
2840 gl_info->gl_ops.gl.p_glDisable(GL_ALPHA_TEST);
2841 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHATESTENABLE));
2842 }
2843 gl_info->gl_ops.gl.p_glDisable(GL_DEPTH_TEST);
2844 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ZENABLE));
2845 gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
2846 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE));
2847 gl_info->gl_ops.gl.p_glDisable(GL_CULL_FACE);
2848 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_CULLMODE));
2849 gl_info->gl_ops.gl.p_glDisable(GL_STENCIL_TEST);
2850 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_STENCILENABLE));
2851 gl_info->gl_ops.gl.p_glDisable(GL_SCISSOR_TEST);
2852 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE));
2853 if (gl_info->supported[ARB_POINT_SPRITE])
2854 {
2855 gl_info->gl_ops.gl.p_glDisable(GL_POINT_SPRITE_ARB);
2856 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE));
2857 }
2858 if (gl_info->supported[ARB_FRAMEBUFFER_SRGB])
2859 {
2860 gl_info->gl_ops.gl.p_glDisable(GL_FRAMEBUFFER_SRGB);
2861 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE));
2862 }
2863 gl_info->gl_ops.gl.p_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
2864 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE));
2865 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1));
2866 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2));
2867 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3));
2868
2869 context->last_was_rhw = TRUE;
2870 context_invalidate_state(context, STATE_VDECL); /* because of last_was_rhw = TRUE */
2871
2872 context_enable_clip_distances(context, 0);
2873 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_CLIPPING));
2874
2875 /* FIXME: Make draw_textured_quad() able to work with a upper left origin. */
2876 if (gl_info->supported[ARB_CLIP_CONTROL])
2877 GL_EXTCALL(glClipControl(GL_LOWER_LEFT, GL_NEGATIVE_ONE_TO_ONE));
2878 gl_info->gl_ops.gl.p_glViewport(0, 0, rt_size.cx, rt_size.cy);
2879 context->viewport_count = WINED3D_MAX_VIEWPORTS;
2880 context_invalidate_state(context, STATE_VIEWPORT);
2881
2882 device->shader_backend->shader_disable(device->shader_priv, context);
2883
2884 context->blit_w = rt_size.cx;
2885 context->blit_h = rt_size.cy;
2886
2887 checkGLcall("blit state application");
2888 }
2889
2890 static void context_apply_blit_projection(const struct wined3d_context *context, unsigned int w, unsigned int h)
2891 {
2892 const struct wined3d_gl_info *gl_info = context->gl_info;
2893 const GLdouble projection[] =
2894 {
2895 2.0 / w, 0.0, 0.0, 0.0,
2896 0.0, 2.0 / h, 0.0, 0.0,
2897 0.0, 0.0, 2.0, 0.0,
2898 -1.0, -1.0, -1.0, 1.0,
2899 };
2900
2901 gl_info->gl_ops.gl.p_glMatrixMode(GL_PROJECTION);
2902 gl_info->gl_ops.gl.p_glLoadMatrixd(projection);
2903 }
2904
2905 /* Setup OpenGL states for fixed-function blitting. */
2906 /* Context activation is done by the caller. */
2907 void context_apply_ffp_blit_state(struct wined3d_context *context, const struct wined3d_device *device)
2908 {
2909 const struct wined3d_gl_info *gl_info = context->gl_info;
2910 unsigned int i, sampler;
2911
2912 if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
2913 ERR("Applying fixed-function state without legacy context support.\n");
2914
2915 if (context->last_was_ffp_blit)
2916 {
2917 SIZE rt_size;
2918
2919 context_get_rt_size(context, &rt_size);
2920 if (context->blit_w != rt_size.cx || context->blit_h != rt_size.cy)
2921 context_apply_blit_projection(context, rt_size.cx, rt_size.cy);
2922 context_apply_blit_state(context, device);
2923
2924 checkGLcall("ffp blit state application");
2925 return;
2926 }
2927 context->last_was_ffp_blit = TRUE;
2928
2929 context_apply_blit_state(context, device);
2930
2931 /* Disable all textures. The caller can then bind a texture it wants to blit
2932 * from. */
2933 for (i = gl_info->limits.textures - 1; i > 0 ; --i)
2934 {
2935 context_active_texture(context, gl_info, i);
2936
2937 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2938 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2939 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
2940 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2941 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
2942 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
2943
2944 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2945
2946 sampler = context->rev_tex_unit_map[i];
2947 if (sampler != WINED3D_UNMAPPED_STAGE)
2948 {
2949 if (sampler < WINED3D_MAX_TEXTURES)
2950 context_invalidate_state(context, STATE_TEXTURESTAGE(sampler, WINED3D_TSS_COLOR_OP));
2951 context_invalidate_state(context, STATE_SAMPLER(sampler));
2952 }
2953 }
2954
2955 context_active_texture(context, gl_info, 0);
2956
2957 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
2958 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB);
2959 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_3D);
2960 if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
2961 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_RECTANGLE_ARB);
2962 gl_info->gl_ops.gl.p_glDisable(GL_TEXTURE_2D);
2963
2964 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
2965 if (gl_info->supported[EXT_TEXTURE_LOD_BIAS])
2966 gl_info->gl_ops.gl.p_glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, 0.0f);
2967
2968 gl_info->gl_ops.gl.p_glMatrixMode(GL_TEXTURE);
2969 gl_info->gl_ops.gl.p_glLoadIdentity();
2970
2971 /* Setup transforms. */
2972 gl_info->gl_ops.gl.p_glMatrixMode(GL_MODELVIEW);
2973 gl_info->gl_ops.gl.p_glLoadIdentity();
2974 context_invalidate_state(context, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)));
2975 context_apply_blit_projection(context, context->blit_w, context->blit_h);
2976 context_invalidate_state(context, STATE_TRANSFORM(WINED3D_TS_PROJECTION));
2977
2978 /* Other misc states. */
2979 gl_info->gl_ops.gl.p_glDisable(GL_LIGHTING);
2980 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_LIGHTING));
2981 glDisableWINE(GL_FOG);
2982 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_FOGENABLE));
2983
2984 if (gl_info->supported[EXT_SECONDARY_COLOR])
2985 {
2986 gl_info->gl_ops.gl.p_glDisable(GL_COLOR_SUM_EXT);
2987 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SPECULARENABLE));
2988 }
2989 checkGLcall("ffp blit state application");
2990 }
2991
2992 static BOOL have_framebuffer_attachment(unsigned int rt_count, struct wined3d_rendertarget_view * const *rts,
2993 const struct wined3d_rendertarget_view *ds)
2994 {
2995 unsigned int i;
2996
2997 if (ds)
2998 return TRUE;
2999
3000 for (i = 0; i < rt_count; ++i)
3001 {
3002 if (rts[i] && rts[i]->format->id != WINED3DFMT_NULL)
3003 return TRUE;
3004 }
3005
3006 return FALSE;
3007 }
3008
3009 /* Context activation is done by the caller. */
3010 BOOL context_apply_clear_state(struct wined3d_context *context, const struct wined3d_state *state,
3011 UINT rt_count, const struct wined3d_fb_state *fb)
3012 {
3013 struct wined3d_rendertarget_view * const *rts = fb->render_targets;
3014 struct wined3d_rendertarget_view *dsv = fb->depth_stencil;
3015 const struct wined3d_gl_info *gl_info = context->gl_info;
3016 DWORD rt_mask = 0, *cur_mask;
3017 unsigned int i;
3018
3019 if (isStateDirty(context, STATE_FRAMEBUFFER) || fb != state->fb
3020 || rt_count != gl_info->limits.buffers)
3021 {
3022 if (!have_framebuffer_attachment(rt_count, rts, dsv))
3023 {
3024 WARN("Invalid render target config, need at least one attachment.\n");
3025 return FALSE;
3026 }
3027
3028 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3029 {
3030 struct wined3d_rendertarget_info ds_info = {{0}};
3031
3032 context_validate_onscreen_formats(context, dsv);
3033
3034 if (!rt_count || wined3d_resource_is_offscreen(rts[0]->resource))
3035 {
3036 memset(context->blit_targets, 0, sizeof(context->blit_targets));
3037 for (i = 0; i < rt_count; ++i)
3038 {
3039 if (rts[i])
3040 {
3041 struct wined3d_rendertarget_view_gl *rtv_gl = wined3d_rendertarget_view_gl(rts[i]);
3042 context->blit_targets[i].gl_view = rtv_gl->gl_view;
3043 context->blit_targets[i].resource = rtv_gl->v.resource;
3044 context->blit_targets[i].sub_resource_idx = rtv_gl->v.sub_resource_idx;
3045 context->blit_targets[i].layer_count = rtv_gl->v.layer_count;
3046 }
3047 if (rts[i] && rts[i]->format->id != WINED3DFMT_NULL)
3048 rt_mask |= (1u << i);
3049 }
3050
3051 if (dsv)
3052 {
3053 struct wined3d_rendertarget_view_gl *dsv_gl = wined3d_rendertarget_view_gl(dsv);
3054 ds_info.gl_view = dsv_gl->gl_view;
3055 ds_info.resource = dsv_gl->v.resource;
3056 ds_info.sub_resource_idx = dsv_gl->v.sub_resource_idx;
3057 ds_info.layer_count = dsv_gl->v.layer_count;
3058 }
3059
3060 context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets, &ds_info,
3061 rt_count ? rts[0]->resource->draw_binding : 0,
3062 dsv ? dsv->resource->draw_binding : 0);
3063 }
3064 else
3065 {
3066 context_apply_fbo_state(context, GL_FRAMEBUFFER, NULL, &ds_info,
3067 WINED3D_LOCATION_DRAWABLE, WINED3D_LOCATION_DRAWABLE);
3068 rt_mask = context_generate_rt_mask_from_resource(rts[0]->resource);
3069 }
3070
3071 /* If the framebuffer is not the device's fb the device's fb has to be reapplied
3072 * next draw. Otherwise we could mark the framebuffer state clean here, once the
3073 * state management allows this */
3074 context_invalidate_state(context, STATE_FRAMEBUFFER);
3075 }
3076 else
3077 {
3078 rt_mask = context_generate_rt_mask_no_fbo(context, rt_count ? rts[0]->resource : NULL);
3079 }
3080 }
3081 else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO
3082 && (!rt_count || wined3d_resource_is_offscreen(rts[0]->resource)))
3083 {
3084 for (i = 0; i < rt_count; ++i)
3085 {
3086 if (rts[i] && rts[i]->format->id != WINED3DFMT_NULL)
3087 rt_mask |= (1u << i);
3088 }
3089 }
3090 else
3091 {
3092 rt_mask = context_generate_rt_mask_no_fbo(context, rt_count ? rts[0]->resource : NULL);
3093 }
3094
3095 cur_mask = context->current_fbo ? &context->current_fbo->rt_mask : &context->draw_buffers_mask;
3096
3097 if (rt_mask != *cur_mask)
3098 {
3099 context_apply_draw_buffers(context, rt_mask);
3100 *cur_mask = rt_mask;
3101 context_invalidate_state(context, STATE_FRAMEBUFFER);
3102 }
3103
3104 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3105 {
3106 context_check_fbo_status(context, GL_FRAMEBUFFER);
3107 }
3108
3109 context->last_was_blit = FALSE;
3110 context->last_was_ffp_blit = FALSE;
3111
3112 /* Blending and clearing should be orthogonal, but tests on the nvidia
3113 * driver show that disabling blending when clearing improves the clearing
3114 * performance incredibly. */
3115 gl_info->gl_ops.gl.p_glDisable(GL_BLEND);
3116 gl_info->gl_ops.gl.p_glEnable(GL_SCISSOR_TEST);
3117 if (rt_count && gl_info->supported[ARB_FRAMEBUFFER_SRGB])
3118 {
3119 if (needs_srgb_write(context, state, fb))
3120 gl_info->gl_ops.gl.p_glEnable(GL_FRAMEBUFFER_SRGB);
3121 else
3122 gl_info->gl_ops.gl.p_glDisable(GL_FRAMEBUFFER_SRGB);
3123 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE));
3124 }
3125 checkGLcall("setting up state for clear");
3126
3127 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE));
3128 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE));
3129 context_invalidate_state(context, STATE_SCISSORRECT);
3130
3131 return TRUE;
3132 }
3133
3134 static unsigned int find_draw_buffers_mask(const struct wined3d_context *context, const struct wined3d_state *state)
3135 {
3136 struct wined3d_rendertarget_view * const *rts = state->fb->render_targets;
3137 struct wined3d_shader *ps = state->shader[WINED3D_SHADER_TYPE_PIXEL];
3138 const struct wined3d_gl_info *gl_info = context->gl_info;
3139 unsigned int rt_mask, mask;
3140 unsigned int i;
3141
3142 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
3143 return context_generate_rt_mask_no_fbo(context, rts[0]->resource);
3144 else if (!context->render_offscreen)
3145 return context_generate_rt_mask_from_resource(rts[0]->resource);
3146
3147 rt_mask = ps ? ps->reg_maps.rt_mask : 1;
3148 rt_mask &= (1u << gl_info->limits.buffers) - 1;
3149
3150 mask = rt_mask;
3151 while (mask)
3152 {
3153 i = wined3d_bit_scan(&mask);
3154 if (!rts[i] || rts[i]->format->id == WINED3DFMT_NULL)
3155 rt_mask &= ~(1u << i);
3156 }
3157
3158 return rt_mask;
3159 }
3160
3161 /* Context activation is done by the caller. */
3162 void context_state_fb(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
3163 {
3164 unsigned int rt_mask = find_draw_buffers_mask(context, state);
3165 const struct wined3d_fb_state *fb = state->fb;
3166 DWORD color_location = 0;
3167 DWORD *cur_mask;
3168
3169 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3170 {
3171 struct wined3d_rendertarget_info ds_info = {{0}};
3172
3173 if (!context->render_offscreen)
3174 {
3175 context_apply_fbo_state(context, GL_FRAMEBUFFER, NULL, &ds_info,
3176 WINED3D_LOCATION_DRAWABLE, WINED3D_LOCATION_DRAWABLE);
3177 }
3178 else
3179 {
3180 const struct wined3d_rendertarget_view_gl *view_gl;
3181 unsigned int i;
3182
3183 memset(context->blit_targets, 0, sizeof(context->blit_targets));
3184 for (i = 0; i < context->gl_info->limits.buffers; ++i)
3185 {
3186 if (!fb->render_targets[i])
3187 continue;
3188
3189 view_gl = wined3d_rendertarget_view_gl(fb->render_targets[i]);
3190 context->blit_targets[i].gl_view = view_gl->gl_view;
3191 context->blit_targets[i].resource = view_gl->v.resource;
3192 context->blit_targets[i].sub_resource_idx = view_gl->v.sub_resource_idx;
3193 context->blit_targets[i].layer_count = view_gl->v.layer_count;
3194
3195 if (!color_location)
3196 color_location = view_gl->v.resource->draw_binding;
3197 }
3198
3199 if (fb->depth_stencil)
3200 {
3201 view_gl = wined3d_rendertarget_view_gl(fb->depth_stencil);
3202 ds_info.gl_view = view_gl->gl_view;
3203 ds_info.resource = view_gl->v.resource;
3204 ds_info.sub_resource_idx = view_gl->v.sub_resource_idx;
3205 ds_info.layer_count = view_gl->v.layer_count;
3206 }
3207
3208 context_apply_fbo_state(context, GL_FRAMEBUFFER, context->blit_targets, &ds_info,
3209 color_location, fb->depth_stencil ? fb->depth_stencil->resource->draw_binding : 0);
3210 }
3211 }
3212
3213 cur_mask = context->current_fbo ? &context->current_fbo->rt_mask : &context->draw_buffers_mask;
3214 if (rt_mask != *cur_mask)
3215 {
3216 context_apply_draw_buffers(context, rt_mask);
3217 *cur_mask = rt_mask;
3218 }
3219 context->constant_update_mask |= WINED3D_SHADER_CONST_PS_Y_CORR;
3220 }
3221
3222 static void context_map_stage(struct wined3d_context *context, DWORD stage, DWORD unit)
3223 {
3224 DWORD i = context->rev_tex_unit_map[unit];
3225 DWORD j = context->tex_unit_map[stage];
3226
3227 TRACE("Mapping stage %u to unit %u.\n", stage, unit);
3228 context->tex_unit_map[stage] = unit;
3229 if (i != WINED3D_UNMAPPED_STAGE && i != stage)
3230 context->tex_unit_map[i] = WINED3D_UNMAPPED_STAGE;
3231
3232 context->rev_tex_unit_map[unit] = stage;
3233 if (j != WINED3D_UNMAPPED_STAGE && j != unit)
3234 context->rev_tex_unit_map[j] = WINED3D_UNMAPPED_STAGE;
3235 }
3236
3237 static void context_invalidate_texture_stage(struct wined3d_context *context, DWORD stage)
3238 {
3239 DWORD i;
3240
3241 for (i = 0; i <= WINED3D_HIGHEST_TEXTURE_STATE; ++i)
3242 context_invalidate_state(context, STATE_TEXTURESTAGE(stage, i));
3243 }
3244
3245 static void context_update_fixed_function_usage_map(struct wined3d_context *context,
3246 const struct wined3d_state *state)
3247 {
3248 UINT i, start, end;
3249
3250 context->fixed_function_usage_map = 0;
3251 for (i = 0; i < WINED3D_MAX_TEXTURES; ++i)
3252 {
3253 enum wined3d_texture_op color_op = state->texture_states[i][WINED3D_TSS_COLOR_OP];
3254 enum wined3d_texture_op alpha_op = state->texture_states[i][WINED3D_TSS_ALPHA_OP];
3255 DWORD color_arg1 = state->texture_states[i][WINED3D_TSS_COLOR_ARG1] & WINED3DTA_SELECTMASK;
3256 DWORD color_arg2 = state->texture_states[i][WINED3D_TSS_COLOR_ARG2] & WINED3DTA_SELECTMASK;
3257 DWORD color_arg3 = state->texture_states[i][WINED3D_TSS_COLOR_ARG0] & WINED3DTA_SELECTMASK;
3258 DWORD alpha_arg1 = state->texture_states[i][WINED3D_TSS_ALPHA_ARG1] & WINED3DTA_SELECTMASK;
3259 DWORD alpha_arg2 = state->texture_states[i][WINED3D_TSS_ALPHA_ARG2] & WINED3DTA_SELECTMASK;
3260 DWORD alpha_arg3 = state->texture_states[i][WINED3D_TSS_ALPHA_ARG0] & WINED3DTA_SELECTMASK;
3261
3262 /* Not used, and disable higher stages. */
3263 if (color_op == WINED3D_TOP_DISABLE)
3264 break;
3265
3266 if (((color_arg1 == WINED3DTA_TEXTURE) && color_op != WINED3D_TOP_SELECT_ARG2)
3267 || ((color_arg2 == WINED3DTA_TEXTURE) && color_op != WINED3D_TOP_SELECT_ARG1)
3268 || ((color_arg3 == WINED3DTA_TEXTURE)
3269 && (color_op == WINED3D_TOP_MULTIPLY_ADD || color_op == WINED3D_TOP_LERP))
3270 || ((alpha_arg1 == WINED3DTA_TEXTURE) && alpha_op != WINED3D_TOP_SELECT_ARG2)
3271 || ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3D_TOP_SELECT_ARG1)
3272 || ((alpha_arg3 == WINED3DTA_TEXTURE)
3273 && (alpha_op == WINED3D_TOP_MULTIPLY_ADD || alpha_op == WINED3D_TOP_LERP)))
3274 context->fixed_function_usage_map |= (1u << i);
3275
3276 if ((color_op == WINED3D_TOP_BUMPENVMAP || color_op == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
3277 && i < WINED3D_MAX_TEXTURES - 1)
3278 context->fixed_function_usage_map |= (1u << (i + 1));
3279 }
3280
3281 if (i < context->lowest_disabled_stage)
3282 {
3283 start = i;
3284 end = context->lowest_disabled_stage;
3285 }
3286 else
3287 {
3288 start = context->lowest_disabled_stage;
3289 end = i;
3290 }
3291
3292 context->lowest_disabled_stage = i;
3293 for (i = start + 1; i < end; ++i)
3294 {
3295 context_invalidate_state(context, STATE_TEXTURESTAGE(i, WINED3D_TSS_COLOR_OP));
3296 }
3297 }
3298
3299 static void context_map_fixed_function_samplers(struct wined3d_context *context,
3300 const struct wined3d_state *state)
3301 {
3302 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
3303 unsigned int i, tex;
3304 WORD ffu_map;
3305
3306 ffu_map = context->fixed_function_usage_map;
3307
3308 if (d3d_info->limits.ffp_textures == d3d_info->limits.ffp_blend_stages
3309 || context->lowest_disabled_stage <= d3d_info->limits.ffp_textures)
3310 {
3311 for (i = 0; ffu_map; ffu_map >>= 1, ++i)
3312 {
3313 if (!(ffu_map & 1))
3314 continue;
3315
3316 if (context->tex_unit_map[i] != i)
3317 {
3318 context_map_stage(context, i, i);
3319 context_invalidate_state(context, STATE_SAMPLER(i));
3320 context_invalidate_texture_stage(context, i);
3321 }
3322 }
3323 return;
3324 }
3325
3326 /* Now work out the mapping */
3327 tex = 0;
3328 for (i = 0; ffu_map; ffu_map >>= 1, ++i)
3329 {
3330 if (!(ffu_map & 1))
3331 continue;
3332
3333 if (context->tex_unit_map[i] != tex)
3334 {
3335 context_map_stage(context, i, tex);
3336 context_invalidate_state(context, STATE_SAMPLER(i));
3337 context_invalidate_texture_stage(context, i);
3338 }
3339
3340 ++tex;
3341 }
3342 }
3343
3344 static void context_map_psamplers(struct wined3d_context *context, const struct wined3d_state *state)
3345 {
3346 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
3347 const struct wined3d_shader_resource_info *resource_info =
3348 state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.resource_info;
3349 unsigned int i;
3350
3351 for (i = 0; i < WINED3D_MAX_FRAGMENT_SAMPLERS; ++i)
3352 {
3353 if (resource_info[i].type && context->tex_unit_map[i] != i)
3354 {
3355 context_map_stage(context, i, i);
3356 context_invalidate_state(context, STATE_SAMPLER(i));
3357 if (i < d3d_info->limits.ffp_blend_stages)
3358 context_invalidate_texture_stage(context, i);
3359 }
3360 }
3361 }
3362
3363 static BOOL context_unit_free_for_vs(const struct wined3d_context *context,
3364 const struct wined3d_shader_resource_info *ps_resource_info, DWORD unit)
3365 {
3366 DWORD current_mapping = context->rev_tex_unit_map[unit];
3367
3368 /* Not currently used */
3369 if (current_mapping == WINED3D_UNMAPPED_STAGE)
3370 return TRUE;
3371
3372 if (current_mapping < WINED3D_MAX_FRAGMENT_SAMPLERS)
3373 {
3374 /* Used by a fragment sampler */
3375
3376 if (!ps_resource_info)
3377 {
3378 /* No pixel shader, check fixed function */
3379 return current_mapping >= WINED3D_MAX_TEXTURES || !(context->fixed_function_usage_map & (1u << current_mapping));
3380 }
3381
3382 /* Pixel shader, check the shader's sampler map */
3383 return !ps_resource_info[current_mapping].type;
3384 }
3385
3386 return TRUE;
3387 }
3388
3389 static void context_map_vsamplers(struct wined3d_context *context, BOOL ps, const struct wined3d_state *state)
3390 {
3391 const struct wined3d_shader_resource_info *vs_resource_info =
3392 state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.resource_info;
3393 const struct wined3d_shader_resource_info *ps_resource_info = NULL;
3394 const struct wined3d_gl_info *gl_info = context->gl_info;
3395 int start = min(WINED3D_MAX_COMBINED_SAMPLERS, gl_info->limits.graphics_samplers) - 1;
3396 int i;
3397
3398 /* Note that we only care if a resource is used or not, not the
3399 * resource's specific type. Otherwise we'd need to call
3400 * shader_update_samplers() here for 1.x pixelshaders. */
3401 if (ps)
3402 ps_resource_info = state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.resource_info;
3403
3404 for (i = 0; i < WINED3D_MAX_VERTEX_SAMPLERS; ++i)
3405 {
3406 DWORD vsampler_idx = i + WINED3D_MAX_FRAGMENT_SAMPLERS;
3407 if (vs_resource_info[i].type)
3408 {
3409 while (start >= 0)
3410 {
3411 if (context_unit_free_for_vs(context, ps_resource_info, start))
3412 {
3413 if (context->tex_unit_map[vsampler_idx] != start)
3414 {
3415 context_map_stage(context, vsampler_idx, start);
3416 context_invalidate_state(context, STATE_SAMPLER(vsampler_idx));
3417 }
3418
3419 --start;
3420 break;
3421 }
3422
3423 --start;
3424 }
3425 if (context->tex_unit_map[vsampler_idx] == WINED3D_UNMAPPED_STAGE)
3426 WARN("Couldn't find a free texture unit for vertex sampler %u.\n", i);
3427 }
3428 }
3429 }
3430
3431 static void context_update_tex_unit_map(struct wined3d_context *context, const struct wined3d_state *state)
3432 {
3433 const struct wined3d_gl_info *gl_info = context->gl_info;
3434 BOOL vs = use_vs(state);
3435 BOOL ps = use_ps(state);
3436
3437 if (!ps)
3438 context_update_fixed_function_usage_map(context, state);
3439
3440 /* Try to go for a 1:1 mapping of the samplers when possible. Pixel shaders
3441 * need a 1:1 map at the moment.
3442 * When the mapping of a stage is changed, sampler and ALL texture stage
3443 * states have to be reset. */
3444
3445 if (gl_info->limits.graphics_samplers >= WINED3D_MAX_COMBINED_SAMPLERS)
3446 return;
3447
3448 if (ps)
3449 context_map_psamplers(context, state);
3450 else
3451 context_map_fixed_function_samplers(context, state);
3452
3453 if (vs)
3454 context_map_vsamplers(context, ps, state);
3455 }
3456
3457 /* Context activation is done by the caller. */
3458 void context_state_drawbuf(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
3459 {
3460 DWORD rt_mask, *cur_mask;
3461
3462 if (isStateDirty(context, STATE_FRAMEBUFFER)) return;
3463
3464 cur_mask = context->current_fbo ? &context->current_fbo->rt_mask : &context->draw_buffers_mask;
3465 rt_mask = find_draw_buffers_mask(context, state);
3466 if (rt_mask != *cur_mask)
3467 {
3468 context_apply_draw_buffers(context, rt_mask);
3469 *cur_mask = rt_mask;
3470 }
3471 }
3472
3473 static BOOL fixed_get_input(BYTE usage, BYTE usage_idx, unsigned int *regnum)
3474 {
3475 if ((usage == WINED3D_DECL_USAGE_POSITION || usage == WINED3D_DECL_USAGE_POSITIONT) && !usage_idx)
3476 *regnum = WINED3D_FFP_POSITION;
3477 else if (usage == WINED3D_DECL_USAGE_BLEND_WEIGHT && !usage_idx)
3478 *regnum = WINED3D_FFP_BLENDWEIGHT;
3479 else if (usage == WINED3D_DECL_USAGE_BLEND_INDICES && !usage_idx)
3480 *regnum = WINED3D_FFP_BLENDINDICES;
3481 else if (usage == WINED3D_DECL_USAGE_NORMAL && !usage_idx)
3482 *regnum = WINED3D_FFP_NORMAL;
3483 else if (usage == WINED3D_DECL_USAGE_PSIZE && !usage_idx)
3484 *regnum = WINED3D_FFP_PSIZE;
3485 else if (usage == WINED3D_DECL_USAGE_COLOR && !usage_idx)
3486 *regnum = WINED3D_FFP_DIFFUSE;
3487 else if (usage == WINED3D_DECL_USAGE_COLOR && usage_idx == 1)
3488 *regnum = WINED3D_FFP_SPECULAR;
3489 else if (usage == WINED3D_DECL_USAGE_TEXCOORD && usage_idx < WINED3DDP_MAXTEXCOORD)
3490 *regnum = WINED3D_FFP_TEXCOORD0 + usage_idx;
3491 else
3492 {
3493 WARN("Unsupported input stream [usage=%s, usage_idx=%u].\n", debug_d3ddeclusage(usage), usage_idx);
3494 *regnum = ~0u;
3495 return FALSE;
3496 }
3497
3498 return TRUE;
3499 }
3500
3501 /* Context activation is done by the caller. */
3502 void wined3d_stream_info_from_declaration(struct wined3d_stream_info *stream_info,
3503 const struct wined3d_state *state, const struct wined3d_d3d_info *d3d_info)
3504 {
3505 /* We need to deal with frequency data! */
3506 struct wined3d_vertex_declaration *declaration = state->vertex_declaration;
3507 BOOL generic_attributes = d3d_info->ffp_generic_attributes;
3508 BOOL use_vshader = use_vs(state);
3509 unsigned int i;
3510
3511 stream_info->use_map = 0;
3512 stream_info->swizzle_map = 0;
3513 stream_info->position_transformed = 0;
3514
3515 if (!declaration)
3516 return;
3517
3518 stream_info->position_transformed = declaration->position_transformed;
3519
3520 /* Translate the declaration into strided data. */
3521 for (i = 0; i < declaration->element_count; ++i)
3522 {
3523 const struct wined3d_vertex_declaration_element *element = &declaration->elements[i];
3524 const struct wined3d_stream_state *stream = &state->streams[element->input_slot];
3525 BOOL stride_used;
3526 unsigned int idx;
3527
3528 TRACE("%p Element %p (%u of %u).\n", declaration->elements,
3529 element, i + 1, declaration->element_count);
3530
3531 if (!stream->buffer)
3532 continue;
3533
3534 TRACE("offset %u input_slot %u usage_idx %d.\n", element->offset, element->input_slot, element->usage_idx);
3535
3536 if (use_vshader)
3537 {
3538 if (element->output_slot == WINED3D_OUTPUT_SLOT_UNUSED)
3539 {
3540 stride_used = FALSE;
3541 }
3542 else if (element->output_slot == WINED3D_OUTPUT_SLOT_SEMANTIC)
3543 {
3544 /* TODO: Assuming vertexdeclarations are usually used with the
3545 * same or a similar shader, it might be worth it to store the
3546 * last used output slot and try that one first. */
3547 stride_used = vshader_get_input(state->shader[WINED3D_SHADER_TYPE_VERTEX],
3548 element->usage, element->usage_idx, &idx);
3549 }
3550 else
3551 {
3552 idx = element->output_slot;
3553 stride_used = TRUE;
3554 }
3555 }
3556 else
3557 {
3558 if (!generic_attributes && !element->ffp_valid)
3559 {
3560 WARN("Skipping unsupported fixed function element of format %s and usage %s.\n",
3561 debug_d3dformat(element->format->id), debug_d3ddeclusage(element->usage));
3562 stride_used = FALSE;
3563 }
3564 else
3565 {
3566 stride_used = fixed_get_input(element->usage, element->usage_idx, &idx);
3567 }
3568 }
3569
3570 if (stride_used)
3571 {
3572 TRACE("Load %s array %u [usage %s, usage_idx %u, "
3573 "input_slot %u, offset %u, stride %u, format %s, class %s, step_rate %u].\n",
3574 use_vshader ? "shader": "fixed function", idx,
3575 debug_d3ddeclusage(element->usage), element->usage_idx, element->input_slot,
3576 element->offset, stream->stride, debug_d3dformat(element->format->id),
3577 debug_d3dinput_classification(element->input_slot_class), element->instance_data_step_rate);
3578
3579 stream_info->elements[idx].format = element->format;
3580 stream_info->elements[idx].data.buffer_object = 0;
3581 stream_info->elements[idx].data.addr = (BYTE *)NULL + stream->offset + element->offset;
3582 stream_info->elements[idx].stride = stream->stride;
3583 stream_info->elements[idx].stream_idx = element->input_slot;
3584 if (stream->flags & WINED3DSTREAMSOURCE_INSTANCEDATA)
3585 {
3586 stream_info->elements[idx].divisor = 1;
3587 }
3588 else if (element->input_slot_class == WINED3D_INPUT_PER_INSTANCE_DATA)
3589 {
3590 stream_info->elements[idx].divisor = element->instance_data_step_rate;
3591 if (!element->instance_data_step_rate)
3592 FIXME("Instance step rate 0 not implemented.\n");
3593 }
3594 else
3595 {
3596 stream_info->elements[idx].divisor = 0;
3597 }
3598
3599 if (!d3d_info->vertex_bgra && element->format->id == WINED3DFMT_B8G8R8A8_UNORM)
3600 {
3601 stream_info->swizzle_map |= 1u << idx;
3602 }
3603 stream_info->use_map |= 1u << idx;
3604 }
3605 }
3606 }
3607
3608 /* Context activation is done by the caller. */
3609 static void context_update_stream_info(struct wined3d_context *context, const struct wined3d_state *state)
3610 {
3611 struct wined3d_stream_info *stream_info = &context->stream_info;
3612 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
3613 const struct wined3d_gl_info *gl_info = context->gl_info;
3614 DWORD prev_all_vbo = stream_info->all_vbo;
3615 unsigned int i;
3616 WORD map;
3617
3618 wined3d_stream_info_from_declaration(stream_info, state, d3d_info);
3619
3620 stream_info->all_vbo = 1;
3621 context->buffer_fence_count = 0;
3622 for (i = 0, map = stream_info->use_map; map; map >>= 1, ++i)
3623 {
3624 struct wined3d_stream_info_element *element;
3625 struct wined3d_bo_address data;
3626 struct wined3d_buffer *buffer;
3627
3628 if (!(map & 1))
3629 continue;
3630
3631 element = &stream_info->elements[i];
3632 buffer = state->streams[element->stream_idx].buffer;
3633
3634 /* We can't use VBOs if the base vertex index is negative. OpenGL
3635 * doesn't accept negative offsets (or rather offsets bigger than the
3636 * VBO, because the pointer is unsigned), so use system memory
3637 * sources. In most sane cases the pointer - offset will still be > 0,
3638 * otherwise it will wrap around to some big value. Hope that with the
3639 * indices the driver wraps it back internally. If not,
3640 * draw_primitive_immediate_mode() is needed, including a vertex buffer
3641 * path. */
3642 if (state->load_base_vertex_index < 0)
3643 {
3644 WARN_(d3d_perf)("load_base_vertex_index is < 0 (%d), not using VBOs.\n",
3645 state->load_base_vertex_index);
3646 element->data.buffer_object = 0;
3647 element->data.addr += (ULONG_PTR)wined3d_buffer_load_sysmem(buffer, context);
3648 if ((UINT_PTR)element->data.addr < -state->load_base_vertex_index * element->stride)
3649 FIXME("System memory vertex data load offset is negative!\n");
3650 }
3651 else
3652 {
3653 wined3d_buffer_load(buffer, context, state);
3654 wined3d_buffer_get_memory(buffer, &data, buffer->locations);
3655 element->data.buffer_object = data.buffer_object;
3656 element->data.addr += (ULONG_PTR)data.addr;
3657 }
3658
3659 if (!element->data.buffer_object)
3660 stream_info->all_vbo = 0;
3661
3662 if (buffer->fence)
3663 context->buffer_fences[context->buffer_fence_count++] = buffer->fence;
3664
3665 TRACE("Load array %u %s.\n", i, debug_bo_address(&element->data));
3666 }
3667
3668 if (prev_all_vbo != stream_info->all_vbo)
3669 context_invalidate_state(context, STATE_INDEXBUFFER);
3670
3671 context->use_immediate_mode_draw = FALSE;
3672
3673 if (stream_info->all_vbo)
3674 return;
3675
3676 if (use_vs(state))
3677 {
3678 if (state->vertex_declaration->have_half_floats && !gl_info->supported[ARB_HALF_FLOAT_VERTEX])
3679 {
3680 TRACE("Using immediate mode draw with vertex shaders for FLOAT16 conversion.\n");
3681 context->use_immediate_mode_draw = TRUE;
3682 }
3683 }
3684 else
3685 {
3686 WORD slow_mask = -!d3d_info->ffp_generic_attributes & (1u << WINED3D_FFP_PSIZE);
3687 slow_mask |= -(!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && !d3d_info->ffp_generic_attributes)
3688 & ((1u << WINED3D_FFP_DIFFUSE) | (1u << WINED3D_FFP_SPECULAR) | (1u << WINED3D_FFP_BLENDWEIGHT));
3689
3690 if ((stream_info->position_transformed && !d3d_info->xyzrhw)
3691 || (stream_info->use_map & slow_mask))
3692 context->use_immediate_mode_draw = TRUE;
3693 }
3694 }
3695
3696 /* Context activation is done by the caller. */
3697 static void context_preload_texture(struct wined3d_context *context,
3698 const struct wined3d_state *state, unsigned int idx)
3699 {
3700 struct wined3d_texture *texture;
3701
3702 if (!(texture = state->textures[idx]))
3703 return;
3704
3705 wined3d_texture_load(texture, context, is_srgb_enabled(state->sampler_states[idx]));
3706 }
3707
3708 /* Context activation is done by the caller. */
3709 static void context_preload_textures(struct wined3d_context *context, const struct wined3d_state *state)
3710 {
3711 unsigned int i;
3712
3713 if (use_vs(state))
3714 {
3715 for (i = 0; i < WINED3D_MAX_VERTEX_SAMPLERS; ++i)
3716 {
3717 if (state->shader[WINED3D_SHADER_TYPE_VERTEX]->reg_maps.resource_info[i].type)
3718 context_preload_texture(context, state, WINED3D_MAX_FRAGMENT_SAMPLERS + i);
3719 }
3720 }
3721
3722 if (use_ps(state))
3723 {
3724 for (i = 0; i < WINED3D_MAX_FRAGMENT_SAMPLERS; ++i)
3725 {
3726 if (state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.resource_info[i].type)
3727 context_preload_texture(context, state, i);
3728 }
3729 }
3730 else
3731 {
3732 WORD ffu_map = context->fixed_function_usage_map;
3733
3734 for (i = 0; ffu_map; ffu_map >>= 1, ++i)
3735 {
3736 if (ffu_map & 1)
3737 context_preload_texture(context, state, i);
3738 }
3739 }
3740 }
3741
3742 static void context_load_shader_resources(struct wined3d_context *context, const struct wined3d_state *state,
3743 unsigned int shader_mask)
3744 {
3745 struct wined3d_shader_sampler_map_entry *entry;
3746 struct wined3d_shader_resource_view *view;
3747 struct wined3d_shader *shader;
3748 unsigned int i, j;
3749
3750 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
3751 {
3752 if (!(shader_mask & (1u << i)))
3753 continue;
3754
3755 if (!(shader = state->shader[i]))
3756 continue;
3757
3758 for (j = 0; j < WINED3D_MAX_CBS; ++j)
3759 {
3760 if (state->cb[i][j])
3761 wined3d_buffer_load(state->cb[i][j], context, state);
3762 }
3763
3764 for (j = 0; j < shader->reg_maps.sampler_map.count; ++j)
3765 {
3766 entry = &shader->reg_maps.sampler_map.entries[j];
3767
3768 if (!(view = state->shader_resource_view[i][entry->resource_idx]))
3769 continue;
3770
3771 if (view->resource->type == WINED3D_RTYPE_BUFFER)
3772 wined3d_buffer_load(buffer_from_resource(view->resource), context, state);
3773 else
3774 wined3d_texture_load(texture_from_resource(view->resource), context, FALSE);
3775 }
3776 }
3777 }
3778
3779 static void context_bind_shader_resources(struct wined3d_context *context,
3780 const struct wined3d_state *state, enum wined3d_shader_type shader_type)
3781 {
3782 unsigned int bind_idx, shader_sampler_count, base, count, i;
3783 const struct wined3d_device *device = context->device;
3784 struct wined3d_shader_sampler_map_entry *entry;
3785 struct wined3d_shader_resource_view *view;
3786 const struct wined3d_shader *shader;
3787 struct wined3d_sampler *sampler;
3788 const DWORD *tex_unit_map;
3789
3790 if (!(shader = state->shader[shader_type]))
3791 return;
3792
3793 tex_unit_map = context_get_tex_unit_mapping(context,
3794 &shader->reg_maps.shader_version, &base, &count);
3795
3796 shader_sampler_count = shader->reg_maps.sampler_map.count;
3797 if (shader_sampler_count > count)
3798 FIXME("Shader %p needs %u samplers, but only %u are supported.\n",
3799 shader, shader_sampler_count, count);
3800 count = min(shader_sampler_count, count);
3801
3802 for (i = 0; i < count; ++i)
3803 {
3804 entry = &shader->reg_maps.sampler_map.entries[i];
3805 bind_idx = base + entry->bind_idx;
3806 if (tex_unit_map)
3807 bind_idx = tex_unit_map[bind_idx];
3808
3809 if (!(view = state->shader_resource_view[shader_type][entry->resource_idx]))
3810 {
3811 WARN("No resource view bound at index %u, %u.\n", shader_type, entry->resource_idx);
3812 continue;
3813 }
3814
3815 if (entry->sampler_idx == WINED3D_SAMPLER_DEFAULT)
3816 sampler = device->default_sampler;
3817 else if (!(sampler = state->sampler[shader_type][entry->sampler_idx]))
3818 sampler = device->null_sampler;
3819 wined3d_shader_resource_view_gl_bind(wined3d_shader_resource_view_gl(view), bind_idx, sampler, context);
3820 }
3821 }
3822
3823 static void context_load_unordered_access_resources(struct wined3d_context *context,
3824 const struct wined3d_shader *shader, struct wined3d_unordered_access_view * const *views)
3825 {
3826 struct wined3d_unordered_access_view *view;
3827 struct wined3d_texture *texture;
3828 struct wined3d_buffer *buffer;
3829 unsigned int i;
3830
3831 context->uses_uavs = 0;
3832
3833 if (!shader)
3834 return;
3835
3836 for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
3837 {
3838 if (!(view = views[i]))
3839 continue;
3840
3841 if (view->resource->type == WINED3D_RTYPE_BUFFER)
3842 {
3843 buffer = buffer_from_resource(view->resource);
3844 wined3d_buffer_load_location(buffer, context, WINED3D_LOCATION_BUFFER);
3845 wined3d_unordered_access_view_invalidate_location(view, ~WINED3D_LOCATION_BUFFER);
3846 }
3847 else
3848 {
3849 texture = texture_from_resource(view->resource);
3850 wined3d_texture_load(texture, context, FALSE);
3851 wined3d_unordered_access_view_invalidate_location(view, ~WINED3D_LOCATION_TEXTURE_RGB);
3852 }
3853
3854 context->uses_uavs = 1;
3855 }
3856 }
3857
3858 static void context_bind_unordered_access_views(struct wined3d_context *context,
3859 const struct wined3d_shader *shader, struct wined3d_unordered_access_view * const *views)
3860 {
3861 const struct wined3d_gl_info *gl_info = context->gl_info;
3862 struct wined3d_unordered_access_view_gl *view_gl;
3863 const struct wined3d_format_gl *format_gl;
3864 GLuint texture_name;
3865 unsigned int i;
3866 GLint level;
3867
3868 if (!shader)
3869 return;
3870
3871 for (i = 0; i < MAX_UNORDERED_ACCESS_VIEWS; ++i)
3872 {
3873 if (!views[i])
3874 {
3875 if (shader->reg_maps.uav_resource_info[i].type)
3876 WARN("No unordered access view bound at index %u.\n", i);
3877 GL_EXTCALL(glBindImageTexture(i, 0, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R8));
3878 continue;
3879 }
3880
3881 view_gl = wined3d_unordered_access_view_gl(views[i]);
3882 if (view_gl->gl_view.name)
3883 {
3884 texture_name = view_gl->gl_view.name;
3885 level = 0;
3886 }
3887 else if (view_gl->v.resource->type != WINED3D_RTYPE_BUFFER)
3888 {
3889 struct wined3d_texture_gl *texture_gl = wined3d_texture_gl(texture_from_resource(view_gl->v.resource));
3890 texture_name = wined3d_texture_gl_get_texture_name(texture_gl, context, FALSE);
3891 level = view_gl->v.desc.u.texture.level_idx;
3892 }
3893 else
3894 {
3895 FIXME("Unsupported buffer unordered access view.\n");
3896 GL_EXTCALL(glBindImageTexture(i, 0, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R8));
3897 continue;
3898 }
3899
3900 format_gl = wined3d_format_gl(view_gl->v.format);
3901 GL_EXTCALL(glBindImageTexture(i, texture_name, level, GL_TRUE, 0, GL_READ_WRITE,
3902 format_gl->internal));
3903
3904 if (view_gl->counter_bo)
3905 GL_EXTCALL(glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, i, view_gl->counter_bo));
3906 }
3907 checkGLcall("Bind unordered access views");
3908 }
3909
3910 static void context_load_stream_output_buffers(struct wined3d_context *context,
3911 const struct wined3d_state *state)
3912 {
3913 unsigned int i;
3914
3915 for (i = 0; i < ARRAY_SIZE(state->stream_output); ++i)
3916 {
3917 struct wined3d_buffer *buffer;
3918 if (!(buffer = state->stream_output[i].buffer))
3919 continue;
3920
3921 wined3d_buffer_load(buffer, context, state);
3922 wined3d_buffer_invalidate_location(buffer, ~WINED3D_LOCATION_BUFFER);
3923 }
3924 }
3925
3926 /* Context activation is done by the caller. */
3927 static BOOL context_apply_draw_state(struct wined3d_context *context,
3928 const struct wined3d_device *device, const struct wined3d_state *state)
3929 {
3930 const struct wined3d_state_entry *state_table = context->state_table;
3931 const struct wined3d_gl_info *gl_info = context->gl_info;
3932 const struct wined3d_fb_state *fb = state->fb;
3933 unsigned int i;
3934 WORD map;
3935
3936 if (!have_framebuffer_attachment(gl_info->limits.buffers, fb->render_targets, fb->depth_stencil))
3937 {
3938 if (!gl_info->supported[ARB_FRAMEBUFFER_NO_ATTACHMENTS])
3939 {
3940 FIXME("OpenGL implementation does not support framebuffers with no attachments.\n");
3941 return FALSE;
3942 }
3943
3944 context_set_render_offscreen(context, TRUE);
3945 }
3946
3947 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && isStateDirty(context, STATE_FRAMEBUFFER))
3948 {
3949 context_validate_onscreen_formats(context, fb->depth_stencil);
3950 }
3951
3952 /* Preload resources before FBO setup. Texture preload in particular may
3953 * result in changes to the current FBO, due to using e.g. FBO blits for
3954 * updating a resource location. */
3955 context_update_tex_unit_map(context, state);
3956 context_preload_textures(context, state);
3957 context_load_shader_resources(context, state, ~(1u << WINED3D_SHADER_TYPE_COMPUTE));
3958 context_load_unordered_access_resources(context, state->shader[WINED3D_SHADER_TYPE_PIXEL],
3959 state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
3960 context_load_stream_output_buffers(context, state);
3961 /* TODO: Right now the dependency on the vertex shader is necessary
3962 * since wined3d_stream_info_from_declaration() depends on the reg_maps of
3963 * the current VS but maybe it's possible to relax the coupling in some
3964 * situations at least. */
3965 if (isStateDirty(context, STATE_VDECL) || isStateDirty(context, STATE_STREAMSRC)
3966 || isStateDirty(context, STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX)))
3967 {
3968 context_update_stream_info(context, state);
3969 }
3970 else
3971 {
3972 for (i = 0, map = context->stream_info.use_map; map; map >>= 1, ++i)
3973 {
3974 if (map & 1)
3975 wined3d_buffer_load(state->streams[context->stream_info.elements[i].stream_idx].buffer,
3976 context, state);
3977 }
3978 /* Loading the buffers above may have invalidated the stream info. */
3979 if (isStateDirty(context, STATE_STREAMSRC))
3980 context_update_stream_info(context, state);
3981 }
3982 if (state->index_buffer)
3983 {
3984 if (context->stream_info.all_vbo)
3985 wined3d_buffer_load(state->index_buffer, context, state);
3986 else
3987 wined3d_buffer_load_sysmem(state->index_buffer, context);
3988 }
3989
3990 for (i = 0; i < context->numDirtyEntries; ++i)
3991 {
3992 DWORD rep = context->dirtyArray[i];
3993 DWORD idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
3994 BYTE shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
3995 context->isStateDirty[idx] &= ~(1u << shift);
3996 state_table[rep].apply(context, state, rep);
3997 }
3998
3999 if (context->shader_update_mask & ~(1u << WINED3D_SHADER_TYPE_COMPUTE))
4000 {
4001 device->shader_backend->shader_select(device->shader_priv, context, state);
4002 context->shader_update_mask &= 1u << WINED3D_SHADER_TYPE_COMPUTE;
4003 }
4004
4005 if (context->constant_update_mask)
4006 {
4007 device->shader_backend->shader_load_constants(device->shader_priv, context, state);
4008 context->constant_update_mask = 0;
4009 }
4010
4011 if (context->update_shader_resource_bindings)
4012 {
4013 for (i = 0; i < WINED3D_SHADER_TYPE_GRAPHICS_COUNT; ++i)
4014 context_bind_shader_resources(context, state, i);
4015 context->update_shader_resource_bindings = 0;
4016 if (gl_info->limits.combined_samplers == gl_info->limits.graphics_samplers)
4017 context->update_compute_shader_resource_bindings = 1;
4018 }
4019
4020 if (context->update_unordered_access_view_bindings)
4021 {
4022 context_bind_unordered_access_views(context,
4023 state->shader[WINED3D_SHADER_TYPE_PIXEL],
4024 state->unordered_access_view[WINED3D_PIPELINE_GRAPHICS]);
4025 context->update_unordered_access_view_bindings = 0;
4026 context->update_compute_unordered_access_view_bindings = 1;
4027 }
4028
4029 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
4030 {
4031 context_check_fbo_status(context, GL_FRAMEBUFFER);
4032 }
4033
4034 context->numDirtyEntries = 0; /* This makes the whole list clean */
4035 context->last_was_blit = FALSE;
4036 context->last_was_ffp_blit = FALSE;
4037
4038 return TRUE;
4039 }
4040
4041 static void context_apply_compute_state(struct wined3d_context *context,
4042 const struct wined3d_device *device, const struct wined3d_state *state)
4043 {
4044 const struct wined3d_state_entry *state_table = context->state_table;
4045 const struct wined3d_gl_info *gl_info = context->gl_info;
4046 unsigned int state_id, i;
4047
4048 context_load_shader_resources(context, state, 1u << WINED3D_SHADER_TYPE_COMPUTE);
4049 context_load_unordered_access_resources(context, state->shader[WINED3D_SHADER_TYPE_COMPUTE],
4050 state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
4051
4052 for (i = 0, state_id = STATE_COMPUTE_OFFSET; i < ARRAY_SIZE(context->dirty_compute_states); ++i)
4053 {
4054 unsigned int dirty_mask = context->dirty_compute_states[i];
4055 while (dirty_mask)
4056 {
4057 unsigned int current_state_id = state_id + wined3d_bit_scan(&dirty_mask);
4058 state_table[current_state_id].apply(context, state, current_state_id);
4059 }
4060 state_id += sizeof(*context->dirty_compute_states) * CHAR_BIT;
4061 }
4062 memset(context->dirty_compute_states, 0, sizeof(*context->dirty_compute_states));
4063
4064 if (context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_COMPUTE))
4065 {
4066 device->shader_backend->shader_select_compute(device->shader_priv, context, state);
4067 context->shader_update_mask &= ~(1u << WINED3D_SHADER_TYPE_COMPUTE);
4068 }
4069
4070 if (context->update_compute_shader_resource_bindings)
4071 {
4072 context_bind_shader_resources(context, state, WINED3D_SHADER_TYPE_COMPUTE);
4073 context->update_compute_shader_resource_bindings = 0;
4074 if (gl_info->limits.combined_samplers == gl_info->limits.graphics_samplers)
4075 context->update_shader_resource_bindings = 1;
4076 }
4077
4078 if (context->update_compute_unordered_access_view_bindings)
4079 {
4080 context_bind_unordered_access_views(context,
4081 state->shader[WINED3D_SHADER_TYPE_COMPUTE],
4082 state->unordered_access_view[WINED3D_PIPELINE_COMPUTE]);
4083 context->update_compute_unordered_access_view_bindings = 0;
4084 context->update_unordered_access_view_bindings = 1;
4085 }
4086
4087 /* Updates to currently bound render targets aren't necessarily coherent
4088 * between the graphics and compute pipelines. Unbind any currently bound
4089 * FBO here to ensure preceding updates to its attachments by the graphics
4090 * pipeline are visible to the compute pipeline.
4091 *
4092 * Without this, the bloom effect in Nier:Automata is too bright on the
4093 * Mesa radeonsi driver, and presumably on other Mesa based drivers. */
4094 context_bind_fbo(context, GL_FRAMEBUFFER, 0);
4095 context_invalidate_state(context, STATE_FRAMEBUFFER);
4096
4097 context->last_was_blit = FALSE;
4098 context->last_was_ffp_blit = FALSE;
4099 }
4100
4101 static BOOL use_transform_feedback(const struct wined3d_state *state)
4102 {
4103 const struct wined3d_shader *shader;
4104 if (!(shader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY]))
4105 return FALSE;
4106 return shader->u.gs.so_desc.element_count;
4107 }
4108
4109 void context_end_transform_feedback(struct wined3d_context *context)
4110 {
4111 const struct wined3d_gl_info *gl_info = context->gl_info;
4112 if (context->transform_feedback_active)
4113 {
4114 GL_EXTCALL(glEndTransformFeedback());
4115 checkGLcall("glEndTransformFeedback");
4116 context->transform_feedback_active = 0;
4117 context->transform_feedback_paused = 0;
4118 }
4119 }
4120
4121 static void context_pause_transform_feedback(struct wined3d_context *context, BOOL force)
4122 {
4123 const struct wined3d_gl_info *gl_info = context->gl_info;
4124
4125 if (!context->transform_feedback_active || context->transform_feedback_paused)
4126 return;
4127
4128 if (gl_info->supported[ARB_TRANSFORM_FEEDBACK2])
4129 {
4130 GL_EXTCALL(glPauseTransformFeedback());
4131 checkGLcall("glPauseTransformFeedback");
4132 context->transform_feedback_paused = 1;
4133 return;
4134 }
4135
4136 WARN("Cannot pause transform feedback operations.\n");
4137
4138 if (force)
4139 context_end_transform_feedback(context);
4140 }
4141
4142 static void context_setup_target(struct wined3d_context *context,
4143 struct wined3d_texture *texture, unsigned int sub_resource_idx)
4144 {
4145 BOOL old_render_offscreen = context->render_offscreen, render_offscreen;
4146
4147 render_offscreen = wined3d_resource_is_offscreen(&texture->resource);
4148 if (context->current_rt.texture == texture
4149 && context->current_rt.sub_resource_idx == sub_resource_idx
4150 && render_offscreen == old_render_offscreen)
4151 return;
4152
4153 /* To compensate the lack of format switching with some offscreen rendering methods and on onscreen buffers
4154 * the alpha blend state changes with different render target formats. */
4155 if (!context->current_rt.texture)
4156 {
4157 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE));
4158 }
4159 else
4160 {
4161 const struct wined3d_format *old = context->current_rt.texture->resource.format;
4162 const struct wined3d_format *new = texture->resource.format;
4163
4164 if (old->id != new->id)
4165 {
4166 /* Disable blending when the alpha mask has changed and when a format doesn't support blending. */
4167 if ((old->alpha_size && !new->alpha_size) || (!old->alpha_size && new->alpha_size)
4168 || !(texture->resource.format_flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING))
4169 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE));
4170
4171 /* Update sRGB writing when switching between formats that do/do not support sRGB writing */
4172 if ((context->current_rt.texture->resource.format_flags & WINED3DFMT_FLAG_SRGB_WRITE)
4173 != (texture->resource.format_flags & WINED3DFMT_FLAG_SRGB_WRITE))
4174 context_invalidate_state(context, STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE));
4175 }
4176
4177 /* When switching away from an offscreen render target, and we're not
4178 * using FBOs, we have to read the drawable into the texture. This is
4179 * done via PreLoad (and WINED3D_LOCATION_DRAWABLE set on the surface).
4180 * There are some things that need care though. PreLoad needs a GL context,
4181 * and FindContext is called before the context is activated. It also
4182 * has to be called with the old rendertarget active, otherwise a
4183 * wrong drawable is read. */
4184 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
4185 && old_render_offscreen && (context->current_rt.texture != texture
4186 || context->current_rt.sub_resource_idx != sub_resource_idx))
4187 {
4188 struct wined3d_texture_gl *prev_texture = wined3d_texture_gl(context->current_rt.texture);
4189 unsigned int prev_sub_resource_idx = context->current_rt.sub_resource_idx;
4190
4191 /* Read the back buffer of the old drawable into the destination texture. */
4192 if (prev_texture->texture_srgb.name)
4193 wined3d_texture_load(&prev_texture->t, context, TRUE);
4194 wined3d_texture_load(&prev_texture->t, context, FALSE);
4195 wined3d_texture_invalidate_location(&prev_texture->t, prev_sub_resource_idx, WINED3D_LOCATION_DRAWABLE);
4196 }
4197 }
4198
4199 context->current_rt.texture = texture;
4200 context->current_rt.sub_resource_idx = sub_resource_idx;
4201 context_set_render_offscreen(context, render_offscreen);
4202 }
4203
4204 static void context_activate(struct wined3d_context *context,
4205 struct wined3d_texture *texture, unsigned int sub_resource_idx)
4206 {
4207 context_enter(context);
4208 context_update_window(context);
4209 context_setup_target(context, texture, sub_resource_idx);
4210 if (!context->valid)
4211 return;
4212
4213 if (context != context_get_current())
4214 {
4215 if (!context_set_current(context))
4216 ERR("Failed to activate the new context.\n");
4217 }
4218 else if (context->needs_set)
4219 {
4220 context_set_gl_context(context);
4221 }
4222 }
4223
4224 struct wined3d_context *context_acquire(const struct wined3d_device *device,
4225 struct wined3d_texture *texture, unsigned int sub_resource_idx)
4226 {
4227 struct wined3d_context *current_context = context_get_current();
4228 struct wined3d_context *context;
4229 BOOL swapchain_texture;
4230
4231 TRACE("device %p, texture %p, sub_resource_idx %u.\n", device, texture, sub_resource_idx);
4232
4233 wined3d_from_cs(device->cs);
4234
4235 if (current_context && current_context->destroyed)
4236 current_context = NULL;
4237
4238 swapchain_texture = texture && texture->swapchain;
4239 if (!texture)
4240 {
4241 if (current_context
4242 && current_context->current_rt.texture
4243 && current_context->device == device)
4244 {
4245 texture = current_context->current_rt.texture;
4246 sub_resource_idx = current_context->current_rt.sub_resource_idx;
4247 }
4248 else
4249 {
4250 struct wined3d_swapchain *swapchain = device->swapchains[0];
4251
4252 if (swapchain->back_buffers)
4253 texture = swapchain->back_buffers[0];
4254 else
4255 texture = swapchain->front_buffer;
4256 sub_resource_idx = 0;
4257 }
4258 }
4259
4260 if (current_context && current_context->current_rt.texture == texture)
4261 {
4262 context = current_context;
4263 }
4264 else if (swapchain_texture)
4265 {
4266 TRACE("Rendering onscreen.\n");
4267
4268 context = swapchain_get_context(texture->swapchain);
4269 }
4270 else
4271 {
4272 TRACE("Rendering offscreen.\n");
4273
4274 /* Stay with the current context if possible. Otherwise use the
4275 * context for the primary swapchain. */
4276 if (current_context && current_context->device == device)
4277 context = current_context;
4278 else
4279 context = swapchain_get_context(device->swapchains[0]);
4280 }
4281
4282 context_activate(context, texture, sub_resource_idx);
4283
4284 return context;
4285 }
4286
4287 struct wined3d_context *context_reacquire(const struct wined3d_device *device,
4288 struct wined3d_context *context)
4289 {
4290 struct wined3d_context *acquired_context;
4291
4292 wined3d_from_cs(device->cs);
4293
4294 if (!context || context->tid != GetCurrentThreadId())
4295 return NULL;
4296
4297 if (context->current_rt.texture)
4298 {
4299 context_activate(context, context->current_rt.texture, context->current_rt.sub_resource_idx);
4300 return context;
4301 }
4302
4303 acquired_context = context_acquire(device, NULL, 0);
4304 if (acquired_context != context)
4305 ERR("Acquired context %p instead of %p.\n", acquired_context, context);
4306 return acquired_context;
4307 }
4308
4309 void dispatch_compute(struct wined3d_device *device, const struct wined3d_state *state,
4310 const struct wined3d_dispatch_parameters *parameters)
4311 {
4312 const struct wined3d_gl_info *gl_info;
4313 struct wined3d_context *context;
4314
4315 context = context_acquire(device, NULL, 0);
4316 if (!context->valid)
4317 {
4318 context_release(context);
4319 WARN("Invalid context, skipping dispatch.\n");
4320 return;
4321 }
4322 gl_info = context->gl_info;
4323
4324 if (!gl_info->supported[ARB_COMPUTE_SHADER])
4325 {
4326 context_release(context);
4327 FIXME("OpenGL implementation does not support compute shaders.\n");
4328 return;
4329 }
4330
4331 if (parameters->indirect)
4332 wined3d_buffer_load(parameters->u.indirect.buffer, context, state);
4333
4334 context_apply_compute_state(context, device, state);
4335
4336 if (!state->shader[WINED3D_SHADER_TYPE_COMPUTE])
4337 {
4338 context_release(context);
4339 WARN("No compute shader bound, skipping dispatch.\n");
4340 return;
4341 }
4342
4343 if (parameters->indirect)
4344 {
4345 const struct wined3d_indirect_dispatch_parameters *indirect = &parameters->u.indirect;
4346 struct wined3d_buffer *buffer = indirect->buffer;
4347
4348 GL_EXTCALL(glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, wined3d_buffer_gl(buffer)->buffer_object));
4349 GL_EXTCALL(glDispatchComputeIndirect((GLintptr)indirect->offset));
4350 GL_EXTCALL(glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, 0));
4351 }
4352 else
4353 {
4354 const struct wined3d_direct_dispatch_parameters *direct = &parameters->u.direct;
4355 GL_EXTCALL(glDispatchCompute(direct->group_count_x, direct->group_count_y, direct->group_count_z));
4356 }
4357 checkGLcall("dispatch compute");
4358
4359 GL_EXTCALL(glMemoryBarrier(GL_ALL_BARRIER_BITS));
4360 checkGLcall("glMemoryBarrier");
4361
4362 context_release(context);
4363 }
4364
4365 /* Context activation is done by the caller. */
4366 static void draw_primitive_arrays(struct wined3d_context *context, const struct wined3d_state *state,
4367 const void *idx_data, unsigned int idx_size, int base_vertex_idx, unsigned int start_idx,
4368 unsigned int count, unsigned int start_instance, unsigned int instance_count)
4369 {
4370 const struct wined3d_ffp_attrib_ops *ops = &context->d3d_info->ffp_attrib_ops;
4371 GLenum idx_type = idx_size == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
4372 const struct wined3d_stream_info *si = &context->stream_info;
4373 unsigned int instanced_elements[ARRAY_SIZE(si->elements)];
4374 const struct wined3d_gl_info *gl_info = context->gl_info;
4375 unsigned int instanced_element_count = 0;
4376 GLenum mode = state->gl_primitive_type;
4377 const void *indices;
4378 unsigned int i, j;
4379
4380 indices = (const char *)idx_data + idx_size * start_idx;
4381
4382 if (!instance_count)
4383 {
4384 if (!idx_size)
4385 {
4386 gl_info->gl_ops.gl.p_glDrawArrays(mode, start_idx, count);
4387 checkGLcall("glDrawArrays");
4388 return;
4389 }
4390
4391 if (gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX])
4392 {
4393 GL_EXTCALL(glDrawElementsBaseVertex(mode, count, idx_type, indices, base_vertex_idx));
4394 checkGLcall("glDrawElementsBaseVertex");
4395 return;
4396 }
4397
4398 gl_info->gl_ops.gl.p_glDrawElements(mode, count, idx_type, indices);
4399 checkGLcall("glDrawElements");
4400 return;
4401 }
4402
4403 if (start_instance && !(gl_info->supported[ARB_BASE_INSTANCE] && gl_info->supported[ARB_INSTANCED_ARRAYS]))
4404 FIXME("Start instance (%u) not supported.\n", start_instance);
4405
4406 if (gl_info->supported[ARB_INSTANCED_ARRAYS])
4407 {
4408 if (!idx_size)
4409 {
4410 if (gl_info->supported[ARB_BASE_INSTANCE])
4411 {
4412 GL_EXTCALL(glDrawArraysInstancedBaseInstance(mode, start_idx, count, instance_count, start_instance));
4413 checkGLcall("glDrawArraysInstancedBaseInstance");
4414 return;
4415 }
4416
4417 GL_EXTCALL(glDrawArraysInstanced(mode, start_idx, count, instance_count));
4418 checkGLcall("glDrawArraysInstanced");
4419 return;
4420 }
4421
4422 if (gl_info->supported[ARB_BASE_INSTANCE])
4423 {
4424 GL_EXTCALL(glDrawElementsInstancedBaseVertexBaseInstance(mode, count, idx_type,
4425 indices, instance_count, base_vertex_idx, start_instance));
4426 checkGLcall("glDrawElementsInstancedBaseVertexBaseInstance");
4427 return;
4428 }
4429 if (gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX])
4430 {
4431 GL_EXTCALL(glDrawElementsInstancedBaseVertex(mode, count, idx_type,
4432 indices, instance_count, base_vertex_idx));
4433 checkGLcall("glDrawElementsInstancedBaseVertex");
4434 return;
4435 }
4436
4437 GL_EXTCALL(glDrawElementsInstanced(mode, count, idx_type, indices, instance_count));
4438 checkGLcall("glDrawElementsInstanced");
4439 return;
4440 }
4441
4442 /* Instancing emulation by mixing immediate mode and arrays. */
4443
4444 /* This is a nasty thing. MSDN says no hardware supports this and
4445 * applications have to use software vertex processing. We don't support
4446 * this for now.
4447 *
4448 * Shouldn't be too hard to support with OpenGL, in theory just call
4449 * glDrawArrays() instead of drawElements(). But the stream fequency value
4450 * has a different meaning in that situation. */
4451 if (!idx_size)
4452 {
4453 FIXME("Non-indexed instanced drawing is not supported.\n");
4454 return;
4455 }
4456
4457 for (i = 0; i < ARRAY_SIZE(si->elements); ++i)
4458 {
4459 if (!(si->use_map & (1u << i)))
4460 continue;
4461
4462 if (state->streams[si->elements[i].stream_idx].flags & WINED3DSTREAMSOURCE_INSTANCEDATA)
4463 instanced_elements[instanced_element_count++] = i;
4464 }
4465
4466 for (i = 0; i < instance_count; ++i)
4467 {
4468 /* Specify the instanced attributes using immediate mode calls. */
4469 for (j = 0; j < instanced_element_count; ++j)
4470 {
4471 const struct wined3d_stream_info_element *element;
4472 unsigned int element_idx;
4473 const BYTE *ptr;
4474
4475 element_idx = instanced_elements[j];
4476 element = &si->elements[element_idx];
4477 ptr = element->data.addr + element->stride * i;
4478 if (element->data.buffer_object)
4479 ptr += (ULONG_PTR)wined3d_buffer_load_sysmem(state->streams[element->stream_idx].buffer, context);
4480 ops->generic[element->format->emit_idx](element_idx, ptr);
4481 }
4482
4483 if (gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX])
4484 {
4485 GL_EXTCALL(glDrawElementsBaseVertex(mode, count, idx_type, indices, base_vertex_idx));
4486 checkGLcall("glDrawElementsBaseVertex");
4487 }
4488 else
4489 {
4490 gl_info->gl_ops.gl.p_glDrawElements(mode, count, idx_type, indices);
4491 checkGLcall("glDrawElements");
4492 }
4493 }
4494 }
4495
4496 static unsigned int get_stride_idx(const void *idx_data, unsigned int idx_size,
4497 unsigned int base_vertex_idx, unsigned int start_idx, unsigned int vertex_idx)
4498 {
4499 if (!idx_data)
4500 return start_idx + vertex_idx;
4501 if (idx_size == 2)
4502 return ((const WORD *)idx_data)[start_idx + vertex_idx] + base_vertex_idx;
4503 return ((const DWORD *)idx_data)[start_idx + vertex_idx] + base_vertex_idx;
4504 }
4505
4506 /* Context activation is done by the caller. */
4507 static void draw_primitive_immediate_mode(struct wined3d_context *context, const struct wined3d_state *state,
4508 const struct wined3d_stream_info *si, const void *idx_data, unsigned int idx_size,
4509 int base_vertex_idx, unsigned int start_idx, unsigned int vertex_count, unsigned int instance_count)
4510 {
4511 const BYTE *position = NULL, *normal = NULL, *diffuse = NULL, *specular = NULL;
4512 const struct wined3d_d3d_info *d3d_info = context->d3d_info;
4513 unsigned int coord_idx, stride_idx, texture_idx, vertex_idx;
4514 const struct wined3d_gl_info *gl_info = context->gl_info;
4515 const struct wined3d_stream_info_element *element;
4516 const BYTE *tex_coords[WINED3DDP_MAXTEXCOORD];
4517 unsigned int texture_unit, texture_stages;
4518 const struct wined3d_ffp_attrib_ops *ops;
4519 unsigned int untracked_material_count;
4520 unsigned int tex_mask = 0;
4521 BOOL specular_fog = FALSE;
4522 BOOL ps = use_ps(state);
4523 const void *ptr;
4524
4525 static unsigned int once;
4526
4527 if (!once++)
4528 FIXME_(d3d_perf)("Drawing using immediate mode.\n");
4529 else
4530 WARN_(d3d_perf)("Drawing using immediate mode.\n");
4531
4532 if (!idx_size && idx_data)
4533 ERR("Non-NULL idx_data with 0 idx_size, this should never happen.\n");
4534
4535 if (instance_count)
4536 FIXME("Instancing not implemented.\n");
4537
4538 /* Immediate mode drawing can't make use of indices in a VBO - get the
4539 * data from the index buffer. */
4540 if (idx_size)
4541 idx_data = wined3d_buffer_load_sysmem(state->index_buffer, context) + state->index_offset;
4542
4543 ops = &d3d_info->ffp_attrib_ops;
4544
4545 gl_info->gl_ops.gl.p_glBegin(state->gl_primitive_type);
4546
4547 if (use_vs(state) || d3d_info->ffp_generic_attributes)
4548 {
4549 for (vertex_idx = 0; vertex_idx < vertex_count; ++vertex_idx)
4550 {
4551 unsigned int use_map = si->use_map;
4552 unsigned int element_idx;
4553
4554 stride_idx = get_stride_idx(idx_data, idx_size, base_vertex_idx, start_idx, vertex_idx);
4555 for (element_idx = MAX_ATTRIBS - 1; use_map; use_map &= ~(1u << element_idx), --element_idx)
4556 {
4557 if (!(use_map & 1u << element_idx))
4558 continue;
4559
4560 ptr = si->elements[element_idx].data.addr + si->elements[element_idx].stride * stride_idx;
4561 ops->generic[si->elements[element_idx].format->emit_idx](element_idx, ptr);
4562 }
4563 }
4564
4565 gl_info->gl_ops.gl.p_glEnd();
4566 return;
4567 }
4568
4569 if (si->use_map & (1u << WINED3D_FFP_POSITION))
4570 position = si->elements[WINED3D_FFP_POSITION].data.addr;
4571
4572 if (si->use_map & (1u << WINED3D_FFP_NORMAL))
4573 normal = si->elements[WINED3D_FFP_NORMAL].data.addr;
4574 else
4575 gl_info->gl_ops.gl.p_glNormal3f(0.0f, 0.0f, 0.0f);
4576
4577 untracked_material_count = context->num_untracked_materials;
4578 if (si->use_map & (1u << WINED3D_FFP_DIFFUSE))
4579 {
4580 element = &si->elements[WINED3D_FFP_DIFFUSE];
4581 diffuse = element->data.addr;
4582
4583 if (untracked_material_count && element->format->id != WINED3DFMT_B8G8R8A8_UNORM)
4584 FIXME("Implement diffuse color tracking from %s.\n", debug_d3dformat(element->format->id));
4585 }
4586 else
4587 {
4588 gl_info->gl_ops.gl.p_glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
4589 }
4590
4591 if (si->use_map & (1u << WINED3D_FFP_SPECULAR))
4592 {
4593 element = &si->elements[WINED3D_FFP_SPECULAR];
4594 specular = element->data.addr;
4595
4596 /* Special case where the fog density is stored in the specular alpha channel. */
4597 if (state->render_states[WINED3D_RS_FOGENABLE]
4598 && (state->render_states[WINED3D_RS_FOGVERTEXMODE] == WINED3D_FOG_NONE
4599 || si->elements[WINED3D_FFP_POSITION].format->id == WINED3DFMT_R32G32B32A32_FLOAT)
4600 && state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3D_FOG_NONE)
4601 {
4602 if (gl_info->supported[EXT_FOG_COORD])
4603 {
4604 if (element->format->id == WINED3DFMT_B8G8R8A8_UNORM)
4605 specular_fog = TRUE;
4606 else
4607 FIXME("Implement fog coordinates from %s.\n", debug_d3dformat(element->format->id));
4608 }
4609 else
4610 {
4611 static unsigned int once;
4612
4613 if (!once++)
4614 FIXME("Implement fog for transformed vertices in software.\n");
4615 }
4616 }
4617 }
4618 else if (gl_info->supported[EXT_SECONDARY_COLOR])
4619 {
4620 GL_EXTCALL(glSecondaryColor3fEXT)(0.0f, 0.0f, 0.0f);
4621 }
4622
4623 texture_stages = d3d_info->limits.ffp_blend_stages;
4624 for (texture_idx = 0; texture_idx < texture_stages; ++texture_idx)
4625 {
4626 if (!gl_info->supported[ARB_MULTITEXTURE] && texture_idx > 0)
4627 {
4628 FIXME("Program using multiple concurrent textures which this OpenGL implementation doesn't support.\n");
4629 continue;
4630 }
4631
4632 if (!ps && !state->textures[texture_idx])
4633 continue;
4634
4635 texture_unit = context->tex_unit_map[texture_idx];
4636 if (texture_unit == WINED3D_UNMAPPED_STAGE)
4637 continue;
4638
4639 coord_idx = state->texture_states[texture_idx][WINED3D_TSS_TEXCOORD_INDEX];
4640 if (coord_idx > 7)
4641 {
4642 TRACE("Skipping generated coordinates (%#x) for texture %u.\n", coord_idx, texture_idx);
4643 continue;
4644 }
4645
4646 if (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx)))
4647 {
4648 tex_coords[coord_idx] = si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].data.addr;
4649 tex_mask |= (1u << texture_idx);
4650 }
4651 else
4652 {
4653 TRACE("Setting default coordinates for texture %u.\n", texture_idx);
4654 if (gl_info->supported[ARB_MULTITEXTURE])
4655 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_unit, 0.0f, 0.0f, 0.0f, 1.0f));
4656 else
4657 gl_info->gl_ops.gl.p_glTexCoord4f(0.0f, 0.0f, 0.0f, 1.0f);
4658 }
4659 }
4660
4661 /* Blending data and point sizes are not supported by this function. They
4662 * are not supported by the fixed function pipeline at all. A FIXME for
4663 * them is printed after decoding the vertex declaration. */
4664 for (vertex_idx = 0; vertex_idx < vertex_count; ++vertex_idx)
4665 {
4666 unsigned int tmp_tex_mask;
4667
4668 stride_idx = get_stride_idx(idx_data, idx_size, base_vertex_idx, start_idx, vertex_idx);
4669
4670 if (normal)
4671 {
4672 ptr = normal + stride_idx * si->elements[WINED3D_FFP_NORMAL].stride;
4673 ops->normal[si->elements[WINED3D_FFP_NORMAL].format->emit_idx](ptr);
4674 }
4675
4676 if (diffuse)
4677 {
4678 ptr = diffuse + stride_idx * si->elements[WINED3D_FFP_DIFFUSE].stride;
4679 ops->diffuse[si->elements[WINED3D_FFP_DIFFUSE].format->emit_idx](ptr);
4680
4681 if (untracked_material_count)
4682 {
4683 struct wined3d_color color;
4684 unsigned int i;
4685
4686 wined3d_color_from_d3dcolor(&color, *(const DWORD *)ptr);
4687 for (i = 0; i < untracked_material_count; ++i)
4688 {
4689 gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, context->untracked_materials[i], &color.r);
4690 }
4691 }
4692 }
4693
4694 if (specular)
4695 {
4696 ptr = specular + stride_idx * si->elements[WINED3D_FFP_SPECULAR].stride;
4697 ops->specular[si->elements[WINED3D_FFP_SPECULAR].format->emit_idx](ptr);
4698
4699 if (specular_fog)
4700 GL_EXTCALL(glFogCoordfEXT((float)(*(const DWORD *)ptr >> 24)));
4701 }
4702
4703 tmp_tex_mask = tex_mask;
4704 for (texture_idx = 0; tmp_tex_mask; tmp_tex_mask >>= 1, ++texture_idx)
4705 {
4706 if (!(tmp_tex_mask & 1))
4707 continue;
4708
4709 coord_idx = state->texture_states[texture_idx][WINED3D_TSS_TEXCOORD_INDEX];
4710 ptr = tex_coords[coord_idx] + (stride_idx * si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].stride);
4711 ops->texcoord[si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].format->emit_idx](
4712 GL_TEXTURE0_ARB + context->tex_unit_map[texture_idx], ptr);
4713 }
4714
4715 if (position)
4716 {
4717 ptr = position + stride_idx * si->elements[WINED3D_FFP_POSITION].stride;
4718 ops->position[si->elements[WINED3D_FFP_POSITION].format->emit_idx](ptr);
4719 }
4720 }
4721
4722 gl_info->gl_ops.gl.p_glEnd();
4723 checkGLcall("draw immediate mode");
4724 }
4725
4726 static void draw_indirect(struct wined3d_context *context, const struct wined3d_state *state,
4727 const struct wined3d_indirect_draw_parameters *parameters, unsigned int idx_size)
4728 {
4729 const struct wined3d_gl_info *gl_info = context->gl_info;
4730 struct wined3d_buffer *buffer = parameters->buffer;
4731 const void *offset;
4732
4733 if (!gl_info->supported[ARB_DRAW_INDIRECT])
4734 {
4735 FIXME("OpenGL implementation does not support indirect draws.\n");
4736 return;
4737 }
4738
4739 GL_EXTCALL(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, wined3d_buffer_gl(buffer)->buffer_object));
4740
4741 offset = (void *)(GLintptr)parameters->offset;
4742 if (idx_size)
4743 {
4744 GLenum idx_type = idx_size == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
4745 if (state->index_offset)
4746 FIXME("Ignoring index offset %u.\n", state->index_offset);
4747 GL_EXTCALL(glDrawElementsIndirect(state->gl_primitive_type, idx_type, offset));
4748 }
4749 else
4750 {
4751 GL_EXTCALL(glDrawArraysIndirect(state->gl_primitive_type, offset));
4752 }
4753
4754 GL_EXTCALL(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0));
4755
4756 checkGLcall("draw indirect");
4757 }
4758
4759 static void remove_vbos(struct wined3d_context *context,
4760 const struct wined3d_state *state, struct wined3d_stream_info *s)
4761 {
4762 unsigned int i;
4763
4764 for (i = 0; i < ARRAY_SIZE(s->elements); ++i)
4765 {
4766 struct wined3d_stream_info_element *e;
4767
4768 if (!(s->use_map & (1u << i)))
4769 continue;
4770
4771 e = &s->elements[i];
4772 if (e->data.buffer_object)
4773 {
4774 struct wined3d_buffer *vb = state->streams[e->stream_idx].buffer;
4775 e->data.buffer_object = 0;
4776 e->data.addr += (ULONG_PTR)wined3d_buffer_load_sysmem(vb, context);
4777 }
4778 }
4779 }
4780
4781 static GLenum gl_tfb_primitive_type_from_d3d(enum wined3d_primitive_type primitive_type)
4782 {
4783 GLenum gl_primitive_type = gl_primitive_type_from_d3d(primitive_type);
4784 switch (gl_primitive_type)
4785 {
4786 case GL_POINTS:
4787 return GL_POINTS;
4788
4789 case GL_LINE_STRIP:
4790 case GL_LINE_STRIP_ADJACENCY:
4791 case GL_LINES_ADJACENCY:
4792 case GL_LINES:
4793 return GL_LINES;
4794
4795 case GL_TRIANGLE_FAN:
4796 case GL_TRIANGLE_STRIP:
4797 case GL_TRIANGLE_STRIP_ADJACENCY:
4798 case GL_TRIANGLES_ADJACENCY:
4799 case GL_TRIANGLES:
4800 return GL_TRIANGLES;
4801
4802 default:
4803 return gl_primitive_type;
4804 }
4805 }
4806
4807 /* Routine common to the draw primitive and draw indexed primitive routines */
4808 void draw_primitive(struct wined3d_device *device, const struct wined3d_state *state,
4809 const struct wined3d_draw_parameters *parameters)
4810 {
4811 BOOL emulation = FALSE, rasterizer_discard = FALSE;
4812 const struct wined3d_fb_state *fb = state->fb;
4813 const struct wined3d_stream_info *stream_info;
4814 struct wined3d_rendertarget_view *dsv, *rtv;
4815 struct wined3d_stream_info si_emulated;
4816 struct wined3d_fence *ib_fence = NULL;
4817 const struct wined3d_gl_info *gl_info;
4818 struct wined3d_context *context;
4819 unsigned int i, idx_size = 0;
4820 const void *idx_data = NULL;
4821
4822 if (!parameters->indirect && !parameters->u.direct.index_count)
4823 return;
4824
4825 if (!(rtv = fb->render_targets[0]))
4826 rtv = fb->depth_stencil;
4827
4828 if (rtv && rtv->resource->type == WINED3D_RTYPE_BUFFER)
4829 {
4830 FIXME("Buffer render targets not implemented.\n");
4831 return;
4832 }
4833
4834 if (rtv)
4835 context = context_acquire(device, wined3d_texture_from_resource(rtv->resource), rtv->sub_resource_idx);
4836 else
4837 context = context_acquire(device, NULL, 0);
4838 if (!context->valid)
4839 {
4840 context_release(context);
4841 WARN("Invalid context, skipping draw.\n");
4842 return;
4843 }
4844 gl_info = context->gl_info;
4845
4846 if (!use_transform_feedback(state))
4847 context_pause_transform_feedback(context, TRUE);
4848
4849 for (i = 0; i < gl_info->limits.buffers; ++i)
4850 {
4851 if (!(rtv = fb->render_targets[i]) || rtv->format->id == WINED3DFMT_NULL)
4852 continue;
4853
4854 if (state->render_states[WINED3D_RS_COLORWRITEENABLE])
4855 {
4856 wined3d_rendertarget_view_load_location(rtv, context, rtv->resource->draw_binding);
4857 wined3d_rendertarget_view_invalidate_location(rtv, ~rtv->resource->draw_binding);
4858 }
4859 else
4860 {
4861 wined3d_rendertarget_view_prepare_location(rtv, context, rtv->resource->draw_binding);
4862 }
4863 }
4864
4865 if ((dsv = fb->depth_stencil))
4866 {
4867 /* Note that this depends on the context_acquire() call above to set
4868 * context->render_offscreen properly. We don't currently take the
4869 * Z-compare function into account, but we could skip loading the
4870 * depthstencil for D3DCMP_NEVER and D3DCMP_ALWAYS as well. Also note
4871 * that we never copy the stencil data.*/
4872 DWORD location = context->render_offscreen ? dsv->resource->draw_binding : WINED3D_LOCATION_DRAWABLE;
4873
4874 if (state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE])
4875 wined3d_rendertarget_view_load_location(dsv, context, location);
4876 else
4877 wined3d_rendertarget_view_prepare_location(dsv, context, location);
4878 }
4879
4880 if (parameters->indirect)
4881 wined3d_buffer_load(parameters->u.indirect.buffer, context, state);
4882
4883 if (!context_apply_draw_state(context, device, state))
4884 {
4885 context_release(context);
4886 WARN("Unable to apply draw state, skipping draw.\n");
4887 return;
4888 }
4889
4890 if (dsv && state->render_states[WINED3D_RS_ZWRITEENABLE])
4891 {
4892 DWORD location = context->render_offscreen ? dsv->resource->draw_binding : WINED3D_LOCATION_DRAWABLE;
4893
4894 wined3d_rendertarget_view_validate_location(dsv, location);
4895 wined3d_rendertarget_view_invalidate_location(dsv, ~location);
4896 }
4897
4898 stream_info = &context->stream_info;
4899
4900 if (parameters->indexed)
4901 {
4902 struct wined3d_buffer *index_buffer = state->index_buffer;
4903 if (!wined3d_buffer_gl(index_buffer)->buffer_object || !stream_info->all_vbo)
4904 {
4905 idx_data = index_buffer->resource.heap_memory;
4906 }
4907 else
4908 {
4909 ib_fence = index_buffer->fence;
4910 idx_data = NULL;
4911 }
4912 idx_data = (const BYTE *)idx_data + state->index_offset;
4913
4914 if (state->index_format == WINED3DFMT_R16_UINT)
4915 idx_size = 2;
4916 else
4917 idx_size = 4;
4918 }
4919
4920 if (!use_vs(state))
4921 {
4922 if (!stream_info->position_transformed && context->num_untracked_materials
4923 && state->render_states[WINED3D_RS_LIGHTING])
4924 {
4925 static BOOL warned;
4926
4927 if (!warned++)
4928 FIXME("Using software emulation because not all material properties could be tracked.\n");
4929 else
4930 WARN_(d3d_perf)("Using software emulation because not all material properties could be tracked.\n");
4931 emulation = TRUE;
4932 }
4933 else if (context->fog_coord && state->render_states[WINED3D_RS_FOGENABLE])
4934 {
4935 static BOOL warned;
4936
4937 /* Either write a pipeline replacement shader or convert the
4938 * specular alpha from unsigned byte to a float in the vertex
4939 * buffer. */
4940 if (!warned++)
4941 FIXME("Using software emulation because manual fog coordinates are provided.\n");
4942 else
4943 WARN_(d3d_perf)("Using software emulation because manual fog coordinates are provided.\n");
4944 emulation = TRUE;
4945 }
4946
4947 if (emulation)
4948 {
4949 si_emulated = context->stream_info;
4950 remove_vbos(context, state, &si_emulated);
4951 stream_info = &si_emulated;
4952 }
4953 }
4954
4955 if (use_transform_feedback(state))
4956 {
4957 const struct wined3d_shader *shader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
4958
4959 if (is_rasterization_disabled(shader))
4960 {
4961 glEnable(GL_RASTERIZER_DISCARD);
4962 checkGLcall("enable rasterizer discard");
4963 rasterizer_discard = TRUE;
4964 }
4965
4966 if (context->transform_feedback_paused)
4967 {
4968 GL_EXTCALL(glResumeTransformFeedback());
4969 checkGLcall("glResumeTransformFeedback");
4970 context->transform_feedback_paused = 0;
4971 }
4972 else if (!context->transform_feedback_active)
4973 {
4974 enum wined3d_primitive_type primitive_type = shader->u.gs.output_type
4975 ? shader->u.gs.output_type : d3d_primitive_type_from_gl(state->gl_primitive_type);
4976 GLenum mode = gl_tfb_primitive_type_from_d3d(primitive_type);
4977 GL_EXTCALL(glBeginTransformFeedback(mode));
4978 checkGLcall("glBeginTransformFeedback");
4979 context->transform_feedback_active = 1;
4980 }
4981 }
4982
4983 if (state->gl_primitive_type == GL_PATCHES)
4984 {
4985 GL_EXTCALL(glPatchParameteri(GL_PATCH_VERTICES, state->gl_patch_vertices));
4986 checkGLcall("glPatchParameteri");
4987 }
4988
4989 if (parameters->indirect)
4990 {
4991 if (!context->use_immediate_mode_draw && !emulation)
4992 draw_indirect(context, state, &parameters->u.indirect, idx_size);
4993 else
4994 FIXME("Indirect draws with immediate mode/emulation are not supported.\n");
4995 }
4996 else
4997 {
4998 unsigned int instance_count = parameters->u.direct.instance_count;
4999 if (context->instance_count)
5000 instance_count = context->instance_count;
5001
5002 if (context->use_immediate_mode_draw || emulation)
5003 draw_primitive_immediate_mode(context, state, stream_info, idx_data,
5004 idx_size, parameters->u.direct.base_vertex_idx,
5005 parameters->u.direct.start_idx, parameters->u.direct.index_count, instance_count);
5006 else
5007 draw_primitive_arrays(context, state, idx_data, idx_size, parameters->u.direct.base_vertex_idx,
5008 parameters->u.direct.start_idx, parameters->u.direct.index_count,
5009 parameters->u.direct.start_instance, instance_count);
5010 }
5011
5012 if (context->uses_uavs)
5013 {
5014 GL_EXTCALL(glMemoryBarrier(GL_ALL_BARRIER_BITS));
5015 checkGLcall("glMemoryBarrier");
5016 }
5017
5018 context_pause_transform_feedback(context, FALSE);
5019
5020 if (rasterizer_discard)
5021 {
5022 glDisable(GL_RASTERIZER_DISCARD);
5023 checkGLcall("disable rasterizer discard");
5024 }
5025
5026 if (ib_fence)
5027 wined3d_fence_issue(ib_fence, device);
5028 for (i = 0; i < context->buffer_fence_count; ++i)
5029 wined3d_fence_issue(context->buffer_fences[i], device);
5030
5031 context_release(context);
5032 }
5033
5034 void context_unload_tex_coords(const struct wined3d_context *context)
5035 {
5036 const struct wined3d_gl_info *gl_info = context->gl_info;
5037 unsigned int texture_idx;
5038
5039 for (texture_idx = 0; texture_idx < gl_info->limits.texture_coords; ++texture_idx)
5040 {
5041 gl_info->gl_ops.ext.p_glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx);
5042 gl_info->gl_ops.gl.p_glDisableClientState(GL_TEXTURE_COORD_ARRAY);
5043 }
5044 }
5045
5046 void context_load_tex_coords(const struct wined3d_context *context, const struct wined3d_stream_info *si,
5047 GLuint *current_bo, const struct wined3d_state *state)
5048 {
5049 const struct wined3d_gl_info *gl_info = context->gl_info;
5050 const struct wined3d_format_gl *format_gl;
5051 unsigned int mapped_stage = 0;
5052 unsigned int texture_idx;
5053
5054 for (texture_idx = 0; texture_idx < context->d3d_info->limits.ffp_blend_stages; ++texture_idx)
5055 {
5056 unsigned int coord_idx = state->texture_states[texture_idx][WINED3D_TSS_TEXCOORD_INDEX];
5057
5058 if ((mapped_stage = context->tex_unit_map[texture_idx]) == WINED3D_UNMAPPED_STAGE)
5059 continue;
5060
5061 if (mapped_stage >= gl_info->limits.texture_coords)
5062 {
5063 FIXME("Attempted to load unsupported texture coordinate %u.\n", mapped_stage);
5064 continue;
5065 }
5066
5067 if (coord_idx < WINED3D_MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx))))
5068 {
5069 const struct wined3d_stream_info_element *e = &si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx];
5070
5071 TRACE("Setting up texture %u, idx %u, coord_idx %u, data %s.\n",
5072 texture_idx, mapped_stage, coord_idx, debug_bo_address(&e->data));
5073
5074 if (*current_bo != e->data.buffer_object)
5075 {
5076 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, e->data.buffer_object));
5077 checkGLcall("glBindBuffer");
5078 *current_bo = e->data.buffer_object;
5079 }
5080
5081 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
5082 checkGLcall("glClientActiveTextureARB");
5083
5084 /* The coords to supply depend completely on the fvf/vertex shader. */
5085 format_gl = wined3d_format_gl(e->format);
5086 gl_info->gl_ops.gl.p_glTexCoordPointer(format_gl->vtx_format, format_gl->vtx_type, e->stride,
5087 e->data.addr + state->load_base_vertex_index * e->stride);
5088 gl_info->gl_ops.gl.p_glEnableClientState(GL_TEXTURE_COORD_ARRAY);
5089 }
5090 else
5091 {
5092 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + mapped_stage, 0, 0, 0, 1));
5093 }
5094 }
5095 if (gl_info->supported[NV_REGISTER_COMBINERS])
5096 {
5097 /* The number of the mapped stages increases monotonically, so it's fine to use the last used one. */
5098 for (texture_idx = mapped_stage + 1; texture_idx < gl_info->limits.textures; ++texture_idx)
5099 {
5100 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_idx, 0, 0, 0, 1));
5101 }
5102 }
5103
5104 checkGLcall("loadTexCoords");
5105 }
5106
5107 /* This should match any arrays loaded in context_load_vertex_data(). */
5108 static void context_unload_vertex_data(struct wined3d_context *context)
5109 {
5110 const struct wined3d_gl_info *gl_info = context->gl_info;
5111
5112 if (!context->namedArraysLoaded)
5113 return;
5114 gl_info->gl_ops.gl.p_glDisableClientState(GL_VERTEX_ARRAY);
5115 gl_info->gl_ops.gl.p_glDisableClientState(GL_NORMAL_ARRAY);
5116 gl_info->gl_ops.gl.p_glDisableClientState(GL_COLOR_ARRAY);
5117 if (gl_info->supported[EXT_SECONDARY_COLOR])
5118 gl_info->gl_ops.gl.p_glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
5119 context_unload_tex_coords(context);
5120 context->namedArraysLoaded = FALSE;
5121 }
5122
5123 static void context_load_vertex_data(struct wined3d_context *context,
5124 const struct wined3d_stream_info *si, const struct wined3d_state *state)
5125 {
5126 const struct wined3d_gl_info *gl_info = context->gl_info;
5127 const struct wined3d_stream_info_element *e;
5128 const struct wined3d_format_gl *format_gl;
5129 GLuint current_bo;
5130
5131 TRACE("context %p, si %p, state %p.\n", context, si, state);
5132
5133 /* This is used for the fixed-function pipeline only, and the
5134 * fixed-function pipeline doesn't do instancing. */
5135 context->instance_count = 0;
5136 current_bo = gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] ? ~0u : 0;
5137
5138 /* Blend data */
5139 if ((si->use_map & (1u << WINED3D_FFP_BLENDWEIGHT))
5140 || si->use_map & (1u << WINED3D_FFP_BLENDINDICES))
5141 {
5142 /* TODO: Support vertex blending in immediate mode draws. No need to
5143 * write a FIXME here, this is done after the general vertex
5144 * declaration decoding. */
5145 WARN("Vertex blending not supported.\n");
5146 }
5147
5148 /* Point Size */
5149 if (si->use_map & (1u << WINED3D_FFP_PSIZE))
5150 {
5151 /* No such functionality in the fixed-function GL pipeline. */
5152 WARN("Per-vertex point size not supported.\n");
5153 }
5154
5155 /* Position */
5156 if (si->use_map & (1u << WINED3D_FFP_POSITION))
5157 {
5158 e = &si->elements[WINED3D_FFP_POSITION];
5159 format_gl = wined3d_format_gl(e->format);
5160
5161 if (current_bo != e->data.buffer_object)
5162 {
5163 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, e->data.buffer_object));
5164 checkGLcall("glBindBuffer");
5165 current_bo = e->data.buffer_object;
5166 }
5167
5168 TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n",
5169 format_gl->vtx_format, format_gl->vtx_type, e->stride,
5170 e->data.addr + state->load_base_vertex_index * e->stride);
5171 gl_info->gl_ops.gl.p_glVertexPointer(format_gl->vtx_format, format_gl->vtx_type, e->stride,
5172 e->data.addr + state->load_base_vertex_index * e->stride);
5173 checkGLcall("glVertexPointer(...)");
5174 gl_info->gl_ops.gl.p_glEnableClientState(GL_VERTEX_ARRAY);
5175 checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
5176 }
5177
5178 /* Normals */
5179 if (si->use_map & (1u << WINED3D_FFP_NORMAL))
5180 {
5181 e = &si->elements[WINED3D_FFP_NORMAL];
5182 format_gl = wined3d_format_gl(e->format);
5183
5184 if (current_bo != e->data.buffer_object)
5185 {
5186 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, e->data.buffer_object));
5187 checkGLcall("glBindBuffer");
5188 current_bo = e->data.buffer_object;
5189 }
5190
5191 TRACE("glNormalPointer(%#x, %#x, %p);\n", format_gl->vtx_type, e->stride,
5192 e->data.addr + state->load_base_vertex_index * e->stride);
5193 gl_info->gl_ops.gl.p_glNormalPointer(format_gl->vtx_type, e->stride,
5194 e->data.addr + state->load_base_vertex_index * e->stride);
5195 checkGLcall("glNormalPointer(...)");
5196 gl_info->gl_ops.gl.p_glEnableClientState(GL_NORMAL_ARRAY);
5197 checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
5198
5199 }
5200 else
5201 {
5202 gl_info->gl_ops.gl.p_glNormal3f(0, 0, 0);
5203 checkGLcall("glNormal3f(0, 0, 0)");
5204 }
5205
5206 /* Diffuse colour */
5207 if (si->use_map & (1u << WINED3D_FFP_DIFFUSE))
5208 {
5209 e = &si->elements[WINED3D_FFP_DIFFUSE];
5210 format_gl = wined3d_format_gl(e->format);
5211
5212 if (current_bo != e->data.buffer_object)
5213 {
5214 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, e->data.buffer_object));
5215 checkGLcall("glBindBuffer");
5216 current_bo = e->data.buffer_object;
5217 }
5218
5219 TRACE("glColorPointer(%#x, %#x %#x, %p);\n",
5220 format_gl->vtx_format, format_gl->vtx_type, e->stride,
5221 e->data.addr + state->load_base_vertex_index * e->stride);
5222 gl_info->gl_ops.gl.p_glColorPointer(format_gl->vtx_format, format_gl->vtx_type, e->stride,
5223 e->data.addr + state->load_base_vertex_index * e->stride);
5224 checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
5225 gl_info->gl_ops.gl.p_glEnableClientState(GL_COLOR_ARRAY);
5226 checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
5227
5228 }
5229 else
5230 {
5231 gl_info->gl_ops.gl.p_glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
5232 checkGLcall("glColor4f(1, 1, 1, 1)");
5233 }
5234
5235 /* Specular colour */
5236 if (si->use_map & (1u << WINED3D_FFP_SPECULAR))
5237 {
5238 TRACE("Setting specular colour.\n");
5239
5240 e = &si->elements[WINED3D_FFP_SPECULAR];
5241
5242 if (gl_info->supported[EXT_SECONDARY_COLOR])
5243 {
5244 GLint format;
5245 GLenum type;
5246
5247 format_gl = wined3d_format_gl(e->format);
5248 type = format_gl->vtx_type;
5249 format = format_gl->vtx_format;
5250
5251 if (current_bo != e->data.buffer_object)
5252 {
5253 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, e->data.buffer_object));
5254 checkGLcall("glBindBuffer");
5255 current_bo = e->data.buffer_object;
5256 }
5257
5258 if (format != 4 || (gl_info->quirks & WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA))
5259 {
5260 /* Usually specular colors only allow 3 components, since they have no alpha. In D3D, the specular alpha
5261 * contains the fog coordinate, which is passed to GL with GL_EXT_fog_coord. However, the fixed function
5262 * vertex pipeline can pass the specular alpha through, and pixel shaders can read it. So it GL accepts
5263 * 4 component secondary colors use it
5264 */
5265 TRACE("glSecondaryColorPointer(%#x, %#x, %#x, %p);\n", format, type, e->stride,
5266 e->data.addr + state->load_base_vertex_index * e->stride);
5267 GL_EXTCALL(glSecondaryColorPointerEXT(format, type, e->stride,
5268 e->data.addr + state->load_base_vertex_index * e->stride));
5269 checkGLcall("glSecondaryColorPointerEXT(format, type, ...)");
5270 }
5271 else
5272 {
5273 switch (type)
5274 {
5275 case GL_UNSIGNED_BYTE:
5276 TRACE("glSecondaryColorPointer(3, GL_UNSIGNED_BYTE, %#x, %p);\n", e->stride,
5277 e->data.addr + state->load_base_vertex_index * e->stride);
5278 GL_EXTCALL(glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, e->stride,
5279 e->data.addr + state->load_base_vertex_index * e->stride));
5280 checkGLcall("glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, ...)");
5281 break;
5282
5283 default:
5284 FIXME("Add 4 component specular colour pointers for type %#x.\n", type);
5285 /* Make sure that the right colour component is dropped. */
5286 TRACE("glSecondaryColorPointer(3, %#x, %#x, %p);\n", type, e->stride,
5287 e->data.addr + state->load_base_vertex_index * e->stride);
5288 GL_EXTCALL(glSecondaryColorPointerEXT(3, type, e->stride,
5289 e->data.addr + state->load_base_vertex_index * e->stride));
5290 checkGLcall("glSecondaryColorPointerEXT(3, type, ...)");
5291 }
5292 }
5293 gl_info->gl_ops.gl.p_glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
5294 checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
5295 }
5296 else
5297 {
5298 WARN("Specular colour is not supported in this GL implementation.\n");
5299 }
5300 }
5301 else
5302 {
5303 if (gl_info->supported[EXT_SECONDARY_COLOR])
5304 {
5305 GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
5306 checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
5307 }
5308 else
5309 {
5310 WARN("Specular colour is not supported in this GL implementation.\n");
5311 }
5312 }
5313
5314 /* Texture coordinates */
5315 context_load_tex_coords(context, si, &current_bo, state);
5316 }
5317
5318 static void context_unload_numbered_array(struct wined3d_context *context, unsigned int i)
5319 {
5320 const struct wined3d_gl_info *gl_info = context->gl_info;
5321
5322 GL_EXTCALL(glDisableVertexAttribArray(i));
5323 checkGLcall("glDisableVertexAttribArray");
5324 if (gl_info->supported[ARB_INSTANCED_ARRAYS])
5325 GL_EXTCALL(glVertexAttribDivisor(i, 0));
5326
5327 context->numbered_array_mask &= ~(1u << i);
5328 }
5329
5330 static void context_unload_numbered_arrays(struct wined3d_context *context)
5331 {
5332 unsigned int i;
5333
5334 while (context->numbered_array_mask)
5335 {
5336 i = wined3d_bit_scan(&context->numbered_array_mask);
5337 context_unload_numbered_array(context, i);
5338 }
5339 }
5340
5341 static void context_load_numbered_arrays(struct wined3d_context *context,
5342 const struct wined3d_stream_info *stream_info, const struct wined3d_state *state)
5343 {
5344 const struct wined3d_shader *vs = state->shader[WINED3D_SHADER_TYPE_VERTEX];
5345 const struct wined3d_gl_info *gl_info = context->gl_info;
5346 GLuint current_bo;
5347 unsigned int i;
5348
5349 /* Default to no instancing. */
5350 context->instance_count = 0;
5351 current_bo = gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] ? ~0u : 0;
5352
5353 for (i = 0; i < MAX_ATTRIBS; ++i)
5354 {
5355 const struct wined3d_stream_info_element *element = &stream_info->elements[i];
5356 const struct wined3d_stream_state *stream;
5357 const struct wined3d_format_gl *format_gl;
5358
5359 if (!(stream_info->use_map & (1u << i)))
5360 {
5361 if (context->numbered_array_mask & (1u << i))
5362 context_unload_numbered_array(context, i);
5363 if (!use_vs(state) && i == WINED3D_FFP_DIFFUSE)
5364 GL_EXTCALL(glVertexAttrib4f(i, 1.0f, 1.0f, 1.0f, 1.0f));
5365 else
5366 GL_EXTCALL(glVertexAttrib4f(i, 0.0f, 0.0f, 0.0f, 0.0f));
5367 continue;
5368 }
5369
5370 format_gl = wined3d_format_gl(element->format);
5371 stream = &state->streams[element->stream_idx];
5372
5373 if ((stream->flags & WINED3DSTREAMSOURCE_INSTANCEDATA) && !context->instance_count)
5374 context->instance_count = state->streams[0].frequency;
5375
5376 if (gl_info->supported[ARB_INSTANCED_ARRAYS])
5377 {
5378 GL_EXTCALL(glVertexAttribDivisor(i, element->divisor));
5379 }
5380 else if (element->divisor)
5381 {
5382 /* Unload instanced arrays, they will be loaded using immediate
5383 * mode instead. */
5384 if (context->numbered_array_mask & (1u << i))
5385 context_unload_numbered_array(context, i);
5386 continue;
5387 }
5388
5389 TRACE("Loading array %u %s.\n", i, debug_bo_address(&element->data));
5390
5391 if (element->stride)
5392 {
5393 DWORD format_flags = format_gl->f.flags[WINED3D_GL_RES_TYPE_BUFFER];
5394
5395 if (current_bo != element->data.buffer_object)
5396 {
5397 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, element->data.buffer_object));
5398 checkGLcall("glBindBuffer");
5399 current_bo = element->data.buffer_object;
5400 }
5401 /* Use the VBO to find out if a vertex buffer exists, not the vb
5402 * pointer. vb can point to a user pointer data blob. In that case
5403 * current_bo will be 0. If there is a vertex buffer but no vbo we
5404 * won't be load converted attributes anyway. */
5405 if (vs && vs->reg_maps.shader_version.major >= 4 && (format_flags & WINED3DFMT_FLAG_INTEGER))
5406 {
5407 GL_EXTCALL(glVertexAttribIPointer(i, format_gl->vtx_format, format_gl->vtx_type,
5408 element->stride, element->data.addr + state->load_base_vertex_index * element->stride));
5409 }
5410 else
5411 {
5412 GL_EXTCALL(glVertexAttribPointer(i, format_gl->vtx_format, format_gl->vtx_type,
5413 !!(format_flags & WINED3DFMT_FLAG_NORMALISED), element->stride,
5414 element->data.addr + state->load_base_vertex_index * element->stride));
5415 }
5416
5417 if (!(context->numbered_array_mask & (1u << i)))
5418 {
5419 GL_EXTCALL(glEnableVertexAttribArray(i));
5420 context->numbered_array_mask |= (1u << i);
5421 }
5422 }
5423 else
5424 {
5425 /* Stride = 0 means always the same values.
5426 * glVertexAttribPointer() doesn't do that. Instead disable the
5427 * pointer and set up the attribute statically. But we have to
5428 * figure out the system memory address. */
5429 const BYTE *ptr = element->data.addr;
5430 if (element->data.buffer_object)
5431 ptr += (ULONG_PTR)wined3d_buffer_load_sysmem(stream->buffer, context);
5432
5433 if (context->numbered_array_mask & (1u << i))
5434 context_unload_numbered_array(context, i);
5435
5436 switch (format_gl->f.id)
5437 {
5438 case WINED3DFMT_R32_FLOAT:
5439 GL_EXTCALL(glVertexAttrib1fv(i, (const GLfloat *)ptr));
5440 break;
5441 case WINED3DFMT_R32G32_FLOAT:
5442 GL_EXTCALL(glVertexAttrib2fv(i, (const GLfloat *)ptr));
5443 break;
5444 case WINED3DFMT_R32G32B32_FLOAT:
5445 GL_EXTCALL(glVertexAttrib3fv(i, (const GLfloat *)ptr));
5446 break;
5447 case WINED3DFMT_R32G32B32A32_FLOAT:
5448 GL_EXTCALL(glVertexAttrib4fv(i, (const GLfloat *)ptr));
5449 break;
5450 case WINED3DFMT_R8G8B8A8_UINT:
5451 GL_EXTCALL(glVertexAttrib4ubv(i, ptr));
5452 break;
5453 case WINED3DFMT_B8G8R8A8_UNORM:
5454 if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
5455 {
5456 const DWORD *src = (const DWORD *)ptr;
5457 DWORD c = *src & 0xff00ff00u;
5458 c |= (*src & 0xff0000u) >> 16;
5459 c |= (*src & 0xffu) << 16;
5460 GL_EXTCALL(glVertexAttrib4Nubv(i, (GLubyte *)&c));
5461 break;
5462 }
5463 /* else fallthrough */
5464 case WINED3DFMT_R8G8B8A8_UNORM:
5465 GL_EXTCALL(glVertexAttrib4Nubv(i, ptr));
5466 break;
5467 case WINED3DFMT_R16G16_SINT:
5468 GL_EXTCALL(glVertexAttrib2sv(i, (const GLshort *)ptr));
5469 break;
5470 case WINED3DFMT_R16G16B16A16_SINT:
5471 GL_EXTCALL(glVertexAttrib4sv(i, (const GLshort *)ptr));
5472 break;
5473 case WINED3DFMT_R16G16_SNORM:
5474 {
5475 const GLshort s[4] = {((const GLshort *)ptr)[0], ((const GLshort *)ptr)[1], 0, 1};
5476 GL_EXTCALL(glVertexAttrib4Nsv(i, s));
5477 break;
5478 }
5479 case WINED3DFMT_R16G16_UNORM:
5480 {
5481 const GLushort s[4] = {((const GLushort *)ptr)[0], ((const GLushort *)ptr)[1], 0, 1};
5482 GL_EXTCALL(glVertexAttrib4Nusv(i, s));
5483 break;
5484 }
5485 case WINED3DFMT_R16G16B16A16_SNORM:
5486 GL_EXTCALL(glVertexAttrib4Nsv(i, (const GLshort *)ptr));
5487 break;
5488 case WINED3DFMT_R16G16B16A16_UNORM:
5489 GL_EXTCALL(glVertexAttrib4Nusv(i, (const GLushort *)ptr));
5490 break;
5491 case WINED3DFMT_R10G10B10X2_UINT:
5492 FIXME("Unsure about WINED3DDECLTYPE_UDEC3.\n");
5493 /*glVertexAttrib3usvARB(i, (const GLushort *)ptr); Does not exist */
5494 break;
5495 case WINED3DFMT_R10G10B10X2_SNORM:
5496 FIXME("Unsure about WINED3DDECLTYPE_DEC3N.\n");
5497 /*glVertexAttrib3NusvARB(i, (const GLushort *)ptr); Does not exist */
5498 break;
5499 case WINED3DFMT_R16G16_FLOAT:
5500 if (gl_info->supported[NV_HALF_FLOAT] && gl_info->supported[NV_VERTEX_PROGRAM])
5501 {
5502 /* Not supported by GL_ARB_half_float_vertex. */
5503 GL_EXTCALL(glVertexAttrib2hvNV(i, (const GLhalfNV *)ptr));
5504 }
5505 else
5506 {
5507 float x = float_16_to_32(((const unsigned short *)ptr) + 0);
5508 float y = float_16_to_32(((const unsigned short *)ptr) + 1);
5509 GL_EXTCALL(glVertexAttrib2f(i, x, y));
5510 }
5511 break;
5512 case WINED3DFMT_R16G16B16A16_FLOAT:
5513 if (gl_info->supported[NV_HALF_FLOAT] && gl_info->supported[NV_VERTEX_PROGRAM])
5514 {
5515 /* Not supported by GL_ARB_half_float_vertex. */
5516 GL_EXTCALL(glVertexAttrib4hvNV(i, (const GLhalfNV *)ptr));
5517 }
5518 else
5519 {
5520 float x = float_16_to_32(((const unsigned short *)ptr) + 0);
5521 float y = float_16_to_32(((const unsigned short *)ptr) + 1);
5522 float z = float_16_to_32(((const unsigned short *)ptr) + 2);
5523 float w = float_16_to_32(((const unsigned short *)ptr) + 3);
5524 GL_EXTCALL(glVertexAttrib4f(i, x, y, z, w));
5525 }
5526 break;
5527 default:
5528 ERR("Unexpected declaration in stride 0 attributes.\n");
5529 break;
5530
5531 }
5532 }
5533 }
5534 checkGLcall("Loading numbered arrays");
5535 }
5536
5537 void context_update_stream_sources(struct wined3d_context *context, const struct wined3d_state *state)
5538 {
5539
5540 if (context->use_immediate_mode_draw)
5541 return;
5542
5543 context_unload_vertex_data(context);
5544 if (context->d3d_info->ffp_generic_attributes || use_vs(state))
5545 {
5546 TRACE("Loading numbered arrays.\n");
5547 context_load_numbered_arrays(context, &context->stream_info, state);
5548 return;
5549 }
5550
5551 TRACE("Loading named arrays.\n");
5552 context_unload_numbered_arrays(context);
5553 context_load_vertex_data(context, &context->stream_info, state);
5554 context->namedArraysLoaded = TRUE;
5555 }
5556
5557 static void apply_texture_blit_state(const struct wined3d_gl_info *gl_info, struct gl_texture *texture,
5558 GLenum target, unsigned int level, enum wined3d_texture_filter_type filter)
5559 {
5560 gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAG_FILTER, wined3d_gl_mag_filter(filter));
5561 gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
5562 wined3d_gl_min_mip_filter(filter, WINED3D_TEXF_NONE));
5563 gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
5564 gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
5565 if (gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
5566 gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT, GL_SKIP_DECODE_EXT);
5567 gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, level);
5568
5569 /* We changed the filtering settings on the texture. Make sure they get
5570 * reset on subsequent draws. */
5571 texture->sampler_desc.mag_filter = WINED3D_TEXF_POINT;
5572 texture->sampler_desc.min_filter = WINED3D_TEXF_POINT;
5573 texture->sampler_desc.mip_filter = WINED3D_TEXF_NONE;
5574 texture->sampler_desc.address_u = WINED3D_TADDRESS_CLAMP;
5575 texture->sampler_desc.address_v = WINED3D_TADDRESS_CLAMP;
5576 texture->sampler_desc.srgb_decode = FALSE;
5577 texture->base_level = level;
5578 }
5579
5580 /* Context activation is done by the caller. */
5581 void context_draw_shaded_quad(struct wined3d_context *context, struct wined3d_texture_gl *texture_gl,
5582 unsigned int sub_resource_idx, const RECT *src_rect, const RECT *dst_rect,
5583 enum wined3d_texture_filter_type filter)
5584 {
5585 const struct wined3d_gl_info *gl_info = context->gl_info;
5586 struct wined3d_blt_info info;
5587 unsigned int level, w, h, i;
5588 SIZE dst_size;
5589 struct blit_vertex
5590 {
5591 float x, y;
5592 struct wined3d_vec3 texcoord;
5593 }
5594 quad[4];
5595
5596 texture2d_get_blt_info(texture_gl, sub_resource_idx, src_rect, &info);
5597
5598 level = sub_resource_idx % texture_gl->t.level_count;
5599 context_bind_texture(context, info.bind_target, texture_gl->texture_rgb.name);
5600 apply_texture_blit_state(gl_info, &texture_gl->texture_rgb, info.bind_target, level, filter);
5601 gl_info->gl_ops.gl.p_glTexParameteri(info.bind_target, GL_TEXTURE_MAX_LEVEL, level);
5602
5603 context_get_rt_size(context, &dst_size);
5604 w = dst_size.cx;
5605 h = dst_size.cy;
5606
5607 quad[0].x = dst_rect->left * 2.0f / w - 1.0f;
5608 quad[0].y = dst_rect->top * 2.0f / h - 1.0f;
5609 quad[0].texcoord = info.texcoords[0];
5610
5611 quad[1].x = dst_rect->right * 2.0f / w - 1.0f;
5612 quad[1].y = dst_rect->top * 2.0f / h - 1.0f;
5613 quad[1].texcoord = info.texcoords[1];
5614
5615 quad[2].x = dst_rect->left * 2.0f / w - 1.0f;
5616 quad[2].y = dst_rect->bottom * 2.0f / h - 1.0f;
5617 quad[2].texcoord = info.texcoords[2];
5618
5619 quad[3].x = dst_rect->right * 2.0f / w - 1.0f;
5620 quad[3].y = dst_rect->bottom * 2.0f / h - 1.0f;
5621 quad[3].texcoord = info.texcoords[3];
5622
5623 /* Draw a quad. */
5624 if (gl_info->supported[ARB_VERTEX_BUFFER_OBJECT])
5625 {
5626 if (!context->blit_vbo)
5627 GL_EXTCALL(glGenBuffers(1, &context->blit_vbo));
5628 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, context->blit_vbo));
5629
5630 context_unload_vertex_data(context);
5631 context_unload_numbered_arrays(context);
5632
5633 GL_EXTCALL(glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STREAM_DRAW));
5634 GL_EXTCALL(glVertexAttribPointer(0, 2, GL_FLOAT, FALSE, sizeof(*quad), NULL));
5635 GL_EXTCALL(glVertexAttribPointer(1, 3, GL_FLOAT, FALSE, sizeof(*quad),
5636 (void *)FIELD_OFFSET(struct blit_vertex, texcoord)));
5637
5638 GL_EXTCALL(glEnableVertexAttribArray(0));
5639 GL_EXTCALL(glEnableVertexAttribArray(1));
5640
5641 gl_info->gl_ops.gl.p_glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
5642
5643 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER, 0));
5644 GL_EXTCALL(glDisableVertexAttribArray(1));
5645 GL_EXTCALL(glDisableVertexAttribArray(0));
5646 }
5647 else
5648 {
5649 gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
5650
5651 for (i = 0; i < ARRAY_SIZE(quad); ++i)
5652 {
5653 GL_EXTCALL(glVertexAttrib3fv(1, &quad[i].texcoord.x));
5654 GL_EXTCALL(glVertexAttrib2fv(0, &quad[i].x));
5655 }
5656
5657 gl_info->gl_ops.gl.p_glEnd();
5658 }
5659 checkGLcall("draw");
5660
5661 gl_info->gl_ops.gl.p_glTexParameteri(info.bind_target, GL_TEXTURE_MAX_LEVEL, texture_gl->t.level_count - 1);
5662 context_bind_texture(context, info.bind_target, 0);
5663 }
5664
5665 /* Context activation is done by the caller. */
5666 void context_draw_textured_quad(struct wined3d_context *context, struct wined3d_texture_gl *texture_gl,
5667 unsigned int sub_resource_idx, const RECT *src_rect, const RECT *dst_rect,
5668 enum wined3d_texture_filter_type filter)
5669 {
5670 const struct wined3d_gl_info *gl_info = context->gl_info;
5671 struct wined3d_blt_info info;
5672 unsigned int level;
5673
5674 texture2d_get_blt_info(texture_gl, sub_resource_idx, src_rect, &info);
5675
5676 gl_info->gl_ops.gl.p_glEnable(info.bind_target);
5677 checkGLcall("glEnable(bind_target)");
5678
5679 level = sub_resource_idx % texture_gl->t.level_count;
5680 context_bind_texture(context, info.bind_target, texture_gl->texture_rgb.name);
5681 apply_texture_blit_state(gl_info, &texture_gl->texture_rgb, info.bind_target, level, filter);
5682 gl_info->gl_ops.gl.p_glTexParameteri(info.bind_target, GL_TEXTURE_MAX_LEVEL, level);
5683 gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
5684 checkGLcall("glTexEnvi");
5685
5686 /* Draw a quad. */
5687 gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
5688 gl_info->gl_ops.gl.p_glTexCoord3fv(&info.texcoords[0].x);
5689 gl_info->gl_ops.gl.p_glVertex2i(dst_rect->left, dst_rect->top);
5690
5691 gl_info->gl_ops.gl.p_glTexCoord3fv(&info.texcoords[1].x);
5692 gl_info->gl_ops.gl.p_glVertex2i(dst_rect->right, dst_rect->top);
5693
5694 gl_info->gl_ops.gl.p_glTexCoord3fv(&info.texcoords[2].x);
5695 gl_info->gl_ops.gl.p_glVertex2i(dst_rect->left, dst_rect->bottom);
5696
5697 gl_info->gl_ops.gl.p_glTexCoord3fv(&info.texcoords[3].x);
5698 gl_info->gl_ops.gl.p_glVertex2i(dst_rect->right, dst_rect->bottom);
5699 gl_info->gl_ops.gl.p_glEnd();
5700
5701 gl_info->gl_ops.gl.p_glTexParameteri(info.bind_target, GL_TEXTURE_MAX_LEVEL, texture_gl->t.level_count - 1);
5702 context_bind_texture(context, info.bind_target, 0);
5703 }
Windows API implementation