Changeset 28475 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c

Timestamp:

Apr 19, 2010 3:27:01 PM (15 years ago)

Author:

vboxsync

Message:

crOpenGL: update to wine 1.1.43

File:

• trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c (modified) (76 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c

@@ -189 +189 @@
     /* We need to deal with frequency data! */
     IWineD3DVertexDeclarationImpl *declaration = (IWineD3DVertexDeclarationImpl *)This->stateBlock->vertexDecl;
-    UINT stream_count = This->stateBlock->streamIsUP ? 0 : declaration->num_streams;
-    const DWORD *streams = declaration->streams;
     unsigned int i;
 
@@ -225 +223 @@
         {
             TRACE("Stream %u isn't UP, %p\n", element->input_slot, This->stateBlock->streamSource[element->input_slot]);
-            data = buffer_get_memory(This->stateBlock->streamSource[element->input_slot], 0, &buffer_object);
+            data = buffer_get_memory(This->stateBlock->streamSource[element->input_slot], &buffer_object);
 
             /* Can't use vbo's if the base vertex index is negative. OpenGL doesn't accept negative offsets
@@ -308 +306 @@
             stream_info->elements[idx].buffer_object = buffer_object;
 
-            if (!This->adapter->gl_info.supported[EXT_VERTEX_ARRAY_BGRA]
+            if (!This->adapter->gl_info.supported[ARB_VERTEX_ARRAY_BGRA]
                     && element->format_desc->format == WINED3DFMT_B8G8R8A8_UNORM)
             {
@@ -317 +315 @@
     }
 
-    /* Now call PreLoad on all the vertex buffers. In the very rare case
-     * that the buffers stopps converting PreLoad will dirtify the VDECL again.
-     * The vertex buffer can now use the strided structure in the device instead of finding its
-     * own again.
-     *
-     * NULL streams won't be recorded in the array, UP streams won't be either. A stream is only
-     * once in there. */
-    for (i = 0; i < stream_count; ++i)
-    {
-        IWineD3DBuffer *vb = This->stateBlock->streamSource[streams[i]];
-        if (vb) IWineD3DBuffer_PreLoad(vb);
+    This->num_buffer_queries = 0;
+    if (!This->stateBlock->streamIsUP)
+    {
+        WORD map = stream_info->use_map;
+
+        /* PreLoad all the vertex buffers. */
+        for (i = 0; map; map >>= 1, ++i)
+        {
+            struct wined3d_stream_info_element *element;
+            struct wined3d_buffer *buffer;
+            struct wined3d_event_query *query;
+
+            if (!(map & 1)) continue;
+
+            element = &stream_info->elements[i];
+            buffer = (struct wined3d_buffer *)This->stateBlock->streamSource[element->stream_idx];
+            IWineD3DBuffer_PreLoad((IWineD3DBuffer *)buffer);
+
+            /* If PreLoad dropped the buffer object, update the stream info. */
+            if (buffer->buffer_object != element->buffer_object)
+            {
+                element->buffer_object = 0;
+                element->data = buffer_get_sysmem(buffer) + (ptrdiff_t)element->data;
+            }
+
+            query = ((struct wined3d_buffer *) buffer)->query;
+            if(query)
+            {
+                This->buffer_queries[This->num_buffer_queries++] = query;
+            }
+        }
     }
 }
@@ -334 +352 @@
         const struct WineDirect3DStridedData *strided, struct wined3d_stream_info_element *e)
 {
-    const struct GlPixelFormatDesc *format_desc = getFormatDescEntry(strided->format, gl_info);
+    const struct wined3d_format_desc *format_desc = getFormatDescEntry(strided->format, gl_info);
     e->format_desc = format_desc;
     e->stride = strided->dwStride;
@@ -342 +360 @@
 }
 
-void device_stream_info_from_strided(const struct wined3d_gl_info *gl_info,
+static void device_stream_info_from_strided(const struct wined3d_gl_info *gl_info,
         const struct WineDirect3DVertexStridedData *strided, struct wined3d_stream_info *stream_info)
 {
@@ -371 +389 @@
         if (!stream_info->elements[i].format_desc) continue;
 
-        if (!gl_info->supported[EXT_VERTEX_ARRAY_BGRA]
+        if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
                 && stream_info->elements[i].format_desc->format == WINED3DFMT_B8G8R8A8_UNORM)
         {
@@ -379 +397 @@
     }
 }
+
+static void device_trace_strided_stream_info(const struct wined3d_stream_info *stream_info)
+{
+    TRACE("Strided Data:\n");
+    TRACE_STRIDED(stream_info, WINED3D_FFP_POSITION);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_BLENDWEIGHT);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_BLENDINDICES);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_NORMAL);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_PSIZE);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_DIFFUSE);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_SPECULAR);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD0);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD1);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD2);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD3);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD4);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD5);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD6);
+    TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD7);
+}
+
+/* Context activation is done by the caller. */
+void device_update_stream_info(IWineD3DDeviceImpl *device, const struct wined3d_gl_info *gl_info)
+{
+    struct wined3d_stream_info *stream_info = &device->strided_streams;
+    IWineD3DStateBlockImpl *stateblock = device->stateBlock;
+    BOOL vs = stateblock->vertexShader && device->vs_selected_mode != SHADER_NONE;
+    BOOL fixup = FALSE;
+
+    if (device->up_strided)
+    {
+        /* Note: this is a ddraw fixed-function code path. */
+        TRACE("=============================== Strided Input ================================\n");
+        device_stream_info_from_strided(gl_info, device->up_strided, stream_info);
+        if (TRACE_ON(d3d)) device_trace_strided_stream_info(stream_info);
+    }
+    else
+    {
+        TRACE("============================= Vertex Declaration =============================\n");
+        device_stream_info_from_declaration(device, vs, stream_info, &fixup);
+    }
+
+    if (vs && !stream_info->position_transformed)
+    {
+        if (((IWineD3DVertexDeclarationImpl *)stateblock->vertexDecl)->half_float_conv_needed && !fixup)
+        {
+            TRACE("Using drawStridedSlow with vertex shaders for FLOAT16 conversion.\n");
+            device->useDrawStridedSlow = TRUE;
+        }
+        else
+        {
+            device->useDrawStridedSlow = FALSE;
+        }
+    }
+    else
+    {
+        WORD slow_mask = (1 << WINED3D_FFP_PSIZE);
+        slow_mask |= -!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
+                & ((1 << WINED3D_FFP_DIFFUSE) | (1 << WINED3D_FFP_SPECULAR));
+
+        if ((stream_info->position_transformed || (stream_info->use_map & slow_mask)) && !fixup)
+        {
+            device->useDrawStridedSlow = TRUE;
+        }
+        else
+        {
+            device->useDrawStridedSlow = FALSE;
+        }
+    }
+}
+
+static void device_preload_texture(IWineD3DStateBlockImpl *stateblock, unsigned int idx)
+{
+    IWineD3DBaseTextureImpl *texture;
+    enum WINED3DSRGB srgb;
+
+    if (!(texture = (IWineD3DBaseTextureImpl *)stateblock->textures[idx])) return;
+    srgb = stateblock->samplerState[idx][WINED3DSAMP_SRGBTEXTURE] ? SRGB_SRGB : SRGB_RGB;
+    texture->baseTexture.internal_preload((IWineD3DBaseTexture *)texture, srgb);
+}
+
+void device_preload_textures(IWineD3DDeviceImpl *device)
+{
+    IWineD3DStateBlockImpl *stateblock = device->stateBlock;
+    unsigned int i;
+
+    if (use_vs(stateblock))
+    {
+        for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i)
+        {
+            if (((IWineD3DBaseShaderImpl *)stateblock->vertexShader)->baseShader.reg_maps.sampler_type[i])
+                device_preload_texture(stateblock, MAX_FRAGMENT_SAMPLERS + i);
+        }
+    }
+
+    if (use_ps(stateblock))
+    {
+        for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
+        {
+            if (((IWineD3DBaseShaderImpl *)stateblock->pixelShader)->baseShader.reg_maps.sampler_type[i])
+                device_preload_texture(stateblock, i);
+        }
+    }
+    else
+    {
+        WORD ffu_map = device->fixed_function_usage_map;
+
+        for (i = 0; ffu_map; ffu_map >>= 1, ++i)
+        {
+            if (ffu_map & 1)
+                device_preload_texture(stateblock, i);
+        }
+    }
+}
+
+BOOL device_context_add(IWineD3DDeviceImpl *device, struct wined3d_context *context)
+{
+    struct wined3d_context **new_array;
+
+    TRACE("Adding context %p.\n", context);
+
+    if (!device->contexts) new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_array));
+    else new_array = HeapReAlloc(GetProcessHeap(), 0, device->contexts, sizeof(*new_array) * (device->numContexts + 1));
+
+    if (!new_array)
+    {
+        ERR("Failed to grow the context array.\n");
+        return FALSE;
+    }
+
+    new_array[device->numContexts++] = context;
+    device->contexts = new_array;
+    return TRUE;
+}
+
+void device_context_remove(IWineD3DDeviceImpl *device, struct wined3d_context *context)
+{
+    struct wined3d_context **new_array;
+    BOOL found = FALSE;
+    UINT i;
+
+    TRACE("Removing context %p.\n", context);
+
+    for (i = 0; i < device->numContexts; ++i)
+    {
+        if (device->contexts[i] == context)
+        {
+            found = TRUE;
+            break;
+        }
+    }
+
+    if (!found)
+    {
+        ERR("Context %p doesn't exist in context array.\n", context);
+        return;
+    }
+
+    if (!--device->numContexts)
+    {
+        HeapFree(GetProcessHeap(), 0, device->contexts);
+        device->contexts = NULL;
+        return;
+    }
+
+    memmove(&device->contexts[i], &device->contexts[i + 1], (device->numContexts - i) * sizeof(*device->contexts));
+    new_array = HeapReAlloc(GetProcessHeap(), 0, device->contexts, device->numContexts * sizeof(*device->contexts));
+    if (!new_array)
+    {
+        ERR("Failed to shrink context array. Oh well.\n");
+        return;
+    }
+
+    device->contexts = new_array;
+}
+
 
 /**********************************************************
@@ -426 +620 @@
         ** ***************************/
 
-        if (!list_empty(&This->resources)) {
+        if (!list_empty(&This->resources))
+        {
+            IWineD3DResourceImpl *resource;
             FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This);
-            dumpResources(&This->resources);
+
+            LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry)
+            {
+                WINED3DRESOURCETYPE type = IWineD3DResource_GetType((IWineD3DResource *)resource);
+                FIXME("Leftover resource %p with type %s (%#x).\n",
+                        resource, debug_d3dresourcetype(type), type);
+            }
         }
 
@@ -606 +808 @@
     HRESULT hr;
 
-    TRACE("(%p) Create surface\n",This);
+    TRACE("iface %p, width %u, height %u, format %s (%#x), lockable %#x, discard %#x, level %u\n",
+            iface, Width, Height, debug_d3dformat(Format), Format, Lockable, Discard, Level);
+    TRACE("surface %p, usage %s (%#x), pool %s (%#x), multisample_type %#x, multisample_quality %u\n",
+            ppSurface, debug_d3dusage(Usage), Usage, debug_d3dpool(Pool), Pool, MultiSample, MultisampleQuality);
+    TRACE("surface_type %#x, parent %p, parent_ops %p.\n", Impl, parent, parent_ops);
 
     if (Impl == SURFACE_OPENGL && !This->adapter)
@@ -642 +848 @@
     struct wined3d_rendertarget_view *object;
 
