af062818b47340eef15700d2f0211576ba3506eevboxsync * Context and render target management in wined3d
af062818b47340eef15700d2f0211576ba3506eevboxsync * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync * Copyright 2009 Henri Verbeet for CodeWeavers
af062818b47340eef15700d2f0211576ba3506eevboxsync * This library is free software; you can redistribute it and/or
af062818b47340eef15700d2f0211576ba3506eevboxsync * modify it under the terms of the GNU Lesser General Public
af062818b47340eef15700d2f0211576ba3506eevboxsync * License as published by the Free Software Foundation; either
af062818b47340eef15700d2f0211576ba3506eevboxsync * version 2.1 of the License, or (at your option) any later version.
af062818b47340eef15700d2f0211576ba3506eevboxsync * This library is distributed in the hope that it will be useful,
af062818b47340eef15700d2f0211576ba3506eevboxsync * but WITHOUT ANY WARRANTY; without even the implied warranty of
af062818b47340eef15700d2f0211576ba3506eevboxsync * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
af062818b47340eef15700d2f0211576ba3506eevboxsync * Lesser General Public License for more details.
af062818b47340eef15700d2f0211576ba3506eevboxsync * You should have received a copy of the GNU Lesser General Public
af062818b47340eef15700d2f0211576ba3506eevboxsync * License along with this library; if not, write to the Free Software
af062818b47340eef15700d2f0211576ba3506eevboxsync * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
4b9d6701570cb98fd36e209314239d104ec584d3vboxsync * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
4b9d6701570cb98fd36e209314239d104ec584d3vboxsync * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
b955672b950093ff7416d1269dd4d3b69983bd8fvboxsync * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
b955672b950093ff7416d1269dd4d3b69983bd8fvboxsync * a choice of LGPL license versions is made available with the language indicating
b955672b950093ff7416d1269dd4d3b69983bd8fvboxsync * that LGPLv2 or any later version may be used, or where a choice of which version
b955672b950093ff7416d1269dd4d3b69983bd8fvboxsync * of the LGPL is applied is otherwise unspecified.
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync# define vboxGetCurrentContext() VBoxTlsRefGetCurrent(struct wined3d_context, wined3d_context_tls_idx)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync# define vboxSetCurrentContext(_ctx) VBoxTlsRefSetCurrent(struct wined3d_context, wined3d_context_tls_idx, (_ctx))
af062818b47340eef15700d2f0211576ba3506eevboxsync/* FBO helper functions */
040b4a09341f574825386333398110f4db3e1e51vboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncvoid context_bind_fbo(struct wined3d_context *context, GLenum target, GLuint *fbo)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
040b4a09341f574825386333398110f4db3e1e51vboxsyncstatic void context_clean_fbo_attachments(const struct wined3d_gl_info *gl_info)
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync unsigned int i;
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, 0, 0);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void context_destroy_fbo(struct wined3d_context *context, GLuint *fbo)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsyncstatic void context_apply_attachment_filter_states(IWineD3DSurfaceImpl *surface)
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Update base texture states array */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *)surface,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync &IID_IWineD3DBaseTexture, (void **)&texture_impl)))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync IWineD3DDeviceImpl *device = surface->resource.device;
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync if (texture_impl->baseTexture.texture_rgb.states[WINED3DTEXSTA_MINFILTER] != WINED3DTEXF_POINT
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync || texture_impl->baseTexture.texture_rgb.states[WINED3DTEXSTA_MIPFILTER] != WINED3DTEXF_NONE)
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync texture_impl->baseTexture.texture_rgb.states[WINED3DTEXSTA_MINFILTER] = WINED3DTEXF_POINT;
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync texture_impl->baseTexture.texture_rgb.states[WINED3DTEXSTA_MIPFILTER] = WINED3DTEXF_NONE;
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync if (texture_impl->baseTexture.texture_rgb.states[WINED3DTEXSTA_MAGFILTER] != WINED3DTEXF_POINT)
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync texture_impl->baseTexture.texture_rgb.states[WINED3DTEXSTA_MAGFILTER] = WINED3DTEXF_POINT;
af062818b47340eef15700d2f0211576ba3506eevboxsync WARN("Render targets should not be bound to a sampler\n");
040b4a09341f574825386333398110f4db3e1e51vboxsync IWineD3DDeviceImpl_MarkStateDirty(device, STATE_SAMPLER(texture_impl->baseTexture.sampler));
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DBaseTexture_Release((IWineD3DBaseTexture *)texture_impl);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_binding);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP_ARB, &old_binding);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (update_minfilter) glTexParameteri(bind_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (update_magfilter) glTexParameteri(bind_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncvoid context_attach_depth_stencil_fbo(struct wined3d_context *context,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync GLenum fbo_target, IWineD3DSurfaceImpl *depth_stencil, BOOL use_render_buffer)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync DWORD format_flags = depth_stencil->resource.format_desc->Flags;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (use_render_buffer && depth_stencil->current_renderbuffer)
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_DEPTH_ATTACHMENT,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync GL_RENDERBUFFER, depth_stencil->current_renderbuffer->id);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferRenderbuffer(fbo_target, GL_STENCIL_ATTACHMENT,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync GL_RENDERBUFFER, depth_stencil->current_renderbuffer->id);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync surface_prepare_texture(depth_stencil, gl_info, FALSE);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context_apply_attachment_filter_states(depth_stencil);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_DEPTH_ATTACHMENT,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync depth_stencil->texture_target, depth_stencil->texture_name,
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_STENCIL_ATTACHMENT,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync depth_stencil->texture_target, depth_stencil->texture_name,
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncvoid context_attach_surface_fbo(const struct wined3d_context *context,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync GLenum fbo_target, DWORD idx, IWineD3DSurfaceImpl *surface)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_COLOR_ATTACHMENT0 + idx, surface->texture_target,
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync gl_info->fbo_ops.glFramebufferTexture2D(fbo_target, GL_COLOR_ATTACHMENT0 + idx, GL_TEXTURE_2D, 0, 0);
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void context_check_fbo_status(struct wined3d_context *context)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
af062818b47340eef15700d2f0211576ba3506eevboxsync unsigned int i;
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("FBO status %s (%#x)\n", debug_fbostatus(status), status);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync /* Dump the FBO attachments */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync attachment = context->current_fbo->render_targets[i];
5112e32d7072e280613921c982a6672f2c859cf3vboxsync i, attachment, debug_d3dformat(attachment->resource.format_desc->format),
5112e32d7072e280613921c982a6672f2c859cf3vboxsync attachment, debug_d3dformat(attachment->resource.format_desc->format),
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic struct fbo_entry *context_create_fbo_entry(struct wined3d_context *context)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
6b9422045350f9373da5033a86972ce1131dd356vboxsync IWineD3DDeviceImpl *device = context_get_device(context);
af062818b47340eef15700d2f0211576ba3506eevboxsync entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
5112e32d7072e280613921c982a6672f2c859cf3vboxsync entry->render_targets = HeapAlloc(GetProcessHeap(), 0, gl_info->limits.buffers * sizeof(*entry->render_targets));
5112e32d7072e280613921c982a6672f2c859cf3vboxsync memcpy(entry->render_targets, device->render_targets, gl_info->limits.buffers * sizeof(*entry->render_targets));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync entry->depth_stencil = (IWineD3DSurfaceImpl *)device->stencilBufferTarget;
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void context_reuse_fbo_entry(struct wined3d_context *context, struct fbo_entry *entry)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
6b9422045350f9373da5033a86972ce1131dd356vboxsync IWineD3DDeviceImpl *device = context_get_device(context);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync context_bind_fbo(context, GL_FRAMEBUFFER, &entry->id);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync memcpy(entry->render_targets, device->render_targets, gl_info->limits.buffers * sizeof(*entry->render_targets));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync entry->depth_stencil = (IWineD3DSurfaceImpl *)device->stencilBufferTarget;
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void context_destroy_fbo_entry(struct wined3d_context *context, struct fbo_entry *entry)
af062818b47340eef15700d2f0211576ba3506eevboxsync HeapFree(GetProcessHeap(), 0, entry->render_targets);
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic struct fbo_entry *context_find_fbo_entry(struct wined3d_context *context)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
6b9422045350f9373da5033a86972ce1131dd356vboxsync IWineD3DDeviceImpl *device = context_get_device(context);
af062818b47340eef15700d2f0211576ba3506eevboxsync LIST_FOR_EACH_ENTRY(entry, &context->fbo_list, struct fbo_entry, entry)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync device->render_targets, gl_info->limits.buffers * sizeof(*entry->render_targets))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync && entry->depth_stencil == (IWineD3DSurfaceImpl *)device->stencilBufferTarget)
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync if (context->fbo_entry_count < WINED3D_MAX_FBO_ENTRIES)
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync entry = LIST_ENTRY(list_tail(&context->fbo_list), struct fbo_entry, entry);
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void context_apply_fbo_entry(struct wined3d_context *context, struct fbo_entry *entry)
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
6b9422045350f9373da5033a86972ce1131dd356vboxsync IWineD3DDeviceImpl *device = context_get_device(context);
af062818b47340eef15700d2f0211576ba3506eevboxsync unsigned int i;
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync context_bind_fbo(context, GL_FRAMEBUFFER, &entry->id);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Apply render targets */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync IWineD3DSurfaceImpl *render_target = (IWineD3DSurfaceImpl *)device->render_targets[i];
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync context_attach_surface_fbo(context, GL_FRAMEBUFFER, i, render_target);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Apply depth targets */
040b4a09341f574825386333398110f4db3e1e51vboxsync unsigned int w = ((IWineD3DSurfaceImpl *)device->render_targets[0])->pow2Width;
040b4a09341f574825386333398110f4db3e1e51vboxsync unsigned int h = ((IWineD3DSurfaceImpl *)device->render_targets[0])->pow2Height;
040b4a09341f574825386333398110f4db3e1e51vboxsync surface_set_compatible_renderbuffer(device->stencilBufferTarget, w, h);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context_attach_depth_stencil_fbo(context, GL_FRAMEBUFFER, (IWineD3DSurfaceImpl *)device->stencilBufferTarget, TRUE);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context_apply_attachment_filter_states((IWineD3DSurfaceImpl *)device->render_targets[i]);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context_apply_attachment_filter_states((IWineD3DSurfaceImpl *)device->stencilBufferTarget);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync device->draw_buffers[i] = GL_COLOR_ATTACHMENT0 + i;
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void context_apply_fbo_state(struct wined3d_context *context)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_destroy_list, struct fbo_entry, entry)
040b4a09341f574825386333398110f4db3e1e51vboxsync context->current_fbo = context_find_fbo_entry(context);
040b4a09341f574825386333398110f4db3e1e51vboxsync context_apply_fbo_entry(context, context->current_fbo);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync/* Context activation is done by the caller. */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncvoid context_alloc_occlusion_query(struct wined3d_context *context, struct wined3d_occlusion_query *query)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync query->id = context->free_occlusion_queries[--context->free_occlusion_query_count];
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync TRACE("Allocated occlusion query %u in context %p.\n", query->id, context);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync WARN("Occlusion queries not supported, not allocating query id.\n");
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync list_add_head(&context->occlusion_queries, &query->entry);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncvoid context_free_occlusion_query(struct wined3d_occlusion_query *query)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync if (context->free_occlusion_query_count >= context->free_occlusion_query_size - 1)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync UINT new_size = context->free_occlusion_query_size << 1;
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync GLuint *new_data = HeapReAlloc(GetProcessHeap(), 0, context->free_occlusion_queries,
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync new_size * sizeof(*context->free_occlusion_queries));
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync ERR("Failed to grow free list, leaking query %u in context %p.\n", query->id, context);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync context->free_occlusion_queries[context->free_occlusion_query_count++] = query->id;
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync/* Context activation is done by the caller. */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncvoid context_alloc_event_query(struct wined3d_context *context, struct wined3d_event_query *query)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync query->object = context->free_event_queries[--context->free_event_query_count];
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Using ARB_sync, not much to do here. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Allocated event query %p in context %p.\n", query->object.sync, context);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync GL_EXTCALL(glGenFencesAPPLE(1, &query->object.id));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Allocated event query %u in context %p.\n", query->object.id, context);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Allocated event query %u in context %p.\n", query->object.id, context);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync WARN("Event queries not supported, not allocating query id.\n");
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync list_add_head(&context->event_queries, &query->entry);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncvoid context_free_event_query(struct wined3d_event_query *query)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync if (context->free_event_query_count >= context->free_event_query_size - 1)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync UINT new_size = context->free_event_query_size << 1;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync union wined3d_gl_query_object *new_data = HeapReAlloc(GetProcessHeap(), 0, context->free_event_queries,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("Failed to grow free list, leaking query %u in context %p.\n", query->object.id, context);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context->free_event_queries[context->free_event_query_count++] = query->object;
af062818b47340eef15700d2f0211576ba3506eevboxsyncvoid context_resource_released(IWineD3DDevice *iface, IWineD3DResource *resource, WINED3DRESOURCETYPE type)
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync struct wined3d_context *context = This->contexts[i];
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync if (context->current_rt == (IWineD3DSurface *)resource) context->current_rt = NULL;
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_list, struct fbo_entry, entry)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (entry->depth_stencil == (IWineD3DSurfaceImpl *)resource)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync list_add_head(&context->fbo_destroy_list, &entry->entry);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (entry->render_targets[j] == (IWineD3DSurfaceImpl *)resource)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync list_add_head(&context->fbo_destroy_list, &entry->entry);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsyncvoid context_surface_update(struct wined3d_context *context, IWineD3DSurfaceImpl *surface)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync unsigned int i;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Updated surface %p is bound as color attachment %u to the current FBO.\n", surface, i);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Updated surface %p is bound as depth attachment to the current FBO.\n", surface);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsyncstatic BOOL context_set_pixel_format(const struct wined3d_gl_info *gl_info, HDC dc, int format)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("Failed to set pixel format %d on device context %p, last error %#x.\n",
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* By default WGL doesn't allow pixel format adjustments but we need it
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * here. For this reason there's a Wine specific wglSetPixelFormat()
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * which allows us to set the pixel format multiple times. Only use it
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * when really needed. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH])
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (!GL_EXTCALL(wglSetPixelFormatWINE(dc, format, NULL)))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("wglSetPixelFormatWINE failed to set pixel format %d on device context %p.\n",
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* OpenGL doesn't allow pixel format adjustments. Print an error and
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * continue using the old format. There's a big chance that the old
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * format works although with a performance hit and perhaps rendering
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * errors. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("Unable to set pixel format %d on device context %p. Already using format %d.\n",
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsyncstatic BOOL swapchain_validate(IWineD3DSwapChainImpl *swapchain)
bf7ab711aa3580b3a587dcbc4653fe78c99fff37vboxsync ERR("Unexpected swapchain for dc %p window expected %p, but was %p.\n", swapchain->hDC, swapchain->win_handle, hWnd);
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsyncstatic IWineD3DSwapChainImpl * swapchain_find_valid(IWineD3DDeviceImpl *device)
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsync for (i = device->NumberOfSwapChains - 1; i >= 0 ; --i)
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsync if (swapchain_validate((IWineD3DSwapChainImpl*)device->swapchains[i]))
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsync return (IWineD3DSwapChainImpl*)device->swapchains[i];
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsyncstatic void context_update_window(struct wined3d_context *context
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync TRACE("Updating context %p swapchain from %p to %p.\n",
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync if (!context_set_pixel_format(context->gl_info, swapchain->hDC, context->pixel_format))
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync ERR("Failed to set pixel format %d on device context %p.\n",
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync if (!pwglMakeCurrent(swapchain->hDC, context->glCtx))
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync ERR("Failed to make GL context %p current on device context %p, last error %#x.\n",
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Updating context %p window from %p to %p.\n",
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context, context->win_handle, context->swapchain->win_handle);
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync if (!VBoxExtReleaseDC(context->win_handle, context->hdc))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("Failed to release device context %p, last error %#x.\n",
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context->win_handle = context->swapchain->win_handle;
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync if (!(context->hdc = VBoxExtGetDC(context->win_handle)))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("Failed to get a device context for window %p.\n", context->win_handle);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (!context_set_pixel_format(context->gl_info, context->hdc, context->pixel_format))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("Failed to set pixel format %d on device context %p.\n",
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (!pwglMakeCurrent(context->hdc, context->glCtx))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("Failed to make GL context %p current on device context %p, last error %#x.\n",
6ce53b61ec00c84abbe9936d7a179c687db124e6vboxsyncstatic void context_validate(struct wined3d_context *context
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync context->valid = swapchain_validate(context->currentSwapchain);
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsync WARN("DC %p belongs to window %p instead of %p., winEr(%d)\n",
a203cc901f73b4c5d67aae8906e42fbda9af1d4fvboxsync if (context->swapchain && context->win_handle != context->swapchain->win_handle)
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsyncstatic void context_validate_adjust_wnd(struct wined3d_context *context)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void context_destroy_gl_resources(struct wined3d_context *context)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync unsigned int i;
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync if (context->valid && restore_ctx != context->glCtx) pwglMakeCurrent(context->currentSwapchain->hDC, context->glCtx);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync if (context->valid && restore_ctx != context->glCtx) pwglMakeCurrent(context->hdc, context->glCtx);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync LIST_FOR_EACH_ENTRY(occlusion_query, &context->occlusion_queries, struct wined3d_occlusion_query, entry)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync if (context->valid && gl_info->supported[ARB_OCCLUSION_QUERY])
5112e32d7072e280613921c982a6672f2c859cf3vboxsync GL_EXTCALL(glDeleteQueriesARB(1, &occlusion_query->id));
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync LIST_FOR_EACH_ENTRY(event_query, &context->event_queries, struct wined3d_event_query, entry)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (event_query->object.sync) GL_EXTCALL(glDeleteSync(event_query->object.sync));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync else if (gl_info->supported[APPLE_FENCE]) GL_EXTCALL(glDeleteFencesAPPLE(1, &event_query->object.id));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync else if (gl_info->supported[NV_FENCE]) GL_EXTCALL(glDeleteFencesNV(1, &event_query->object.id));
5112e32d7072e280613921c982a6672f2c859cf3vboxsync LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_destroy_list, struct fbo_entry, entry)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &context->fbo_list, struct fbo_entry, entry)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync GL_EXTCALL(glDeleteProgramsARB(1, &context->dummy_arbfp_prog));
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync GL_EXTCALL(glDeleteQueriesARB(context->free_occlusion_query_count, context->free_occlusion_queries));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (event_query->object.sync) GL_EXTCALL(glDeleteSync(event_query->object.sync));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync for (i = 0; i < context->free_event_query_count; ++i)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync GL_EXTCALL(glDeleteFencesAPPLE(1, &context->free_event_queries[i].id));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync for (i = 0; i < context->free_event_query_count; ++i)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync GL_EXTCALL(glDeleteFencesNV(1, &context->free_event_queries[i].id));
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync HeapFree(GetProcessHeap(), 0, context->free_occlusion_queries);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync HeapFree(GetProcessHeap(), 0, context->free_event_queries);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync ERR("Failed to restore GL context %p on device context %p, last error %#x.\n",
5112e32d7072e280613921c982a6672f2c859cf3vboxsync else if (pwglGetCurrentContext() && !pwglMakeCurrent(NULL, NULL))
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync VBoxExtReleaseDC(context->win_handle, context->hdc);
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync VBoxExtReleaseDC(context->win_handle, context->hdc);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync ERR("wglDeleteContext(%p) failed, last error %#x.\n", context->glCtx, err);
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsyncstatic struct wined3d_context *context_get_current_ex(DWORD adjustTid)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync struct wined3d_context *ctx = vboxGetCurrentContext();
4a4f3fbc8663316b63f570e53e2432e19b18da74vboxsync /* this is a destroyed context left in the tls of the current thread */
4a4f3fbc8663316b63f570e53e2432e19b18da74vboxsync /* 1. this releases the context and clears the tls */
4a4f3fbc8663316b63f570e53e2432e19b18da74vboxsync /* return there is no context current */
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if !defined(VBOX_WINE_WITH_SINGLE_CONTEXT) && !defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncBOOL context_set_current(struct wined3d_context *ctx)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync struct wined3d_context *old = context_get_current_ex(0);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync struct wined3d_context *old = context_get_current();
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync TRACE("Switching away from destroyed context %p.\n", old);
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync TRACE("Switching to D3D context %p, GL context %p, device context %p.\n", ctx, ctx->glCtx, ctx->currentSwapchain->hDC);
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync if (!pwglMakeCurrent(ctx->currentSwapchain->hDC, ctx->glCtx))
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync ERR("Failed to make GL context %p current on device context %p, last error %#x.\n",
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync TRACE("Switching to D3D context %p, GL context %p, device context %p.\n", ctx, ctx->glCtx, ctx->hdc);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync ERR("Failed to make GL context %p current on device context %p, last error %#x.\n",
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync ERR("Failed to clear current GL context, last error %#x.\n", err);
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if !defined(VBOX_WINE_WITH_SINGLE_CONTEXT) && !defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync /* In theory, we should do context_set_current(NULL) here,
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * but since it may result in calling a context dtor, it should be done under wined3d lock.
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * We can not acquire a wined3d lock here since this routine is called in a DllMain context
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * and this would result in a lock order violation, which may result in a deadlock.
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * In other words, wined3d may internally call Win32 API functions which result in
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * a DLL lock acquisition while holding wined3d lock.
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * So lock order should always be "wined3d lock" -> "dll lock".
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * This is why we do the following:
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync /* 1. get the current context w/o adjusting its thread id, etc. */
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync struct wined3d_context *old = context_get_current_ex(0);
91563ca66c54f5974bd78d4a8e51e1a690c03e0fvboxsync// /* there is a currently assigned context,
91563ca66c54f5974bd78d4a8e51e1a690c03e0fvboxsync// * 2. now increase its ref count to ensure its dtor routine is not called while making set_current(NULL).
91563ca66c54f5974bd78d4a8e51e1a690c03e0fvboxsync// * This is needed since dtor can only be run with a wined3d lock held */
91563ca66c54f5974bd78d4a8e51e1a690c03e0fvboxsync// VBoxTlsRefAddRef(old);
91563ca66c54f5974bd78d4a8e51e1a690c03e0fvboxsync /* context_tls_dtor now does only memfree, so just call it right away */
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync /* 3. now we can call context_set_current(NULL) */
91563ca66c54f5974bd78d4a8e51e1a690c03e0fvboxsync// /* 4. to avoid possible deadlocks we make an asynchronous call to a worker thread to make
91563ca66c54f5974bd78d4a8e51e1a690c03e0fvboxsync// * wined3d lock - context release - wined3d unlock from there. */
91563ca66c54f5974bd78d4a8e51e1a690c03e0fvboxsync// VBoxExtReleaseContextAsync(old);
5112e32d7072e280613921c982a6672f2c859cf3vboxsyncvoid context_release(struct wined3d_context *context)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync TRACE("Releasing context %p, level %u.\n", context, context->level);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync WARN("Context %p is not the current context.\n", context);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync TRACE("Restoring GL context %p on device context %p.\n", context->restore_ctx, context->restore_dc);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync if (!pwglMakeCurrent(context->restore_dc, context->restore_ctx))
5112e32d7072e280613921c982a6672f2c859cf3vboxsync ERR("Failed to restore GL context %p on device context %p, last error %#x.\n",
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync /* success branch */
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync /* sync back our tls with gl settings */
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync const struct wined3d_context *current_context = context_get_current();
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync if (current_context && current_context->glCtx != context->restore_ctx)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync IWineD3DDeviceImpl *device = context->swapchain->device;
5112e32d7072e280613921c982a6672f2c859cf3vboxsyncstatic void context_enter(struct wined3d_context *context)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync TRACE("Entering context %p, level %u.\n", context, context->level + 1);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync const struct wined3d_context *current_context = context_get_current();
5112e32d7072e280613921c982a6672f2c859cf3vboxsync if (current_gl && (!current_context || current_context->glCtx != current_gl))
5112e32d7072e280613921c982a6672f2c859cf3vboxsync TRACE("Another GL context (%p on device context %p) is already current.\n",
af062818b47340eef15700d2f0211576ba3506eevboxsync/*****************************************************************************
af062818b47340eef15700d2f0211576ba3506eevboxsync * Context_MarkStateDirty
af062818b47340eef15700d2f0211576ba3506eevboxsync * Marks a state in a context dirty. Only one context, opposed to
af062818b47340eef15700d2f0211576ba3506eevboxsync * IWineD3DDeviceImpl_MarkStateDirty, which marks the state dirty in all
af062818b47340eef15700d2f0211576ba3506eevboxsync * context: Context to mark the state dirty in
af062818b47340eef15700d2f0211576ba3506eevboxsync * state: State to mark dirty
af062818b47340eef15700d2f0211576ba3506eevboxsync * StateTable: Pointer to the state table in use(for state grouping)
af062818b47340eef15700d2f0211576ba3506eevboxsync *****************************************************************************/
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void Context_MarkStateDirty(struct wined3d_context *context, DWORD state, const struct StateEntry *StateTable)
af062818b47340eef15700d2f0211576ba3506eevboxsync context->dirtyArray[context->numDirtyEntries++] = rep;
5112e32d7072e280613921c982a6672f2c859cf3vboxsync idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
af062818b47340eef15700d2f0211576ba3506eevboxsync/* This function takes care of WineD3D pixel format selection. */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsyncstatic int WineD3D_ChoosePixelFormat(IWineD3DDeviceImpl *This, HDC hdc,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync const struct wined3d_format_desc *color_format_desc, const struct wined3d_format_desc *ds_format_desc,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync BOOL auxBuffers, int numSamples, BOOL findCompatible)
af062818b47340eef15700d2f0211576ba3506eevboxsync short redBits, greenBits, blueBits, alphaBits, colorBits;
af062818b47340eef15700d2f0211576ba3506eevboxsync /* First, try without alpha match buffers. MacOS supports aux buffers only
af062818b47340eef15700d2f0211576ba3506eevboxsync * on A8R8G8B8, and we prefer better offscreen rendering over an alpha match.
af062818b47340eef15700d2f0211576ba3506eevboxsync * Then try without aux buffers - this is the most common cause for not
af062818b47340eef15700d2f0211576ba3506eevboxsync * finding a pixel format. Also some drivers(the open source ones)
af062818b47340eef15700d2f0211576ba3506eevboxsync * only offer 32 bit ARB pixel formats. First try without an exact alpha
af062818b47340eef15700d2f0211576ba3506eevboxsync * match, then try without an exact alpha and color match.
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("ColorFormat=%s, DepthStencilFormat=%s, auxBuffers=%d, numSamples=%d, findCompatible=%d\n",
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync debug_d3dformat(color_format_desc->format), debug_d3dformat(ds_format_desc->format),
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync if (!getColorBits(color_format_desc, &redBits, &greenBits, &blueBits, &alphaBits, &colorBits))
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync ERR("Unable to get color bits for format %s (%#x)!\n",
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync debug_d3dformat(color_format_desc->format), color_format_desc->format);
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync getDepthStencilBits(ds_format_desc, &depthBits, &stencilBits);
af062818b47340eef15700d2f0211576ba3506eevboxsync for(matchtry = 0; matchtry < (sizeof(matches) / sizeof(matches[0])) && !iPixelFormat; matchtry++) {
af062818b47340eef15700d2f0211576ba3506eevboxsync for(i=0; i<nCfgs; i++) {
af062818b47340eef15700d2f0211576ba3506eevboxsync WineD3D_PixelFormat *cfg = &This->adapter->cfgs[i];
af062818b47340eef15700d2f0211576ba3506eevboxsync /* For now only accept RGBA formats. Perhaps some day we will
af062818b47340eef15700d2f0211576ba3506eevboxsync * allow floating point formats for pbuffers. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* In window mode we need a window drawable format and double buffering. */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* We like to have aux buffers in backbuffer mode */
af062818b47340eef15700d2f0211576ba3506eevboxsync if(auxBuffers && !cfg->auxBuffers && matches[matchtry].require_aux)
af062818b47340eef15700d2f0211576ba3506eevboxsync /* We try to locate a format which matches our requirements exactly. In case of
af062818b47340eef15700d2f0211576ba3506eevboxsync * depth it is no problem to emulate 16-bit using e.g. 24-bit, so accept that. */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* In all cases make sure the number of stencil bits matches our requirements
af062818b47340eef15700d2f0211576ba3506eevboxsync * even when we don't need stencil because it could affect performance EXCEPT
af062818b47340eef15700d2f0211576ba3506eevboxsync * on cards which don't offer depth formats without stencil like the i915 drivers
af062818b47340eef15700d2f0211576ba3506eevboxsync * on Linux. */
af062818b47340eef15700d2f0211576ba3506eevboxsync if(stencilBits != cfg->stencilSize && !(This->adapter->brokenStencil && stencilBits <= cfg->stencilSize))
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Check multisampling support */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* When we have passed all the checks then we have found a format which matches our
af062818b47340eef15700d2f0211576ba3506eevboxsync * requirements. Note that we only check for a limit number of capabilities right now,
af062818b47340eef15700d2f0211576ba3506eevboxsync * so there can easily be a dozen of pixel formats which appear to be the 'same' but
af062818b47340eef15700d2f0211576ba3506eevboxsync * can still differ in things like multisampling, stereo, SRGB and other flags.
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Exit the loop as we have found a format :) */
af062818b47340eef15700d2f0211576ba3506eevboxsync } else if(!iPixelFormat) {
af062818b47340eef15700d2f0211576ba3506eevboxsync /* In the end we might end up with a format which doesn't exactly match our depth
af062818b47340eef15700d2f0211576ba3506eevboxsync * requirements. Accept the first format we found because formats with higher iPixelFormat
af062818b47340eef15700d2f0211576ba3506eevboxsync * values tend to have more extended capabilities (e.g. multisampling) which we don't need. */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* When findCompatible is set and no suitable format was found, let ChoosePixelFormat choose a pixel format in order not to crash. */
af062818b47340eef15700d2f0211576ba3506eevboxsync } else if(!iPixelFormat) {
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("Falling back to ChoosePixelFormat as we weren't able to find an exactly matching pixel format\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync /* PixelFormat selection */
af062818b47340eef15700d2f0211576ba3506eevboxsync pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW;/*PFD_GENERIC_ACCELERATED*/
af062818b47340eef15700d2f0211576ba3506eevboxsync /* If this happens something is very wrong as ChoosePixelFormat barely fails */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync TRACE("Found iPixelFormat=%d for ColorFormat=%s, DepthStencilFormat=%s\n",
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync iPixelFormat, debug_d3dformat(color_format_desc->format), debug_d3dformat(ds_format_desc->format));
6b9422045350f9373da5033a86972ce1131dd356vboxsyncstruct IWineD3DDeviceImpl *context_get_device(const struct wined3d_context *context)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsyncstatic DECLCALLBACK(void) context_tls_dtor(void* pvCtx)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync struct wined3d_context * context = (struct wined3d_context *)pvCtx;
af062818b47340eef15700d2f0211576ba3506eevboxsync/*****************************************************************************
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * context_create
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * Creates a new context.
af062818b47340eef15700d2f0211576ba3506eevboxsync * * Params:
af062818b47340eef15700d2f0211576ba3506eevboxsync * This: Device to activate the context for
af062818b47340eef15700d2f0211576ba3506eevboxsync * target: Surface this context will render to
af062818b47340eef15700d2f0211576ba3506eevboxsync * win_handle: handle to the window which we are drawing to
af062818b47340eef15700d2f0211576ba3506eevboxsync * pPresentParameters: contains the pixelformats to use for onscreen rendering
af062818b47340eef15700d2f0211576ba3506eevboxsync *****************************************************************************/
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsyncstruct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3DSurfaceImpl *target,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync const struct wined3d_format_desc *color_format_desc;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync unsigned int s;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("swapchain %p, target %p, window %p.\n", swapchain, target, swapchain->win_handle);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* In case of ORM_BACKBUFFER, make sure to request an alpha component for
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * X4R4G4B4/X8R8G8B8 as we might need it for the backbuffer. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (color_format_desc->format == WINED3DFMT_B4G4R4X4_UNORM)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync color_format_desc = getFormatDescEntry(WINED3DFMT_B4G4R4A4_UNORM, gl_info);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync else if (color_format_desc->format == WINED3DFMT_B8G8R8X8_UNORM)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync color_format_desc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* DirectDraw supports 8bit paletted render targets and these are used by
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * old games like Starcraft and C&C. Most modern hardware doesn't support
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * 8bit natively so we perform some form of 8bit -> 32bit conversion. The
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * conversion (ab)uses the alpha component for storing the palette index.
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * For this reason we require a format with 8bit alpha, so request
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * A8R8G8B8. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (color_format_desc->format == WINED3DFMT_P8_UINT)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync color_format_desc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Retrieve the depth stencil format from the present parameters.
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * The choice of the proper format can give a nice performance boost
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * in case of GPU limited programs. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (swapchain->presentParms.EnableAutoDepthStencil)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Auto depth stencil enabled, using format %s.\n",
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync debug_d3dformat(swapchain->presentParms.AutoDepthStencilFormat));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ds_format_desc = getFormatDescEntry(swapchain->presentParms.AutoDepthStencilFormat, gl_info);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* D3D only allows multisampling when SwapEffect is set to WINED3DSWAPEFFECT_DISCARD. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (swapchain->presentParms.MultiSampleType && (swapchain->presentParms.SwapEffect == WINED3DSWAPEFFECT_DISCARD))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync WARN("The application is requesting multisampling without support.\n");
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Requesting multisample type %#x.\n", swapchain->presentParms.MultiSampleType);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync numSamples = swapchain->presentParms.MultiSampleType;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Try to find a pixel format which matches our requirements. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync pixel_format = WineD3D_ChoosePixelFormat(device, hdc, color_format_desc, ds_format_desc,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync auxBuffers, numSamples, FALSE /* findCompatible */);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Try to locate a compatible format if we weren't able to find anything. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync TRACE("Trying to locate a compatible pixel format because an exact match failed.\n");
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync pixel_format = WineD3D_ChoosePixelFormat(device, hdc, color_format_desc, ds_format_desc,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync auxBuffers, 0 /* numSamples */, TRUE /* findCompatible */);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* If we still don't have a pixel format, something is very wrong as ChoosePixelFormat barely fails */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync DescribePixelFormat(hdc, pixel_format, sizeof(pfd), &pfd);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (!context_set_pixel_format(gl_info, hdc, pixel_format))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync ERR("Failed to set pixel format %d on device context %p.\n", pixel_format, hdc);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (!pwglShareLists(device->contexts[0]->glCtx, ctx))
040b4a09341f574825386333398110f4db3e1e51vboxsync ERR("wglShareLists(%p, %p) failed, last error %#x.\n",
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("Failed to add the newly created context to the context list\n");
040b4a09341f574825386333398110f4db3e1e51vboxsync ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx, err);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Mark all states dirty to force a proper initialization of the states
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * on the first use of the context. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(ret, state, device->StateTable);
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if !defined(VBOX_WINE_WITH_SINGLE_CONTEXT) && !defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync ret->render_offscreen = surface_is_offscreen((IWineD3DSurface *) target);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (device->shader_backend->shader_dirtifyable_constants((IWineD3DDevice *)device))
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Create the dirty constants array and initialize them to dirty */
af062818b47340eef15700d2f0211576ba3506eevboxsync ret->vshader_const_dirty = HeapAlloc(GetProcessHeap(), 0,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync sizeof(*ret->vshader_const_dirty) * device->d3d_vshader_constantF);
af062818b47340eef15700d2f0211576ba3506eevboxsync ret->pshader_const_dirty = HeapAlloc(GetProcessHeap(), 0,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync sizeof(*ret->pshader_const_dirty) * device->d3d_pshader_constantF);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync sizeof(*ret->vshader_const_dirty) * device->d3d_vshader_constantF);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync sizeof(*ret->pshader_const_dirty) * device->d3d_pshader_constantF);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync ret->free_occlusion_queries = HeapAlloc(GetProcessHeap(), 0,
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync ret->free_occlusion_query_size * sizeof(*ret->free_occlusion_queries));
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync ret->free_event_queries = HeapAlloc(GetProcessHeap(), 0,
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync ret->free_event_query_size * sizeof(*ret->free_event_queries));
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("Successfully created new context %p\n", ret);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Set up the context defaults */
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("Cannot activate context to set up defaults\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Clear the screen */
af062818b47340eef15700d2f0211576ba3506eevboxsync glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
af062818b47340eef15700d2f0211576ba3506eevboxsync checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);");
af062818b47340eef15700d2f0211576ba3506eevboxsync glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
af062818b47340eef15700d2f0211576ba3506eevboxsync checkGLcall("glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);");
af062818b47340eef15700d2f0211576ba3506eevboxsync glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
af062818b47340eef15700d2f0211576ba3506eevboxsync checkGLcall("glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);");
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync glPixelStorei(GL_PACK_ALIGNMENT, device->surface_alignment);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync checkGLcall("glPixelStorei(GL_PACK_ALIGNMENT, device->surface_alignment);");
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync glPixelStorei(GL_UNPACK_ALIGNMENT, device->surface_alignment);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync checkGLcall("glPixelStorei(GL_UNPACK_ALIGNMENT, device->surface_alignment);");
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Most textures will use client storage if supported. Exceptions are non-native power of 2 textures
af062818b47340eef15700d2f0211576ba3506eevboxsync * and textures in DIB sections(due to the memory protection).
af062818b47340eef15700d2f0211576ba3506eevboxsync glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
af062818b47340eef15700d2f0211576ba3506eevboxsync checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Direct3D always uses n-1 weights for n world matrices and uses 1 - sum for the last one
af062818b47340eef15700d2f0211576ba3506eevboxsync * this is equal to GL_WEIGHT_SUM_UNITY_ARB. Enabling it doesn't do anything unless
af062818b47340eef15700d2f0211576ba3506eevboxsync * GL_VERTEX_BLEND_ARB isn't enabled too
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Set up the previous texture input for all shader units. This applies to bump mapping, and in d3d
af062818b47340eef15700d2f0211576ba3506eevboxsync * the previous texture where to source the offset from is always unit - 1.
af062818b47340eef15700d2f0211576ba3506eevboxsync GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + s));
af062818b47340eef15700d2f0211576ba3506eevboxsync glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + s - 1);
040b4a09341f574825386333398110f4db3e1e51vboxsync checkGLcall("glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, ...");
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync /* MacOS(radeon X1600 at least, but most likely others too) refuses to draw if GLSL and ARBFP are
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync * enabled, but the currently bound arbfp program is 0. Enabling ARBFP with prog 0 is invalid, but
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync * GLSL should bypass this. This causes problems in programs that never use the fixed function pipeline,
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync * because the ARBFP extension is enabled by the ARBFP pipeline at context creation, but no program
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync * is ever assigned.
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync * So make sure a program is assigned to each context. The first real ARBFP use will set a different
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync * program and the dummy program is destroyed when the context is destroyed.
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync "!!ARBfp1.0\n"
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync "MOV result.color, fragment.color.primary;\n"
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync GL_EXTCALL(glGenProgramsARB(1, &ret->dummy_arbfp_prog));
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ret->dummy_arbfp_prog));
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(dummy_program), dummy_program));
5112e32d7072e280613921c982a6672f2c859cf3vboxsync for (s = 0; s < gl_info->limits.point_sprite_units; ++s)
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + s));
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
040b4a09341f574825386333398110f4db3e1e51vboxsync checkGLcall("glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE)");
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync GL_EXTCALL(glProvokingVertex(GL_FIRST_VERTEX_CONVENTION));
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync GL_EXTCALL(glProvokingVertexEXT(GL_FIRST_VERTEX_CONVENTION_EXT));
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync /* for WDDM case this is used for shared resource handling
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * for XPDM this is needed to at least support texture sharing between device contexts.
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync * this is a kinda hack, but it is needed since our ogl driver currently does not support ShareLists */
14e23ea879a4aad5f0beb4cadee81a25cefe6303vboxsync GL_EXTCALL(glChromiumParameteriCR(GL_SHARE_CONTEXT_RESOURCES_CR, GL_TRUE));
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if defined(VBOX_WITH_WDDM) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
3eb9ba270e4a54e3ddc89f2a8828bb051f9fc7e9vboxsync GL_EXTCALL(glChromiumParameteriCR(GL_FLUSH_ON_THREAD_SWITCH_CR, GL_TRUE));
a79e8ee6782877eb8d4c8363875379d49b23acd8vboxsync GL_EXTCALL(glChromiumParameteriCR(GL_HOST_WND_CREATED_HIDDEN, GL_TRUE));
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync device->frag_pipe->enable_extension((IWineD3DDevice *)device, TRUE);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync HeapFree(GetProcessHeap(), 0, ret->free_event_queries);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync HeapFree(GetProcessHeap(), 0, ret->free_occlusion_queries);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync HeapFree(GetProcessHeap(), 0, ret->pshader_const_dirty);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync HeapFree(GetProcessHeap(), 0, ret->vshader_const_dirty);
6ce53b61ec00c84abbe9936d7a179c687db124e6vboxsyncstatic void context_setup_target(IWineD3DDeviceImpl *device, struct wined3d_context *context, IWineD3DSurface *target);
601ad8faca2e55f8871903c44b6b62e922c3928evboxsyncstatic void context_apply_state(struct wined3d_context *context, IWineD3DDeviceImpl *device, enum ContextUsage usage);
601ad8faca2e55f8871903c44b6b62e922c3928evboxsyncBOOL context_acquire_context(struct wined3d_context * context, IWineD3DSurface *target, enum ContextUsage usage, BOOL bReValidate)
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync struct wined3d_context *current_context = context_get_current();
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync if (target && SUCCEEDED(IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
9c7e5d48d876c073bd3269be7769be8337671ae7vboxsync context_validate(context, (IWineD3DSwapChainImpl*)swapchain
4e8d11ceb233da90f965f4a4c74b7782e8474e17vboxsync// Assert(context->valid);
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync if (!context_set_current(context)) ERR("Failed to activate the new context.\n");
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync else device->frag_pipe->enable_extension((IWineD3DDevice *)device, !context->last_was_blit);
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync sizeof(*context->vshader_const_dirty) * device->d3d_vshader_constantF);
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync device->highest_dirty_vs_const = device->d3d_vshader_constantF;
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync sizeof(*context->pshader_const_dirty) * device->d3d_pshader_constantF);
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync device->highest_dirty_ps_const = device->d3d_pshader_constantF;
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync if (!pwglMakeCurrent(context->currentSwapchain->hDC, context->glCtx))
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync ERR("Failed to make GL context %p current on device context %p, last error %#x.\n",
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync context->currentSwapchain->hDC, context->glCtx, err);
6ce53b61ec00c84abbe9936d7a179c687db124e6vboxsyncstruct wined3d_context *context_find_create(IWineD3DDeviceImpl *device, IWineD3DSwapChainImpl *swapchain, IWineD3DSurfaceImpl *target,
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync context = device->numContexts ? device->contexts[0] : NULL;
d10b60270f0c0eeb87f45002a010cff8ba2126b1vboxsync context = context_create(swapchain, target, ds_format_desc
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync if(!context_acquire_context(context, (IWineD3DSurface*)target, CTXUSAGE_RESOURCELOAD, TRUE))
af062818b47340eef15700d2f0211576ba3506eevboxsync/*****************************************************************************
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * context_destroy
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * Destroys a wined3d context
af062818b47340eef15700d2f0211576ba3506eevboxsync * This: Device to activate the context for
af062818b47340eef15700d2f0211576ba3506eevboxsync * context: Context to destroy
af062818b47340eef15700d2f0211576ba3506eevboxsync *****************************************************************************/
5112e32d7072e280613921c982a6672f2c859cf3vboxsyncvoid context_destroy(IWineD3DDeviceImpl *This, struct wined3d_context *context)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if !defined(VBOX_WINE_WITH_SINGLE_CONTEXT) && !defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if !defined(VBOX_WINE_WITH_SINGLE_CONTEXT) && !defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync if (context->tid == GetCurrentThreadId() || !context->current)
af062818b47340eef15700d2f0211576ba3506eevboxsync HeapFree(GetProcessHeap(), 0, context->vshader_const_dirty);
af062818b47340eef15700d2f0211576ba3506eevboxsync HeapFree(GetProcessHeap(), 0, context->pshader_const_dirty);
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if !defined(VBOX_WINE_WITH_SINGLE_CONTEXT) && !defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync if (destroy) HeapFree(GetProcessHeap(), 0, context);
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
af062818b47340eef15700d2f0211576ba3506eevboxsyncstatic inline void set_blit_dimension(UINT width, UINT height) {
af062818b47340eef15700d2f0211576ba3506eevboxsync/*****************************************************************************
af062818b47340eef15700d2f0211576ba3506eevboxsync * SetupForBlit
af062818b47340eef15700d2f0211576ba3506eevboxsync * Sets up a context for DirectDraw blitting.
af062818b47340eef15700d2f0211576ba3506eevboxsync * All texture units are disabled, texture unit 0 is set as current unit
af062818b47340eef15700d2f0211576ba3506eevboxsync * fog, lighting, blending, alpha test, z test, scissor test, culling disabled
af062818b47340eef15700d2f0211576ba3506eevboxsync * color writing enabled for all channels
af062818b47340eef15700d2f0211576ba3506eevboxsync * register combiners disabled, shaders disabled
af062818b47340eef15700d2f0211576ba3506eevboxsync * world matrix is set to identity, texture matrix 0 too
af062818b47340eef15700d2f0211576ba3506eevboxsync * projection matrix is setup for drawing screen coordinates
af062818b47340eef15700d2f0211576ba3506eevboxsync * This: Device to activate the context for
af062818b47340eef15700d2f0211576ba3506eevboxsync * context: Context to setup
af062818b47340eef15700d2f0211576ba3506eevboxsync *****************************************************************************/
040b4a09341f574825386333398110f4db3e1e51vboxsync/* Context activation is done by the caller. */
5112e32d7072e280613921c982a6672f2c859cf3vboxsyncstatic void SetupForBlit(IWineD3DDeviceImpl *This, struct wined3d_context *context)
af062818b47340eef15700d2f0211576ba3506eevboxsync const struct StateEntry *StateTable = This->StateTable;
040b4a09341f574825386333398110f4db3e1e51vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
5112e32d7072e280613921c982a6672f2c859cf3vboxsync UINT width = ((IWineD3DSurfaceImpl *)context->current_rt)->currentDesc.Width;
5112e32d7072e280613921c982a6672f2c859cf3vboxsync UINT height = ((IWineD3DSurfaceImpl *)context->current_rt)->currentDesc.Height;
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("Setting up context %p for blitting\n", context);
af062818b47340eef15700d2f0211576ba3506eevboxsync if(context->blit_w != width || context->blit_h != height) {
af062818b47340eef15700d2f0211576ba3506eevboxsync /* No need to dirtify here, the states are still dirtified because they weren't
af062818b47340eef15700d2f0211576ba3506eevboxsync * applied since the last SetupForBlit call. Otherwise last_was_blit would not
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("Context is already set up for blitting, nothing to do\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync /* TODO: Use a display list */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Disable shaders */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync This->shader_backend->shader_select(context, FALSE, FALSE);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_VSHADER, StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_PIXELSHADER, StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Call ENTER_GL() once for all gl calls below. In theory we should not call
af062818b47340eef15700d2f0211576ba3506eevboxsync * helper functions in between gl calls. This function is full of Context_MarkStateDirty
af062818b47340eef15700d2f0211576ba3506eevboxsync * which can safely be called from here, we only lock once instead locking/unlocking
af062818b47340eef15700d2f0211576ba3506eevboxsync * after each GL call.
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Disable all textures. The caller can then bind a texture it wants to blit
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync * The blitting code uses (for now) the fixed function pipeline, so make sure to reset all fixed
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync * function texture unit. No need to care for higher samplers
5112e32d7072e280613921c982a6672f2c859cf3vboxsync for (i = gl_info->limits.textures - 1; i > 0 ; --i)
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);");
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync Context_MarkStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP), StateTable);
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync Context_MarkStateDirty(context, STATE_SAMPLER(sampler), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
af062818b47340eef15700d2f0211576ba3506eevboxsync checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + sampler), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_SAMPLER(sampler), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Other misc states */
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ALPHATESTENABLE), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ZENABLE), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_FOGENABLE), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_CULLMODE), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_STENCILENABLE), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), StateTable);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE), StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_SPECULARENABLE), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Setup transforms */
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_VDECL, StateTable); /* because of last_was_rhw = TRUE */
af062818b47340eef15700d2f0211576ba3506eevboxsync glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)");
af062818b47340eef15700d2f0211576ba3506eevboxsync glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)");
af062818b47340eef15700d2f0211576ba3506eevboxsync glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)");
af062818b47340eef15700d2f0211576ba3506eevboxsync glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)");
af062818b47340eef15700d2f0211576ba3506eevboxsync glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)");
af062818b47340eef15700d2f0211576ba3506eevboxsync glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)");
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_CLIPPING), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_VIEWPORT, StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync Context_MarkStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION), StateTable);
af062818b47340eef15700d2f0211576ba3506eevboxsync This->frag_pipe->enable_extension((IWineD3DDevice *) This, FALSE);
af062818b47340eef15700d2f0211576ba3506eevboxsync/*****************************************************************************
af062818b47340eef15700d2f0211576ba3506eevboxsync * findThreadContextForSwapChain
af062818b47340eef15700d2f0211576ba3506eevboxsync * Searches a swapchain for all contexts and picks one for the thread tid.
af062818b47340eef15700d2f0211576ba3506eevboxsync * If none can be found the swapchain is requested to create a new context
af062818b47340eef15700d2f0211576ba3506eevboxsync *****************************************************************************/
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsyncstatic struct wined3d_context *findThreadContextForSwapChain(IWineD3DSwapChain *swapchain
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync#if !defined(VBOX_WINE_WITH_SINGLE_CONTEXT) && !defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync IWineD3DDeviceImpl *device = ((IWineD3DSwapChainImpl*)swapchain)->device;
af062818b47340eef15700d2f0211576ba3506eevboxsync unsigned int i;
06bfdb01d92810c68168b1304ac7aef2130c86a0vboxsync IWineD3DDeviceImpl *device = ((IWineD3DSwapChainImpl*)swapchain)->device;
af062818b47340eef15700d2f0211576ba3506eevboxsync for(i = 0; i < ((IWineD3DSwapChainImpl *) swapchain)->num_contexts; i++) {
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync if(VBoxTlsRefIsFunctional(((IWineD3DSwapChainImpl *) swapchain)->context[i])) {
af062818b47340eef15700d2f0211576ba3506eevboxsync if(((IWineD3DSwapChainImpl *) swapchain)->context[i]->tid == tid) {
af062818b47340eef15700d2f0211576ba3506eevboxsync return ((IWineD3DSwapChainImpl *) swapchain)->context[i];
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Create a new context for the thread */
5112e32d7072e280613921c982a6672f2c859cf3vboxsync return swapchain_create_context_for_thread(swapchain);
af062818b47340eef15700d2f0211576ba3506eevboxsync/*****************************************************************************
af062818b47340eef15700d2f0211576ba3506eevboxsync * FindContext
af062818b47340eef15700d2f0211576ba3506eevboxsync * Finds a context for the current render target and thread
af062818b47340eef15700d2f0211576ba3506eevboxsync * Parameters:
af062818b47340eef15700d2f0211576ba3506eevboxsync * target: Render target to find the context for
af062818b47340eef15700d2f0211576ba3506eevboxsync * tid: Thread to activate the context for
af062818b47340eef15700d2f0211576ba3506eevboxsync * Returns: The needed context
af062818b47340eef15700d2f0211576ba3506eevboxsync *****************************************************************************/
5112e32d7072e280613921c982a6672f2c859cf3vboxsyncstatic struct wined3d_context *FindContext(IWineD3DDeviceImpl *This, IWineD3DSurface *target)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync struct wined3d_context *current_context = context_get_current();
5a7c4f3b41de4fc601b52a370c421163b63f2906vboxsync /* tmp work-around */
5a7c4f3b41de4fc601b52a370c421163b63f2906vboxsync IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *)This->swapchains[This->NumberOfSwapChains-1];
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *)This->swapchains[0];
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync if (swapchain->backBuffer) target = swapchain->backBuffer[0];
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync if (current_context && current_context->current_rt == target)
5a7c4f3b41de4fc601b52a370c421163b63f2906vboxsync if (SUCCEEDED(IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync context_validate(current_context, (IWineD3DSwapChainImpl*)swapchain);
5a7c4f3b41de4fc601b52a370c421163b63f2906vboxsync /* tmp work-around */
e63d6c88e07773c7361d7f5a9bb78af4b5e758a9vboxsync NULL //(IWineD3DSwapChainImpl*)current_context->device->swapchains[current_context->device->NumberOfSwapChains-1]
af062818b47340eef15700d2f0211576ba3506eevboxsync if (SUCCEEDED(IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
601ad8faca2e55f8871903c44b6b62e922c3928evboxsync context_validate(context, (IWineD3DSwapChainImpl*)swapchain);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Stay with the currently active context. */
6b9422045350f9373da5033a86972ce1131dd356vboxsync if (current_context && context_get_device(current_context) == This)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* This may happen if the app jumps straight into offscreen rendering
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * Start using the context of the primary swapchain. tid == 0 is no problem
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * for findThreadContextForSwapChain.
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * Can also happen on thread switches - in that case findThreadContextForSwapChain
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * is perfect to call. */
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync context = findThreadContextForSwapChain(This->swapchains[This->NumberOfSwapChains-1]
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync context = findThreadContextForSwapChain(This->swapchains[0]
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync NULL //(IWineD3DSwapChainImpl*)This->swapchains[This->NumberOfSwapChains-1] /* tmp work-around */
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync/*****************************************************************************
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync * FindContext
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync * Finds a context for the current render target and thread
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync * Parameters:
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync * target: Render target to find the context for
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync * tid: Thread to activate the context for
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync * Returns: The needed context
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync *****************************************************************************/
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsyncstatic struct wined3d_context *FindContext(IWineD3DDeviceImpl *This, IWineD3DSurface *target)
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync struct wined3d_context *context = This->numContexts ? This->contexts[0] : NULL;
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsync IWineD3DSwapChainImpl *swapchain = swapchain_find_valid(This);
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsync swapchain = (IWineD3DSwapChainImpl *)This->swapchains[This->NumberOfSwapChains-1]; /* just fallback to anything to avoid NPE */
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync if (swapchain->backBuffer) target = swapchain->backBuffer[0];
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync else if (swapchain->frontBuffer) target = swapchain->frontBuffer;
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync if (SUCCEEDED(IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
9c7e5d48d876c073bd3269be7769be8337671ae7vboxsync context_validate(context, (IWineD3DSwapChainImpl*)swapchain
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync if (SUCCEEDED(IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync context = findThreadContextForSwapChain(swapchain);
9c7e5d48d876c073bd3269be7769be8337671ae7vboxsync context_validate(context, (IWineD3DSwapChainImpl*)swapchain
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsync IWineD3DSwapChainImpl *swapchain = swapchain_find_valid(This);
0b924fd7a4c33f3357b92e9ce45c6ecb021191c4vboxsync swapchain = (IWineD3DSwapChainImpl *)This->swapchains[This->NumberOfSwapChains-1]; /* just fallback to anything to avoid NPE */
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync context = findThreadContextForSwapChain((IWineD3DSwapChain*)swapchain);
040b4a09341f574825386333398110f4db3e1e51vboxsync/* Context activation is done by the caller. */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void context_apply_draw_buffer(struct wined3d_context *context, BOOL blit)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
5112e32d7072e280613921c982a6672f2c859cf3vboxsync device = ((IWineD3DSurfaceImpl *)rt)->resource.device;
af062818b47340eef15700d2f0211576ba3506eevboxsync if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync GL_EXTCALL(glDrawBuffersARB(gl_info->limits.buffers, device->draw_buffers));
5112e32d7072e280613921c982a6672f2c859cf3vboxsync/* GL locking is done by the caller. */
5112e32d7072e280613921c982a6672f2c859cf3vboxsyncvoid context_set_draw_buffer(struct wined3d_context *context, GLenum buffer)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsyncstatic inline void context_set_render_offscreen(struct wined3d_context *context, const struct StateEntry *StateTable,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (context->render_offscreen == offscreen) return;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION), StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_VDECL, StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_VIEWPORT, StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_SCISSORRECT, StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_FRONTFACE, StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsyncstatic BOOL match_depth_stencil_format(const struct wined3d_format_desc *existing,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync short existing_depth, existing_stencil, required_depth, required_stencil;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if((existing->Flags & WINED3DFMT_FLAG_FLOAT) != (required->Flags & WINED3DFMT_FLAG_FLOAT)) return FALSE;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync getDepthStencilBits(existing, &existing_depth, &existing_stencil);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync getDepthStencilBits(required, &required_depth, &required_stencil);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* If stencil bits are used the exact amount is required - otherwise wrapping
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * won't work correctly */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if(required_stencil && required_stencil != existing_stencil) return FALSE;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync/* The caller provides a context */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsyncstatic void context_validate_onscreen_formats(IWineD3DDeviceImpl *device, struct wined3d_context *context)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Onscreen surfaces are always in a swapchain */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync IWineD3DSurfaceImpl *depth_stencil = (IWineD3DSurfaceImpl *) device->stencilBufferTarget;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) ((IWineD3DSurfaceImpl *)context->current_rt)->container;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (match_depth_stencil_format(swapchain->ds_format, depth_stencil->resource.format_desc)) return;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* TODO: If the requested format would satisfy the needs of the existing one(reverse match),
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * or no onscreen depth buffer was created, the OpenGL drawable could be changed to the new
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * format. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync WARN("Depth stencil format is not supported by WGL, rendering the backbuffer in an FBO\n");
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* The currently active context is the necessary context to access the swapchain's onscreen buffers */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync IWineD3DSurface_LoadLocation(context->current_rt, SFLAG_INTEXTURE, NULL);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context_set_render_offscreen(context, device->StateTable, TRUE);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync/* Context activation is done by the caller. */
5112e32d7072e280613921c982a6672f2c859cf3vboxsyncstatic void context_apply_state(struct wined3d_context *context, IWineD3DDeviceImpl *device, enum ContextUsage usage)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync const struct StateEntry *state_table = device->StateTable;
5112e32d7072e280613921c982a6672f2c859cf3vboxsync unsigned int i;
af062818b47340eef15700d2f0211576ba3506eevboxsync if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (!context->render_offscreen) context_validate_onscreen_formats(device, context);
af062818b47340eef15700d2f0211576ba3506eevboxsync if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (!context->render_offscreen) context_validate_onscreen_formats(device, context);
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Activating for CTXUSAGE_BLIT for an offscreen target with ORM_FBO. This should be avoided.\n");
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync surface_internal_preload(context->current_rt, SRGB_RGB);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync context_bind_fbo(context, GL_FRAMEBUFFER, &context->dst_fbo);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context_attach_surface_fbo(context, GL_FRAMEBUFFER, 0, (IWineD3DSurfaceImpl *)context->current_rt);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync context_attach_depth_stencil_fbo(context, GL_FRAMEBUFFER, NULL, FALSE);
af062818b47340eef15700d2f0211576ba3506eevboxsync if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) {
af062818b47340eef15700d2f0211576ba3506eevboxsync /* This does not require any special states to be set up */
5112e32d7072e280613921c982a6672f2c859cf3vboxsync device->frag_pipe->enable_extension((IWineD3DDevice *)device, TRUE);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Blending and clearing should be orthogonal, but tests on the nvidia driver show that disabling
af062818b47340eef15700d2f0211576ba3506eevboxsync * blending when clearing improves the clearing performance incredibly.
5112e32d7072e280613921c982a6672f2c859cf3vboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_table);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_table);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync Context_MarkStateDirty(context, STATE_SCISSORRECT, state_table);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* This needs all dirty states applied */
5112e32d7072e280613921c982a6672f2c859cf3vboxsync device->frag_pipe->enable_extension((IWineD3DDevice *)device, TRUE);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync device_update_stream_info(device, context->gl_info);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync DWORD idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync BYTE shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync state_table[rep].apply(rep, device->stateBlock, context);
af062818b47340eef15700d2f0211576ba3506eevboxsync context->numDirtyEntries = 0; /* This makes the whole list clean */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsyncstatic void context_setup_target(IWineD3DDeviceImpl *device, struct wined3d_context *context, IWineD3DSurface *target)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync BOOL old_render_offscreen = context->render_offscreen, render_offscreen;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync const struct StateEntry *StateTable = device->StateTable;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (!target) return;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync context_set_render_offscreen(context, StateTable, render_offscreen);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* To compensate the lack of format switching with some offscreen rendering methods and on onscreen buffers
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * the alpha blend state changes with different render target formats. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync const struct wined3d_format_desc *old = ((IWineD3DSurfaceImpl *)context->current_rt)->resource.format_desc;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync const struct wined3d_format_desc *new = ((IWineD3DSurfaceImpl *)target)->resource.format_desc;
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Disable blending when the alpha mask has changed and when a format doesn't support blending. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if ((old->alpha_mask && !new->alpha_mask) || (!old->alpha_mask && new->alpha_mask)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync || !(new->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING))
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync Context_MarkStateDirty(context, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), StateTable);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* When switching away from an offscreen render target, and we're not
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * using FBOs, we have to read the drawable into the texture. This is
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * done via PreLoad (and SFLAG_INDRAWABLE set on the surface). There
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * are some things that need care though. PreLoad needs a GL context,
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * and FindContext is called before the context is activated. It also
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * has to be called with the old rendertarget active, otherwise a
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * wrong drawable is read. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (wined3d_settings.offscreen_rendering_mode != ORM_FBO
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync && old_render_offscreen && context->current_rt != target)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* surface_internal_preload() requires a context to load the
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * texture, so it will call context_acquire(). Set isInDraw to true
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * to signal surface_internal_preload() that it has a context. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* FIXME: This is just broken. There's no guarantee whatsoever
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * that the currently active context, if any, is appropriate for
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * reading back the render target. We should probably call
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * context_set_current(context) here and then rely on
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync * context_acquire() doing the right thing. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync /* Read the back buffer of the old drawable into the destination texture. */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (((IWineD3DSurfaceImpl *)context->current_rt)->texture_name_srgb)
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync surface_internal_preload(context->current_rt, SRGB_BOTH);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync surface_internal_preload(context->current_rt, SRGB_RGB);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync IWineD3DSurface_ModifyLocation(context->current_rt, SFLAG_INDRAWABLE, FALSE);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync/*****************************************************************************
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * context_acquire
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * Finds a rendering context and drawable matching the device and render
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * target for the current thread, activates them and puts them into the
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * requested state.
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * This: Device to activate the context for
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * target: Requested render target
5112e32d7072e280613921c982a6672f2c859cf3vboxsync * usage: Prepares the context for blitting, drawing or other actions
5112e32d7072e280613921c982a6672f2c859cf3vboxsync *****************************************************************************/
5112e32d7072e280613921c982a6672f2c859cf3vboxsyncstruct wined3d_context *context_acquire(IWineD3DDeviceImpl *device, IWineD3DSurface *target, enum ContextUsage usage)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync struct wined3d_context *current_context = context_get_current();
5112e32d7072e280613921c982a6672f2c859cf3vboxsync TRACE("device %p, target %p, usage %#x.\n", device, target, usage);
6decafdf89f825b3af922ab6fa02345e08e5be7bvboxsync ERR("context_acquire failed to get a valid context!");
5112e32d7072e280613921c982a6672f2c859cf3vboxsync if (!context_set_current(context)) ERR("Failed to activate the new context.\n");
5112e32d7072e280613921c982a6672f2c859cf3vboxsync else device->frag_pipe->enable_extension((IWineD3DDevice *)device, !context->last_was_blit);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync sizeof(*context->vshader_const_dirty) * device->d3d_vshader_constantF);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync device->highest_dirty_vs_const = device->d3d_vshader_constantF;
5112e32d7072e280613921c982a6672f2c859cf3vboxsync sizeof(*context->pshader_const_dirty) * device->d3d_pshader_constantF);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync device->highest_dirty_ps_const = device->d3d_pshader_constantF;
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync if (!pwglMakeCurrent(context->currentSwapchain->hDC, context->glCtx))
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync ERR("Failed to make GL context %p current on device context %p, last error %#x.\n",
3b5b00fc19a7b52f11075648a1b93d477137f4d3vboxsync context->currentSwapchain->hDC, context->glCtx, err);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync if (!pwglMakeCurrent(context->hdc, context->glCtx))
5112e32d7072e280613921c982a6672f2c859cf3vboxsync ERR("Failed to make GL context %p current on device context %p, last error %#x.\n",