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

   1 /*
   2  * Copyright 2002 Lionel Ulmer
   3  * Copyright 2002-2005 Jason Edmeades
   4  * Copyright 2003-2004 Raphael Junqueira
   5  * Copyright 2004 Christian Costa
   6  * Copyright 2005 Oliver Stieber
   7  * Copyright 2006-2008 Stefan Dösinger for CodeWeavers
   8  * Copyright 2006-2008 Henri Verbeet
   9  * Copyright 2007 Andrew Riedi
  10  * Copyright 2009-2011 Henri Verbeet for CodeWeavers
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #include "config.h"
  28 #include <stdio.h>
  29 #ifdef HAVE_FLOAT_H
  30 # include <float.h>
  31 #endif
  32 #include "wined3d_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  35
  36 /* Define the default light parameters as specified by MSDN */
  37 const WINED3DLIGHT WINED3D_default_light = {
  38
  39     WINED3DLIGHT_DIRECTIONAL,   /* Type */
  40     { 1.0f, 1.0f, 1.0f, 0.0f }, /* Diffuse r,g,b,a */
  41     { 0.0f, 0.0f, 0.0f, 0.0f }, /* Specular r,g,b,a */
  42     { 0.0f, 0.0f, 0.0f, 0.0f }, /* Ambient r,g,b,a, */
  43     { 0.0f, 0.0f, 0.0f },       /* Position x,y,z */
  44     { 0.0f, 0.0f, 1.0f },       /* Direction x,y,z */
  45     0.0f,                       /* Range */
  46     0.0f,                       /* Falloff */
  47     0.0f, 0.0f, 0.0f,           /* Attenuation 0,1,2 */
  48     0.0f,                       /* Theta */
  49     0.0f                        /* Phi */
  50 };
  51
  52 /**********************************************************
  53  * Global variable / Constants follow
  54  **********************************************************/
  55 const float identity[] =
  56 {
  57     1.0f, 0.0f, 0.0f, 0.0f,
  58     0.0f, 1.0f, 0.0f, 0.0f,
  59     0.0f, 0.0f, 1.0f, 0.0f,
  60     0.0f, 0.0f, 0.0f, 1.0f,
  61 };  /* When needed for comparisons */
  62
  63 /* Note that except for WINED3DPT_POINTLIST and WINED3DPT_LINELIST these
  64  * actually have the same values in GL and D3D. */
  65 static GLenum gl_primitive_type_from_d3d(WINED3DPRIMITIVETYPE primitive_type)
  66 {
  67     switch(primitive_type)
  68     {
  69         case WINED3DPT_POINTLIST:
  70             return GL_POINTS;
  71
  72         case WINED3DPT_LINELIST:
  73             return GL_LINES;
  74
  75         case WINED3DPT_LINESTRIP:
  76             return GL_LINE_STRIP;
  77
  78         case WINED3DPT_TRIANGLELIST:
  79             return GL_TRIANGLES;
  80
  81         case WINED3DPT_TRIANGLESTRIP:
  82             return GL_TRIANGLE_STRIP;
  83
  84         case WINED3DPT_TRIANGLEFAN:
  85             return GL_TRIANGLE_FAN;
  86
  87         case WINED3DPT_LINELIST_ADJ:
  88             return GL_LINES_ADJACENCY_ARB;
  89
  90         case WINED3DPT_LINESTRIP_ADJ:
  91             return GL_LINE_STRIP_ADJACENCY_ARB;
  92
  93         case WINED3DPT_TRIANGLELIST_ADJ:
  94             return GL_TRIANGLES_ADJACENCY_ARB;
  95
  96         case WINED3DPT_TRIANGLESTRIP_ADJ:
  97             return GL_TRIANGLE_STRIP_ADJACENCY_ARB;
  98
  99         default:
 100             FIXME("Unhandled primitive type %s\n", debug_d3dprimitivetype(primitive_type));
 101             return GL_NONE;
 102     }
 103 }
 104
 105 static WINED3DPRIMITIVETYPE d3d_primitive_type_from_gl(GLenum primitive_type)
 106 {
 107     switch(primitive_type)
 108     {
 109         case GL_POINTS:
 110             return WINED3DPT_POINTLIST;
 111
 112         case GL_LINES:
 113             return WINED3DPT_LINELIST;
 114
 115         case GL_LINE_STRIP:
 116             return WINED3DPT_LINESTRIP;
 117
 118         case GL_TRIANGLES:
 119             return WINED3DPT_TRIANGLELIST;
 120
 121         case GL_TRIANGLE_STRIP:
 122             return WINED3DPT_TRIANGLESTRIP;
 123
 124         case GL_TRIANGLE_FAN:
 125             return WINED3DPT_TRIANGLEFAN;
 126
 127         case GL_LINES_ADJACENCY_ARB:
 128             return WINED3DPT_LINELIST_ADJ;
 129
 130         case GL_LINE_STRIP_ADJACENCY_ARB:
 131             return WINED3DPT_LINESTRIP_ADJ;
 132
 133         case GL_TRIANGLES_ADJACENCY_ARB:
 134             return WINED3DPT_TRIANGLELIST_ADJ;
 135
 136         case GL_TRIANGLE_STRIP_ADJACENCY_ARB:
 137             return WINED3DPT_TRIANGLESTRIP_ADJ;
 138
 139         default:
 140             FIXME("Unhandled primitive type %s\n", debug_d3dprimitivetype(primitive_type));
 141             return WINED3DPT_UNDEFINED;
 142     }
 143 }
 144
 145 static BOOL fixed_get_input(BYTE usage, BYTE usage_idx, unsigned int *regnum)
 146 {
 147     if ((usage == WINED3DDECLUSAGE_POSITION || usage == WINED3DDECLUSAGE_POSITIONT) && !usage_idx)
 148         *regnum = WINED3D_FFP_POSITION;
 149     else if (usage == WINED3DDECLUSAGE_BLENDWEIGHT && !usage_idx)
 150         *regnum = WINED3D_FFP_BLENDWEIGHT;
 151     else if (usage == WINED3DDECLUSAGE_BLENDINDICES && !usage_idx)
 152         *regnum = WINED3D_FFP_BLENDINDICES;
 153     else if (usage == WINED3DDECLUSAGE_NORMAL && !usage_idx)
 154         *regnum = WINED3D_FFP_NORMAL;
 155     else if (usage == WINED3DDECLUSAGE_PSIZE && !usage_idx)
 156         *regnum = WINED3D_FFP_PSIZE;
 157     else if (usage == WINED3DDECLUSAGE_COLOR && !usage_idx)
 158         *regnum = WINED3D_FFP_DIFFUSE;
 159     else if (usage == WINED3DDECLUSAGE_COLOR && usage_idx == 1)
 160         *regnum = WINED3D_FFP_SPECULAR;
 161     else if (usage == WINED3DDECLUSAGE_TEXCOORD && usage_idx < WINED3DDP_MAXTEXCOORD)
 162         *regnum = WINED3D_FFP_TEXCOORD0 + usage_idx;
 163     else
 164     {
 165         FIXME("Unsupported input stream [usage=%s, usage_idx=%u]\n", debug_d3ddeclusage(usage), usage_idx);
 166         *regnum = ~0U;
 167         return FALSE;
 168     }
 169
 170     return TRUE;
 171 }
 172
 173 /* Context activation is done by the caller. */
 174 void device_stream_info_from_declaration(struct wined3d_device *device,
 175         struct wined3d_stream_info *stream_info, BOOL *fixup)
 176 {
 177     const struct wined3d_state *state = &device->stateBlock->state;
 178     /* We need to deal with frequency data! */
 179     struct wined3d_vertex_declaration *declaration = state->vertex_declaration;
 180     BOOL use_vshader;
 181     unsigned int i;
 182
 183     stream_info->use_map = 0;
 184     stream_info->swizzle_map = 0;
 185
 186     /* Check for transformed vertices, disable vertex shader if present. */
 187     stream_info->position_transformed = declaration->position_transformed;
 188     use_vshader = state->vertex_shader && !declaration->position_transformed;
 189
 190     /* Translate the declaration into strided data. */
 191     for (i = 0; i < declaration->element_count; ++i)
 192     {
 193         const struct wined3d_vertex_declaration_element *element = &declaration->elements[i];
 194         const struct wined3d_stream_state *stream = &state->streams[element->input_slot];
 195         struct wined3d_buffer *buffer = stream->buffer;
 196         struct wined3d_bo_address data;
 197         BOOL stride_used;
 198         unsigned int idx;
 199         DWORD stride;
 200
 201         TRACE("%p Element %p (%u of %u)\n", declaration->elements,
 202                 element, i + 1, declaration->element_count);
 203
 204         if (!buffer) continue;
 205
 206         data.buffer_object = 0;
 207         data.addr = NULL;
 208
 209         stride = stream->stride;
 210         if (state->user_stream)
 211         {
 212             TRACE("Stream %u is UP, %p\n", element->input_slot, buffer);
 213             data.buffer_object = 0;
 214             data.addr = (BYTE *)buffer;
 215         }
 216         else
 217         {
 218             TRACE("Stream %u isn't UP, %p\n", element->input_slot, buffer);
 219             buffer_get_memory(buffer, &device->adapter->gl_info, &data);
 220
 221             /* Can't use vbo's if the base vertex index is negative. OpenGL doesn't accept negative offsets
 222              * (or rather offsets bigger than the vbo, because the pointer is unsigned), so use system memory
 223              * sources. In most sane cases the pointer - offset will still be > 0, otherwise it will wrap
 224              * around to some big value. Hope that with the indices, the driver wraps it back internally. If
 225              * not, drawStridedSlow is needed, including a vertex buffer path. */
 226             if (state->load_base_vertex_index < 0)
 227             {
 228                 WARN("load_base_vertex_index is < 0 (%d), not using VBOs.\n",
 229                         state->load_base_vertex_index);
 230                 data.buffer_object = 0;
 231                 data.addr = buffer_get_sysmem(buffer, &device->adapter->gl_info);
 232                 if ((UINT_PTR)data.addr < -state->load_base_vertex_index * stride)
 233                 {
 234                     FIXME("System memory vertex data load offset is negative!\n");
 235                 }
 236             }
 237
 238             if (fixup)
 239             {
 240                 if (data.buffer_object)
 241                     *fixup = TRUE;
 242                 else if (*fixup && !use_vshader
 243                         && (element->usage == WINED3DDECLUSAGE_COLOR
 244                         || element->usage == WINED3DDECLUSAGE_POSITIONT))
 245                 {
 246                     static BOOL warned = FALSE;
 247                     if (!warned)
 248                     {
 249                         /* This may be bad with the fixed function pipeline. */
 250                         FIXME("Missing vbo streams with unfixed colors or transformed position, expect problems\n");
 251                         warned = TRUE;
 252                     }
 253                 }
 254             }
 255         }
 256         data.addr += element->offset;
 257
 258         TRACE("offset %u input_slot %u usage_idx %d\n", element->offset, element->input_slot, element->usage_idx);
 259
 260         if (use_vshader)
 261         {
 262             if (element->output_slot == ~0U)
 263             {
 264                 /* TODO: Assuming vertexdeclarations are usually used with the
 265                  * same or a similar shader, it might be worth it to store the
 266                  * last used output slot and try that one first. */
 267                 stride_used = vshader_get_input(state->vertex_shader,
 268                         element->usage, element->usage_idx, &idx);
 269             }
 270             else
 271             {
 272                 idx = element->output_slot;
 273                 stride_used = TRUE;
 274             }
 275         }
 276         else
 277         {
 278             if (!element->ffp_valid)
 279             {
 280                 WARN("Skipping unsupported fixed function element of format %s and usage %s\n",
 281                         debug_d3dformat(element->format->id), debug_d3ddeclusage(element->usage));
 282                 stride_used = FALSE;
 283             }
 284             else
 285             {
 286                 stride_used = fixed_get_input(element->usage, element->usage_idx, &idx);
 287             }
 288         }
 289
 290         if (stride_used)
 291         {
 292             TRACE("Load %s array %u [usage %s, usage_idx %u, "
 293                     "input_slot %u, offset %u, stride %u, format %s, buffer_object %u]\n",
 294                     use_vshader ? "shader": "fixed function", idx,
 295                     debug_d3ddeclusage(element->usage), element->usage_idx, element->input_slot,
 296                     element->offset, stride, debug_d3dformat(element->format->id), data.buffer_object);
 297
 298             data.addr += stream->offset;
 299
 300             stream_info->elements[idx].format = element->format;
 301             stream_info->elements[idx].data = data;
 302             stream_info->elements[idx].stride = stride;
 303             stream_info->elements[idx].stream_idx = element->input_slot;
 304
 305             if (!device->adapter->gl_info.supported[ARB_VERTEX_ARRAY_BGRA]
 306                     && element->format->id == WINED3DFMT_B8G8R8A8_UNORM)
 307             {
 308                 stream_info->swizzle_map |= 1 << idx;
 309             }
 310             stream_info->use_map |= 1 << idx;
 311         }
 312     }
 313
 314     device->num_buffer_queries = 0;
 315     if (!state->user_stream)
 316     {
 317         WORD map = stream_info->use_map;
 318
 319         /* PreLoad all the vertex buffers. */
 320         for (i = 0; map; map >>= 1, ++i)
 321         {
 322             struct wined3d_stream_info_element *element;
 323             struct wined3d_buffer *buffer;
 324
 325             if (!(map & 1)) continue;
 326
 327             element = &stream_info->elements[i];
 328             buffer = state->streams[element->stream_idx].buffer;
 329             wined3d_buffer_preload(buffer);
 330
 331             /* If the preload dropped the buffer object, update the stream info. */
 332             if (buffer->buffer_object != element->data.buffer_object)
 333             {
 334                 element->data.buffer_object = 0;
 335                 element->data.addr = buffer_get_sysmem(buffer, &device->adapter->gl_info)
 336                         + (ptrdiff_t)element->data.addr;
 337             }
 338
 339             if (buffer->query)
 340                 device->buffer_queries[device->num_buffer_queries++] = buffer->query;
 341         }
 342     }
 343 }
 344
 345 static void stream_info_element_from_strided(const struct wined3d_gl_info *gl_info,
 346         const struct WineDirect3DStridedData *strided, struct wined3d_stream_info_element *e)
 347 {
 348     e->data.addr = strided->lpData;
 349     e->data.buffer_object = 0;
 350     e->format = wined3d_get_format(gl_info, strided->format);
 351     e->stride = strided->dwStride;
 352     e->stream_idx = 0;
 353 }
 354
 355 static void device_stream_info_from_strided(const struct wined3d_gl_info *gl_info,
 356         const struct WineDirect3DVertexStridedData *strided, struct wined3d_stream_info *stream_info)
 357 {
 358     unsigned int i;
 359
 360     memset(stream_info, 0, sizeof(*stream_info));
 361
 362     if (strided->position.lpData)
 363         stream_info_element_from_strided(gl_info, &strided->position, &stream_info->elements[WINED3D_FFP_POSITION]);
 364     if (strided->normal.lpData)
 365         stream_info_element_from_strided(gl_info, &strided->normal, &stream_info->elements[WINED3D_FFP_NORMAL]);
 366     if (strided->diffuse.lpData)
 367         stream_info_element_from_strided(gl_info, &strided->diffuse, &stream_info->elements[WINED3D_FFP_DIFFUSE]);
 368     if (strided->specular.lpData)
 369         stream_info_element_from_strided(gl_info, &strided->specular, &stream_info->elements[WINED3D_FFP_SPECULAR]);
 370
 371     for (i = 0; i < WINED3DDP_MAXTEXCOORD; ++i)
 372     {
 373         if (strided->texCoords[i].lpData)
 374             stream_info_element_from_strided(gl_info, &strided->texCoords[i],
 375                     &stream_info->elements[WINED3D_FFP_TEXCOORD0 + i]);
 376     }
 377
 378     stream_info->position_transformed = strided->position_transformed;
 379
 380     for (i = 0; i < sizeof(stream_info->elements) / sizeof(*stream_info->elements); ++i)
 381     {
 382         if (!stream_info->elements[i].format) continue;
 383
 384         if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
 385                 && stream_info->elements[i].format->id == WINED3DFMT_B8G8R8A8_UNORM)
 386         {
 387             stream_info->swizzle_map |= 1 << i;
 388         }
 389         stream_info->use_map |= 1 << i;
 390     }
 391 }
 392
 393 static void device_trace_strided_stream_info(const struct wined3d_stream_info *stream_info)
 394 {
 395     TRACE("Strided Data:\n");
 396     TRACE_STRIDED(stream_info, WINED3D_FFP_POSITION);
 397     TRACE_STRIDED(stream_info, WINED3D_FFP_BLENDWEIGHT);
 398     TRACE_STRIDED(stream_info, WINED3D_FFP_BLENDINDICES);
 399     TRACE_STRIDED(stream_info, WINED3D_FFP_NORMAL);
 400     TRACE_STRIDED(stream_info, WINED3D_FFP_PSIZE);
 401     TRACE_STRIDED(stream_info, WINED3D_FFP_DIFFUSE);
 402     TRACE_STRIDED(stream_info, WINED3D_FFP_SPECULAR);
 403     TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD0);
 404     TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD1);
 405     TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD2);
 406     TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD3);
 407     TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD4);
 408     TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD5);
 409     TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD6);
 410     TRACE_STRIDED(stream_info, WINED3D_FFP_TEXCOORD7);
 411 }
 412
 413 /* Context activation is done by the caller. */
 414 void device_update_stream_info(struct wined3d_device *device, const struct wined3d_gl_info *gl_info)
 415 {
 416     struct wined3d_stream_info *stream_info = &device->strided_streams;
 417     const struct wined3d_state *state = &device->stateBlock->state;
 418     BOOL fixup = FALSE;
 419
 420     if (device->up_strided)
 421     {
 422         /* Note: this is a ddraw fixed-function code path. */
 423         TRACE("=============================== Strided Input ================================\n");
 424         device_stream_info_from_strided(gl_info, device->up_strided, stream_info);
 425         if (TRACE_ON(d3d)) device_trace_strided_stream_info(stream_info);
 426     }
 427     else
 428     {
 429         TRACE("============================= Vertex Declaration =============================\n");
 430         device_stream_info_from_declaration(device, stream_info, &fixup);
 431     }
 432
 433     if (state->vertex_shader && !stream_info->position_transformed)
 434     {
 435         if (state->vertex_declaration->half_float_conv_needed && !fixup)
 436         {
 437             TRACE("Using drawStridedSlow with vertex shaders for FLOAT16 conversion.\n");
 438             device->useDrawStridedSlow = TRUE;
 439         }
 440         else
 441         {
 442             device->useDrawStridedSlow = FALSE;
 443         }
 444     }
 445     else
 446     {
 447         WORD slow_mask = (1 << WINED3D_FFP_PSIZE);
 448         slow_mask |= -!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
 449                 & ((1 << WINED3D_FFP_DIFFUSE) | (1 << WINED3D_FFP_SPECULAR));
 450
 451         if ((stream_info->position_transformed || (stream_info->use_map & slow_mask)) && !fixup)
 452         {
 453             device->useDrawStridedSlow = TRUE;
 454         }
 455         else
 456         {
 457             device->useDrawStridedSlow = FALSE;
 458         }
 459     }
 460 }
 461
 462 static void device_preload_texture(const struct wined3d_state *state, unsigned int idx)
 463 {
 464     struct wined3d_texture *texture;
 465     enum WINED3DSRGB srgb;
 466
 467     if (!(texture = state->textures[idx])) return;
 468     srgb = state->sampler_states[idx][WINED3DSAMP_SRGBTEXTURE] ? SRGB_SRGB : SRGB_RGB;
 469     texture->texture_ops->texture_preload(texture, srgb);
 470 }
 471
 472 void device_preload_textures(const struct wined3d_device *device)
 473 {
 474     const struct wined3d_state *state = &device->stateBlock->state;
 475     unsigned int i;
 476
 477     if (use_vs(state))
 478     {
 479         for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i)
 480         {
 481             if (state->vertex_shader->reg_maps.sampler_type[i])
 482                 device_preload_texture(state, MAX_FRAGMENT_SAMPLERS + i);
 483         }
 484     }
 485
 486     if (use_ps(state))
 487     {
 488         for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
 489         {
 490             if (state->pixel_shader->reg_maps.sampler_type[i])
 491                 device_preload_texture(state, i);
 492         }
 493     }
 494     else
 495     {
 496         WORD ffu_map = device->fixed_function_usage_map;
 497
 498         for (i = 0; ffu_map; ffu_map >>= 1, ++i)
 499         {
 500             if (ffu_map & 1)
 501                 device_preload_texture(state, i);
 502         }
 503     }
 504 }
 505
 506 BOOL device_context_add(struct wined3d_device *device, struct wined3d_context *context)
 507 {
 508     struct wined3d_context **new_array;
 509
 510     TRACE("Adding context %p.\n", context);
 511
 512     if (!device->contexts) new_array = HeapAlloc(GetProcessHeap(), 0, sizeof(*new_array));
 513     else new_array = HeapReAlloc(GetProcessHeap(), 0, device->contexts,
 514             sizeof(*new_array) * (device->context_count + 1));
 515
 516     if (!new_array)
 517     {
 518         ERR("Failed to grow the context array.\n");
 519         return FALSE;
 520     }
 521
 522     new_array[device->context_count++] = context;
 523     device->contexts = new_array;
 524     return TRUE;
 525 }
 526
 527 void device_context_remove(struct wined3d_device *device, struct wined3d_context *context)
 528 {
 529     struct wined3d_context **new_array;
 530     BOOL found = FALSE;
 531     UINT i;
 532
 533     TRACE("Removing context %p.\n", context);
 534
 535     for (i = 0; i < device->context_count; ++i)
 536     {
 537         if (device->contexts[i] == context)
 538         {
 539             found = TRUE;
 540             break;
 541         }
 542     }
 543
 544     if (!found)
 545     {
 546         ERR("Context %p doesn't exist in context array.\n", context);
 547         return;
 548     }
 549
 550     if (!--device->context_count)
 551     {
 552         HeapFree(GetProcessHeap(), 0, device->contexts);
 553         device->contexts = NULL;
 554         return;
 555     }
 556
 557     memmove(&device->contexts[i], &device->contexts[i + 1], (device->context_count - i) * sizeof(*device->contexts));
 558     new_array = HeapReAlloc(GetProcessHeap(), 0, device->contexts, device->context_count * sizeof(*device->contexts));
 559     if (!new_array)
 560     {
 561         ERR("Failed to shrink context array. Oh well.\n");
 562         return;
 563     }
 564
 565     device->contexts = new_array;
 566 }
 567
 568 /* Do not call while under the GL lock. */
 569 void device_switch_onscreen_ds(struct wined3d_device *device,
 570         struct wined3d_context *context, struct wined3d_surface *depth_stencil)
 571 {
 572     if (device->onscreen_depth_stencil)
 573     {
 574         surface_load_ds_location(device->onscreen_depth_stencil, context, SFLAG_DS_OFFSCREEN);
 575         surface_modify_ds_location(device->onscreen_depth_stencil, SFLAG_DS_OFFSCREEN,
 576                 device->onscreen_depth_stencil->ds_current_size.cx,
 577                 device->onscreen_depth_stencil->ds_current_size.cy);
 578         wined3d_surface_decref(device->onscreen_depth_stencil);
 579     }
 580     device->onscreen_depth_stencil = depth_stencil;
 581     wined3d_surface_incref(device->onscreen_depth_stencil);
 582 }
 583
 584 static BOOL is_full_clear(const struct wined3d_surface *target, const RECT *draw_rect, const RECT *clear_rect)
 585 {
 586     /* partial draw rect */
 587     if (draw_rect->left || draw_rect->top
 588             || draw_rect->right < target->resource.width
 589             || draw_rect->bottom < target->resource.height)
 590         return FALSE;
 591
 592     /* partial clear rect */
 593     if (clear_rect && (clear_rect->left > 0 || clear_rect->top > 0
 594             || clear_rect->right < target->resource.width
 595             || clear_rect->bottom < target->resource.height))
 596         return FALSE;
 597
 598     return TRUE;
 599 }
 600
 601 static void prepare_ds_clear(struct wined3d_surface *ds, struct wined3d_context *context,
 602         DWORD location, const RECT *draw_rect, UINT rect_count, const RECT *clear_rect)
 603 {
 604     RECT current_rect, r;
 605
 606     if (ds->flags & location)
 607         SetRect(&current_rect, 0, 0,
 608                 ds->ds_current_size.cx,
 609                 ds->ds_current_size.cy);
 610     else
 611         SetRectEmpty(&current_rect);
 612
 613     IntersectRect(&r, draw_rect, &current_rect);
 614     if (EqualRect(&r, draw_rect))
 615     {
 616         /* current_rect ⊇ draw_rect, modify only. */
 617         surface_modify_ds_location(ds, location, ds->ds_current_size.cx, ds->ds_current_size.cy);
 618         return;
 619     }
 620
 621     if (EqualRect(&r, &current_rect))
 622     {
 623         /* draw_rect ⊇ current_rect, test if we're doing a full clear. */
 624
 625         if (!clear_rect)
 626         {
 627             /* Full clear, modify only. */
 628             surface_modify_ds_location(ds, location, draw_rect->right, draw_rect->bottom);
 629             return;
 630         }
 631
 632         IntersectRect(&r, draw_rect, clear_rect);
 633         if (EqualRect(&r, draw_rect))
 634         {
 635             /* clear_rect ⊇ draw_rect, modify only. */
 636             surface_modify_ds_location(ds, location, draw_rect->right, draw_rect->bottom);
 637             return;
 638         }
 639     }
 640
 641     /* Full load. */
 642     surface_load_ds_location(ds, context, location);
 643     surface_modify_ds_location(ds, location, ds->ds_current_size.cx, ds->ds_current_size.cy);
 644 }
 645
 646 /* Do not call while under the GL lock. */
 647 HRESULT device_clear_render_targets(struct wined3d_device *device, UINT rt_count, const struct wined3d_fb_state *fb,
 648         UINT rect_count, const RECT *rects, const RECT *draw_rect, DWORD flags, const WINED3DCOLORVALUE *color,
 649         float depth, DWORD stencil)
 650 {
 651     const RECT *clear_rect = (rect_count > 0 && rects) ? (const RECT *)rects : NULL;
 652     struct wined3d_surface *target = rt_count ? fb->render_targets[0] : NULL;
 653     UINT drawable_width, drawable_height;
 654     struct wined3d_context *context;
 655     GLbitfield clear_mask = 0;
 656     BOOL render_offscreen;
 657     unsigned int i;
 658
 659     /* When we're clearing parts of the drawable, make sure that the target surface is well up to date in the
 660      * drawable. After the clear we'll mark the drawable up to date, so we have to make sure that this is true
 661      * for the cleared parts, and the untouched parts.
 662      *
 663      * If we're clearing the whole target there is no need to copy it into the drawable, it will be overwritten
 664      * anyway. If we're not clearing the color buffer we don't have to copy either since we're not going to set
 665      * the drawable up to date. We have to check all settings that limit the clear area though. Do not bother
 666      * checking all this if the dest surface is in the drawable anyway. */
 667     if (flags & WINED3DCLEAR_TARGET && !is_full_clear(target, draw_rect, clear_rect))
 668     {
 669         for (i = 0; i < rt_count; ++i)
 670         {
 671             struct wined3d_surface *rt = fb->render_targets[i];
 672             if (rt)
 673                 surface_load_location(rt, rt->draw_binding, NULL);
 674         }
 675     }
 676
 677     context = context_acquire(device, target);
 678     if (!context->valid)
 679     {
 680         context_release(context);
 681         WARN("Invalid context, skipping clear.\n");
 682         return WINED3D_OK;
 683     }
 684
 685     if (target)
 686     {
 687         render_offscreen = context->render_offscreen;
 688         target->get_drawable_size(context, &drawable_width, &drawable_height);
 689     }
 690     else
 691     {
 692         render_offscreen = TRUE;
 693         drawable_width = fb->depth_stencil->pow2Width;
 694         drawable_height = fb->depth_stencil->pow2Height;
 695     }
 696
 697     if (flags & WINED3DCLEAR_ZBUFFER)
 698     {
 699         DWORD location = render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
 700
 701         if (location == SFLAG_DS_ONSCREEN && fb->depth_stencil != device->onscreen_depth_stencil)
 702             device_switch_onscreen_ds(device, context, fb->depth_stencil);
 703         prepare_ds_clear(fb->depth_stencil, context, location, draw_rect, rect_count, clear_rect);
 704     }
 705
 706     if (!context_apply_clear_state(context, device, rt_count, fb))
 707     {
 708         context_release(context);
 709         WARN("Failed to apply clear state, skipping clear.\n");
 710         return WINED3D_OK;
 711     }
 712
 713     ENTER_GL();
 714
 715     /* Only set the values up once, as they are not changing. */
 716     if (flags & WINED3DCLEAR_STENCIL)
 717     {
 718         if (context->gl_info->supported[EXT_STENCIL_TWO_SIDE])
 719         {
 720             glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
 721             context_invalidate_state(context, STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE));
 722         }
 723         glStencilMask(~0U);
 724         context_invalidate_state(context, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
 725         glClearStencil(stencil);
 726         checkGLcall("glClearStencil");
 727         clear_mask = clear_mask | GL_STENCIL_BUFFER_BIT;
 728     }
 729
 730     if (flags & WINED3DCLEAR_ZBUFFER)
 731     {
 732         surface_modify_location(fb->depth_stencil, fb->depth_stencil->draw_binding, TRUE);
 733
 734         glDepthMask(GL_TRUE);
 735         context_invalidate_state(context, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
 736         glClearDepth(depth);
 737         checkGLcall("glClearDepth");
 738         clear_mask = clear_mask | GL_DEPTH_BUFFER_BIT;
 739     }
 740
 741     if (flags & WINED3DCLEAR_TARGET)
 742     {
 743         for (i = 0; i < rt_count; ++i)
 744         {
 745             struct wined3d_surface *rt = fb->render_targets[i];
 746
 747             if (rt)
 748                 surface_modify_location(rt, rt->draw_binding, TRUE);
 749         }
 750
 751         glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 752         context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
 753         context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
 754         context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
 755         context_invalidate_state(context, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
 756         glClearColor(color->r, color->g, color->b, color->a);
 757         checkGLcall("glClearColor");
 758         clear_mask = clear_mask | GL_COLOR_BUFFER_BIT;
 759     }
 760
 761     if (!clear_rect)
 762     {
 763         if (render_offscreen)
 764         {
 765             glScissor(draw_rect->left, draw_rect->top,
 766                     draw_rect->right - draw_rect->left, draw_rect->bottom - draw_rect->top);
 767         }
 768         else
 769         {
 770             glScissor(draw_rect->left, drawable_height - draw_rect->bottom,
 771                         draw_rect->right - draw_rect->left, draw_rect->bottom - draw_rect->top);
 772         }
 773         checkGLcall("glScissor");
 774         glClear(clear_mask);
 775         checkGLcall("glClear");
 776     }
 777     else
 778     {
 779         RECT current_rect;
 780
 781         /* Now process each rect in turn. */
 782         for (i = 0; i < rect_count; ++i)
 783         {
 784             /* Note that GL uses lower left, width/height. */
 785             IntersectRect(&current_rect, draw_rect, &clear_rect[i]);
 786
 787             TRACE("clear_rect[%u] %s, current_rect %s.\n", i,
 788                     wine_dbgstr_rect(&clear_rect[i]),
 789                     wine_dbgstr_rect(&current_rect));
 790
 791             /* Tests show that rectangles where x1 > x2 or y1 > y2 are ignored silently.
 792              * The rectangle is not cleared, no error is returned, but further rectangles are
 793              * still cleared if they are valid. */
 794             if (current_rect.left > current_rect.right || current_rect.top > current_rect.bottom)
 795             {
 796                 TRACE("Rectangle with negative dimensions, ignoring.\n");
 797                 continue;
 798             }
 799
 800             if (render_offscreen)
 801             {
 802                 glScissor(current_rect.left, current_rect.top,
 803                         current_rect.right - current_rect.left, current_rect.bottom - current_rect.top);
 804             }
 805             else
 806             {
 807                 glScissor(current_rect.left, drawable_height - current_rect.bottom,
 808                           current_rect.right - current_rect.left, current_rect.bottom - current_rect.top);
 809             }
 810             checkGLcall("glScissor");
 811
 812             glClear(clear_mask);
 813             checkGLcall("glClear");
 814         }
 815     }
 816
 817     LEAVE_GL();
 818
 819     if (wined3d_settings.strict_draw_ordering || (flags & WINED3DCLEAR_TARGET
 820             && target->container.type == WINED3D_CONTAINER_SWAPCHAIN
 821             && target->container.u.swapchain->front_buffer == target))
 822         wglFlush(); /* Flush to ensure ordering across contexts. */
 823
 824     context_release(context);
 825
 826     return WINED3D_OK;
 827 }
 828
 829 ULONG CDECL wined3d_device_incref(struct wined3d_device *device)
 830 {
 831     ULONG refcount = InterlockedIncrement(&device->ref);
 832
 833     TRACE("%p increasing refcount to %u.\n", device, refcount);
 834
 835     return refcount;
 836 }
 837
 838 ULONG CDECL wined3d_device_decref(struct wined3d_device *device)
 839 {
 840     ULONG refcount = InterlockedDecrement(&device->ref);
 841
 842     TRACE("%p decreasing refcount to %u.\n", device, refcount);
 843
 844     if (!refcount)
 845     {
 846         UINT i;
 847
 848         for (i = 0; i < sizeof(device->multistate_funcs) / sizeof(device->multistate_funcs[0]); ++i)
 849         {
 850             HeapFree(GetProcessHeap(), 0, device->multistate_funcs[i]);
 851             device->multistate_funcs[i] = NULL;
 852         }
 853
 854         if (!list_empty(&device->resources))
 855         {
 856             struct wined3d_resource *resource;
 857
 858             FIXME("Device released with resources still bound, acceptable but unexpected.\n");
 859
 860             LIST_FOR_EACH_ENTRY(resource, &device->resources, struct wined3d_resource, resource_list_entry)
 861             {
 862                 FIXME("Leftover resource %p with type %s (%#x).\n",
 863                         resource, debug_d3dresourcetype(resource->resourceType), resource->resourceType);
 864             }
 865         }
 866
 867         if (device->contexts)
 868             ERR("Context array not freed!\n");
 869         if (device->hardwareCursor)
 870             DestroyCursor(device->hardwareCursor);
 871         device->hardwareCursor = 0;
 872
 873         wined3d_decref(device->wined3d);
 874         device->wined3d = NULL;
 875         HeapFree(GetProcessHeap(), 0, device);
 876         TRACE("Freed device %p.\n", device);
 877     }
 878
 879     return refcount;
 880 }
 881
 882 UINT CDECL wined3d_device_get_swapchain_count(const struct wined3d_device *device)
 883 {
 884     TRACE("device %p.\n", device);
 885
 886     return device->swapchain_count;
 887 }
 888
 889 HRESULT CDECL wined3d_device_get_swapchain(const struct wined3d_device *device,
 890         UINT swapchain_idx, struct wined3d_swapchain **swapchain)
 891 {
 892     TRACE("device %p, swapchain_idx %u, swapchain %p.\n",
 893             device, swapchain_idx, swapchain);
 894
 895     if (swapchain_idx >= device->swapchain_count)
 896     {
 897         WARN("swapchain_idx %u >= swapchain_count %u.\n",
 898                 swapchain_idx, device->swapchain_count);
 899         *swapchain = NULL;
 900
 901         return WINED3DERR_INVALIDCALL;
 902     }
 903
 904     *swapchain = device->swapchains[swapchain_idx];
 905     wined3d_swapchain_incref(*swapchain);
 906     TRACE("Returning %p.\n", *swapchain);
 907
 908     return WINED3D_OK;
 909 }
 910
 911 static void device_load_logo(struct wined3d_device *device, const char *filename)
 912 {
 913     HBITMAP hbm;
 914     BITMAP bm;
 915     HRESULT hr;
 916     HDC dcb = NULL, dcs = NULL;
 917     WINEDDCOLORKEY colorkey;
 918
 919     hbm = LoadImageA(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
 920     if(hbm)
 921     {
 922         GetObjectA(hbm, sizeof(BITMAP), &bm);
 923         dcb = CreateCompatibleDC(NULL);
 924         if(!dcb) goto out;
 925         SelectObject(dcb, hbm);
 926     }
 927     else
 928     {
 929         /* Create a 32x32 white surface to indicate that wined3d is used, but the specified image
 930          * couldn't be loaded
 931          */
 932         memset(&bm, 0, sizeof(bm));
 933         bm.bmWidth = 32;
 934         bm.bmHeight = 32;
 935     }
 936
 937     hr = wined3d_surface_create(device, bm.bmWidth, bm.bmHeight, WINED3DFMT_B5G6R5_UNORM, TRUE,
 938             FALSE, 0, 0, WINED3DPOOL_DEFAULT, WINED3DMULTISAMPLE_NONE, 0, SURFACE_OPENGL, NULL,
 939             &wined3d_null_parent_ops, &device->logo_surface);
 940     if (FAILED(hr))
 941     {
 942         ERR("Wine logo requested, but failed to create surface, hr %#x.\n", hr);
 943         goto out;
 944     }
 945
 946     if (dcb)
 947     {
 948         if (FAILED(hr = wined3d_surface_getdc(device->logo_surface, &dcs)))
 949             goto out;
 950         BitBlt(dcs, 0, 0, bm.bmWidth, bm.bmHeight, dcb, 0, 0, SRCCOPY);
 951         wined3d_surface_releasedc(device->logo_surface, dcs);
 952
 953         colorkey.dwColorSpaceLowValue = 0;
 954         colorkey.dwColorSpaceHighValue = 0;
 955         wined3d_surface_set_color_key(device->logo_surface, WINEDDCKEY_SRCBLT, &colorkey);
 956     }
 957     else
 958     {
 959         const WINED3DCOLORVALUE c = {1.0f, 1.0f, 1.0f, 1.0f};
 960         /* Fill the surface with a white color to show that wined3d is there */
 961         wined3d_device_color_fill(device, device->logo_surface, NULL, &c);
 962     }
 963
 964 out:
 965     if (dcb) DeleteDC(dcb);
 966     if (hbm) DeleteObject(hbm);
 967 }
 968
 969 /* Context activation is done by the caller. */
 970 static void create_dummy_textures(struct wined3d_device *device, struct wined3d_context *context)
 971 {
 972     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 973     unsigned int i, j, count;
 974     /* Under DirectX you can sample even if no texture is bound, whereas
 975      * OpenGL will only allow that when a valid texture is bound.
 976      * We emulate this by creating dummy textures and binding them
 977      * to each texture stage when the currently set D3D texture is NULL. */
 978     ENTER_GL();
 979
 980     if (gl_info->supported[APPLE_CLIENT_STORAGE])
 981     {
 982         /* The dummy texture does not have client storage backing */
 983         glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
 984         checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
 985     }
 986
 987     count = min(MAX_COMBINED_SAMPLERS, gl_info->limits.combined_samplers);
 988     for (i = 0; i < count; ++i)
 989     {
 990         DWORD color = 0x000000ff;
 991
 992         /* Make appropriate texture active */
 993         context_active_texture(context, gl_info, i);
 994
 995         glGenTextures(1, &device->dummy_texture_2d[i]);
 996         checkGLcall("glGenTextures");
 997         TRACE("Dummy 2D texture %u given name %u.\n", i, device->dummy_texture_2d[i]);
 998
 999         glBindTexture(GL_TEXTURE_2D, device->dummy_texture_2d[i]);
1000         checkGLcall("glBindTexture");
1001
1002         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color);
1003         checkGLcall("glTexImage2D");
1004
1005         if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
1006         {
1007             glGenTextures(1, &device->dummy_texture_rect[i]);
1008             checkGLcall("glGenTextures");
1009             TRACE("Dummy rectangle texture %u given name %u.\n", i, device->dummy_texture_rect[i]);
1010
1011             glBindTexture(GL_TEXTURE_RECTANGLE_ARB, device->dummy_texture_rect[i]);
1012             checkGLcall("glBindTexture");
1013
1014             glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, 1, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color);
1015             checkGLcall("glTexImage2D");
1016         }
1017
1018         if (gl_info->supported[EXT_TEXTURE3D])
1019         {
1020             glGenTextures(1, &device->dummy_texture_3d[i]);
1021             checkGLcall("glGenTextures");
1022             TRACE("Dummy 3D texture %u given name %u.\n", i, device->dummy_texture_3d[i]);
1023
1024             glBindTexture(GL_TEXTURE_3D, device->dummy_texture_3d[i]);
1025             checkGLcall("glBindTexture");
1026
1027             GL_EXTCALL(glTexImage3DEXT(GL_TEXTURE_3D, 0, GL_RGBA8, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color));
1028             checkGLcall("glTexImage3D");
1029         }
1030
1031         if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
1032         {
1033             glGenTextures(1, &device->dummy_texture_cube[i]);
1034             checkGLcall("glGenTextures");
1035             TRACE("Dummy cube texture %u given name %u.\n", i, device->dummy_texture_cube[i]);
1036
1037             glBindTexture(GL_TEXTURE_CUBE_MAP, device->dummy_texture_cube[i]);
1038             checkGLcall("glBindTexture");
1039
1040             for (j = GL_TEXTURE_CUBE_MAP_POSITIVE_X; j <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; ++j)
1041             {
1042                 glTexImage2D(j, 0, GL_RGBA8, 1, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, &color);
1043                 checkGLcall("glTexImage2D");
1044             }
1045         }
1046     }
1047
1048     if (gl_info->supported[APPLE_CLIENT_STORAGE])
1049     {
1050         /* Reenable because if supported it is enabled by default */
1051         glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
1052         checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
1053     }
1054
1055     LEAVE_GL();
1056 }
1057
1058 /* Context activation is done by the caller. */
1059 static void destroy_dummy_textures(struct wined3d_device *device, const struct wined3d_gl_info *gl_info)
1060 {
1061     unsigned int count = min(MAX_COMBINED_SAMPLERS, gl_info->limits.combined_samplers);
1062
1063     ENTER_GL();
1064     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
1065     {
1066         glDeleteTextures(count, device->dummy_texture_cube);
1067         checkGLcall("glDeleteTextures(count, device->dummy_texture_cube)");
1068     }
1069
1070     if (gl_info->supported[EXT_TEXTURE3D])
1071     {
1072         glDeleteTextures(count, device->dummy_texture_3d);
1073         checkGLcall("glDeleteTextures(count, device->dummy_texture_3d)");
1074     }
1075
1076     if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
1077     {
1078         glDeleteTextures(count, device->dummy_texture_rect);
1079         checkGLcall("glDeleteTextures(count, device->dummy_texture_rect)");
1080     }
1081
1082     glDeleteTextures(count, device->dummy_texture_2d);
1083     checkGLcall("glDeleteTextures(count, device->dummy_texture_2d)");
1084     LEAVE_GL();
1085
1086     memset(device->dummy_texture_cube, 0, gl_info->limits.textures * sizeof(*device->dummy_texture_cube));
1087     memset(device->dummy_texture_3d, 0, gl_info->limits.textures * sizeof(*device->dummy_texture_3d));
1088     memset(device->dummy_texture_rect, 0, gl_info->limits.textures * sizeof(*device->dummy_texture_rect));
1089     memset(device->dummy_texture_2d, 0, gl_info->limits.textures * sizeof(*device->dummy_texture_2d));
1090 }
1091
1092 static LONG fullscreen_style(LONG style)
1093 {
1094     /* Make sure the window is managed, otherwise we won't get keyboard input. */
1095     style |= WS_POPUP | WS_SYSMENU;
1096     style &= ~(WS_CAPTION | WS_THICKFRAME);
1097
1098     return style;
1099 }
1100
1101 static LONG fullscreen_exstyle(LONG exstyle)
1102 {
1103     /* Filter out window decorations. */
1104     exstyle &= ~(WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE);
1105
1106     return exstyle;
1107 }
1108
1109 void CDECL wined3d_device_setup_fullscreen_window(struct wined3d_device *device, HWND window, UINT w, UINT h)
1110 {
1111     BOOL filter_messages;
1112     LONG style, exstyle;
1113
1114     TRACE("Setting up window %p for fullscreen mode.\n", window);
1115
1116     if (device->style || device->exStyle)
1117     {
1118         ERR("Changing the window style for window %p, but another style (%08x, %08x) is already stored.\n",
1119                 window, device->style, device->exStyle);
1120     }
1121
1122     device->style = GetWindowLongW(window, GWL_STYLE);
1123     device->exStyle = GetWindowLongW(window, GWL_EXSTYLE);
1124
1125     style = fullscreen_style(device->style);
1126     exstyle = fullscreen_exstyle(device->exStyle);
1127
1128     TRACE("Old style was %08x, %08x, setting to %08x, %08x.\n",
1129             device->style, device->exStyle, style, exstyle);
1130
1131     filter_messages = device->filter_messages;
1132     device->filter_messages = TRUE;
1133
1134     SetWindowLongW(window, GWL_STYLE, style);
1135     SetWindowLongW(window, GWL_EXSTYLE, exstyle);
1136     SetWindowPos(window, HWND_TOP, 0, 0, w, h, SWP_FRAMECHANGED | SWP_SHOWWINDOW | SWP_NOACTIVATE);
1137
1138     device->filter_messages = filter_messages;
1139 }
1140
1141 void CDECL wined3d_device_restore_fullscreen_window(struct wined3d_device *device, HWND window)
1142 {
1143     BOOL filter_messages;
1144     LONG style, exstyle;
1145
1146     if (!device->style && !device->exStyle) return;
1147
1148     TRACE("Restoring window style of window %p to %08x, %08x.\n",
1149             window, device->style, device->exStyle);
1150
1151     style = GetWindowLongW(window, GWL_STYLE);
1152     exstyle = GetWindowLongW(window, GWL_EXSTYLE);
1153
1154     filter_messages = device->filter_messages;
1155     device->filter_messages = TRUE;
1156
1157     /* Only restore the style if the application didn't modify it during the
1158      * fullscreen phase. Some applications change it before calling Reset()
1159      * when switching between windowed and fullscreen modes (HL2), some
1160      * depend on the original style (Eve Online). */
1161     if (style == fullscreen_style(device->style) && exstyle == fullscreen_exstyle(device->exStyle))
1162     {
1163         SetWindowLongW(window, GWL_STYLE, device->style);
1164         SetWindowLongW(window, GWL_EXSTYLE, device->exStyle);
1165     }
1166     SetWindowPos(window, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
1167
1168     device->filter_messages = filter_messages;
1169
1170     /* Delete the old values. */
1171     device->style = 0;
1172     device->exStyle = 0;
1173 }
1174
1175 HRESULT CDECL wined3d_device_acquire_focus_window(struct wined3d_device *device, HWND window)
1176 {
1177     TRACE("device %p, window %p.\n", device, window);
1178
1179     if (!wined3d_register_window(window, device))
1180     {
1181         ERR("Failed to register window %p.\n", window);
1182         return E_FAIL;
1183     }
1184
1185     device->focus_window = window;
1186     SetWindowPos(window, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
1187
1188     return WINED3D_OK;
1189 }
1190
1191 void CDECL wined3d_device_release_focus_window(struct wined3d_device *device)
1192 {
1193     TRACE("device %p.\n", device);
1194
1195     if (device->focus_window) wined3d_unregister_window(device->focus_window);
1196     device->focus_window = NULL;
1197 }
1198
1199 HRESULT CDECL wined3d_device_init_3d(struct wined3d_device *device,
1200         WINED3DPRESENT_PARAMETERS *present_parameters)
1201 {
1202     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1203     struct wined3d_swapchain *swapchain = NULL;
1204     struct wined3d_context *context;
1205     HRESULT hr;
1206     DWORD state;
1207     unsigned int i;
1208
1209     TRACE("device %p, present_parameters %p.\n", device, present_parameters);
1210
1211     if (device->d3d_initialized)
1212         return WINED3DERR_INVALIDCALL;
1213     if (!device->adapter->opengl)
1214         return WINED3DERR_INVALIDCALL;
1215
1216     TRACE("Creating stateblock.\n");
1217     hr = wined3d_stateblock_create(device, WINED3DSBT_INIT, &device->stateBlock);
1218     if (FAILED(hr))
1219     {
1220         WARN("Failed to create stateblock\n");
1221         goto err_out;
1222     }
1223
1224     TRACE("Created stateblock %p.\n", device->stateBlock);
1225     device->updateStateBlock = device->stateBlock;
1226     wined3d_stateblock_incref(device->updateStateBlock);
1227
1228     device->valid_rt_mask = 0;
1229     for (i = 0; i < gl_info->limits.buffers; ++i)
1230         device->valid_rt_mask |= (1 << i);
1231     device->fb.render_targets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1232             sizeof(*device->fb.render_targets) * gl_info->limits.buffers);
1233
1234     device->palette_count = 1;
1235     device->palettes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PALETTEENTRY*));
1236     if (!device->palettes || !device->fb.render_targets)
1237     {
1238         ERR("Out of memory!\n");
1239         hr = E_OUTOFMEMORY;
1240         goto err_out;
1241     }
1242
1243     device->palettes[0] = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
1244     if (!device->palettes[0])
1245     {
1246         ERR("Out of memory!\n");
1247         hr = E_OUTOFMEMORY;
1248         goto err_out;
1249     }
1250
1251     for (i = 0; i < 256; ++i)
1252     {
1253         device->palettes[0][i].peRed = 0xff;
1254         device->palettes[0][i].peGreen = 0xff;
1255         device->palettes[0][i].peBlue = 0xff;
1256         device->palettes[0][i].peFlags = 0xff;
1257     }
1258     device->currentPalette = 0;
1259
1260     /* Initialize the texture unit mapping to a 1:1 mapping */
1261     for (state = 0; state < MAX_COMBINED_SAMPLERS; ++state)
1262     {
1263         if (state < gl_info->limits.fragment_samplers)
1264         {
1265             device->texUnitMap[state] = state;
1266             device->rev_tex_unit_map[state] = state;
1267         }
1268         else
1269         {
1270             device->texUnitMap[state] = WINED3D_UNMAPPED_STAGE;
1271             device->rev_tex_unit_map[state] = WINED3D_UNMAPPED_STAGE;
1272         }
1273     }
1274
1275     /* Setup the implicit swapchain. This also initializes a context. */
1276     TRACE("Creating implicit swapchain\n");
1277     hr = device->device_parent->ops->create_swapchain(device->device_parent,
1278             present_parameters, &swapchain);
1279     if (FAILED(hr))
1280     {
1281         WARN("Failed to create implicit swapchain\n");
1282         goto err_out;
1283     }
1284
1285     device->swapchain_count = 1;
1286     device->swapchains = HeapAlloc(GetProcessHeap(), 0, device->swapchain_count * sizeof(*device->swapchains));
1287     if (!device->swapchains)
1288     {
1289         ERR("Out of memory!\n");
1290         goto err_out;
1291     }
1292     device->swapchains[0] = swapchain;
1293
1294     if (swapchain->back_buffers && swapchain->back_buffers[0])
1295     {
1296         TRACE("Setting rendertarget to %p.\n", swapchain->back_buffers);
1297         device->fb.render_targets[0] = swapchain->back_buffers[0];
1298     }
1299     else
1300     {
1301         TRACE("Setting rendertarget to %p.\n", swapchain->front_buffer);
1302         device->fb.render_targets[0] = swapchain->front_buffer;
1303     }
1304     wined3d_surface_incref(device->fb.render_targets[0]);
1305
1306     /* Depth Stencil support */
1307     device->fb.depth_stencil = device->auto_depth_stencil;
1308     if (device->fb.depth_stencil)
1309         wined3d_surface_incref(device->fb.depth_stencil);
1310
1311     hr = device->shader_backend->shader_alloc_private(device);
1312     if (FAILED(hr))
1313     {
1314         TRACE("Shader private data couldn't be allocated\n");
1315         goto err_out;
1316     }
1317     hr = device->frag_pipe->alloc_private(device);
1318     if (FAILED(hr))
1319     {
1320         TRACE("Fragment pipeline private data couldn't be allocated\n");
1321         goto err_out;
1322     }
1323     hr = device->blitter->alloc_private(device);
1324     if (FAILED(hr))
1325     {
1326         TRACE("Blitter private data couldn't be allocated\n");
1327         goto err_out;
1328     }
1329
1330     /* Set up some starting GL setup */
1331
1332     /* Setup all the devices defaults */
1333     stateblock_init_default_state(device->stateBlock);
1334
1335     context = context_acquire(device, swapchain->front_buffer);
1336
1337     create_dummy_textures(device, context);
1338
1339     ENTER_GL();
1340
1341     /* Initialize the current view state */
1342     device->view_ident = 1;
1343     device->contexts[0]->last_was_rhw = 0;
1344
1345     switch (wined3d_settings.offscreen_rendering_mode)
1346     {
1347         case ORM_FBO:
1348             device->offscreenBuffer = GL_COLOR_ATTACHMENT0;
1349             break;
1350
1351         case ORM_BACKBUFFER:
1352         {
1353             if (context_get_current()->aux_buffers > 0)
1354             {
1355                 TRACE("Using auxiliary buffer for offscreen rendering\n");
1356                 device->offscreenBuffer = GL_AUX0;
1357             }
1358             else
1359             {
1360                 TRACE("Using back buffer for offscreen rendering\n");
1361                 device->offscreenBuffer = GL_BACK;
1362             }
1363         }
1364     }
1365
1366     TRACE("All defaults now set up, leaving 3D init.\n");
1367     LEAVE_GL();
1368
1369     context_release(context);
1370
1371     /* Clear the screen */
1372     wined3d_device_clear(device, 0, NULL, WINED3DCLEAR_TARGET
1373             | (present_parameters->EnableAutoDepthStencil ? WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL : 0),
1374             0x00, 1.0f, 0);
1375
1376     device->d3d_initialized = TRUE;
1377
1378     if (wined3d_settings.logo)
1379         device_load_logo(device, wined3d_settings.logo);
1380     device->highest_dirty_ps_const = 0;
1381     device->highest_dirty_vs_const = 0;
1382     return WINED3D_OK;
1383
1384 err_out:
1385     HeapFree(GetProcessHeap(), 0, device->fb.render_targets);
1386     HeapFree(GetProcessHeap(), 0, device->swapchains);
1387     device->swapchain_count = 0;
1388     if (device->palettes)
1389     {
1390         HeapFree(GetProcessHeap(), 0, device->palettes[0]);
1391         HeapFree(GetProcessHeap(), 0, device->palettes);
1392     }
1393     device->palette_count = 0;
1394     if (swapchain)
1395         wined3d_swapchain_decref(swapchain);
1396     if (device->stateBlock)
1397     {
1398         wined3d_stateblock_decref(device->stateBlock);
1399         device->stateBlock = NULL;
1400     }
1401     if (device->blit_priv)
1402         device->blitter->free_private(device);
1403     if (device->fragment_priv)
1404         device->frag_pipe->free_private(device);
1405     if (device->shader_priv)
1406         device->shader_backend->shader_free_private(device);
1407
1408     return hr;
1409 }
1410
1411 HRESULT CDECL wined3d_device_init_gdi(struct wined3d_device *device,
1412         WINED3DPRESENT_PARAMETERS *present_parameters)
1413 {
1414     struct wined3d_swapchain *swapchain = NULL;
1415     HRESULT hr;
1416
1417     TRACE("device %p, present_parameters %p.\n", device, present_parameters);
1418
1419     /* Setup the implicit swapchain */
1420     TRACE("Creating implicit swapchain\n");
1421     hr = device->device_parent->ops->create_swapchain(device->device_parent,
1422             present_parameters, &swapchain);
1423     if (FAILED(hr))
1424     {
1425         WARN("Failed to create implicit swapchain\n");
1426         goto err_out;
1427     }
1428
1429     device->swapchain_count = 1;
1430     device->swapchains = HeapAlloc(GetProcessHeap(), 0, device->swapchain_count * sizeof(*device->swapchains));
1431     if (!device->swapchains)
1432     {
1433         ERR("Out of memory!\n");
1434         goto err_out;
1435     }
1436     device->swapchains[0] = swapchain;
1437     return WINED3D_OK;
1438
1439 err_out:
1440     wined3d_swapchain_decref(swapchain);
1441     return hr;
1442 }
1443
1444 HRESULT CDECL wined3d_device_uninit_3d(struct wined3d_device *device)
1445 {
1446     struct wined3d_resource *resource, *cursor;
1447     const struct wined3d_gl_info *gl_info;
1448     struct wined3d_context *context;
1449     struct wined3d_surface *surface;
1450     UINT i;
1451
1452     TRACE("device %p.\n", device);
1453
1454     if (!device->d3d_initialized)
1455         return WINED3DERR_INVALIDCALL;
1456
1457     /* Force making the context current again, to verify it is still valid
1458      * (workaround for broken drivers) */
1459     context_set_current(NULL);
1460     /* I don't think that the interface guarantees that the device is destroyed from the same thread
1461      * it was created. Thus make sure a context is active for the glDelete* calls
1462      */
1463     context = context_acquire(device, NULL);
1464     gl_info = context->gl_info;
1465
1466     if (device->logo_surface)
1467         wined3d_surface_decref(device->logo_surface);
1468
1469     /* Unload resources */
1470     LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
1471     {
1472         TRACE("Unloading resource %p.\n", resource);
1473
1474         resource->resource_ops->resource_unload(resource);
1475     }
1476
1477     TRACE("Deleting high order patches\n");
1478     for(i = 0; i < PATCHMAP_SIZE; i++) {
1479         struct list *e1, *e2;
1480         struct WineD3DRectPatch *patch;
1481         LIST_FOR_EACH_SAFE(e1, e2, &device->patches[i])
1482         {
1483             patch = LIST_ENTRY(e1, struct WineD3DRectPatch, entry);
1484             wined3d_device_delete_patch(device, patch->Handle);
1485         }
1486     }
1487
1488     /* Delete the mouse cursor texture */
1489     if (device->cursorTexture)
1490     {
1491         ENTER_GL();
1492         glDeleteTextures(1, &device->cursorTexture);
1493         LEAVE_GL();
1494         device->cursorTexture = 0;
1495     }
1496
1497     /* Destroy the depth blt resources, they will be invalid after the reset. Also free shader
1498      * private data, it might contain opengl pointers
1499      */
1500     if (device->depth_blt_texture)
1501     {
1502         ENTER_GL();
1503         glDeleteTextures(1, &device->depth_blt_texture);
1504         LEAVE_GL();
1505         device->depth_blt_texture = 0;
1506     }
1507
1508     /* Release the update stateblock */
1509     if (wined3d_stateblock_decref(device->updateStateBlock))
1510     {
1511         if (device->updateStateBlock != device->stateBlock)
1512             FIXME("Something's still holding the update stateblock.\n");
1513     }
1514     device->updateStateBlock = NULL;
1515
1516     {
1517         struct wined3d_stateblock *stateblock = device->stateBlock;
1518         device->stateBlock = NULL;
1519
1520         /* Release the stateblock */
1521         if (wined3d_stateblock_decref(stateblock))
1522             FIXME("Something's still holding the stateblock.\n");
1523     }
1524
1525     /* Destroy the shader backend. Note that this has to happen after all shaders are destroyed. */
1526     device->blitter->free_private(device);
1527     device->frag_pipe->free_private(device);
1528     device->shader_backend->shader_free_private(device);
1529
1530     /* Release the buffers (with sanity checks)*/
1531     if (device->onscreen_depth_stencil)
1532     {
1533         surface = device->onscreen_depth_stencil;
1534         device->onscreen_depth_stencil = NULL;
1535         wined3d_surface_decref(surface);
1536     }
1537
1538     if (device->fb.depth_stencil)
1539     {
1540         surface = device->fb.depth_stencil;
1541
1542         TRACE("Releasing depth/stencil buffer %p.\n", surface);
1543
1544         device->fb.depth_stencil = NULL;
1545         if (wined3d_surface_decref(surface)
1546                 && surface != device->auto_depth_stencil)
1547             ERR("Something is still holding a reference to depth/stencil buffer %p.\n", surface);
1548     }
1549
1550     if (device->auto_depth_stencil)
1551     {
1552         surface = device->auto_depth_stencil;
1553         device->auto_depth_stencil = NULL;
1554         if (wined3d_surface_decref(surface))
1555             FIXME("Something's still holding the auto depth stencil buffer (%p).\n", surface);
1556     }
1557
1558     for (i = 1; i < gl_info->limits.buffers; ++i)
1559     {
1560         wined3d_device_set_render_target(device, i, NULL, FALSE);
1561     }
1562
1563     surface = device->fb.render_targets[0];
1564     TRACE("Setting rendertarget 0 to NULL\n");
1565     device->fb.render_targets[0] = NULL;
1566     TRACE("Releasing the render target at %p\n", surface);
1567     wined3d_surface_decref(surface);
1568
1569     context_release(context);
1570
1571     for (i = 0; i < device->swapchain_count; ++i)
1572     {
1573         TRACE("Releasing the implicit swapchain %u.\n", i);
1574         if (wined3d_swapchain_decref(device->swapchains[i]))
1575             FIXME("Something's still holding the implicit swapchain.\n");
1576     }
1577
1578     HeapFree(GetProcessHeap(), 0, device->swapchains);
1579     device->swapchains = NULL;
1580     device->swapchain_count = 0;
1581
1582     for (i = 0; i < device->palette_count; ++i)
1583         HeapFree(GetProcessHeap(), 0, device->palettes[i]);
1584     HeapFree(GetProcessHeap(), 0, device->palettes);
1585     device->palettes = NULL;
1586     device->palette_count = 0;
1587
1588     HeapFree(GetProcessHeap(), 0, device->fb.render_targets);
1589     device->fb.render_targets = NULL;
1590
1591     device->d3d_initialized = FALSE;
1592
1593     return WINED3D_OK;
1594 }
1595
1596 HRESULT CDECL wined3d_device_uninit_gdi(struct wined3d_device *device)
1597 {
1598     unsigned int i;
1599
1600     for (i = 0; i < device->swapchain_count; ++i)
1601     {
1602         TRACE("Releasing the implicit swapchain %u.\n", i);
1603         if (wined3d_swapchain_decref(device->swapchains[i]))
1604             FIXME("Something's still holding the implicit swapchain.\n");
1605     }
1606
1607     HeapFree(GetProcessHeap(), 0, device->swapchains);
1608     device->swapchains = NULL;
1609     device->swapchain_count = 0;
1610     return WINED3D_OK;
1611 }
1612
1613 /* Enables thread safety in the wined3d device and its resources. Called by DirectDraw
1614  * from SetCooperativeLevel if DDSCL_MULTITHREADED is specified, and by d3d8/9 from
1615  * CreateDevice if D3DCREATE_MULTITHREADED is passed.
1616  *
1617  * There is no way to deactivate thread safety once it is enabled.
1618  */
1619 void CDECL wined3d_device_set_multithreaded(struct wined3d_device *device)
1620 {
1621     TRACE("device %p.\n", device);
1622
1623     /* For now just store the flag (needed in case of ddraw). */
1624     device->createParms.BehaviorFlags |= WINED3DCREATE_MULTITHREADED;
1625 }
1626
1627 HRESULT CDECL wined3d_device_set_display_mode(struct wined3d_device *device,
1628         UINT swapchain_idx, const WINED3DDISPLAYMODE *mode)
1629 {
1630     struct wined3d_adapter *adapter = device->adapter;
1631     const struct wined3d_format *format = wined3d_get_format(&adapter->gl_info, mode->Format);
1632     DEVMODEW devmode;
1633     LONG ret;
1634     RECT clip_rc;
1635
1636     TRACE("device %p, swapchain_idx %u, mode %p (%ux%u@%u %s).\n", device, swapchain_idx, mode,
1637             mode->Width, mode->Height, mode->RefreshRate, debug_d3dformat(mode->Format));
1638
1639     /* Resize the screen even without a window:
1640      * The app could have unset it with SetCooperativeLevel, but not called
1641      * RestoreDisplayMode first. Then the release will call RestoreDisplayMode,
1642      * but we don't have any hwnd
1643      */
1644
1645     memset(&devmode, 0, sizeof(devmode));
1646     devmode.dmSize = sizeof(devmode);
1647     devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
1648     devmode.dmBitsPerPel = format->byte_count * CHAR_BIT;
1649     devmode.dmPelsWidth = mode->Width;
1650     devmode.dmPelsHeight = mode->Height;
1651
1652     devmode.dmDisplayFrequency = mode->RefreshRate;
1653     if (mode->RefreshRate)
1654         devmode.dmFields |= DM_DISPLAYFREQUENCY;
1655
1656     /* Only change the mode if necessary */
1657     if (adapter->screen_size.cx == mode->Width && adapter->screen_size.cy == mode->Height
1658             && adapter->screen_format == mode->Format && !mode->RefreshRate)
1659         return WINED3D_OK;
1660
1661     ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL);
1662     if (ret != DISP_CHANGE_SUCCESSFUL)
1663     {
1664         if (devmode.dmDisplayFrequency)
1665         {
1666             WARN("ChangeDisplaySettingsExW failed, trying without the refresh rate\n");
1667             devmode.dmFields &= ~DM_DISPLAYFREQUENCY;
1668             devmode.dmDisplayFrequency = 0;
1669             ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL;
1670         }
1671         if(ret != DISP_CHANGE_SUCCESSFUL) {
1672             return WINED3DERR_NOTAVAILABLE;
1673         }
1674     }
1675
1676     /* Store the new values */
1677     adapter->screen_size.cx = mode->Width;
1678     adapter->screen_size.cy = mode->Height;
1679     adapter->screen_format = mode->Format;
1680
1681     /* And finally clip mouse to our screen */
1682     SetRect(&clip_rc, 0, 0, mode->Width, mode->Height);
1683     ClipCursor(&clip_rc);
1684
1685     return WINED3D_OK;
1686 }
1687
1688 HRESULT CDECL wined3d_device_get_wined3d(const struct wined3d_device *device, struct wined3d **wined3d)
1689 {
1690     TRACE("device %p, wined3d %p.\n", device, wined3d);
1691
1692     *wined3d = device->wined3d;
1693     wined3d_incref(*wined3d);
1694
1695     TRACE("Returning %p.\n", *wined3d);
1696
1697     return WINED3D_OK;
1698 }
1699
1700 UINT CDECL wined3d_device_get_available_texture_mem(const struct wined3d_device *device)
1701 {
1702     TRACE("device %p.\n", device);
1703
1704     TRACE("Emulating %d MB, returning %d MB left.\n",
1705             device->adapter->TextureRam / (1024 * 1024),
1706             (device->adapter->TextureRam - device->adapter->UsedTextureRam) / (1024 * 1024));
1707
1708     return device->adapter->TextureRam - device->adapter->UsedTextureRam;
1709 }
1710
1711 HRESULT CDECL wined3d_device_set_stream_source(struct wined3d_device *device, UINT stream_idx,
1712         struct wined3d_buffer *buffer, UINT offset, UINT stride)
1713 {
1714     struct wined3d_stream_state *stream;
1715     struct wined3d_buffer *prev_buffer;
1716
1717     TRACE("device %p, stream_idx %u, buffer %p, offset %u, stride %u.\n",
1718             device, stream_idx, buffer, offset, stride);
1719
1720     if (stream_idx >= MAX_STREAMS)
1721     {
1722         WARN("Stream index %u out of range.\n", stream_idx);
1723         return WINED3DERR_INVALIDCALL;
1724     }
1725     else if (offset & 0x3)
1726     {
1727         WARN("Offset %u is not 4 byte aligned.\n", offset);
1728         return WINED3DERR_INVALIDCALL;
1729     }
1730
1731     stream = &device->updateStateBlock->state.streams[stream_idx];
1732     prev_buffer = stream->buffer;
1733
1734     device->updateStateBlock->changed.streamSource |= 1 << stream_idx;
1735
1736     if (prev_buffer == buffer
1737             && stream->stride == stride
1738             && stream->offset == offset)
1739     {
1740        TRACE("Application is setting the old values over, nothing to do.\n");
1741        return WINED3D_OK;
1742     }
1743
1744     stream->buffer = buffer;
1745     if (buffer)
1746     {
1747         stream->stride = stride;
1748         stream->offset = offset;
1749     }
1750
1751     /* Handle recording of state blocks. */
1752     if (device->isRecordingState)
1753     {
1754         TRACE("Recording... not performing anything.\n");
1755         if (buffer)
1756             wined3d_buffer_incref(buffer);
1757         if (prev_buffer)
1758             wined3d_buffer_decref(prev_buffer);
1759         return WINED3D_OK;
1760     }
1761
1762     if (buffer)
1763     {
1764         InterlockedIncrement(&buffer->bind_count);
1765         wined3d_buffer_incref(buffer);
1766     }
1767     if (prev_buffer)
1768     {
1769         InterlockedDecrement(&prev_buffer->bind_count);
1770         wined3d_buffer_decref(prev_buffer);
1771     }
1772
1773     device_invalidate_state(device, STATE_STREAMSRC);
1774
1775     return WINED3D_OK;
1776 }
1777
1778 HRESULT CDECL wined3d_device_get_stream_source(const struct wined3d_device *device,
1779         UINT stream_idx, struct wined3d_buffer **buffer, UINT *offset, UINT *stride)
1780 {
1781     struct wined3d_stream_state *stream;
1782
1783     TRACE("device %p, stream_idx %u, buffer %p, offset %p, stride %p.\n",
1784             device, stream_idx, buffer, offset, stride);
1785
1786     if (stream_idx >= MAX_STREAMS)
1787     {
1788         WARN("Stream index %u out of range.\n", stream_idx);
1789         return WINED3DERR_INVALIDCALL;
1790     }
1791
1792     stream = &device->stateBlock->state.streams[stream_idx];
1793     *buffer = stream->buffer;
1794     if (*buffer)
1795         wined3d_buffer_incref(*buffer);
1796     if (offset)
1797         *offset = stream->offset;
1798     *stride = stream->stride;
1799
1800     return WINED3D_OK;
1801 }
1802
1803 HRESULT CDECL wined3d_device_set_stream_source_freq(struct wined3d_device *device, UINT stream_idx, UINT divider)
1804 {
1805     struct wined3d_stream_state *stream;
1806     UINT old_flags, old_freq;
1807
1808     TRACE("device %p, stream_idx %u, divider %#x.\n", device, stream_idx, divider);
1809
1810     /* Verify input. At least in d3d9 this is invalid. */
1811     if ((divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && (divider & WINED3DSTREAMSOURCE_INDEXEDDATA))
1812     {
1813         WARN("INSTANCEDATA and INDEXEDDATA were set, returning D3DERR_INVALIDCALL.\n");
1814         return WINED3DERR_INVALIDCALL;
1815     }
1816     if ((divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && !stream_idx)
1817     {
1818         WARN("INSTANCEDATA used on stream 0, returning D3DERR_INVALIDCALL.\n");
1819         return WINED3DERR_INVALIDCALL;
1820     }
1821     if (!divider)
1822     {
1823         WARN("Divider is 0, returning D3DERR_INVALIDCALL.\n");
1824         return WINED3DERR_INVALIDCALL;
1825     }
1826
1827     stream = &device->updateStateBlock->state.streams[stream_idx];
1828     old_flags = stream->flags;
1829     old_freq = stream->frequency;
1830
1831     stream->flags = divider & (WINED3DSTREAMSOURCE_INSTANCEDATA | WINED3DSTREAMSOURCE_INDEXEDDATA);
1832     stream->frequency = divider & 0x7fffff;
1833
1834     device->updateStateBlock->changed.streamFreq |= 1 << stream_idx;
1835
1836     if (stream->frequency != old_freq || stream->flags != old_flags)
1837         device_invalidate_state(device, STATE_STREAMSRC);
1838
1839     return WINED3D_OK;
1840 }
1841
1842 HRESULT CDECL wined3d_device_get_stream_source_freq(const struct wined3d_device *device,
1843         UINT stream_idx, UINT *divider)
1844 {
1845     struct wined3d_stream_state *stream;
1846
1847     TRACE("device %p, stream_idx %u, divider %p.\n", device, stream_idx, divider);
1848
1849     stream = &device->updateStateBlock->state.streams[stream_idx];
1850     *divider = stream->flags | stream->frequency;
1851
1852     TRACE("Returning %#x.\n", *divider);
1853
1854     return WINED3D_OK;
1855 }
1856
1857 HRESULT CDECL wined3d_device_set_transform(struct wined3d_device *device,
1858         WINED3DTRANSFORMSTATETYPE d3dts, const WINED3DMATRIX *matrix)
1859 {
1860     TRACE("device %p, state %s, matrix %p.\n",
1861             device, debug_d3dtstype(d3dts), matrix);
1862
1863     /* Handle recording of state blocks. */
1864     if (device->isRecordingState)
1865     {
1866         TRACE("Recording... not performing anything.\n");
1867         device->updateStateBlock->changed.transform[d3dts >> 5] |= 1 << (d3dts & 0x1f);
1868         device->updateStateBlock->state.transforms[d3dts] = *matrix;
1869         return WINED3D_OK;
1870     }
1871
1872     /* If the new matrix is the same as the current one,
1873      * we cut off any further processing. this seems to be a reasonable
1874      * optimization because as was noticed, some apps (warcraft3 for example)
1875      * tend towards setting the same matrix repeatedly for some reason.
1876      *
1877      * From here on we assume that the new matrix is different, wherever it matters. */
1878     if (!memcmp(&device->stateBlock->state.transforms[d3dts].u.m[0][0], matrix, sizeof(*matrix)))
1879     {
1880         TRACE("The application is setting the same matrix over again.\n");
1881         return WINED3D_OK;
1882     }
1883
1884     conv_mat(matrix, &device->stateBlock->state.transforms[d3dts].u.m[0][0]);
1885
1886     /* ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord
1887      * where ViewMat = Camera space, WorldMat = world space.
1888      *
1889      * In OpenGL, camera and world space is combined into GL_MODELVIEW
1890      * matrix.  The Projection matrix stay projection matrix. */
1891
1892     if (d3dts == WINED3DTS_VIEW)
1893         device->view_ident = !memcmp(matrix, identity, 16 * sizeof(float));
1894
1895     if (d3dts < WINED3DTS_WORLDMATRIX(device->adapter->gl_info.limits.blends))
1896         device_invalidate_state(device, STATE_TRANSFORM(d3dts));
1897
1898     return WINED3D_OK;
1899
1900 }
1901
1902 HRESULT CDECL wined3d_device_get_transform(const struct wined3d_device *device,
1903         WINED3DTRANSFORMSTATETYPE state, WINED3DMATRIX *matrix)
1904 {
1905     TRACE("device %p, state %s, matrix %p.\n", device, debug_d3dtstype(state), matrix);
1906
1907     *matrix = device->stateBlock->state.transforms[state];
1908
1909     return WINED3D_OK;
1910 }
1911
1912 HRESULT CDECL wined3d_device_multiply_transform(struct wined3d_device *device,
1913         WINED3DTRANSFORMSTATETYPE state, const WINED3DMATRIX *matrix)
1914 {
1915     const WINED3DMATRIX *mat = NULL;
1916     WINED3DMATRIX temp;
1917
1918     TRACE("device %p, state %s, matrix %p.\n", device, debug_d3dtstype(state), matrix);
1919
1920     /* Note: Using 'updateStateBlock' rather than 'stateblock' in the code
1921      * below means it will be recorded in a state block change, but it
1922      * works regardless where it is recorded.
1923      * If this is found to be wrong, change to StateBlock. */
1924     if (state > HIGHEST_TRANSFORMSTATE)
1925     {
1926         WARN("Unhandled transform state %#x.\n", state);
1927         return WINED3D_OK;
1928     }
1929
1930     mat = &device->updateStateBlock->state.transforms[state];
1931     multiply_matrix(&temp, mat, matrix);
1932
1933     /* Apply change via set transform - will reapply to eg. lights this way. */
1934     return wined3d_device_set_transform(device, state, &temp);
1935 }
1936
1937 /* Note lights are real special cases. Although the device caps state only
1938  * e.g. 8 are supported, you can reference any indexes you want as long as
1939  * that number max are enabled at any one point in time. Therefore since the
1940  * indices can be anything, we need a hashmap of them. However, this causes
1941  * stateblock problems. When capturing the state block, I duplicate the
1942  * hashmap, but when recording, just build a chain pretty much of commands to
1943  * be replayed. */
1944 HRESULT CDECL wined3d_device_set_light(struct wined3d_device *device, UINT light_idx, const WINED3DLIGHT *light)
1945 {
1946     UINT hash_idx = LIGHTMAP_HASHFUNC(light_idx);
1947     struct wined3d_light_info *object = NULL;
1948     struct list *e;
1949     float rho;
1950
1951     TRACE("device %p, light_idx %u, light %p.\n", device, light_idx, light);
1952
1953     /* Check the parameter range. Need for speed most wanted sets junk lights
1954      * which confuse the GL driver. */
1955     if (!light)
1956         return WINED3DERR_INVALIDCALL;
1957
1958     switch (light->Type)
1959     {
1960         case WINED3DLIGHT_POINT:
1961         case WINED3DLIGHT_SPOT:
1962         case WINED3DLIGHT_PARALLELPOINT:
1963         case WINED3DLIGHT_GLSPOT:
1964             /* Incorrect attenuation values can cause the gl driver to crash.
1965              * Happens with Need for speed most wanted. */
1966             if (light->Attenuation0 < 0.0f || light->Attenuation1 < 0.0f || light->Attenuation2 < 0.0f)
1967             {
1968                 WARN("Attenuation is negative, returning WINED3DERR_INVALIDCALL.\n");
1969                 return WINED3DERR_INVALIDCALL;
1970             }
1971             break;
1972
1973         case WINED3DLIGHT_DIRECTIONAL:
1974             /* Ignores attenuation */
1975             break;
1976
1977         default:
1978         WARN("Light type out of range, returning WINED3DERR_INVALIDCALL\n");
1979         return WINED3DERR_INVALIDCALL;
1980     }
1981
1982     LIST_FOR_EACH(e, &device->updateStateBlock->state.light_map[hash_idx])
1983     {
1984         object = LIST_ENTRY(e, struct wined3d_light_info, entry);
1985         if (object->OriginalIndex == light_idx)
1986             break;
1987         object = NULL;
1988     }
1989
1990     if (!object)
1991     {
1992         TRACE("Adding new light\n");
1993         object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1994         if (!object)
1995         {
1996             ERR("Out of memory error when allocating a light\n");
1997             return E_OUTOFMEMORY;
1998         }
1999         list_add_head(&device->updateStateBlock->state.light_map[hash_idx], &object->entry);
2000         object->glIndex = -1;
2001         object->OriginalIndex = light_idx;
2002     }
2003
2004     /* Initialize the object. */
2005     TRACE("Light %d setting to type %d, Diffuse(%f,%f,%f,%f), Specular(%f,%f,%f,%f), Ambient(%f,%f,%f,%f)\n",
2006             light_idx, light->Type,
2007             light->Diffuse.r, light->Diffuse.g, light->Diffuse.b, light->Diffuse.a,
2008             light->Specular.r, light->Specular.g, light->Specular.b, light->Specular.a,
2009             light->Ambient.r, light->Ambient.g, light->Ambient.b, light->Ambient.a);
2010     TRACE("... Pos(%f,%f,%f), Dir(%f,%f,%f)\n", light->Position.x, light->Position.y, light->Position.z,
2011             light->Direction.x, light->Direction.y, light->Direction.z);
2012     TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n",
2013             light->Range, light->Falloff, light->Theta, light->Phi);
2014
2015     /* Save away the information. */
2016     object->OriginalParms = *light;
2017
2018     switch (light->Type)
2019     {
2020         case WINED3DLIGHT_POINT:
2021             /* Position */
2022             object->lightPosn[0] = light->Position.x;
2023             object->lightPosn[1] = light->Position.y;
2024             object->lightPosn[2] = light->Position.z;
2025             object->lightPosn[3] = 1.0f;
2026             object->cutoff = 180.0f;
2027             /* FIXME: Range */
2028             break;
2029
2030         case WINED3DLIGHT_DIRECTIONAL:
2031             /* Direction */
2032             object->lightPosn[0] = -light->Direction.x;
2033             object->lightPosn[1] = -light->Direction.y;
2034             object->lightPosn[2] = -light->Direction.z;
2035             object->lightPosn[3] = 0.0f;
2036             object->exponent = 0.0f;
2037             object->cutoff = 180.0f;
2038             break;
2039
2040         case WINED3DLIGHT_SPOT:
2041             /* Position */
2042             object->lightPosn[0] = light->Position.x;
2043             object->lightPosn[1] = light->Position.y;
2044             object->lightPosn[2] = light->Position.z;
2045             object->lightPosn[3] = 1.0f;
2046
2047             /* Direction */
2048             object->lightDirn[0] = light->Direction.x;
2049             object->lightDirn[1] = light->Direction.y;
2050             object->lightDirn[2] = light->Direction.z;
2051             object->lightDirn[3] = 1.0f;
2052
2053             /* opengl-ish and d3d-ish spot lights use too different models
2054              * for the light "intensity" as a function of the angle towards
2055              * the main light direction, so we only can approximate very
2056              * roughly. However, spot lights are rather rarely used in games
2057              * (if ever used at all). Furthermore if still used, probably
2058              * nobody pays attention to such details. */
2059             if (!light->Falloff)
2060             {
2061                 /* Falloff = 0 is easy, because d3d's and opengl's spot light
2062                  * equations have the falloff resp. exponent parameter as an
2063                  * exponent, so the spot light lighting will always be 1.0 for
2064                  * both of them, and we don't have to care for the rest of the
2065                  * rather complex calculation. */
2066                 object->exponent = 0.0f;
2067             }
2068             else
2069             {
2070                 rho = light->Theta + (light->Phi - light->Theta) / (2 * light->Falloff);
2071                 if (rho < 0.0001f)
2072                     rho = 0.0001f;
2073                 object->exponent = -0.3f / logf(cosf(rho / 2));
2074             }
2075
2076             if (object->exponent > 128.0f)
2077                 object->exponent = 128.0f;
2078
2079             object->cutoff = (float)(light->Phi * 90 / M_PI);
2080             /* FIXME: Range */
2081             break;
2082
2083         default:
2084             FIXME("Unrecognized light type %#x.\n", light->Type);
2085     }
2086
2087     /* Update the live definitions if the light is currently assigned a glIndex. */
2088     if (object->glIndex != -1 && !device->isRecordingState)
2089         device_invalidate_state(device, STATE_ACTIVELIGHT(object->glIndex));
2090
2091     return WINED3D_OK;
2092 }
2093
2094 HRESULT CDECL wined3d_device_get_light(const struct wined3d_device *device, UINT light_idx, WINED3DLIGHT *light)
2095 {
2096     UINT hash_idx = LIGHTMAP_HASHFUNC(light_idx);
2097     struct wined3d_light_info *light_info = NULL;
2098     struct list *e;
2099
2100     TRACE("device %p, light_idx %u, light %p.\n", device, light_idx, light);
2101
2102     LIST_FOR_EACH(e, &device->stateBlock->state.light_map[hash_idx])
2103     {
2104         light_info = LIST_ENTRY(e, struct wined3d_light_info, entry);
2105         if (light_info->OriginalIndex == light_idx)
2106             break;
2107         light_info = NULL;
2108     }
2109
2110     if (!light_info)
2111     {
2112         TRACE("Light information requested but light not defined\n");
2113         return WINED3DERR_INVALIDCALL;
2114     }
2115
2116     *light = light_info->OriginalParms;
2117     return WINED3D_OK;
2118 }
2119
2120 HRESULT CDECL wined3d_device_set_light_enable(struct wined3d_device *device, UINT light_idx, BOOL enable)
2121 {
2122     UINT hash_idx = LIGHTMAP_HASHFUNC(light_idx);
2123     struct wined3d_light_info *light_info = NULL;
2124     struct list *e;
2125
2126     TRACE("device %p, light_idx %u, enable %#x.\n", device, light_idx, enable);
2127
2128     LIST_FOR_EACH(e, &device->updateStateBlock->state.light_map[hash_idx])
2129     {
2130         light_info = LIST_ENTRY(e, struct wined3d_light_info, entry);
2131         if (light_info->OriginalIndex == light_idx)
2132             break;
2133         light_info = NULL;
2134     }
2135     TRACE("Found light %p.\n", light_info);
2136
2137     /* Special case - enabling an undefined light creates one with a strict set of parameters. */
2138     if (!light_info)
2139     {
2140         TRACE("Light enabled requested but light not defined, so defining one!\n");
2141         wined3d_device_set_light(device, light_idx, &WINED3D_default_light);
2142
2143         /* Search for it again! Should be fairly quick as near head of list. */
2144         LIST_FOR_EACH(e, &device->updateStateBlock->state.light_map[hash_idx])
2145         {
2146             light_info = LIST_ENTRY(e, struct wined3d_light_info, entry);
2147             if (light_info->OriginalIndex == light_idx)
2148                 break;
2149             light_info = NULL;
2150         }
2151         if (!light_info)
2152         {
2153             FIXME("Adding default lights has failed dismally\n");
2154             return WINED3DERR_INVALIDCALL;
2155         }
2156     }
2157
2158     if (!enable)
2159     {
2160         if (light_info->glIndex != -1)
2161         {
2162             if (!device->isRecordingState)
2163                 device_invalidate_state(device, STATE_ACTIVELIGHT(light_info->glIndex));
2164
2165             device->updateStateBlock->state.lights[light_info->glIndex] = NULL;
2166             light_info->glIndex = -1;
2167         }
2168         else
2169         {
2170             TRACE("Light already disabled, nothing to do\n");
2171         }
2172         light_info->enabled = FALSE;
2173     }
2174     else
2175     {
2176         light_info->enabled = TRUE;
2177         if (light_info->glIndex != -1)
2178         {
2179             TRACE("Nothing to do as light was enabled\n");
2180         }
2181         else
2182         {
2183             unsigned int i;
2184             const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2185             /* Find a free GL light. */
2186             for (i = 0; i < gl_info->limits.lights; ++i)
2187             {
2188                 if (!device->updateStateBlock->state.lights[i])
2189                 {
2190                     device->updateStateBlock->state.lights[i] = light_info;
2191                     light_info->glIndex = i;
2192                     break;
2193                 }
2194             }
2195             if (light_info->glIndex == -1)
2196             {
2197                 /* Our tests show that Windows returns D3D_OK in this situation, even with
2198                  * D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE devices. This
2199                  * is consistent among ddraw, d3d8 and d3d9. GetLightEnable returns TRUE
2200                  * as well for those lights.
2201                  *
2202                  * TODO: Test how this affects rendering. */
2203                 WARN("Too many concurrently active lights\n");
2204                 return WINED3D_OK;
2205             }
2206
2207             /* i == light_info->glIndex */
2208             if (!device->isRecordingState)
2209                 device_invalidate_state(device, STATE_ACTIVELIGHT(i));
2210         }
2211     }
2212
2213     return WINED3D_OK;
2214 }
2215
2216 HRESULT CDECL wined3d_device_get_light_enable(const struct wined3d_device *device, UINT light_idx, BOOL *enable)
2217 {
2218     UINT hash_idx = LIGHTMAP_HASHFUNC(light_idx);
2219     struct wined3d_light_info *light_info = NULL;
2220     struct list *e;
2221
2222     TRACE("device %p, light_idx %u, enable %p.\n", device, light_idx, enable);
2223
2224     LIST_FOR_EACH(e, &device->stateBlock->state.light_map[hash_idx])
2225     {
2226         light_info = LIST_ENTRY(e, struct wined3d_light_info, entry);
2227         if (light_info->OriginalIndex == light_idx)
2228             break;
2229         light_info = NULL;
2230     }
2231
2232     if (!light_info)
2233     {
2234         TRACE("Light enabled state requested but light not defined.\n");
2235         return WINED3DERR_INVALIDCALL;
2236     }
2237     /* true is 128 according to SetLightEnable */
2238     *enable = light_info->enabled ? 128 : 0;
2239     return WINED3D_OK;
2240 }
2241
2242 HRESULT CDECL wined3d_device_set_clip_plane(struct wined3d_device *device, UINT plane_idx, const float *plane)
2243 {
2244     TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
2245
2246     /* Validate plane_idx. */
2247     if (plane_idx >= device->adapter->gl_info.limits.clipplanes)
2248     {
2249         TRACE("Application has requested clipplane this device doesn't support.\n");
2250         return WINED3DERR_INVALIDCALL;
2251     }
2252
2253     device->updateStateBlock->changed.clipplane |= 1 << plane_idx;
2254
2255     if (device->updateStateBlock->state.clip_planes[plane_idx][0] == plane[0]
2256             && device->updateStateBlock->state.clip_planes[plane_idx][1] == plane[1]
2257             && device->updateStateBlock->state.clip_planes[plane_idx][2] == plane[2]
2258             && device->updateStateBlock->state.clip_planes[plane_idx][3] == plane[3])
2259     {
2260         TRACE("Application is setting old values over, nothing to do.\n");
2261         return WINED3D_OK;
2262     }
2263
2264     device->updateStateBlock->state.clip_planes[plane_idx][0] = plane[0];
2265     device->updateStateBlock->state.clip_planes[plane_idx][1] = plane[1];
2266     device->updateStateBlock->state.clip_planes[plane_idx][2] = plane[2];
2267     device->updateStateBlock->state.clip_planes[plane_idx][3] = plane[3];
2268
2269     /* Handle recording of state blocks. */
2270     if (device->isRecordingState)
2271     {
2272         TRACE("Recording... not performing anything.\n");
2273         return WINED3D_OK;
2274     }
2275
2276     device_invalidate_state(device, STATE_CLIPPLANE(plane_idx));
2277
2278     return WINED3D_OK;
2279 }
2280
2281 HRESULT CDECL wined3d_device_get_clip_plane(const struct wined3d_device *device, UINT plane_idx, float *plane)
2282 {
2283     TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
2284
2285     /* Validate plane_idx. */
2286     if (plane_idx >= device->adapter->gl_info.limits.clipplanes)
2287     {
2288         TRACE("Application has requested clipplane this device doesn't support.\n");
2289         return WINED3DERR_INVALIDCALL;
2290     }
2291
2292     plane[0] = (float)device->stateBlock->state.clip_planes[plane_idx][0];
2293     plane[1] = (float)device->stateBlock->state.clip_planes[plane_idx][1];
2294     plane[2] = (float)device->stateBlock->state.clip_planes[plane_idx][2];
2295     plane[3] = (float)device->stateBlock->state.clip_planes[plane_idx][3];
2296
2297     return WINED3D_OK;
2298 }
2299
2300 HRESULT CDECL wined3d_device_set_clip_status(struct wined3d_device *device, const WINED3DCLIPSTATUS *clip_status)
2301 {
2302     FIXME("device %p, clip_status %p stub!\n", device, clip_status);
2303
2304     if (!clip_status)
2305         return WINED3DERR_INVALIDCALL;
2306
2307     return WINED3D_OK;
2308 }
2309
2310 HRESULT CDECL wined3d_device_get_clip_status(const struct wined3d_device *device, WINED3DCLIPSTATUS *clip_status)
2311 {
2312     FIXME("device %p, clip_status %p stub!\n", device, clip_status);
2313
2314     if (!clip_status)
2315         return WINED3DERR_INVALIDCALL;
2316
2317     return WINED3D_OK;
2318 }
2319
2320 HRESULT CDECL wined3d_device_set_material(struct wined3d_device *device, const WINED3DMATERIAL *material)
2321 {
2322     TRACE("device %p, material %p.\n", device, material);
2323
2324     device->updateStateBlock->changed.material = TRUE;
2325     device->updateStateBlock->state.material = *material;
2326
2327     /* Handle recording of state blocks */
2328     if (device->isRecordingState)
2329     {
2330         TRACE("Recording... not performing anything.\n");
2331         return WINED3D_OK;
2332     }
2333
2334     device_invalidate_state(device, STATE_MATERIAL);
2335
2336     return WINED3D_OK;
2337 }
2338
2339 HRESULT CDECL wined3d_device_get_material(const struct wined3d_device *device, WINED3DMATERIAL *material)
2340 {
2341     TRACE("device %p, material %p.\n", device, material);
2342
2343     *material = device->updateStateBlock->state.material;
2344
2345     TRACE("Diffuse {%.8e, %.8e, %.8e, %.8e}\n",
2346             material->Diffuse.r, material->Diffuse.g,
2347             material->Diffuse.b, material->Diffuse.a);
2348     TRACE("Ambient {%.8e, %.8e, %.8e, %.8e}\n",
2349             material->Ambient.r, material->Ambient.g,
2350             material->Ambient.b, material->Ambient.a);
2351     TRACE("Specular {%.8e, %.8e, %.8e, %.8e}\n",
2352             material->Specular.r, material->Specular.g,
2353             material->Specular.b, material->Specular.a);
2354     TRACE("Emissive {%.8e, %.8e, %.8e, %.8e}\n",
2355             material->Emissive.r, material->Emissive.g,
2356             material->Emissive.b, material->Emissive.a);
2357     TRACE("Power %.8e.\n", material->Power);
2358
2359     return WINED3D_OK;
2360 }
2361
2362 HRESULT CDECL wined3d_device_set_index_buffer(struct wined3d_device *device,
2363         struct wined3d_buffer *buffer, enum wined3d_format_id format_id)
2364 {
2365     struct wined3d_buffer *prev_buffer;
2366
2367     TRACE("device %p, buffer %p, format %s.\n",
2368             device, buffer, debug_d3dformat(format_id));
2369
2370     prev_buffer = device->updateStateBlock->state.index_buffer;
2371
2372     device->updateStateBlock->changed.indices = TRUE;
2373     device->updateStateBlock->state.index_buffer = buffer;
2374     device->updateStateBlock->state.index_format = format_id;
2375
2376     /* Handle recording of state blocks. */
2377     if (device->isRecordingState)
2378     {
2379         TRACE("Recording... not performing anything.\n");
2380         if (buffer)
2381             wined3d_buffer_incref(buffer);
2382         if (prev_buffer)
2383             wined3d_buffer_decref(prev_buffer);
2384         return WINED3D_OK;
2385     }
2386
2387     if (prev_buffer != buffer)
2388     {
2389         device_invalidate_state(device, STATE_INDEXBUFFER);
2390         if (buffer)
2391         {
2392             InterlockedIncrement(&buffer->bind_count);
2393             wined3d_buffer_incref(buffer);
2394         }
2395         if (prev_buffer)
2396         {
2397             InterlockedDecrement(&prev_buffer->bind_count);
2398             wined3d_buffer_decref(prev_buffer);
2399         }
2400     }
2401
2402     return WINED3D_OK;
2403 }
2404
2405 HRESULT CDECL wined3d_device_get_index_buffer(const struct wined3d_device *device, struct wined3d_buffer **buffer)
2406 {
2407     TRACE("device %p, buffer %p.\n", device, buffer);
2408
2409     *buffer = device->stateBlock->state.index_buffer;
2410
2411     if (*buffer)
2412         wined3d_buffer_incref(*buffer);
2413
2414     TRACE("Returning %p.\n", *buffer);
2415
2416     return WINED3D_OK;
2417 }
2418
2419 /* Method to offer d3d9 a simple way to set the base vertex index without messing with the index buffer */
2420 HRESULT CDECL wined3d_device_set_base_vertex_index(struct wined3d_device *device, INT base_index)
2421 {
2422     TRACE("device %p, base_index %d.\n", device, base_index);
2423
2424     if (device->updateStateBlock->state.base_vertex_index == base_index)
2425     {
2426         TRACE("Application is setting the old value over, nothing to do\n");
2427         return WINED3D_OK;
2428     }
2429
2430     device->updateStateBlock->state.base_vertex_index = base_index;
2431
2432     if (device->isRecordingState)
2433     {
2434         TRACE("Recording... not performing anything\n");
2435         return WINED3D_OK;
2436     }
2437     return WINED3D_OK;
2438 }
2439
2440 INT CDECL wined3d_device_get_base_vertex_index(const struct wined3d_device *device)
2441 {
2442     TRACE("device %p.\n", device);
2443
2444     return device->stateBlock->state.base_vertex_index;
2445 }
2446
2447 HRESULT CDECL wined3d_device_set_viewport(struct wined3d_device *device, const WINED3DVIEWPORT *viewport)
2448 {
2449     TRACE("device %p, viewport %p.\n", device, viewport);
2450     TRACE("x %u, y %u, w %u, h %u, minz %.8e, maxz %.8e.\n",
2451           viewport->X, viewport->Y, viewport->Width, viewport->Height, viewport->MinZ, viewport->MaxZ);
2452
2453     device->updateStateBlock->changed.viewport = TRUE;
2454     device->updateStateBlock->state.viewport = *viewport;
2455
2456     /* Handle recording of state blocks */
2457     if (device->isRecordingState)
2458     {
2459         TRACE("Recording... not performing anything\n");
2460         return WINED3D_OK;
2461     }
2462
2463     device_invalidate_state(device, STATE_VIEWPORT);
2464
2465     return WINED3D_OK;
2466 }
2467
2468 HRESULT CDECL wined3d_device_get_viewport(const struct wined3d_device *device, WINED3DVIEWPORT *viewport)
2469 {
2470     TRACE("device %p, viewport %p.\n", device, viewport);
2471
2472     *viewport = device->stateBlock->state.viewport;
2473
2474     return WINED3D_OK;
2475 }
2476
2477 HRESULT CDECL wined3d_device_set_render_state(struct wined3d_device *device,
2478         WINED3DRENDERSTATETYPE state, DWORD value)
2479 {
2480     DWORD old_value = device->stateBlock->state.render_states[state];
2481
2482     TRACE("device %p, state %s (%#x), value %#x.\n", device, debug_d3drenderstate(state), state, value);
2483
2484     device->updateStateBlock->changed.renderState[state >> 5] |= 1 << (state & 0x1f);
2485     device->updateStateBlock->state.render_states[state] = value;
2486
2487     /* Handle recording of state blocks. */
2488     if (device->isRecordingState)
2489     {
2490         TRACE("Recording... not performing anything.\n");
2491         return WINED3D_OK;
2492     }
2493
2494     /* Compared here and not before the assignment to allow proper stateblock recording. */
2495     if (value == old_value)
2496         TRACE("Application is setting the old value over, nothing to do.\n");
2497     else
2498         device_invalidate_state(device, STATE_RENDER(state));
2499
2500     return WINED3D_OK;
2501 }
2502
2503 HRESULT CDECL wined3d_device_get_render_state(const struct wined3d_device *device,
2504         WINED3DRENDERSTATETYPE state, DWORD *value)
2505 {
2506     TRACE("device %p, state %s (%#x), value %p.\n", device, debug_d3drenderstate(state), state, value);
2507
2508     *value = device->stateBlock->state.render_states[state];
2509
2510     return WINED3D_OK;
2511 }
2512
2513 HRESULT CDECL wined3d_device_set_sampler_state(struct wined3d_device *device,
2514         UINT sampler_idx, WINED3DSAMPLERSTATETYPE state, DWORD value)
2515 {
2516     DWORD old_value;
2517
2518     TRACE("device %p, sampler_idx %u, state %s, value %#x.\n",
2519             device, sampler_idx, debug_d3dsamplerstate(state), value);
2520
2521     if (sampler_idx >= WINED3DVERTEXTEXTURESAMPLER0 && sampler_idx <= WINED3DVERTEXTEXTURESAMPLER3)
2522         sampler_idx -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
2523
2524     if (sampler_idx >= sizeof(device->stateBlock->state.sampler_states)
2525             / sizeof(*device->stateBlock->state.sampler_states))
2526     {
2527         WARN("Invalid sampler %u.\n", sampler_idx);
2528         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
2529     }
2530
2531     old_value = device->stateBlock->state.sampler_states[sampler_idx][state];
2532     device->updateStateBlock->state.sampler_states[sampler_idx][state] = value;
2533     device->updateStateBlock->changed.samplerState[sampler_idx] |= 1 << state;
2534
2535     /* Handle recording of state blocks. */
2536     if (device->isRecordingState)
2537     {
2538         TRACE("Recording... not performing anything.\n");
2539         return WINED3D_OK;
2540     }
2541
2542     if (old_value == value)
2543     {
2544         TRACE("Application is setting the old value over, nothing to do.\n");
2545         return WINED3D_OK;
2546     }
2547
2548     device_invalidate_state(device, STATE_SAMPLER(sampler_idx));
2549
2550     return WINED3D_OK;
2551 }
2552
2553 HRESULT CDECL wined3d_device_get_sampler_state(const struct wined3d_device *device,
2554         UINT sampler_idx, WINED3DSAMPLERSTATETYPE state, DWORD *value)
2555 {
2556     TRACE("device %p, sampler_idx %u, state %s, value %p.\n",
2557             device, sampler_idx, debug_d3dsamplerstate(state), value);
2558
2559     if (sampler_idx >= WINED3DVERTEXTEXTURESAMPLER0 && sampler_idx <= WINED3DVERTEXTEXTURESAMPLER3)
2560         sampler_idx -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
2561
2562     if (sampler_idx >= sizeof(device->stateBlock->state.sampler_states)
2563             / sizeof(*device->stateBlock->state.sampler_states))
2564     {
2565         WARN("Invalid sampler %u.\n", sampler_idx);
2566         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
2567     }
2568
2569     *value = device->stateBlock->state.sampler_states[sampler_idx][state];
2570     TRACE("Returning %#x.\n", *value);
2571
2572     return WINED3D_OK;
2573 }
2574
2575 HRESULT CDECL wined3d_device_set_scissor_rect(struct wined3d_device *device, const RECT *rect)
2576 {
2577     TRACE("device %p, rect %s.\n", device, wine_dbgstr_rect(rect));
2578
2579     device->updateStateBlock->changed.scissorRect = TRUE;
2580     if (EqualRect(&device->updateStateBlock->state.scissor_rect, rect))
2581     {
2582         TRACE("App is setting the old scissor rectangle over, nothing to do.\n");
2583         return WINED3D_OK;
2584     }
2585     CopyRect(&device->updateStateBlock->state.scissor_rect, rect);
2586
2587     if (device->isRecordingState)
2588     {
2589         TRACE("Recording... not performing anything.\n");
2590         return WINED3D_OK;
2591     }
2592
2593     device_invalidate_state(device, STATE_SCISSORRECT);
2594
2595     return WINED3D_OK;
2596 }
2597
2598 HRESULT CDECL wined3d_device_get_scissor_rect(const struct wined3d_device *device, RECT *rect)
2599 {
2600     TRACE("device %p, rect %p.\n", device, rect);
2601
2602     *rect = device->updateStateBlock->state.scissor_rect;
2603     TRACE("Returning rect %s.\n", wine_dbgstr_rect(rect));
2604
2605     return WINED3D_OK;
2606 }
2607
2608 HRESULT CDECL wined3d_device_set_vertex_declaration(struct wined3d_device *device,
2609         struct wined3d_vertex_declaration *declaration)
2610 {
2611     struct wined3d_vertex_declaration *prev = device->updateStateBlock->state.vertex_declaration;
2612
2613     TRACE("device %p, declaration %p.\n", device, declaration);
2614
2615     if (declaration)
2616         wined3d_vertex_declaration_incref(declaration);
2617     if (prev)
2618         wined3d_vertex_declaration_decref(prev);
2619
2620     device->updateStateBlock->state.vertex_declaration = declaration;
2621     device->updateStateBlock->changed.vertexDecl = TRUE;
2622
2623     if (device->isRecordingState)
2624     {
2625         TRACE("Recording... not performing anything.\n");
2626         return WINED3D_OK;
2627     }
2628     else if (declaration == prev)
2629     {
2630         /* Checked after the assignment to allow proper stateblock recording. */
2631         TRACE("Application is setting the old declaration over, nothing to do.\n");
2632         return WINED3D_OK;
2633     }
2634
2635     device_invalidate_state(device, STATE_VDECL);
2636     return WINED3D_OK;
2637 }
2638
2639 HRESULT CDECL wined3d_device_get_vertex_declaration(const struct wined3d_device *device,
2640         struct wined3d_vertex_declaration **declaration)
2641 {
2642     TRACE("device %p, declaration %p.\n", device, declaration);
2643
2644     *declaration = device->stateBlock->state.vertex_declaration;
2645     if (*declaration)
2646         wined3d_vertex_declaration_incref(*declaration);
2647
2648     return WINED3D_OK;
2649 }
2650
2651 HRESULT CDECL wined3d_device_set_vertex_shader(struct wined3d_device *device, struct wined3d_shader *shader)
2652 {
2653     struct wined3d_shader *prev = device->updateStateBlock->state.vertex_shader;
2654
2655     TRACE("device %p, shader %p.\n", device, shader);
2656
2657     device->updateStateBlock->state.vertex_shader = shader;
2658     device->updateStateBlock->changed.vertexShader = TRUE;
2659
2660     if (device->isRecordingState)
2661     {
2662         if (shader)
2663             wined3d_shader_incref(shader);
2664         if (prev)
2665             wined3d_shader_decref(prev);
2666         TRACE("Recording... not performing anything.\n");
2667         return WINED3D_OK;
2668     }
2669
2670     if (shader == prev)
2671     {
2672         TRACE("Application is setting the old shader over, nothing to do.\n");
2673         return WINED3D_OK;
2674     }
2675
2676     if (shader)
2677         wined3d_shader_incref(shader);
2678     if (prev)
2679         wined3d_shader_decref(prev);
2680
2681     device_invalidate_state(device, STATE_VSHADER);
2682
2683     return WINED3D_OK;
2684 }
2685
2686 struct wined3d_shader * CDECL wined3d_device_get_vertex_shader(const struct wined3d_device *device)
2687 {
2688     struct wined3d_shader *shader;
2689
2690     TRACE("device %p.\n", device);
2691
2692     shader = device->stateBlock->state.vertex_shader;
2693     if (shader)
2694         wined3d_shader_incref(shader);
2695
2696     TRACE("Returning %p.\n", shader);
2697     return shader;
2698 }
2699
2700 HRESULT CDECL wined3d_device_set_vs_consts_b(struct wined3d_device *device,
2701         UINT start_register, const BOOL *constants, UINT bool_count)
2702 {
2703     UINT count = min(bool_count, MAX_CONST_B - start_register);
2704     UINT i;
2705
2706     TRACE("device %p, start_register %u, constants %p, bool_count %u.\n",
2707             device, start_register, constants, bool_count);
2708
2709     if (!constants || start_register >= MAX_CONST_B)
2710         return WINED3DERR_INVALIDCALL;
2711
2712     memcpy(&device->updateStateBlock->state.vs_consts_b[start_register], constants, count * sizeof(BOOL));
2713     for (i = 0; i < count; ++i)
2714         TRACE("Set BOOL constant %u to %s.\n", start_register + i, constants[i] ? "true" : "false");
2715
2716     for (i = start_register; i < count + start_register; ++i)
2717         device->updateStateBlock->changed.vertexShaderConstantsB |= (1 << i);
2718
2719     if (!device->isRecordingState)
2720         device_invalidate_state(device, STATE_VERTEXSHADERCONSTANT);
2721
2722     return WINED3D_OK;
2723 }
2724
2725 HRESULT CDECL wined3d_device_get_vs_consts_b(const struct wined3d_device *device,
2726         UINT start_register, BOOL *constants, UINT bool_count)
2727 {
2728     UINT count = min(bool_count, MAX_CONST_B - start_register);
2729
2730     TRACE("device %p, start_register %u, constants %p, bool_count %u.\n",
2731             device, start_register, constants, bool_count);
2732
2733     if (!constants || start_register >= MAX_CONST_B)
2734         return WINED3DERR_INVALIDCALL;
2735
2736     memcpy(constants, &device->stateBlock->state.vs_consts_b[start_register], count * sizeof(BOOL));
2737
2738     return WINED3D_OK;
2739 }
2740
2741 HRESULT CDECL wined3d_device_set_vs_consts_i(struct wined3d_device *device,
2742         UINT start_register, const int *constants, UINT vector4i_count)
2743 {
2744     UINT count = min(vector4i_count, MAX_CONST_I - start_register);
2745     UINT i;
2746
2747     TRACE("device %p, start_register %u, constants %p, vector4i_count %u.\n",
2748             device, start_register, constants, vector4i_count);
2749
2750     if (!constants || start_register >= MAX_CONST_I)
2751         return WINED3DERR_INVALIDCALL;
2752
2753     memcpy(&device->updateStateBlock->state.vs_consts_i[start_register * 4], constants, count * sizeof(int) * 4);
2754     for (i = 0; i < count; ++i)
2755         TRACE("Set INT constant %u to {%d, %d, %d, %d}.\n", start_register + i,
2756                 constants[i * 4], constants[i * 4 + 1],
2757                 constants[i * 4 + 2], constants[i * 4 + 3]);
2758
2759     for (i = start_register; i < count + start_register; ++i)
2760         device->updateStateBlock->changed.vertexShaderConstantsI |= (1 << i);
2761
2762     if (!device->isRecordingState)
2763         device_invalidate_state(device, STATE_VERTEXSHADERCONSTANT);
2764
2765     return WINED3D_OK;
2766 }
2767
2768 HRESULT CDECL wined3d_device_get_vs_consts_i(const struct wined3d_device *device,
2769         UINT start_register, int *constants, UINT vector4i_count)
2770 {
2771     UINT count = min(vector4i_count, MAX_CONST_I - start_register);
2772
2773     TRACE("device %p, start_register %u, constants %p, vector4i_count %u.\n",
2774             device, start_register, constants, vector4i_count);
2775
2776     if (!constants || start_register >= MAX_CONST_I)
2777         return WINED3DERR_INVALIDCALL;
2778
2779     memcpy(constants, &device->stateBlock->state.vs_consts_i[start_register * 4], count * sizeof(int) * 4);
2780     return WINED3D_OK;
2781 }
2782
2783 HRESULT CDECL wined3d_device_set_vs_consts_f(struct wined3d_device *device,
2784         UINT start_register, const float *constants, UINT vector4f_count)
2785 {
2786     UINT i;
2787
2788     TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
2789             device, start_register, constants, vector4f_count);
2790
2791     /* Specifically test start_register > limit to catch MAX_UINT overflows
2792      * when adding start_register + vector4f_count. */
2793     if (!constants
2794             || start_register + vector4f_count > device->d3d_vshader_constantF
2795             || start_register > device->d3d_vshader_constantF)
2796         return WINED3DERR_INVALIDCALL;
2797
2798     memcpy(&device->updateStateBlock->state.vs_consts_f[start_register * 4],
2799             constants, vector4f_count * sizeof(float) * 4);
2800     if (TRACE_ON(d3d))
2801     {
2802         for (i = 0; i < vector4f_count; ++i)
2803             TRACE("Set FLOAT constant %u to {%.8e, %.8e, %.8e, %.8e}.\n", start_register + i,
2804                     constants[i * 4], constants[i * 4 + 1],
2805                     constants[i * 4 + 2], constants[i * 4 + 3]);
2806     }
2807
2808     if (!device->isRecordingState)
2809     {
2810         device->shader_backend->shader_update_float_vertex_constants(device, start_register, vector4f_count);
2811         device_invalidate_state(device, STATE_VERTEXSHADERCONSTANT);
2812     }
2813
2814     memset(device->updateStateBlock->changed.vertexShaderConstantsF + start_register, 1,
2815             sizeof(*device->updateStateBlock->changed.vertexShaderConstantsF) * vector4f_count);
2816
2817     return WINED3D_OK;
2818 }
2819
2820 HRESULT CDECL wined3d_device_get_vs_consts_f(const struct wined3d_device *device,
2821         UINT start_register, float *constants, UINT vector4f_count)
2822 {
2823     int count = min(vector4f_count, device->d3d_vshader_constantF - start_register);
2824
2825     TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
2826             device, start_register, constants, vector4f_count);
2827
2828     if (!constants || count < 0)
2829         return WINED3DERR_INVALIDCALL;
2830
2831     memcpy(constants, &device->stateBlock->state.vs_consts_f[start_register * 4], count * sizeof(float) * 4);
2832
2833     return WINED3D_OK;
2834 }
2835
2836 static void device_invalidate_texture_stage(const struct wined3d_device *device, DWORD stage)
2837 {
2838     DWORD i;
2839
2840     for (i = 0; i <= WINED3D_HIGHEST_TEXTURE_STATE; ++i)
2841     {
2842         device_invalidate_state(device, STATE_TEXTURESTAGE(stage, i));
2843     }
2844 }
2845
2846 static void device_map_stage(struct wined3d_device *device, DWORD stage, DWORD unit)
2847 {
2848     DWORD i = device->rev_tex_unit_map[unit];
2849     DWORD j = device->texUnitMap[stage];
2850
2851     device->texUnitMap[stage] = unit;
2852     if (i != WINED3D_UNMAPPED_STAGE && i != stage)
2853         device->texUnitMap[i] = WINED3D_UNMAPPED_STAGE;
2854
2855     device->rev_tex_unit_map[unit] = stage;
2856     if (j != WINED3D_UNMAPPED_STAGE && j != unit)
2857         device->rev_tex_unit_map[j] = WINED3D_UNMAPPED_STAGE;
2858 }
2859
2860 static void device_update_fixed_function_usage_map(struct wined3d_device *device)
2861 {
2862     UINT i;
2863
2864     device->fixed_function_usage_map = 0;
2865     for (i = 0; i < MAX_TEXTURES; ++i)
2866     {
2867         const struct wined3d_state *state = &device->stateBlock->state;
2868         WINED3DTEXTUREOP color_op = state->texture_states[i][WINED3DTSS_COLOROP];
2869         WINED3DTEXTUREOP alpha_op = state->texture_states[i][WINED3DTSS_ALPHAOP];
2870         DWORD color_arg1 = state->texture_states[i][WINED3DTSS_COLORARG1] & WINED3DTA_SELECTMASK;
2871         DWORD color_arg2 = state->texture_states[i][WINED3DTSS_COLORARG2] & WINED3DTA_SELECTMASK;
2872         DWORD color_arg3 = state->texture_states[i][WINED3DTSS_COLORARG0] & WINED3DTA_SELECTMASK;
2873         DWORD alpha_arg1 = state->texture_states[i][WINED3DTSS_ALPHAARG1] & WINED3DTA_SELECTMASK;
2874         DWORD alpha_arg2 = state->texture_states[i][WINED3DTSS_ALPHAARG2] & WINED3DTA_SELECTMASK;
2875         DWORD alpha_arg3 = state->texture_states[i][WINED3DTSS_ALPHAARG0] & WINED3DTA_SELECTMASK;
2876
2877         if (color_op == WINED3DTOP_DISABLE) {
2878             /* Not used, and disable higher stages */
2879             break;
2880         }
2881
2882         if (((color_arg1 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG2)
2883                 || ((color_arg2 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG1)
2884                 || ((color_arg3 == WINED3DTA_TEXTURE)
2885                     && (color_op == WINED3DTOP_MULTIPLYADD || color_op == WINED3DTOP_LERP))
2886                 || ((alpha_arg1 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG2)
2887                 || ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG1)
2888                 || ((alpha_arg3 == WINED3DTA_TEXTURE)
2889                     && (alpha_op == WINED3DTOP_MULTIPLYADD || alpha_op == WINED3DTOP_LERP)))
2890             device->fixed_function_usage_map |= (1 << i);
2891
2892         if ((color_op == WINED3DTOP_BUMPENVMAP || color_op == WINED3DTOP_BUMPENVMAPLUMINANCE) && i < MAX_TEXTURES - 1)
2893             device->fixed_function_usage_map |= (1 << (i + 1));
2894     }
2895 }
2896
2897 static void device_map_fixed_function_samplers(struct wined3d_device *device, const struct wined3d_gl_info *gl_info)
2898 {
2899     unsigned int i, tex;
2900     WORD ffu_map;
2901
2902     device_update_fixed_function_usage_map(device);
2903     ffu_map = device->fixed_function_usage_map;
2904
2905     if (device->max_ffp_textures == gl_info->limits.texture_stages
2906             || device->stateBlock->state.lowest_disabled_stage <= device->max_ffp_textures)
2907     {
2908         for (i = 0; ffu_map; ffu_map >>= 1, ++i)
2909         {
2910             if (!(ffu_map & 1)) continue;
2911
2912             if (device->texUnitMap[i] != i)
2913             {
2914                 device_map_stage(device, i, i);
2915                 device_invalidate_state(device, STATE_SAMPLER(i));
2916                 device_invalidate_texture_stage(device, i);
2917             }
2918         }
2919         return;
2920     }
2921
2922     /* Now work out the mapping */
2923     tex = 0;
2924     for (i = 0; ffu_map; ffu_map >>= 1, ++i)
2925     {
2926         if (!(ffu_map & 1)) continue;
2927
2928         if (device->texUnitMap[i] != tex)
2929         {
2930             device_map_stage(device, i, tex);
2931             device_invalidate_state(device, STATE_SAMPLER(i));
2932             device_invalidate_texture_stage(device, i);
2933         }
2934
2935         ++tex;
2936     }
2937 }
2938
2939 static void device_map_psamplers(struct wined3d_device *device, const struct wined3d_gl_info *gl_info)
2940 {
2941     const WINED3DSAMPLER_TEXTURE_TYPE *sampler_type =
2942             device->stateBlock->state.pixel_shader->reg_maps.sampler_type;
2943     unsigned int i;
2944
2945     for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
2946     {
2947         if (sampler_type[i] && device->texUnitMap[i] != i)
2948         {
2949             device_map_stage(device, i, i);
2950             device_invalidate_state(device, STATE_SAMPLER(i));
2951             if (i < gl_info->limits.texture_stages)
2952                 device_invalidate_texture_stage(device, i);
2953         }
2954     }
2955 }
2956
2957 static BOOL device_unit_free_for_vs(const struct wined3d_device *device,
2958         const WINED3DSAMPLER_TEXTURE_TYPE *pshader_sampler_tokens,
2959         const WINED3DSAMPLER_TEXTURE_TYPE *vshader_sampler_tokens, DWORD unit)
2960 {
2961     DWORD current_mapping = device->rev_tex_unit_map[unit];
2962
2963     /* Not currently used */
2964     if (current_mapping == WINED3D_UNMAPPED_STAGE) return TRUE;
2965
2966     if (current_mapping < MAX_FRAGMENT_SAMPLERS) {
2967         /* Used by a fragment sampler */
2968
2969         if (!pshader_sampler_tokens) {
2970             /* No pixel shader, check fixed function */
2971             return current_mapping >= MAX_TEXTURES || !(device->fixed_function_usage_map & (1 << current_mapping));
2972         }
2973
2974         /* Pixel shader, check the shader's sampler map */
2975         return !pshader_sampler_tokens[current_mapping];
2976     }
2977
2978     /* Used by a vertex sampler */
2979     return !vshader_sampler_tokens[current_mapping - MAX_FRAGMENT_SAMPLERS];
2980 }
2981
2982 static void device_map_vsamplers(struct wined3d_device *device, BOOL ps, const struct wined3d_gl_info *gl_info)
2983 {
2984     const WINED3DSAMPLER_TEXTURE_TYPE *vshader_sampler_type =
2985             device->stateBlock->state.vertex_shader->reg_maps.sampler_type;
2986     const WINED3DSAMPLER_TEXTURE_TYPE *pshader_sampler_type = NULL;
2987     int start = min(MAX_COMBINED_SAMPLERS, gl_info->limits.combined_samplers) - 1;
2988     int i;
2989
2990     if (ps)
2991     {
2992         /* Note that we only care if a sampler is sampled or not, not the sampler's specific type.
2993          * Otherwise we'd need to call shader_update_samplers() here for 1.x pixelshaders. */
2994         pshader_sampler_type = device->stateBlock->state.pixel_shader->reg_maps.sampler_type;
2995     }
2996
2997     for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
2998         DWORD vsampler_idx = i + MAX_FRAGMENT_SAMPLERS;
2999         if (vshader_sampler_type[i])
3000         {
3001             if (device->texUnitMap[vsampler_idx] != WINED3D_UNMAPPED_STAGE)
3002             {
3003                 /* Already mapped somewhere */
3004                 continue;
3005             }
3006
3007             while (start >= 0)
3008             {
3009                 if (device_unit_free_for_vs(device, pshader_sampler_type, vshader_sampler_type, start))
3010                 {
3011                     device_map_stage(device, vsampler_idx, start);
3012                     device_invalidate_state(device, STATE_SAMPLER(vsampler_idx));
3013
3014                     --start;
3015                     break;
3016                 }
3017
3018                 --start;
3019             }
3020         }
3021     }
3022 }
3023
3024 void device_update_tex_unit_map(struct wined3d_device *device)
3025 {
3026     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
3027     const struct wined3d_state *state = &device->stateBlock->state;
3028     BOOL vs = use_vs(state);
3029     BOOL ps = use_ps(state);
3030     /*
3031      * Rules are:
3032      * -> Pixel shaders need a 1:1 map. In theory the shader input could be mapped too, but
3033      * that would be really messy and require shader recompilation
3034      * -> When the mapping of a stage is changed, sampler and ALL texture stage states have
3035      * to be reset. Because of that try to work with a 1:1 mapping as much as possible
3036      */
3037     if (ps)
3038         device_map_psamplers(device, gl_info);
3039     else
3040         device_map_fixed_function_samplers(device, gl_info);
3041
3042     if (vs)
3043         device_map_vsamplers(device, ps, gl_info);
3044 }
3045
3046 HRESULT CDECL wined3d_device_set_pixel_shader(struct wined3d_device *device, struct wined3d_shader *shader)
3047 {
3048     struct wined3d_shader *prev = device->updateStateBlock->state.pixel_shader;
3049
3050     TRACE("device %p, shader %p.\n", device, shader);
3051
3052     device->updateStateBlock->state.pixel_shader = shader;
3053     device->updateStateBlock->changed.pixelShader = TRUE;
3054
3055     if (device->isRecordingState)
3056     {
3057         if (shader)
3058             wined3d_shader_incref(shader);
3059         if (prev)
3060             wined3d_shader_decref(prev);
3061         TRACE("Recording... not performing anything.\n");
3062         return WINED3D_OK;
3063     }
3064
3065     if (shader == prev)
3066     {
3067         TRACE("Application is setting the old shader over, nothing to do.\n");
3068         return WINED3D_OK;
3069     }
3070
3071     if (shader)
3072         wined3d_shader_incref(shader);
3073     if (prev)
3074         wined3d_shader_decref(prev);
3075
3076     device_invalidate_state(device, STATE_PIXELSHADER);
3077
3078     return WINED3D_OK;
3079 }
3080
3081 struct wined3d_shader * CDECL wined3d_device_get_pixel_shader(const struct wined3d_device *device)
3082 {
3083     struct wined3d_shader *shader;
3084
3085     TRACE("device %p.\n", device);
3086
3087     shader = device->stateBlock->state.pixel_shader;
3088     if (shader)
3089         wined3d_shader_incref(shader);
3090
3091     TRACE("Returning %p.\n", shader);
3092     return shader;
3093 }
3094
3095 HRESULT CDECL wined3d_device_set_ps_consts_b(struct wined3d_device *device,
3096         UINT start_register, const BOOL *constants, UINT bool_count)
3097 {
3098     UINT count = min(bool_count, MAX_CONST_B - start_register);
3099     UINT i;
3100
3101     TRACE("device %p, start_register %u, constants %p, bool_count %u.\n",
3102             device, start_register, constants, bool_count);
3103
3104     if (!constants || start_register >= MAX_CONST_B)
3105         return WINED3DERR_INVALIDCALL;
3106
3107     memcpy(&device->updateStateBlock->state.ps_consts_b[start_register], constants, count * sizeof(BOOL));
3108     for (i = 0; i < count; ++i)
3109         TRACE("Set BOOL constant %u to %s.\n", start_register + i, constants[i] ? "true" : "false");
3110
3111     for (i = start_register; i < count + start_register; ++i)
3112         device->updateStateBlock->changed.pixelShaderConstantsB |= (1 << i);
3113
3114     if (!device->isRecordingState)
3115         device_invalidate_state(device, STATE_PIXELSHADERCONSTANT);
3116
3117     return WINED3D_OK;
3118 }
3119
3120 HRESULT CDECL wined3d_device_get_ps_consts_b(struct wined3d_device *device,
3121         UINT start_register, BOOL *constants, UINT bool_count)
3122 {
3123     UINT count = min(bool_count, MAX_CONST_B - start_register);
3124
3125     TRACE("device %p, start_register %u, constants %p, bool_count %u.\n",
3126             device, start_register, constants, bool_count);
3127
3128     if (!constants || start_register >= MAX_CONST_B)
3129         return WINED3DERR_INVALIDCALL;
3130
3131     memcpy(constants, &device->stateBlock->state.ps_consts_b[start_register], count * sizeof(BOOL));
3132
3133     return WINED3D_OK;
3134 }
3135
3136 HRESULT CDECL wined3d_device_set_ps_consts_i(struct wined3d_device *device,
3137         UINT start_register, const int *constants, UINT vector4i_count)
3138 {
3139     UINT count = min(vector4i_count, MAX_CONST_I - start_register);
3140     UINT i;
3141
3142     TRACE("device %p, start_register %u, constants %p, vector4i_count %u.\n",
3143             device, start_register, constants, vector4i_count);
3144
3145     if (!constants || start_register >= MAX_CONST_I)
3146         return WINED3DERR_INVALIDCALL;
3147
3148     memcpy(&device->updateStateBlock->state.ps_consts_i[start_register * 4], constants, count * sizeof(int) * 4);
3149     for (i = 0; i < count; ++i)
3150         TRACE("Set INT constant %u to {%d, %d, %d, %d}.\n", start_register + i,
3151                 constants[i * 4], constants[i * 4 + 1],
3152                 constants[i * 4 + 2], constants[i * 4 + 3]);
3153
3154     for (i = start_register; i < count + start_register; ++i)
3155         device->updateStateBlock->changed.pixelShaderConstantsI |= (1 << i);
3156
3157     if (!device->isRecordingState)
3158         device_invalidate_state(device, STATE_PIXELSHADERCONSTANT);
3159
3160     return WINED3D_OK;
3161 }
3162
3163 HRESULT CDECL wined3d_device_get_ps_consts_i(struct wined3d_device *device,
3164         UINT start_register, int *constants, UINT vector4i_count)
3165 {
3166     UINT count = min(vector4i_count, MAX_CONST_I - start_register);
3167
3168     TRACE("device %p, start_register %u, constants %p, vector4i_count %u.\n",
3169             device, start_register, constants, vector4i_count);
3170
3171     if (!constants || start_register >= MAX_CONST_I)
3172         return WINED3DERR_INVALIDCALL;
3173
3174     memcpy(constants, &device->stateBlock->state.ps_consts_i[start_register * 4], count * sizeof(int) * 4);
3175
3176     return WINED3D_OK;
3177 }
3178
3179 HRESULT CDECL wined3d_device_set_ps_consts_f(struct wined3d_device *device,
3180         UINT start_register, const float *constants, UINT vector4f_count)
3181 {
3182     UINT i;
3183
3184     TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
3185             device, start_register, constants, vector4f_count);
3186
3187     /* Specifically test start_register > limit to catch MAX_UINT overflows
3188      * when adding start_register + vector4f_count. */
3189     if (!constants
3190             || start_register + vector4f_count > device->d3d_pshader_constantF
3191             || start_register > device->d3d_pshader_constantF)
3192         return WINED3DERR_INVALIDCALL;
3193
3194     memcpy(&device->updateStateBlock->state.ps_consts_f[start_register * 4],
3195             constants, vector4f_count * sizeof(float) * 4);
3196     if (TRACE_ON(d3d))
3197     {
3198         for (i = 0; i < vector4f_count; ++i)
3199             TRACE("Set FLOAT constant %u to {%.8e, %.8e, %.8e, %.8e}.\n", start_register + i,
3200                     constants[i * 4], constants[i * 4 + 1],
3201                     constants[i * 4 + 2], constants[i * 4 + 3]);
3202     }
3203
3204     if (!device->isRecordingState)
3205     {
3206         device->shader_backend->shader_update_float_pixel_constants(device, start_register, vector4f_count);
3207         device_invalidate_state(device, STATE_PIXELSHADERCONSTANT);
3208     }
3209
3210     memset(device->updateStateBlock->changed.pixelShaderConstantsF + start_register, 1,
3211             sizeof(*device->updateStateBlock->changed.pixelShaderConstantsF) * vector4f_count);
3212
3213     return WINED3D_OK;
3214 }
3215
3216 HRESULT CDECL wined3d_device_get_ps_consts_f(struct wined3d_device *device,
3217         UINT start_register, float *constants, UINT vector4f_count)
3218 {
3219     int count = min(vector4f_count, device->d3d_pshader_constantF - start_register);
3220
3221     TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
3222             device, start_register, constants, vector4f_count);
3223
3224     if (!constants || count < 0)
3225         return WINED3DERR_INVALIDCALL;
3226
3227     memcpy(constants, &device->stateBlock->state.ps_consts_f[start_register * 4], count * sizeof(float) * 4);
3228
3229     return WINED3D_OK;
3230 }
3231
3232 /* Context activation is done by the caller. */
3233 /* Do not call while under the GL lock. */
3234 #define copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size)
3235 static HRESULT process_vertices_strided(struct wined3d_device *device, DWORD dwDestIndex, DWORD dwCount,
3236         const struct wined3d_stream_info *stream_info, struct wined3d_buffer *dest, DWORD flags,
3237         DWORD DestFVF)
3238 {
3239     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
3240     char *dest_ptr, *dest_conv = NULL, *dest_conv_addr = NULL;
3241     unsigned int i;
3242     WINED3DVIEWPORT vp;
3243     WINED3DMATRIX mat, proj_mat, view_mat, world_mat;
3244     BOOL doClip;
3245     DWORD numTextures;
3246
3247     if (stream_info->use_map & (1 << WINED3D_FFP_NORMAL))
3248     {
3249         WARN(" lighting state not saved yet... Some strange stuff may happen !\n");
3250     }
3251
3252     if (!(stream_info->use_map & (1 << WINED3D_FFP_POSITION)))
3253     {
3254         ERR("Source has no position mask\n");
3255         return WINED3DERR_INVALIDCALL;
3256     }
3257
3258     if (!dest->resource.allocatedMemory)
3259         buffer_get_sysmem(dest, gl_info);
3260
3261     /* Get a pointer into the destination vbo(create one if none exists) and
3262      * write correct opengl data into it. It's cheap and allows us to run drawStridedFast
3263      */
3264     if (!dest->buffer_object && gl_info->supported[ARB_VERTEX_BUFFER_OBJECT])
3265     {
3266         dest->flags |= WINED3D_BUFFER_CREATEBO;
3267         wined3d_buffer_preload(dest);
3268     }
3269
3270     if (dest->buffer_object)
3271     {
3272         unsigned char extrabytes = 0;
3273         /* If the destination vertex buffer has D3DFVF_XYZ position(non-rhw), native d3d writes RHW position, where the RHW
3274          * gets written into the 4 bytes after the Z position. In the case of a dest buffer that only has D3DFVF_XYZ data,
3275          * this may write 4 extra bytes beyond the area that should be written
3276          */
3277         if(DestFVF == WINED3DFVF_XYZ) extrabytes = 4;
3278         dest_conv_addr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwCount * get_flexible_vertex_size(DestFVF) + extrabytes);
3279         if(!dest_conv_addr) {
3280             ERR("Out of memory\n");
3281             /* Continue without storing converted vertices */
3282         }
3283         dest_conv = dest_conv_addr;
3284     }
3285
3286     if (device->stateBlock->state.render_states[WINED3DRS_CLIPPING])
3287     {
3288         static BOOL warned = FALSE;
3289         /*
3290          * The clipping code is not quite correct. Some things need
3291          * to be checked against IDirect3DDevice3 (!), d3d8 and d3d9,
3292          * so disable clipping for now.
3293          * (The graphics in Half-Life are broken, and my processvertices
3294          *  test crashes with IDirect3DDevice3)
3295         doClip = TRUE;
3296          */
3297         doClip = FALSE;
3298         if(!warned) {
3299            warned = TRUE;
3300            FIXME("Clipping is broken and disabled for now\n");
3301         }
3302     } else doClip = FALSE;
3303     dest_ptr = ((char *)buffer_get_sysmem(dest, gl_info)) + dwDestIndex * get_flexible_vertex_size(DestFVF);
3304
3305     wined3d_device_get_transform(device, WINED3DTS_VIEW, &view_mat);
3306     wined3d_device_get_transform(device, WINED3DTS_PROJECTION, &proj_mat);
3307     wined3d_device_get_transform(device, WINED3DTS_WORLDMATRIX(0), &world_mat);
3308
3309     TRACE("View mat:\n");
3310     TRACE("%f %f %f %f\n", view_mat.u.s._11, view_mat.u.s._12, view_mat.u.s._13, view_mat.u.s._14);
3311     TRACE("%f %f %f %f\n", view_mat.u.s._21, view_mat.u.s._22, view_mat.u.s._23, view_mat.u.s._24);
3312     TRACE("%f %f %f %f\n", view_mat.u.s._31, view_mat.u.s._32, view_mat.u.s._33, view_mat.u.s._34);
3313     TRACE("%f %f %f %f\n", view_mat.u.s._41, view_mat.u.s._42, view_mat.u.s._43, view_mat.u.s._44);
3314
3315     TRACE("Proj mat:\n");
3316     TRACE("%f %f %f %f\n", proj_mat.u.s._11, proj_mat.u.s._12, proj_mat.u.s._13, proj_mat.u.s._14);
3317     TRACE("%f %f %f %f\n", proj_mat.u.s._21, proj_mat.u.s._22, proj_mat.u.s._23, proj_mat.u.s._24);
3318     TRACE("%f %f %f %f\n", proj_mat.u.s._31, proj_mat.u.s._32, proj_mat.u.s._33, proj_mat.u.s._34);
3319     TRACE("%f %f %f %f\n", proj_mat.u.s._41, proj_mat.u.s._42, proj_mat.u.s._43, proj_mat.u.s._44);
3320
3321     TRACE("World mat:\n");
3322     TRACE("%f %f %f %f\n", world_mat.u.s._11, world_mat.u.s._12, world_mat.u.s._13, world_mat.u.s._14);
3323     TRACE("%f %f %f %f\n", world_mat.u.s._21, world_mat.u.s._22, world_mat.u.s._23, world_mat.u.s._24);
3324     TRACE("%f %f %f %f\n", world_mat.u.s._31, world_mat.u.s._32, world_mat.u.s._33, world_mat.u.s._34);
3325     TRACE("%f %f %f %f\n", world_mat.u.s._41, world_mat.u.s._42, world_mat.u.s._43, world_mat.u.s._44);
3326
3327     /* Get the viewport */
3328     wined3d_device_get_viewport(device, &vp);
3329     TRACE("Viewport: X=%d, Y=%d, Width=%d, Height=%d, MinZ=%f, MaxZ=%f\n",
3330           vp.X, vp.Y, vp.Width, vp.Height, vp.MinZ, vp.MaxZ);
3331
3332     multiply_matrix(&mat,&view_mat,&world_mat);
3333     multiply_matrix(&mat,&proj_mat,&mat);
3334
3335     numTextures = (DestFVF & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
3336
3337     for (i = 0; i < dwCount; i+= 1) {
3338         unsigned int tex_index;
3339
3340         if ( ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZ ) ||
3341              ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) ) {
3342             /* The position first */
3343             const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_POSITION];
3344             const float *p = (const float *)(element->data.addr + i * element->stride);
3345             float x, y, z, rhw;
3346             TRACE("In: ( %06.2f %06.2f %06.2f )\n", p[0], p[1], p[2]);
3347
3348             /* Multiplication with world, view and projection matrix */
3349             x =   (p[0] * mat.u.s._11) + (p[1] * mat.u.s._21) + (p[2] * mat.u.s._31) + (1.0f * mat.u.s._41);
3350             y =   (p[0] * mat.u.s._12) + (p[1] * mat.u.s._22) + (p[2] * mat.u.s._32) + (1.0f * mat.u.s._42);
3351             z =   (p[0] * mat.u.s._13) + (p[1] * mat.u.s._23) + (p[2] * mat.u.s._33) + (1.0f * mat.u.s._43);
3352             rhw = (p[0] * mat.u.s._14) + (p[1] * mat.u.s._24) + (p[2] * mat.u.s._34) + (1.0f * mat.u.s._44);
3353
3354             TRACE("x=%f y=%f z=%f rhw=%f\n", x, y, z, rhw);
3355
3356             /* WARNING: The following things are taken from d3d7 and were not yet checked
3357              * against d3d8 or d3d9!
3358              */
3359
3360             /* Clipping conditions: From msdn
3361              *
3362              * A vertex is clipped if it does not match the following requirements
3363              * -rhw < x <= rhw
3364              * -rhw < y <= rhw
3365              *    0 < z <= rhw
3366              *    0 < rhw ( Not in d3d7, but tested in d3d7)
3367              *
3368              * If clipping is on is determined by the D3DVOP_CLIP flag in D3D7, and
3369              * by the D3DRS_CLIPPING in D3D9(according to the msdn, not checked)
3370              *
3371              */
3372
3373             if( !doClip ||
3374                 ( (-rhw -eps < x) && (-rhw -eps < y) && ( -eps < z) &&
3375                   (x <= rhw + eps) && (y <= rhw + eps ) && (z <= rhw + eps) &&
3376                   ( rhw > eps ) ) ) {
3377
3378                 /* "Normal" viewport transformation (not clipped)
3379                  * 1) The values are divided by rhw
3380                  * 2) The y axis is negative, so multiply it with -1
3381                  * 3) Screen coordinates go from -(Width/2) to +(Width/2) and
3382                  *    -(Height/2) to +(Height/2). The z range is MinZ to MaxZ
3383                  * 4) Multiply x with Width/2 and add Width/2
3384                  * 5) The same for the height
3385                  * 6) Add the viewpoint X and Y to the 2D coordinates and
3386                  *    The minimum Z value to z
3387                  * 7) rhw = 1 / rhw Reciprocal of Homogeneous W....
3388                  *
3389                  * Well, basically it's simply a linear transformation into viewport
3390                  * coordinates
3391                  */
3392
3393                 x /= rhw;
3394                 y /= rhw;
3395                 z /= rhw;
3396
3397                 y *= -1;
3398
3399                 x *= vp.Width / 2;
3400                 y *= vp.Height / 2;
3401                 z *= vp.MaxZ - vp.MinZ;
3402
3403                 x += vp.Width / 2 + vp.X;
3404                 y += vp.Height / 2 + vp.Y;
3405                 z += vp.MinZ;
3406
3407                 rhw = 1 / rhw;
3408             } else {
3409                 /* That vertex got clipped
3410                  * Contrary to OpenGL it is not dropped completely, it just
3411                  * undergoes a different calculation.
3412                  */
3413                 TRACE("Vertex got clipped\n");
3414                 x += rhw;
3415                 y += rhw;
3416
3417                 x  /= 2;
3418                 y  /= 2;
3419
3420                 /* Msdn mentions that Direct3D9 keeps a list of clipped vertices
3421                  * outside of the main vertex buffer memory. That needs some more
3422                  * investigation...
3423                  */
3424             }
3425
3426             TRACE("Writing (%f %f %f) %f\n", x, y, z, rhw);
3427
3428
3429             ( (float *) dest_ptr)[0] = x;
3430             ( (float *) dest_ptr)[1] = y;
3431             ( (float *) dest_ptr)[2] = z;
3432             ( (float *) dest_ptr)[3] = rhw; /* SIC, see ddraw test! */
3433
3434             dest_ptr += 3 * sizeof(float);
3435
3436             if((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) {
3437                 dest_ptr += sizeof(float);
3438             }
3439
3440             if(dest_conv) {
3441                 float w = 1 / rhw;
3442                 ( (float *) dest_conv)[0] = x * w;
3443                 ( (float *) dest_conv)[1] = y * w;
3444                 ( (float *) dest_conv)[2] = z * w;
3445                 ( (float *) dest_conv)[3] = w;
3446
3447                 dest_conv += 3 * sizeof(float);
3448
3449                 if((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) {
3450                     dest_conv += sizeof(float);
3451                 }
3452             }
3453         }
3454         if (DestFVF & WINED3DFVF_PSIZE) {
3455             dest_ptr += sizeof(DWORD);
3456             if(dest_conv) dest_conv += sizeof(DWORD);
3457         }
3458         if (DestFVF & WINED3DFVF_NORMAL)
3459         {
3460             const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_NORMAL];
3461             const float *normal = (const float *)(element->data.addr + i * element->stride);
3462             /* AFAIK this should go into the lighting information */
3463             FIXME("Didn't expect the destination to have a normal\n");
3464             copy_and_next(dest_ptr, normal, 3 * sizeof(float));
3465             if(dest_conv) {
3466                 copy_and_next(dest_conv, normal, 3 * sizeof(float));
3467             }
3468         }
3469
3470         if (DestFVF & WINED3DFVF_DIFFUSE)
3471         {
3472             const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_DIFFUSE];
3473             const DWORD *color_d = (const DWORD *)(element->data.addr + i * element->stride);
3474             if (!(stream_info->use_map & (1 << WINED3D_FFP_DIFFUSE)))
3475             {
3476                 static BOOL warned = FALSE;
3477
3478                 if(!warned) {
3479                     ERR("No diffuse color in source, but destination has one\n");
3480                     warned = TRUE;
3481                 }
3482
3483                 *( (DWORD *) dest_ptr) = 0xffffffff;
3484                 dest_ptr += sizeof(DWORD);
3485
3486                 if(dest_conv) {
3487                     *( (DWORD *) dest_conv) = 0xffffffff;
3488                     dest_conv += sizeof(DWORD);
3489                 }
3490             }
3491             else {
3492                 copy_and_next(dest_ptr, color_d, sizeof(DWORD));
3493                 if(dest_conv) {
3494                     *( (DWORD *) dest_conv)  = (*color_d & 0xff00ff00)      ; /* Alpha + green */
3495                     *( (DWORD *) dest_conv) |= (*color_d & 0x00ff0000) >> 16; /* Red */
3496                     *( (DWORD *) dest_conv) |= (*color_d & 0xff0000ff) << 16; /* Blue */
3497                     dest_conv += sizeof(DWORD);
3498                 }
3499             }
3500         }
3501
3502         if (DestFVF & WINED3DFVF_SPECULAR)
3503         {
3504             /* What's the color value in the feedback buffer? */
3505             const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_SPECULAR];
3506             const DWORD *color_s = (const DWORD *)(element->data.addr + i * element->stride);
3507             if (!(stream_info->use_map & (1 << WINED3D_FFP_SPECULAR)))
3508             {
3509                 static BOOL warned = FALSE;
3510
3511                 if(!warned) {
3512                     ERR("No specular color in source, but destination has one\n");
3513                     warned = TRUE;
3514                 }
3515
3516                 *( (DWORD *) dest_ptr) = 0xFF000000;
3517                 dest_ptr += sizeof(DWORD);
3518
3519                 if(dest_conv) {
3520                     *( (DWORD *) dest_conv) = 0xFF000000;
3521                     dest_conv += sizeof(DWORD);
3522                 }
3523             }
3524             else {
3525                 copy_and_next(dest_ptr, color_s, sizeof(DWORD));
3526                 if(dest_conv) {
3527                     *( (DWORD *) dest_conv)  = (*color_s & 0xff00ff00)      ; /* Alpha + green */
3528                     *( (DWORD *) dest_conv) |= (*color_s & 0x00ff0000) >> 16; /* Red */
3529                     *( (DWORD *) dest_conv) |= (*color_s & 0xff0000ff) << 16; /* Blue */
3530                     dest_conv += sizeof(DWORD);
3531                 }
3532             }
3533         }
3534
3535         for (tex_index = 0; tex_index < numTextures; ++tex_index)
3536         {
3537             const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_TEXCOORD0 + tex_index];
3538             const float *tex_coord = (const float *)(element->data.addr + i * element->stride);
3539             if (!(stream_info->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + tex_index))))
3540             {
3541                 ERR("No source texture, but destination requests one\n");
3542                 dest_ptr+=GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
3543                 if(dest_conv) dest_conv += GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
3544             }
3545             else {
3546                 copy_and_next(dest_ptr, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
3547                 if(dest_conv) {
3548                     copy_and_next(dest_conv, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
3549                 }
3550             }
3551         }
3552     }
3553
3554     if (dest_conv)
3555     {
3556         ENTER_GL();
3557
3558         GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, dest->buffer_object));
3559         checkGLcall("glBindBufferARB(GL_ARRAY_BUFFER_ARB)");
3560         GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, dwDestIndex * get_flexible_vertex_size(DestFVF),
3561                                       dwCount * get_flexible_vertex_size(DestFVF),
3562                                       dest_conv_addr));
3563         checkGLcall("glBufferSubDataARB(GL_ARRAY_BUFFER_ARB)");
3564
3565         LEAVE_GL();
3566
3567         HeapFree(GetProcessHeap(), 0, dest_conv_addr);
3568     }
3569
3570     return WINED3D_OK;
3571 }
3572 #undef copy_and_next
3573
3574 /* Do not call while under the GL lock. */
3575 HRESULT CDECL wined3d_device_process_vertices(struct wined3d_device *device,
3576         UINT src_start_idx, UINT dst_idx, UINT vertex_count, struct wined3d_buffer *dst_buffer,
3577         struct wined3d_vertex_declaration *declaration, DWORD flags, DWORD dst_fvf)
3578 {
3579     struct wined3d_state *state = &device->stateBlock->state;
3580     BOOL vbo = FALSE, streamWasUP = state->user_stream;
3581     struct wined3d_stream_info stream_info;
3582     const struct wined3d_gl_info *gl_info;
3583     struct wined3d_context *context;
3584     struct wined3d_shader *vs;
3585     HRESULT hr;
3586
3587     TRACE("device %p, src_start_idx %u, dst_idx %u, vertex_count %u, "
3588             "dst_buffer %p, declaration %p, flags %#x, dst_fvf %#x.\n",
3589             device, src_start_idx, dst_idx, vertex_count,
3590             dst_buffer, declaration, flags, dst_fvf);
3591
3592     if (declaration)
3593         FIXME("Output vertex declaration not implemented yet.\n");
3594
3595     /* Need any context to write to the vbo. */
3596     context = context_acquire(device, NULL);
3597     gl_info = context->gl_info;
3598
3599     /* ProcessVertices reads from vertex buffers, which have to be assigned.
3600      * DrawPrimitive and DrawPrimitiveUP control the streamIsUP flag, thus
3601      * restore it afterwards. */
3602     vs = state->vertex_shader;
3603     state->vertex_shader = NULL;
3604     state->user_stream = FALSE;
3605     device_stream_info_from_declaration(device, &stream_info, &vbo);
3606     state->user_stream = streamWasUP;
3607     state->vertex_shader = vs;
3608
3609     if (vbo || src_start_idx)
3610     {
3611         unsigned int i;
3612         /* ProcessVertices can't convert FROM a vbo, and vertex buffers used to source into ProcessVertices are
3613          * unlikely to ever be used for drawing. Release vbos in those buffers and fix up the stream_info structure
3614          *
3615          * Also get the start index in, but only loop over all elements if there's something to add at all.
3616          */
3617         for (i = 0; i < (sizeof(stream_info.elements) / sizeof(*stream_info.elements)); ++i)
3618         {
3619             struct wined3d_stream_info_element *e;
3620
3621             if (!(stream_info.use_map & (1 << i))) continue;
3622
3623             e = &stream_info.elements[i];
3624             if (e->data.buffer_object)
3625             {
3626                 struct wined3d_buffer *vb = state->streams[e->stream_idx].buffer;
3627                 e->data.buffer_object = 0;
3628                 e->data.addr = (BYTE *)((ULONG_PTR)e->data.addr + (ULONG_PTR)buffer_get_sysmem(vb, gl_info));
3629                 ENTER_GL();
3630                 GL_EXTCALL(glDeleteBuffersARB(1, &vb->buffer_object));
3631                 vb->buffer_object = 0;
3632                 LEAVE_GL();
3633             }
3634             if (e->data.addr)
3635                 e->data.addr += e->stride * src_start_idx;
3636         }
3637     }
3638
3639     hr = process_vertices_strided(device, dst_idx, vertex_count,
3640             &stream_info, dst_buffer, flags, dst_fvf);
3641
3642     context_release(context);
3643
3644     return hr;
3645 }
3646
3647 HRESULT CDECL wined3d_device_set_texture_stage_state(struct wined3d_device *device,
3648         UINT stage, WINED3DTEXTURESTAGESTATETYPE state, DWORD value)
3649 {
3650     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
3651     DWORD old_value;
3652
3653     TRACE("device %p, stage %u, state %s, value %#x.\n",
3654             device, stage, debug_d3dtexturestate(state), value);
3655
3656     if (state > WINED3D_HIGHEST_TEXTURE_STATE)
3657     {
3658         WARN("Invalid state %#x passed.\n", state);
3659         return WINED3D_OK;
3660     }
3661
3662     if (stage >= gl_info->limits.texture_stages)
3663     {
3664         WARN("Attempting to set stage %u which is higher than the max stage %u, ignoring.\n",
3665                 stage, gl_info->limits.texture_stages - 1);
3666         return WINED3D_OK;
3667     }
3668
3669     old_value = device->updateStateBlock->state.texture_states[stage][state];
3670     device->updateStateBlock->changed.textureState[stage] |= 1 << state;
3671     device->updateStateBlock->state.texture_states[stage][state] = value;
3672
3673     if (device->isRecordingState)
3674     {
3675         TRACE("Recording... not performing anything.\n");
3676         return WINED3D_OK;
3677     }
3678
3679     /* Checked after the assignments to allow proper stateblock recording. */
3680     if (old_value == value)
3681     {
3682         TRACE("Application is setting the old value over, nothing to do.\n");
3683         return WINED3D_OK;
3684     }
3685
3686     if (stage > device->stateBlock->state.lowest_disabled_stage
3687             && device->StateTable[STATE_TEXTURESTAGE(0, state)].representative
3688             == STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP))
3689     {
3690         /* Colorop change above lowest disabled stage? That won't change
3691          * anything in the GL setup. Changes in other states are important on
3692          * disabled stages too. */
3693         return WINED3D_OK;
3694     }
3695
3696     if (state == WINED3DTSS_COLOROP)
3697     {
3698         unsigned int i;
3699
3700         if (value == WINED3DTOP_DISABLE && old_value != WINED3DTOP_DISABLE)
3701         {
3702             /* Previously enabled stage disabled now. Make sure to dirtify
3703              * all enabled stages above stage, they have to be disabled.
3704              *
3705              * The current stage is dirtified below. */
3706             for (i = stage + 1; i < device->stateBlock->state.lowest_disabled_stage; ++i)
3707             {
3708                 TRACE("Additionally dirtifying stage %u.\n", i);
3709                 device_invalidate_state(device, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
3710             }
3711             device->stateBlock->state.lowest_disabled_stage = stage;
3712             TRACE("New lowest disabled: %u.\n", stage);
3713         }
3714         else if (value != WINED3DTOP_DISABLE && old_value == WINED3DTOP_DISABLE)
3715         {
3716             /* Previously disabled stage enabled. Stages above it may need
3717              * enabling. Stage must be lowest_disabled_stage here, if it's
3718              * bigger success is returned above, and stages below the lowest
3719              * disabled stage can't be enabled (because they are enabled
3720              * already).
3721              *
3722              * Again stage stage doesn't need to be dirtified here, it is
3723              * handled below. */
3724             for (i = stage + 1; i < gl_info->limits.texture_stages; ++i)
3725             {
3726                 if (device->updateStateBlock->state.texture_states[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE)
3727                     break;
3728                 TRACE("Additionally dirtifying stage %u due to enable.\n", i);
3729                 device_invalidate_state(device, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
3730             }
3731             device->stateBlock->state.lowest_disabled_stage = i;
3732             TRACE("New lowest disabled: %u.\n", i);
3733         }
3734     }
3735
3736     device_invalidate_state(device, STATE_TEXTURESTAGE(stage, state));
3737
3738     return WINED3D_OK;
3739 }
3740
3741 HRESULT CDECL wined3d_device_get_texture_stage_state(struct wined3d_device *device,
3742         UINT stage, WINED3DTEXTURESTAGESTATETYPE state, DWORD *value)
3743 {
3744     TRACE("device %p, stage %u, state %s, value %p.\n",
3745             device, stage, debug_d3dtexturestate(state), value);
3746
3747     if (state > WINED3D_HIGHEST_TEXTURE_STATE)
3748     {
3749         WARN("Invalid state %#x passed.\n", state);
3750         return WINED3D_OK;
3751     }
3752
3753     *value = device->updateStateBlock->state.texture_states[stage][state];
3754     TRACE("Returning %#x.\n", *value);
3755
3756     return WINED3D_OK;
3757 }
3758
3759 HRESULT CDECL wined3d_device_set_texture(struct wined3d_device *device,
3760         UINT stage, struct wined3d_texture *texture)
3761 {
3762     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
3763     struct wined3d_texture *prev;
3764
3765     TRACE("device %p, stage %u, texture %p.\n", device, stage, texture);
3766
3767     if (stage >= WINED3DVERTEXTEXTURESAMPLER0 && stage <= WINED3DVERTEXTEXTURESAMPLER3)
3768         stage -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
3769
3770     /* Windows accepts overflowing this array... we do not. */
3771     if (stage >= sizeof(device->stateBlock->state.textures) / sizeof(*device->stateBlock->state.textures))
3772     {
3773         WARN("Ignoring invalid stage %u.\n", stage);
3774         return WINED3D_OK;
3775     }
3776
3777     /* SetTexture isn't allowed on textures in WINED3DPOOL_SCRATCH */
3778     if (texture && texture->resource.pool == WINED3DPOOL_SCRATCH)
3779     {
3780         WARN("Rejecting attempt to set scratch texture.\n");
3781         return WINED3DERR_INVALIDCALL;
3782     }
3783
3784     device->updateStateBlock->changed.textures |= 1 << stage;
3785
3786     prev = device->updateStateBlock->state.textures[stage];
3787     TRACE("Previous texture %p.\n", prev);
3788
3789     if (texture == prev)
3790     {
3791         TRACE("App is setting the same texture again, nothing to do.\n");
3792         return WINED3D_OK;
3793     }
3794
3795     TRACE("Setting new texture to %p.\n", texture);
3796     device->updateStateBlock->state.textures[stage] = texture;
3797
3798     if (device->isRecordingState)
3799     {
3800         TRACE("Recording... not performing anything\n");
3801
3802         if (texture) wined3d_texture_incref(texture);
3803         if (prev) wined3d_texture_decref(prev);
3804
3805         return WINED3D_OK;
3806     }
3807
3808     if (texture)
3809     {
3810         LONG bind_count = InterlockedIncrement(&texture->bind_count);
3811
3812         wined3d_texture_incref(texture);
3813
3814         if (!prev || texture->target != prev->target)
3815             device_invalidate_state(device, STATE_PIXELSHADER);
3816
3817         if (!prev && stage < gl_info->limits.texture_stages)
3818         {
3819             /* The source arguments for color and alpha ops have different
3820              * meanings when a NULL texture is bound, so the COLOROP and
3821              * ALPHAOP have to be dirtified. */
3822             device_invalidate_state(device, STATE_TEXTURESTAGE(stage, WINED3DTSS_COLOROP));
3823             device_invalidate_state(device, STATE_TEXTURESTAGE(stage, WINED3DTSS_ALPHAOP));
3824         }
3825
3826         if (bind_count == 1)
3827             texture->sampler = stage;
3828     }
3829
3830     if (prev)
3831     {
3832         LONG bind_count = InterlockedDecrement(&prev->bind_count);
3833
3834         wined3d_texture_decref(prev);
3835
3836         if (!texture && stage < gl_info->limits.texture_stages)
3837         {
3838             device_invalidate_state(device, STATE_TEXTURESTAGE(stage, WINED3DTSS_COLOROP));
3839             device_invalidate_state(device, STATE_TEXTURESTAGE(stage, WINED3DTSS_ALPHAOP));
3840         }
3841
3842         if (bind_count && prev->sampler == stage)
3843         {
3844             unsigned int i;
3845
3846             /* Search for other stages the texture is bound to. Shouldn't
3847              * happen if applications bind textures to a single stage only. */
3848             TRACE("Searching for other stages the texture is bound to.\n");
3849             for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
3850             {
3851                 if (device->updateStateBlock->state.textures[i] == prev)
3852                 {
3853                     TRACE("Texture is also bound to stage %u.\n", i);
3854                     prev->sampler = i;
3855                     break;
3856                 }
3857             }
3858         }
3859     }
3860
3861     device_invalidate_state(device, STATE_SAMPLER(stage));
3862
3863     return WINED3D_OK;
3864 }
3865
3866 HRESULT CDECL wined3d_device_get_texture(struct wined3d_device *device,
3867         UINT stage, struct wined3d_texture **texture)
3868 {
3869     TRACE("device %p, stage %u, texture %p.\n", device, stage, texture);
3870
3871     if (stage >= WINED3DVERTEXTEXTURESAMPLER0 && stage <= WINED3DVERTEXTEXTURESAMPLER3)
3872         stage -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
3873
3874     if (stage >= sizeof(device->stateBlock->state.textures) / sizeof(*device->stateBlock->state.textures))
3875     {
3876         WARN("Ignoring invalid stage %u.\n", stage);
3877         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
3878     }
3879
3880     *texture = device->stateBlock->state.textures[stage];
3881     if (*texture)
3882         wined3d_texture_incref(*texture);
3883
3884     TRACE("Returning %p.\n", *texture);
3885
3886     return WINED3D_OK;
3887 }
3888
3889 HRESULT CDECL wined3d_device_get_back_buffer(struct wined3d_device *device, UINT swapchain_idx,
3890         UINT backbuffer_idx, WINED3DBACKBUFFER_TYPE backbuffer_type, struct wined3d_surface **backbuffer)
3891 {
3892     struct wined3d_swapchain *swapchain;
3893     HRESULT hr;
3894
3895     TRACE("device %p, swapchain_idx %u, backbuffer_idx %u, backbuffer_type %#x, backbuffer %p.\n",
3896             device, swapchain_idx, backbuffer_idx, backbuffer_type, backbuffer);
3897
3898     hr = wined3d_device_get_swapchain(device, swapchain_idx, &swapchain);
3899     if (FAILED(hr))
3900     {
3901         WARN("Failed to get swapchain %u, hr %#x.\n", swapchain_idx, hr);
3902         return hr;
3903     }
3904
3905     hr = wined3d_swapchain_get_back_buffer(swapchain, backbuffer_idx, backbuffer_type, backbuffer);
3906     wined3d_swapchain_decref(swapchain);
3907     if (FAILED(hr))
3908     {
3909         WARN("Failed to get backbuffer %u, hr %#x.\n", backbuffer_idx, hr);
3910         return hr;
3911     }
3912
3913     return WINED3D_OK;
3914 }
3915
3916 HRESULT CDECL wined3d_device_get_device_caps(struct wined3d_device *device, WINED3DCAPS *caps)
3917 {
3918     TRACE("device %p, caps %p.\n", device, caps);
3919
3920     return wined3d_get_device_caps(device->wined3d, device->adapter->ordinal, device->devType, caps);
3921 }
3922
3923 HRESULT CDECL wined3d_device_get_display_mode(struct wined3d_device *device,
3924         UINT swapchain_idx, WINED3DDISPLAYMODE *mode)
3925 {
3926     struct wined3d_swapchain *swapchain;
3927     HRESULT hr;
3928
3929     TRACE("device %p, swapchain_idx %u, mode %p.\n", device, swapchain_idx, mode);
3930
3931     if (swapchain_idx)
3932     {
3933         hr = wined3d_device_get_swapchain(device, swapchain_idx, &swapchain);
3934         if (SUCCEEDED(hr))
3935         {
3936             hr = wined3d_swapchain_get_display_mode(swapchain, mode);
3937             wined3d_swapchain_decref(swapchain);
3938         }
3939     }
3940     else
3941     {
3942         const struct wined3d_adapter *adapter = device->adapter;
3943
3944         /* Don't read the real display mode, but return the stored mode
3945          * instead. X11 can't change the color depth, and some apps are
3946          * pretty angry if they SetDisplayMode from 24 to 16 bpp and find out
3947          * that GetDisplayMode still returns 24 bpp.
3948          *
3949          * Also don't relay to the swapchain because with ddraw it's possible
3950          * that there isn't a swapchain at all. */
3951         mode->Width = adapter->screen_size.cx;
3952         mode->Height = adapter->screen_size.cy;
3953         mode->Format = adapter->screen_format;
3954         mode->RefreshRate = 0;
3955         hr = WINED3D_OK;
3956     }
3957
3958     return hr;
3959 }
3960
3961 HRESULT CDECL wined3d_device_begin_stateblock(struct wined3d_device *device)
3962 {
3963     struct wined3d_stateblock *stateblock;
3964     HRESULT hr;
3965
3966     TRACE("device %p.\n", device);
3967
3968     if (device->isRecordingState)
3969         return WINED3DERR_INVALIDCALL;
3970
3971     hr = wined3d_stateblock_create(device, WINED3DSBT_RECORDED, &stateblock);
3972     if (FAILED(hr))
3973         return hr;
3974
3975     wined3d_stateblock_decref(device->updateStateBlock);
3976     device->updateStateBlock = stateblock;
3977     device->isRecordingState = TRUE;
3978
3979     TRACE("Recording stateblock %p.\n", stateblock);
3980
3981     return WINED3D_OK;
3982 }
3983
3984 HRESULT CDECL wined3d_device_end_stateblock(struct wined3d_device *device,
3985         struct wined3d_stateblock **stateblock)
3986 {
3987     struct wined3d_stateblock *object = device->updateStateBlock;
3988
3989     TRACE("device %p, stateblock %p.\n", device, stateblock);
3990
3991     if (!device->isRecordingState)
3992     {
3993         WARN("Not recording.\n");
3994         *stateblock = NULL;
3995         return WINED3DERR_INVALIDCALL;
3996     }
3997
3998     stateblock_init_contained_states(object);
3999
4000     *stateblock = object;
4001     device->isRecordingState = FALSE;
4002     device->updateStateBlock = device->stateBlock;
4003     wined3d_stateblock_incref(device->updateStateBlock);
4004
4005     TRACE("Returning stateblock %p.\n", *stateblock);
4006
4007     return WINED3D_OK;
4008 }
4009
4010 HRESULT CDECL wined3d_device_begin_scene(struct wined3d_device *device)
4011 {
4012     /* At the moment we have no need for any functionality at the beginning
4013      * of a scene. */
4014     TRACE("device %p.\n", device);
4015
4016     if (device->inScene)
4017     {
4018         WARN("Already in scene, returning WINED3DERR_INVALIDCALL.\n");
4019         return WINED3DERR_INVALIDCALL;
4020     }
4021     device->inScene = TRUE;
4022     return WINED3D_OK;
4023 }
4024
4025 HRESULT CDECL wined3d_device_end_scene(struct wined3d_device *device)
4026 {
4027     struct wined3d_context *context;
4028
4029     TRACE("device %p.\n", device);
4030
4031     if (!device->inScene)
4032     {
4033         WARN("Not in scene, returning WINED3DERR_INVALIDCALL.\n");
4034         return WINED3DERR_INVALIDCALL;
4035     }
4036
4037     context = context_acquire(device, NULL);
4038     /* We only have to do this if we need to read the, swapbuffers performs a flush for us */
4039     wglFlush();
4040     /* No checkGLcall here to avoid locking the lock just for checking a call that hardly ever
4041      * fails. */
4042     context_release(context);
4043
4044     device->inScene = FALSE;
4045     return WINED3D_OK;
4046 }
4047
4048 HRESULT CDECL wined3d_device_present(struct wined3d_device *device, const RECT *src_rect,
4049         const RECT *dst_rect, HWND dst_window_override, const RGNDATA *dirty_region)
4050 {
4051     UINT i;
4052
4053     TRACE("device %p, src_rect %s, dst_rect %s, dst_window_override %p, dirty_region %p.\n",
4054             device, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect),
4055             dst_window_override, dirty_region);
4056
4057     for (i = 0; i < device->swapchain_count; ++i)
4058     {
4059         wined3d_swapchain_present(device->swapchains[i], src_rect,
4060                 dst_rect, dst_window_override, dirty_region, 0);
4061     }
4062
4063     return WINED3D_OK;
4064 }
4065
4066 /* Do not call while under the GL lock. */
4067 HRESULT CDECL wined3d_device_clear(struct wined3d_device *device, DWORD rect_count,
4068         const RECT *rects, DWORD flags, WINED3DCOLOR color, float depth, DWORD stencil)
4069 {
4070     const WINED3DCOLORVALUE c = {D3DCOLOR_R(color), D3DCOLOR_G(color), D3DCOLOR_B(color), D3DCOLOR_A(color)};
4071     RECT draw_rect;
4072
4073     TRACE("device %p, rect_count %u, rects %p, flags %#x, color 0x%08x, depth %.8e, stencil %u.\n",
4074             device, rect_count, rects, flags, color, depth, stencil);
4075
4076     if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
4077     {
4078         struct wined3d_surface *ds = device->fb.depth_stencil;
4079         if (!ds)
4080         {
4081             WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
4082             /* TODO: What about depth stencil buffers without stencil bits? */
4083             return WINED3DERR_INVALIDCALL;
4084         }
4085         else if (flags & WINED3DCLEAR_TARGET)
4086         {
4087             if (ds->resource.width < device->fb.render_targets[0]->resource.width
4088                     || ds->resource.height < device->fb.render_targets[0]->resource.height)
4089             {
4090                 WARN("Silently ignoring depth and target clear with mismatching sizes\n");
4091                 return WINED3D_OK;
4092             }
4093         }
4094     }
4095
4096     wined3d_get_draw_rect(&device->stateBlock->state, &draw_rect);
4097
4098     return device_clear_render_targets(device, device->adapter->gl_info.limits.buffers,
4099             &device->fb, rect_count, rects,
4100             &draw_rect, flags, &c, depth, stencil);
4101 }
4102
4103 void CDECL wined3d_device_set_primitive_type(struct wined3d_device *device,
4104         WINED3DPRIMITIVETYPE primitive_type)
4105 {
4106     TRACE("device %p, primitive_type %s\n", device, debug_d3dprimitivetype(primitive_type));
4107
4108     device->updateStateBlock->changed.primitive_type = TRUE;
4109     device->updateStateBlock->state.gl_primitive_type = gl_primitive_type_from_d3d(primitive_type);
4110 }
4111
4112 void CDECL wined3d_device_get_primitive_type(struct wined3d_device *device,
4113         WINED3DPRIMITIVETYPE *primitive_type)
4114 {
4115     TRACE("device %p, primitive_type %p\n", device, primitive_type);
4116
4117     *primitive_type = d3d_primitive_type_from_gl(device->stateBlock->state.gl_primitive_type);
4118
4119     TRACE("Returning %s\n", debug_d3dprimitivetype(*primitive_type));
4120 }
4121
4122 HRESULT CDECL wined3d_device_draw_primitive(struct wined3d_device *device, UINT start_vertex, UINT vertex_count)
4123 {
4124     TRACE("device %p, start_vertex %u, vertex_count %u.\n", device, start_vertex, vertex_count);
4125
4126     if (!device->stateBlock->state.vertex_declaration)
4127     {
4128         WARN("Called without a valid vertex declaration set.\n");
4129         return WINED3DERR_INVALIDCALL;
4130     }
4131
4132     /* The index buffer is not needed here, but restore it, otherwise it is hell to keep track of */
4133     if (device->stateBlock->state.user_stream)
4134     {
4135         device_invalidate_state(device, STATE_INDEXBUFFER);
4136         device->stateBlock->state.user_stream = FALSE;
4137     }
4138
4139     if (device->stateBlock->state.load_base_vertex_index)
4140     {
4141         device->stateBlock->state.load_base_vertex_index = 0;
4142         device_invalidate_state(device, STATE_BASEVERTEXINDEX);
4143     }
4144
4145     /* Account for the loading offset due to index buffers. Instead of
4146      * reloading all sources correct it with the startvertex parameter. */
4147     drawPrimitive(device, vertex_count, start_vertex, 0, NULL);
4148     return WINED3D_OK;
4149 }
4150
4151 HRESULT CDECL wined3d_device_draw_indexed_primitive(struct wined3d_device *device, UINT start_idx, UINT index_count)
4152 {
4153     struct wined3d_buffer *index_buffer;
4154     UINT index_size = 2;
4155     GLuint vbo;
4156     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
4157
4158     TRACE("device %p, start_idx %u, index_count %u.\n", device, start_idx, index_count);
4159
4160     index_buffer = device->stateBlock->state.index_buffer;
4161     if (!index_buffer)
4162     {
4163         /* D3D9 returns D3DERR_INVALIDCALL when DrawIndexedPrimitive is called
4164          * without an index buffer set. (The first time at least...)
4165          * D3D8 simply dies, but I doubt it can do much harm to return
4166          * D3DERR_INVALIDCALL there as well. */
4167         WARN("Called without a valid index buffer set, returning WINED3DERR_INVALIDCALL.\n");
4168         return WINED3DERR_INVALIDCALL;
4169     }
4170
4171     if (!device->stateBlock->state.vertex_declaration)
4172     {
4173         WARN("Called without a valid vertex declaration set.\n");
4174         return WINED3DERR_INVALIDCALL;
4175     }
4176
4177     if (device->stateBlock->state.user_stream)
4178     {
4179         device_invalidate_state(device, STATE_INDEXBUFFER);
4180         device->stateBlock->state.user_stream = FALSE;
4181     }
4182     vbo = index_buffer->buffer_object;
4183
4184     if (device->stateBlock->state.index_format == WINED3DFMT_R16_UINT)
4185         index_size = 2;
4186     else
4187         index_size = 4;
4188
4189     if (!gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX] &&
4190         device->stateBlock->state.load_base_vertex_index != device->stateBlock->state.base_vertex_index)
4191     {
4192         device->stateBlock->state.load_base_vertex_index = device->stateBlock->state.base_vertex_index;
4193         device_invalidate_state(device, STATE_BASEVERTEXINDEX);
4194     }
4195
4196     drawPrimitive(device, index_count, start_idx, index_size,
4197             vbo ? NULL : index_buffer->resource.allocatedMemory);
4198
4199     return WINED3D_OK;
4200 }
4201
4202 HRESULT CDECL wined3d_device_draw_primitive_up(struct wined3d_device *device, UINT vertex_count,
4203         const void *stream_data, UINT stream_stride)
4204 {
4205     struct wined3d_stream_state *stream;
4206     struct wined3d_buffer *vb;
4207
4208     TRACE("device %p, vertex count %u, stream_data %p, stream_stride %u.\n",
4209             device, vertex_count, stream_data, stream_stride);
4210
4211     if (!device->stateBlock->state.vertex_declaration)
4212     {
4213         WARN("Called without a valid vertex declaration set.\n");
4214         return WINED3DERR_INVALIDCALL;
4215     }
4216
4217     /* Note in the following, it's not this type, but that's the purpose of streamIsUP */
4218     stream = &device->stateBlock->state.streams[0];
4219     vb = stream->buffer;
4220     stream->buffer = (struct wined3d_buffer *)stream_data;
4221     if (vb)
4222         wined3d_buffer_decref(vb);
4223     stream->offset = 0;
4224     stream->stride = stream_stride;
4225     device->stateBlock->state.user_stream = TRUE;
4226     if (device->stateBlock->state.load_base_vertex_index)
4227     {
4228         device->stateBlock->state.load_base_vertex_index = 0;
4229         device_invalidate_state(device, STATE_BASEVERTEXINDEX);
4230     }
4231
4232     /* TODO: Only mark dirty if drawing from a different UP address */
4233     device_invalidate_state(device, STATE_STREAMSRC);
4234
4235     drawPrimitive(device, vertex_count, 0, 0, NULL);
4236
4237     /* MSDN specifies stream zero settings must be set to NULL */
4238     stream->buffer = NULL;
4239     stream->stride = 0;
4240
4241     /* stream zero settings set to null at end, as per the msdn. No need to
4242      * mark dirty here, the app has to set the new stream sources or use UP
4243      * drawing again. */
4244     return WINED3D_OK;
4245 }
4246
4247 HRESULT CDECL wined3d_device_draw_indexed_primitive_up(struct wined3d_device *device,
4248         UINT index_count, const void *index_data, enum wined3d_format_id index_data_format_id,
4249         const void *stream_data, UINT stream_stride)
4250 {
4251     struct wined3d_stream_state *stream;
4252     struct wined3d_buffer *vb, *ib;
4253     UINT index_size;
4254
4255     TRACE("device %p, index_count %u, index_data %p, index_data_format %s, stream_data %p, stream_stride %u.\n",
4256             device, index_count, index_data, debug_d3dformat(index_data_format_id), stream_data, stream_stride);
4257
4258     if (!device->stateBlock->state.vertex_declaration)
4259     {
4260         WARN("(%p) : Called without a valid vertex declaration set\n", device);
4261         return WINED3DERR_INVALIDCALL;
4262     }
4263
4264     if (index_data_format_id == WINED3DFMT_R16_UINT)
4265         index_size = 2;
4266     else
4267         index_size = 4;
4268
4269     stream = &device->stateBlock->state.streams[0];
4270     vb = stream->buffer;
4271     stream->buffer = (struct wined3d_buffer *)stream_data;
4272     if (vb)
4273         wined3d_buffer_decref(vb);
4274     stream->offset = 0;
4275     stream->stride = stream_stride;
4276     device->stateBlock->state.user_stream = TRUE;
4277
4278     /* Set to 0 as per msdn. Do it now due to the stream source loading during drawPrimitive */
4279     device->stateBlock->state.base_vertex_index = 0;
4280     if (device->stateBlock->state.load_base_vertex_index)
4281     {
4282         device->stateBlock->state.load_base_vertex_index = 0;
4283         device_invalidate_state(device, STATE_BASEVERTEXINDEX);
4284     }
4285     /* Invalidate the state until we have nicer tracking of the stream source pointers */
4286     device_invalidate_state(device, STATE_STREAMSRC);
4287     device_invalidate_state(device, STATE_INDEXBUFFER);
4288
4289     drawPrimitive(device, index_count, 0, index_size, index_data);
4290
4291     /* MSDN specifies stream zero settings and index buffer must be set to NULL */
4292     stream->buffer = NULL;
4293     stream->stride = 0;
4294     ib = device->stateBlock->state.index_buffer;
4295     if (ib)
4296     {
4297         wined3d_buffer_decref(ib);
4298         device->stateBlock->state.index_buffer = NULL;
4299     }
4300     /* No need to mark the stream source state dirty here. Either the app calls UP drawing again, or it has to call
4301      * SetStreamSource to specify a vertex buffer
4302      */
4303
4304     return WINED3D_OK;
4305 }
4306
4307 HRESULT CDECL wined3d_device_draw_primitive_strided(struct wined3d_device *device,
4308         UINT vertex_count, const WineDirect3DVertexStridedData *strided_data)
4309 {
4310     /* Mark the state dirty until we have nicer tracking. It's fine to change
4311      * baseVertexIndex because that call is only called by ddraw which does
4312      * not need that value. */
4313     device_invalidate_state(device, STATE_VDECL);
4314     device_invalidate_state(device, STATE_STREAMSRC);
4315     device_invalidate_state(device, STATE_INDEXBUFFER);
4316
4317     device->stateBlock->state.base_vertex_index = 0;
4318     device->up_strided = strided_data;
4319     drawPrimitive(device, vertex_count, 0, 0, NULL);
4320     device->up_strided = NULL;
4321
4322     /* Invalidate the states again to make sure the values from the stateblock
4323      * are properly applied in the next regular draw. Note that the application-
4324      * provided strided data has ovwritten pretty much the entire vertex and
4325      * and index stream related states */
4326     device_invalidate_state(device, STATE_VDECL);
4327     device_invalidate_state(device, STATE_STREAMSRC);
4328     device_invalidate_state(device, STATE_INDEXBUFFER);
4329     return WINED3D_OK;
4330 }
4331
4332 HRESULT CDECL wined3d_device_draw_indexed_primitive_strided(struct wined3d_device *device,
4333         UINT index_count, const WineDirect3DVertexStridedData *strided_data,
4334         UINT vertex_count, const void *index_data, enum wined3d_format_id index_data_format_id)
4335 {
4336     UINT index_size = index_data_format_id == WINED3DFMT_R32_UINT ? 4 : 2;
4337
4338     /* Mark the state dirty until we have nicer tracking
4339      * its fine to change baseVertexIndex because that call is only called by ddraw which does not need
4340      * that value.
4341      */
4342     device_invalidate_state(device, STATE_VDECL);
4343     device_invalidate_state(device, STATE_STREAMSRC);
4344     device_invalidate_state(device, STATE_INDEXBUFFER);
4345
4346     device->stateBlock->state.user_stream = TRUE;
4347     device->stateBlock->state.base_vertex_index = 0;
4348     device->up_strided = strided_data;
4349     drawPrimitive(device, index_count, 0, index_size, index_data);
4350     device->up_strided = NULL;
4351
4352     device_invalidate_state(device, STATE_VDECL);
4353     device_invalidate_state(device, STATE_STREAMSRC);
4354     device_invalidate_state(device, STATE_INDEXBUFFER);
4355     return WINED3D_OK;
4356 }
4357
4358 /* This is a helper function for UpdateTexture, there is no UpdateVolume method in D3D. */
4359 static HRESULT device_update_volume(struct wined3d_device *device,
4360         struct wined3d_volume *src_volume, struct wined3d_volume *dst_volume)
4361 {
4362     WINED3DLOCKED_BOX src;
4363     WINED3DLOCKED_BOX dst;
4364     HRESULT hr;
4365
4366     TRACE("device %p, src_volume %p, dst_volume %p.\n",
4367             device, src_volume, dst_volume);
4368
4369     /* TODO: Implement direct loading into the gl volume instead of using
4370      * memcpy and dirtification to improve loading performance. */
4371     hr = wined3d_volume_map(src_volume, &src, NULL, WINED3DLOCK_READONLY);
4372     if (FAILED(hr)) return hr;
4373     hr = wined3d_volume_map(dst_volume, &dst, NULL, WINED3DLOCK_DISCARD);
4374     if (FAILED(hr))
4375     {
4376         wined3d_volume_unmap(src_volume);
4377         return hr;
4378     }
4379
4380     memcpy(dst.pBits, src.pBits, dst_volume->resource.size);
4381
4382     hr = wined3d_volume_unmap(dst_volume);
4383     if (FAILED(hr))
4384         wined3d_volume_unmap(src_volume);
4385     else
4386         hr = wined3d_volume_unmap(src_volume);
4387
4388     return hr;
4389 }
4390
4391 HRESULT CDECL wined3d_device_update_texture(struct wined3d_device *device,
4392         struct wined3d_texture *src_texture, struct wined3d_texture *dst_texture)
4393 {
4394     unsigned int level_count, i;
4395     WINED3DRESOURCETYPE type;
4396     HRESULT hr;
4397
4398     TRACE("device %p, src_texture %p, dst_texture %p.\n", device, src_texture, dst_texture);
4399
4400     /* Verify that the source and destination textures are non-NULL. */
4401     if (!src_texture || !dst_texture)
4402     {
4403         WARN("Source and destination textures must be non-NULL, returning WINED3DERR_INVALIDCALL.\n");
4404         return WINED3DERR_INVALIDCALL;
4405     }
4406
4407     if (src_texture == dst_texture)
4408     {
4409         WARN("Source and destination are the same object, returning WINED3DERR_INVALIDCALL.\n");
4410         return WINED3DERR_INVALIDCALL;
4411     }
4412
4413     /* Verify that the source and destination textures are the same type. */
4414     type = src_texture->resource.resourceType;
4415     if (dst_texture->resource.resourceType != type)
4416     {
4417         WARN("Source and destination have different types, returning WINED3DERR_INVALIDCALL.\n");
4418         return WINED3DERR_INVALIDCALL;
4419     }
4420
4421     /* Check that both textures have the identical numbers of levels. */
4422     level_count = wined3d_texture_get_level_count(src_texture);
4423     if (wined3d_texture_get_level_count(dst_texture) != level_count)
4424     {
4425         WARN("Source and destination have different level counts, returning WINED3DERR_INVALIDCALL.\n");
4426         return WINED3DERR_INVALIDCALL;
4427     }
4428
4429     /* Make sure that the destination texture is loaded. */
4430     dst_texture->texture_ops->texture_preload(dst_texture, SRGB_RGB);
4431
4432     /* Update every surface level of the texture. */
4433     switch (type)
4434     {
4435         case WINED3DRTYPE_TEXTURE:
4436         {
4437             struct wined3d_surface *src_surface;
4438             struct wined3d_surface *dst_surface;
4439
4440             for (i = 0; i < level_count; ++i)
4441             {
4442                 src_surface = surface_from_resource(wined3d_texture_get_sub_resource(src_texture, i));
4443                 dst_surface = surface_from_resource(wined3d_texture_get_sub_resource(dst_texture, i));
4444                 hr = wined3d_device_update_surface(device, src_surface, NULL, dst_surface, NULL);
4445                 if (FAILED(hr))
4446                 {
4447                     WARN("Failed to update surface, hr %#x.\n", hr);
4448                     return hr;
4449                 }
4450             }
4451             break;
4452         }
4453
4454         case WINED3DRTYPE_CUBETEXTURE:
4455         {
4456             struct wined3d_surface *src_surface;
4457             struct wined3d_surface *dst_surface;
4458
4459             for (i = 0; i < level_count * 6; ++i)
4460             {
4461                 src_surface = surface_from_resource(wined3d_texture_get_sub_resource(src_texture, i));
4462                 dst_surface = surface_from_resource(wined3d_texture_get_sub_resource(dst_texture, i));
4463                 hr = wined3d_device_update_surface(device, src_surface, NULL, dst_surface, NULL);
4464                 if (FAILED(hr))
4465                 {
4466                     WARN("Failed to update surface, hr %#x.\n", hr);
4467                     return hr;
4468                 }
4469             }
4470             break;
4471         }
4472
4473         case WINED3DRTYPE_VOLUMETEXTURE:
4474         {
4475             for (i = 0; i < level_count; ++i)
4476             {
4477                 hr = device_update_volume(device,
4478                         volume_from_resource(wined3d_texture_get_sub_resource(src_texture, i)),
4479                         volume_from_resource(wined3d_texture_get_sub_resource(dst_texture, i)));
4480                 if (FAILED(hr))
4481                 {
4482                     WARN("Failed to update volume, hr %#x.\n", hr);
4483                     return hr;
4484                 }
4485             }
4486             break;
4487         }
4488
4489         default:
4490             FIXME("Unsupported texture type %#x.\n", type);
4491             return WINED3DERR_INVALIDCALL;
4492     }
4493
4494     return WINED3D_OK;
4495 }
4496
4497 HRESULT CDECL wined3d_device_get_front_buffer_data(struct wined3d_device *device,
4498         UINT swapchain_idx, struct wined3d_surface *dst_surface)
4499 {
4500     struct wined3d_swapchain *swapchain;
4501     HRESULT hr;
4502
4503     TRACE("device %p, swapchain_idx %u, dst_surface %p.\n", device, swapchain_idx, dst_surface);
4504
4505     hr = wined3d_device_get_swapchain(device, swapchain_idx, &swapchain);
4506     if (FAILED(hr)) return hr;
4507
4508     hr = wined3d_swapchain_get_front_buffer_data(swapchain, dst_surface);
4509     wined3d_swapchain_decref(swapchain);
4510
4511     return hr;
4512 }
4513
4514 HRESULT CDECL wined3d_device_validate_device(struct wined3d_device *device, DWORD *num_passes)
4515 {
4516     const struct wined3d_state *state = &device->stateBlock->state;
4517     struct wined3d_texture *texture;
4518     DWORD i;
4519
4520     TRACE("device %p, num_passes %p.\n", device, num_passes);
4521
4522     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
4523     {
4524         if (state->sampler_states[i][WINED3DSAMP_MINFILTER] == WINED3DTEXF_NONE)
4525         {
4526             WARN("Sampler state %u has minfilter D3DTEXF_NONE, returning D3DERR_UNSUPPORTEDTEXTUREFILTER\n", i);
4527             return WINED3DERR_UNSUPPORTEDTEXTUREFILTER;
4528         }
4529         if (state->sampler_states[i][WINED3DSAMP_MAGFILTER] == WINED3DTEXF_NONE)
4530         {
4531             WARN("Sampler state %u has magfilter D3DTEXF_NONE, returning D3DERR_UNSUPPORTEDTEXTUREFILTER\n", i);
4532             return WINED3DERR_UNSUPPORTEDTEXTUREFILTER;
4533         }
4534
4535         texture = state->textures[i];
4536         if (!texture || texture->resource.format->flags & WINED3DFMT_FLAG_FILTERING) continue;
4537
4538         if (state->sampler_states[i][WINED3DSAMP_MAGFILTER] != WINED3DTEXF_POINT)
4539         {
4540             WARN("Non-filterable texture and mag filter enabled on samper %u, returning E_FAIL\n", i);
4541             return E_FAIL;
4542         }
4543         if (state->sampler_states[i][WINED3DSAMP_MINFILTER] != WINED3DTEXF_POINT)
4544         {
4545             WARN("Non-filterable texture and min filter enabled on samper %u, returning E_FAIL\n", i);
4546             return E_FAIL;
4547         }
4548         if (state->sampler_states[i][WINED3DSAMP_MIPFILTER] != WINED3DTEXF_NONE
4549                 && state->sampler_states[i][WINED3DSAMP_MIPFILTER] != WINED3DTEXF_POINT)
4550         {
4551             WARN("Non-filterable texture and mip filter enabled on samper %u, returning E_FAIL\n", i);
4552             return E_FAIL;
4553         }
4554     }
4555
4556     if (state->render_states[WINED3DRS_ZENABLE] || state->render_states[WINED3DRS_ZWRITEENABLE] ||
4557         state->render_states[WINED3DRS_STENCILENABLE])
4558     {
4559         struct wined3d_surface *ds = device->fb.depth_stencil;
4560         struct wined3d_surface *target = device->fb.render_targets[0];
4561
4562         if(ds && target
4563                 && (ds->resource.width < target->resource.width || ds->resource.height < target->resource.height))
4564         {
4565             WARN("Depth stencil is smaller than the color buffer, returning D3DERR_CONFLICTINGRENDERSTATE\n");
4566             return WINED3DERR_CONFLICTINGRENDERSTATE;
4567         }
4568     }
4569
4570     /* return a sensible default */
4571     *num_passes = 1;
4572
4573     TRACE("returning D3D_OK\n");
4574     return WINED3D_OK;
4575 }
4576
4577 static void dirtify_p8_texture_samplers(struct wined3d_device *device)
4578 {
4579     UINT i;
4580
4581     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
4582     {
4583         struct wined3d_texture *texture = device->stateBlock->state.textures[i];
4584         if (texture && (texture->resource.format->id == WINED3DFMT_P8_UINT
4585                 || texture->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM))
4586             device_invalidate_state(device, STATE_SAMPLER(i));
4587     }
4588 }
4589
4590 HRESULT CDECL wined3d_device_set_palette_entries(struct wined3d_device *device,
4591         UINT palette_idx, const PALETTEENTRY *entries)
4592 {
4593     UINT i;
4594
4595     TRACE("device %p, palette_idx %u, entries %p.\n", device, palette_idx, entries);
4596
4597     if (palette_idx >= MAX_PALETTES)
4598     {
4599         WARN("Invalid palette index %u.\n", palette_idx);
4600         return WINED3DERR_INVALIDCALL;
4601     }
4602
4603     if (palette_idx >= device->palette_count)
4604     {
4605         UINT new_size = device->palette_count;
4606         PALETTEENTRY **palettes;
4607
4608         do
4609         {
4610            new_size *= 2;
4611         } while (palette_idx >= new_size);
4612         palettes = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, device->palettes, sizeof(*palettes) * new_size);
4613         if (!palettes)
4614         {
4615             ERR("Out of memory!\n");
4616             return E_OUTOFMEMORY;
4617         }
4618         device->palettes = palettes;
4619         device->palette_count = new_size;
4620     }
4621
4622     if (!device->palettes[palette_idx])
4623     {
4624         device->palettes[palette_idx] = HeapAlloc(GetProcessHeap(),  0, sizeof(PALETTEENTRY) * 256);
4625         if (!device->palettes[palette_idx])
4626         {
4627             ERR("Out of memory!\n");
4628             return E_OUTOFMEMORY;
4629         }
4630     }
4631
4632     for (i = 0; i < 256; ++i)
4633     {
4634         device->palettes[palette_idx][i].peRed = entries[i].peRed;
4635         device->palettes[palette_idx][i].peGreen = entries[i].peGreen;
4636         device->palettes[palette_idx][i].peBlue = entries[i].peBlue;
4637         device->palettes[palette_idx][i].peFlags = entries[i].peFlags;
4638     }
4639
4640     if (palette_idx == device->currentPalette)
4641         dirtify_p8_texture_samplers(device);
4642
4643     return WINED3D_OK;
4644 }
4645
4646 HRESULT CDECL wined3d_device_get_palette_entries(struct wined3d_device *device,
4647         UINT palette_idx, PALETTEENTRY *entries)
4648 {
4649     UINT i;
4650
4651     TRACE("device %p, palette_idx %u, entries %p.\n", device, palette_idx, entries);
4652
4653     if (palette_idx >= device->palette_count || !device->palettes[palette_idx])
4654     {
4655         /* What happens in such situation isn't documented; Native seems to
4656          * silently abort on such conditions. */
4657         WARN("Invalid palette index %u.\n", palette_idx);
4658         return WINED3DERR_INVALIDCALL;
4659     }
4660
4661     for (i = 0; i < 256; ++i)
4662     {
4663         entries[i].peRed = device->palettes[palette_idx][i].peRed;
4664         entries[i].peGreen = device->palettes[palette_idx][i].peGreen;
4665         entries[i].peBlue = device->palettes[palette_idx][i].peBlue;
4666         entries[i].peFlags = device->palettes[palette_idx][i].peFlags;
4667     }
4668
4669     return WINED3D_OK;
4670 }
4671
4672 HRESULT CDECL wined3d_device_set_current_texture_palette(struct wined3d_device *device, UINT palette_idx)
4673 {
4674     TRACE("device %p, palette_idx %u.\n", device, palette_idx);
4675
4676     /* Native appears to silently abort on attempt to make an uninitialized
4677      * palette current and render. (tested with reference rasterizer). */
4678     if (palette_idx >= device->palette_count || !device->palettes[palette_idx])
4679     {
4680         WARN("Invalid palette index %u.\n", palette_idx);
4681         return WINED3DERR_INVALIDCALL;
4682     }
4683
4684     /* TODO: stateblocks? */
4685     if (device->currentPalette != palette_idx)
4686     {
4687         device->currentPalette = palette_idx;
4688         dirtify_p8_texture_samplers(device);
4689     }
4690
4691     return WINED3D_OK;
4692 }
4693
4694 HRESULT CDECL wined3d_device_get_current_texture_palette(struct wined3d_device *device, UINT *palette_idx)
4695 {
4696     TRACE("device %p, palette_idx %p.\n", device, palette_idx);
4697
4698     if (!palette_idx)
4699         return WINED3DERR_INVALIDCALL;
4700
4701     *palette_idx = device->currentPalette;
4702
4703     return WINED3D_OK;
4704 }
4705
4706 HRESULT CDECL wined3d_device_set_software_vertex_processing(struct wined3d_device *device, BOOL software)
4707 {
4708     static BOOL warned;
4709
4710     TRACE("device %p, software %#x.\n", device, software);
4711
4712     if (!warned)
4713     {
4714         FIXME("device %p, software %#x stub!\n", device, software);
4715         warned = TRUE;
4716     }
4717
4718     device->softwareVertexProcessing = software;
4719
4720     return WINED3D_OK;
4721 }
4722
4723 BOOL CDECL wined3d_device_get_software_vertex_processing(struct wined3d_device *device)
4724 {
4725     static BOOL warned;
4726
4727     TRACE("device %p.\n", device);
4728
4729     if (!warned)
4730     {
4731         TRACE("device %p stub!\n", device);
4732         warned = TRUE;
4733     }
4734
4735     return device->softwareVertexProcessing;
4736 }
4737
4738 HRESULT CDECL wined3d_device_get_raster_status(struct wined3d_device *device,
4739         UINT swapchain_idx, WINED3DRASTER_STATUS *raster_status)
4740 {
4741     struct wined3d_swapchain *swapchain;
4742     HRESULT hr;
4743
4744     TRACE("device %p, swapchain_idx %u, raster_status %p.\n",
4745             device, swapchain_idx, raster_status);
4746
4747     hr = wined3d_device_get_swapchain(device, swapchain_idx, &swapchain);
4748     if (FAILED(hr))
4749     {
4750         WARN("Failed to get swapchain %u, hr %#x.\n", swapchain_idx, hr);
4751         return hr;
4752     }
4753
4754     hr = wined3d_swapchain_get_raster_status(swapchain, raster_status);
4755     wined3d_swapchain_decref(swapchain);
4756     if (FAILED(hr))
4757     {
4758         WARN("Failed to get raster status, hr %#x.\n", hr);
4759         return hr;
4760     }
4761
4762     return WINED3D_OK;
4763 }
4764
4765 HRESULT CDECL wined3d_device_set_npatch_mode(struct wined3d_device *device, float segments)
4766 {
4767     static BOOL warned;
4768
4769     TRACE("device %p, segments %.8e.\n", device, segments);
4770
4771     if (segments != 0.0f)
4772     {
4773         if (!warned)
4774         {
4775             FIXME("device %p, segments %.8e stub!\n", device, segments);
4776             warned = TRUE;
4777         }
4778     }
4779
4780     return WINED3D_OK;
4781 }
4782
4783 float CDECL wined3d_device_get_npatch_mode(struct wined3d_device *device)
4784 {
4785     static BOOL warned;
4786
4787     TRACE("device %p.\n", device);
4788
4789     if (!warned)
4790     {
4791         FIXME("device %p stub!\n", device);
4792         warned = TRUE;
4793     }
4794
4795     return 0.0f;
4796 }
4797
4798 static inline void invalidate_active_texture(struct wined3d_device *device, struct wined3d_context *context)
4799 {
4800     DWORD sampler = device->rev_tex_unit_map[context->active_texture];
4801     if (sampler != WINED3D_UNMAPPED_STAGE)
4802         context_invalidate_state(context, STATE_SAMPLER(sampler));
4803 }
4804
4805 HRESULT CDECL wined3d_device_update_surface(struct wined3d_device *device,
4806         struct wined3d_surface *src_surface, const RECT *src_rect,
4807         struct wined3d_surface *dst_surface, const POINT *dst_point)
4808 {
4809     const struct wined3d_format *src_format;
4810     const struct wined3d_format *dst_format;
4811     const struct wined3d_gl_info *gl_info;
4812     struct wined3d_context *context;
4813     struct wined3d_bo_address data;
4814     struct wined3d_format format;
4815     UINT update_w, update_h;
4816     CONVERT_TYPES convert;
4817     UINT dst_w, dst_h;
4818     UINT src_w, src_h;
4819     POINT p;
4820     RECT r;
4821
4822     TRACE("device %p, src_surface %p, src_rect %s, dst_surface %p, dst_point %s.\n",
4823             device, src_surface, wine_dbgstr_rect(src_rect),
4824             dst_surface, wine_dbgstr_point(dst_point));
4825
4826     if (src_surface->resource.pool != WINED3DPOOL_SYSTEMMEM || dst_surface->resource.pool != WINED3DPOOL_DEFAULT)
4827     {
4828         WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, returning WINED3DERR_INVALIDCALL\n",
4829                 src_surface, dst_surface);
4830         return WINED3DERR_INVALIDCALL;
4831     }
4832
4833     src_format = src_surface->resource.format;
4834     dst_format = dst_surface->resource.format;
4835
4836     if (src_format->id != dst_format->id)
4837     {
4838         WARN("Source and destination surfaces should have the same format.\n");
4839         return WINED3DERR_INVALIDCALL;
4840     }
4841
4842     if (!dst_point)
4843     {
4844         p.x = 0;
4845         p.y = 0;
4846         dst_point = &p;
4847     }
4848     else if (dst_point->x < 0 || dst_point->y < 0)
4849     {
4850         WARN("Invalid destination point.\n");
4851         return WINED3DERR_INVALIDCALL;
4852     }
4853
4854     if (!src_rect)
4855     {
4856         r.left = 0;
4857         r.top = 0;
4858         r.right = src_surface->resource.width;
4859         r.bottom = src_surface->resource.height;
4860         src_rect = &r;
4861     }
4862     else if (src_rect->left < 0 || src_rect->left >= src_rect->right
4863             || src_rect->top < 0 || src_rect->top >= src_rect->bottom)
4864     {
4865         WARN("Invalid source rectangle.\n");
4866         return WINED3DERR_INVALIDCALL;
4867     }
4868
4869     src_w = src_surface->resource.width;
4870     src_h = src_surface->resource.height;
4871
4872     dst_w = dst_surface->resource.width;
4873     dst_h = dst_surface->resource.height;
4874
4875     update_w = src_rect->right - src_rect->left;
4876     update_h = src_rect->bottom - src_rect->top;
4877
4878     if (update_w > dst_w || dst_point->x > dst_w - update_w
4879             || update_h > dst_h || dst_point->y > dst_h - update_h)
4880     {
4881         WARN("Destination out of bounds.\n");
4882         return WINED3DERR_INVALIDCALL;
4883     }
4884
4885     /* NPOT block sizes would be silly. */
4886     if ((src_format->flags & WINED3DFMT_FLAG_COMPRESSED)
4887             && ((update_w & (src_format->block_width - 1) || update_h & (src_format->block_height - 1))
4888             && (src_w != update_w || dst_w != update_w || src_h != update_h || dst_h != update_h)))
4889     {
4890         WARN("Update rect not block-aligned.\n");
4891         return WINED3DERR_INVALIDCALL;
4892     }
4893
4894     /* This call loads the OpenGL surface directly, instead of copying the
4895      * surface to the destination's sysmem copy. If surface conversion is
4896      * needed, use BltFast instead to copy in sysmem and use regular surface
4897      * loading. */
4898     d3dfmt_get_conv(dst_surface, FALSE, TRUE, &format, &convert);
4899     if (convert != NO_CONVERSION || format.convert)
4900         return wined3d_surface_bltfast(dst_surface, dst_point->x, dst_point->y, src_surface, src_rect, 0);
4901
4902     context = context_acquire(device, NULL);
4903     gl_info = context->gl_info;
4904
4905     /* Only load the surface for partial updates. For newly allocated texture
4906      * the texture wouldn't be the current location, and we'd upload zeroes
4907      * just to overwrite them again. */
4908     if (update_w == dst_w && update_h == dst_h)
4909         surface_prepare_texture(dst_surface, context, FALSE);
4910     else
4911         surface_load_location(dst_surface, SFLAG_INTEXTURE, NULL);
4912     surface_bind(dst_surface, context, FALSE);
4913
4914     data.buffer_object = 0;
4915     data.addr = src_surface->resource.allocatedMemory;
4916
4917     if (!data.addr)
4918         ERR("Source surface has no allocated memory, but should be a sysmem surface.\n");
4919
4920     surface_upload_data(dst_surface, gl_info, src_format, src_rect, src_w, dst_point, FALSE, &data);
4921
4922     invalidate_active_texture(device, context);
4923
4924     context_release(context);
4925
4926     surface_modify_location(dst_surface, SFLAG_INTEXTURE, TRUE);
4927     return WINED3D_OK;
4928 }
4929
4930 HRESULT CDECL wined3d_device_draw_rect_patch(struct wined3d_device *device, UINT handle,
4931         const float *num_segs, const WINED3DRECTPATCH_INFO *rect_patch_info)
4932 {
4933     struct WineD3DRectPatch *patch;
4934     GLenum old_primitive_type;
4935     unsigned int i;
4936     struct list *e;
4937     BOOL found;
4938
4939     TRACE("device %p, handle %#x, num_segs %p, rect_patch_info %p.\n",
4940             device, handle, num_segs, rect_patch_info);
4941
4942     if (!(handle || rect_patch_info))
4943     {
4944         /* TODO: Write a test for the return value, thus the FIXME */
4945         FIXME("Both handle and rect_patch_info are NULL.\n");
4946         return WINED3DERR_INVALIDCALL;
4947     }
4948
4949     if (handle)
4950     {
4951         i = PATCHMAP_HASHFUNC(handle);
4952         found = FALSE;
4953         LIST_FOR_EACH(e, &device->patches[i])
4954         {
4955             patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
4956             if (patch->Handle == handle)
4957             {
4958                 found = TRUE;
4959                 break;
4960             }
4961         }
4962
4963         if (!found)
4964         {
4965             TRACE("Patch does not exist. Creating a new one\n");
4966             patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
4967             patch->Handle = handle;
4968             list_add_head(&device->patches[i], &patch->entry);
4969         } else {
4970             TRACE("Found existing patch %p\n", patch);
4971         }
4972     }
4973     else
4974     {
4975         /* Since opengl does not load tesselated vertex attributes into numbered vertex
4976          * attributes we have to tesselate, read back, and draw. This needs a patch
4977          * management structure instance. Create one.
4978          *
4979          * A possible improvement is to check if a vertex shader is used, and if not directly
4980          * draw the patch.
4981          */
4982         FIXME("Drawing an uncached patch. This is slow\n");
4983         patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
4984     }
4985
4986     if (num_segs[0] != patch->numSegs[0] || num_segs[1] != patch->numSegs[1]
4987             || num_segs[2] != patch->numSegs[2] || num_segs[3] != patch->numSegs[3]
4988             || (rect_patch_info && memcmp(rect_patch_info, &patch->RectPatchInfo, sizeof(*rect_patch_info))))
4989     {
4990         HRESULT hr;
4991         TRACE("Tesselation density or patch info changed, retesselating\n");
4992
4993         if (rect_patch_info)
4994             patch->RectPatchInfo = *rect_patch_info;
4995
4996         patch->numSegs[0] = num_segs[0];
4997         patch->numSegs[1] = num_segs[1];
4998         patch->numSegs[2] = num_segs[2];
4999         patch->numSegs[3] = num_segs[3];
5000
5001         hr = tesselate_rectpatch(device, patch);
5002         if (FAILED(hr))
5003         {
5004             WARN("Patch tesselation failed.\n");
5005
5006             /* Do not release the handle to store the params of the patch */
5007             if (!handle)
5008                 HeapFree(GetProcessHeap(), 0, patch);
5009
5010             return hr;
5011         }
5012     }
5013
5014     old_primitive_type = device->stateBlock->state.gl_primitive_type;
5015     device->stateBlock->state.gl_primitive_type = GL_TRIANGLES;
5016     wined3d_device_draw_primitive_strided(device, patch->numSegs[0] * patch->numSegs[1] * 2 * 3, &patch->strided);
5017     device->stateBlock->state.gl_primitive_type = old_primitive_type;
5018
5019     /* Destroy uncached patches */
5020     if (!handle)
5021     {
5022         HeapFree(GetProcessHeap(), 0, patch->mem);
5023         HeapFree(GetProcessHeap(), 0, patch);
5024     }
5025     return WINED3D_OK;
5026 }
5027
5028 HRESULT CDECL wined3d_device_draw_tri_patch(struct wined3d_device *device, UINT handle,
5029         const float *segment_count, const WINED3DTRIPATCH_INFO *patch_info)
5030 {
5031     FIXME("device %p, handle %#x, segment_count %p, patch_info %p stub!\n",
5032             device, handle, segment_count, patch_info);
5033
5034     return WINED3D_OK;
5035 }
5036
5037 HRESULT CDECL wined3d_device_delete_patch(struct wined3d_device *device, UINT handle)
5038 {
5039     struct WineD3DRectPatch *patch;
5040     struct list *e;
5041     int i;
5042
5043     TRACE("device %p, handle %#x.\n", device, handle);
5044
5045     i = PATCHMAP_HASHFUNC(handle);
5046     LIST_FOR_EACH(e, &device->patches[i])
5047     {
5048         patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
5049         if (patch->Handle == handle)
5050         {
5051             TRACE("Deleting patch %p\n", patch);
5052             list_remove(&patch->entry);
5053             HeapFree(GetProcessHeap(), 0, patch->mem);
5054             HeapFree(GetProcessHeap(), 0, patch);
5055             return WINED3D_OK;
5056         }
5057     }
5058
5059     /* TODO: Write a test for the return value */
5060     FIXME("Attempt to destroy nonexistent patch\n");
5061     return WINED3DERR_INVALIDCALL;
5062 }
5063
5064 /* Do not call while under the GL lock. */
5065 HRESULT CDECL wined3d_device_color_fill(struct wined3d_device *device,
5066         struct wined3d_surface *surface, const RECT *rect, const WINED3DCOLORVALUE *color)
5067 {
5068     RECT r;
5069
5070     TRACE("device %p, surface %p, rect %s, color {%.8e, %.8e, %.8e, %.8e}.\n",
5071             device, surface, wine_dbgstr_rect(rect),
5072             color->r, color->g, color->b, color->a);
5073
5074     if (surface->resource.pool != WINED3DPOOL_DEFAULT && surface->resource.pool != WINED3DPOOL_SYSTEMMEM)
5075     {
5076         FIXME("call to colorfill with non WINED3DPOOL_DEFAULT or WINED3DPOOL_SYSTEMMEM surface\n");
5077         return WINED3DERR_INVALIDCALL;
5078     }
5079
5080     if (!rect)
5081     {
5082         SetRect(&r, 0, 0, surface->resource.width, surface->resource.height);
5083         rect = &r;
5084     }
5085
5086     return surface_color_fill(surface, rect, color);
5087 }
5088
5089 /* Do not call while under the GL lock. */
5090 void CDECL wined3d_device_clear_rendertarget_view(struct wined3d_device *device,
5091         struct wined3d_rendertarget_view *rendertarget_view, const WINED3DCOLORVALUE *color)
5092 {
5093     struct wined3d_resource *resource;
5094     HRESULT hr;
5095     RECT rect;
5096
5097     resource = rendertarget_view->resource;
5098     if (resource->resourceType != WINED3DRTYPE_SURFACE)
5099     {
5100         FIXME("Only supported on surface resources\n");
5101         return;
5102     }
5103
5104     SetRect(&rect, 0, 0, resource->width, resource->height);
5105     hr = surface_color_fill(surface_from_resource(resource), &rect, color);
5106     if (FAILED(hr)) ERR("Color fill failed, hr %#x.\n", hr);
5107 }
5108
5109 HRESULT CDECL wined3d_device_get_render_target(struct wined3d_device *device,
5110         UINT render_target_idx, struct wined3d_surface **render_target)
5111 {
5112     TRACE("device %p, render_target_idx %u, render_target %p.\n",
5113             device, render_target_idx, render_target);
5114
5115     if (render_target_idx >= device->adapter->gl_info.limits.buffers)
5116     {
5117         WARN("Only %u render targets are supported.\n", device->adapter->gl_info.limits.buffers);
5118         return WINED3DERR_INVALIDCALL;
5119     }
5120
5121     *render_target = device->fb.render_targets[render_target_idx];
5122     if (*render_target)
5123         wined3d_surface_incref(*render_target);
5124
5125     TRACE("Returning render target %p.\n", *render_target);
5126
5127     return WINED3D_OK;
5128 }
5129
5130 HRESULT CDECL wined3d_device_get_depth_stencil(struct wined3d_device *device, struct wined3d_surface **depth_stencil)
5131 {
5132     TRACE("device %p, depth_stencil %p.\n", device, depth_stencil);
5133
5134     *depth_stencil = device->fb.depth_stencil;
5135     TRACE("Returning depth/stencil surface %p.\n", *depth_stencil);
5136
5137     if (!*depth_stencil)
5138         return WINED3DERR_NOTFOUND;
5139
5140     wined3d_surface_incref(*depth_stencil);
5141
5142     return WINED3D_OK;
5143 }
5144
5145 HRESULT CDECL wined3d_device_set_render_target(struct wined3d_device *device,
5146         UINT render_target_idx, struct wined3d_surface *render_target, BOOL set_viewport)
5147 {
5148     struct wined3d_surface *prev;
5149
5150     TRACE("device %p, render_target_idx %u, render_target %p, set_viewport %#x.\n",
5151             device, render_target_idx, render_target, set_viewport);
5152
5153     if (render_target_idx >= device->adapter->gl_info.limits.buffers)
5154     {
5155         WARN("Only %u render targets are supported.\n", device->adapter->gl_info.limits.buffers);
5156         return WINED3DERR_INVALIDCALL;
5157     }
5158
5159     prev = device->fb.render_targets[render_target_idx];
5160     if (render_target == prev)
5161     {
5162         TRACE("Trying to do a NOP SetRenderTarget operation.\n");
5163         return WINED3D_OK;
5164     }
5165
5166     /* Render target 0 can't be set to NULL. */
5167     if (!render_target && !render_target_idx)
5168     {
5169         WARN("Trying to set render target 0 to NULL.\n");
5170         return WINED3DERR_INVALIDCALL;
5171     }
5172
5173     if (render_target && !(render_target->resource.usage & WINED3DUSAGE_RENDERTARGET))
5174     {
5175         FIXME("Surface %p doesn't have render target usage.\n", render_target);
5176         return WINED3DERR_INVALIDCALL;
5177     }
5178
5179     if (render_target)
5180         wined3d_surface_incref(render_target);
5181     device->fb.render_targets[render_target_idx] = render_target;
5182     /* Release after the assignment, to prevent device_resource_released()
5183      * from seeing the surface as still in use. */
5184     if (prev)
5185         wined3d_surface_decref(prev);
5186
5187     /* Render target 0 is special. */
5188     if (!render_target_idx && set_viewport)
5189     {
5190         /* Set the viewport and scissor rectangles, if requested. Tests show
5191          * that stateblock recording is ignored, the change goes directly
5192          * into the primary stateblock. */
5193         device->stateBlock->state.viewport.Height = device->fb.render_targets[0]->resource.height;
5194         device->stateBlock->state.viewport.Width  = device->fb.render_targets[0]->resource.width;
5195         device->stateBlock->state.viewport.X      = 0;
5196         device->stateBlock->state.viewport.Y      = 0;
5197         device->stateBlock->state.viewport.MaxZ   = 1.0f;
5198         device->stateBlock->state.viewport.MinZ   = 0.0f;
5199         device_invalidate_state(device, STATE_VIEWPORT);
5200
5201         device->stateBlock->state.scissor_rect.top = 0;
5202         device->stateBlock->state.scissor_rect.left = 0;
5203         device->stateBlock->state.scissor_rect.right = device->stateBlock->state.viewport.Width;
5204         device->stateBlock->state.scissor_rect.bottom = device->stateBlock->state.viewport.Height;
5205         device_invalidate_state(device, STATE_SCISSORRECT);
5206     }
5207
5208     device_invalidate_state(device, STATE_FRAMEBUFFER);
5209
5210     return WINED3D_OK;
5211 }
5212
5213 HRESULT CDECL wined3d_device_set_depth_stencil(struct wined3d_device *device, struct wined3d_surface *depth_stencil)
5214 {
5215     struct wined3d_surface *prev = device->fb.depth_stencil;
5216
5217     TRACE("device %p, depth_stencil %p, old depth_stencil %p.\n",
5218             device, depth_stencil, prev);
5219
5220     if (prev == depth_stencil)
5221     {
5222         TRACE("Trying to do a NOP SetRenderTarget operation.\n");
5223         return WINED3D_OK;
5224     }
5225
5226     if (prev)
5227     {
5228         if (device->swapchains[0]->presentParms.Flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
5229                 || prev->flags & SFLAG_DISCARD)
5230         {
5231             surface_modify_ds_location(prev, SFLAG_DS_DISCARDED,
5232                     prev->resource.width, prev->resource.height);
5233             if (prev == device->onscreen_depth_stencil)
5234             {
5235                 wined3d_surface_decref(device->onscreen_depth_stencil);
5236                 device->onscreen_depth_stencil = NULL;
5237             }
5238         }
5239     }
5240
5241     device->fb.depth_stencil = depth_stencil;
5242     if (depth_stencil)
5243         wined3d_surface_incref(depth_stencil);
5244
5245     if (!prev != !depth_stencil)
5246     {
5247         /* Swapping NULL / non NULL depth stencil affects the depth and tests */
5248         device_invalidate_state(device, STATE_RENDER(WINED3DRS_ZENABLE));
5249         device_invalidate_state(device, STATE_RENDER(WINED3DRS_STENCILENABLE));
5250         device_invalidate_state(device, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
5251         device_invalidate_state(device, STATE_RENDER(WINED3DRS_DEPTHBIAS));
5252     }
5253     else if (prev && prev->resource.format->depth_size != depth_stencil->resource.format->depth_size)
5254     {
5255         device_invalidate_state(device, STATE_RENDER(WINED3DRS_DEPTHBIAS));
5256     }
5257     if (prev)
5258         wined3d_surface_decref(prev);
5259
5260     device_invalidate_state(device, STATE_FRAMEBUFFER);
5261
5262     return WINED3D_OK;
5263 }
5264
5265 HRESULT CDECL wined3d_device_set_cursor_properties(struct wined3d_device *device,
5266         UINT x_hotspot, UINT y_hotspot, struct wined3d_surface *cursor_image)
5267 {
5268     WINED3DLOCKED_RECT lockedRect;
5269
5270     TRACE("device %p, x_hotspot %u, y_hotspot %u, cursor_image %p.\n",
5271             device, x_hotspot, y_hotspot, cursor_image);
5272
5273     /* some basic validation checks */
5274     if (device->cursorTexture)
5275     {
5276         struct wined3d_context *context = context_acquire(device, NULL);
5277         ENTER_GL();
5278         glDeleteTextures(1, &device->cursorTexture);
5279         LEAVE_GL();
5280         context_release(context);
5281         device->cursorTexture = 0;
5282     }
5283
5284     if (cursor_image)
5285     {
5286         WINED3DLOCKED_RECT rect;
5287
5288         /* MSDN: Cursor must be A8R8G8B8 */
5289         if (cursor_image->resource.format->id != WINED3DFMT_B8G8R8A8_UNORM)
5290         {
5291             WARN("surface %p has an invalid format.\n", cursor_image);
5292             return WINED3DERR_INVALIDCALL;
5293         }
5294
5295         /* MSDN: Cursor must be smaller than the display mode */
5296         if (cursor_image->resource.width > device->adapter->screen_size.cx
5297                 || cursor_image->resource.height > device->adapter->screen_size.cy)
5298         {
5299             WARN("Surface %p dimensions are %ux%u, but screen dimensions are %ux%u.\n",
5300                     cursor_image, cursor_image->resource.width, cursor_image->resource.height,
5301                     device->adapter->screen_size.cx, device->adapter->screen_size.cy);
5302             return WINED3DERR_INVALIDCALL;
5303         }
5304
5305         /* TODO: MSDN: Cursor sizes must be a power of 2 */
5306
5307         /* Do not store the surface's pointer because the application may
5308          * release it after setting the cursor image. Windows doesn't
5309          * addref the set surface, so we can't do this either without
5310          * creating circular refcount dependencies. Copy out the gl texture
5311          * instead. */
5312         device->cursorWidth = cursor_image->resource.width;
5313         device->cursorHeight = cursor_image->resource.height;
5314         if (SUCCEEDED(wined3d_surface_map(cursor_image, &rect, NULL, WINED3DLOCK_READONLY)))
5315         {
5316             const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
5317             const struct wined3d_format *format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
5318             struct wined3d_context *context;
5319             char *mem, *bits = rect.pBits;
5320             GLint intfmt = format->glInternal;
5321             GLint gl_format = format->glFormat;
5322             GLint type = format->glType;
5323             INT height = device->cursorHeight;
5324             INT width = device->cursorWidth;
5325             INT bpp = format->byte_count;
5326             INT i;
5327
5328             /* Reformat the texture memory (pitch and width can be
5329              * different) */
5330             mem = HeapAlloc(GetProcessHeap(), 0, width * height * bpp);
5331             for(i = 0; i < height; i++)
5332                 memcpy(&mem[width * bpp * i], &bits[rect.Pitch * i], width * bpp);
5333             wined3d_surface_unmap(cursor_image);
5334
5335             context = context_acquire(device, NULL);
5336
5337             ENTER_GL();
5338
5339             if (gl_info->supported[APPLE_CLIENT_STORAGE])
5340             {
5341                 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
5342                 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
5343             }
5344
5345             invalidate_active_texture(device, context);
5346             /* Create a new cursor texture */
5347             glGenTextures(1, &device->cursorTexture);
5348             checkGLcall("glGenTextures");
5349             context_bind_texture(context, GL_TEXTURE_2D, device->cursorTexture);
5350             /* Copy the bitmap memory into the cursor texture */
5351             glTexImage2D(GL_TEXTURE_2D, 0, intfmt, width, height, 0, gl_format, type, mem);
5352             checkGLcall("glTexImage2D");
5353             HeapFree(GetProcessHeap(), 0, mem);
5354
5355             if (gl_info->supported[APPLE_CLIENT_STORAGE])
5356             {
5357                 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
5358                 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
5359             }
5360
5361             LEAVE_GL();
5362
5363             context_release(context);
5364         }
5365         else
5366         {
5367             FIXME("A cursor texture was not returned.\n");
5368             device->cursorTexture = 0;
5369         }
5370
5371         if (cursor_image->resource.width == 32 && cursor_image->resource.height == 32)
5372         {
5373             /* Draw a hardware cursor */
5374             ICONINFO cursorInfo;
5375             HCURSOR cursor;
5376             /* Create and clear maskBits because it is not needed for
5377              * 32-bit cursors.  32x32 bits split into 32-bit chunks == 32
5378              * chunks. */
5379             DWORD *maskBits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
5380                     (cursor_image->resource.width * cursor_image->resource.height / 8));
5381             wined3d_surface_map(cursor_image, &lockedRect, NULL,
5382                     WINED3DLOCK_NO_DIRTY_UPDATE | WINED3DLOCK_READONLY);
5383             TRACE("width: %u height: %u.\n", cursor_image->resource.width, cursor_image->resource.height);
5384
5385             cursorInfo.fIcon = FALSE;
5386             cursorInfo.xHotspot = x_hotspot;
5387             cursorInfo.yHotspot = y_hotspot;
5388             cursorInfo.hbmMask = CreateBitmap(cursor_image->resource.width, cursor_image->resource.height,
5389                     1, 1, maskBits);
5390             cursorInfo.hbmColor = CreateBitmap(cursor_image->resource.width, cursor_image->resource.height,
5391                     1, 32, lockedRect.pBits);
5392             wined3d_surface_unmap(cursor_image);
5393             /* Create our cursor and clean up. */
5394             cursor = CreateIconIndirect(&cursorInfo);
5395             if (cursorInfo.hbmMask) DeleteObject(cursorInfo.hbmMask);
5396             if (cursorInfo.hbmColor) DeleteObject(cursorInfo.hbmColor);
5397             if (device->hardwareCursor) DestroyCursor(device->hardwareCursor);
5398             device->hardwareCursor = cursor;
5399             if (device->bCursorVisible) SetCursor( cursor );
5400             HeapFree(GetProcessHeap(), 0, maskBits);
5401         }
5402     }
5403
5404     device->xHotSpot = x_hotspot;
5405     device->yHotSpot = y_hotspot;
5406     return WINED3D_OK;
5407 }
5408
5409 void CDECL wined3d_device_set_cursor_position(struct wined3d_device *device,
5410         int x_screen_space, int y_screen_space, DWORD flags)
5411 {
5412     TRACE("device %p, x %d, y %d, flags %#x.\n",
5413             device, x_screen_space, y_screen_space, flags);
5414
5415     device->xScreenSpace = x_screen_space;
5416     device->yScreenSpace = y_screen_space;
5417
5418     /* switch to the software cursor if position diverges from the hardware one */
5419     if (device->hardwareCursor)
5420     {
5421         POINT pt;
5422         GetCursorPos( &pt );
5423         if (x_screen_space != pt.x || y_screen_space != pt.y)
5424         {
5425             if (device->bCursorVisible) SetCursor( NULL );
5426             DestroyCursor( device->hardwareCursor );
5427             device->hardwareCursor = 0;
5428         }
5429     }
5430 }
5431
5432 BOOL CDECL wined3d_device_show_cursor(struct wined3d_device *device, BOOL show)
5433 {
5434     BOOL oldVisible = device->bCursorVisible;
5435
5436     TRACE("device %p, show %#x.\n", device, show);
5437
5438     /*
5439      * When ShowCursor is first called it should make the cursor appear at the OS's last
5440      * known cursor position.
5441      */
5442     if (show && !oldVisible)
5443     {
5444         POINT pt;
5445         GetCursorPos(&pt);
5446         device->xScreenSpace = pt.x;
5447         device->yScreenSpace = pt.y;
5448     }
5449
5450     if (device->hardwareCursor)
5451     {
5452         device->bCursorVisible = show;
5453         if (show)
5454             SetCursor(device->hardwareCursor);
5455         else
5456             SetCursor(NULL);
5457     }
5458     else
5459     {
5460         if (device->cursorTexture)
5461             device->bCursorVisible = show;
5462     }
5463
5464     return oldVisible;
5465 }
5466
5467 void CDECL wined3d_device_evict_managed_resources(struct wined3d_device *device)
5468 {
5469     struct wined3d_resource *resource, *cursor;
5470
5471     TRACE("device %p.\n", device);
5472
5473     LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
5474     {
5475         TRACE("Checking resource %p for eviction.\n", resource);
5476
5477         if (resource->pool == WINED3DPOOL_MANAGED)
5478         {
5479             TRACE("Evicting %p.\n", resource);
5480             resource->resource_ops->resource_unload(resource);
5481         }
5482     }
5483
5484     /* Invalidate stream sources, the buffer(s) may have been evicted. */
5485     device_invalidate_state(device, STATE_STREAMSRC);
5486 }
5487
5488 static HRESULT updateSurfaceDesc(struct wined3d_surface *surface,
5489         const WINED3DPRESENT_PARAMETERS *pPresentationParameters)
5490 {
5491     struct wined3d_device *device = surface->resource.device;
5492     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
5493
5494     /* Reallocate proper memory for the front and back buffer and adjust their sizes */
5495     if (surface->flags & SFLAG_DIBSECTION)
5496     {
5497         /* Release the DC */
5498         SelectObject(surface->hDC, surface->dib.holdbitmap);
5499         DeleteDC(surface->hDC);
5500         /* Release the DIB section */
5501         DeleteObject(surface->dib.DIBsection);
5502         surface->dib.bitmap_data = NULL;
5503         surface->resource.allocatedMemory = NULL;
5504         surface->flags &= ~SFLAG_DIBSECTION;
5505     }
5506     surface->resource.width = pPresentationParameters->BackBufferWidth;
5507     surface->resource.height = pPresentationParameters->BackBufferHeight;
5508     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] || gl_info->supported[ARB_TEXTURE_RECTANGLE]
5509             || gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT])
5510     {
5511         surface->pow2Width = pPresentationParameters->BackBufferWidth;
5512         surface->pow2Height = pPresentationParameters->BackBufferHeight;
5513     } else {
5514         surface->pow2Width = surface->pow2Height = 1;
5515         while (surface->pow2Width < pPresentationParameters->BackBufferWidth) surface->pow2Width <<= 1;
5516         while (surface->pow2Height < pPresentationParameters->BackBufferHeight) surface->pow2Height <<= 1;
5517     }
5518
5519     surface->resource.multisample_type = pPresentationParameters->MultiSampleType;
5520     surface->resource.multisample_quality = pPresentationParameters->MultiSampleQuality;
5521
5522     surface->resource.resource_ops->resource_unload(&surface->resource);
5523
5524     if (surface->pow2Width != pPresentationParameters->BackBufferWidth
5525             || surface->pow2Height != pPresentationParameters->BackBufferHeight)
5526     {
5527         surface->flags |= SFLAG_NONPOW2;
5528     }
5529     else
5530     {
5531         surface->flags &= ~SFLAG_NONPOW2;
5532     }
5533     HeapFree(GetProcessHeap(), 0, surface->resource.heapMemory);
5534     surface->resource.allocatedMemory = NULL;
5535     surface->resource.heapMemory = NULL;
5536     surface->resource.size = wined3d_surface_get_pitch(surface) * surface->pow2Width;
5537
5538     /* Put all surfaces into sysmem - the drawable might disappear if the backbuffer was rendered
5539      * to a FBO */
5540     if (!surface_init_sysmem(surface))
5541     {
5542         return E_OUTOFMEMORY;
5543     }
5544     return WINED3D_OK;
5545 }
5546
5547 static BOOL is_display_mode_supported(struct wined3d_device *device, const WINED3DPRESENT_PARAMETERS *pp)
5548 {
5549     UINT i, count;
5550     WINED3DDISPLAYMODE m;
5551     HRESULT hr;
5552
5553     /* All Windowed modes are supported, as is leaving the current mode */
5554     if(pp->Windowed) return TRUE;
5555     if(!pp->BackBufferWidth) return TRUE;
5556     if(!pp->BackBufferHeight) return TRUE;
5557
5558     count = wined3d_get_adapter_mode_count(device->wined3d, device->adapter->ordinal, WINED3DFMT_UNKNOWN);
5559     for (i = 0; i < count; ++i)
5560     {
5561         memset(&m, 0, sizeof(m));
5562         hr = wined3d_enum_adapter_modes(device->wined3d, device->adapter->ordinal, WINED3DFMT_UNKNOWN, i, &m);
5563         if (FAILED(hr))
5564             ERR("Failed to enumerate adapter mode.\n");
5565         if (m.Width == pp->BackBufferWidth && m.Height == pp->BackBufferHeight)
5566             /* Mode found, it is supported. */
5567             return TRUE;
5568     }
5569     /* Mode not found -> not supported */
5570     return FALSE;
5571 }
5572
5573 /* Do not call while under the GL lock. */
5574 static void delete_opengl_contexts(struct wined3d_device *device, struct wined3d_swapchain *swapchain)
5575 {
5576     struct wined3d_resource *resource, *cursor;
5577     const struct wined3d_gl_info *gl_info;
5578     struct wined3d_context *context;
5579     struct wined3d_shader *shader;
5580
5581     context = context_acquire(device, NULL);
5582     gl_info = context->gl_info;
5583
5584     LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
5585     {
5586         TRACE("Unloading resource %p.\n", resource);
5587
5588         resource->resource_ops->resource_unload(resource);
5589     }
5590
5591     LIST_FOR_EACH_ENTRY(shader, &device->shaders, struct wined3d_shader, shader_list_entry)
5592     {
5593         device->shader_backend->shader_destroy(shader);
5594     }
5595
5596     ENTER_GL();
5597     if (device->depth_blt_texture)
5598     {
5599         glDeleteTextures(1, &device->depth_blt_texture);
5600         device->depth_blt_texture = 0;
5601     }
5602     if (device->cursorTexture)
5603     {
5604         glDeleteTextures(1, &device->cursorTexture);
5605         device->cursorTexture = 0;
5606     }
5607     LEAVE_GL();
5608
5609     device->blitter->free_private(device);
5610     device->frag_pipe->free_private(device);
5611     device->shader_backend->shader_free_private(device);
5612     destroy_dummy_textures(device, gl_info);
5613
5614     context_release(context);
5615
5616     while (device->context_count)
5617     {
5618         swapchain_destroy_contexts(device->contexts[0]->swapchain);
5619     }
5620
5621     HeapFree(GetProcessHeap(), 0, swapchain->context);
5622     swapchain->context = NULL;
5623 }
5624
5625 /* Do not call while under the GL lock. */
5626 static HRESULT create_primary_opengl_context(struct wined3d_device *device, struct wined3d_swapchain *swapchain)
5627 {
5628     struct wined3d_context *context;
5629     struct wined3d_surface *target;
5630     HRESULT hr;
5631
5632     /* Recreate the primary swapchain's context */
5633     swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context));
5634     if (!swapchain->context)
5635     {
5636         ERR("Failed to allocate memory for swapchain context array.\n");
5637         return E_OUTOFMEMORY;
5638     }
5639
5640     target = swapchain->back_buffers ? swapchain->back_buffers[0] : swapchain->front_buffer;
5641     if (!(context = context_create(swapchain, target, swapchain->ds_format)))
5642     {
5643         WARN("Failed to create context.\n");
5644         HeapFree(GetProcessHeap(), 0, swapchain->context);
5645         return E_FAIL;
5646     }
5647
5648     swapchain->context[0] = context;
5649     swapchain->num_contexts = 1;
5650     create_dummy_textures(device, context);
5651     context_release(context);
5652
5653     hr = device->shader_backend->shader_alloc_private(device);
5654     if (FAILED(hr))
5655     {
5656         ERR("Failed to allocate shader private data, hr %#x.\n", hr);
5657         goto err;
5658     }
5659
5660     hr = device->frag_pipe->alloc_private(device);
5661     if (FAILED(hr))
5662     {
5663         ERR("Failed to allocate fragment pipe private data, hr %#x.\n", hr);
5664         device->shader_backend->shader_free_private(device);
5665         goto err;
5666     }
5667
5668     hr = device->blitter->alloc_private(device);
5669     if (FAILED(hr))
5670     {
5671         ERR("Failed to allocate blitter private data, hr %#x.\n", hr);
5672         device->frag_pipe->free_private(device);
5673         device->shader_backend->shader_free_private(device);
5674         goto err;
5675     }
5676
5677     return WINED3D_OK;
5678
5679 err:
5680     context_acquire(device, NULL);
5681     destroy_dummy_textures(device, context->gl_info);
5682     context_release(context);
5683     context_destroy(device, context);
5684     HeapFree(GetProcessHeap(), 0, swapchain->context);
5685     swapchain->num_contexts = 0;
5686     return hr;
5687 }
5688
5689 /* Do not call while under the GL lock. */
5690 HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
5691         WINED3DPRESENT_PARAMETERS *present_parameters,
5692         wined3d_device_reset_cb callback)
5693 {
5694     struct wined3d_resource *resource, *cursor;
5695     struct wined3d_swapchain *swapchain;
5696     BOOL DisplayModeChanged = FALSE;
5697     BOOL update_desc = FALSE;
5698     WINED3DDISPLAYMODE mode;
5699     unsigned int i;
5700     HRESULT hr;
5701
5702     TRACE("device %p, present_parameters %p.\n", device, present_parameters);
5703
5704     wined3d_device_set_index_buffer(device, NULL, WINED3DFMT_UNKNOWN);
5705     for (i = 0; i < MAX_STREAMS; ++i)
5706     {
5707         wined3d_device_set_stream_source(device, i, NULL, 0, 0);
5708     }
5709     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
5710     {
5711         wined3d_device_set_texture(device, i, NULL);
5712     }
5713     if (device->onscreen_depth_stencil)
5714     {
5715         wined3d_surface_decref(device->onscreen_depth_stencil);
5716         device->onscreen_depth_stencil = NULL;
5717     }
5718
5719     LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
5720     {
5721         TRACE("Enumerating resource %p.\n", resource);
5722         if (FAILED(hr = callback(resource)))
5723             return hr;
5724     }
5725
5726     hr = wined3d_device_get_swapchain(device, 0, &swapchain);
5727     if (FAILED(hr))
5728     {
5729         ERR("Failed to get the first implicit swapchain\n");
5730         return hr;
5731     }
5732
5733     if (!is_display_mode_supported(device, present_parameters))
5734     {
5735         WARN("Rejecting Reset() call because the requested display mode is not supported\n");
5736         WARN("Requested mode: %d, %d.\n",
5737             present_parameters->BackBufferWidth,
5738              present_parameters->BackBufferHeight);
5739         wined3d_swapchain_decref(swapchain);
5740         return WINED3DERR_INVALIDCALL;
5741     }
5742
5743     /* Is it necessary to recreate the gl context? Actually every setting can be changed
5744      * on an existing gl context, so there's no real need for recreation.
5745      *
5746      * TODO: Figure out how Reset influences resources in D3DPOOL_DEFAULT, D3DPOOL_SYSTEMMEMORY and D3DPOOL_MANAGED
5747      *
5748      * TODO: Figure out what happens to explicit swapchains, or if we have more than one implicit swapchain
5749      */
5750     TRACE("New params:\n");
5751     TRACE("BackBufferWidth = %d\n", present_parameters->BackBufferWidth);
5752     TRACE("BackBufferHeight = %d\n", present_parameters->BackBufferHeight);
5753     TRACE("BackBufferFormat = %s\n", debug_d3dformat(present_parameters->BackBufferFormat));
5754     TRACE("BackBufferCount = %d\n", present_parameters->BackBufferCount);
5755     TRACE("MultiSampleType = %d\n", present_parameters->MultiSampleType);
5756     TRACE("MultiSampleQuality = %d\n", present_parameters->MultiSampleQuality);
5757     TRACE("SwapEffect = %d\n", present_parameters->SwapEffect);
5758     TRACE("hDeviceWindow = %p\n", present_parameters->hDeviceWindow);
5759     TRACE("Windowed = %s\n", present_parameters->Windowed ? "true" : "false");
5760     TRACE("EnableAutoDepthStencil = %s\n", present_parameters->EnableAutoDepthStencil ? "true" : "false");
5761     TRACE("Flags = %08x\n", present_parameters->Flags);
5762     TRACE("FullScreen_RefreshRateInHz = %d\n", present_parameters->FullScreen_RefreshRateInHz);
5763     TRACE("PresentationInterval = %d\n", present_parameters->PresentationInterval);
5764
5765     /* No special treatment of these parameters. Just store them */
5766     swapchain->presentParms.SwapEffect = present_parameters->SwapEffect;
5767     swapchain->presentParms.Flags = present_parameters->Flags;
5768     swapchain->presentParms.PresentationInterval = present_parameters->PresentationInterval;
5769     swapchain->presentParms.FullScreen_RefreshRateInHz = present_parameters->FullScreen_RefreshRateInHz;
5770
5771     /* What to do about these? */
5772     if (present_parameters->BackBufferCount
5773             && present_parameters->BackBufferCount != swapchain->presentParms.BackBufferCount)
5774         FIXME("Cannot change the back buffer count yet.\n");
5775
5776     if (present_parameters->BackBufferFormat != WINED3DFMT_UNKNOWN
5777             && present_parameters->BackBufferFormat != swapchain->presentParms.BackBufferFormat)
5778         FIXME("Cannot change the back buffer format yet.\n");
5779
5780     if (present_parameters->hDeviceWindow
5781             && present_parameters->hDeviceWindow != swapchain->presentParms.hDeviceWindow)
5782         FIXME("Cannot change the device window yet.\n");
5783
5784     if (present_parameters->EnableAutoDepthStencil && !device->auto_depth_stencil)
5785     {
5786         HRESULT hrc;
5787
5788         TRACE("Creating the depth stencil buffer\n");
5789
5790         hrc = device->device_parent->ops->create_depth_stencil(device->device_parent,
5791                 present_parameters->BackBufferWidth,
5792                 present_parameters->BackBufferHeight,
5793                 present_parameters->AutoDepthStencilFormat,
5794                 present_parameters->MultiSampleType,
5795                 present_parameters->MultiSampleQuality,
5796                 FALSE,
5797                 &device->auto_depth_stencil);
5798         if (FAILED(hrc))
5799         {
5800             ERR("Failed to create the depth stencil buffer.\n");
5801             wined3d_swapchain_decref(swapchain);
5802             return WINED3DERR_INVALIDCALL;
5803         }
5804     }
5805
5806     if (device->onscreen_depth_stencil)
5807     {
5808         wined3d_surface_decref(device->onscreen_depth_stencil);
5809         device->onscreen_depth_stencil = NULL;
5810     }
5811
5812     /* Reset the depth stencil */
5813     if (present_parameters->EnableAutoDepthStencil)
5814         wined3d_device_set_depth_stencil(device, device->auto_depth_stencil);
5815     else
5816         wined3d_device_set_depth_stencil(device, NULL);
5817
5818     TRACE("Resetting stateblock\n");
5819     wined3d_stateblock_decref(device->updateStateBlock);
5820     wined3d_stateblock_decref(device->stateBlock);
5821
5822     if (present_parameters->Windowed)
5823     {
5824         mode.Width = swapchain->orig_width;
5825         mode.Height = swapchain->orig_height;
5826         mode.RefreshRate = 0;
5827         mode.Format = swapchain->presentParms.BackBufferFormat;
5828     }
5829     else
5830     {
5831         mode.Width = present_parameters->BackBufferWidth;
5832         mode.Height = present_parameters->BackBufferHeight;
5833         mode.RefreshRate = present_parameters->FullScreen_RefreshRateInHz;
5834         mode.Format = swapchain->presentParms.BackBufferFormat;
5835     }
5836
5837     /* Should Width == 800 && Height == 0 set 800x600? */
5838     if (present_parameters->BackBufferWidth && present_parameters->BackBufferHeight
5839             && (present_parameters->BackBufferWidth != swapchain->presentParms.BackBufferWidth
5840             || present_parameters->BackBufferHeight != swapchain->presentParms.BackBufferHeight))
5841     {
5842         if (!present_parameters->Windowed)
5843             DisplayModeChanged = TRUE;
5844
5845         swapchain->presentParms.BackBufferWidth = present_parameters->BackBufferWidth;
5846         swapchain->presentParms.BackBufferHeight = present_parameters->BackBufferHeight;
5847         update_desc = TRUE;
5848     }
5849
5850     if (present_parameters->MultiSampleType != swapchain->presentParms.MultiSampleType
5851             || present_parameters->MultiSampleQuality != swapchain->presentParms.MultiSampleQuality)
5852     {
5853         swapchain->presentParms.MultiSampleType = present_parameters->MultiSampleType;
5854         swapchain->presentParms.MultiSampleQuality = present_parameters->MultiSampleQuality;
5855         update_desc = TRUE;
5856     }
5857
5858     if (update_desc)
5859     {
5860         UINT i;
5861
5862         hr = updateSurfaceDesc(swapchain->front_buffer, &swapchain->presentParms);
5863         if (FAILED(hr))
5864         {
5865             wined3d_swapchain_decref(swapchain);
5866             return hr;
5867         }
5868
5869         for (i = 0; i < swapchain->presentParms.BackBufferCount; ++i)
5870         {
5871             hr = updateSurfaceDesc(swapchain->back_buffers[i], &swapchain->presentParms);
5872             if (FAILED(hr))
5873             {
5874                 wined3d_swapchain_decref(swapchain);
5875                 return hr;
5876             }
5877         }
5878         if (device->auto_depth_stencil)
5879         {
5880             hr = updateSurfaceDesc(device->auto_depth_stencil, &swapchain->presentParms);
5881             if (FAILED(hr))
5882             {
5883                 wined3d_swapchain_decref(swapchain);
5884                 return hr;
5885             }
5886         }
5887     }
5888
5889     delete_opengl_contexts(device, swapchain);
5890
5891     if (!present_parameters->Windowed != !swapchain->presentParms.Windowed
5892             || DisplayModeChanged)
5893     {
5894         wined3d_device_set_display_mode(device, 0, &mode);
5895
5896         if (!present_parameters->Windowed)
5897         {
5898             if (swapchain->presentParms.Windowed)
5899             {
5900                 HWND focus_window = device->createParms.hFocusWindow;
5901                 if (!focus_window)
5902                     focus_window = present_parameters->hDeviceWindow;
5903                 if (FAILED(hr = wined3d_device_acquire_focus_window(device, focus_window)))
5904                 {
5905                     ERR("Failed to acquire focus window, hr %#x.\n", hr);
5906                     wined3d_swapchain_decref(swapchain);
5907                     return hr;
5908                 }
5909
5910                 /* switch from windowed to fs */
5911                 wined3d_device_setup_fullscreen_window(device, swapchain->device_window,
5912                         present_parameters->BackBufferWidth,
5913                         present_parameters->BackBufferHeight);
5914             }
5915             else
5916             {
5917                 /* Fullscreen -> fullscreen mode change */
5918                 MoveWindow(swapchain->device_window, 0, 0,
5919                            present_parameters->BackBufferWidth, present_parameters->BackBufferHeight,
5920                            TRUE);
5921             }
5922         }
5923         else if (!swapchain->presentParms.Windowed)
5924         {
5925             /* Fullscreen -> windowed switch */
5926             wined3d_device_restore_fullscreen_window(device, swapchain->device_window);
5927             wined3d_device_release_focus_window(device);
5928         }
5929         swapchain->presentParms.Windowed = present_parameters->Windowed;
5930     }
5931     else if (!present_parameters->Windowed)
5932     {
5933         DWORD style = device->style;
5934         DWORD exStyle = device->exStyle;
5935         /* If we're in fullscreen, and the mode wasn't changed, we have to get the window back into
5936          * the right position. Some applications(Battlefield 2, Guild Wars) move it and then call
5937          * Reset to clear up their mess. Guild Wars also loses the device during that.
5938          */
5939         device->style = 0;
5940         device->exStyle = 0;
5941         wined3d_device_setup_fullscreen_window(device, swapchain->device_window,
5942                 present_parameters->BackBufferWidth,
5943                 present_parameters->BackBufferHeight);
5944         device->style = style;
5945         device->exStyle = exStyle;
5946     }
5947
5948     /* Note: No parent needed for initial internal stateblock */
5949     hr = wined3d_stateblock_create(device, WINED3DSBT_INIT, &device->stateBlock);
5950     if (FAILED(hr))
5951         ERR("Resetting the stateblock failed with error %#x.\n", hr);
5952     else
5953         TRACE("Created stateblock %p.\n", device->stateBlock);
5954     device->updateStateBlock = device->stateBlock;
5955     wined3d_stateblock_incref(device->updateStateBlock);
5956
5957     stateblock_init_default_state(device->stateBlock);
5958
5959     swapchain_update_render_to_fbo(swapchain);
5960     swapchain_update_draw_bindings(swapchain);
5961
5962     hr = create_primary_opengl_context(device, swapchain);
5963     wined3d_swapchain_decref(swapchain);
5964
5965     /* All done. There is no need to reload resources or shaders, this will happen automatically on the
5966      * first use
5967      */
5968     return hr;
5969 }
5970
5971 HRESULT CDECL wined3d_device_set_dialog_box_mode(struct wined3d_device *device, BOOL enable_dialogs)
5972 {
5973     TRACE("device %p, enable_dialogs %#x.\n", device, enable_dialogs);
5974
5975     if (!enable_dialogs) FIXME("Dialogs cannot be disabled yet.\n");
5976
5977     return WINED3D_OK;
5978 }
5979
5980
5981 HRESULT CDECL wined3d_device_get_creation_parameters(struct wined3d_device *device,
5982         WINED3DDEVICE_CREATION_PARAMETERS *parameters)
5983 {
5984     TRACE("device %p, parameters %p.\n", device, parameters);
5985
5986     *parameters = device->createParms;
5987     return WINED3D_OK;
5988 }
5989
5990 void CDECL wined3d_device_set_gamma_ramp(struct wined3d_device *device,
5991         UINT swapchain_idx, DWORD flags, const WINED3DGAMMARAMP *ramp)
5992 {
5993     struct wined3d_swapchain *swapchain;
5994
5995     TRACE("device %p, swapchain_idx %u, flags %#x, ramp %p.\n",
5996             device, swapchain_idx, flags, ramp);
5997
5998     if (SUCCEEDED(wined3d_device_get_swapchain(device, swapchain_idx, &swapchain)))
5999     {
6000         wined3d_swapchain_set_gamma_ramp(swapchain, flags, ramp);
6001         wined3d_swapchain_decref(swapchain);
6002     }
6003 }
6004
6005 void CDECL wined3d_device_get_gamma_ramp(struct wined3d_device *device, UINT swapchain_idx, WINED3DGAMMARAMP *ramp)
6006 {
6007     struct wined3d_swapchain *swapchain;
6008
6009     TRACE("device %p, swapchain_idx %u, ramp %p.\n",
6010             device, swapchain_idx, ramp);
6011
6012     if (SUCCEEDED(wined3d_device_get_swapchain(device, swapchain_idx, &swapchain)))
6013     {
6014         wined3d_swapchain_get_gamma_ramp(swapchain, ramp);
6015         wined3d_swapchain_decref(swapchain);
6016     }
6017 }
6018
6019 void device_resource_add(struct wined3d_device *device, struct wined3d_resource *resource)
6020 {
6021     TRACE("device %p, resource %p.\n", device, resource);
6022
6023     list_add_head(&device->resources, &resource->resource_list_entry);
6024 }
6025
6026 static void device_resource_remove(struct wined3d_device *device, struct wined3d_resource *resource)
6027 {
6028     TRACE("device %p, resource %p.\n", device, resource);
6029
6030     list_remove(&resource->resource_list_entry);
6031 }
6032
6033 void device_resource_released(struct wined3d_device *device, struct wined3d_resource *resource)
6034 {
6035     WINED3DRESOURCETYPE type = resource->resourceType;
6036     unsigned int i;
6037
6038     TRACE("device %p, resource %p, type %s.\n", device, resource, debug_d3dresourcetype(type));
6039
6040     context_resource_released(device, resource, type);
6041
6042     switch (type)
6043     {
6044         case WINED3DRTYPE_SURFACE:
6045             {
6046                 struct wined3d_surface *surface = surface_from_resource(resource);
6047
6048                 if (!device->d3d_initialized) break;
6049
6050                 for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
6051                 {
6052                     if (device->fb.render_targets[i] == surface)
6053                     {
6054                         ERR("Surface %p is still in use as render target %u.\n", surface, i);
6055                         device->fb.render_targets[i] = NULL;
6056                     }
6057                 }
6058
6059                 if (device->fb.depth_stencil == surface)
6060                 {
6061                     ERR("Surface %p is still in use as depth/stencil buffer.\n", surface);
6062                     device->fb.depth_stencil = NULL;
6063                 }
6064             }
6065             break;
6066
6067         case WINED3DRTYPE_TEXTURE:
6068         case WINED3DRTYPE_CUBETEXTURE:
6069         case WINED3DRTYPE_VOLUMETEXTURE:
6070             for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
6071             {
6072                 struct wined3d_texture *texture = wined3d_texture_from_resource(resource);
6073
6074                 if (device->stateBlock && device->stateBlock->state.textures[i] == texture)
6075                 {
6076                     ERR("Texture %p is still in use by stateblock %p, stage %u.\n",
6077                             texture, device->stateBlock, i);
6078                     device->stateBlock->state.textures[i] = NULL;
6079                 }
6080
6081                 if (device->updateStateBlock != device->stateBlock
6082                         && device->updateStateBlock->state.textures[i] == texture)
6083                 {
6084                     ERR("Texture %p is still in use by stateblock %p, stage %u.\n",
6085                             texture, device->updateStateBlock, i);
6086                     device->updateStateBlock->state.textures[i] = NULL;
6087                 }
6088             }
6089             break;
6090
6091         case WINED3DRTYPE_BUFFER:
6092             {
6093                 struct wined3d_buffer *buffer = buffer_from_resource(resource);
6094
6095                 for (i = 0; i < MAX_STREAMS; ++i)
6096                 {
6097                     if (device->stateBlock && device->stateBlock->state.streams[i].buffer == buffer)
6098                     {
6099                         ERR("Buffer %p is still in use by stateblock %p, stream %u.\n",
6100                                 buffer, device->stateBlock, i);
6101                         device->stateBlock->state.streams[i].buffer = NULL;
6102                     }
6103
6104                     if (device->updateStateBlock != device->stateBlock
6105                             && device->updateStateBlock->state.streams[i].buffer == buffer)
6106                     {
6107                         ERR("Buffer %p is still in use by stateblock %p, stream %u.\n",
6108                                 buffer, device->updateStateBlock, i);
6109                         device->updateStateBlock->state.streams[i].buffer = NULL;
6110                     }
6111
6112                 }
6113
6114                 if (device->stateBlock && device->stateBlock->state.index_buffer == buffer)
6115                 {
6116                     ERR("Buffer %p is still in use by stateblock %p as index buffer.\n",
6117                             buffer, device->stateBlock);
6118                     device->stateBlock->state.index_buffer =  NULL;
6119                 }
6120
6121                 if (device->updateStateBlock != device->stateBlock
6122                         && device->updateStateBlock->state.index_buffer == buffer)
6123                 {
6124                     ERR("Buffer %p is still in use by stateblock %p as index buffer.\n",
6125                             buffer, device->updateStateBlock);
6126                     device->updateStateBlock->state.index_buffer =  NULL;
6127                 }
6128             }
6129             break;
6130
6131         default:
6132             break;
6133     }
6134
6135     /* Remove the resource from the resourceStore */
6136     device_resource_remove(device, resource);
6137
6138     TRACE("Resource released.\n");
6139 }
6140
6141 HRESULT CDECL wined3d_device_get_surface_from_dc(struct wined3d_device *device,
6142         HDC dc, struct wined3d_surface **surface)
6143 {
6144     struct wined3d_resource *resource;
6145
6146     TRACE("device %p, dc %p, surface %p.\n", device, dc, surface);
6147
6148     LIST_FOR_EACH_ENTRY(resource, &device->resources, struct wined3d_resource, resource_list_entry)
6149     {
6150         if (resource->resourceType == WINED3DRTYPE_SURFACE)
6151         {
6152             struct wined3d_surface *s = surface_from_resource(resource);
6153
6154             if (s->hDC == dc)
6155             {
6156                 TRACE("Found surface %p for dc %p.\n", s, dc);
6157                 *surface = s;
6158                 return WINED3D_OK;
6159             }
6160         }
6161     }
6162
6163     return WINED3DERR_INVALIDCALL;
6164 }
6165
6166 HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d,
6167         UINT adapter_idx, WINED3DDEVTYPE device_type, HWND focus_window, DWORD flags,
6168         BYTE surface_alignment, struct wined3d_device_parent *device_parent)
6169 {
6170     struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx];
6171     const struct fragment_pipeline *fragment_pipeline;
6172     struct shader_caps shader_caps;
6173     struct fragment_caps ffp_caps;
6174     WINED3DDISPLAYMODE mode;
6175     unsigned int i;
6176     HRESULT hr;
6177
6178     device->ref = 1;
6179     device->wined3d = wined3d;
6180     wined3d_incref(device->wined3d);
6181     device->adapter = wined3d->adapter_count ? adapter : NULL;
6182     device->device_parent = device_parent;
6183     list_init(&device->resources);
6184     list_init(&device->shaders);
6185     device->surface_alignment = surface_alignment;
6186
6187     /* Get the initial screen setup for ddraw. */
6188     hr = wined3d_get_adapter_display_mode(wined3d, adapter_idx, &mode);
6189     if (FAILED(hr))
6190     {
6191         ERR("Failed to get the adapter's display mode, hr %#x.\n", hr);
6192         wined3d_decref(device->wined3d);
6193         return hr;
6194     }
6195     adapter->screen_size.cx = mode.Width;
6196     adapter->screen_size.cy = mode.Height;
6197     adapter->screen_format = mode.Format;
6198
6199     /* Save the creation parameters. */
6200     device->createParms.AdapterOrdinal = adapter_idx;
6201     device->createParms.DeviceType = device_type;
6202     device->createParms.hFocusWindow = focus_window;
6203     device->createParms.BehaviorFlags = flags;
6204
6205     device->devType = device_type;
6206     for (i = 0; i < PATCHMAP_SIZE; ++i) list_init(&device->patches[i]);
6207
6208     select_shader_mode(&adapter->gl_info, &device->ps_selected_mode, &device->vs_selected_mode);
6209     device->shader_backend = adapter->shader_backend;
6210
6211     if (device->shader_backend)
6212     {
6213         device->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
6214         device->d3d_vshader_constantF = shader_caps.MaxVertexShaderConst;
6215         device->d3d_pshader_constantF = shader_caps.MaxPixelShaderConst;
6216         device->vs_clipping = shader_caps.VSClipping;
6217     }
6218     fragment_pipeline = adapter->fragment_pipe;
6219     device->frag_pipe = fragment_pipeline;
6220     if (fragment_pipeline)
6221     {
6222         fragment_pipeline->get_caps(&adapter->gl_info, &ffp_caps);
6223         device->max_ffp_textures = ffp_caps.MaxSimultaneousTextures;
6224
6225         hr = compile_state_table(device->StateTable, device->multistate_funcs, &adapter->gl_info,
6226                                  ffp_vertexstate_template, fragment_pipeline, misc_state_template);
6227         if (FAILED(hr))
6228         {
6229             ERR("Failed to compile state table, hr %#x.\n", hr);
6230             wined3d_decref(device->wined3d);
6231             return hr;
6232         }
6233     }
6234     device->blitter = adapter->blitter;
6235
6236     return WINED3D_OK;
6237 }
6238
6239
6240 void device_invalidate_state(const struct wined3d_device *device, DWORD state)
6241 {
6242     DWORD rep = device->StateTable[state].representative;
6243     struct wined3d_context *context;
6244     DWORD idx;
6245     BYTE shift;
6246     UINT i;
6247
6248     for (i = 0; i < device->context_count; ++i)
6249     {
6250         context = device->contexts[i];
6251         if(isStateDirty(context, rep)) continue;
6252
6253         context->dirtyArray[context->numDirtyEntries++] = rep;
6254         idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
6255         shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
6256         context->isStateDirty[idx] |= (1 << shift);
6257     }
6258 }
6259
6260 void get_drawable_size_fbo(const struct wined3d_context *context, UINT *width, UINT *height)
6261 {
6262     /* The drawable size of a fbo target is the opengl texture size, which is the power of two size. */
6263     *width = context->current_rt->pow2Width;
6264     *height = context->current_rt->pow2Height;
6265 }
6266
6267 void get_drawable_size_backbuffer(const struct wined3d_context *context, UINT *width, UINT *height)
6268 {
6269     const struct wined3d_swapchain *swapchain = context->swapchain;
6270     /* The drawable size of a backbuffer / aux buffer offscreen target is the size of the
6271      * current context's drawable, which is the size of the back buffer of the swapchain
6272      * the active context belongs to. */
6273     *width = swapchain->presentParms.BackBufferWidth;
6274     *height = swapchain->presentParms.BackBufferHeight;
6275 }
6276
6277 LRESULT device_process_message(struct wined3d_device *device, HWND window, BOOL unicode,
6278         UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc)
6279 {
6280     if (device->filter_messages)
6281     {
6282         TRACE("Filtering message: window %p, message %#x, wparam %#lx, lparam %#lx.\n",
6283                 window, message, wparam, lparam);
6284         if (unicode)
6285             return DefWindowProcW(window, message, wparam, lparam);
6286         else
6287             return DefWindowProcA(window, message, wparam, lparam);
6288     }
6289
6290     if (message == WM_DESTROY)
6291     {
6292         TRACE("unregister window %p.\n", window);
6293         wined3d_unregister_window(window);
6294
6295         if (device->focus_window == window) device->focus_window = NULL;
6296         else ERR("Window %p is not the focus window for device %p.\n", window, device);
6297     }
6298
6299     if (unicode)
6300         return CallWindowProcW(proc, window, message, wparam, lparam);
6301     else
6302         return CallWindowProcA(proc, window, message, wparam, lparam);
6303 }