+    TRACE("iface %p, resource %p, parent %p, rendertarget_view %p.\n",
+            iface, resource, parent, rendertarget_view);
+
     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
     if (!object)
@@ -649 +858 @@
     }
 
-    object->vtbl = &wined3d_rendertarget_view_vtbl;
-    object->refcount = 1;
-    IWineD3DResource_AddRef(resource);
-    object->resource = resource;
-    object->parent = parent;
-
+    wined3d_rendertarget_view_init(object, resource, parent);
+
+    TRACE("Created render target view %p.\n", object);
     *rendertarget_view = (IWineD3DRendertargetView *)object;
 
@@ -794 +1000 @@
 }
 
-static HRESULT WINAPI IWineD3DDeviceImpl_CreateQuery(IWineD3DDevice *iface, WINED3DQUERYTYPE Type, IWineD3DQuery **ppQuery, IUnknown* parent) {
-    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
-    const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
-    IWineD3DQueryImpl *object; /*NOTE: impl ref allowed since this is a create function */
-    HRESULT hr = WINED3DERR_NOTAVAILABLE;
-    const IWineD3DQueryVtbl *vtable;
-
-    /* Just a check to see if we support this type of query */
-    switch(Type) {
-    case WINED3DQUERYTYPE_OCCLUSION:
-        TRACE("(%p) occlusion query\n", This);
-        if (gl_info->supported[ARB_OCCLUSION_QUERY])
-            hr = WINED3D_OK;
-        else
-            WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY/NV_OCCLUSION_QUERY\n");
-
-        vtable = &IWineD3DOcclusionQuery_Vtbl;
-        break;
-
-    case WINED3DQUERYTYPE_EVENT:
-        if (!gl_info->supported[NV_FENCE] && !gl_info->supported[APPLE_FENCE])
-        {
-            /* Half-Life 2 needs this query. It does not render the main menu correctly otherwise
-             * Pretend to support it, faking this query does not do much harm except potentially lowering performance
-             */
-            FIXME("(%p) Event query: Unimplemented, but pretending to be supported\n", This);
-        }
-        vtable = &IWineD3DEventQuery_Vtbl;
-        hr = WINED3D_OK;
-        break;
-
-    case WINED3DQUERYTYPE_VCACHE:
-    case WINED3DQUERYTYPE_RESOURCEMANAGER:
-    case WINED3DQUERYTYPE_VERTEXSTATS:
-    case WINED3DQUERYTYPE_TIMESTAMP:
-    case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
-    case WINED3DQUERYTYPE_TIMESTAMPFREQ:
-    case WINED3DQUERYTYPE_PIPELINETIMINGS:
-    case WINED3DQUERYTYPE_INTERFACETIMINGS:
-    case WINED3DQUERYTYPE_VERTEXTIMINGS:
-    case WINED3DQUERYTYPE_PIXELTIMINGS:
-    case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
-    case WINED3DQUERYTYPE_CACHEUTILIZATION:
-    default:
-        /* Use the base Query vtable until we have a special one for each query */
-        vtable = &IWineD3DQuery_Vtbl;
-        FIXME("(%p) Unhandled query type %d\n", This, Type);
-    }
-    if(NULL == ppQuery || hr != WINED3D_OK) {
+static HRESULT WINAPI IWineD3DDeviceImpl_CreateQuery(IWineD3DDevice *iface,
+        WINED3DQUERYTYPE type, IWineD3DQuery **query, IUnknown *parent)
+{
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    IWineD3DQueryImpl *object;
+    HRESULT hr;
+
+    TRACE("iface %p, type %#x, query %p, parent %p.\n", iface, type, query, parent);
+
+    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
+    if (!object)
+    {
+        ERR("Failed to allocate query memory.\n");
+        return E_OUTOFMEMORY;
+    }
+
+    hr = query_init(object, This, type, parent);
+    if (FAILED(hr))
+    {
+        WARN("Failed to initialize query, hr %#x.\n", hr);
+        HeapFree(GetProcessHeap(), 0, object);
         return hr;
     }
 
-    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
-    if(!object)
-    {
-        ERR("Out of memory\n");
-        *ppQuery = NULL;
-        return WINED3DERR_OUTOFVIDEOMEMORY;
-    }
-
-    object->lpVtbl = vtable;
-    object->type = Type;
-    object->state = QUERY_CREATED;
-    object->device = This;
-    object->parent = parent;
-    object->ref = 1;
-
-    *ppQuery = (IWineD3DQuery *)object;
-
-    /* allocated the 'extended' data based on the type of query requested */
-    switch(Type){
-    case WINED3DQUERYTYPE_OCCLUSION:
-        object->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_occlusion_query));
-        ((struct wined3d_occlusion_query *)object->extendedData)->context = NULL;
-        break;
-
-    case WINED3DQUERYTYPE_EVENT:
-        object->extendedData = HeapAlloc(GetProcessHeap(), 0, sizeof(struct wined3d_event_query));
-        ((struct wined3d_event_query *)object->extendedData)->context = NULL;
-        break;
-
-    case WINED3DQUERYTYPE_VCACHE:
-    case WINED3DQUERYTYPE_RESOURCEMANAGER:
-    case WINED3DQUERYTYPE_VERTEXSTATS:
-    case WINED3DQUERYTYPE_TIMESTAMP:
-    case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
-    case WINED3DQUERYTYPE_TIMESTAMPFREQ:
-    case WINED3DQUERYTYPE_PIPELINETIMINGS:
-    case WINED3DQUERYTYPE_INTERFACETIMINGS:
-    case WINED3DQUERYTYPE_VERTEXTIMINGS:
-    case WINED3DQUERYTYPE_PIXELTIMINGS:
-    case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
-    case WINED3DQUERYTYPE_CACHEUTILIZATION:
-    default:
-        object->extendedData = 0;
-        FIXME("(%p) Unhandled query type %d\n",This , Type);
-    }
-    TRACE("(%p) : Created Query %p\n", This, object);
+    TRACE("Created query %p.\n", object);
+    *query = (IWineD3DQuery *)object;
+
     return WINED3D_OK;
 }
@@ -983 +1118 @@
 }
 
+struct wined3d_fvf_convert_state
+{
+    const struct wined3d_gl_info *gl_info;
+    WINED3DVERTEXELEMENT *elements;
+    UINT offset;
+    UINT idx;
+};
+
+static void append_decl_element(struct wined3d_fvf_convert_state *state,
+        WINED3DFORMAT format, WINED3DDECLUSAGE usage, UINT usage_idx)
+{
+    WINED3DVERTEXELEMENT *elements = state->elements;
+    const struct wined3d_format_desc *format_desc;
+    UINT offset = state->offset;
+    UINT idx = state->idx;
+
+    elements[idx].format = format;
+    elements[idx].input_slot = 0;
+    elements[idx].offset = offset;
+    elements[idx].output_slot = 0;
+    elements[idx].method = WINED3DDECLMETHOD_DEFAULT;
+    elements[idx].usage = usage;
+    elements[idx].usage_idx = usage_idx;
+
+    format_desc = getFormatDescEntry(format, state->gl_info);
+    state->offset += format_desc->component_count * format_desc->component_size;
+    ++state->idx;
+}
+
 static unsigned int ConvertFvfToDeclaration(IWineD3DDeviceImpl *This, /* For the GL info, which has the type table */
-                                            DWORD fvf, WINED3DVERTEXELEMENT** ppVertexElements) {
-
-    unsigned int idx, idx2;
-    unsigned int offset;
+        DWORD fvf, WINED3DVERTEXELEMENT **ppVertexElements)
+{
+    const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
     BOOL has_pos = (fvf & WINED3DFVF_POSITION_MASK) != 0;
     BOOL has_blend = (fvf & WINED3DFVF_XYZB5) > WINED3DFVF_XYZRHW;
@@ -1001 +1164 @@
     DWORD num_textures = (fvf & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
     DWORD texcoords = (fvf & 0xFFFF0000) >> 16;
-    WINED3DVERTEXELEMENT *elements = NULL;
-
+    struct wined3d_fvf_convert_state state;
     unsigned int size;
+    unsigned int idx;
     DWORD num_blends = 1 + (((fvf & WINED3DFVF_XYZB5) - WINED3DFVF_XYZB1) >> 1);
     if (has_blend_idx) num_blends--;
@@ -1011 +1174 @@
            has_psize + has_diffuse + has_specular + num_textures;
 
-    /* convert the declaration */
-    elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WINED3DVERTEXELEMENT));
-    if (!elements) return ~0U;
-
-    idx = 0;
-    if (has_pos) {
-        if (!has_blend && (fvf & WINED3DFVF_XYZRHW)) {
-            elements[idx].format = WINED3DFMT_R32G32B32A32_FLOAT;
-            elements[idx].usage = WINED3DDECLUSAGE_POSITIONT;
-        }
-        else if ((fvf & WINED3DFVF_XYZW) == WINED3DFVF_XYZW) {
-            elements[idx].format = WINED3DFMT_R32G32B32A32_FLOAT;
-            elements[idx].usage = WINED3DDECLUSAGE_POSITION;
-        }
-        else {
-            elements[idx].format = WINED3DFMT_R32G32B32_FLOAT;
-            elements[idx].usage = WINED3DDECLUSAGE_POSITION;
-        }
-        elements[idx].usage_idx = 0;
-        idx++;
-    }
-    if (has_blend && (num_blends > 0)) {
-        if (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2) && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR))
-            elements[idx].format = WINED3DFMT_B8G8R8A8_UNORM;
-        else {
-            switch(num_blends) {
-                case 1: elements[idx].format = WINED3DFMT_R32_FLOAT; break;
-                case 2: elements[idx].format = WINED3DFMT_R32G32_FLOAT; break;
-                case 3: elements[idx].format = WINED3DFMT_R32G32B32_FLOAT; break;
-                case 4: elements[idx].format = WINED3DFMT_R32G32B32A32_FLOAT; break;
+    state.gl_info = gl_info;
+    state.elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*state.elements));
+    if (!state.elements) return ~0U;
+    state.offset = 0;
+    state.idx = 0;
+
+    if (has_pos)
+    {
+        if (!has_blend && (fvf & WINED3DFVF_XYZRHW))
+            append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3DDECLUSAGE_POSITIONT, 0);
+        else if ((fvf & WINED3DFVF_XYZW) == WINED3DFVF_XYZW)
+            append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3DDECLUSAGE_POSITION, 0);
+        else
+            append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3DDECLUSAGE_POSITION, 0);
+    }
+
+    if (has_blend && (num_blends > 0))
+    {
+        if ((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2 && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR))
+            append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
+        else
+        {
+            switch (num_blends)
+            {
+                case 1:
+                    append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
+                    break;
+                case 2:
+                    append_decl_element(&state, WINED3DFMT_R32G32_FLOAT, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
+                    break;
+                case 3:
+                    append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
+                    break;
+                case 4:
+                    append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3DDECLUSAGE_BLENDWEIGHT, 0);
+                    break;
                 default:
                     ERR("Unexpected amount of blend values: %u\n", num_blends);
             }
         }
-        elements[idx].usage = WINED3DDECLUSAGE_BLENDWEIGHT;
-        elements[idx].usage_idx = 0;
-        idx++;
-    }
-    if (has_blend_idx) {
-        if (fvf & WINED3DFVF_LASTBETA_UBYTE4 ||
-            (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2) && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)))
-            elements[idx].format = WINED3DFMT_R8G8B8A8_UINT;
+    }
+
+    if (has_blend_idx)
+    {
+        if ((fvf & WINED3DFVF_LASTBETA_UBYTE4)
+                || ((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2 && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)))
+            append_decl_element(&state, WINED3DFMT_R8G8B8A8_UINT, WINED3DDECLUSAGE_BLENDINDICES, 0);
         else if (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)
-            elements[idx].format = WINED3DFMT_B8G8R8A8_UNORM;
+            append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3DDECLUSAGE_BLENDINDICES, 0);
         else
