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

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