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(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(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(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     const struct wined3d_format *format = wined3d_get_format(&device->adapter->gl_info, mode->Format);
1631     DEVMODEW devmode;
1632     LONG ret;
1633     RECT clip_rc;
1634
1635     TRACE("device %p, swapchain_idx %u, mode %p (%ux%u@%u %s).\n", device, swapchain_idx, mode,
1636             mode->Width, mode->Height, mode->RefreshRate, debug_d3dformat(mode->Format));
1637
1638     /* Resize the screen even without a window:
1639      * The app could have unset it with SetCooperativeLevel, but not called
1640      * RestoreDisplayMode first. Then the release will call RestoreDisplayMode,
1641      * but we don't have any hwnd
1642      */
1643
1644     memset(&devmode, 0, sizeof(devmode));
1645     devmode.dmSize = sizeof(devmode);
1646     devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
1647     devmode.dmBitsPerPel = format->byte_count * CHAR_BIT;
1648     devmode.dmPelsWidth = mode->Width;
1649     devmode.dmPelsHeight = mode->Height;
1650
1651     devmode.dmDisplayFrequency = mode->RefreshRate;
1652     if (mode->RefreshRate)
1653         devmode.dmFields |= DM_DISPLAYFREQUENCY;
1654
1655     /* Only change the mode if necessary */
1656     if (device->ddraw_width == mode->Width && device->ddraw_height == mode->Height
1657             && device->ddraw_format == mode->Format && !mode->RefreshRate)
1658         return WINED3D_OK;
1659
1660     ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL);
1661     if (ret != DISP_CHANGE_SUCCESSFUL)
1662     {
1663         if (devmode.dmDisplayFrequency)
1664         {
1665             WARN("ChangeDisplaySettingsExW failed, trying without the refresh rate\n");
1666             devmode.dmFields &= ~DM_DISPLAYFREQUENCY;
1667             devmode.dmDisplayFrequency = 0;
1668             ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL;
1669         }
1670         if(ret != DISP_CHANGE_SUCCESSFUL) {
1671             return WINED3DERR_NOTAVAILABLE;
1672         }
1673     }
1674
1675     /* Store the new values */
1676     device->ddraw_width = mode->Width;
1677     device->ddraw_height = mode->Height;
1678     device->ddraw_format = mode->Format;
1679
1680     /* And finally clip mouse to our screen */
1681     SetRect(&clip_rc, 0, 0, mode->Width, mode->Height);
1682     ClipCursor(&clip_rc);
1683
1684     return WINED3D_OK;
1685 }
1686
1687 HRESULT CDECL wined3d_device_get_wined3d(struct wined3d_device *device, struct wined3d **wined3d)
1688 {
1689     TRACE("device %p, wined3d %p.\n", device, wined3d);
1690
1691     *wined3d = device->wined3d;
1692     wined3d_incref(*wined3d);
1693
1694     TRACE("Returning %p.\n", *wined3d);
1695
1696     return WINED3D_OK;
1697 }
1698
1699 UINT CDECL wined3d_device_get_available_texture_mem(struct wined3d_device *device)
1700 {
1701     TRACE("device %p.\n", device);
1702
1703     TRACE("Emulating %d MB, returning %d MB left.\n",
1704             device->adapter->TextureRam / (1024 * 1024),
1705             (device->adapter->TextureRam - device->adapter->UsedTextureRam) / (1024 * 1024));
1706
1707     return device->adapter->TextureRam - device->adapter->UsedTextureRam;
1708 }
1709
1710 HRESULT CDECL wined3d_device_set_stream_source(struct wined3d_device *device, UINT stream_idx,
1711         struct wined3d_buffer *buffer, UINT offset, UINT stride)
1712 {
1713     struct wined3d_stream_state *stream;
1714     struct wined3d_buffer *prev_buffer;
1715
1716     TRACE("device %p, stream_idx %u, buffer %p, offset %u, stride %u.\n",
1717             device, stream_idx, buffer, offset, stride);
1718
1719     if (stream_idx >= MAX_STREAMS)
1720     {
1721         WARN("Stream index %u out of range.\n", stream_idx);
1722         return WINED3DERR_INVALIDCALL;
1723     }
1724     else if (offset & 0x3)
1725     {
1726         WARN("Offset %u is not 4 byte aligned.\n", offset);
1727         return WINED3DERR_INVALIDCALL;
1728     }
1729
1730     stream = &device->updateStateBlock->state.streams[stream_idx];
1731     prev_buffer = stream->buffer;
1732
1733     device->updateStateBlock->changed.streamSource |= 1 << stream_idx;
1734
1735     if (prev_buffer == buffer
1736             && stream->stride == stride
1737             && stream->offset == offset)
1738     {
1739        TRACE("Application is setting the old values over, nothing to do.\n");
1740        return WINED3D_OK;
1741     }
1742
1743     stream->buffer = buffer;
1744     if (buffer)
1745     {
1746         stream->stride = stride;
1747         stream->offset = offset;
1748     }
1749
1750     /* Handle recording of state blocks. */
1751     if (device->isRecordingState)
1752     {
1753         TRACE("Recording... not performing anything.\n");
1754         if (buffer)
1755             wined3d_buffer_incref(buffer);
1756         if (prev_buffer)
1757             wined3d_buffer_decref(prev_buffer);
1758         return WINED3D_OK;
1759     }
1760
1761     if (buffer)
1762     {
1763         InterlockedIncrement(&buffer->bind_count);
1764         wined3d_buffer_incref(buffer);
1765     }
1766     if (prev_buffer)
1767     {
1768         InterlockedDecrement(&prev_buffer->bind_count);
1769         wined3d_buffer_decref(prev_buffer);
1770     }
1771
1772     device_invalidate_state(device, STATE_STREAMSRC);
1773
1774     return WINED3D_OK;
1775 }
1776
1777 HRESULT CDECL wined3d_device_get_stream_source(struct wined3d_device *device,
1778         UINT stream_idx, struct wined3d_buffer **buffer, UINT *offset, UINT *stride)
1779 {
1780     struct wined3d_stream_state *stream;
1781
1782     TRACE("device %p, stream_idx %u, buffer %p, offset %p, stride %p.\n",
1783             device, stream_idx, buffer, offset, stride);
1784
1785     if (stream_idx >= MAX_STREAMS)
1786     {
1787         WARN("Stream index %u out of range.\n", stream_idx);
1788         return WINED3DERR_INVALIDCALL;
1789     }
1790
1791     stream = &device->stateBlock->state.streams[stream_idx];
1792     *buffer = stream->buffer;
1793     if (*buffer)
1794         wined3d_buffer_incref(*buffer);
1795     if (offset)
1796         *offset = stream->offset;
1797     *stride = stream->stride;
1798
1799     return WINED3D_OK;
1800 }
1801
1802 HRESULT CDECL wined3d_device_set_stream_source_freq(struct wined3d_device *device, UINT stream_idx, UINT divider)
1803 {
1804     struct wined3d_stream_state *stream;
1805     UINT old_flags, old_freq;
1806
1807     TRACE("device %p, stream_idx %u, divider %#x.\n", device, stream_idx, divider);
1808
1809     /* Verify input. At least in d3d9 this is invalid. */
1810     if ((divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && (divider & WINED3DSTREAMSOURCE_INDEXEDDATA))
1811     {
1812         WARN("INSTANCEDATA and INDEXEDDATA were set, returning D3DERR_INVALIDCALL.\n");
1813         return WINED3DERR_INVALIDCALL;
1814     }
1815     if ((divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && !stream_idx)
1816     {
1817         WARN("INSTANCEDATA used on stream 0, returning D3DERR_INVALIDCALL.\n");
1818         return WINED3DERR_INVALIDCALL;
1819     }
1820     if (!divider)
1821     {
1822         WARN("Divider is 0, returning D3DERR_INVALIDCALL.\n");
1823         return WINED3DERR_INVALIDCALL;
1824     }
1825
1826     stream = &device->updateStateBlock->state.streams[stream_idx];
1827     old_flags = stream->flags;
1828     old_freq = stream->frequency;
1829
1830     stream->flags = divider & (WINED3DSTREAMSOURCE_INSTANCEDATA | WINED3DSTREAMSOURCE_INDEXEDDATA);
1831     stream->frequency = divider & 0x7fffff;
1832
1833     device->updateStateBlock->changed.streamFreq |= 1 << stream_idx;
1834
1835     if (stream->frequency != old_freq || stream->flags != old_flags)
1836         device_invalidate_state(device, STATE_STREAMSRC);
1837
1838     return WINED3D_OK;
1839 }
1840
1841 HRESULT CDECL wined3d_device_get_stream_source_freq(struct wined3d_device *device, UINT stream_idx, UINT *divider)
1842 {
1843     struct wined3d_stream_state *stream;
1844
1845     TRACE("device %p, stream_idx %u, divider %p.\n", device, stream_idx, divider);
1846
1847     stream = &device->updateStateBlock->state.streams[stream_idx];
1848     *divider = stream->flags | stream->frequency;
1849
1850     TRACE("Returning %#x.\n", *divider);
1851
1852     return WINED3D_OK;
1853 }
1854
1855 HRESULT CDECL wined3d_device_set_transform(struct wined3d_device *device,
1856         WINED3DTRANSFORMSTATETYPE d3dts, const WINED3DMATRIX *matrix)
1857 {
1858     TRACE("device %p, state %s, matrix %p.\n",
1859             device, debug_d3dtstype(d3dts), matrix);
1860
1861     /* Handle recording of state blocks. */
1862     if (device->isRecordingState)
1863     {
1864         TRACE("Recording... not performing anything.\n");
1865         device->updateStateBlock->changed.transform[d3dts >> 5] |= 1 << (d3dts & 0x1f);
1866         device->updateStateBlock->state.transforms[d3dts] = *matrix;
1867         return WINED3D_OK;
1868     }
1869
1870     /* If the new matrix is the same as the current one,
1871      * we cut off any further processing. this seems to be a reasonable
1872      * optimization because as was noticed, some apps (warcraft3 for example)
1873      * tend towards setting the same matrix repeatedly for some reason.
1874      *
1875      * From here on we assume that the new matrix is different, wherever it matters. */
1876     if (!memcmp(&device->stateBlock->state.transforms[d3dts].u.m[0][0], matrix, sizeof(*matrix)))
1877     {
1878         TRACE("The application is setting the same matrix over again.\n");
1879         return WINED3D_OK;
1880     }
1881
1882     conv_mat(matrix, &device->stateBlock->state.transforms[d3dts].u.m[0][0]);
1883
1884     /* ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord
1885      * where ViewMat = Camera space, WorldMat = world space.
1886      *
1887      * In OpenGL, camera and world space is combined into GL_MODELVIEW
1888      * matrix.  The Projection matrix stay projection matrix. */
1889
1890     if (d3dts == WINED3DTS_VIEW)
1891         device->view_ident = !memcmp(matrix, identity, 16 * sizeof(float));
1892
1893     if (d3dts < WINED3DTS_WORLDMATRIX(device->adapter->gl_info.limits.blends))
1894         device_invalidate_state(device, STATE_TRANSFORM(d3dts));
1895
1896     return WINED3D_OK;
1897
1898 }
1899
1900 HRESULT CDECL wined3d_device_get_transform(struct wined3d_device *device,
1901         WINED3DTRANSFORMSTATETYPE state, WINED3DMATRIX *matrix)
1902 {
1903     TRACE("device %p, state %s, matrix %p.\n", device, debug_d3dtstype(state), matrix);
1904
1905     *matrix = device->stateBlock->state.transforms[state];
1906
1907     return WINED3D_OK;
1908 }
1909
1910 HRESULT CDECL wined3d_device_multiply_transform(struct wined3d_device *device,
1911         WINED3DTRANSFORMSTATETYPE state, const WINED3DMATRIX *matrix)
1912 {
1913     const WINED3DMATRIX *mat = NULL;
1914     WINED3DMATRIX temp;
1915
1916     TRACE("device %p, state %s, matrix %p.\n", device, debug_d3dtstype(state), matrix);
1917
1918     /* Note: Using 'updateStateBlock' rather than 'stateblock' in the code
1919      * below means it will be recorded in a state block change, but it
1920      * works regardless where it is recorded.
1921      * If this is found to be wrong, change to StateBlock. */
1922     if (state > HIGHEST_TRANSFORMSTATE)
1923     {
1924         WARN("Unhandled transform state %#x.\n", state);
1925         return WINED3D_OK;
1926     }
1927
1928     mat = &device->updateStateBlock->state.transforms[state];
1929     multiply_matrix(&temp, mat, matrix);
1930
1931     /* Apply change via set transform - will reapply to eg. lights this way. */
1932     return wined3d_device_set_transform(device, state, &temp);
1933 }
1934
1935 /* Note lights are real special cases. Although the device caps state only
1936  * e.g. 8 are supported, you can reference any indexes you want as long as
1937  * that number max are enabled at any one point in time. Therefore since the
1938  * indices can be anything, we need a hashmap of them. However, this causes
1939  * stateblock problems. When capturing the state block, I duplicate the
1940  * hashmap, but when recording, just build a chain pretty much of commands to
1941  * be replayed. */
1942 HRESULT CDECL wined3d_device_set_light(struct wined3d_device *device, UINT light_idx, const WINED3DLIGHT *light)
1943 {
1944     UINT hash_idx = LIGHTMAP_HASHFUNC(light_idx);
1945     struct wined3d_light_info *object = NULL;
1946     struct list *e;
1947     float rho;
1948
1949     TRACE("device %p, light_idx %u, light %p.\n", device, light_idx, light);
1950
1951     /* Check the parameter range. Need for speed most wanted sets junk lights
1952      * which confuse the GL driver. */
1953     if (!light)
1954         return WINED3DERR_INVALIDCALL;
1955
1956     switch (light->Type)
1957     {
1958         case WINED3DLIGHT_POINT:
1959         case WINED3DLIGHT_SPOT:
1960         case WINED3DLIGHT_PARALLELPOINT:
1961         case WINED3DLIGHT_GLSPOT:
1962             /* Incorrect attenuation values can cause the gl driver to crash.
1963              * Happens with Need for speed most wanted. */
1964             if (light->Attenuation0 < 0.0f || light->Attenuation1 < 0.0f || light->Attenuation2 < 0.0f)
1965             {
1966                 WARN("Attenuation is negative, returning WINED3DERR_INVALIDCALL.\n");
1967                 return WINED3DERR_INVALIDCALL;
1968             }
1969             break;
1970
1971         case WINED3DLIGHT_DIRECTIONAL:
1972             /* Ignores attenuation */
1973             break;
1974
1975         default:
1976         WARN("Light type out of range, returning WINED3DERR_INVALIDCALL\n");
1977         return WINED3DERR_INVALIDCALL;
1978     }
1979
1980     LIST_FOR_EACH(e, &device->updateStateBlock->state.light_map[hash_idx])
1981     {
1982         object = LIST_ENTRY(e, struct wined3d_light_info, entry);
1983         if (object->OriginalIndex == light_idx)
1984             break;
1985         object = NULL;
1986     }
1987
1988     if (!object)
1989     {
1990         TRACE("Adding new light\n");
1991         object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1992         if (!object)
1993         {
1994             ERR("Out of memory error when allocating a light\n");
1995             return E_OUTOFMEMORY;
1996         }
1997         list_add_head(&device->updateStateBlock->state.light_map[hash_idx], &object->entry);
1998         object->glIndex = -1;
1999         object->OriginalIndex = light_idx;
2000     }
2001
2002     /* Initialize the object. */
2003     TRACE("Light %d setting to type %d, Diffuse(%f,%f,%f,%f), Specular(%f,%f,%f,%f), Ambient(%f,%f,%f,%f)\n",
2004             light_idx, light->Type,
2005             light->Diffuse.r, light->Diffuse.g, light->Diffuse.b, light->Diffuse.a,
2006             light->Specular.r, light->Specular.g, light->Specular.b, light->Specular.a,
2007             light->Ambient.r, light->Ambient.g, light->Ambient.b, light->Ambient.a);
2008     TRACE("... Pos(%f,%f,%f), Dir(%f,%f,%f)\n", light->Position.x, light->Position.y, light->Position.z,
2009             light->Direction.x, light->Direction.y, light->Direction.z);
2010     TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n",
2011             light->Range, light->Falloff, light->Theta, light->Phi);
2012
2013     /* Save away the information. */
2014     object->OriginalParms = *light;
2015
2016     switch (light->Type)
2017     {
2018         case WINED3DLIGHT_POINT:
2019             /* Position */
2020             object->lightPosn[0] = light->Position.x;
2021             object->lightPosn[1] = light->Position.y;
2022             object->lightPosn[2] = light->Position.z;
2023             object->lightPosn[3] = 1.0f;
2024             object->cutoff = 180.0f;
2025             /* FIXME: Range */
2026             break;
2027
2028         case WINED3DLIGHT_DIRECTIONAL:
2029             /* Direction */
2030             object->lightPosn[0] = -light->Direction.x;
2031             object->lightPosn[1] = -light->Direction.y;
2032             object->lightPosn[2] = -light->Direction.z;
2033             object->lightPosn[3] = 0.0f;
2034             object->exponent = 0.0f;
2035             object->cutoff = 180.0f;
2036             break;
2037
2038         case WINED3DLIGHT_SPOT:
2039             /* Position */
2040             object->lightPosn[0] = light->Position.x;
2041             object->lightPosn[1] = light->Position.y;
2042             object->lightPosn[2] = light->Position.z;
2043             object->lightPosn[3] = 1.0f;
2044
2045             /* Direction */
2046             object->lightDirn[0] = light->Direction.x;
2047             object->lightDirn[1] = light->Direction.y;
2048             object->lightDirn[2] = light->Direction.z;
2049             object->lightDirn[3] = 1.0f;
2050
2051             /* opengl-ish and d3d-ish spot lights use too different models
2052              * for the light "intensity" as a function of the angle towards
2053              * the main light direction, so we only can approximate very
2054              * roughly. However, spot lights are rather rarely used in games
2055              * (if ever used at all). Furthermore if still used, probably
2056              * nobody pays attention to such details. */
2057             if (!light->Falloff)
2058             {
2059                 /* Falloff = 0 is easy, because d3d's and opengl's spot light
2060                  * equations have the falloff resp. exponent parameter as an
2061                  * exponent, so the spot light lighting will always be 1.0 for
2062                  * both of them, and we don't have to care for the rest of the
2063                  * rather complex calculation. */
2064                 object->exponent = 0.0f;
2065             }
2066             else
2067             {
2068                 rho = light->Theta + (light->Phi - light->Theta) / (2 * light->Falloff);
2069                 if (rho < 0.0001f)
2070                     rho = 0.0001f;
2071                 object->exponent = -0.3f / logf(cosf(rho / 2));
2072             }
2073
2074             if (object->exponent > 128.0f)
2075                 object->exponent = 128.0f;
2076
2077             object->cutoff = (float)(light->Phi * 90 / M_PI);
2078             /* FIXME: Range */
2079             break;
2080
2081         default:
2082             FIXME("Unrecognized light type %#x.\n", light->Type);
2083     }
2084
2085     /* Update the live definitions if the light is currently assigned a glIndex. */
2086     if (object->glIndex != -1 && !device->isRecordingState)
2087         device_invalidate_state(device, STATE_ACTIVELIGHT(object->glIndex));
2088
2089     return WINED3D_OK;
2090 }
2091
2092 HRESULT CDECL wined3d_device_get_light(struct wined3d_device *device, UINT light_idx, WINED3DLIGHT *light)
2093 {
2094     UINT hash_idx = LIGHTMAP_HASHFUNC(light_idx);
2095     struct wined3d_light_info *light_info = NULL;
2096     struct list *e;
2097
2098     TRACE("device %p, light_idx %u, light %p.\n", device, light_idx, light);
2099
2100     LIST_FOR_EACH(e, &device->stateBlock->state.light_map[hash_idx])
2101     {
2102         light_info = LIST_ENTRY(e, struct wined3d_light_info, entry);
2103         if (light_info->OriginalIndex == light_idx)
2104             break;
2105         light_info = NULL;
2106     }
2107
2108     if (!light_info)
2109     {
2110         TRACE("Light information requested but light not defined\n");
2111         return WINED3DERR_INVALIDCALL;
2112     }
2113
2114     *light = light_info->OriginalParms;
2115     return WINED3D_OK;
2116 }
2117
2118 HRESULT CDECL wined3d_device_set_light_enable(struct wined3d_device *device, UINT light_idx, BOOL enable)
2119 {
2120     UINT hash_idx = LIGHTMAP_HASHFUNC(light_idx);
2121     struct wined3d_light_info *light_info = NULL;
2122     struct list *e;
2123
2124     TRACE("device %p, light_idx %u, enable %#x.\n", device, light_idx, enable);
2125
2126     LIST_FOR_EACH(e, &device->updateStateBlock->state.light_map[hash_idx])
2127     {
2128         light_info = LIST_ENTRY(e, struct wined3d_light_info, entry);
2129         if (light_info->OriginalIndex == light_idx)
2130             break;
2131         light_info = NULL;
2132     }
2133     TRACE("Found light %p.\n", light_info);
2134
2135     /* Special case - enabling an undefined light creates one with a strict set of parameters. */
2136     if (!light_info)
2137     {
2138         TRACE("Light enabled requested but light not defined, so defining one!\n");
2139         wined3d_device_set_light(device, light_idx, &WINED3D_default_light);
2140
2141         /* Search for it again! Should be fairly quick as near head of list. */
2142         LIST_FOR_EACH(e, &device->updateStateBlock->state.light_map[hash_idx])
2143         {
2144             light_info = LIST_ENTRY(e, struct wined3d_light_info, entry);
2145             if (light_info->OriginalIndex == light_idx)
2146                 break;
2147             light_info = NULL;
2148         }
2149         if (!light_info)
2150         {
2151             FIXME("Adding default lights has failed dismally\n");
2152             return WINED3DERR_INVALIDCALL;
2153         }
2154     }
2155
2156     if (!enable)
2157     {
2158         if (light_info->glIndex != -1)
2159         {
2160             if (!device->isRecordingState)
2161                 device_invalidate_state(device, STATE_ACTIVELIGHT(light_info->glIndex));
2162
2163             device->updateStateBlock->state.lights[light_info->glIndex] = NULL;
2164             light_info->glIndex = -1;
2165         }
2166         else
2167         {
2168             TRACE("Light already disabled, nothing to do\n");
2169         }
2170         light_info->enabled = FALSE;
2171     }
2172     else
2173     {
2174         light_info->enabled = TRUE;
2175         if (light_info->glIndex != -1)
2176         {
2177             TRACE("Nothing to do as light was enabled\n");
2178         }
2179         else
2180         {
2181             unsigned int i;
2182             const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2183             /* Find a free GL light. */
2184             for (i = 0; i < gl_info->limits.lights; ++i)
2185             {
2186                 if (!device->updateStateBlock->state.lights[i])
2187                 {
2188                     device->updateStateBlock->state.lights[i] = light_info;
2189                     light_info->glIndex = i;
2190                     break;
2191                 }
2192             }
2193             if (light_info->glIndex == -1)
2194             {
2195                 /* Our tests show that Windows returns D3D_OK in this situation, even with
2196                  * D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE devices. This
2197                  * is consistent among ddraw, d3d8 and d3d9. GetLightEnable returns TRUE
2198                  * as well for those lights.
2199                  *
2200                  * TODO: Test how this affects rendering. */
2201                 WARN("Too many concurrently active lights\n");
2202                 return WINED3D_OK;
2203             }
2204
2205             /* i == light_info->glIndex */
2206             if (!device->isRecordingState)
2207                 device_invalidate_state(device, STATE_ACTIVELIGHT(i));
2208         }
2209     }
2210
2211     return WINED3D_OK;
2212 }
2213
2214 HRESULT CDECL wined3d_device_get_light_enable(struct wined3d_device *device, UINT light_idx, BOOL *enable)
2215 {
2216     UINT hash_idx = LIGHTMAP_HASHFUNC(light_idx);
2217     struct wined3d_light_info *light_info = NULL;
2218     struct list *e;
2219
2220     TRACE("device %p, light_idx %u, enable %p.\n", device, light_idx, enable);
2221
2222     LIST_FOR_EACH(e, &device->stateBlock->state.light_map[hash_idx])
2223     {
2224         light_info = LIST_ENTRY(e, struct wined3d_light_info, entry);
2225         if (light_info->OriginalIndex == light_idx)
2226             break;
2227         light_info = NULL;
2228     }
2229
2230     if (!light_info)
2231     {
2232         TRACE("Light enabled state requested but light not defined.\n");
2233         return WINED3DERR_INVALIDCALL;
2234     }
2235     /* true is 128 according to SetLightEnable */
2236     *enable = light_info->enabled ? 128 : 0;
2237     return WINED3D_OK;
2238 }
2239
2240 HRESULT CDECL wined3d_device_set_clip_plane(struct wined3d_device *device, UINT plane_idx, const float *plane)
2241 {
2242     TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
2243
2244     /* Validate plane_idx. */
2245     if (plane_idx >= device->adapter->gl_info.limits.clipplanes)
2246     {
2247         TRACE("Application has requested clipplane this device doesn't support.\n");
2248         return WINED3DERR_INVALIDCALL;
2249     }
2250
2251     device->updateStateBlock->changed.clipplane |= 1 << plane_idx;
2252
2253     if (device->updateStateBlock->state.clip_planes[plane_idx][0] == plane[0]
2254             && device->updateStateBlock->state.clip_planes[plane_idx][1] == plane[1]
2255             && device->updateStateBlock->state.clip_planes[plane_idx][2] == plane[2]
2256             && device->updateStateBlock->state.clip_planes[plane_idx][3] == plane[3])
2257     {
2258         TRACE("Application is setting old values over, nothing to do.\n");
2259         return WINED3D_OK;
2260     }
2261
2262     device->updateStateBlock->state.clip_planes[plane_idx][0] = plane[0];
2263     device->updateStateBlock->state.clip_planes[plane_idx][1] = plane[1];
2264     device->updateStateBlock->state.clip_planes[plane_idx][2] = plane[2];
2265     device->updateStateBlock->state.clip_planes[plane_idx][3] = plane[3];
2266
2267     /* Handle recording of state blocks. */
2268     if (device->isRecordingState)
2269     {
2270         TRACE("Recording... not performing anything.\n");
2271         return WINED3D_OK;
2272     }
2273
2274     device_invalidate_state(device, STATE_CLIPPLANE(plane_idx));
2275
2276     return WINED3D_OK;
2277 }
2278
2279 HRESULT CDECL wined3d_device_get_clip_plane(struct wined3d_device *device, UINT plane_idx, float *plane)
2280 {
2281     TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
2282
2283     /* Validate plane_idx. */
2284     if (plane_idx >= device->adapter->gl_info.limits.clipplanes)
2285     {
2286         TRACE("Application has requested clipplane this device doesn't support.\n");
2287         return WINED3DERR_INVALIDCALL;
2288     }
2289
2290     plane[0] = (float)device->stateBlock->state.clip_planes[plane_idx][0];
2291     plane[1] = (float)device->stateBlock->state.clip_planes[plane_idx][1];
2292     plane[2] = (float)device->stateBlock->state.clip_planes[plane_idx][2];
2293     plane[3] = (float)device->stateBlock->state.clip_planes[plane_idx][3];
2294
2295     return WINED3D_OK;
2296 }
2297
2298 HRESULT CDECL wined3d_device_set_clip_status(struct wined3d_device *device, const WINED3DCLIPSTATUS *clip_status)
2299 {
2300     FIXME("device %p, clip_status %p stub!\n", device, clip_status);
2301
2302     if (!clip_status)
2303         return WINED3DERR_INVALIDCALL;
2304
2305     return WINED3D_OK;
2306 }
2307
2308 HRESULT CDECL wined3d_device_get_clip_status(struct wined3d_device *device, WINED3DCLIPSTATUS *clip_status)
2309 {
2310     FIXME("device %p, clip_status %p stub!\n", device, clip_status);
2311
2312     if (!clip_status)
2313         return WINED3DERR_INVALIDCALL;
2314
2315     return WINED3D_OK;
2316 }
2317
2318 HRESULT CDECL wined3d_device_set_material(struct wined3d_device *device, const WINED3DMATERIAL *material)
2319 {
2320     TRACE("device %p, material %p.\n", device, material);
2321
2322     device->updateStateBlock->changed.material = TRUE;
2323     device->updateStateBlock->state.material = *material;
2324
2325     /* Handle recording of state blocks */
2326     if (device->isRecordingState)
2327     {
2328         TRACE("Recording... not performing anything.\n");
2329         return WINED3D_OK;
2330     }
2331
2332     device_invalidate_state(device, STATE_MATERIAL);
2333
2334     return WINED3D_OK;
2335 }
2336
2337 HRESULT CDECL wined3d_device_get_material(struct wined3d_device *device, WINED3DMATERIAL *material)
2338 {
2339     TRACE("device %p, material %p.\n", device, material);
2340
2341     *material = device->updateStateBlock->state.material;
2342
2343     TRACE("Diffuse {%.8e, %.8e, %.8e, %.8e}\n",
2344             material->Diffuse.r, material->Diffuse.g,
2345             material->Diffuse.b, material->Diffuse.a);
2346     TRACE("Ambient {%.8e, %.8e, %.8e, %.8e}\n",
2347             material->Ambient.r, material->Ambient.g,
2348             material->Ambient.b, material->Ambient.a);
2349     TRACE("Specular {%.8e, %.8e, %.8e, %.8e}\n",
2350             material->Specular.r, material->Specular.g,
2351             material->Specular.b, material->Specular.a);
2352     TRACE("Emissive {%.8e, %.8e, %.8e, %.8e}\n",
2353             material->Emissive.r, material->Emissive.g,
2354             material->Emissive.b, material->Emissive.a);
2355     TRACE("Power %.8e.\n", material->Power);
2356
2357     return WINED3D_OK;
2358 }
2359
2360 HRESULT CDECL wined3d_device_set_index_buffer(struct wined3d_device *device,
2361         struct wined3d_buffer *buffer, enum wined3d_format_id format_id)
2362 {
2363     struct wined3d_buffer *prev_buffer;
2364
2365     TRACE("device %p, buffer %p, format %s.\n",
2366             device, buffer, debug_d3dformat(format_id));
2367
2368     prev_buffer = device->updateStateBlock->state.index_buffer;
2369
2370     device->updateStateBlock->changed.indices = TRUE;
2371     device->updateStateBlock->state.index_buffer = buffer;
2372     device->updateStateBlock->state.index_format = format_id;
2373
2374     /* Handle recording of state blocks. */
2375     if (device->isRecordingState)
2376     {
2377         TRACE("Recording... not performing anything.\n");
2378         if (buffer)
2379             wined3d_buffer_incref(buffer);
2380         if (prev_buffer)
2381             wined3d_buffer_decref(prev_buffer);
2382         return WINED3D_OK;
2383     }
2384
2385     if (prev_buffer != buffer)
2386     {
2387         device_invalidate_state(device, STATE_INDEXBUFFER);
2388         if (buffer)
2389         {
2390             InterlockedIncrement(&buffer->bind_count);
2391             wined3d_buffer_incref(buffer);
2392         }
2393         if (prev_buffer)
2394         {
2395             InterlockedDecrement(&prev_buffer->bind_count);
2396             wined3d_buffer_decref(prev_buffer);
2397         }
2398     }
2399
2400     return WINED3D_OK;
2401 }
2402
2403 HRESULT CDECL wined3d_device_get_index_buffer(struct wined3d_device *device, struct wined3d_buffer **buffer)
2404 {
2405     TRACE("device %p, buffer %p.\n", device, buffer);
2406
2407     *buffer = device->stateBlock->state.index_buffer;
2408
2409     if (*buffer)
2410         wined3d_buffer_incref(*buffer);
2411
2412     TRACE("Returning %p.\n", *buffer);
2413
2414     return WINED3D_OK;
2415 }
2416
2417 /* Method to offer d3d9 a simple way to set the base vertex index without messing with the index buffer */
2418 HRESULT CDECL wined3d_device_set_base_vertex_index(struct wined3d_device *device, INT base_index)
2419 {
2420     TRACE("device %p, base_index %d.\n", device, base_index);
2421
2422     if (device->updateStateBlock->state.base_vertex_index == base_index)
2423     {
2424         TRACE("Application is setting the old value over, nothing to do\n");
2425         return WINED3D_OK;
2426     }
2427
2428     device->updateStateBlock->state.base_vertex_index = base_index;
2429
2430     if (device->isRecordingState)
2431     {
2432         TRACE("Recording... not performing anything\n");
2433         return WINED3D_OK;
2434     }
2435     return WINED3D_OK;
2436 }
2437
2438 INT CDECL wined3d_device_get_base_vertex_index(struct wined3d_device *device)
2439 {
2440     TRACE("device %p.\n", device);
2441
2442     return device->stateBlock->state.base_vertex_index;
2443 }
2444
2445 HRESULT CDECL wined3d_device_set_viewport(struct wined3d_device *device, const WINED3DVIEWPORT *viewport)
2446 {
2447     TRACE("device %p, viewport %p.\n", device, viewport);
2448     TRACE("x %u, y %u, w %u, h %u, minz %.8e, maxz %.8e.\n",
2449           viewport->X, viewport->Y, viewport->Width, viewport->Height, viewport->MinZ, viewport->MaxZ);
2450
2451     device->updateStateBlock->changed.viewport = TRUE;
2452     device->updateStateBlock->state.viewport = *viewport;
2453
2454     /* Handle recording of state blocks */
2455     if (device->isRecordingState)
2456     {
2457         TRACE("Recording... not performing anything\n");
2458         return WINED3D_OK;
2459     }
2460
2461     device_invalidate_state(device, STATE_VIEWPORT);
2462
2463     return WINED3D_OK;
2464 }
2465
2466 HRESULT CDECL wined3d_device_get_viewport(struct wined3d_device *device, WINED3DVIEWPORT *viewport)
2467 {
2468     TRACE("device %p, viewport %p.\n", device, viewport);
2469
2470     *viewport = device->stateBlock->state.viewport;
2471
2472     return WINED3D_OK;
2473 }
2474
2475 HRESULT CDECL wined3d_device_set_render_state(struct wined3d_device *device,
2476         WINED3DRENDERSTATETYPE state, DWORD value)
2477 {
2478     DWORD old_value = device->stateBlock->state.render_states[state];
2479
2480     TRACE("device %p, state %s (%#x), value %#x.\n", device, debug_d3drenderstate(state), state, value);
2481
2482     device->updateStateBlock->changed.renderState[state >> 5] |= 1 << (state & 0x1f);
2483     device->updateStateBlock->state.render_states[state] = value;
2484
2485     /* Handle recording of state blocks. */
2486     if (device->isRecordingState)
2487     {
2488         TRACE("Recording... not performing anything.\n");
2489         return WINED3D_OK;
2490     }
2491
2492     /* Compared here and not before the assignment to allow proper stateblock recording. */
2493     if (value == old_value)
2494         TRACE("Application is setting the old value over, nothing to do.\n");
2495     else
2496         device_invalidate_state(device, STATE_RENDER(state));
2497
2498     return WINED3D_OK;
2499 }
2500
2501 HRESULT CDECL wined3d_device_get_render_state(struct wined3d_device *device,
2502         WINED3DRENDERSTATETYPE state, DWORD *value)
2503 {
2504     TRACE("device %p, state %s (%#x), value %p.\n", device, debug_d3drenderstate(state), state, value);
2505
2506     *value = device->stateBlock->state.render_states[state];
2507
2508     return WINED3D_OK;
2509 }
2510
2511 HRESULT CDECL wined3d_device_set_sampler_state(struct wined3d_device *device,
2512         UINT sampler_idx, WINED3DSAMPLERSTATETYPE state, DWORD value)
2513 {
2514     DWORD old_value;
2515
2516     TRACE("device %p, sampler_idx %u, state %s, value %#x.\n",
2517             device, sampler_idx, debug_d3dsamplerstate(state), value);
2518
2519     if (sampler_idx >= WINED3DVERTEXTEXTURESAMPLER0 && sampler_idx <= WINED3DVERTEXTEXTURESAMPLER3)
2520         sampler_idx -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
2521
2522     if (sampler_idx >= sizeof(device->stateBlock->state.sampler_states)
2523             / sizeof(*device->stateBlock->state.sampler_states))
2524     {
2525         WARN("Invalid sampler %u.\n", sampler_idx);
2526         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
2527     }
2528
2529     old_value = device->stateBlock->state.sampler_states[sampler_idx][state];
2530     device->updateStateBlock->state.sampler_states[sampler_idx][state] = value;
2531     device->updateStateBlock->changed.samplerState[sampler_idx] |= 1 << state;
2532
2533     /* Handle recording of state blocks. */
2534     if (device->isRecordingState)
2535     {
2536         TRACE("Recording... not performing anything.\n");
2537         return WINED3D_OK;
2538     }
2539
2540     if (old_value == value)
2541     {
2542         TRACE("Application is setting the old value over, nothing to do.\n");
2543         return WINED3D_OK;
2544     }
2545
2546     device_invalidate_state(device, STATE_SAMPLER(sampler_idx));
2547
2548     return WINED3D_OK;
2549 }
2550
2551 HRESULT CDECL wined3d_device_get_sampler_state(struct wined3d_device *device,
2552         UINT sampler_idx, WINED3DSAMPLERSTATETYPE state, DWORD *value)
2553 {
2554     TRACE("device %p, sampler_idx %u, state %s, value %p.\n",
2555             device, sampler_idx, debug_d3dsamplerstate(state), value);
2556
2557     if (sampler_idx >= WINED3DVERTEXTEXTURESAMPLER0 && sampler_idx <= WINED3DVERTEXTEXTURESAMPLER3)
2558         sampler_idx -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
2559
2560     if (sampler_idx >= sizeof(device->stateBlock->state.sampler_states)
2561             / sizeof(*device->stateBlock->state.sampler_states))
2562     {
2563         WARN("Invalid sampler %u.\n", sampler_idx);
2564         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
2565     }
2566
2567     *value = device->stateBlock->state.sampler_states[sampler_idx][state];
2568     TRACE("Returning %#x.\n", *value);
2569
2570     return WINED3D_OK;
2571 }
2572
2573 HRESULT CDECL wined3d_device_set_scissor_rect(struct wined3d_device *device, const RECT *rect)
2574 {
2575     TRACE("device %p, rect %s.\n", device, wine_dbgstr_rect(rect));
2576
2577     device->updateStateBlock->changed.scissorRect = TRUE;
2578     if (EqualRect(&device->updateStateBlock->state.scissor_rect, rect))
2579     {
2580         TRACE("App is setting the old scissor rectangle over, nothing to do.\n");
2581         return WINED3D_OK;
2582     }
2583     CopyRect(&device->updateStateBlock->state.scissor_rect, rect);
2584
2585     if (device->isRecordingState)
2586     {
2587         TRACE("Recording... not performing anything.\n");
2588         return WINED3D_OK;
2589     }
2590
2591     device_invalidate_state(device, STATE_SCISSORRECT);
2592
2593     return WINED3D_OK;
2594 }
2595
2596 HRESULT CDECL wined3d_device_get_scissor_rect(struct wined3d_device *device, RECT *rect)
2597 {
2598     TRACE("device %p, rect %p.\n", device, rect);
2599
2600     *rect = device->updateStateBlock->state.scissor_rect;
2601     TRACE("Returning rect %s.\n", wine_dbgstr_rect(rect));
2602
2603     return WINED3D_OK;
2604 }
2605
2606 HRESULT CDECL wined3d_device_set_vertex_declaration(struct wined3d_device *device,
2607         struct wined3d_vertex_declaration *declaration)
2608 {
2609     struct wined3d_vertex_declaration *prev = device->updateStateBlock->state.vertex_declaration;
2610
2611     TRACE("device %p, declaration %p.\n", device, declaration);
2612
2613     if (declaration)
2614         wined3d_vertex_declaration_incref(declaration);
2615     if (prev)
2616         wined3d_vertex_declaration_decref(prev);
2617
2618     device->updateStateBlock->state.vertex_declaration = declaration;
2619     device->updateStateBlock->changed.vertexDecl = TRUE;
2620
2621     if (device->isRecordingState)
2622     {
2623         TRACE("Recording... not performing anything.\n");
2624         return WINED3D_OK;
2625     }
2626     else if (declaration == prev)
2627     {
2628         /* Checked after the assignment to allow proper stateblock recording. */
2629         TRACE("Application is setting the old declaration over, nothing to do.\n");
2630         return WINED3D_OK;
2631     }
2632
2633     device_invalidate_state(device, STATE_VDECL);
2634     return WINED3D_OK;
2635 }
2636
2637 HRESULT CDECL wined3d_device_get_vertex_declaration(struct wined3d_device *device,
2638         struct wined3d_vertex_declaration **declaration)
2639 {
2640     TRACE("device %p, declaration %p.\n", device, declaration);
2641
2642     *declaration = device->stateBlock->state.vertex_declaration;
2643     if (*declaration)
2644         wined3d_vertex_declaration_incref(*declaration);
2645
2646     return WINED3D_OK;
2647 }
2648
2649 HRESULT CDECL wined3d_device_set_vertex_shader(struct wined3d_device *device, struct wined3d_shader *shader)
2650 {
2651     struct wined3d_shader *prev = device->updateStateBlock->state.vertex_shader;
2652
2653     TRACE("device %p, shader %p.\n", device, shader);
2654
2655     device->updateStateBlock->state.vertex_shader = shader;
2656     device->updateStateBlock->changed.vertexShader = TRUE;
2657
2658     if (device->isRecordingState)
2659     {
2660         if (shader)
2661             wined3d_shader_incref(shader);
2662         if (prev)
2663             wined3d_shader_decref(prev);
2664         TRACE("Recording... not performing anything.\n");
2665         return WINED3D_OK;
2666     }
2667
2668     if (shader == prev)
2669     {
2670         TRACE("Application is setting the old shader over, nothing to do.\n");
2671         return WINED3D_OK;
2672     }
2673
2674     if (shader)
2675         wined3d_shader_incref(shader);
2676     if (prev)
2677         wined3d_shader_decref(prev);
2678
2679     device_invalidate_state(device, STATE_VSHADER);
2680
2681     return WINED3D_OK;
2682 }
2683
2684 struct wined3d_shader * CDECL wined3d_device_get_vertex_shader(struct wined3d_device *device)
2685 {
2686     struct wined3d_shader *shader;
2687
2688     TRACE("device %p.\n", device);
2689
2690     shader = device->stateBlock->state.vertex_shader;
2691     if (shader)
2692         wined3d_shader_incref(shader);
2693
2694     TRACE("Returning %p.\n", shader);
2695     return shader;
2696 }
2697
2698 HRESULT CDECL wined3d_device_set_vs_consts_b(struct wined3d_device *device,
2699         UINT start_register, const BOOL *constants, UINT bool_count)
2700 {
2701     UINT count = min(bool_count, MAX_CONST_B - start_register);
2702     UINT i;
2703
2704     TRACE("device %p, start_register %u, constants %p, bool_count %u.\n",
2705             device, start_register, constants, bool_count);
2706
2707     if (!constants || start_register >= MAX_CONST_B)
2708         return WINED3DERR_INVALIDCALL;
2709
2710     memcpy(&device->updateStateBlock->state.vs_consts_b[start_register], constants, count * sizeof(BOOL));
2711     for (i = 0; i < count; ++i)
2712         TRACE("Set BOOL constant %u to %s.\n", start_register + i, constants[i] ? "true" : "false");
2713
2714     for (i = start_register; i < count + start_register; ++i)
2715         device->updateStateBlock->changed.vertexShaderConstantsB |= (1 << i);
2716
2717     if (!device->isRecordingState)
2718         device_invalidate_state(device, STATE_VERTEXSHADERCONSTANT);
2719
2720     return WINED3D_OK;
2721 }
2722
2723 HRESULT CDECL wined3d_device_get_vs_consts_b(struct wined3d_device *device,
2724         UINT start_register, BOOL *constants, UINT bool_count)
2725 {
2726     UINT count = min(bool_count, MAX_CONST_B - start_register);
2727
2728     TRACE("device %p, start_register %u, constants %p, bool_count %u.\n",
2729             device, start_register, constants, bool_count);
2730
2731     if (!constants || start_register >= MAX_CONST_B)
2732         return WINED3DERR_INVALIDCALL;
2733
2734     memcpy(constants, &device->stateBlock->state.vs_consts_b[start_register], count * sizeof(BOOL));
2735
2736     return WINED3D_OK;
2737 }
2738
2739 HRESULT CDECL wined3d_device_set_vs_consts_i(struct wined3d_device *device,
2740         UINT start_register, const int *constants, UINT vector4i_count)
2741 {
2742     UINT count = min(vector4i_count, MAX_CONST_I - start_register);
2743     UINT i;
2744
2745     TRACE("device %p, start_register %u, constants %p, vector4i_count %u.\n",
2746             device, start_register, constants, vector4i_count);
2747
2748     if (!constants || start_register >= MAX_CONST_I)
2749         return WINED3DERR_INVALIDCALL;
2750
2751     memcpy(&device->updateStateBlock->state.vs_consts_i[start_register * 4], constants, count * sizeof(int) * 4);
2752     for (i = 0; i < count; ++i)
2753         TRACE("Set INT constant %u to {%d, %d, %d, %d}.\n", start_register + i,
2754                 constants[i * 4], constants[i * 4 + 1],
2755                 constants[i * 4 + 2], constants[i * 4 + 3]);
2756
2757     for (i = start_register; i < count + start_register; ++i)
2758         device->updateStateBlock->changed.vertexShaderConstantsI |= (1 << i);
2759
2760     if (!device->isRecordingState)
2761         device_invalidate_state(device, STATE_VERTEXSHADERCONSTANT);
2762
2763     return WINED3D_OK;
2764 }
2765
2766 HRESULT CDECL wined3d_device_get_vs_consts_i(struct wined3d_device *device,
2767         UINT start_register, int *constants, UINT vector4i_count)
2768 {
2769     UINT count = min(vector4i_count, MAX_CONST_I - start_register);
2770
2771     TRACE("device %p, start_register %u, constants %p, vector4i_count %u.\n",
2772             device, start_register, constants, vector4i_count);
2773
2774     if (!constants || start_register >= MAX_CONST_I)
2775         return WINED3DERR_INVALIDCALL;
2776
2777     memcpy(constants, &device->stateBlock->state.vs_consts_i[start_register * 4], count * sizeof(int) * 4);
2778     return WINED3D_OK;
2779 }
2780
2781 HRESULT CDECL wined3d_device_set_vs_consts_f(struct wined3d_device *device,
2782         UINT start_register, const float *constants, UINT vector4f_count)
2783 {
2784     UINT i;
2785
2786     TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
2787             device, start_register, constants, vector4f_count);
2788
2789     /* Specifically test start_register > limit to catch MAX_UINT overflows
2790      * when adding start_register + vector4f_count. */
2791     if (!constants
2792             || start_register + vector4f_count > device->d3d_vshader_constantF
2793             || start_register > device->d3d_vshader_constantF)
2794         return WINED3DERR_INVALIDCALL;
2795
2796     memcpy(&device->updateStateBlock->state.vs_consts_f[start_register * 4],
2797             constants, vector4f_count * sizeof(float) * 4);
2798     if (TRACE_ON(d3d))
2799     {
2800         for (i = 0; i < vector4f_count; ++i)
2801             TRACE("Set FLOAT constant %u to {%.8e, %.8e, %.8e, %.8e}.\n", start_register + i,
2802                     constants[i * 4], constants[i * 4 + 1],
2803                     constants[i * 4 + 2], constants[i * 4 + 3]);
2804     }
2805
2806     if (!device->isRecordingState)
2807     {
2808         device->shader_backend->shader_update_float_vertex_constants(device, start_register, vector4f_count);
2809         device_invalidate_state(device, STATE_VERTEXSHADERCONSTANT);
2810     }
2811
2812     memset(device->updateStateBlock->changed.vertexShaderConstantsF + start_register, 1,
2813             sizeof(*device->updateStateBlock->changed.vertexShaderConstantsF) * vector4f_count);
2814
2815     return WINED3D_OK;
2816 }
2817
2818 HRESULT CDECL wined3d_device_get_vs_consts_f(struct wined3d_device *device,
2819         UINT start_register, float *constants, UINT vector4f_count)
2820 {
2821     int count = min(vector4f_count, device->d3d_vshader_constantF - start_register);
2822
2823     TRACE("device %p, start_register %u, constants %p, vector4f_count %u.\n",
2824             device, start_register, constants, vector4f_count);
2825
2826     if (!constants || count < 0)
2827         return WINED3DERR_INVALIDCALL;
2828
2829     memcpy(constants, &device->stateBlock->state.vs_consts_f[start_register * 4], count * sizeof(float) * 4);
2830
2831     return WINED3D_OK;
2832 }
2833
2834 static inline void markTextureStagesDirty(struct wined3d_device *device, DWORD stage)
2835 {
2836     DWORD i;
2837
2838     for (i = 0; i <= WINED3D_HIGHEST_TEXTURE_STATE; ++i)
2839     {
2840         device_invalidate_state(device, STATE_TEXTURESTAGE(stage, i));
2841     }
2842 }
2843
2844 static void device_map_stage(struct wined3d_device *device, DWORD stage, DWORD unit)
2845 {
2846     DWORD i = device->rev_tex_unit_map[unit];
2847     DWORD j = device->texUnitMap[stage];
2848
2849     device->texUnitMap[stage] = unit;
2850     if (i != WINED3D_UNMAPPED_STAGE && i != stage)
2851         device->texUnitMap[i] = WINED3D_UNMAPPED_STAGE;
2852
2853     device->rev_tex_unit_map[unit] = stage;
2854     if (j != WINED3D_UNMAPPED_STAGE && j != unit)
2855         device->rev_tex_unit_map[j] = WINED3D_UNMAPPED_STAGE;
2856 }
2857
2858 static void device_update_fixed_function_usage_map(struct wined3d_device *device)
2859 {
2860     UINT i;
2861
2862     device->fixed_function_usage_map = 0;
2863     for (i = 0; i < MAX_TEXTURES; ++i)
2864     {
2865         const struct wined3d_state *state = &device->stateBlock->state;
2866         WINED3DTEXTUREOP color_op = state->texture_states[i][WINED3DTSS_COLOROP];
2867         WINED3DTEXTUREOP alpha_op = state->texture_states[i][WINED3DTSS_ALPHAOP];
2868         DWORD color_arg1 = state->texture_states[i][WINED3DTSS_COLORARG1] & WINED3DTA_SELECTMASK;
2869         DWORD color_arg2 = state->texture_states[i][WINED3DTSS_COLORARG2] & WINED3DTA_SELECTMASK;
2870         DWORD color_arg3 = state->texture_states[i][WINED3DTSS_COLORARG0] & WINED3DTA_SELECTMASK;
2871         DWORD alpha_arg1 = state->texture_states[i][WINED3DTSS_ALPHAARG1] & WINED3DTA_SELECTMASK;
2872         DWORD alpha_arg2 = state->texture_states[i][WINED3DTSS_ALPHAARG2] & WINED3DTA_SELECTMASK;
2873         DWORD alpha_arg3 = state->texture_states[i][WINED3DTSS_ALPHAARG0] & WINED3DTA_SELECTMASK;
2874
2875         if (color_op == WINED3DTOP_DISABLE) {
2876             /* Not used, and disable higher stages */
2877             break;
2878         }
2879
2880         if (((color_arg1 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG2)
2881                 || ((color_arg2 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG1)
2882                 || ((color_arg3 == WINED3DTA_TEXTURE)
2883                     && (color_op == WINED3DTOP_MULTIPLYADD || color_op == WINED3DTOP_LERP))
2884                 || ((alpha_arg1 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG2)
2885                 || ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG1)
2886                 || ((alpha_arg3 == WINED3DTA_TEXTURE)
2887                     && (alpha_op == WINED3DTOP_MULTIPLYADD || alpha_op == WINED3DTOP_LERP)))
2888             device->fixed_function_usage_map |= (1 << i);
2889
2890         if ((color_op == WINED3DTOP_BUMPENVMAP || color_op == WINED3DTOP_BUMPENVMAPLUMINANCE) && i < MAX_TEXTURES - 1)
2891             device->fixed_function_usage_map |= (1 << (i + 1));
2892     }
2893 }
2894
2895 static void device_map_fixed_function_samplers(struct wined3d_device *device, const struct wined3d_gl_info *gl_info)
2896 {
2897     unsigned int i, tex;
2898     WORD ffu_map;
2899
2900     device_update_fixed_function_usage_map(device);
2901     ffu_map = device->fixed_function_usage_map;
2902
2903     if (device->max_ffp_textures == gl_info->limits.texture_stages
2904             || device->stateBlock->state.lowest_disabled_stage <= device->max_ffp_textures)
2905     {
2906         for (i = 0; ffu_map; ffu_map >>= 1, ++i)
2907         {
2908             if (!(ffu_map & 1)) continue;
2909
2910             if (device->texUnitMap[i] != i)
2911             {
2912                 device_map_stage(device, i, i);
2913                 device_invalidate_state(device, STATE_SAMPLER(i));
2914                 markTextureStagesDirty(device, i);
2915             }
2916         }
2917         return;
2918     }
2919
2920     /* Now work out the mapping */
2921     tex = 0;
2922     for (i = 0; ffu_map; ffu_map >>= 1, ++i)
2923     {
2924         if (!(ffu_map & 1)) continue;
2925
2926         if (device->texUnitMap[i] != tex)
2927         {
2928             device_map_stage(device, i, tex);
2929             device_invalidate_state(device, STATE_SAMPLER(i));
2930             markTextureStagesDirty(device, i);
2931         }
2932
2933         ++tex;
2934     }
2935 }
2936
2937 static void device_map_psamplers(struct wined3d_device *device, const struct wined3d_gl_info *gl_info)
2938 {
2939     const WINED3DSAMPLER_TEXTURE_TYPE *sampler_type =
2940             device->stateBlock->state.pixel_shader->reg_maps.sampler_type;
2941     unsigned int i;
2942
2943     for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
2944     {
2945         if (sampler_type[i] && device->texUnitMap[i] != i)
2946         {
2947             device_map_stage(device, i, i);
2948             device_invalidate_state(device, STATE_SAMPLER(i));
2949             if (i < gl_info->limits.texture_stages)
2950             {
2951                 markTextureStagesDirty(device, i);
2952             }
2953         }
2954     }
2955 }
2956
2957 static BOOL device_unit_free_for_vs(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(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         /* Don't read the real display mode, but return the stored mode
3943          * instead. X11 can't change the color depth, and some apps are
3944          * pretty angry if they SetDisplayMode from 24 to 16 bpp and find out
3945          * that GetDisplayMode still returns 24 bpp.
3946          *
3947          * Also don't relay to the swapchain because with ddraw it's possible
3948          * that there isn't a swapchain at all. */
3949         mode->Width = device->ddraw_width;
3950         mode->Height = device->ddraw_height;
3951         mode->Format = device->ddraw_format;
3952         mode->RefreshRate = 0;
3953         hr = WINED3D_OK;
3954     }
3955
3956     return hr;
3957 }
3958
3959 HRESULT CDECL wined3d_device_begin_stateblock(struct wined3d_device *device)
3960 {
3961     struct wined3d_stateblock *stateblock;
3962     HRESULT hr;
3963
3964     TRACE("device %p.\n", device);
3965
3966     if (device->isRecordingState)
3967         return WINED3DERR_INVALIDCALL;
3968
3969     hr = wined3d_stateblock_create(device, WINED3DSBT_RECORDED, &stateblock);
3970     if (FAILED(hr))
3971         return hr;
3972
3973     wined3d_stateblock_decref(device->updateStateBlock);
3974     device->updateStateBlock = stateblock;
3975     device->isRecordingState = TRUE;
3976
3977     TRACE("Recording stateblock %p.\n", stateblock);
3978
3979     return WINED3D_OK;
3980 }
3981
3982 HRESULT CDECL wined3d_device_end_stateblock(struct wined3d_device *device,
3983         struct wined3d_stateblock **stateblock)
3984 {
3985     struct wined3d_stateblock *object = device->updateStateBlock;
3986
3987     TRACE("device %p, stateblock %p.\n", device, stateblock);
3988
3989     if (!device->isRecordingState)
3990     {
3991         WARN("Not recording.\n");
3992         *stateblock = NULL;
3993         return WINED3DERR_INVALIDCALL;
3994     }
3995
3996     stateblock_init_contained_states(object);
3997
3998     *stateblock = object;
3999     device->isRecordingState = FALSE;
4000     device->updateStateBlock = device->stateBlock;
4001     wined3d_stateblock_incref(device->updateStateBlock);
4002
4003     TRACE("Returning stateblock %p.\n", *stateblock);
4004
4005     return WINED3D_OK;
4006 }
4007
4008 HRESULT CDECL wined3d_device_begin_scene(struct wined3d_device *device)
4009 {
4010     /* At the moment we have no need for any functionality at the beginning
4011      * of a scene. */
4012     TRACE("device %p.\n", device);
4013
4014     if (device->inScene)
4015     {
4016         WARN("Already in scene, returning WINED3DERR_INVALIDCALL.\n");
4017         return WINED3DERR_INVALIDCALL;
4018     }
4019     device->inScene = TRUE;
4020     return WINED3D_OK;
4021 }
4022
4023 HRESULT CDECL wined3d_device_end_scene(struct wined3d_device *device)
4024 {
4025     struct wined3d_context *context;
4026
4027     TRACE("device %p.\n", device);
4028
4029     if (!device->inScene)
4030     {
4031         WARN("Not in scene, returning WINED3DERR_INVALIDCALL.\n");
4032         return WINED3DERR_INVALIDCALL;
4033     }
4034
4035     context = context_acquire(device, NULL);
4036     /* We only have to do this if we need to read the, swapbuffers performs a flush for us */
4037     wglFlush();
4038     /* No checkGLcall here to avoid locking the lock just for checking a call that hardly ever
4039      * fails. */
4040     context_release(context);
4041
4042     device->inScene = FALSE;
4043     return WINED3D_OK;
4044 }
4045
4046 HRESULT CDECL wined3d_device_present(struct wined3d_device *device, const RECT *src_rect,
4047         const RECT *dst_rect, HWND dst_window_override, const RGNDATA *dirty_region)
4048 {
4049     UINT i;
4050
4051     TRACE("device %p, src_rect %s, dst_rect %s, dst_window_override %p, dirty_region %p.\n",
4052             device, wine_dbgstr_rect(src_rect), wine_dbgstr_rect(dst_rect),
4053             dst_window_override, dirty_region);
4054
4055     for (i = 0; i < device->swapchain_count; ++i)
4056     {
4057         wined3d_swapchain_present(device->swapchains[i], src_rect,
4058                 dst_rect, dst_window_override, dirty_region, 0);
4059     }
4060
4061     return WINED3D_OK;
4062 }
4063
4064 /* Do not call while under the GL lock. */
4065 HRESULT CDECL wined3d_device_clear(struct wined3d_device *device, DWORD rect_count,
4066         const RECT *rects, DWORD flags, WINED3DCOLOR color, float depth, DWORD stencil)
4067 {
4068     const WINED3DCOLORVALUE c = {D3DCOLOR_R(color), D3DCOLOR_G(color), D3DCOLOR_B(color), D3DCOLOR_A(color)};
4069     RECT draw_rect;
4070
4071     TRACE("device %p, rect_count %u, rects %p, flags %#x, color 0x%08x, depth %.8e, stencil %u.\n",
4072             device, rect_count, rects, flags, color, depth, stencil);
4073
4074     if (flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL))
4075     {
4076         struct wined3d_surface *ds = device->fb.depth_stencil;
4077         if (!ds)
4078         {
4079             WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
4080             /* TODO: What about depth stencil buffers without stencil bits? */
4081             return WINED3DERR_INVALIDCALL;
4082         }
4083         else if (flags & WINED3DCLEAR_TARGET)
4084         {
4085             if (ds->resource.width < device->fb.render_targets[0]->resource.width
4086                     || ds->resource.height < device->fb.render_targets[0]->resource.height)
4087             {
4088                 WARN("Silently ignoring depth and target clear with mismatching sizes\n");
4089                 return WINED3D_OK;
4090             }
4091         }
4092     }
4093
4094     wined3d_get_draw_rect(&device->stateBlock->state, &draw_rect);
4095
4096     return device_clear_render_targets(device, device->adapter->gl_info.limits.buffers,
4097             &device->fb, rect_count, rects,
4098             &draw_rect, flags, &c, depth, stencil);
4099 }
4100
4101 void CDECL wined3d_device_set_primitive_type(struct wined3d_device *device,
4102         WINED3DPRIMITIVETYPE primitive_type)
4103 {
4104     TRACE("device %p, primitive_type %s\n", device, debug_d3dprimitivetype(primitive_type));
4105
4106     device->updateStateBlock->changed.primitive_type = TRUE;
4107     device->updateStateBlock->state.gl_primitive_type = gl_primitive_type_from_d3d(primitive_type);
4108 }
4109
4110 void CDECL wined3d_device_get_primitive_type(struct wined3d_device *device,
4111         WINED3DPRIMITIVETYPE *primitive_type)
4112 {
4113     TRACE("device %p, primitive_type %p\n", device, primitive_type);
4114
4115     *primitive_type = d3d_primitive_type_from_gl(device->stateBlock->state.gl_primitive_type);
4116
4117     TRACE("Returning %s\n", debug_d3dprimitivetype(*primitive_type));
4118 }
4119
4120 HRESULT CDECL wined3d_device_draw_primitive(struct wined3d_device *device, UINT start_vertex, UINT vertex_count)
4121 {
4122     TRACE("device %p, start_vertex %u, vertex_count %u.\n", device, start_vertex, vertex_count);
4123
4124     if (!device->stateBlock->state.vertex_declaration)
4125     {
4126         WARN("Called without a valid vertex declaration set.\n");
4127         return WINED3DERR_INVALIDCALL;
4128     }
4129
4130     /* The index buffer is not needed here, but restore it, otherwise it is hell to keep track of */
4131     if (device->stateBlock->state.user_stream)
4132     {
4133         device_invalidate_state(device, STATE_INDEXBUFFER);
4134         device->stateBlock->state.user_stream = FALSE;
4135     }
4136
4137     if (device->stateBlock->state.load_base_vertex_index)
4138     {
4139         device->stateBlock->state.load_base_vertex_index = 0;
4140         device_invalidate_state(device, STATE_BASEVERTEXINDEX);
4141     }
4142
4143     /* Account for the loading offset due to index buffers. Instead of
4144      * reloading all sources correct it with the startvertex parameter. */
4145     drawPrimitive(device, vertex_count, start_vertex, 0, NULL);
4146     return WINED3D_OK;
4147 }
4148
4149 HRESULT CDECL wined3d_device_draw_indexed_primitive(struct wined3d_device *device, UINT start_idx, UINT index_count)
4150 {
4151     struct wined3d_buffer *index_buffer;
4152     UINT index_size = 2;
4153     GLuint vbo;
4154     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
4155
4156     TRACE("device %p, start_idx %u, index_count %u.\n", device, start_idx, index_count);
4157
4158     index_buffer = device->stateBlock->state.index_buffer;
4159     if (!index_buffer)
4160     {
4161         /* D3D9 returns D3DERR_INVALIDCALL when DrawIndexedPrimitive is called
4162          * without an index buffer set. (The first time at least...)
4163          * D3D8 simply dies, but I doubt it can do much harm to return
4164          * D3DERR_INVALIDCALL there as well. */
4165         WARN("Called without a valid index buffer set, returning WINED3DERR_INVALIDCALL.\n");
4166         return WINED3DERR_INVALIDCALL;
4167     }
4168
4169     if (!device->stateBlock->state.vertex_declaration)
4170     {
4171         WARN("Called without a valid vertex declaration set.\n");
4172         return WINED3DERR_INVALIDCALL;
4173     }
4174
4175     if (device->stateBlock->state.user_stream)
4176     {
4177         device_invalidate_state(device, STATE_INDEXBUFFER);
4178         device->stateBlock->state.user_stream = FALSE;
4179     }
4180     vbo = index_buffer->buffer_object;
4181
4182     if (device->stateBlock->state.index_format == WINED3DFMT_R16_UINT)
4183         index_size = 2;
4184     else
4185         index_size = 4;
4186
4187     if (!gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX] &&
4188         device->stateBlock->state.load_base_vertex_index != device->stateBlock->state.base_vertex_index)
4189     {
4190         device->stateBlock->state.load_base_vertex_index = device->stateBlock->state.base_vertex_index;
4191         device_invalidate_state(device, STATE_BASEVERTEXINDEX);
4192     }
4193
4194     drawPrimitive(device, index_count, start_idx, index_size,
4195             vbo ? NULL : index_buffer->resource.allocatedMemory);
4196
4197     return WINED3D_OK;
4198 }
4199
4200 HRESULT CDECL wined3d_device_draw_primitive_up(struct wined3d_device *device, UINT vertex_count,
4201         const void *stream_data, UINT stream_stride)
4202 {
4203     struct wined3d_stream_state *stream;
4204     struct wined3d_buffer *vb;
4205
4206     TRACE("device %p, vertex count %u, stream_data %p, stream_stride %u.\n",
4207             device, vertex_count, stream_data, stream_stride);
4208
4209     if (!device->stateBlock->state.vertex_declaration)
4210     {
4211         WARN("Called without a valid vertex declaration set.\n");
4212         return WINED3DERR_INVALIDCALL;
4213     }
4214
4215     /* Note in the following, it's not this type, but that's the purpose of streamIsUP */
4216     stream = &device->stateBlock->state.streams[0];
4217     vb = stream->buffer;
4218     stream->buffer = (struct wined3d_buffer *)stream_data;
4219     if (vb)
4220         wined3d_buffer_decref(vb);
4221     stream->offset = 0;
4222     stream->stride = stream_stride;
4223     device->stateBlock->state.user_stream = TRUE;
4224     if (device->stateBlock->state.load_base_vertex_index)
4225     {
4226         device->stateBlock->state.load_base_vertex_index = 0;
4227         device_invalidate_state(device, STATE_BASEVERTEXINDEX);
4228     }
4229
4230     /* TODO: Only mark dirty if drawing from a different UP address */
4231     device_invalidate_state(device, STATE_STREAMSRC);
4232
4233     drawPrimitive(device, vertex_count, 0, 0, NULL);
4234
4235     /* MSDN specifies stream zero settings must be set to NULL */
4236     stream->buffer = NULL;
4237     stream->stride = 0;
4238
4239     /* stream zero settings set to null at end, as per the msdn. No need to
4240      * mark dirty here, the app has to set the new stream sources or use UP
4241      * drawing again. */
4242     return WINED3D_OK;
4243 }
4244
4245 HRESULT CDECL wined3d_device_draw_indexed_primitive_up(struct wined3d_device *device,
4246         UINT index_count, const void *index_data, enum wined3d_format_id index_data_format_id,
4247         const void *stream_data, UINT stream_stride)
4248 {
4249     struct wined3d_stream_state *stream;
4250     struct wined3d_buffer *vb, *ib;
4251     UINT index_size;
4252
4253     TRACE("device %p, index_count %u, index_data %p, index_data_format %s, stream_data %p, stream_stride %u.\n",
4254             device, index_count, index_data, debug_d3dformat(index_data_format_id), stream_data, stream_stride);
4255
4256     if (!device->stateBlock->state.vertex_declaration)
4257     {
4258         WARN("(%p) : Called without a valid vertex declaration set\n", device);
4259         return WINED3DERR_INVALIDCALL;
4260     }
4261
4262     if (index_data_format_id == WINED3DFMT_R16_UINT)
4263         index_size = 2;
4264     else
4265         index_size = 4;
4266
4267     stream = &device->stateBlock->state.streams[0];
4268     vb = stream->buffer;
4269     stream->buffer = (struct wined3d_buffer *)stream_data;
4270     if (vb)
4271         wined3d_buffer_decref(vb);
4272     stream->offset = 0;
4273     stream->stride = stream_stride;
4274     device->stateBlock->state.user_stream = TRUE;
4275
4276     /* Set to 0 as per msdn. Do it now due to the stream source loading during drawPrimitive */
4277     device->stateBlock->state.base_vertex_index = 0;
4278     if (device->stateBlock->state.load_base_vertex_index)
4279     {
4280         device->stateBlock->state.load_base_vertex_index = 0;
4281         device_invalidate_state(device, STATE_BASEVERTEXINDEX);
4282     }
4283     /* Invalidate the state until we have nicer tracking of the stream source pointers */
4284     device_invalidate_state(device, STATE_STREAMSRC);
4285     device_invalidate_state(device, STATE_INDEXBUFFER);
4286
4287     drawPrimitive(device, index_count, 0, index_size, index_data);
4288
4289     /* MSDN specifies stream zero settings and index buffer must be set to NULL */
4290     stream->buffer = NULL;
4291     stream->stride = 0;
4292     ib = device->stateBlock->state.index_buffer;
4293     if (ib)
4294     {
4295         wined3d_buffer_decref(ib);
4296         device->stateBlock->state.index_buffer = NULL;
4297     }
4298     /* No need to mark the stream source state dirty here. Either the app calls UP drawing again, or it has to call
4299      * SetStreamSource to specify a vertex buffer
4300      */
4301
4302     return WINED3D_OK;
4303 }
4304
4305 HRESULT CDECL wined3d_device_draw_primitive_strided(struct wined3d_device *device,
4306         UINT vertex_count, const WineDirect3DVertexStridedData *strided_data)
4307 {
4308     /* Mark the state dirty until we have nicer tracking. It's fine to change
4309      * baseVertexIndex because that call is only called by ddraw which does
4310      * not need that value. */
4311     device_invalidate_state(device, STATE_VDECL);
4312     device_invalidate_state(device, STATE_STREAMSRC);
4313     device_invalidate_state(device, STATE_INDEXBUFFER);
4314
4315     device->stateBlock->state.base_vertex_index = 0;
4316     device->up_strided = strided_data;
4317     drawPrimitive(device, vertex_count, 0, 0, NULL);
4318     device->up_strided = NULL;
4319
4320     /* Invalidate the states again to make sure the values from the stateblock
4321      * are properly applied in the next regular draw. Note that the application-
4322      * provided strided data has ovwritten pretty much the entire vertex and
4323      * and index stream related states */
4324     device_invalidate_state(device, STATE_VDECL);
4325     device_invalidate_state(device, STATE_STREAMSRC);
4326     device_invalidate_state(device, STATE_INDEXBUFFER);
4327     return WINED3D_OK;
4328 }
4329
4330 HRESULT CDECL wined3d_device_draw_indexed_primitive_strided(struct wined3d_device *device,
4331         UINT index_count, const WineDirect3DVertexStridedData *strided_data,
4332         UINT vertex_count, const void *index_data, enum wined3d_format_id index_data_format_id)
4333 {
4334     UINT index_size = index_data_format_id == WINED3DFMT_R32_UINT ? 4 : 2;
4335
4336     /* Mark the state dirty until we have nicer tracking
4337      * its fine to change baseVertexIndex because that call is only called by ddraw which does not need
4338      * that value.
4339      */
4340     device_invalidate_state(device, STATE_VDECL);
4341     device_invalidate_state(device, STATE_STREAMSRC);
4342     device_invalidate_state(device, STATE_INDEXBUFFER);
4343
4344     device->stateBlock->state.user_stream = TRUE;
4345     device->stateBlock->state.base_vertex_index = 0;
4346     device->up_strided = strided_data;
4347     drawPrimitive(device, index_count, 0, index_size, index_data);
4348     device->up_strided = NULL;
4349
4350     device_invalidate_state(device, STATE_VDECL);
4351     device_invalidate_state(device, STATE_STREAMSRC);
4352     device_invalidate_state(device, STATE_INDEXBUFFER);
4353     return WINED3D_OK;
4354 }
4355
4356 /* This is a helper function for UpdateTexture, there is no UpdateVolume method in D3D. */
4357 static HRESULT device_update_volume(struct wined3d_device *device,
4358         struct wined3d_volume *src_volume, struct wined3d_volume *dst_volume)
4359 {
4360     WINED3DLOCKED_BOX src;
4361     WINED3DLOCKED_BOX dst;
4362     HRESULT hr;
4363
4364     TRACE("device %p, src_volume %p, dst_volume %p.\n",
4365             device, src_volume, dst_volume);
4366
4367     /* TODO: Implement direct loading into the gl volume instead of using
4368      * memcpy and dirtification to improve loading performance. */
4369     hr = wined3d_volume_map(src_volume, &src, NULL, WINED3DLOCK_READONLY);
4370     if (FAILED(hr)) return hr;
4371     hr = wined3d_volume_map(dst_volume, &dst, NULL, WINED3DLOCK_DISCARD);
4372     if (FAILED(hr))
4373     {
4374         wined3d_volume_unmap(src_volume);
4375         return hr;
4376     }
4377
4378     memcpy(dst.pBits, src.pBits, dst_volume->resource.size);
4379
4380     hr = wined3d_volume_unmap(dst_volume);
4381     if (FAILED(hr))
4382         wined3d_volume_unmap(src_volume);
4383     else
4384         hr = wined3d_volume_unmap(src_volume);
4385
4386     return hr;
4387 }
4388
4389 HRESULT CDECL wined3d_device_update_texture(struct wined3d_device *device,
4390         struct wined3d_texture *src_texture, struct wined3d_texture *dst_texture)
4391 {
4392     unsigned int level_count, i;
4393     WINED3DRESOURCETYPE type;
4394     HRESULT hr;
4395
4396     TRACE("device %p, src_texture %p, dst_texture %p.\n", device, src_texture, dst_texture);
4397
4398     /* Verify that the source and destination textures are non-NULL. */
4399     if (!src_texture || !dst_texture)
4400     {
4401         WARN("Source and destination textures must be non-NULL, returning WINED3DERR_INVALIDCALL.\n");
4402         return WINED3DERR_INVALIDCALL;
4403     }
4404
4405     if (src_texture == dst_texture)
4406     {
4407         WARN("Source and destination are the same object, returning WINED3DERR_INVALIDCALL.\n");
4408         return WINED3DERR_INVALIDCALL;
4409     }
4410
4411     /* Verify that the source and destination textures are the same type. */
4412     type = src_texture->resource.resourceType;
4413     if (dst_texture->resource.resourceType != type)
4414     {
4415         WARN("Source and destination have different types, returning WINED3DERR_INVALIDCALL.\n");
4416         return WINED3DERR_INVALIDCALL;
4417     }
4418
4419     /* Check that both textures have the identical numbers of levels. */
4420     level_count = wined3d_texture_get_level_count(src_texture);
4421     if (wined3d_texture_get_level_count(dst_texture) != level_count)
4422     {
4423         WARN("Source and destination have different level counts, returning WINED3DERR_INVALIDCALL.\n");
4424         return WINED3DERR_INVALIDCALL;
4425     }
4426
4427     /* Make sure that the destination texture is loaded. */
4428     dst_texture->texture_ops->texture_preload(dst_texture, SRGB_RGB);
4429
4430     /* Update every surface level of the texture. */
4431     switch (type)
4432     {
4433         case WINED3DRTYPE_TEXTURE:
4434         {
4435             struct wined3d_surface *src_surface;
4436             struct wined3d_surface *dst_surface;
4437
4438             for (i = 0; i < level_count; ++i)
4439             {
4440                 src_surface = surface_from_resource(wined3d_texture_get_sub_resource(src_texture, i));
4441                 dst_surface = surface_from_resource(wined3d_texture_get_sub_resource(dst_texture, i));
4442                 hr = wined3d_device_update_surface(device, src_surface, NULL, dst_surface, NULL);
4443                 if (FAILED(hr))
4444                 {
4445                     WARN("Failed to update surface, hr %#x.\n", hr);
4446                     return hr;
4447                 }
4448             }
4449             break;
4450         }
4451
4452         case WINED3DRTYPE_CUBETEXTURE:
4453         {
4454             struct wined3d_surface *src_surface;
4455             struct wined3d_surface *dst_surface;
4456
4457             for (i = 0; i < level_count * 6; ++i)
4458             {
4459                 src_surface = surface_from_resource(wined3d_texture_get_sub_resource(src_texture, i));
4460                 dst_surface = surface_from_resource(wined3d_texture_get_sub_resource(dst_texture, i));
4461                 hr = wined3d_device_update_surface(device, src_surface, NULL, dst_surface, NULL);
4462                 if (FAILED(hr))
4463                 {
4464                     WARN("Failed to update surface, hr %#x.\n", hr);
4465                     return hr;
4466                 }
4467             }
4468             break;
4469         }
4470
4471         case WINED3DRTYPE_VOLUMETEXTURE:
4472         {
4473             for (i = 0; i < level_count; ++i)
4474             {
4475                 hr = device_update_volume(device,
4476                         volume_from_resource(wined3d_texture_get_sub_resource(src_texture, i)),
4477                         volume_from_resource(wined3d_texture_get_sub_resource(dst_texture, i)));
4478                 if (FAILED(hr))
4479                 {
4480                     WARN("Failed to update volume, hr %#x.\n", hr);
4481                     return hr;
4482                 }
4483             }
4484             break;
4485         }
4486
4487         default:
4488             FIXME("Unsupported texture type %#x.\n", type);
4489             return WINED3DERR_INVALIDCALL;
4490     }
4491
4492     return WINED3D_OK;
4493 }
4494
4495 HRESULT CDECL wined3d_device_get_front_buffer_data(struct wined3d_device *device,
4496         UINT swapchain_idx, struct wined3d_surface *dst_surface)
4497 {
4498     struct wined3d_swapchain *swapchain;
4499     HRESULT hr;
4500
4501     TRACE("device %p, swapchain_idx %u, dst_surface %p.\n", device, swapchain_idx, dst_surface);
4502
4503     hr = wined3d_device_get_swapchain(device, swapchain_idx, &swapchain);
4504     if (FAILED(hr)) return hr;
4505
4506     hr = wined3d_swapchain_get_front_buffer_data(swapchain, dst_surface);
4507     wined3d_swapchain_decref(swapchain);
4508
4509     return hr;
4510 }
4511
4512 HRESULT CDECL wined3d_device_validate_device(struct wined3d_device *device, DWORD *num_passes)
4513 {
4514     const struct wined3d_state *state = &device->stateBlock->state;
4515     struct wined3d_texture *texture;
4516     DWORD i;
4517
4518     TRACE("device %p, num_passes %p.\n", device, num_passes);
4519
4520     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
4521     {
4522         if (state->sampler_states[i][WINED3DSAMP_MINFILTER] == WINED3DTEXF_NONE)
4523         {
4524             WARN("Sampler state %u has minfilter D3DTEXF_NONE, returning D3DERR_UNSUPPORTEDTEXTUREFILTER\n", i);
4525             return WINED3DERR_UNSUPPORTEDTEXTUREFILTER;
4526         }
4527         if (state->sampler_states[i][WINED3DSAMP_MAGFILTER] == WINED3DTEXF_NONE)
4528         {
4529             WARN("Sampler state %u has magfilter D3DTEXF_NONE, returning D3DERR_UNSUPPORTEDTEXTUREFILTER\n", i);
4530             return WINED3DERR_UNSUPPORTEDTEXTUREFILTER;
4531         }
4532
4533         texture = state->textures[i];
4534         if (!texture || texture->resource.format->flags & WINED3DFMT_FLAG_FILTERING) continue;
4535
4536         if (state->sampler_states[i][WINED3DSAMP_MAGFILTER] != WINED3DTEXF_POINT)
4537         {
4538             WARN("Non-filterable texture and mag filter enabled on samper %u, returning E_FAIL\n", i);
4539             return E_FAIL;
4540         }
4541         if (state->sampler_states[i][WINED3DSAMP_MINFILTER] != WINED3DTEXF_POINT)
4542         {
4543             WARN("Non-filterable texture and min filter enabled on samper %u, returning E_FAIL\n", i);
4544             return E_FAIL;
4545         }
4546         if (state->sampler_states[i][WINED3DSAMP_MIPFILTER] != WINED3DTEXF_NONE
4547                 && state->sampler_states[i][WINED3DSAMP_MIPFILTER] != WINED3DTEXF_POINT)
4548         {
4549             WARN("Non-filterable texture and mip filter enabled on samper %u, returning E_FAIL\n", i);
4550             return E_FAIL;
4551         }
4552     }
4553
4554     if (state->render_states[WINED3DRS_ZENABLE] || state->render_states[WINED3DRS_ZWRITEENABLE] ||
4555         state->render_states[WINED3DRS_STENCILENABLE])
4556     {
4557         struct wined3d_surface *ds = device->fb.depth_stencil;
4558         struct wined3d_surface *target = device->fb.render_targets[0];
4559
4560         if(ds && target
4561                 && (ds->resource.width < target->resource.width || ds->resource.height < target->resource.height))
4562         {
4563             WARN("Depth stencil is smaller than the color buffer, returning D3DERR_CONFLICTINGRENDERSTATE\n");
4564             return WINED3DERR_CONFLICTINGRENDERSTATE;
4565         }
4566     }
4567
4568     /* return a sensible default */
4569     *num_passes = 1;
4570
4571     TRACE("returning D3D_OK\n");
4572     return WINED3D_OK;
4573 }
4574
4575 static void dirtify_p8_texture_samplers(struct wined3d_device *device)
4576 {
4577     UINT i;
4578
4579     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
4580     {
4581         struct wined3d_texture *texture = device->stateBlock->state.textures[i];
4582         if (texture && (texture->resource.format->id == WINED3DFMT_P8_UINT
4583                 || texture->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM))
4584             device_invalidate_state(device, STATE_SAMPLER(i));
4585     }
4586 }
4587
4588 HRESULT CDECL wined3d_device_set_palette_entries(struct wined3d_device *device,
4589         UINT palette_idx, const PALETTEENTRY *entries)
4590 {
4591     UINT i;
4592
4593     TRACE("device %p, palette_idx %u, entries %p.\n", device, palette_idx, entries);
4594
4595     if (palette_idx >= MAX_PALETTES)
4596     {
4597         WARN("Invalid palette index %u.\n", palette_idx);
4598         return WINED3DERR_INVALIDCALL;
4599     }
4600
4601     if (palette_idx >= device->palette_count)
4602     {
4603         UINT new_size = device->palette_count;
4604         PALETTEENTRY **palettes;
4605
4606         do
4607         {
4608            new_size *= 2;
4609         } while (palette_idx >= new_size);
4610         palettes = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, device->palettes, sizeof(*palettes) * new_size);
4611         if (!palettes)
4612         {
4613             ERR("Out of memory!\n");
4614             return E_OUTOFMEMORY;
4615         }
4616         device->palettes = palettes;
4617         device->palette_count = new_size;
4618     }
4619
4620     if (!device->palettes[palette_idx])
4621     {
4622         device->palettes[palette_idx] = HeapAlloc(GetProcessHeap(),  0, sizeof(PALETTEENTRY) * 256);
4623         if (!device->palettes[palette_idx])
4624         {
4625             ERR("Out of memory!\n");
4626             return E_OUTOFMEMORY;
4627         }
4628     }
4629
4630     for (i = 0; i < 256; ++i)
4631     {
4632         device->palettes[palette_idx][i].peRed = entries[i].peRed;
4633         device->palettes[palette_idx][i].peGreen = entries[i].peGreen;
4634         device->palettes[palette_idx][i].peBlue = entries[i].peBlue;
4635         device->palettes[palette_idx][i].peFlags = entries[i].peFlags;
4636     }
4637
4638     if (palette_idx == device->currentPalette)
4639         dirtify_p8_texture_samplers(device);
4640
4641     return WINED3D_OK;
4642 }
4643
4644 HRESULT CDECL wined3d_device_get_palette_entries(struct wined3d_device *device,
4645         UINT palette_idx, PALETTEENTRY *entries)
4646 {
4647     UINT i;
4648
4649     TRACE("device %p, palette_idx %u, entries %p.\n", device, palette_idx, entries);
4650
4651     if (palette_idx >= device->palette_count || !device->palettes[palette_idx])
4652     {
4653         /* What happens in such situation isn't documented; Native seems to
4654          * silently abort on such conditions. */
4655         WARN("Invalid palette index %u.\n", palette_idx);
4656         return WINED3DERR_INVALIDCALL;
4657     }
4658
4659     for (i = 0; i < 256; ++i)
4660     {
4661         entries[i].peRed = device->palettes[palette_idx][i].peRed;
4662         entries[i].peGreen = device->palettes[palette_idx][i].peGreen;
4663         entries[i].peBlue = device->palettes[palette_idx][i].peBlue;
4664         entries[i].peFlags = device->palettes[palette_idx][i].peFlags;
4665     }
4666
4667     return WINED3D_OK;
4668 }
4669
4670 HRESULT CDECL wined3d_device_set_current_texture_palette(struct wined3d_device *device, UINT palette_idx)
4671 {
4672     TRACE("device %p, palette_idx %u.\n", device, palette_idx);
4673
4674     /* Native appears to silently abort on attempt to make an uninitialized
4675      * palette current and render. (tested with reference rasterizer). */
4676     if (palette_idx >= device->palette_count || !device->palettes[palette_idx])
4677     {
4678         WARN("Invalid palette index %u.\n", palette_idx);
4679         return WINED3DERR_INVALIDCALL;
4680     }
4681
4682     /* TODO: stateblocks? */
4683     if (device->currentPalette != palette_idx)
4684     {
4685         device->currentPalette = palette_idx;
4686         dirtify_p8_texture_samplers(device);
4687     }
4688
4689     return WINED3D_OK;
4690 }
4691
4692 HRESULT CDECL wined3d_device_get_current_texture_palette(struct wined3d_device *device, UINT *palette_idx)
4693 {
4694     TRACE("device %p, palette_idx %p.\n", device, palette_idx);
4695
4696     if (!palette_idx)
4697         return WINED3DERR_INVALIDCALL;
4698
4699     *palette_idx = device->currentPalette;
4700
4701     return WINED3D_OK;
4702 }
4703
4704 HRESULT CDECL wined3d_device_set_software_vertex_processing(struct wined3d_device *device, BOOL software)
4705 {
4706     static BOOL warned;
4707
4708     TRACE("device %p, software %#x.\n", device, software);
4709
4710     if (!warned)
4711     {
4712         FIXME("device %p, software %#x stub!\n", device, software);
4713         warned = TRUE;
4714     }
4715
4716     device->softwareVertexProcessing = software;
4717
4718     return WINED3D_OK;
4719 }
4720
4721 BOOL CDECL wined3d_device_get_software_vertex_processing(struct wined3d_device *device)
4722 {
4723     static BOOL warned;
4724
4725     TRACE("device %p.\n", device);
4726
4727     if (!warned)
4728     {
4729         TRACE("device %p stub!\n", device);
4730         warned = TRUE;
4731     }
4732
4733     return device->softwareVertexProcessing;
4734 }
4735
4736 HRESULT CDECL wined3d_device_get_raster_status(struct wined3d_device *device,
4737         UINT swapchain_idx, WINED3DRASTER_STATUS *raster_status)
4738 {
4739     struct wined3d_swapchain *swapchain;
4740     HRESULT hr;
4741
4742     TRACE("device %p, swapchain_idx %u, raster_status %p.\n",
4743             device, swapchain_idx, raster_status);
4744
4745     hr = wined3d_device_get_swapchain(device, swapchain_idx, &swapchain);
4746     if (FAILED(hr))
4747     {
4748         WARN("Failed to get swapchain %u, hr %#x.\n", swapchain_idx, hr);
4749         return hr;
4750     }
4751
4752     hr = wined3d_swapchain_get_raster_status(swapchain, raster_status);
4753     wined3d_swapchain_decref(swapchain);
4754     if (FAILED(hr))
4755     {
4756         WARN("Failed to get raster status, hr %#x.\n", hr);
4757         return hr;
4758     }
4759
4760     return WINED3D_OK;
4761 }
4762
4763 HRESULT CDECL wined3d_device_set_npatch_mode(struct wined3d_device *device, float segments)
4764 {
4765     static BOOL warned;
4766
4767     TRACE("device %p, segments %.8e.\n", device, segments);
4768
4769     if (segments != 0.0f)
4770     {
4771         if (!warned)
4772         {
4773             FIXME("device %p, segments %.8e stub!\n", device, segments);
4774             warned = TRUE;
4775         }
4776     }
4777
4778     return WINED3D_OK;
4779 }
4780
4781 float CDECL wined3d_device_get_npatch_mode(struct wined3d_device *device)
4782 {
4783     static BOOL warned;
4784
4785     TRACE("device %p.\n", device);
4786
4787     if (!warned)
4788     {
4789         FIXME("device %p stub!\n", device);
4790         warned = TRUE;
4791     }
4792
4793     return 0.0f;
4794 }
4795
4796 static inline void invalidate_active_texture(struct wined3d_device *device, struct wined3d_context *context)
4797 {
4798     DWORD sampler = device->rev_tex_unit_map[context->active_texture];
4799     if (sampler != WINED3D_UNMAPPED_STAGE)
4800         context_invalidate_state(context, STATE_SAMPLER(sampler));
4801 }
4802
4803 HRESULT CDECL wined3d_device_update_surface(struct wined3d_device *device,
4804         struct wined3d_surface *src_surface, const RECT *src_rect,
4805         struct wined3d_surface *dst_surface, const POINT *dst_point)
4806 {
4807     const struct wined3d_format *src_format;
4808     const struct wined3d_format *dst_format;
4809     const struct wined3d_gl_info *gl_info;
4810     struct wined3d_context *context;
4811     struct wined3d_bo_address data;
4812     struct wined3d_format format;
4813     UINT update_w, update_h;
4814     CONVERT_TYPES convert;
4815     UINT dst_w, dst_h;
4816     UINT src_w, src_h;
4817     POINT p;
4818     RECT r;
4819
4820     TRACE("device %p, src_surface %p, src_rect %s, dst_surface %p, dst_point %s.\n",
4821             device, src_surface, wine_dbgstr_rect(src_rect),
4822             dst_surface, wine_dbgstr_point(dst_point));
4823
4824     if (src_surface->resource.pool != WINED3DPOOL_SYSTEMMEM || dst_surface->resource.pool != WINED3DPOOL_DEFAULT)
4825     {
4826         WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, returning WINED3DERR_INVALIDCALL\n",
4827                 src_surface, dst_surface);
4828         return WINED3DERR_INVALIDCALL;
4829     }
4830
4831     src_format = src_surface->resource.format;
4832     dst_format = dst_surface->resource.format;
4833
4834     if (src_format->id != dst_format->id)
4835     {
4836         WARN("Source and destination surfaces should have the same format.\n");
4837         return WINED3DERR_INVALIDCALL;
4838     }
4839
4840     if (!dst_point)
4841     {
4842         p.x = 0;
4843         p.y = 0;
4844         dst_point = &p;
4845     }
4846     else if (dst_point->x < 0 || dst_point->y < 0)
4847     {
4848         WARN("Invalid destination point.\n");
4849         return WINED3DERR_INVALIDCALL;
4850     }
4851
4852     if (!src_rect)
4853     {
4854         r.left = 0;
4855         r.top = 0;
4856         r.right = src_surface->resource.width;
4857         r.bottom = src_surface->resource.height;
4858         src_rect = &r;
4859     }
4860     else if (src_rect->left < 0 || src_rect->left >= src_rect->right
4861             || src_rect->top < 0 || src_rect->top >= src_rect->bottom)
4862     {
4863         WARN("Invalid source rectangle.\n");
4864         return WINED3DERR_INVALIDCALL;
4865     }
4866
4867     src_w = src_surface->resource.width;
4868     src_h = src_surface->resource.height;
4869
4870     dst_w = dst_surface->resource.width;
4871     dst_h = dst_surface->resource.height;
4872
4873     update_w = src_rect->right - src_rect->left;
4874     update_h = src_rect->bottom - src_rect->top;
4875
4876     if (update_w > dst_w || dst_point->x > dst_w - update_w
4877             || update_h > dst_h || dst_point->y > dst_h - update_h)
4878     {
4879         WARN("Destination out of bounds.\n");
4880         return WINED3DERR_INVALIDCALL;
4881     }
4882
4883     /* NPOT block sizes would be silly. */
4884     if ((src_format->flags & WINED3DFMT_FLAG_COMPRESSED)
4885             && ((update_w & (src_format->block_width - 1) || update_h & (src_format->block_height - 1))
4886             && (src_w != update_w || dst_w != update_w || src_h != update_h || dst_h != update_h)))
4887     {
4888         WARN("Update rect not block-aligned.\n");
4889         return WINED3DERR_INVALIDCALL;
4890     }
4891
4892     /* This call loads the OpenGL surface directly, instead of copying the
4893      * surface to the destination's sysmem copy. If surface conversion is
4894      * needed, use BltFast instead to copy in sysmem and use regular surface
4895      * loading. */
4896     d3dfmt_get_conv(dst_surface, FALSE, TRUE, &format, &convert);
4897     if (convert != NO_CONVERSION || format.convert)
4898         return wined3d_surface_bltfast(dst_surface, dst_point->x, dst_point->y, src_surface, src_rect, 0);
4899
4900     context = context_acquire(device, NULL);
4901     gl_info = context->gl_info;
4902
4903     /* Only load the surface for partial updates. For newly allocated texture
4904      * the texture wouldn't be the current location, and we'd upload zeroes
4905      * just to overwrite them again. */
4906     if (update_w == dst_w && update_h == dst_h)
4907         surface_prepare_texture(dst_surface, context, FALSE);
4908     else
4909         surface_load_location(dst_surface, SFLAG_INTEXTURE, NULL);
4910     surface_bind(dst_surface, context, FALSE);
4911
4912     data.buffer_object = 0;
4913     data.addr = src_surface->resource.allocatedMemory;
4914
4915     if (!data.addr)
4916         ERR("Source surface has no allocated memory, but should be a sysmem surface.\n");
4917
4918     surface_upload_data(dst_surface, gl_info, src_format, src_rect, src_w, dst_point, FALSE, &data);
4919
4920     invalidate_active_texture(device, context);
4921
4922     context_release(context);
4923
4924     surface_modify_location(dst_surface, SFLAG_INTEXTURE, TRUE);
4925     return WINED3D_OK;
4926 }
4927
4928 HRESULT CDECL wined3d_device_draw_rect_patch(struct wined3d_device *device, UINT handle,
4929         const float *num_segs, const WINED3DRECTPATCH_INFO *rect_patch_info)
4930 {
4931     struct WineD3DRectPatch *patch;
4932     GLenum old_primitive_type;
4933     unsigned int i;
4934     struct list *e;
4935     BOOL found;
4936
4937     TRACE("device %p, handle %#x, num_segs %p, rect_patch_info %p.\n",
4938             device, handle, num_segs, rect_patch_info);
4939
4940     if (!(handle || rect_patch_info))
4941     {
4942         /* TODO: Write a test for the return value, thus the FIXME */
4943         FIXME("Both handle and rect_patch_info are NULL.\n");
4944         return WINED3DERR_INVALIDCALL;
4945     }
4946
4947     if (handle)
4948     {
4949         i = PATCHMAP_HASHFUNC(handle);
4950         found = FALSE;
4951         LIST_FOR_EACH(e, &device->patches[i])
4952         {
4953             patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
4954             if (patch->Handle == handle)
4955             {
4956                 found = TRUE;
4957                 break;
4958             }
4959         }
4960
4961         if (!found)
4962         {
4963             TRACE("Patch does not exist. Creating a new one\n");
4964             patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
4965             patch->Handle = handle;
4966             list_add_head(&device->patches[i], &patch->entry);
4967         } else {
4968             TRACE("Found existing patch %p\n", patch);
4969         }
4970     }
4971     else
4972     {
4973         /* Since opengl does not load tesselated vertex attributes into numbered vertex
4974          * attributes we have to tesselate, read back, and draw. This needs a patch
4975          * management structure instance. Create one.
4976          *
4977          * A possible improvement is to check if a vertex shader is used, and if not directly
4978          * draw the patch.
4979          */
4980         FIXME("Drawing an uncached patch. This is slow\n");
4981         patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
4982     }
4983
4984     if (num_segs[0] != patch->numSegs[0] || num_segs[1] != patch->numSegs[1]
4985             || num_segs[2] != patch->numSegs[2] || num_segs[3] != patch->numSegs[3]
4986             || (rect_patch_info && memcmp(rect_patch_info, &patch->RectPatchInfo, sizeof(*rect_patch_info))))
4987     {
4988         HRESULT hr;
4989         TRACE("Tesselation density or patch info changed, retesselating\n");
4990
4991         if (rect_patch_info)
4992             patch->RectPatchInfo = *rect_patch_info;
4993
4994         patch->numSegs[0] = num_segs[0];
4995         patch->numSegs[1] = num_segs[1];
4996         patch->numSegs[2] = num_segs[2];
4997         patch->numSegs[3] = num_segs[3];
4998
4999         hr = tesselate_rectpatch(device, patch);
5000         if (FAILED(hr))
5001         {
5002             WARN("Patch tesselation failed.\n");
5003
5004             /* Do not release the handle to store the params of the patch */
5005             if (!handle)
5006                 HeapFree(GetProcessHeap(), 0, patch);
5007
5008             return hr;
5009         }
5010     }
5011
5012     old_primitive_type = device->stateBlock->state.gl_primitive_type;
5013     device->stateBlock->state.gl_primitive_type = GL_TRIANGLES;
5014     wined3d_device_draw_primitive_strided(device, patch->numSegs[0] * patch->numSegs[1] * 2 * 3, &patch->strided);
5015     device->stateBlock->state.gl_primitive_type = old_primitive_type;
5016
5017     /* Destroy uncached patches */
5018     if (!handle)
5019     {
5020         HeapFree(GetProcessHeap(), 0, patch->mem);
5021         HeapFree(GetProcessHeap(), 0, patch);
5022     }
5023     return WINED3D_OK;
5024 }
5025
5026 HRESULT CDECL wined3d_device_draw_tri_patch(struct wined3d_device *device, UINT handle,
5027         const float *segment_count, const WINED3DTRIPATCH_INFO *patch_info)
5028 {
5029     FIXME("device %p, handle %#x, segment_count %p, patch_info %p stub!\n",
5030             device, handle, segment_count, patch_info);
5031
5032     return WINED3D_OK;
5033 }
5034
5035 HRESULT CDECL wined3d_device_delete_patch(struct wined3d_device *device, UINT handle)
5036 {
5037     struct WineD3DRectPatch *patch;
5038     struct list *e;
5039     int i;
5040
5041     TRACE("device %p, handle %#x.\n", device, handle);
5042
5043     i = PATCHMAP_HASHFUNC(handle);
5044     LIST_FOR_EACH(e, &device->patches[i])
5045     {
5046         patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
5047         if (patch->Handle == handle)
5048         {
5049             TRACE("Deleting patch %p\n", patch);
5050             list_remove(&patch->entry);
5051             HeapFree(GetProcessHeap(), 0, patch->mem);
5052             HeapFree(GetProcessHeap(), 0, patch);
5053             return WINED3D_OK;
5054         }
5055     }
5056
5057     /* TODO: Write a test for the return value */
5058     FIXME("Attempt to destroy nonexistent patch\n");
5059     return WINED3DERR_INVALIDCALL;
5060 }
5061
5062 /* Do not call while under the GL lock. */
5063 HRESULT CDECL wined3d_device_color_fill(struct wined3d_device *device,
5064         struct wined3d_surface *surface, const RECT *rect, const WINED3DCOLORVALUE *color)
5065 {
5066     RECT r;
5067
5068     TRACE("device %p, surface %p, rect %s, color {%.8e, %.8e, %.8e, %.8e}.\n",
5069             device, surface, wine_dbgstr_rect(rect),
5070             color->r, color->g, color->b, color->a);
5071
5072     if (surface->resource.pool != WINED3DPOOL_DEFAULT && surface->resource.pool != WINED3DPOOL_SYSTEMMEM)
5073     {
5074         FIXME("call to colorfill with non WINED3DPOOL_DEFAULT or WINED3DPOOL_SYSTEMMEM surface\n");
5075         return WINED3DERR_INVALIDCALL;
5076     }
5077
5078     if (!rect)
5079     {
5080         SetRect(&r, 0, 0, surface->resource.width, surface->resource.height);
5081         rect = &r;
5082     }
5083
5084     return surface_color_fill(surface, rect, color);
5085 }
5086
5087 /* Do not call while under the GL lock. */
5088 void CDECL wined3d_device_clear_rendertarget_view(struct wined3d_device *device,
5089         struct wined3d_rendertarget_view *rendertarget_view, const WINED3DCOLORVALUE *color)
5090 {
5091     struct wined3d_resource *resource;
5092     HRESULT hr;
5093     RECT rect;
5094
5095     resource = rendertarget_view->resource;
5096     if (resource->resourceType != WINED3DRTYPE_SURFACE)
5097     {
5098         FIXME("Only supported on surface resources\n");
5099         return;
5100     }
5101
5102     SetRect(&rect, 0, 0, resource->width, resource->height);
5103     hr = surface_color_fill(surface_from_resource(resource), &rect, color);
5104     if (FAILED(hr)) ERR("Color fill failed, hr %#x.\n", hr);
5105 }
5106
5107 HRESULT CDECL wined3d_device_get_render_target(struct wined3d_device *device,
5108         UINT render_target_idx, struct wined3d_surface **render_target)
5109 {
5110     TRACE("device %p, render_target_idx %u, render_target %p.\n",
5111             device, render_target_idx, render_target);
5112
5113     if (render_target_idx >= device->adapter->gl_info.limits.buffers)
5114     {
5115         WARN("Only %u render targets are supported.\n", device->adapter->gl_info.limits.buffers);
5116         return WINED3DERR_INVALIDCALL;
5117     }
5118
5119     *render_target = device->fb.render_targets[render_target_idx];
5120     if (*render_target)
5121         wined3d_surface_incref(*render_target);
5122
5123     TRACE("Returning render target %p.\n", *render_target);
5124
5125     return WINED3D_OK;
5126 }
5127
5128 HRESULT CDECL wined3d_device_get_depth_stencil(struct wined3d_device *device, struct wined3d_surface **depth_stencil)
5129 {
5130     TRACE("device %p, depth_stencil %p.\n", device, depth_stencil);
5131
5132     *depth_stencil = device->fb.depth_stencil;
5133     TRACE("Returning depth/stencil surface %p.\n", *depth_stencil);
5134
5135     if (!*depth_stencil)
5136         return WINED3DERR_NOTFOUND;
5137
5138     wined3d_surface_incref(*depth_stencil);
5139
5140     return WINED3D_OK;
5141 }
5142
5143 HRESULT CDECL wined3d_device_set_render_target(struct wined3d_device *device,
5144         UINT render_target_idx, struct wined3d_surface *render_target, BOOL set_viewport)
5145 {
5146     struct wined3d_surface *prev;
5147
5148     TRACE("device %p, render_target_idx %u, render_target %p, set_viewport %#x.\n",
5149             device, render_target_idx, render_target, set_viewport);
5150
5151     if (render_target_idx >= device->adapter->gl_info.limits.buffers)
5152     {
5153         WARN("Only %u render targets are supported.\n", device->adapter->gl_info.limits.buffers);
5154         return WINED3DERR_INVALIDCALL;
5155     }
5156
5157     prev = device->fb.render_targets[render_target_idx];
5158     if (render_target == prev)
5159     {
5160         TRACE("Trying to do a NOP SetRenderTarget operation.\n");
5161         return WINED3D_OK;
5162     }
5163
5164     /* Render target 0 can't be set to NULL. */
5165     if (!render_target && !render_target_idx)
5166     {
5167         WARN("Trying to set render target 0 to NULL.\n");
5168         return WINED3DERR_INVALIDCALL;
5169     }
5170
5171     if (render_target && !(render_target->resource.usage & WINED3DUSAGE_RENDERTARGET))
5172     {
5173         FIXME("Surface %p doesn't have render target usage.\n", render_target);
5174         return WINED3DERR_INVALIDCALL;
5175     }
5176
5177     if (render_target)
5178         wined3d_surface_incref(render_target);
5179     device->fb.render_targets[render_target_idx] = render_target;
5180     /* Release after the assignment, to prevent device_resource_released()
5181      * from seeing the surface as still in use. */
5182     if (prev)
5183         wined3d_surface_decref(prev);
5184
5185     /* Render target 0 is special. */
5186     if (!render_target_idx && set_viewport)
5187     {
5188         /* Set the viewport and scissor rectangles, if requested. Tests show
5189          * that stateblock recording is ignored, the change goes directly
5190          * into the primary stateblock. */
5191         device->stateBlock->state.viewport.Height = device->fb.render_targets[0]->resource.height;
5192         device->stateBlock->state.viewport.Width  = device->fb.render_targets[0]->resource.width;
5193         device->stateBlock->state.viewport.X      = 0;
5194         device->stateBlock->state.viewport.Y      = 0;
5195         device->stateBlock->state.viewport.MaxZ   = 1.0f;
5196         device->stateBlock->state.viewport.MinZ   = 0.0f;
5197         device_invalidate_state(device, STATE_VIEWPORT);
5198
5199         device->stateBlock->state.scissor_rect.top = 0;
5200         device->stateBlock->state.scissor_rect.left = 0;
5201         device->stateBlock->state.scissor_rect.right = device->stateBlock->state.viewport.Width;
5202         device->stateBlock->state.scissor_rect.bottom = device->stateBlock->state.viewport.Height;
5203         device_invalidate_state(device, STATE_SCISSORRECT);
5204     }
5205
5206     device_invalidate_state(device, STATE_FRAMEBUFFER);
5207
5208     return WINED3D_OK;
5209 }
5210
5211 HRESULT CDECL wined3d_device_set_depth_stencil(struct wined3d_device *device, struct wined3d_surface *depth_stencil)
5212 {
5213     struct wined3d_surface *prev = device->fb.depth_stencil;
5214
5215     TRACE("device %p, depth_stencil %p, old depth_stencil %p.\n",
5216             device, depth_stencil, prev);
5217
5218     if (prev == depth_stencil)
5219     {
5220         TRACE("Trying to do a NOP SetRenderTarget operation.\n");
5221         return WINED3D_OK;
5222     }
5223
5224     if (prev)
5225     {
5226         if (device->swapchains[0]->presentParms.Flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
5227                 || prev->flags & SFLAG_DISCARD)
5228         {
5229             surface_modify_ds_location(prev, SFLAG_DS_DISCARDED,
5230                     prev->resource.width, prev->resource.height);
5231             if (prev == device->onscreen_depth_stencil)
5232             {
5233                 wined3d_surface_decref(device->onscreen_depth_stencil);
5234                 device->onscreen_depth_stencil = NULL;
5235             }
5236         }
5237     }
5238
5239     device->fb.depth_stencil = depth_stencil;
5240     if (depth_stencil)
5241         wined3d_surface_incref(depth_stencil);
5242
5243     if (!prev != !depth_stencil)
5244     {
5245         /* Swapping NULL / non NULL depth stencil affects the depth and tests */
5246         device_invalidate_state(device, STATE_RENDER(WINED3DRS_ZENABLE));
5247         device_invalidate_state(device, STATE_RENDER(WINED3DRS_STENCILENABLE));
5248         device_invalidate_state(device, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
5249         device_invalidate_state(device, STATE_RENDER(WINED3DRS_DEPTHBIAS));
5250     }
5251     else if (prev && prev->resource.format->depth_size != depth_stencil->resource.format->depth_size)
5252     {
5253         device_invalidate_state(device, STATE_RENDER(WINED3DRS_DEPTHBIAS));
5254     }
5255     if (prev)
5256         wined3d_surface_decref(prev);
5257
5258     device_invalidate_state(device, STATE_FRAMEBUFFER);
5259
5260     return WINED3D_OK;
5261 }
5262
5263 HRESULT CDECL wined3d_device_set_cursor_properties(struct wined3d_device *device,
5264         UINT x_hotspot, UINT y_hotspot, struct wined3d_surface *cursor_image)
5265 {
5266     WINED3DLOCKED_RECT lockedRect;
5267
5268     TRACE("device %p, x_hotspot %u, y_hotspot %u, cursor_image %p.\n",
5269             device, x_hotspot, y_hotspot, cursor_image);
5270
5271     /* some basic validation checks */
5272     if (device->cursorTexture)
5273     {
5274         struct wined3d_context *context = context_acquire(device, NULL);
5275         ENTER_GL();
5276         glDeleteTextures(1, &device->cursorTexture);
5277         LEAVE_GL();
5278         context_release(context);
5279         device->cursorTexture = 0;
5280     }
5281
5282     if (cursor_image)
5283     {
5284         WINED3DLOCKED_RECT rect;
5285
5286         /* MSDN: Cursor must be A8R8G8B8 */
5287         if (cursor_image->resource.format->id != WINED3DFMT_B8G8R8A8_UNORM)
5288         {
5289             WARN("surface %p has an invalid format.\n", cursor_image);
5290             return WINED3DERR_INVALIDCALL;
5291         }
5292
5293         /* MSDN: Cursor must be smaller than the display mode */
5294         if (cursor_image->resource.width > device->ddraw_width
5295                 || cursor_image->resource.height > device->ddraw_height)
5296         {
5297             WARN("Surface %p dimensions are %ux%u, but screen dimensions are %ux%u.\n",
5298                     cursor_image, cursor_image->resource.width, cursor_image->resource.height,
5299                     device->ddraw_width, device->ddraw_height);
5300             return WINED3DERR_INVALIDCALL;
5301         }
5302
5303         /* TODO: MSDN: Cursor sizes must be a power of 2 */
5304
5305         /* Do not store the surface's pointer because the application may
5306          * release it after setting the cursor image. Windows doesn't
5307          * addref the set surface, so we can't do this either without
5308          * creating circular refcount dependencies. Copy out the gl texture
5309          * instead. */
5310         device->cursorWidth = cursor_image->resource.width;
5311         device->cursorHeight = cursor_image->resource.height;
5312         if (SUCCEEDED(wined3d_surface_map(cursor_image, &rect, NULL, WINED3DLOCK_READONLY)))
5313         {
5314             const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
5315             const struct wined3d_format *format = wined3d_get_format(gl_info, WINED3DFMT_B8G8R8A8_UNORM);
5316             struct wined3d_context *context;
5317             char *mem, *bits = rect.pBits;
5318             GLint intfmt = format->glInternal;
5319             GLint gl_format = format->glFormat;
5320             GLint type = format->glType;
5321             INT height = device->cursorHeight;
5322             INT width = device->cursorWidth;
5323             INT bpp = format->byte_count;
5324             INT i;
5325
5326             /* Reformat the texture memory (pitch and width can be
5327              * different) */
5328             mem = HeapAlloc(GetProcessHeap(), 0, width * height * bpp);
5329             for(i = 0; i < height; i++)
5330                 memcpy(&mem[width * bpp * i], &bits[rect.Pitch * i], width * bpp);
5331             wined3d_surface_unmap(cursor_image);
5332
5333             context = context_acquire(device, NULL);
5334
5335             ENTER_GL();
5336
5337             if (gl_info->supported[APPLE_CLIENT_STORAGE])
5338             {
5339                 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
5340                 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
5341             }
5342
5343             invalidate_active_texture(device, context);
5344             /* Create a new cursor texture */
5345             glGenTextures(1, &device->cursorTexture);
5346             checkGLcall("glGenTextures");
5347             context_bind_texture(context, GL_TEXTURE_2D, device->cursorTexture);
5348             /* Copy the bitmap memory into the cursor texture */
5349             glTexImage2D(GL_TEXTURE_2D, 0, intfmt, width, height, 0, gl_format, type, mem);
5350             checkGLcall("glTexImage2D");
5351             HeapFree(GetProcessHeap(), 0, mem);
5352
5353             if (gl_info->supported[APPLE_CLIENT_STORAGE])
5354             {
5355                 glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
5356                 checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
5357             }
5358
5359             LEAVE_GL();
5360
5361             context_release(context);
5362         }
5363         else
5364         {
5365             FIXME("A cursor texture was not returned.\n");
5366             device->cursorTexture = 0;
5367         }
5368
5369         if (cursor_image->resource.width == 32 && cursor_image->resource.height == 32)
5370         {
5371             /* Draw a hardware cursor */
5372             ICONINFO cursorInfo;
5373             HCURSOR cursor;
5374             /* Create and clear maskBits because it is not needed for
5375              * 32-bit cursors.  32x32 bits split into 32-bit chunks == 32
5376              * chunks. */
5377             DWORD *maskBits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
5378                     (cursor_image->resource.width * cursor_image->resource.height / 8));
5379             wined3d_surface_map(cursor_image, &lockedRect, NULL,
5380                     WINED3DLOCK_NO_DIRTY_UPDATE | WINED3DLOCK_READONLY);
5381             TRACE("width: %u height: %u.\n", cursor_image->resource.width, cursor_image->resource.height);
5382
5383             cursorInfo.fIcon = FALSE;
5384             cursorInfo.xHotspot = x_hotspot;
5385             cursorInfo.yHotspot = y_hotspot;
5386             cursorInfo.hbmMask = CreateBitmap(cursor_image->resource.width, cursor_image->resource.height,
5387                     1, 1, maskBits);
5388             cursorInfo.hbmColor = CreateBitmap(cursor_image->resource.width, cursor_image->resource.height,
5389                     1, 32, lockedRect.pBits);
5390             wined3d_surface_unmap(cursor_image);
5391             /* Create our cursor and clean up. */
5392             cursor = CreateIconIndirect(&cursorInfo);
5393             if (cursorInfo.hbmMask) DeleteObject(cursorInfo.hbmMask);
5394             if (cursorInfo.hbmColor) DeleteObject(cursorInfo.hbmColor);
5395             if (device->hardwareCursor) DestroyCursor(device->hardwareCursor);
5396             device->hardwareCursor = cursor;
5397             if (device->bCursorVisible) SetCursor( cursor );
5398             HeapFree(GetProcessHeap(), 0, maskBits);
5399         }
5400     }
5401
5402     device->xHotSpot = x_hotspot;
5403     device->yHotSpot = y_hotspot;
5404     return WINED3D_OK;
5405 }
5406
5407 void CDECL wined3d_device_set_cursor_position(struct wined3d_device *device,
5408         int x_screen_space, int y_screen_space, DWORD flags)
5409 {
5410     TRACE("device %p, x %d, y %d, flags %#x.\n",
5411             device, x_screen_space, y_screen_space, flags);
5412
5413     device->xScreenSpace = x_screen_space;
5414     device->yScreenSpace = y_screen_space;
5415
5416     /* switch to the software cursor if position diverges from the hardware one */
5417     if (device->hardwareCursor)
5418     {
5419         POINT pt;
5420         GetCursorPos( &pt );
5421         if (x_screen_space != pt.x || y_screen_space != pt.y)
5422         {
5423             if (device->bCursorVisible) SetCursor( NULL );
5424             DestroyCursor( device->hardwareCursor );
5425             device->hardwareCursor = 0;
5426         }
5427     }
5428 }
5429
5430 BOOL CDECL wined3d_device_show_cursor(struct wined3d_device *device, BOOL show)
5431 {
5432     BOOL oldVisible = device->bCursorVisible;
5433
5434     TRACE("device %p, show %#x.\n", device, show);
5435
5436     /*
5437      * When ShowCursor is first called it should make the cursor appear at the OS's last
5438      * known cursor position.
5439      */
5440     if (show && !oldVisible)
5441     {
5442         POINT pt;
5443         GetCursorPos(&pt);
5444         device->xScreenSpace = pt.x;
5445         device->yScreenSpace = pt.y;
5446     }
5447
5448     if (device->hardwareCursor)
5449     {
5450         device->bCursorVisible = show;
5451         if (show)
5452             SetCursor(device->hardwareCursor);
5453         else
5454             SetCursor(NULL);
5455     }
5456     else
5457     {
5458         if (device->cursorTexture)
5459             device->bCursorVisible = show;
5460     }
5461
5462     return oldVisible;
5463 }
5464
5465 void CDECL wined3d_device_evict_managed_resources(struct wined3d_device *device)
5466 {
5467     struct wined3d_resource *resource, *cursor;
5468
5469     TRACE("device %p.\n", device);
5470
5471     LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
5472     {
5473         TRACE("Checking resource %p for eviction.\n", resource);
5474
5475         if (resource->pool == WINED3DPOOL_MANAGED)
5476         {
5477             TRACE("Evicting %p.\n", resource);
5478             resource->resource_ops->resource_unload(resource);
5479         }
5480     }
5481
5482     /* Invalidate stream sources, the buffer(s) may have been evicted. */
5483     device_invalidate_state(device, STATE_STREAMSRC);
5484 }
5485
5486 static HRESULT updateSurfaceDesc(struct wined3d_surface *surface,
5487         const WINED3DPRESENT_PARAMETERS *pPresentationParameters)
5488 {
5489     struct wined3d_device *device = surface->resource.device;
5490     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
5491
5492     /* Reallocate proper memory for the front and back buffer and adjust their sizes */
5493     if (surface->flags & SFLAG_DIBSECTION)
5494     {
5495         /* Release the DC */
5496         SelectObject(surface->hDC, surface->dib.holdbitmap);
5497         DeleteDC(surface->hDC);
5498         /* Release the DIB section */
5499         DeleteObject(surface->dib.DIBsection);
5500         surface->dib.bitmap_data = NULL;
5501         surface->resource.allocatedMemory = NULL;
5502         surface->flags &= ~SFLAG_DIBSECTION;
5503     }
5504     surface->resource.width = pPresentationParameters->BackBufferWidth;
5505     surface->resource.height = pPresentationParameters->BackBufferHeight;
5506     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] || gl_info->supported[ARB_TEXTURE_RECTANGLE]
5507             || gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT])
5508     {
5509         surface->pow2Width = pPresentationParameters->BackBufferWidth;
5510         surface->pow2Height = pPresentationParameters->BackBufferHeight;
5511     } else {
5512         surface->pow2Width = surface->pow2Height = 1;
5513         while (surface->pow2Width < pPresentationParameters->BackBufferWidth) surface->pow2Width <<= 1;
5514         while (surface->pow2Height < pPresentationParameters->BackBufferHeight) surface->pow2Height <<= 1;
5515     }
5516
5517     surface->resource.multisample_type = pPresentationParameters->MultiSampleType;
5518     surface->resource.multisample_quality = pPresentationParameters->MultiSampleQuality;
5519
5520     surface->resource.resource_ops->resource_unload(&surface->resource);
5521
5522     if (surface->pow2Width != pPresentationParameters->BackBufferWidth
5523             || surface->pow2Height != pPresentationParameters->BackBufferHeight)
5524     {
5525         surface->flags |= SFLAG_NONPOW2;
5526     }
5527     else
5528     {
5529         surface->flags &= ~SFLAG_NONPOW2;
5530     }
5531     HeapFree(GetProcessHeap(), 0, surface->resource.heapMemory);
5532     surface->resource.allocatedMemory = NULL;
5533     surface->resource.heapMemory = NULL;
5534     surface->resource.size = wined3d_surface_get_pitch(surface) * surface->pow2Width;
5535
5536     /* Put all surfaces into sysmem - the drawable might disappear if the backbuffer was rendered
5537      * to a FBO */
5538     if (!surface_init_sysmem(surface))
5539     {
5540         return E_OUTOFMEMORY;
5541     }
5542     return WINED3D_OK;
5543 }
5544
5545 static BOOL is_display_mode_supported(struct wined3d_device *device, const WINED3DPRESENT_PARAMETERS *pp)
5546 {
5547     UINT i, count;
5548     WINED3DDISPLAYMODE m;
5549     HRESULT hr;
5550
5551     /* All Windowed modes are supported, as is leaving the current mode */
5552     if(pp->Windowed) return TRUE;
5553     if(!pp->BackBufferWidth) return TRUE;
5554     if(!pp->BackBufferHeight) return TRUE;
5555
5556     count = wined3d_get_adapter_mode_count(device->wined3d, device->adapter->ordinal, WINED3DFMT_UNKNOWN);
5557     for (i = 0; i < count; ++i)
5558     {
5559         memset(&m, 0, sizeof(m));
5560         hr = wined3d_enum_adapter_modes(device->wined3d, device->adapter->ordinal, WINED3DFMT_UNKNOWN, i, &m);
5561         if (FAILED(hr))
5562             ERR("Failed to enumerate adapter mode.\n");
5563         if (m.Width == pp->BackBufferWidth && m.Height == pp->BackBufferHeight)
5564             /* Mode found, it is supported. */
5565             return TRUE;
5566     }
5567     /* Mode not found -> not supported */
5568     return FALSE;
5569 }
5570
5571 /* Do not call while under the GL lock. */
5572 static void delete_opengl_contexts(struct wined3d_device *device, struct wined3d_swapchain *swapchain)
5573 {
5574     struct wined3d_resource *resource, *cursor;
5575     const struct wined3d_gl_info *gl_info;
5576     struct wined3d_context *context;
5577     struct wined3d_shader *shader;
5578
5579     context = context_acquire(device, NULL);
5580     gl_info = context->gl_info;
5581
5582     LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
5583     {
5584         TRACE("Unloading resource %p.\n", resource);
5585
5586         resource->resource_ops->resource_unload(resource);
5587     }
5588
5589     LIST_FOR_EACH_ENTRY(shader, &device->shaders, struct wined3d_shader, shader_list_entry)
5590     {
5591         device->shader_backend->shader_destroy(shader);
5592     }
5593
5594     ENTER_GL();
5595     if (device->depth_blt_texture)
5596     {
5597         glDeleteTextures(1, &device->depth_blt_texture);
5598         device->depth_blt_texture = 0;
5599     }
5600     if (device->cursorTexture)
5601     {
5602         glDeleteTextures(1, &device->cursorTexture);
5603         device->cursorTexture = 0;
5604     }
5605     LEAVE_GL();
5606
5607     device->blitter->free_private(device);
5608     device->frag_pipe->free_private(device);
5609     device->shader_backend->shader_free_private(device);
5610     destroy_dummy_textures(device, gl_info);
5611
5612     context_release(context);
5613
5614     while (device->context_count)
5615     {
5616         swapchain_destroy_contexts(device->contexts[0]->swapchain);
5617     }
5618
5619     HeapFree(GetProcessHeap(), 0, swapchain->context);
5620     swapchain->context = NULL;
5621 }
5622
5623 /* Do not call while under the GL lock. */
5624 static HRESULT create_primary_opengl_context(struct wined3d_device *device, struct wined3d_swapchain *swapchain)
5625 {
5626     struct wined3d_context *context;
5627     struct wined3d_surface *target;
5628     HRESULT hr;
5629
5630     /* Recreate the primary swapchain's context */
5631     swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context));
5632     if (!swapchain->context)
5633     {
5634         ERR("Failed to allocate memory for swapchain context array.\n");
5635         return E_OUTOFMEMORY;
5636     }
5637
5638     target = swapchain->back_buffers ? swapchain->back_buffers[0] : swapchain->front_buffer;
5639     if (!(context = context_create(swapchain, target, swapchain->ds_format)))
5640     {
5641         WARN("Failed to create context.\n");
5642         HeapFree(GetProcessHeap(), 0, swapchain->context);
5643         return E_FAIL;
5644     }
5645
5646     swapchain->context[0] = context;
5647     swapchain->num_contexts = 1;
5648     create_dummy_textures(device, context);
5649     context_release(context);
5650
5651     hr = device->shader_backend->shader_alloc_private(device);
5652     if (FAILED(hr))
5653     {
5654         ERR("Failed to allocate shader private data, hr %#x.\n", hr);
5655         goto err;
5656     }
5657
5658     hr = device->frag_pipe->alloc_private(device);
5659     if (FAILED(hr))
5660     {
5661         ERR("Failed to allocate fragment pipe private data, hr %#x.\n", hr);
5662         device->shader_backend->shader_free_private(device);
5663         goto err;
5664     }
5665
5666     hr = device->blitter->alloc_private(device);
5667     if (FAILED(hr))
5668     {
5669         ERR("Failed to allocate blitter private data, hr %#x.\n", hr);
5670         device->frag_pipe->free_private(device);
5671         device->shader_backend->shader_free_private(device);
5672         goto err;
5673     }
5674
5675     return WINED3D_OK;
5676
5677 err:
5678     context_acquire(device, NULL);
5679     destroy_dummy_textures(device, context->gl_info);
5680     context_release(context);
5681     context_destroy(device, context);
5682     HeapFree(GetProcessHeap(), 0, swapchain->context);
5683     swapchain->num_contexts = 0;
5684     return hr;
5685 }
5686
5687 /* Do not call while under the GL lock. */
5688 HRESULT CDECL wined3d_device_reset(struct wined3d_device *device,
5689         WINED3DPRESENT_PARAMETERS *present_parameters,
5690         wined3d_device_reset_cb callback)
5691 {
5692     struct wined3d_resource *resource, *cursor;
5693     struct wined3d_swapchain *swapchain;
5694     BOOL DisplayModeChanged = FALSE;
5695     BOOL update_desc = FALSE;
5696     WINED3DDISPLAYMODE mode;
5697     unsigned int i;
5698     HRESULT hr;
5699
5700     TRACE("device %p, present_parameters %p.\n", device, present_parameters);
5701
5702     wined3d_device_set_index_buffer(device, NULL, WINED3DFMT_UNKNOWN);
5703     for (i = 0; i < MAX_STREAMS; ++i)
5704     {
5705         wined3d_device_set_stream_source(device, i, NULL, 0, 0);
5706     }
5707     for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
5708     {
5709         wined3d_device_set_texture(device, i, NULL);
5710     }
5711     if (device->onscreen_depth_stencil)
5712     {
5713         wined3d_surface_decref(device->onscreen_depth_stencil);
5714         device->onscreen_depth_stencil = NULL;
5715     }
5716
5717     LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &device->resources, struct wined3d_resource, resource_list_entry)
5718     {
5719         TRACE("Enumerating resource %p.\n", resource);
5720         if (FAILED(hr = callback(resource)))
5721             return hr;
5722     }
5723
5724     hr = wined3d_device_get_swapchain(device, 0, &swapchain);
5725     if (FAILED(hr))
5726     {
5727         ERR("Failed to get the first implicit swapchain\n");
5728         return hr;
5729     }
5730
5731     if (!is_display_mode_supported(device, present_parameters))
5732     {
5733         WARN("Rejecting Reset() call because the requested display mode is not supported\n");
5734         WARN("Requested mode: %d, %d.\n",
5735             present_parameters->BackBufferWidth,
5736              present_parameters->BackBufferHeight);
5737         wined3d_swapchain_decref(swapchain);
5738         return WINED3DERR_INVALIDCALL;
5739     }
5740
5741     /* Is it necessary to recreate the gl context? Actually every setting can be changed
5742      * on an existing gl context, so there's no real need for recreation.
5743      *
5744      * TODO: Figure out how Reset influences resources in D3DPOOL_DEFAULT, D3DPOOL_SYSTEMMEMORY and D3DPOOL_MANAGED
5745      *
5746      * TODO: Figure out what happens to explicit swapchains, or if we have more than one implicit swapchain
5747      */
5748     TRACE("New params:\n");
5749     TRACE("BackBufferWidth = %d\n", present_parameters->BackBufferWidth);
5750     TRACE("BackBufferHeight = %d\n", present_parameters->BackBufferHeight);
5751     TRACE("BackBufferFormat = %s\n", debug_d3dformat(present_parameters->BackBufferFormat));
5752     TRACE("BackBufferCount = %d\n", present_parameters->BackBufferCount);
5753     TRACE("MultiSampleType = %d\n", present_parameters->MultiSampleType);
5754     TRACE("MultiSampleQuality = %d\n", present_parameters->MultiSampleQuality);
5755     TRACE("SwapEffect = %d\n", present_parameters->SwapEffect);
5756     TRACE("hDeviceWindow = %p\n", present_parameters->hDeviceWindow);
5757     TRACE("Windowed = %s\n", present_parameters->Windowed ? "true" : "false");
5758     TRACE("EnableAutoDepthStencil = %s\n", present_parameters->EnableAutoDepthStencil ? "true" : "false");
5759     TRACE("Flags = %08x\n", present_parameters->Flags);
5760     TRACE("FullScreen_RefreshRateInHz = %d\n", present_parameters->FullScreen_RefreshRateInHz);
5761     TRACE("PresentationInterval = %d\n", present_parameters->PresentationInterval);
5762
5763     /* No special treatment of these parameters. Just store them */
5764     swapchain->presentParms.SwapEffect = present_parameters->SwapEffect;
5765     swapchain->presentParms.Flags = present_parameters->Flags;
5766     swapchain->presentParms.PresentationInterval = present_parameters->PresentationInterval;
5767     swapchain->presentParms.FullScreen_RefreshRateInHz = present_parameters->FullScreen_RefreshRateInHz;
5768
5769     /* What to do about these? */
5770     if (present_parameters->BackBufferCount
5771             && present_parameters->BackBufferCount != swapchain->presentParms.BackBufferCount)
5772         FIXME("Cannot change the back buffer count yet.\n");
5773
5774     if (present_parameters->BackBufferFormat != WINED3DFMT_UNKNOWN
5775             && present_parameters->BackBufferFormat != swapchain->presentParms.BackBufferFormat)
5776         FIXME("Cannot change the back buffer format yet.\n");
5777
5778     if (present_parameters->hDeviceWindow
5779             && present_parameters->hDeviceWindow != swapchain->presentParms.hDeviceWindow)
5780         FIXME("Cannot change the device window yet.\n");
5781
5782     if (present_parameters->EnableAutoDepthStencil && !device->auto_depth_stencil)
5783     {
5784         HRESULT hrc;
5785
5786         TRACE("Creating the depth stencil buffer\n");
5787
5788         hrc = device->device_parent->ops->create_depth_stencil(device->device_parent,
5789                 present_parameters->BackBufferWidth,
5790                 present_parameters->BackBufferHeight,
5791                 present_parameters->AutoDepthStencilFormat,
5792                 present_parameters->MultiSampleType,
5793                 present_parameters->MultiSampleQuality,
5794                 FALSE,
5795                 &device->auto_depth_stencil);
5796         if (FAILED(hrc))
5797         {
5798             ERR("Failed to create the depth stencil buffer.\n");
5799             wined3d_swapchain_decref(swapchain);
5800             return WINED3DERR_INVALIDCALL;
5801         }
5802     }
5803
5804     if (device->onscreen_depth_stencil)
5805     {
5806         wined3d_surface_decref(device->onscreen_depth_stencil);
5807         device->onscreen_depth_stencil = NULL;
5808     }
5809
5810     /* Reset the depth stencil */
5811     if (present_parameters->EnableAutoDepthStencil)
5812         wined3d_device_set_depth_stencil(device, device->auto_depth_stencil);
5813     else
5814         wined3d_device_set_depth_stencil(device, NULL);
5815
5816     TRACE("Resetting stateblock\n");
5817     wined3d_stateblock_decref(device->updateStateBlock);
5818     wined3d_stateblock_decref(device->stateBlock);
5819
5820     if (present_parameters->Windowed)
5821     {
5822         mode.Width = swapchain->orig_width;
5823         mode.Height = swapchain->orig_height;
5824         mode.RefreshRate = 0;
5825         mode.Format = swapchain->presentParms.BackBufferFormat;
5826     }
5827     else
5828     {
5829         mode.Width = present_parameters->BackBufferWidth;
5830         mode.Height = present_parameters->BackBufferHeight;
5831         mode.RefreshRate = present_parameters->FullScreen_RefreshRateInHz;
5832         mode.Format = swapchain->presentParms.BackBufferFormat;
5833     }
5834
5835     /* Should Width == 800 && Height == 0 set 800x600? */
5836     if (present_parameters->BackBufferWidth && present_parameters->BackBufferHeight
5837             && (present_parameters->BackBufferWidth != swapchain->presentParms.BackBufferWidth
5838             || present_parameters->BackBufferHeight != swapchain->presentParms.BackBufferHeight))
5839     {
5840         if (!present_parameters->Windowed)
5841             DisplayModeChanged = TRUE;
5842
5843         swapchain->presentParms.BackBufferWidth = present_parameters->BackBufferWidth;
5844         swapchain->presentParms.BackBufferHeight = present_parameters->BackBufferHeight;
5845         update_desc = TRUE;
5846     }
5847
5848     if (present_parameters->MultiSampleType != swapchain->presentParms.MultiSampleType
5849             || present_parameters->MultiSampleQuality != swapchain->presentParms.MultiSampleQuality)
5850     {
5851         swapchain->presentParms.MultiSampleType = present_parameters->MultiSampleType;
5852         swapchain->presentParms.MultiSampleQuality = present_parameters->MultiSampleQuality;
5853         update_desc = TRUE;
5854     }
5855
5856     if (update_desc)
5857     {
5858         UINT i;
5859
5860         hr = updateSurfaceDesc(swapchain->front_buffer, &swapchain->presentParms);
5861         if (FAILED(hr))
5862         {
5863             wined3d_swapchain_decref(swapchain);
5864             return hr;
5865         }
5866
5867         for (i = 0; i < swapchain->presentParms.BackBufferCount; ++i)
5868         {
5869             hr = updateSurfaceDesc(swapchain->back_buffers[i], &swapchain->presentParms);
5870             if (FAILED(hr))
5871             {
5872                 wined3d_swapchain_decref(swapchain);
5873                 return hr;
5874             }
5875         }
5876         if (device->auto_depth_stencil)
5877         {
5878             hr = updateSurfaceDesc(device->auto_depth_stencil, &swapchain->presentParms);
5879             if (FAILED(hr))
5880             {
5881                 wined3d_swapchain_decref(swapchain);
5882                 return hr;
5883             }
5884         }
5885     }
5886
5887     delete_opengl_contexts(device, swapchain);
5888
5889     if (!present_parameters->Windowed != !swapchain->presentParms.Windowed
5890             || DisplayModeChanged)
5891     {
5892         wined3d_device_set_display_mode(device, 0, &mode);
5893
5894         if (!present_parameters->Windowed)
5895         {
5896             if (swapchain->presentParms.Windowed)
5897             {
5898                 HWND focus_window = device->createParms.hFocusWindow;
5899                 if (!focus_window)
5900                     focus_window = present_parameters->hDeviceWindow;
5901                 if (FAILED(hr = wined3d_device_acquire_focus_window(device, focus_window)))
5902                 {
5903                     ERR("Failed to acquire focus window, hr %#x.\n", hr);
5904                     wined3d_swapchain_decref(swapchain);
5905                     return hr;
5906                 }
5907
5908                 /* switch from windowed to fs */
5909                 wined3d_device_setup_fullscreen_window(device, swapchain->device_window,
5910                         present_parameters->BackBufferWidth,
5911                         present_parameters->BackBufferHeight);
5912             }
5913             else
5914             {
5915                 /* Fullscreen -> fullscreen mode change */
5916                 MoveWindow(swapchain->device_window, 0, 0,
5917                            present_parameters->BackBufferWidth, present_parameters->BackBufferHeight,
5918                            TRUE);
5919             }
5920         }
5921         else if (!swapchain->presentParms.Windowed)
5922         {
5923             /* Fullscreen -> windowed switch */
5924             wined3d_device_restore_fullscreen_window(device, swapchain->device_window);
5925             wined3d_device_release_focus_window(device);
5926         }
5927         swapchain->presentParms.Windowed = present_parameters->Windowed;
5928     }
5929     else if (!present_parameters->Windowed)
5930     {
5931         DWORD style = device->style;
5932         DWORD exStyle = device->exStyle;
5933         /* If we're in fullscreen, and the mode wasn't changed, we have to get the window back into
5934          * the right position. Some applications(Battlefield 2, Guild Wars) move it and then call
5935          * Reset to clear up their mess. Guild Wars also loses the device during that.
5936          */
5937         device->style = 0;
5938         device->exStyle = 0;
5939         wined3d_device_setup_fullscreen_window(device, swapchain->device_window,
5940                 present_parameters->BackBufferWidth,
5941                 present_parameters->BackBufferHeight);
5942         device->style = style;
5943         device->exStyle = exStyle;
5944     }
5945
5946     /* Note: No parent needed for initial internal stateblock */
5947     hr = wined3d_stateblock_create(device, WINED3DSBT_INIT, &device->stateBlock);
5948     if (FAILED(hr))
5949         ERR("Resetting the stateblock failed with error %#x.\n", hr);
5950     else
5951         TRACE("Created stateblock %p.\n", device->stateBlock);
5952     device->updateStateBlock = device->stateBlock;
5953     wined3d_stateblock_incref(device->updateStateBlock);
5954
5955     stateblock_init_default_state(device->stateBlock);
5956
5957     swapchain_update_render_to_fbo(swapchain);
5958     swapchain_update_draw_bindings(swapchain);
5959
5960     hr = create_primary_opengl_context(device, swapchain);
5961     wined3d_swapchain_decref(swapchain);
5962
5963     /* All done. There is no need to reload resources or shaders, this will happen automatically on the
5964      * first use
5965      */
5966     return hr;
5967 }
5968
5969 HRESULT CDECL wined3d_device_set_dialog_box_mode(struct wined3d_device *device, BOOL enable_dialogs)
5970 {
5971     TRACE("device %p, enable_dialogs %#x.\n", device, enable_dialogs);
5972
5973     if (!enable_dialogs) FIXME("Dialogs cannot be disabled yet.\n");
5974
5975     return WINED3D_OK;
5976 }
5977
5978
5979 HRESULT CDECL wined3d_device_get_creation_parameters(struct wined3d_device *device,
5980         WINED3DDEVICE_CREATION_PARAMETERS *parameters)
5981 {
5982     TRACE("device %p, parameters %p.\n", device, parameters);
5983
5984     *parameters = device->createParms;
5985     return WINED3D_OK;
5986 }
5987
5988 void CDECL wined3d_device_set_gamma_ramp(struct wined3d_device *device,
5989         UINT swapchain_idx, DWORD flags, const WINED3DGAMMARAMP *ramp)
5990 {
5991     struct wined3d_swapchain *swapchain;
5992
5993     TRACE("device %p, swapchain_idx %u, flags %#x, ramp %p.\n",
5994             device, swapchain_idx, flags, ramp);
5995
5996     if (SUCCEEDED(wined3d_device_get_swapchain(device, swapchain_idx, &swapchain)))
5997     {
5998         wined3d_swapchain_set_gamma_ramp(swapchain, flags, ramp);
5999         wined3d_swapchain_decref(swapchain);
6000     }
6001 }
6002
6003 void CDECL wined3d_device_get_gamma_ramp(struct wined3d_device *device, UINT swapchain_idx, WINED3DGAMMARAMP *ramp)
6004 {
6005     struct wined3d_swapchain *swapchain;
6006
6007     TRACE("device %p, swapchain_idx %u, ramp %p.\n",
6008             device, swapchain_idx, ramp);
6009
6010     if (SUCCEEDED(wined3d_device_get_swapchain(device, swapchain_idx, &swapchain)))
6011     {
6012         wined3d_swapchain_get_gamma_ramp(swapchain, ramp);
6013         wined3d_swapchain_decref(swapchain);
6014     }
6015 }
6016
6017 void device_resource_add(struct wined3d_device *device, struct wined3d_resource *resource)
6018 {
6019     TRACE("device %p, resource %p.\n", device, resource);
6020
6021     list_add_head(&device->resources, &resource->resource_list_entry);
6022 }
6023
6024 static void device_resource_remove(struct wined3d_device *device, struct wined3d_resource *resource)
6025 {
6026     TRACE("device %p, resource %p.\n", device, resource);
6027
6028     list_remove(&resource->resource_list_entry);
6029 }
6030
6031 void device_resource_released(struct wined3d_device *device, struct wined3d_resource *resource)
6032 {
6033     WINED3DRESOURCETYPE type = resource->resourceType;
6034     unsigned int i;
6035
6036     TRACE("device %p, resource %p, type %s.\n", device, resource, debug_d3dresourcetype(type));
6037
6038     context_resource_released(device, resource, type);
6039
6040     switch (type)
6041     {
6042         case WINED3DRTYPE_SURFACE:
6043             {
6044                 struct wined3d_surface *surface = surface_from_resource(resource);
6045
6046                 if (!device->d3d_initialized) break;
6047
6048                 for (i = 0; i < device->adapter->gl_info.limits.buffers; ++i)
6049                 {
6050                     if (device->fb.render_targets[i] == surface)
6051                     {
6052                         ERR("Surface %p is still in use as render target %u.\n", surface, i);
6053                         device->fb.render_targets[i] = NULL;
6054                     }
6055                 }
6056
6057                 if (device->fb.depth_stencil == surface)
6058                 {
6059                     ERR("Surface %p is still in use as depth/stencil buffer.\n", surface);
6060                     device->fb.depth_stencil = NULL;
6061                 }
6062             }
6063             break;
6064
6065         case WINED3DRTYPE_TEXTURE:
6066         case WINED3DRTYPE_CUBETEXTURE:
6067         case WINED3DRTYPE_VOLUMETEXTURE:
6068             for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i)
6069             {
6070                 struct wined3d_texture *texture = wined3d_texture_from_resource(resource);
6071
6072                 if (device->stateBlock && device->stateBlock->state.textures[i] == texture)
6073                 {
6074                     ERR("Texture %p is still in use by stateblock %p, stage %u.\n",
6075                             texture, device->stateBlock, i);
6076                     device->stateBlock->state.textures[i] = NULL;
6077                 }
6078
6079                 if (device->updateStateBlock != device->stateBlock
6080                         && device->updateStateBlock->state.textures[i] == texture)
6081                 {
6082                     ERR("Texture %p is still in use by stateblock %p, stage %u.\n",
6083                             texture, device->updateStateBlock, i);
6084                     device->updateStateBlock->state.textures[i] = NULL;
6085                 }
6086             }
6087             break;
6088
6089         case WINED3DRTYPE_BUFFER:
6090             {
6091                 struct wined3d_buffer *buffer = buffer_from_resource(resource);
6092
6093                 for (i = 0; i < MAX_STREAMS; ++i)
6094                 {
6095                     if (device->stateBlock && device->stateBlock->state.streams[i].buffer == buffer)
6096                     {
6097                         ERR("Buffer %p is still in use by stateblock %p, stream %u.\n",
6098                                 buffer, device->stateBlock, i);
6099                         device->stateBlock->state.streams[i].buffer = NULL;
6100                     }
6101
6102                     if (device->updateStateBlock != device->stateBlock
6103                             && device->updateStateBlock->state.streams[i].buffer == buffer)
6104                     {
6105                         ERR("Buffer %p is still in use by stateblock %p, stream %u.\n",
6106                                 buffer, device->updateStateBlock, i);
6107                         device->updateStateBlock->state.streams[i].buffer = NULL;
6108                     }
6109
6110                 }
6111
6112                 if (device->stateBlock && device->stateBlock->state.index_buffer == buffer)
6113                 {
6114                     ERR("Buffer %p is still in use by stateblock %p as index buffer.\n",
6115                             buffer, device->stateBlock);
6116                     device->stateBlock->state.index_buffer =  NULL;
6117                 }
6118
6119                 if (device->updateStateBlock != device->stateBlock
6120                         && device->updateStateBlock->state.index_buffer == buffer)
6121                 {
6122                     ERR("Buffer %p is still in use by stateblock %p as index buffer.\n",
6123                             buffer, device->updateStateBlock);
6124                     device->updateStateBlock->state.index_buffer =  NULL;
6125                 }
6126             }
6127             break;
6128
6129         default:
6130             break;
6131     }
6132
6133     /* Remove the resource from the resourceStore */
6134     device_resource_remove(device, resource);
6135
6136     TRACE("Resource released.\n");
6137 }
6138
6139 HRESULT CDECL wined3d_device_get_surface_from_dc(struct wined3d_device *device,
6140         HDC dc, struct wined3d_surface **surface)
6141 {
6142     struct wined3d_resource *resource;
6143
6144     TRACE("device %p, dc %p, surface %p.\n", device, dc, surface);
6145
6146     LIST_FOR_EACH_ENTRY(resource, &device->resources, struct wined3d_resource, resource_list_entry)
6147     {
6148         if (resource->resourceType == WINED3DRTYPE_SURFACE)
6149         {
6150             struct wined3d_surface *s = surface_from_resource(resource);
6151
6152             if (s->hDC == dc)
6153             {
6154                 TRACE("Found surface %p for dc %p.\n", s, dc);
6155                 *surface = s;
6156                 return WINED3D_OK;
6157             }
6158         }
6159     }
6160
6161     return WINED3DERR_INVALIDCALL;
6162 }
6163
6164 HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d,
6165         UINT adapter_idx, WINED3DDEVTYPE device_type, HWND focus_window, DWORD flags,
6166         BYTE surface_alignment, struct wined3d_device_parent *device_parent)
6167 {
6168     struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx];
6169     const struct fragment_pipeline *fragment_pipeline;
6170     struct shader_caps shader_caps;
6171     struct fragment_caps ffp_caps;
6172     WINED3DDISPLAYMODE mode;
6173     unsigned int i;
6174     HRESULT hr;
6175
6176     device->ref = 1;
6177     device->wined3d = wined3d;
6178     wined3d_incref(device->wined3d);
6179     device->adapter = wined3d->adapter_count ? adapter : NULL;
6180     device->device_parent = device_parent;
6181     list_init(&device->resources);
6182     list_init(&device->shaders);
6183     device->surface_alignment = surface_alignment;
6184
6185     /* Get the initial screen setup for ddraw. */
6186     hr = wined3d_get_adapter_display_mode(wined3d, adapter_idx, &mode);
6187     if (FAILED(hr))
6188     {
6189         ERR("Failed to get the adapter's display mode, hr %#x.\n", hr);
6190         wined3d_decref(device->wined3d);
6191         return hr;
6192     }
6193     device->ddraw_width = mode.Width;
6194     device->ddraw_height = mode.Height;
6195     device->ddraw_format = mode.Format;
6196
6197     /* Save the creation parameters. */
6198     device->createParms.AdapterOrdinal = adapter_idx;
6199     device->createParms.DeviceType = device_type;
6200     device->createParms.hFocusWindow = focus_window;
6201     device->createParms.BehaviorFlags = flags;
6202
6203     device->devType = device_type;
6204     for (i = 0; i < PATCHMAP_SIZE; ++i) list_init(&device->patches[i]);
6205
6206     select_shader_mode(&adapter->gl_info, &device->ps_selected_mode, &device->vs_selected_mode);
6207     device->shader_backend = adapter->shader_backend;
6208
6209     if (device->shader_backend)
6210     {
6211         device->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
6212         device->d3d_vshader_constantF = shader_caps.MaxVertexShaderConst;
6213         device->d3d_pshader_constantF = shader_caps.MaxPixelShaderConst;
6214         device->vs_clipping = shader_caps.VSClipping;
6215     }
6216     fragment_pipeline = adapter->fragment_pipe;
6217     device->frag_pipe = fragment_pipeline;
6218     if (fragment_pipeline)
6219     {
6220         fragment_pipeline->get_caps(&adapter->gl_info, &ffp_caps);
6221         device->max_ffp_textures = ffp_caps.MaxSimultaneousTextures;
6222
6223         hr = compile_state_table(device->StateTable, device->multistate_funcs, &adapter->gl_info,
6224                                  ffp_vertexstate_template, fragment_pipeline, misc_state_template);
6225         if (FAILED(hr))
6226         {
6227             ERR("Failed to compile state table, hr %#x.\n", hr);
6228             wined3d_decref(device->wined3d);
6229             return hr;
6230         }
6231     }
6232     device->blitter = adapter->blitter;
6233
6234     return WINED3D_OK;
6235 }
6236
6237
6238 void device_invalidate_state(const struct wined3d_device *device, DWORD state)
6239 {
6240     DWORD rep = device->StateTable[state].representative;
6241     struct wined3d_context *context;
6242     DWORD idx;
6243     BYTE shift;
6244     UINT i;
6245
6246     for (i = 0; i < device->context_count; ++i)
6247     {
6248         context = device->contexts[i];
6249         if(isStateDirty(context, rep)) continue;
6250
6251         context->dirtyArray[context->numDirtyEntries++] = rep;
6252         idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
6253         shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
6254         context->isStateDirty[idx] |= (1 << shift);
6255     }
6256 }
6257
6258 void get_drawable_size_fbo(const struct wined3d_context *context, UINT *width, UINT *height)
6259 {
6260     /* The drawable size of a fbo target is the opengl texture size, which is the power of two size. */
6261     *width = context->current_rt->pow2Width;
6262     *height = context->current_rt->pow2Height;
6263 }
6264
6265 void get_drawable_size_backbuffer(const struct wined3d_context *context, UINT *width, UINT *height)
6266 {
6267     const struct wined3d_swapchain *swapchain = context->swapchain;
6268     /* The drawable size of a backbuffer / aux buffer offscreen target is the size of the
6269      * current context's drawable, which is the size of the back buffer of the swapchain
6270      * the active context belongs to. */
6271     *width = swapchain->presentParms.BackBufferWidth;
6272     *height = swapchain->presentParms.BackBufferHeight;
6273 }
6274
6275 LRESULT device_process_message(struct wined3d_device *device, HWND window, BOOL unicode,
6276         UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc)
6277 {
6278     if (device->filter_messages)
6279     {
6280         TRACE("Filtering message: window %p, message %#x, wparam %#lx, lparam %#lx.\n",
6281                 window, message, wparam, lparam);
6282         if (unicode)
6283             return DefWindowProcW(window, message, wparam, lparam);
6284         else
6285             return DefWindowProcA(window, message, wparam, lparam);
6286     }
6287
6288     if (message == WM_DESTROY)
6289     {
6290         TRACE("unregister window %p.\n", window);
6291         wined3d_unregister_window(window);
6292
6293         if (device->focus_window == window) device->focus_window = NULL;
6294         else ERR("Window %p is not the focus window for device %p.\n", window, device);
6295     }
6296
6297     if (unicode)
6298         return CallWindowProcW(proc, window, message, wparam, lparam);
6299     else
6300         return CallWindowProcA(proc, window, message, wparam, lparam);
6301 }