-            elements[idx].format = WINED3DFMT_R32_FLOAT;
-        elements[idx].usage = WINED3DDECLUSAGE_BLENDINDICES;
-        elements[idx].usage_idx = 0;
-        idx++;
-    }
-    if (has_normal) {
-        elements[idx].format = WINED3DFMT_R32G32B32_FLOAT;
-        elements[idx].usage = WINED3DDECLUSAGE_NORMAL;
-        elements[idx].usage_idx = 0;
-        idx++;
-    }
-    if (has_psize) {
-        elements[idx].format = WINED3DFMT_R32_FLOAT;
-        elements[idx].usage = WINED3DDECLUSAGE_PSIZE;
-        elements[idx].usage_idx = 0;
-        idx++;
-    }
-    if (has_diffuse) {
-        elements[idx].format = WINED3DFMT_B8G8R8A8_UNORM;
-        elements[idx].usage = WINED3DDECLUSAGE_COLOR;
-        elements[idx].usage_idx = 0;
-        idx++;
-    }
-    if (has_specular) {
-        elements[idx].format = WINED3DFMT_B8G8R8A8_UNORM;
-        elements[idx].usage = WINED3DDECLUSAGE_COLOR;
-        elements[idx].usage_idx = 1;
-        idx++;
-    }
-    for (idx2 = 0; idx2 < num_textures; idx2++) {
-        unsigned int numcoords = (texcoords >> (idx2*2)) & 0x03;
-        switch (numcoords) {
+            append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3DDECLUSAGE_BLENDINDICES, 0);
+    }
+
+    if (has_normal) append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3DDECLUSAGE_NORMAL, 0);
+    if (has_psize) append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3DDECLUSAGE_PSIZE, 0);
+    if (has_diffuse) append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3DDECLUSAGE_COLOR, 0);
+    if (has_specular) append_decl_element(&state, WINED3DFMT_B8G8R8A8_UNORM, WINED3DDECLUSAGE_COLOR, 1);
+
+    for (idx = 0; idx < num_textures; ++idx)
+    {
+        switch ((texcoords >> (idx * 2)) & 0x03)
+        {
             case WINED3DFVF_TEXTUREFORMAT1:
-                elements[idx].format = WINED3DFMT_R32_FLOAT;
+                append_decl_element(&state, WINED3DFMT_R32_FLOAT, WINED3DDECLUSAGE_TEXCOORD, idx);
                 break;
             case WINED3DFVF_TEXTUREFORMAT2:
-                elements[idx].format = WINED3DFMT_R32G32_FLOAT;
+                append_decl_element(&state, WINED3DFMT_R32G32_FLOAT, WINED3DDECLUSAGE_TEXCOORD, idx);
                 break;
             case WINED3DFVF_TEXTUREFORMAT3:
-                elements[idx].format = WINED3DFMT_R32G32B32_FLOAT;
+                append_decl_element(&state, WINED3DFMT_R32G32B32_FLOAT, WINED3DDECLUSAGE_TEXCOORD, idx);
                 break;
             case WINED3DFVF_TEXTUREFORMAT4:
-                elements[idx].format = WINED3DFMT_R32G32B32A32_FLOAT;
+                append_decl_element(&state, WINED3DFMT_R32G32B32A32_FLOAT, WINED3DDECLUSAGE_TEXCOORD, idx);
                 break;
         }
-        elements[idx].usage = WINED3DDECLUSAGE_TEXCOORD;
-        elements[idx].usage_idx = idx2;
-        idx++;
-    }
-
-    /* Now compute offsets, and initialize the rest of the fields */
-    for (idx = 0, offset = 0; idx < size; ++idx)
-    {
-        const struct GlPixelFormatDesc *format_desc = getFormatDescEntry(elements[idx].format, &This->adapter->gl_info);
-        elements[idx].input_slot = 0;
-        elements[idx].method = WINED3DDECLMETHOD_DEFAULT;
-        elements[idx].offset = offset;
-        offset += format_desc->component_count * format_desc->component_size;
-    }
-
-    *ppVertexElements = elements;
+    }
+
+    *ppVertexElements = state.elements;
     return size;
 }
@@ -1235 +1370 @@
     IWineD3DPaletteImpl *object;
     HRESULT hr;
-    TRACE("(%p)->(%x, %p, %p, %p)\n", This, Flags, PalEnt, Palette, Parent);
-
-    /* Create the new object */
-    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DPaletteImpl));
-    if(!object) {
-        ERR("Out of memory when allocating memory for a IWineD3DPalette implementation\n");
+
+    TRACE("iface %p, flags %#x, entries %p, palette %p, parent %p.\n",
+            iface, Flags, PalEnt, Palette, Parent);
+
+    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
+    if (!object)
+    {
+        ERR("Failed to allocate palette memory.\n");
         return E_OUTOFMEMORY;
     }
 
-    object->lpVtbl = &IWineD3DPalette_Vtbl;
-    object->ref = 1;
-    object->Flags = Flags;
-    object->parent = Parent;
-    object->device = This;
-    object->palNumEntries = IWineD3DPaletteImpl_Size(Flags);
-    object->hpal = CreatePalette((const LOGPALETTE*)&(object->palVersion));
-
-    if(!object->hpal) {
-        HeapFree( GetProcessHeap(), 0, object);
-        return E_OUTOFMEMORY;
-    }
-
-    hr = IWineD3DPalette_SetEntries((IWineD3DPalette *) object, 0, 0, IWineD3DPaletteImpl_Size(Flags), PalEnt);
-    if(FAILED(hr)) {
-        IWineD3DPalette_Release((IWineD3DPalette *) object);
+    hr = wined3d_palette_init(object, This, Flags, PalEnt, Parent);
+    if (FAILED(hr))
+    {
+        WARN("Failed to initialize palette, hr %#x.\n", hr);
+        HeapFree(GetProcessHeap(), 0, object);
         return hr;
     }
 
-    *Palette = (IWineD3DPalette *) object;
+    TRACE("Created palette %p.\n", object);
+    *Palette = (IWineD3DPalette *)object;
 
     return WINED3D_OK;
@@ -1382 +1509 @@
 }
 
+static HRESULT WINAPI IWineD3DDeviceImpl_AcquireFocusWindow(IWineD3DDevice *iface, HWND window)
+{
+    IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)iface;
+
+    if (!wined3d_register_window(window, device))
+    {
+        ERR("Failed to register window %p.\n", window);
+        return E_FAIL;
+    }
+
+    device->focus_window = window;
+    SetForegroundWindow(window);
+
+    return WINED3D_OK;
+}
+
+static void WINAPI IWineD3DDeviceImpl_ReleaseFocusWindow(IWineD3DDevice *iface)
+{
+    IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)iface;
+
+    if (device->focus_window) wined3d_unregister_window(device->focus_window);
+    device->focus_window = NULL;
+}
+
 static HRESULT WINAPI IWineD3DDeviceImpl_Init3D(IWineD3DDevice *iface,
         WINED3DPRESENT_PARAMETERS *pPresentationParameters)
@@ -1397 +1548 @@
     if(This->d3d_initialized) return WINED3DERR_INVALIDCALL;
     if(!This->adapter->opengl) return WINED3DERR_INVALIDCALL;
-
-    if (!pPresentationParameters->Windowed)
-    {
-        This->focus_window = This->createParms.hFocusWindow;
-        if (!This->focus_window) This->focus_window = pPresentationParameters->hDeviceWindow;
-        if (!wined3d_register_window(This->focus_window, This))
-        {
-            ERR("Failed to register window %p.\n", This->focus_window);
-            return E_FAIL;
-        }
-    }
 
     TRACE("(%p) : Creating stateblock\n", This);
@@ -1462 +1602 @@
     }
 
-    if (This->focus_window) SetFocus(This->focus_window);
-
     /* Setup the implicit swapchain. This also initializes a context. */
     TRACE("Creating implicit swapchain\n");
@@ -1534 +1672 @@
         case ORM_FBO:
             This->offscreenBuffer = GL_COLOR_ATTACHMENT0;
-            break;
-
-        case ORM_PBUFFER:
-            This->offscreenBuffer = GL_BACK;
             break;
 
@@ -1598 +1732 @@
         This->shader_backend->shader_free_private(iface);
     }
-    if (This->focus_window) wined3d_unregister_window(This->focus_window);
     return hr;
 }
@@ -1672 +1805 @@
         }
     }
-
-    /* Delete the palette conversion shader if it is around */
-    if(This->paletteConversionShader) {
-        ENTER_GL();
-        GL_EXTCALL(glDeleteProgramsARB(1, &This->paletteConversionShader));
-        LEAVE_GL();
-        This->paletteConversionShader = 0;
-    }
-
-    /* Delete the pbuffer context if there is any */
-    if(This->pbufferContext) context_destroy(This, This->pbufferContext);
 
     /* Delete the mouse cursor texture */
@@ -1750 +1872 @@
 
     TRACE("Releasing the render target at %p\n", This->render_targets[0]);
-    if(IWineD3DSurface_Release(This->render_targets[0]) >0){
-          /* This check is a bit silly, it should be in swapchain_release FIXME("(%p) Something's still holding the renderTarget\n",This); */
-    }
+    IWineD3DSurface_Release(This->render_targets[0]);
+
     TRACE("Setting rendertarget to NULL\n");
     This->render_targets[0] = NULL;
@@ -1788 +1909 @@
 
     This->d3d_initialized = FALSE;
-
-    if (This->focus_window) wined3d_unregister_window(This->focus_window);
 
     return WINED3D_OK;
@@ -1828 +1947 @@
     DEVMODEW devmode;
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    const struct wined3d_format_desc *format_desc = getFormatDescEntry(pMode->Format, &This->adapter->gl_info);
     LONG ret;
-    const struct GlPixelFormatDesc *format_desc = getFormatDescEntry(pMode->Format, &This->adapter->gl_info);
     RECT clip_rc;
 
@@ -2943 +3062 @@
             iface, dstData, start, count);
 
-    if (dstData == NULL || ((signed int) MAX_CONST_I - (signed int) start) <= (signed int) 0)
+    if (dstData == NULL || ((signed int) MAX_CONST_I - (signed int) start) <= 0)
         return WINED3DERR_INVALIDCALL;
 
@@ -3064 +3183 @@
 }
 
