git.oblomov.eu Git - wine/blob - dlls/wined3d/context.c

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