-static void device_map_fixed_function_samplers(IWineD3DDeviceImpl *This) {
+static void device_map_fixed_function_samplers(IWineD3DDeviceImpl *This, const struct wined3d_gl_info *gl_info)
+{
     unsigned int i, tex;
     WORD ffu_map;
@@ -3071 +3191 @@
     ffu_map = This->fixed_function_usage_map;
 
-    if (This->max_ffp_textures == This->max_ffp_texture_stages ||
-            This->stateBlock->lowest_disabled_stage <= This->max_ffp_textures) {
+    if (This->max_ffp_textures == gl_info->limits.texture_stages
+            || This->stateBlock->lowest_disabled_stage <= This->max_ffp_textures)
+    {
         for (i = 0; ffu_map; ffu_map >>= 1, ++i)
         {
@@ -3102 +3223 @@
 }
 
-static void device_map_psamplers(IWineD3DDeviceImpl *This) {
+static void device_map_psamplers(IWineD3DDeviceImpl *This, const struct wined3d_gl_info *gl_info)
+{
     const WINED3DSAMPLER_TEXTURE_TYPE *sampler_type =
             ((IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader)->baseShader.reg_maps.sampler_type;
@@ -3112 +3234 @@
             device_map_stage(This, i, i);
             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
-            if (i < MAX_TEXTURES) {
+            if (i < gl_info->limits.texture_stages)
+            {
                 markTextureStagesDirty(This, i);
             }
@@ -3143 +3266 @@
 }
 
-static void device_map_vsamplers(IWineD3DDeviceImpl *This, BOOL ps) {
+static void device_map_vsamplers(IWineD3DDeviceImpl *This, BOOL ps, const struct wined3d_gl_info *gl_info)
+{
     const WINED3DSAMPLER_TEXTURE_TYPE *vshader_sampler_type =
             ((IWineD3DVertexShaderImpl *)This->stateBlock->vertexShader)->baseShader.reg_maps.sampler_type;
     const WINED3DSAMPLER_TEXTURE_TYPE *pshader_sampler_type = NULL;
-    int start = min(MAX_COMBINED_SAMPLERS, This->adapter->gl_info.limits.combined_samplers) - 1;
+    int start = min(MAX_COMBINED_SAMPLERS, gl_info->limits.combined_samplers) - 1;
     int i;
 
@@ -3184 +3308 @@
 }
 
-void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This) {
+void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This)
+{
+    const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
     BOOL vs = use_vs(This->stateBlock);
     BOOL ps = use_ps(This->stateBlock);
@@ -3194 +3320 @@
      * to be reset. Because of that try to work with a 1:1 mapping as much as possible
      */
-    if (ps) {
-        device_map_psamplers(This);
-    } else {
-        device_map_fixed_function_samplers(This);
-    }
-
-    if (vs) {
-        device_map_vsamplers(This, ps);
-    }
+    if (ps) device_map_psamplers(This, gl_info);
+    else device_map_fixed_function_samplers(This, gl_info);
+
+    if (vs) device_map_vsamplers(This, ps, gl_info);
 }
 
@@ -3816 +3937 @@
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
     DWORD oldValue = This->updateStateBlock->textureState[Stage][Type];
+    const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
 
     TRACE("(%p) : Stage=%d, Type=%s(%d), Value=%d\n", This, Stage, debug_d3dtexturestate(Type), Type, Value);
 
-    if (Stage >= MAX_TEXTURES) {
-        WARN("Attempting to set stage %u which is higher than the max stage %u, ignoring\n", Stage, MAX_TEXTURES - 1);
+    if (Stage >= gl_info->limits.texture_stages)
+    {
+        WARN("Attempting to set stage %u which is higher than the max stage %u, ignoring.\n",
+                Stage, gl_info->limits.texture_stages - 1);
         return WINED3D_OK;
     }
@@ -3901 +4025 @@
 {
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
     IWineD3DBaseTexture *prev;
 
@@ -3959 +4084 @@
         }
 
-        if (!prev && stage < MAX_TEXTURES)
+        if (!prev && stage < gl_info->limits.texture_stages)
         {
             /* The source arguments for color and alpha ops have different
@@ -3978 +4103 @@
         IWineD3DBaseTexture_Release(prev);
 
-        if (!texture && stage < MAX_TEXTURES)
+        if (!texture && stage < gl_info->limits.texture_stages)
         {
             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(stage, WINED3DTSS_COLOROP));
@@ -4205 +4330 @@
 }
 
+static BOOL is_full_clear(IWineD3DSurfaceImpl *target, const WINED3DVIEWPORT *viewport,
+        const RECT *scissor_rect, const WINED3DRECT *clear_rect)
+{
+    /* partial viewport*/
+    if (viewport->X != 0 || viewport->Y != 0
+            || viewport->Width < target->currentDesc.Width
+            || viewport->Height < target->currentDesc.Height)
+        return FALSE;
+
+    /* partial scissor rect */
+    if (scissor_rect && (scissor_rect->left > 0 || scissor_rect->top > 0
+            || scissor_rect->right < target->currentDesc.Width
+            || scissor_rect->bottom < target->currentDesc.Height))
+        return FALSE;
+
+    /* partial clear rect */
+    if (clear_rect && (clear_rect->x1 > 0 || clear_rect->y1 > 0
+            || clear_rect->x2 < target->currentDesc.Width
+            || clear_rect->y2 < target->currentDesc.Height))
+        return FALSE;
+
+    return TRUE;
+}
+
 /* Not called from the VTable (internal subroutine) */
-HRESULT IWineD3DDeviceImpl_ClearSurface(IWineD3DDeviceImpl *This,  IWineD3DSurfaceImpl *target, DWORD Count,
-                                        CONST WINED3DRECT* pRects, DWORD Flags, WINED3DCOLOR Color,
-                                        float Z, DWORD Stencil) {
+HRESULT IWineD3DDeviceImpl_ClearSurface(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target, DWORD Count,
+        const WINED3DRECT *pRects, DWORD Flags, WINED3DCOLOR Color, float Z, DWORD Stencil)
+{
+    IWineD3DStateBlockImpl *stateblock = This->stateBlock;
+    const RECT *scissor_rect = stateblock->renderState[WINED3DRS_SCISSORTESTENABLE] ? &stateblock->scissorRect : NULL;
+    const WINED3DRECT *clear_rect = (Count > 0 && pRects) ? pRects : NULL;
+    const WINED3DVIEWPORT *vp = &stateblock->viewport;
     GLbitfield     glMask = 0;
     unsigned int   i;
     WINED3DRECT curRect;
     RECT vp_rect;
-    const WINED3DVIEWPORT *vp = &This->stateBlock->viewport;
     UINT drawable_width, drawable_height;
     IWineD3DSurfaceImpl *depth_stencil = (IWineD3DSurfaceImpl *) This->stencilBufferTarget;
-    IWineD3DSwapChainImpl *swapchain = NULL;
     struct wined3d_context *context;
 
@@ -4228 +4379 @@
      * checking all this if the dest surface is in the drawable anyway.
      */
-    if((Flags & WINED3DCLEAR_TARGET) && !(target->Flags & SFLAG_INDRAWABLE)) {
-        while(1) {
-            if(vp->X != 0 || vp->Y != 0 ||
-               vp->Width < target->currentDesc.Width || vp->Height < target->currentDesc.Height) {
-                IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
-                break;
-            }
-            if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE] && (
-               This->stateBlock->scissorRect.left > 0 || This->stateBlock->scissorRect.top > 0 ||
-               This->stateBlock->scissorRect.right < target->currentDesc.Width ||
-               This->stateBlock->scissorRect.bottom < target->currentDesc.Height)) {
-                IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
-                break;
-            }
-            if(Count > 0 && pRects && (
-               pRects[0].x1 > 0 || pRects[0].y1 > 0 ||
-               pRects[0].x2 < target->currentDesc.Width ||
-               pRects[0].y2 < target->currentDesc.Height)) {
-                IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
-                break;
-            }
-            break;
-        }
+    if (Flags & WINED3DCLEAR_TARGET && !(target->Flags & SFLAG_INDRAWABLE))
+    {
+        if (!is_full_clear(target, vp, scissor_rect, clear_rect))
+            IWineD3DSurface_LoadLocation((IWineD3DSurface *)target, SFLAG_INDRAWABLE, NULL);
     }
 
     context = context_acquire(This, (IWineD3DSurface *)target, CTXUSAGE_CLEAR);
+    if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
+    {
+        if (!surface_is_offscreen((IWineD3DSurface *)target))
+        {
+            TRACE("Surface %p is onscreen\n", target);
+
+            ENTER_GL();
+            context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
+            context_set_draw_buffer(context, surface_get_gl_buffer((IWineD3DSurface *)target));
+            LEAVE_GL();
+        }
+        else
+        {
+            TRACE("Surface %p is offscreen\n", target);
+
+            ENTER_GL();
+            context_bind_fbo(context, GL_FRAMEBUFFER, &context->dst_fbo);
+            context_attach_surface_fbo(context, GL_FRAMEBUFFER, 0, target);
+            context_attach_depth_stencil_fbo(context, GL_FRAMEBUFFER, depth_stencil, TRUE);
+            LEAVE_GL();
+        }
+    }
+
+    if (!context->valid)
+    {
+        context_release(context);
+        WARN("Invalid context, skipping clear.\n");
+        return WINED3D_OK;
+    }
 
     target->get_drawable_size(context, &drawable_width, &drawable_height);
@@ -4260 +4421 @@
 
     /* Only set the values up once, as they are not changing */
-    if (Flags & WINED3DCLEAR_STENCIL) {
+    if (Flags & WINED3DCLEAR_STENCIL)
+    {
+        if (context->gl_info->supported[EXT_STENCIL_TWO_SIDE])
+        {
+            glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
+            IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE));
+        }
+        glStencilMask(~0U);
+        IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
         glClearStencil(Stencil);
         checkGLcall("glClearStencil");
         glMask = glMask | GL_STENCIL_BUFFER_BIT;
-        glStencilMask(0xFFFFFFFF);
-    }
-
-    if (Flags & WINED3DCLEAR_ZBUFFER) {
+    }
+
+    if (Flags & WINED3DCLEAR_ZBUFFER)
+    {
         DWORD location = context->render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
+        if (!(depth_stencil->Flags & location) && !is_full_clear(depth_stencil, vp, scissor_rect, clear_rect))
+            surface_load_ds_location(This->stencilBufferTarget, context, location);
+
         glDepthMask(GL_TRUE);
+        IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
         glClearDepth(Z);
         checkGLcall("glClearDepth");
         glMask = glMask | GL_DEPTH_BUFFER_BIT;
-        IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
-
-        if (vp->X != 0 || vp->Y != 0 ||
-                vp->Width < depth_stencil->currentDesc.Width || vp->Height < depth_stencil->currentDesc.Height) {
-            surface_load_ds_location(This->stencilBufferTarget, context, location);
-        }
-        else if (This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE] && (
-                This->stateBlock->scissorRect.left > 0 || This->stateBlock->scissorRect.top > 0 ||
-                This->stateBlock->scissorRect.right < depth_stencil->currentDesc.Width ||
-                This->stateBlock->scissorRect.bottom < depth_stencil->currentDesc.Height)) {
-            surface_load_ds_location(This->stencilBufferTarget, context, location);
-        }
-        else if (Count > 0 && pRects && (
-                pRects[0].x1 > 0 || pRects[0].y1 > 0 ||
-                pRects[0].x2 < depth_stencil->currentDesc.Width ||
-                pRects[0].y2 < depth_stencil->currentDesc.Height)) {
-            surface_load_ds_location(This->stencilBufferTarget, context, location);
-        }
-    }
-
-    if (Flags & WINED3DCLEAR_TARGET) {
-        TRACE("Clearing screen with glClear to color %x\n", Color);
-        glClearColor(D3DCOLOR_R(Color),
-                     D3DCOLOR_G(Color),
-                     D3DCOLOR_B(Color),
-                     D3DCOLOR_A(Color));
+    }
+
+    if (Flags & WINED3DCLEAR_TARGET)
+    {
+        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+        IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
+        IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
+        IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
+        IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
+        glClearColor(D3DCOLOR_R(Color), D3DCOLOR_G(Color), D3DCOLOR_B(Color), D3DCOLOR_A(Color));
         checkGLcall("glClearColor");
-
-        /* Clear ALL colors! */
-        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
         glMask = glMask | GL_COLOR_BUFFER_BIT;
     }
@@ -4362 +4516 @@
     }
 
-    /* Restore the old values (why..?) */
-    if (Flags & WINED3DCLEAR_STENCIL) {
-        glStencilMask(This->stateBlock->renderState[WINED3DRS_STENCILWRITEMASK]);
-    }
-    if (Flags & WINED3DCLEAR_TARGET) {
-        DWORD mask = This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE];
-        glColorMask(mask & WINED3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
-                    mask & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
-                    mask & WINED3DCOLORWRITEENABLE_BLUE  ? GL_TRUE : GL_FALSE,
-                    mask & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
-
-        /* Dirtify the target surface for now. If the surface is locked regularly, and an up to date sysmem copy exists,
-         * it is most likely more efficient to perform a clear on the sysmem copy too instead of downloading it
-         */
+    if (Flags & WINED3DCLEAR_TARGET)
+    {
         IWineD3DSurface_ModifyLocation((IWineD3DSurface *)target, SFLAG_INDRAWABLE, TRUE);
     }
@@ -4386 +4528 @@
     LEAVE_GL();
 
-    if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *)target, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
-        if (target == (IWineD3DSurfaceImpl*) swapchain->frontBuffer) {
-            wglFlush();
-        }
-        IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
-    }
+    if (wined3d_settings.strict_draw_ordering || ((target->Flags & SFLAG_SWAPCHAIN)
+            && ((IWineD3DSwapChainImpl *)target->container)->frontBuffer == (IWineD3DSurface *)target))
+        wglFlush(); /* Flush to ensure ordering across contexts. */
 
     context_release(context);
@@ -5044 +5183 @@
 }
 
-static HRESULT  WINAPI  IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface, IWineD3DSurface *pSourceSurface, CONST RECT* pSourceRect, IWineD3DSurface *pDestinationSurface, CONST POINT* pDestPoint) {
-    IWineD3DDeviceImpl  *This         = (IWineD3DDeviceImpl *) iface;
-    /** TODO: remove casts to IWineD3DSurfaceImpl
-     *       NOTE: move code to surface to accomplish this
-      ****************************************/
-    IWineD3DSurfaceImpl *pSrcSurface  = (IWineD3DSurfaceImpl *)pSourceSurface;
-    IWineD3DSurfaceImpl *dst_impl = (IWineD3DSurfaceImpl *)pDestinationSurface;
-    int srcWidth, srcHeight;
-    unsigned int  srcSurfaceWidth, srcSurfaceHeight, destSurfaceWidth, destSurfaceHeight;
-    WINED3DFORMAT destFormat, srcFormat;
-    UINT          destSize;
-    int srcLeft, destLeft, destTop;
-    WINED3DPOOL       srcPool, destPool;
-    int offset    = 0;
-    int rowoffset = 0; /* how many bytes to add onto the end of a row to wraparound to the beginning of the next */
-    const struct GlPixelFormatDesc *src_format_desc, *dst_format_desc;
-    GLenum dummy;
+static HRESULT WINAPI IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface,
+        IWineD3DSurface *src_surface, const RECT *src_rect,
+        IWineD3DSurface *dst_surface, const POINT *dst_point)
+{
+    IWineD3DSurfaceImpl *src_impl = (IWineD3DSurfaceImpl *)src_surface;
+    IWineD3DSurfaceImpl *dst_impl = (IWineD3DSurfaceImpl *)dst_surface;
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
+    const struct wined3d_format_desc *src_format;
+    const struct wined3d_format_desc *dst_format;
+    struct wined3d_context *context;
+    const unsigned char *data;
+    UINT update_w, update_h;
+    CONVERT_TYPES convert;
+    UINT src_w, src_h;
+    UINT dst_x, dst_y;
     DWORD sampler;
-    int bpp;
-    CONVERT_TYPES convert = NO_CONVERSION;
-    struct wined3d_context *context;
-
-    WINED3DSURFACE_DESC  winedesc;
-
-    TRACE("(%p) : Source (%p)  Rect (%p) Destination (%p) Point(%p)\n", This, pSourceSurface, pSourceRect, pDestinationSurface, pDestPoint);
-
-    IWineD3DSurface_GetDesc(pSourceSurface, &winedesc);
-    srcSurfaceWidth = winedesc.width;
-    srcSurfaceHeight = winedesc.height;
-    srcPool = winedesc.pool;
-    srcFormat = winedesc.format;
-
-    IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
-    destSurfaceWidth = winedesc.width;
-    destSurfaceHeight = winedesc.height;
-    destPool = winedesc.pool;
-    destFormat = winedesc.format;
-    destSize = winedesc.size;
-
-    if(srcPool != WINED3DPOOL_SYSTEMMEM  || destPool != WINED3DPOOL_DEFAULT){
-        WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, returning WINED3DERR_INVALIDCALL\n", pSourceSurface, pDestinationSurface);
+    struct wined3d_format_desc dummy_desc;
+
+    TRACE("iface %p, src_surface %p, src_rect %s, dst_surface %p, dst_point %s",
+            iface, src_surface, wine_dbgstr_rect(src_rect),
+            dst_surface, wine_dbgstr_point(dst_point));
+
+    if (src_impl->resource.pool != WINED3DPOOL_SYSTEMMEM || dst_impl->resource.pool != WINED3DPOOL_DEFAULT)
+    {
+        WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, returning WINED3DERR_INVALIDCALL\n",
+                src_surface, dst_surface);
         return WINED3DERR_INVALIDCALL;
     }
 
-    /* This call loads the opengl surface directly, instead of copying the surface to the
-     * destination's sysmem copy. If surface conversion is needed, use BltFast instead to
-     * copy in sysmem and use regular surface loading.
-     */
-    d3dfmt_get_conv(dst_impl, FALSE, TRUE, &dummy, &dummy, &dummy, &convert, &bpp, FALSE);
-    if(convert != NO_CONVERSION) {
-        return IWineD3DSurface_BltFast(pDestinationSurface,
-                                        pDestPoint  ? pDestPoint->x : 0,
-                                        pDestPoint  ? pDestPoint->y : 0,
-                                        pSourceSurface, pSourceRect, 0);
-    }
-
-    if (destFormat == WINED3DFMT_UNKNOWN) {
-        TRACE("(%p) : Converting destination surface from WINED3DFMT_UNKNOWN to the source format\n", This);
-        IWineD3DSurface_SetFormat(pDestinationSurface, srcFormat);
-
-        /* Get the update surface description */
-        IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
-    }
+    src_format = src_impl->resource.format_desc;
+    dst_format = dst_impl->resource.format_desc;
+
+    if (src_format->format != dst_format->format)
+    {
+        WARN("Source and destination surfaces should have the same format.\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    dst_x = dst_point ? dst_point->x : 0;
+    dst_y = dst_point ? dst_point->y : 0;
+
+    /* This call loads the OpenGL surface directly, instead of copying the
+     * surface to the destination's sysmem copy. If surface conversion is
+     * needed, use BltFast instead to copy in sysmem and use regular surface
+     * loading. */
+    d3dfmt_get_conv(dst_impl, FALSE, TRUE, &dummy_desc, &convert);
+    if (convert != NO_CONVERSION)
+        return IWineD3DSurface_BltFast(dst_surface, dst_x, dst_y, src_surface, src_rect, 0);
 
     context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
@@ -5116 +5240 @@
 
     /* Make sure the surface is loaded and up to date */
-    surface_internal_preload(pDestinationSurface, SRGB_RGB);
-    IWineD3DSurface_BindTexture(pDestinationSurface, FALSE);
-
-    src_format_desc = ((IWineD3DSurfaceImpl *)pSrcSurface)->resource.format_desc;
-    dst_format_desc = dst_impl->resource.format_desc;
-
-    /* this needs to be done in lines if the sourceRect != the sourceWidth */
-    srcWidth   = pSourceRect ? pSourceRect->right - pSourceRect->left   : srcSurfaceWidth;
-    srcHeight  = pSourceRect ? pSourceRect->bottom - pSourceRect->top   : srcSurfaceHeight;
-    srcLeft    = pSourceRect ? pSourceRect->left : 0;
-    destLeft   = pDestPoint  ? pDestPoint->x : 0;
-    destTop    = pDestPoint  ? pDestPoint->y : 0;
-
-
-    /* This function doesn't support compressed textures
-    the pitch is just bytesPerPixel * width */
-    if(srcWidth != srcSurfaceWidth  || srcLeft ){
-        rowoffset = srcSurfaceWidth * src_format_desc->byte_count;
-        offset   += srcLeft * src_format_desc->byte_count;
-        /* TODO: do we ever get 3bpp?, would a shift and an add be quicker than a mul (well maybe a cycle or two) */
-    }
-    /* TODO DXT formats */
-
-    if(pSourceRect != NULL && pSourceRect->top != 0){
-       offset +=  pSourceRect->top * srcSurfaceWidth * src_format_desc->byte_count;
-    }
-    TRACE("(%p) glTexSubImage2D, level %d, left %d, top %d, width %d, height %d, fmt %#x, type %#x, memory %p+%#x\n",
-            This, dst_impl->texture_level, destLeft, destTop, srcWidth, srcHeight, dst_format_desc->glFormat,
-            dst_format_desc->glType, IWineD3DSurface_GetData(pSourceSurface), offset);
-
-    /* Sanity check */
-    if (IWineD3DSurface_GetData(pSourceSurface) == NULL) {
-
-        /* need to lock the surface to get the data */
-        FIXME("Surfaces has no allocated memory, but should be an in memory only surface\n");
-    }
+    surface_internal_preload(dst_surface, SRGB_RGB);
+    IWineD3DSurface_BindTexture(dst_surface, FALSE);
+
+    src_w = src_impl->currentDesc.Width;
+    src_h = src_impl->currentDesc.Height;
+    update_w = src_rect ? src_rect->right - src_rect->left : src_w;
+    update_h = src_rect ? src_rect->bottom - src_rect->top : src_h;
+
+    data = IWineD3DSurface_GetData(src_surface);
+    if (!data) ERR("Source surface has no allocated memory, but should be a sysmem surface.\n");
 
     ENTER_GL();
 
-    /* TODO: Cube and volume support */
-    if(rowoffset != 0){
-        /* not a whole row so we have to do it a line at a time */
-        int j;
-
-        /* hopefully using pointer addition will be quicker than using a point + j * rowoffset */
-        const unsigned char* data =((const unsigned char *)IWineD3DSurface_GetData(pSourceSurface)) + offset;
-
-        for (j = destTop; j < (srcHeight + destTop); ++j)
+    if (dst_format->Flags & WINED3DFMT_FLAG_COMPRESSED)
+    {
+        UINT row_length = (update_w / src_format->block_width) * src_format->block_byte_count;
+        UINT row_count = update_h / src_format->block_height;
+        UINT src_pitch = IWineD3DSurface_GetPitch(src_surface);
+
+        if (src_rect)
         {
-            glTexSubImage2D(dst_impl->texture_target, dst_impl->texture_level, destLeft, j,
-                    srcWidth, 1, dst_format_desc->glFormat, dst_format_desc->glType,data);
-            data += rowoffset;
-        }
-
-    } else { /* Full width, so just write out the whole texture */
-        const unsigned char* data = ((const unsigned char *)IWineD3DSurface_GetData(pSourceSurface)) + offset;
-
-        if (dst_format_desc->Flags & WINED3DFMT_FLAG_COMPRESSED)
+            data += (src_rect->top / src_format->block_height) * src_pitch;
+            data += (src_rect->left / src_format->block_width) * src_format->block_byte_count;
+        }
+
+        TRACE("glCompressedTexSubImage2DARB, target %#x, level %d, x %d, y %d, w %d, h %d, "
+                "format %#x, image_size %#x, data %p.\n", dst_impl->texture_target, dst_impl->texture_level,
+                dst_x, dst_y, update_w, update_h, dst_format->glFormat, row_count * row_length, data);
+
+        if (row_length == src_pitch)
         {
-            if (destSurfaceHeight != srcHeight || destSurfaceWidth != srcWidth)
-            {
-                /* FIXME: The easy way to do this is to lock the destination, and copy the bits across. */
-                FIXME("Updating part of a compressed texture is not supported.\n");
-            }
-            if (destFormat != srcFormat)
-            {
-                FIXME("Updating mixed format compressed textures is not supported.\n");
-            }
-            else
-            {
-                GL_EXTCALL(glCompressedTexImage2DARB(dst_impl->texture_target, dst_impl->texture_level,
-                        dst_format_desc->glInternal, srcWidth, srcHeight, 0, destSize, data));
-            }
+            GL_EXTCALL(glCompressedTexSubImage2DARB(dst_impl->texture_target, dst_impl->texture_level,
+                    dst_x, dst_y, update_w, update_h, dst_format->glInternal, row_count * row_length, data));
         }
         else
         {
-            glTexSubImage2D(dst_impl->texture_target, dst_impl->texture_level, destLeft, destTop,
-                    srcWidth, srcHeight, dst_format_desc->glFormat, dst_format_desc->glType, data);
-        }
-     }
-    checkGLcall("glTexSubImage2D");
+            UINT row, y;
+
+            /* glCompressedTexSubImage2DARB() ignores pixel store state, so we
+             * can't use the unpack row length like below. */
+            for (row = 0, y = dst_y; row < row_count; ++row)
+            {
+                GL_EXTCALL(glCompressedTexSubImage2DARB(dst_impl->texture_target, dst_impl->texture_level,
+                        dst_x, y, update_w, src_format->block_height, dst_format->glInternal, row_length, data));
+                y += src_format->block_height;
+                data += src_pitch;
+            }
+        }
+        checkGLcall("glCompressedTexSubImage2DARB");
+    }
+    else
+    {
+        if (src_rect)
+        {
+            data += src_rect->top * src_w * src_format->byte_count;
+            data += src_rect->left * src_format->byte_count;
+        }
+
+        TRACE("glTexSubImage2D, target %#x, level %d, x %d, y %d, w %d, h %d, format %#x, type %#x, data %p.\n",
+                dst_impl->texture_target, dst_impl->texture_level, dst_x, dst_y,
+                update_w, update_h, dst_format->glFormat, dst_format->glType, data);
+
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, src_w);
+        glTexSubImage2D(dst_impl->texture_target, dst_impl->texture_level, dst_x, dst_y,
+                update_w, update_h, dst_format->glFormat, dst_format->glType, data);
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+        checkGLcall("glTexSubImage2D");
+    }
 
     LEAVE_GL();
     context_release(context);
 
-    IWineD3DSurface_ModifyLocation(pDestinationSurface, SFLAG_INTEXTURE, TRUE);
+    IWineD3DSurface_ModifyLocation(dst_surface, SFLAG_INTEXTURE, TRUE);
     sampler = This->rev_tex_unit_map[0];
     if (sampler != WINED3D_UNMAPPED_STAGE)
@@ -5331 +5442 @@
 }
 
-static IWineD3DSwapChain *get_swapchain(IWineD3DSurface *target) {
-    HRESULT hr;
-    IWineD3DSwapChain *swapchain;
-
-    hr = IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **)&swapchain);
-    if (SUCCEEDED(hr)) {
-        IWineD3DSwapChain_Release((IUnknown *)swapchain);
-        return swapchain;
-    }
-
-    return NULL;
-}
-
 static void color_fill_fbo(IWineD3DDevice *iface, IWineD3DSurface *surface,
         const WINED3DRECT *rect, const float color[4])
@@ -5349 +5447 @@
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
     struct wined3d_context *context;
+
+    if (rect) IWineD3DSurface_LoadLocation(surface, SFLAG_INDRAWABLE, NULL);
+    IWineD3DSurface_ModifyLocation(surface, SFLAG_INDRAWABLE, TRUE);
 
     if (!surface_is_offscreen(surface))
@@ -5366 +5467 @@
         ENTER_GL();
         context_bind_fbo(context, GL_FRAMEBUFFER, &context->dst_fbo);
-        context_attach_surface_fbo(context, GL_FRAMEBUFFER, 0, surface);
+        context_attach_surface_fbo(context, GL_FRAMEBUFFER, 0, (IWineD3DSurfaceImpl *)surface);
         context_attach_depth_stencil_fbo(context, GL_FRAMEBUFFER, NULL, FALSE);
     }
@@ -5390 +5491 @@
     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
+    IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
+    IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
+    IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
 
     glClearColor(color[0], color[1], color[2], color[3]);
@@ -5396 +5500 @@
 
     LEAVE_GL();
+
+    if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
+
     context_release(context);
-}
-
-static inline DWORD argb_to_fmt(DWORD color, WINED3DFORMAT destfmt) {
-    unsigned int r, g, b, a;
-    DWORD ret;
-
-    if (destfmt == WINED3DFMT_B8G8R8A8_UNORM
-            || destfmt == WINED3DFMT_B8G8R8X8_UNORM
-            || destfmt == WINED3DFMT_B8G8R8_UNORM)
-        return color;
-
-    TRACE("Converting color %08x to format %s\n", color, debug_d3dformat(destfmt));
-
-    a = (color & 0xff000000) >> 24;
-    r = (color & 0x00ff0000) >> 16;
-    g = (color & 0x0000ff00) >>  8;
-    b = (color & 0x000000ff) >>  0;
-
-    switch(destfmt)
-    {
-        case WINED3DFMT_B5G6R5_UNORM:
-            if(r == 0xff && g == 0xff && b == 0xff) return 0xffff;
-            r = (r * 32) / 256;
-            g = (g * 64) / 256;
-            b = (b * 32) / 256;
-            ret  = r << 11;
-            ret |= g << 5;
-            ret |= b;
-            TRACE("Returning %08x\n", ret);
-            return ret;
-
-        case WINED3DFMT_B5G5R5X1_UNORM:
-        case WINED3DFMT_B5G5R5A1_UNORM:
-            a = (a *  2) / 256;
-            r = (r * 32) / 256;
-            g = (g * 32) / 256;
-            b = (b * 32) / 256;
-            ret  = a << 15;
-            ret |= r << 10;
-            ret |= g <<  5;
-            ret |= b <<  0;
-            TRACE("Returning %08x\n", ret);
-            return ret;
-
-        case WINED3DFMT_A8_UNORM:
-            TRACE("Returning %08x\n", a);
-            return a;
-
-        case WINED3DFMT_B4G4R4X4_UNORM:
-        case WINED3DFMT_B4G4R4A4_UNORM:
-            a = (a * 16) / 256;
-            r = (r * 16) / 256;
-            g = (g * 16) / 256;
-            b = (b * 16) / 256;
-            ret  = a << 12;
-            ret |= r <<  8;
-            ret |= g <<  4;
-            ret |= b <<  0;
-            TRACE("Returning %08x\n", ret);
-            return ret;
-
-        case WINED3DFMT_B2G3R3_UNORM:
-            r = (r * 8) / 256;
-            g = (g * 8) / 256;
-            b = (b * 4) / 256;
-            ret  = r <<  5;
-            ret |= g <<  2;
-            ret |= b <<  0;
-            TRACE("Returning %08x\n", ret);
-            return ret;
-
-        case WINED3DFMT_R8G8B8X8_UNORM:
-        case WINED3DFMT_R8G8B8A8_UNORM:
-            ret  = a << 24;
-            ret |= b << 16;
-            ret |= g <<  8;
-            ret |= r <<  0;
-            TRACE("Returning %08x\n", ret);
-            return ret;
-
-        case WINED3DFMT_B10G10R10A2_UNORM:
-            a = (a *    4) / 256;
-            r = (r * 1024) / 256;
-            g = (g * 1024) / 256;
-            b = (b * 1024) / 256;
-            ret  = a << 30;
-            ret |= r << 20;
-            ret |= g << 10;
-            ret |= b <<  0;
-            TRACE("Returning %08x\n", ret);
-            return ret;
-
-        case WINED3DFMT_R10G10B10A2_UNORM:
-            a = (a *    4) / 256;
-            r = (r * 1024) / 256;
-            g = (g * 1024) / 256;
-            b = (b * 1024) / 256;
-            ret  = a << 30;
-            ret |= b << 20;
-            ret |= g << 10;
-            ret |= r <<  0;
-            TRACE("Returning %08x\n", ret);
-            return ret;
-
-        default:
-            FIXME("Add a COLORFILL conversion for format %s\n", debug_d3dformat(destfmt));
-            return 0;
-    }
 }
 
@@ -5528 +5527 @@
         memset(&BltFx, 0, sizeof(BltFx));
         BltFx.dwSize = sizeof(BltFx);
-        BltFx.u5.dwFillColor = argb_to_fmt(color, surface->resource.format_desc->format);
+        BltFx.u5.dwFillColor = color_convert_argb_to_fmt(color, surface->resource.format_desc->format);
         return IWineD3DSurface_Blt(pSurface, (const RECT *)pRect, NULL, NULL,
                 WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_POINT);
@@ -5576 +5575 @@
         memset(&BltFx, 0, sizeof(BltFx));
         BltFx.dwSize = sizeof(BltFx);
-        BltFx.u5.dwFillColor = argb_to_fmt(c, ((IWineD3DSurfaceImpl *)surface)->resource.format_desc->format);
+        BltFx.u5.dwFillColor = color_convert_argb_to_fmt(c, ((IWineD3DSurfaceImpl *)surface)->resource.format_desc->format);
         hr = IWineD3DSurface_Blt(surface, NULL, NULL, NULL, WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_POINT);
         if (FAILED(hr))
@@ -5607 +5606 @@
 
 static HRESULT WINAPI IWineD3DDeviceImpl_SetFrontBackBuffers(IWineD3DDevice *iface,
-        IWineD3DSurface *Front, IWineD3DSurface *Back)
-{
-    IWineD3DSurfaceImpl *FrontImpl = (IWineD3DSurfaceImpl *) Front;
-    IWineD3DSurfaceImpl *BackImpl = (IWineD3DSurfaceImpl *) Back;
-    IWineD3DSwapChainImpl *Swapchain;
+        IWineD3DSurface *front, IWineD3DSurface *back)
+{
+    IWineD3DSurfaceImpl *front_impl = (IWineD3DSurfaceImpl *)front;
+    IWineD3DSurfaceImpl *back_impl = (IWineD3DSurfaceImpl *)back;
+    IWineD3DSwapChainImpl *swapchain;
     HRESULT hr;
 
-    TRACE("iface %p, front %p, back %p.\n", iface, Front, Back);
-
-    hr = IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **) &Swapchain);
-    if(hr != WINED3D_OK) {
-        ERR("Can't get the swapchain\n");
+    TRACE("iface %p, front %p, back %p.\n", iface, front, back);
+
+    if (FAILED(hr = IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **)&swapchain)))
+    {
+        ERR("Failed to get the swapchain, hr %#x.\n", hr);
         return hr;
     }
 
-    /* Make sure to release the swapchain */
-    IWineD3DSwapChain_Release((IWineD3DSwapChain *) Swapchain);
-
-    if(FrontImpl && !(FrontImpl->resource.usage & WINED3DUSAGE_RENDERTARGET) ) {
-        ERR("Trying to set a front buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage\n");
+    if (front_impl && !(front_impl->resource.usage & WINED3DUSAGE_RENDERTARGET))
+    {
+        ERR("Trying to set a front buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage.\n");
+        IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
         return WINED3DERR_INVALIDCALL;
     }
-    else if(BackImpl && !(BackImpl->resource.usage & WINED3DUSAGE_RENDERTARGET)) {
-        ERR("Trying to set a back buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage\n");
-        return WINED3DERR_INVALIDCALL;
-    }
-
-    if(Swapchain->frontBuffer != Front) {
-        TRACE("Changing the front buffer from %p to %p\n", Swapchain->frontBuffer, Front);
-
-        if(Swapchain->frontBuffer)
+
+    if (back_impl)
+    {
+        if (!(back_impl->resource.usage & WINED3DUSAGE_RENDERTARGET))
         {
-            IWineD3DSurface_SetContainer(Swapchain->frontBuffer, NULL);
-            ((IWineD3DSurfaceImpl *)Swapchain->frontBuffer)->Flags &= ~SFLAG_SWAPCHAIN;
-        }
-        Swapchain->frontBuffer = Front;
-
-        if(Swapchain->frontBuffer) {
-            IWineD3DSurface_SetContainer(Swapchain->frontBuffer, (IWineD3DBase *) Swapchain);
-            ((IWineD3DSurfaceImpl *)Swapchain->frontBuffer)->Flags |= SFLAG_SWAPCHAIN;
-        }
-    }
-
-    if(Back && !Swapchain->backBuffer) {
-        /* We need memory for the back buffer array - only one back buffer this way */
-        Swapchain->backBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DSurface *));
-        if(!Swapchain->backBuffer) {
-            ERR("Out of memory\n");
-            return E_OUTOFMEMORY;
-        }
-    }
-
-    if(Swapchain->backBuffer[0] != Back) {
-        TRACE("Changing the back buffer from %p to %p\n", Swapchain->backBuffer, Back);
-
-        /* What to do about the context here in the case of multithreading? Not sure.
-         * This function is called by IDirect3D7::CreateDevice so in theory its initialization code
-         */
-        WARN("No active context?\n");
-
-        ENTER_GL();
-        if(!Swapchain->backBuffer[0]) {
-            /* GL was told to draw to the front buffer at creation,
-             * undo that
-             */
-            glDrawBuffer(GL_BACK);
-            checkGLcall("glDrawBuffer(GL_BACK)");
-            /* Set the backbuffer count to 1 because other code uses it to fing the back buffers */
-            Swapchain->presentParms.BackBufferCount = 1;
-        } else if (!Back) {
-            /* That makes problems - disable for now */
-            /* glDrawBuffer(GL_FRONT); */
-            checkGLcall("glDrawBuffer(GL_FRONT)");
-            /* We have lost our back buffer, set this to 0 to avoid confusing other code */
-            Swapchain->presentParms.BackBufferCount = 0;
-        }
-        LEAVE_GL();
-
-        if(Swapchain->backBuffer[0])
+            ERR("Trying to set a back buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage.\n");
+            IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
+            return WINED3DERR_INVALIDCALL;
+        }
+
+        if (!swapchain->backBuffer)
         {
-            IWineD3DSurface_SetContainer(Swapchain->backBuffer[0], NULL);
-            ((IWineD3DSurfaceImpl *)Swapchain->backBuffer[0])->Flags &= ~SFLAG_SWAPCHAIN;
-        }
-        Swapchain->backBuffer[0] = Back;
-
-        if(Swapchain->backBuffer[0]) {
-            IWineD3DSurface_SetContainer(Swapchain->backBuffer[0], (IWineD3DBase *) Swapchain);
-            ((IWineD3DSurfaceImpl *)Swapchain->backBuffer[0])->Flags |= SFLAG_SWAPCHAIN;
-        } else {
-            HeapFree(GetProcessHeap(), 0, Swapchain->backBuffer);
-            Swapchain->backBuffer = NULL;
-        }
-
-    }
-
+            swapchain->backBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*swapchain->backBuffer));
+            if (!swapchain->backBuffer)
+            {
+                ERR("Failed to allocate back buffer array memory.\n");
+                IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
+                return E_OUTOFMEMORY;
+            }
+        }
+    }
+
+    if (swapchain->frontBuffer != front)
+    {
+        TRACE("Changing the front buffer from %p to %p.\n", swapchain->frontBuffer, front);
+
+        if (swapchain->frontBuffer)
+        {
+            IWineD3DSurface_SetContainer(swapchain->frontBuffer, NULL);
+            ((IWineD3DSurfaceImpl *)swapchain->frontBuffer)->Flags &= ~SFLAG_SWAPCHAIN;
+        }
+        swapchain->frontBuffer = front;
+
+        if (front)
+        {
+            IWineD3DSurface_SetContainer(front, (IWineD3DBase *)swapchain);
+            front_impl->Flags |= SFLAG_SWAPCHAIN;
+        }
+    }
+
+    if (swapchain->backBuffer[0] != back)
+    {
+        TRACE("Changing the back buffer from %p to %p.\n", swapchain->backBuffer[0], back);
+
+        if (swapchain->backBuffer[0])
+        {
+            IWineD3DSurface_SetContainer(swapchain->backBuffer[0], NULL);
+            ((IWineD3DSurfaceImpl *)swapchain->backBuffer[0])->Flags &= ~SFLAG_SWAPCHAIN;
+        }
+        swapchain->backBuffer[0] = back;
+
+        if (back)
+        {
+            swapchain->presentParms.BackBufferWidth = back_impl->currentDesc.Width;
+            swapchain->presentParms.BackBufferHeight = back_impl->currentDesc.Height;
+            swapchain->presentParms.BackBufferFormat = back_impl->resource.format_desc->format;
+            swapchain->presentParms.BackBufferCount = 1;
+
+            IWineD3DSurface_SetContainer(back, (IWineD3DBase *)swapchain);
+            back_impl->Flags |= SFLAG_SWAPCHAIN;
+        }
+        else
+        {
+            swapchain->presentParms.BackBufferCount = 0;
+            HeapFree(GetProcessHeap(), 0, swapchain->backBuffer);
+            swapchain->backBuffer = NULL;
+        }
+    }
+
+    IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
     return WINED3D_OK;
 }
@@ -5719 +5714 @@
 }
 
-void stretch_rect_fbo(IWineD3DDevice *iface, IWineD3DSurface *src_surface, WINED3DRECT *src_rect,
-        IWineD3DSurface *dst_surface, WINED3DRECT *dst_rect, const WINED3DTEXTUREFILTERTYPE filter, BOOL flip)
+void stretch_rect_fbo(IWineD3DDevice *iface, IWineD3DSurface *src_surface, const RECT *src_rect_in,
+        IWineD3DSurface *dst_surface, const RECT *dst_rect_in, const WINED3DTEXTUREFILTERTYPE filter)
 {
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
     GLbitfield mask = GL_COLOR_BUFFER_BIT; /* TODO: Support blitting depth/stencil surfaces */
-    IWineD3DSwapChain *src_swapchain, *dst_swapchain;
     const struct wined3d_gl_info *gl_info;
     struct wined3d_context *context;
     GLenum gl_filter;
     POINT offset = {0, 0};
-
-    TRACE("(%p) : src_surface %p, src_rect %p, dst_surface %p, dst_rect %p, filter %s (0x%08x), flip %u\n",
-            This, src_surface, src_rect, dst_surface, dst_rect, debug_d3dtexturefiltertype(filter), filter, flip);
-    TRACE("src_rect [%u, %u]->[%u, %u]\n", src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2);
-    TRACE("dst_rect [%u, %u]->[%u, %u]\n", dst_rect->x1, dst_rect->y1, dst_rect->x2, dst_rect->y2);
+    RECT src_rect, dst_rect;
+
+    TRACE("(%p) : src_surface %p, src_rect_in %p, dst_surface %p, dst_rect_in %p, filter %s (0x%08x)\n",
+            This, src_surface, src_rect_in, dst_surface, dst_rect_in, debug_d3dtexturefiltertype(filter), filter);
+    TRACE("src_rect_in %s\n", wine_dbgstr_rect(src_rect_in));
+    TRACE("dst_rect_in %s\n", wine_dbgstr_rect(dst_rect_in));
+
+    src_rect = *src_rect_in;
+    dst_rect = *dst_rect_in;
 
     switch (filter) {
@@ -5748 +5746 @@
     }
 
-    /* Attach src surface to src fbo */
-    src_swapchain = get_swapchain(src_surface);
-    dst_swapchain = get_swapchain(dst_surface);
-
-    if (src_swapchain) context = context_acquire(This, src_surface, CTXUSAGE_RESOURCELOAD);
-    else if (dst_swapchain) context = context_acquire(This, dst_surface, CTXUSAGE_RESOURCELOAD);
+    /* Make sure the drawables are up-to-date. Note that loading the
+     * destination surface isn't strictly required if we overwrite the
+     * entire surface. */
+    IWineD3DSurface_LoadLocation(src_surface, SFLAG_INDRAWABLE, NULL);
+    IWineD3DSurface_LoadLocation(dst_surface, SFLAG_INDRAWABLE, NULL);
+
+    if (!surface_is_offscreen(src_surface)) context = context_acquire(This, src_surface, CTXUSAGE_RESOURCELOAD);
+    else if (!surface_is_offscreen(dst_surface)) context = context_acquire(This, dst_surface, CTXUSAGE_RESOURCELOAD);
     else context = context_acquire(This, NULL, CTXUSAGE_RESOURCELOAD);
 
+    if (!context->valid)
+    {
+        context_release(context);
+        WARN("Invalid context, skipping blit.\n");
+        return;
+    }
+
     gl_info = context->gl_info;
 
@@ -5763 +5770 @@
 
         TRACE("Source surface %p is onscreen\n", src_surface);
-        /* Make sure the drawable is up to date. In the offscreen case
-         * attach_surface_fbo() implicitly takes care of this. */
-        IWineD3DSurface_LoadLocation(src_surface, SFLAG_INDRAWABLE, NULL);
 
         if(buffer == GL_FRONT) {
             RECT windowsize;
             UINT h;
-            ClientToScreen(((IWineD3DSwapChainImpl *)src_swapchain)->win_handle, &offset);
-            GetClientRect(((IWineD3DSwapChainImpl *)src_swapchain)->win_handle, &windowsize);
+            ClientToScreen(context->win_handle, &offset);
+            GetClientRect(context->win_handle, &windowsize);
             h = windowsize.bottom - windowsize.top;
-            src_rect->x1 -= offset.x; src_rect->x2 -=offset.x;
-            src_rect->y1 =  offset.y + h - src_rect->y1;
-            src_rect->y2 =  offset.y + h - src_rect->y2;
+            src_rect.left -= offset.x; src_rect.right -=offset.x;
+            src_rect.top =  offset.y + h - src_rect.top;
+            src_rect.bottom =  offset.y + h - src_rect.bottom;
         } else {
-            src_rect->y1 = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect->y1;
-            src_rect->y2 = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect->y2;
+            src_rect.top = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect.top;
+            src_rect.bottom = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect.bottom;
         }
 
@@ -5789 +5793 @@
         ENTER_GL();
         context_bind_fbo(context, GL_READ_FRAMEBUFFER, &context->src_fbo);
-        context_attach_surface_fbo(context, GL_READ_FRAMEBUFFER, 0, src_surface);
+        context_attach_surface_fbo(context, GL_READ_FRAMEBUFFER, 0, (IWineD3DSurfaceImpl *)src_surface);
         glReadBuffer(GL_COLOR_ATTACHMENT0);
         checkGLcall("glReadBuffer()");
@@ -5802 +5806 @@
 
         TRACE("Destination surface %p is onscreen\n", dst_surface);
-        /* Make sure the drawable is up to date. In the offscreen case
-         * attach_surface_fbo() implicitly takes care of this. */
-        IWineD3DSurface_LoadLocation(dst_surface, SFLAG_INDRAWABLE, NULL);
 
         if(buffer == GL_FRONT) {
             RECT windowsize;
             UINT h;
-            ClientToScreen(((IWineD3DSwapChainImpl *)dst_swapchain)->win_handle, &offset);
-            GetClientRect(((IWineD3DSwapChainImpl *)dst_swapchain)->win_handle, &windowsize);
+            ClientToScreen(context->win_handle, &offset);
+            GetClientRect(context->win_handle, &windowsize);
             h = windowsize.bottom - windowsize.top;
-            dst_rect->x1 -= offset.x; dst_rect->x2 -=offset.x;
-            dst_rect->y1 =  offset.y + h - dst_rect->y1;
-            dst_rect->y2 =  offset.y + h - dst_rect->y2;
+            dst_rect.left -= offset.x; dst_rect.right -=offset.x;
+            dst_rect.top =  offset.y + h - dst_rect.top;
+            dst_rect.bottom =  offset.y + h - dst_rect.bottom;
         } else {
             /* Screen coords = window coords, surface height = window height */
-            dst_rect->y1 = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect->y1;
-            dst_rect->y2 = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect->y2;
+            dst_rect.top = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect.top;
+            dst_rect.bottom = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect.bottom;
         }
 
@@ -5831 +5832 @@
         ENTER_GL();
         context_bind_fbo(context, GL_DRAW_FRAMEBUFFER, &context->dst_fbo);
-        context_attach_surface_fbo(context, GL_DRAW_FRAMEBUFFER, 0, dst_surface);
+        context_attach_surface_fbo(context, GL_DRAW_FRAMEBUFFER, 0, (IWineD3DSurfaceImpl *)dst_surface);
         context_set_draw_buffer(context, GL_COLOR_ATTACHMENT0);
         context_attach_depth_stencil_fbo(context, GL_DRAW_FRAMEBUFFER, NULL, FALSE);
@@ -5838 +5839 @@
     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
 
-    if (flip) {
-        gl_info->fbo_ops.glBlitFramebuffer(src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2,
-                dst_rect->x1, dst_rect->y2, dst_rect->x2, dst_rect->y1, mask, gl_filter);
-        checkGLcall("glBlitFramebuffer()");
-    } else {
-        gl_info->fbo_ops.glBlitFramebuffer(src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2,
-                dst_rect->x1, dst_rect->y1, dst_rect->x2, dst_rect->y2, mask, gl_filter);
-        checkGLcall("glBlitFramebuffer()");
-    }
+    gl_info->fbo_ops.glBlitFramebuffer(src_rect.left, src_rect.top, src_rect.right, src_rect.bottom,
+            dst_rect.left, dst_rect.top, dst_rect.right, dst_rect.bottom, mask, gl_filter);
+    checkGLcall("glBlitFramebuffer()");
 
     LEAVE_GL();
+
+    if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
+
     context_release(context);
 
@@ -6014 +6012 @@
             {
                 const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
-                const struct GlPixelFormatDesc *glDesc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
+                const struct wined3d_format_desc *format_desc = getFormatDescEntry(WINED3DFMT_B8G8R8A8_UNORM, gl_info);
                 struct wined3d_context *context;
                 char *mem, *bits = rect.pBits;
-                GLint intfmt = glDesc->glInternal;
-                GLint format = glDesc->glFormat;
-                GLint type = glDesc->glType;
+                GLint intfmt = format_desc->glInternal;
+                GLint format = format_desc->glFormat;
+                GLint type = format_desc->glType;
                 INT height = This->cursorHeight;
                 INT width = This->cursorWidth;
-                INT bpp = glDesc->byte_count;
+                INT bpp = format_desc->byte_count;
                 DWORD sampler;
                 INT i;
@@ -6207 +6205 @@
         while (surface->pow2Height < pPresentationParameters->BackBufferHeight) surface->pow2Height <<= 1;
     }
-    surface->glRect.left = 0;
-    surface->glRect.top = 0;
-    surface->glRect.right = surface->pow2Width;
-    surface->glRect.bottom = surface->pow2Height;
 
     if (surface->texture_name)
@@ -6276 +6270 @@
 }
 
-void delete_opengl_contexts(IWineD3DDevice *iface, IWineD3DSwapChain *swapchain_iface) {
+static void delete_opengl_contexts(IWineD3DDevice *iface, IWineD3DSwapChainImpl *swapchain)
+{
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
-    IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) swapchain_iface;
     const struct wined3d_gl_info *gl_info;
     struct wined3d_context *context;
@@ -6320 +6314 @@
 }
 
-HRESULT create_primary_opengl_context(IWineD3DDevice *iface, IWineD3DSwapChain *swapchain_iface) {
+static HRESULT create_primary_opengl_context(IWineD3DDevice *iface, IWineD3DSwapChainImpl *swapchain)
+{
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
-    IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) swapchain_iface;
     struct wined3d_context *context;
     HRESULT hr;
@@ -6336 +6330 @@
 
     target = (IWineD3DSurfaceImpl *)(swapchain->backBuffer ? swapchain->backBuffer[0] : swapchain->frontBuffer);
-    context = context_create(This, target, swapchain->win_handle, FALSE, &swapchain->presentParms);
-    if (!context)
+    if (!(context = context_create(swapchain, target, swapchain->ds_format)))
     {
         WARN("Failed to create context.\n");
@@ -6480 +6473 @@
     IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->stateBlock);
 
-    delete_opengl_contexts(iface, (IWineD3DSwapChain *) swapchain);
+    delete_opengl_contexts(iface, swapchain);
 
     if(pPresentationParameters->Windowed) {
@@ -6532 +6525 @@
     }
 
-    if((pPresentationParameters->Windowed && !swapchain->presentParms.Windowed) ||
-       (swapchain->presentParms.Windowed && !pPresentationParameters->Windowed) ||
-        DisplayModeChanged) {
-
+    if (!pPresentationParameters->Windowed != !swapchain->presentParms.Windowed
+            || DisplayModeChanged)
+    {
         IWineD3DDevice_SetDisplayMode(iface, 0, &mode);
 
-        if(swapchain->win_handle && !pPresentationParameters->Windowed) {
+        if (!pPresentationParameters->Windowed)
+        {
             if(swapchain->presentParms.Windowed) {
                 /* switch from windowed to fs */
@@ -6545 +6538 @@
             } else {
                 /* Fullscreen -> fullscreen mode change */
-                MoveWindow(swapchain->win_handle, 0, 0,
+                MoveWindow(swapchain->device_window, 0, 0,
                            pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight,
                            TRUE);
             }
-        } else if(swapchain->win_handle && !swapchain->presentParms.Windowed) {
+        }
+        else if (!swapchain->presentParms.Windowed)
+        {
             /* Fullscreen -> windowed switch */
             swapchain_restore_fullscreen_window(swapchain);
@@ -6606 +6601 @@
     }
 
-    hr = create_primary_opengl_context(iface, (IWineD3DSwapChain *) swapchain);
+    hr = create_primary_opengl_context(iface, swapchain);
     IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
 
@@ -6792 +6787 @@
     }
     return WINED3D_OK;
+}
+
+static HRESULT WINAPI IWineD3DDeviceImpl_GetSurfaceFromDC(IWineD3DDevice *iface, HDC dc, IWineD3DSurface **surface)
+{
+    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
+    IWineD3DResourceImpl *resource;
+
+    LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry)
+    {
+        WINED3DRESOURCETYPE type = IWineD3DResource_GetType((IWineD3DResource *)resource);
+        if (type == WINED3DRTYPE_SURFACE)
+        {
+            if (((IWineD3DSurfaceImpl *)resource)->hDC == dc)
+            {
+                TRACE("Found surface %p for dc %p.\n", resource, dc);
+                *surface = (IWineD3DSurface *)resource;
+                return WINED3D_OK;
+            }
+        }
+    }
+
+    return WINED3DERR_INVALIDCALL;
 }
 
@@ -6942 +6959 @@
     IWineD3DDeviceImpl_GetFrontBufferData,
     /*** object tracking ***/
-    IWineD3DDeviceImpl_EnumResources
+    IWineD3DDeviceImpl_EnumResources,
+    IWineD3DDeviceImpl_GetSurfaceFromDC,
+    IWineD3DDeviceImpl_AcquireFocusWindow,
+    IWineD3DDeviceImpl_ReleaseFocusWindow,
 };
 
@@ -6992 +7012 @@
 
     select_shader_mode(&adapter->gl_info, &device->ps_selected_mode, &device->vs_selected_mode);
-    device->shader_backend = select_shader_backend(adapter, device_type);
+    device->shader_backend = adapter->shader_backend;
 
     memset(&shader_caps, 0, sizeof(shader_caps));
-    device->shader_backend->shader_get_caps(device_type, &adapter->gl_info, &shader_caps);
+    device->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
     device->d3d_vshader_constantF = shader_caps.MaxVertexShaderConst;
     device->d3d_pshader_constantF = shader_caps.MaxPixelShaderConst;
@@ -7001 +7021 @@
 
     memset(&ffp_caps, 0, sizeof(ffp_caps));
-    fragment_pipeline = select_fragment_implementation(adapter, device_type);
+    fragment_pipeline = adapter->fragment_pipe;
     device->frag_pipe = fragment_pipeline;
-    fragment_pipeline->get_caps(device_type, &adapter->gl_info, &ffp_caps);
+    fragment_pipeline->get_caps(&adapter->gl_info, &ffp_caps);
     device->max_ffp_textures = ffp_caps.MaxSimultaneousTextures;
-    device->max_ffp_texture_stages = ffp_caps.MaxTextureBlendStages;
 
     hr = compile_state_table(device->StateTable, device->multistate_funcs, &adapter->gl_info,
@@ -7016 +7035 @@
     }
 
-    device->blitter = select_blit_implementation(adapter, device_type);
+    device->blitter = adapter->blitter;
 
     return WINED3D_OK;
@@ -7040 +7059 @@
 }
 
-void get_drawable_size_pbuffer(struct wined3d_context *context, UINT *width, UINT *height)
-{
-    IWineD3DDeviceImpl *device = ((IWineD3DSurfaceImpl *)context->current_rt)->resource.device;
-    /* The drawable size of a pbuffer render target is the current pbuffer size. */
-    *width = device->pbufferWidth;
-    *height = device->pbufferHeight;
-}
-
 void get_drawable_size_fbo(struct wined3d_context *context, UINT *width, UINT *height)
 {
@@ -7058 +7069 @@
 void get_drawable_size_backbuffer(struct wined3d_context *context, UINT *width, UINT *height)
 {
-    IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *)context->surface;
+    IWineD3DSwapChainImpl *swapchain = context->swapchain;
     /* The drawable size of a backbuffer / aux buffer offscreen target is the size of the
      * current context's drawable, which is the size of the back buffer of the swapchain
-     * the active context belongs to. The back buffer of the swapchain is stored as the
-     * surface the context belongs to. */
-    *width = surface->currentDesc.Width;
-    *height = surface->currentDesc.Height;
+     * the active context belongs to. */
+    *width = swapchain->presentParms.BackBufferWidth;
+    *height = swapchain->presentParms.BackBufferHeight;
 }